Retro Challenge 2017/10 Getting Started

So, the idea of streaming the RC2014 to the internet had been rattling around in my head for a while, but I’d never quite worked out how the software side of things would work.  Although the hardware side should be kind of straightforward, with my software skills, I need to find something I can copy & paste.  A couple of days ago I just happened to put the right search terms in to Google and it gave a result that looked like it would do want I wanted.  So, with that, my plan for Retro Challenge took shape!

A couple of years ago I played around with some EPS8266 Wifi Modules, but never really found a use for them.  However, for this, they would be ideal.  The code I had found was a Web Sockets Serial Monitor designed specifically to run on an ESP8266, so I decided to test it out just to check that it did what I expected it would.

Several hours later, it did!  Those hours, however, were spent trying to remember how to program these things.  My desktop machine didn’t have any of the ESP stuff in the Arduino IDE, but luckily, I still have my old laptop that I used a couple of years ago.  Despite getting all the right libraries, it just wouldn’t compile.  So, on to the new laptop, with a fresh Arduino IDE and all the ESP stuff and libraries, and it compiles.  Getting it to upload, however, was another challenge which actually involved burning myself on the USB to serial adapter at one point!  It turns out that of the two I tried, one of them was dead, and the other one spammed my Twitter account ever time it’s turned on (I didn’t know this until checking Twitter later… what!  86 new mentions!).  It also turns out they need more power than the adapter can supply.  And, in order to program them, the ESP needs to be pushed in to the adapter really really really hard!

The programming jig wasn’t really suitable for testing things out, so time to transfer this to a prototype board.  But first, lets work out a circuit!  The programming jig has the necessary support components and minimal connections, so that’s a good start.  The ESP works on 3v3, so I’m going to need a regulator to drop the 5v down.  And the Rx pin is only 3v3 tolerant, so a couple of resistors as a voltage divider will work fine as a level shift here.  The Tx pin won’t be connecting to the RC2014, although even if it was needed, 3v3 is sufficient enough to work.  GPIO0 is used to either put the ESP in to programming mode or run mode.  2 of the other GPIO pins (15 and 2) were tide to ground and 3v3 respectively on the programming jig.  I can’t remember why I did that, but that won’t be needed for this board.

Before hooking up the ESP to the power rails, I checked that the regulator I used (spare one I had lying around) did it’s job.  Yup, 3.299v, close enough!  On with adding the rest of the stuff.

So, from left to right, we’ve got a connector for 3v3 so it can be powered directly if needed (or use 3v3 elsewhere), and an FTDI header for my 3v3 adapter so the ESP can be reprogrammed.  Then there’s a reset button, the 3v3 regulator and caps, then the ESP itself.  There’s a 10k pull up resistor on the reset pin, and a program/run jumper below the ESP.  As yet, the resistor divider for the Rx pin aren’t fitted.  But it should power up and work just as it did in the jig, right?

Ummm… no.  Regardless if I used the power regulator, or fed 3v3 in directly, out of the serial header all I got was gibberish.  It was consistent gibberish, but not something I could make any sense of.  Maybe I damaged the ESP when soldering the wires on?  Hmmmm… maybe I should program another one just in case.  Well, long story short, it needs GPIO15 connected to ground to work!  I can’t see any logic why this would need to be the case, but, whatever, it works now.

I needed to add a rule on the firewall to allow port 81 through to the IP address of the ESP, and after that, I could connect from the outside world and see what my RC2014 was saying!

Things work pretty well, although there’s some kind of issue with carriage returns and/or linefeeds that’s causing some stuff to be dropped, but that’s enough success for one day.  We’ll sort that out tomorrow!

Decoding ROM labels

Back in the earliest days of the RC2014, it came with a pre-programmed 27C512 64k ROM, with Microsoft BASIC on it in the first 8k, and it would work with 32k of RAM and a 68B50 ACIA.  One set up, one ROM, life was simple!

As time has gone on, and more options have become available, other ROM images, such as Microsoft BASIC for 56k RAM, CP/M Monitor, RomWBW and Small Computer Monitor have been introduced.  See this page for a brief overview of each option

