The Binary Encoder

The first Working Digital Computer module described in the book was the Binary Encoder. Here's what it looked like:

It's job was to accept decimal input from the operator and convert it into binary codes the computer could use. It did this using some clever encoding wheels made from empty thread spools to enter the decimal numbers and light bulbs to display their binary equivalents. So I was going to need some encoding wheels and some panel lights.

Decimal to Binary Encoder

Here is a diagram of the implementation of the Decimal to Binary Encoder from the book.

They used an empty thread spool, wrapped it with uninsulated wire, then covered the wire with paper that had cutouts for the binary codes. Four paperclips were used as contacts to read the codes (I told you there would be paperclips). It was an ingenious design using only the promised household items.

Here is my implementation:

While my design does not use paperclips, I believe it embodies both the concept and spirit of the original. I'm not going for a "pure" replica here. At the end of the day someone should be able to operate the new machine from the instructions in the book, starting with the Decimal to Binary Encoder.

For more details I published my Mostly 3D Printed Binary Encoder design to Instructables.

A Panel Mount LED Socket

Just a small thing but I know I am going to need about 86 console lights for this project. I'm also trying for a "vintage" look. So I come up with these based on the panel lights from the GENIAC computer:

The picture below does not do justice to how nice these look when lit:

Bonus these are really inexpensive to make, a few cents each. The cheapest I could find on Digi-Key was about 50 cents. I have posted the STL files and printing instructions on Thingiverse: Panel Mount LED Socket.

My Input Panel Implementation

From the book, the diagram of the Binary Encoder Panel looked like this:

Here are some pictures of my implementation:

Wiring:

Pretty close I think. Ready to be wired into the rest of the panels.

Core Memory

Next I tackled the Core Memory module. From the book:

This really shows why the book is called the "Paperclip Computer" book. A closeup of this shot appears on the cover.

The core memory could hold five 4-bit words using 20 paperclip switches. To "select" a word, another paperclip attached to a +1.5V wire would be clipped to the 4 leads for that word lighting up the bulbs at the top of the panel.

Sorry I'm still not going to use paperclips in my build so the 20 memory switches will be replaced with simple toggle switches. The word selector was another matter and I had an idea for that.

A Selector Switch for the Core Panel

Most sizeable projects involve a number of side trips, and this one is no exception. From the Core Memory section of the book: "To read [core] memory, use the clip lead to simultaneously connect all four exposed wires for the address desired. See Fig. F-9."

In adherence to my no paperclip policy for this project I had to come up with an alternate method of selecting one of the five core memory "words". Looking closely at the CT-650 image below it looks like they used a rotary selector switch.

Cool, I could use a variant of my Mostly 3D Printed Rotary Switch, but when I started laying out the Panel it felt more like a slider switch would be a better fit. So I took a little side trip and designed one (based on my rotary switch).

The STL files and and construction details can be found in my Instructable: Mostly 3D Printed Slider Switch.

My Core Panel Implementation

Here is the diagram from the book showing the "Core Memory" panel:

With my slider switch implementation installed, here is my finished panel:

