This journey didn't start with magnetic tape, but rather, with paper tape, which is a very logical choice for relay computers because the rate of data input can be modulated by the tape speed itself. Relays don't like a lot of speed.

My big problem with paper tape is that I simply don't have the means to punch the tape - those are $$$ on eBay and sometimes this drives one to explore alternate solutions. I had recently done some work creating a serial keyboard interface for a TRS-80 Model II - and that clicked somewhere in my noodle -- and the idea of using a 2-channel tape for a relay computer was born.


In the first video, I explore the very basic concept of using one of the stereo audio channels for a clock signal, and then the other channel for a data signal. The clock channel would be used to drive a simple relay-based ring counter (or sequencer). This sequencer would then be used to combine the data signals (from the right channel) and latch the bits into a byte that could be stored in the relay computer's memory.

 I'd then use a standard audio amplifier to create the voltages (via the speaker outputs) to drive the relays. So I wrote a quick Arduino program to create a clock tone, and recorded that to the left channel of a cassette.

At this point I quickly ran into my first challenge. Although I was able to use the volume control on the amp to tune in 5 Volts, I realized that amplifiers output AC voltage, whereas the relays need DC (otherwise they get quite upset and make interesting noises of protest.)

This created my very first excuse to put together a full-bridge rectifier to convert the AC to DC - and this worked like an absolute charm! I was now able to get the clock signal driving the clock relay for the sequencer.

Part II - Getting a Data Tone and "Build-a-Byte"™

Now that we have a clock signal, the next  step was to create the data signal tones, and this presented the second challenge. It turns out that the "out of the box" tone library in the Arduino doesn't allow for polyphonic tones (ie: playing multiple tones at once). Thankfully there's a library for that, and after a bit of monkeying around with the code, it all worked out and was able to generate the clock and data tones on the 2 cassette channels.

To build the byte, it's sort of like a shift register - except that it's building the byte from MSB to LSB. Okay, so not a shift - but the register part is accurate! The latching is just like how registers work in a relay computer, so this part came together very quickly. And then I just used a sequencer step at the end to "clear" the latch bits so they are ready for the next bunch of data bits.

And once the latch bits were set up, I just needed a way to load the latch if there is a sequencer step occurring at the same time as a DATA pulse. So that means a new set of gating relays that are used to create AND logic and load the latch bits.

And after a bit of wiring, voila! The byte is being built!

And all was good in the world...or so I thought. When I started doing other byte patterns, it was clear that there were some timing issues that are unique to relays. They require some "settle down" time, which means that I needed to squeeze the DATA pulse to fall well inside the CLOCK pulse.

And after that, everything magically worked - at least in terms of getting the program bytes built properly. So now, onto the big finale - getting these new bytes loaded into the relay computer's memory and running the program.

This final part was supposed to be a cake walk, since I just needed to add some sequencer steps to create the "load memory" and "advance the program counter" signals. What do they say about "Best laid plans"? Yeah, well - the board was looking like a hot mess.

So, a makeover was in order. I channeled my inner Ben Eater (who makes this look easy), put someTangerine Dream on the old turn table,  and got into the zone. The results speak for themselves (imo)...

So now that all of the sequencer steps are there, the next part was to create those interesting pulses that are needed to direct the relay computer control lines to do the stuff they need to do, like hold open the "Select Program Counter" while we "Load the Incrementer". And like on the Relay Computer's Sequencer Card build, we can use diodes to shape these signals.

And once those pulses were created, I combined everything into one big breadboard, and dubbed it "The Monolith".

Above we can see testing in progress, and can compare the value output from the Arduino testing (10101010) with what is actually appearing on the memory card in the relay computer. The memory address is also showing as "2" which is correct since this is the 3rd position in memory.  

THE BIG FINALE!

I only have 8 card slots in my backplanes, and I could add more, but I've realized that I need to create a new backplane so no sense in wasting edge card connectors. So I restricted the testing to something that could be done with 8 cards, which was to simply load registers with values and move them around a bit. 

The above also contains a "HLT" or Halt instruction, which activates the "HLT" control line in the relay computer. So I just added a reset option to my clock that is driven by this HLT signal.

And after writing the program code to the audio cassette, it was time for the final test...and...(spoiler alert!) it was a resounding success (as can be fully viewed in the video above).

I'll admit that at the end of the test, I was in a bit of shock (as can be seen by the look on my face at the end of the video). I've been wanting to do this project for a couple of years, and frankly it became a bit of an obsession (er...healthy obsession) over the last several weeks. So, I was lacking in sleep - but very happy nonetheless!

Next steps are to reverse engineer this Frankenstein into a set of schematics, happy to share them out with anyone who's interested!