Future possibilities, such as other UARTs, different CPUs or other variations will inevitably lead to more ROM images being needed.  So, in order to keep track of what is programmed where, ROMs are now being shipped out with a label on them.

27C512 64k ROM

Every 64k ROM now has an 8 digit code on it.  Each digit, from left to right, refers to an 8k bank from 0x0000 to 0xD000.  This bank can be selected with the A13, A14, A15 jumpers;

Address A15 A14 A13 ROM Label
0000 0 0 0  Xooooooo
2000 0 0 1  oXoooooo
4000 0 1 0  ooXooooo
6000 0 1 1  oooXoooo
8000 1 0 0  ooooXooo
A000 1 0 1  oooooXoo
C000 1 1 0  ooooooXo
E000 1 1 1  oooooooX


The value of the digit represents the ROM image that sits in that particular 8k bank.  Currently, it will be one of the following;

0 – Empty bank, available for user to program

R – Microsoft BASIC, for 32k RAM, 68B50 ACIA, with origin 0x0000

K – Microsoft BASIC, for 56k RAM, 68B50 ACIA, with origin 0x0000

1 – CP/M Monitor, for pageable ROM, 64k RAM, 68B50 ACIA, CF Module at 0x10, with origin at 0x0000

2 – Microsoft BASIC, for 32k RAM, SIO/2, with origin 0x0000

4 – Microsoft BASIC, for 56k RAM, SIO/2, with origin 0x0000

6 – CP/M Monitor, for pageable ROM, 64k RAM, SIO/2, CF Module at 0x10, with origin at 0x0000

88 – Small Computer Monitor for pageable ROM, 64k RAM, SIO/2 or 68B50 ACIA, with Microsoft BASIC and CP/M boot options

9 – Small Computer Monitor for any ROM, any RAM, any UART


ST39SF040 512k ROM

With the advent of the 512k ROM 512k RAM Module, an ST39SF040 is now supplied.  This will have the designation of x.512K, where x is the software designation. At time of writing, only 1 image is supplied;

1.512k – RomWBW RC_Std.ROM 2.9.0

As more ROM images are added, this list will be updated.


Standard factory ROM images can be downloaded from Github


Note that despite having total control over which designation I want to use for whichever ROM image and where that is located on the ROM – I still managed to pick a combination that my label gun was unable to do!  So some people will have a label that starts with an interlocking “n” and “u” character, which is the closest I could do to represent a “2”.  If this is the case, your “¬4006000” is actually “24006000”.  In order to get around this, I have now bought an extra 2 label guns, which have been dismantled to allow the belts to be swapped around, and reassembled.  Normally reassembly of label guns is only possible by a highly skilled and qualified octupus, so I don’t recommend anybody tries doing this themselves!

Iterations of a SD Module

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.

Retro Challenge 2016 – My Dog Ate My Homework

So, all the way back in deepest darkest December, I announced I would enter the Retro Challenge 2016 competition that ran throughout January.  Those of you that followed by blog or Twitter account when I did this in 2014 will know that I blogged and Tweeted relentlessly for the whole month, but, this time around, almost nothing.  Obviously, I’m keeping some secret about an amazing breakthrough or something, right?  Well, truth is, I’ve done almost nothing.

Things started well, and on 1st January, I designed a new backplane for the RC2014.  Although I hadn’t studied the circuit diagrams for the ZX81, Jupiter Ace or ZX Spectrum yet, I knew that there were resistiors between the Z80 CPU and other devices.  The stripboard backplane I’d been using had served me well, but it was time to progress to a better solution, and one that could be adapted better to my needs.  Knowing that PCB delivery times could be against me, I thought it best to crack on and get this  ordered.

Screenshot from 2016-01-31 16:01:00

