Emulating a Commodore Chessmate

 A couple of years ago, Hackaday published a short piece on the Commodore Chessmate. As is usual with their articles, its shortness of length was more than made up by the breadth of its links. The last of these led to Hans Otten's Retro Computing page. 

(One of the few comments beneath the article is by Peter Jennings, creator of the original Microchess program, linking to his reminiscences about the Chessmate: well worth a read!)

Chessmate by Commodore

Anyway the article caught my attention because I'd had one of these as a nerdy kid. I remember opening it up, hoping to find... I don't know what, maybe a sort of PET? but not recognising many of the components; nowadays I could just Google it, and probably end up at Hans's page.

Among a wealth of other information, Hans provides ROM dumps and a memory map. I thought, should be pretty easy to write an emulation of that, and so it was. (The hardest part was probably mapping the 7-segment LEDs onto the TFT screen, which is to say: not very. Probably about a weekend in all.)

Chessmate by me

(The emulation uses r65emu, my emulator library for Arduino, running on an esp8266 connected to a TFT screen.)

Time passed and r65emu slowly improved. One update was to support other kinds of displays and keyboards besides the original TFT and PS/2. Sometime after this I decided to build a retro-modern version of the Chessmate with an anachronous mix of whatever parts I had lying around, and knocked it together on a couple of breadboards. 

I don't have a picture of that, but it was an unholy mess of wires, and languished on the side of my desk for over a year before I sat down with KiCad to turn it into something more permanent. I must have been in a rush because I made several mistakes with that PCB, getting some footprints wrong. I fixed them and parked the design, slightly depressed.

Things might have stayed like that for yet another couple of years, had I not been contacted out-of-the-blue by Liam from PCBWay who expressed interest in sponsoring r65emu. And so...

Chessmate by me and PCBWay

This uses a node32s microcontroller, push-button switches, a buzzer and 7-segment LED displays. The four status LEDs are represented by decimal points. Its software and hardware lives on GitHub.

It would be interesting to run a modern chess program on this hardware; one possible candidate is by Sergey Urusov.

(Incidentally, Michael Gardi has a much nicer modern rebuild of the Chessmate, complete with 3D-printed replica case!)

Space Invaders!

When I was a teenager Space Invaders arrived and changed the world. I must have put pounds into that machine in the local chipper, in the days when chips cost shillings. It never occurred to me that you could actually buy one of your own until one of my brother's friends' fathers did. (Come to think of it though, if I'd kept all of the cash I put into various machines, I probably could have had one of my own. I believe this is known as delayed gratification.)

Same Hardware, Different Processor!

Fast-forward 30-odd years and I'm sitting there blogging about an emulation of an 8-bit microcomputer of similar vintage. Hmm...

Space Invaders hardware comprises an Intel 8080 clocked at 2MHz, 8k ROM, 1k RAM and 7k memory-mapped video RAM. (An Emutalk thread has all the details and the ROMs.) The most difficult part is definitely the CPU but that only has to be done once to open up a whole world of crap games.

There are dozens of 8080 emulations out there, of varying quality. (Most of them written solely for this game!) I picked one and remixed it in the spirit of the 6502 emulator I made for the UK101; it plugs into that framework quite easily.

When a moderately-complex project like this links for the first time, the natural thing to do is upload it, more in hope than expectation, and when it fails, start debugging. The best way to do this is with a test-suite, preferably one which someone else has written in advance. (This worked out really well for my 6502 core thanks to Klaus Dormann's excellent 6502 tester.)

For the 8080, all searches led to a 'CPU exerciser'. Rather than testing a single instruction in isolation, this program runs a group of operations with different arguments and merging the resulting CPU state into a checksum as it goes. If the final checksum obtained by 'your' CPU is the same as one from a real chip, you know (to a high probability anyway) that your implementation is good for the instructions tested. (Luckily, that page documents results from real CPUs so there's no need to dig up an old 8080 board.)

If that sounds daunting, it is! Fortunately a preliminary test is also provided which tests the instructions required to run the exerciser itself. This helped fix a few bugs on its own and, since it used the CP/M "bdos conout" operation to report success, raised the interesting possibility of implementing a virtual 8080-based CP/M machine. I subsequently found a slightly more complex set of tests in another emulator's repository which helped find enough bugs to get all-but-two of the exerciser's tests passing.

(Timings of the exerciser indicate that my 8 year-old Lenovo laptop runs an emulated 8080 about 80x faster than the 2MHz 8080 for which it was intended. I haven't timed it on a Stellaris Launchpad however.)

Adventures in Dremel

So, despite the fact that some bugs remain in the emulation, enough of it is working to run Space Invaders properly. It runs at correct speed because it is driven by a timer interrupt (emulated with Energia's millisecond timer) and therefore we didn't need to bother keeping track of individual instruction timings, which all of the CPU emulators I looked at did. (Most of them were similar in other ways too, indicating a common influence, perhaps in this document.)

Just like the real thing, if you're 6" tall.

You can find the whole thing at Github, as usual.

Retrocomputer Resurrection

"What's a Computer?"

This chimera is a microcontroller emulation of a UK101, an 8-bit microcomputer from the early 1980s. Needless to say I had one; it is a shocking thirty-three years since, as a spotty teenager, I soldered one together over the course of a few days. I recall the kit cost the equally shocking sum of £99.95 (a lot of pocket-money), and had to be smuggled through Irish customs in my parents' car because the Single European Market was at that time merely a twinkle in M. Delors' eye. In its original configuration it had 1k of user RAM, 1k of display RAM, 8k ROM Basic (from Microsoft) and a 2k ROM monitor. When it went to its present resting place in the attic a couple of years later, it had 16k of user RAM, 2k of display RAM and an additional 6k of utility ROM, all piggy-backed on the original chips.

The last time I had patently too much time on my hands, in 1997 (seventeen years!), I hacked together a software simulation of it. I had intended this to be a general purpose simulator but it fell by the wayside after the UK101. In the intervening time I'd often regretted not writing the simulator in Java (indeed, a very good Java-based simulator now exists) but luckily where microcontrollers are concerned, C/C++ is still the only game in town, and most of the code compiled under the Energia IDE.

The hardware is almost insultingly simple, there are five components:

• A Stellaris Launchpad from Texas Instruments,
• An SD card drive,
• A TFT LCD boosterpack,
• A PS/2 socket,
• A PS/2 keyboard.

While the Launchpad has only 16k of RAM, of which 12k is used for the main memory and 2k for the display, it does have 256k of flash, easily enough to contain all of the ROMs I've collected for it. (Another UK101 hardware instantiation can support the full 40k of user RAM.)

This build's main limitations are the display (only 30 lines of 40 characters vs the original's 32x48 ---  affordable TFT screens max-out at 240x320 pixels these days) and the keyboard (a lot of the games use the Control, Left-shift and Right-shift keys, which aren't available individually from the off-the-shelf PS/2 keyboard library).

However it has one modern advantages over the original which almost makes it enjoyable to use: checkpointing and restoring the machine state using the SD card. This allows creation of initial game images (which load instantly since they're only 14k) and progressive checkpoints, as adventure games are completed, for instance, or new programs developed.

Space Invaders: it doesn't get much better than this!

Code and programs are at GitHub, should you care.

The final thing is to find a suitably retrotacular housing for it. Something like this would be about right...

Kim Greist in "Brazil" by Terry Gilliam