Posts

Incrementer Design

Image
In my last post I covered the design of the 16-bit half adder which takes whatever value is currently on the address bus and increments it by one. To make this incremented value useable we need to create a register so that we can store the value ready for pushing back on to the address bus. Typically this incremented value would then be loaded into the program counter to get it ready for the next instruction in memory.

By now you're probably sick of seeing register designs (I know I am) and this particular register is similar to all the other registers seen so far in the computer. Just like the program counter this register holds a single 16-bit value which can be gated on to the address bus. The main difference here is that the register is loaded directly from the 16-bit half adder via an inter-card connector. Here's the design for this register:
As with other register cards the relays that latch each bit value are on the bottom half of the card with bit 0 at the bottom righ…

Incrementer Design: 16-bit Half Adder

Image
In the last post I introduced the design for the 1-bit Half Adder. This post covers connecting sixteen of these units together to make the 16-bit Half Adder.

So, diving straight in, here is what sixteen of the 1-bit Half Adder units look like all together on the usual 55 x 40 hole pad board:
Each half adder bit is made up of two relays (as seen in the previous blog post) and starting at the bottom right of the diagram above the bit stages run upwards from 0 to 3 and then continuing on in rising columns to the left until bit 15 at the top left. Between each bit the carry out lines of the prior bit are connected to the carry in and the carry out lines connect to the carry in of the next bit effectively chaining each bit together to form a ripple carry adder circuit.

We can now connect up the inputs and outputs of the 16-bit half adder as follows:
Each bit of the half adder is directly connected to the address bus meaning that the adder is always active even when the output isn't ne…

Incrementer Design: 1-bit Half Adder

Image
Typical isn't it?! ... you wait 10 months for a post and then two come along at once. Well, all being well, this should be the first of a short flurry of posts as I move on to the design of the incrementer.

The incrementer takes any value currently on the 16-bit address bus and adds one to it, or rather, it increments it (clue is in the name of course). Typically that value on the address bus is going to come from the program counter (in order to point it at the next instruction in memory) but it'll also be possible to bump the upcoming XY register eventually too.

One complication in the incrementer is that because the address bus can only hold one value at a time it's necessary to have a built-in 16-bit register which can hold the result of the incrementation ready to be gated back on the address bus and off into the destination register. So, for example, the PC register is selected and the incrementer register loaded with the PC value +1. Once that's done the increm…

Register Design: Program Counter

Image
It's been a while since my last post ... pretty much 10 months in fact ... and I'd love to say I've been quietly working on my relay computer in the meantime but I haven't. Designing, building and blogging about the various parts of the computer is really time consuming and unfortunately I'm just one of those people who has way too many hobbies. Anyway, after picking up some subscribers on YouTube I thought it was high time (or maybe I felt guilty enough) to focus back on the computer and get it through to the next milestone ... where it can step through a simple program stored in its memory without any human intervention (beyond entering the program itself and setting the computer running).

So where to begin? The three units that'll need building are the program counter, incrementer and memory. To recap: the memory holds the instructions that make up the program to be executed; the program counter points to the current instruction (line of program) in the memo…

Yet another diversion

Image
It's been a bit quiet on the relay computer front again for a while ... well it is summer after all and there's no point staying inside the house tending to my hobbies when I can be running around outside getting sunburnt. Of course though, this is the UK and summer consists mostly of rain (as do most of the other seasons here) so what other excuse do I have for not posting in ages?

Well, I have been busy working on the relay computer but not in the way you might expect. A comment on one of my YouTube videos recently got me thinking ... it was a question around if I simulate the computer at each stage before building it for real. I had to admit that so far I'd been crossing my fingers and just going for it but as I get in to more complicated areas the benefits of simulating first seemed quite appealing. It just so happened that this coincided with needing to brush up on my web developing skills so this seemed a good time to kills two birds with one stone as the old saying …

Sequencing & Control Test

Image
It's finally time to give all the cards created so far a test so I can check everything works together as expected. This represents quite a bit of a milestone as the computer can now perform a single ALU, SETAB or MOV-8 instruction. This means a user can technically run a program by entering and running each instruction in turn and although the computer is still a long way from completion with this latest round of functionality it's a lot more usable than before.

Viewed from the front the computer now looks like this:
I've put together a new video to mark this construction milestone which gives an overview of what's changed since the last milestone, a tour of the computer as it currently stands and finally a demonstration of running a program through the computer.
So, with a line drawn under what's been built so far it's time to look at what comes next. There's quite a few different ways to go from here but I'd like to concentrate on getting the compute…

W Backplane Construction & Power Distribution

Image
Before I can test the new decoder, sequencer and controller cards all working together with the rest of the computer I need to construct the 'W' backplane which the new cards sit on. Generally this backplane is similar in design to the 'Z' backplane that the ALU cards and A/D and B/C register cards sit on. However, whereas each card on the Z backplane has the exact same connectors the W backplane is slightly more complex as the sequencer and control units are spread over two cards each requiring a different set of connectors. The upshot is that the backplane has three 'W1' card slots and two 'W2' card slots. A diagram explains it better:
On the Z backplane each individual connector is joined to it's siblings via a ribbon cable that runs the length of the backplane. The only oddity is that at the bottom of the backplane each pair of wires in the ribbon cable need twisting so that each line comes out in the right place. As you can see from the diagra…