Posts

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…

User Interface Construction: Instruction, Clock and Sequencer

Image
Well, the good news is I've just passed a major milestone in constructing this relay computer ... it can now perform a single instruction in full firing the various control lines as needed. The bad news ... I'm rather behind in blogging about it so this will be the first of a couple of 'catch up' posts which will culminate in a video showing off the computer as it currently stands.

The last outstanding item from the MOV-8, ALU and SETAB series of construction is updating the computer's user interface so that the contents of the instruction register and the actions of the control and sequencer cards can be observed. The first job was to apply the legends to the new buttons and indicators that I'd be adding to the two display cards. Here's a close up picture: The buttons at the top are (from left to right) clock, instruction to bus (I2B), instruction load and condition load. Below that are the instruction class indicators: MOV8 and SETAB. The ALU instruction…

Controller Construction: MOV-8, ALU and SETAB

Image
So yea, it's been a while since my last post ... in fact it's been just over six months. For some reason I decided I didn't have enough to do in the evenings so had a crack at becoming an actuary. Needless to say I've been busy studying for my entry exams and so the computer took a back seat for a while. Exams are done for now though so the computer is back on and I'm back constructing to get the MOV8, ALU and SETAB instructions running.

Following on from the sequencer cards in my last post it's now the turn of the control cards. These take the sequenced pulses and operate the various control lines of the computer at the appropriate time to perform the active instruction. As with the sequencer the controller is spread over two cards so it can access the full set of busses needed and to make room for all the relays that'll eventually be squeezed in to operate the full range of instructions.

I'm going to skip the usual pictures of the cards being built up…