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...