From the very earliest days of the RC2014, back when the whole thing was a bunch of wires and chips on a breadboard and before the RC2014 even had a name I knew that it needed some kind of storage. The obvious solution to me was via SD card. I had already made a simple PS2 keyboard and 4 line LCD display interface from an Atmel ATMEGA328, and it was easy enough to add an SD card interface. The ‘328 was connected to the yet to be named RC2014 via serial, so anything I could type on the keyboard could be passed through to the RC2014. Likewise, the contents of a text file on the SD card could also be put on the serial port. Intercepting keystrokes like F1 would send the text file 1.bas to the RC2014.
It kind of worked, but was clunky at best. The text files had to be created on a PC as there was no way to save anything – although I thought about monitoring the keyboard for SAVE to be typed which would be replaced by LIST and the stream coming back would be saved to SD. But that was even more clunky and hacky.
Once the RC2014 appeared in PCB form, I returned to the idea of an SD card storage device. This time it was to load raw machine code from SD to RAM – again, via an ATMEGA328 but this time connected via a Z80 port (Essentially, the same circuit as the Digital I/O Module)
The idea here would be a simple bootloader ROM would run on the RC2014. This would set one of the bits of port 0 high so the ‘328 would know to load the first byte from a file on the SD card on to the data bus. Once the Z80 had loaded this in to RAM it would toggle the bit and the next byte would be read until the whole file was loaded.
Although this worked, it wasn’t a solution I was particularly happy with. The main reason was that it had very limited functionality and relied on a custom ROM image.
What I wanted was a way to fill the RAM without worrying about what’s in the ROM (or even having a ROM), and bypassing the Z80. An old idea that I had for making an EPROM burner was recycled in the form of this prototype;
This used a couple of 74LS393 counters connected to the address bus via 74LS245 to count from 0 to 65535 (ie the whole Z80 memory address space). A bus request (BUSRQ) from the ‘328 asked the Z80 to disconnect itself from the bus. When this is acknowledged (BUSACK) the ‘245s have control of the bus and can increment the address from a pulse from the ‘328. The prototype proved the concept worked, so time to spin up a simple board to take things further.
The first spin of the board was focused on the Z80 interface with the SD pins and any spare GPIO pins from the ‘328 bought out to headers. I still hadn’t decided yet how the SD card would actually be fitted. Every SD card socket I could find was surface mount, and if this was to be made in to a kit, I wanted to avoid surface mount components if possible.
The next spin of the board refined more of the control circuitry. The spare GPIO pins had been connected to switches, LEDs and some of the bus lines. Not everything quite worked as planned, as the subtle bodge wires allude to. In hindsight, using black solder resist for a prototype board wasn’t such a great idea either. However, I got it to work and was able to get the firmware on the ‘328 doing what I wanted it to do.
I had been using a cheap Chinese SD module to connect the ‘328 to an SD card, and these actually work very well as well as being a kind of standard, so to get around the surface mount issue, I decided to use the whole module in the finished product. Oh, and as you can see, there really isn’t much spare PCB space for an SD card socket either!
With a bit of swapping around, I managed to free up an analog GPIO pin that I could connect to a potentiometer. This works as a crude file selector. The initial firmware I wrote for the ‘328 works, and loads an image from SD card in to RAM, or dumps the whole contents of memory in to a file on the SD card. Scott Lawrence has updated this to give access to different file images and protects these against accidental overwriting.
So far, this is the best SD card storage for the RC2014 that I’ve made. I wanted to share this though to give you an idea of how a new module is created, from conception, through prototypes and to final product.