The switches are wired much like a keyboard, with a diode for each switch to prevent "ghosting". (OK...

Another Working Digital Computer Lives!
Michael Gardi • 06/15/2021 at 12:26 • 0 comments

I just wanted to welcome Marcelo to the small rather exclusive club of hobbyists that have actually built a Working Digital Computer based on the book. Check out his PaperClip Computer project page!
Say Hello To WDC-2
Michael Gardi • 05/07/2020 at 23:10 • 0 comments
Over the past couple of months I had been slowly building a new working digital computer to replace the one now on display at the System Source Computer Museum. Hopefully in the not too distant future people will actually be able to go into the museum and see it there :-(
Well a basically identical reproduction of the original (WDC-1) is now finished! Not to much to say here except that I thought the process of rebuilding would be tedious and boring, but I was surprised at how enjoyable it actually was. Without the anxiety of wondering (despite best laid plans) if everything would work as expected, and the anticipation pushing you (maybe too fast sometimes) to want to see a finished project, I had a very pleasant experience. I think it helps that there is a good variety of tasks that go into making a WDC:
- Printing and post printing (a lot of the smaller parts required brims that had to be removed).
- Assembly. Who doesn't like putting things together.
- Wiring and soldering .
- Organization. I took the time to organize the various STL print files and remove any that were no longer being used.
By working on a module at a time, I was able to cycle through these task and thus not get too tired of doing any one thing for too long.
All in all, making WDC-2 was a nice change of pace.
Postscript
Michael Gardi • 03/17/2020 at 14:53 • 2 comments

With thanks to Bob Roswell curator of the System Source Computer Museum I'm proud to announce that my WDC-1 will be on permanent display at the museum.

WDC-1 is on the middle shelf, to the right of a CT-650, which was a commercial version of the working digital computer built from the same book. The tablet on the far right is looping the video that I made of WDC-1 in action (which in hindsight I should have put a little more effort into - sigh).

In the same picture you can see six other devices that I have made reproductions of, five of which I created myself. I'm in good company there. I'm honored.
Winding Down
Michael Gardi • 01/24/2020 at 00:46 • 0 comments

I posted a video of WDC-1 in "action" today calculating a couple of digits of the Fibonacci Sequence.

It's been a lot of fun but, time to move on. I appreciate the all follows, likes, and views. Thank you!

Running a Program on WDC-1

Michael Gardi • 01/15/2020 at 22:17 • 0 comments

With everything together I wanted to do something interesting on my Working Digital Computer Version 1 so I wrote the following program to calculate the first few numbers in the Fibonacci sequence (which we know starts with 0, 1 and that each subsequent element is the sum of the previous two numbers in the sequence (so 0, 1, 1, 2, 3, 5, 8, 13...)).

        ; Calculate the first few Fibonacci numbers.
        ; Assumes that the first two numbers 0 and 1 are in the
        ;  INPUT Encoder A and Encoder B addresses.
        ;
1000 1000    RIN    A        ; Read the first seed
0110 0000    TRA             ; Transfer A to X
1000 0100    RIN    B        ; Read the second seed
0001 1100    STO    C1       ; Save the last number
0100 1101    ADD    4        ; A + X  Result in A
1110 0011    RUT    1s       ; Result < 10 show in OUTPUT
0001 0010    STO    C2       ; Remember result
1000 1100    RIN    C1       ; Get last number
0110 0000    TRA             ; Transfer A to X            
1000 0010    RIN    C2       ; Get current result back
1010 0001    SHL    1        ; Is the current result >= 8?
1001 0001    COJ    1        ; Result >= 8
1000 0010    RIN    C2       ; Get current result back
0001 1100    STO    C1       ; New last number
0101 1101    JMP    4        ; Go back to add
1101 0001    ENJ    1        ; Jump to location
1000 0010    RIN    C2       ; Get current result back
0100 0000    ADD             ; A + X  Result in A
1110 1111    RUT    BCD      ; Convert binary to BCD put result in OUTPUT
0000 0111    NOP    ANS      ; Final result

The hardest part was keeping the program length down to 20 instructions, the current limit for my "low density" drum memory. I'll have to get going on the "high density" drum if I want to do more. I've "run" the program a few times and it seems to operate as expected. I guess my current thinking is to make a video of WDC-1 in action.

Finishing Touches
Michael Gardi • 01/15/2020 at 19:38 • 0 comments

With all of the major components complete it's time to put it all together. I attached a 3-wire power cable with a 3.5 mm stereo plugs to each of the peripheral modules.

For the Input and Output panels the extra power wire would allow me to selectively power the Encoder A, Encoder B, 10^1, and 10^0 elements independently should I choose.

After that there was nothing left to do but plug it all together and power it on.

Ready to go.
Control Panel Done
Michael Gardi • 01/14/2020 at 20:47 • 0 comments
Just finished wiring and testing the Control Panel. The wiring got a bit hairy but it works well.
I used a 10 lead ribbon cable to connect the Drum Instruction Memory to the panel itself. Two leads were for power and the other 8 were for the op code and address control bits (4 for each). The drum base has lights marked Even and Odd hooked up to the two timing switches. These will alternate between instructions to give a visual indication that you have move to the next instruction correctly. You could also have both on to indicate the first line of the program and both off for the last line (say).
Lots of wire but the two 4 to 16 decoders basically just map the each op code and address to a single indicator light on the panel. There are 31 LEDs in total. I guess you could say this is WDC-1's instruction decoder.
The Control Panel is also where the power comes in and gets distributed to the other components of the machine. I'm using 3.5 mm stereo jacks and plugs so that the various pieces of the machine can be easily disconnected for close examination.
As I was setting up the power I also decided to make another small change from the book. The power "Junction Box" in the book was set up to power the components only when they were being used for part of an instruction. So for the command:
```
RIN Address A
```
for instance only the ALU and the Input Panel's Encoder A part of the machine would be enabled. This might provide a little extra clarity when executing instructions, but prevents a demonstrator from just showing what each part of the machine does in the absence of the proper commands. So I have decided to keep all of the modules powered all the time. I have not closed the door on the book's method, I can easily rewire for it, but for now I'm going with always on.
2BCD, Or Not 2BCD, That Is the Question
Michael Gardi • 01/09/2020 at 15:23 • 0 comments
When I first started looking at the book "How to Build a Working Digital Computer" I noticed with interest that the Input Panel converted decimal numbers to Binary Coded Decimal (BCD) and the Output Panel in turn converted BCD results back to decimal numbers. In between the ALU is pure binary. This was new for me as all of my other projects were pretty much binary only. Cool. The encoders and decoders for these panels were pretty straight forward as they only had to deal with single digit decimal numbers and their BCD equivalents.

What I didn't give a lot of thought to was this, "How does a binary result that is greater than 9 get converted into the two BCD inputs that the Output Panel is expecting?". Well the answer is simple, run a program. Here is the "Readout Program" from the book.

Wait there's more...

So if I'm demonstrating WDC-1 and want to show something basic like adding 8 + 7 I would run a program something like this (assumes the two addends are in Address A and B):
```
RIN Address A  ; Read first addend into A
TRA            ; Transfer A to X
RIN Address B  ; Read second addend into A
ADD            ; Add A and X. Result in A
```
With the result now in the accumulator at this point I say "Please bear with me as I perform 43 more complex and potentially error prone instructions so I can show you the answer.".

This felt like a gap to me so I started looking into binary to BCD conversion. How hard could it be? Well it turns out that while BIN2BCD conversion is not really that hard, it's not easy to do with a simple circuit. It requires computation, hence the 43 instruction "Readout Program". So I think I understand why the authors relegated their solution to the very back of the book.

I learned that there are a few ways to perform binary to BCD conversion. You can create a circuit to do this. Here is a design I found on Stack Exchange with thanks to jonk that employs the Double Dabble (love the name) algorithm:

This first schematic accepts a binary value and leaves it unchanged if the value is ≤ 4. Otherwise, it adds 3 to the binary input.

The second schematic uses the above circuit (named PLUS3 below), repeatedly:

Like I said, binary to BCD is not an easy get with logic circuits. I can't imagine how this could have been done with "household" items.

Another clever way to do a binary to BCD conversion is to use a binary up/down counter (SN74LS191 say) and a BCD counter (SN74LS192 say). The binary number is in parallel jammed into the up/down counter. Then the counter is clocked to count down to zero. The same clock is used to clock the BCD counter up from zero. When the binary counter reaches zero, the BCD counter will contain the binary number in BCD format.

A third option is to use a microprocessor. Now at this point I had already decided that I really needed (wanted) a BIN2BCD component to get me past the awkward 8 + 7 show the result issue. I was tempted by option number 2, the counters solution, which was more in line with my use of 7400 series ICs in other modules, but I literally had an Arduino Nano sitting on the desk in front of me. So microprocessor it is. Here is my BIN2BCD module:

The first thing you'll notice is that I chose different colors for this component. I wanted to make it clear that this module, with it's definitely not from the 60s microprocessor, was somehow "outside" of the Working Digital Computer book implementation. At a minimum the different color should initiate a discussion as to why.

I wrote a "brute force" but hopefully easy to understand sketch for the Arduino:
```
#include <avr/pgmspace.h>

/**
 * Debug. Uncomment the following line for debugging.
 */
// #define DEBUG 1

// Only recalculate if different.
int oldDecimal = -1;

void setup() {

  // Initialize serial debugging.
#ifdef DEBUG
  Serial.begin(115000);
  Serial.println("Setup...
```
Read more »
The Control Panel
Michael Gardi • 01/08/2020 at 17:11 • 0 comments
From the Book

The unit "that unifies all of the computer elements" built so far is the Control Panel. It consists of two major parts, a display panel

to tell the operator (you) what program instructions to perform, and a drum memory

device to hold those instructions. The drum memory was by far the most complex of all the components described in the book. It was constructed from a tin can wrapped in paper with holes (much like their decimal to binary encoder), a frame, and many, many paper clips. Here is the construction diagram:

Despite the complexity of the drum memory, the Control Panel implementation in the book is very simple. The Working Digital Computer supports 10 different instructions and the 16 addresses that those instructions can act upon. Here they are:

There is a paperclip "contact" for each individual command and address, plus two contacts for "timing", and another to act as the common ground for all the other contacts. That makes 29 in total. Each command and address contact is connected to an appropriately labeled light on the display panel. The timing contacts drive two lights beside the rotating drum that alternate being on indicating even and odd instruction lines. Like I say pretty simple.

My Implementation

My first thought was that the 29 paperclip contacts seemed pretty extreme. I have a great deal of respect for gort59 for getting this to work in his wonderfully authentic Working Digital Computer build (as seen in the video in the Details section). I understand that he used the small springs from ball point pens which may have helped. Still kudos gort59!

I had also at this point decided to take advantage of my beefed up ALU and add 6 more op codes bringing the total up to 35. Thats a lot of switches leading to a lot of potential points of failure. Given that the total number of commands and addresses were both 16 or less, and that I already had a 4 to 16 decoder designed and working for the Output Panel, I decided to implement a 10 bit encoded instruction instead. This is what I came up with:

Each instruction would have 4 bits for the op code, 4 bits for the address, and I would keep the 2 timing bits as is.

The advantage of having a single bit for each command and address is that an instruction can have more than one "address" bit for each op code. For example the STO command would have an Address C bit to enable the Core Panel (essentially power the panel - this feels more like a control bit to me than an address) and a Core n bit to indicate which word to store the value of the accumulator in. With encoded addresses this is not possible, so some small tweaks to the implementation were required. For the above example I eliminated the Address C address altogether and will enable the Core Panel if any of the Core 1 to Core 5 addresses are used. Here are the other small changes:
- Display ACC removed. Like the Address C bit this would be added to any command that required the accumulator to enable the ALU. Since this is most commands I will simply leave the accumulator "on" all the time.
- JMP changed. The JUP op code used in the book just seemed very wrong to me.
- ENJ command added. The COJ and JMP instructions used the 1-4 addresses as a way to label the target instruction for the jump. They can still be used this way for instructions that do not take an address (like ADD for instance), but for instructions with an address (like STO for instance) an ENJ instruction with the target 1-4 can be added just prior.
- ORA command added. Boolean Or the A and X registers. Store result in A.
- XOR command added. Boolean Exclusive Or the A and X registers. Store result in A.
- AND command added. Boolean And the A and X registers. Store result in A.
- INV command added. Boolean Invert A register. Store result in A.
- NOP command added. No Operation. Do Nothing....
Read more »
WDC-1 Presentation
Michael Gardi • 01/05/2020 at 15:20 • 0 comments

With some of the components finished, I started thinking about what the final project would look like. My initial thought was to build a slanted console and arrange the panels on top much like the CT-650 pictured in the Description above or a Minivac 601. But when I started thinking about Max Maxfield and Joe Farr's talk about implementing their computer as a: "...a series of glass-fronted wooden cabinets" plus the very nature of the Working Digital Computer as a teaching tool I changed my mind. Instead I designed some simple stands to hold the panels upright at a small angle:

The components will be wired together with quick connects so they can be easily detached and examined. It's my convertible with the top down look.
BTW here is a sneak peek at my Control Panel implementation with a clue to where I will be going with it.