The basic circuit is very very simple – however, I wanted to get this just right, not only for Retro Challenge 2016, but for other possible RC2014 uses.  Essentially, there are 8 40 way connectors that are linked straight through – however, the data lines and address lines for the leftmost 2 connectors and rightmost 2 connectors are separated by a pair of pads.  These can either be shorted together for up to 8 commoned connectors, or have resistors soldered across them.  I also added a power connector and the option of either running 5v directly in to the board, or regulating a higher voltage down via a LM7805.


HDMI and USB Keyboard Support

So, the RC2014 is a great little computer.  We all know that.  However, to communicate with it, it is easiest to use the serial port and hook it up to a laptop or desktop PC.  This makes detracts from the fact that it is small, portable and cheap as well as missing the point of running code on such a basic computer.  So I’ve been looking for a solution to this.

Back when this was still running on a breadboard, I hooked up an Atmel ‘328 that was connected to a keyboard and 4 x 20 LCD display.  It communicated with the RC2014 over the serial port and kind of worked ok, although 4 lines was very restrictive and the Atmel couldn’t really keep the screen running and listening at the same time.   I have thought about using a ‘328 to drive a composite output, or maybe some kind of bigger LCD panel, but nothing really struck me as just right.

That is, until the kind people at Raspberry Pi released a cheap multifunction interface device a couple of weeks ago!

2015-12-18 22.13.44


Retro Challenge January 2016 – Preamble

So, you may well remember that I entered Retro Challenge 18 months ago, and what a fun crazy busy time that was!  Well, the January Retro Challenge competition is about to kick off in just over 2 weeks.

If you’re not familiar with Retro Challenge, shame on you!  But you can de-shame yourself by heading over to and seeing what it’s all about.  Essentially, it’s a month long bi-annual competition where the entrants set themselves a goal based around old school computing and blog, tweet and share their experiences.  The goals are pretty loose, as long as they are based on something from last centuary (modern emulators of old kit is fine).

The challenge I set myself was to take a breadboard based Z80 computer and bring it to life in modular PCB form in such a way that I could spell out my name on.  Have a look back through my blog to see how I did.  Spoiler —->



RC2014 SD Bootloader Update

Just a quick update to about the SD Bootloader I designed a few posts ago.  Well, the PCBs have arrived and last week I took a soldering iron to one of them and gave it a quick test

One side of the board is effectively an Arduino, so without plugging it in to the RC2014, I connected up an FTDI lead and uploaded the Arduino Blink sketch.  A quick check with a multimeter and one of the pins was altenating between 5v and 0v.  So far, all good! (more…)

RC2014 Bootloader for SD Cards

So, the RC2014 is great.  I can run Microsoft BASIC and program it from there, and as long as I am using a terminal emulator, I can copy & paste to save and load programs.  Alternatively, I can write Z80 code using an online compiler then download it, copy it to USB stick, move it to my old Windows 2000 laptop (which has a parallel port) so I can burn it on to EPROM to see if it works, make adjustments and repeat with another EPROM.

I will be the first to admit, however, that this is probably not the most efficient workflow.  Not to mention the time and effort involved in wiping the limited stock of aged EPROMS.

So, I am in the process of designing an SD Card based bootloader.

i (2)


RC2014 with ZX Printer interface

My original plan had never been to design and build my own computer.  I had, however, planned to build a clone of the Sinclair ZX80, which has been on my bucket list of things to own for year, and which I had found plans for online.  Whilst collecting the parts and reading up on simple Z80 computers I got kind of sidetracked and ended up with the RC2014.

The print out shown was what was left from the last time this was connected to a ZX Spectrum!

The heart of the RC2014 is a Zilog Z80 CPU, which is the same one that Sinclair used in the ZX80, ZX81, ZX Spectrum and Z88.  If the ZX81 and ZX Spectrum can run a ZX Printer, then surely it follows that the RC2014 will be able to too?


Assembly Language Vs Lego

I guess this is kind of a follow up to my Retro Challenge posts, as it was thoughts that stemmed from teaching myself Assembly Language for my Z80 project.  Essentially it is a comparison between programming in the 70’s and today against building with Lego in the 70s and today.


But before I get stuck in, can you identify this famous TV family from a few crude Lego bricks? (more…)