Crystal Hammer

⏱️Overview

This is the final version of the “console” I created around 2003. Its purpose was to serve as program memory for 8051 MCU (board with it is not yet attached on this picture).
The PC was filling console’s memory with bytes of code and then starting MCU which used it as program code.
Console was connected with a PC through parallel port (LPT). The PC had my own IDE (editor) and compiling its assembler code to bytes.

Nowadays this isn’t at all needed and even looks scary. MCUs of today have Flash memory for program, either programmed from PC through USB already or with a simple chip (USB to serial) converter/adapter/programmer.

📊Features

PC usually was sending a lot of bytes, so the console had counters, to increment the address by itself.
It used power supply from PC, here 12V which LM317 regulator converted to 5V.

So its memory (SRAM, 256kbit) was filled by the PC through the console, it then would serve as program memory for the 8051 family MCUs (a quite popular one, but still poor, like ATmega328 today).

I had two modules for it. One with big 80C32 and second with smaller and faster 90C32. The console had a connector where you could attach one.

It also featured a relay that would automatically turn on the supply for the module once the program got transferred to memory.

Later you could switch the SRAM to EEPROM and get it programmed for the use in actual module/device with MCU, without console. Which I eventually never got to.

🔍Details

The console board was smaller than the older one (below) and needed less current. It featured a small and detachable display module, for showing address and byte value, which was mainly for checking and later wasn’t needed.

Construction was made on a universal board, possibly reused. Since being smaller it also was more durable and had less spaghetti wires. Underside actually looked very well compared to the mess in older version.

🖥️Program

The PC program was driving LPT port and sending code bytes to memory. It quickly became a basic IDE, where I could write code for ’51 MCU in its assembly language. I wrote it in Delphi 5, which I was using at that time a lot. It translated all instructions and computed jump offsets. Additionally with one key press it compiled assembly code to bytes, then sent it to console and triggered its relay to start the program with MCU module. That was the most convenient thing possible. I’ve seen too many solutions which needed pressing reset switch on the board or other slow, manual work.

⏳Conclusions

I was trying out few things to get done, an 8 bit ADC, a real time clock HM6818A chip and mostly 5×7 dot matrices. It somehow didn’t feel too stable, and it was a lot work to get anything done at the time. I actually didn’t finish any board then, as a separate working MCU. For a clock it would use too much current. And for making anything else that MCU was too slow. And I was more interested in other things at the time like creating music and my tracker.

📜Older version

The first (even older) version had bigger digits, mounted solid with also the logic to decode them. I think it was using close to 1A from 5V, and the 74192 counters were heating like crazy.

I was also using SMD chips, if I found them somewhere else and desoldered. I don’t have any picture from underside of this old version, but I remember it was a serious spaghetti. I’m guessing around 400 wires connected 😆.

I also made an older project before this console. It was a clock with few cool fonts on 4 small, red, 5×7 matrices. I made fonts just by programming memory and using tiny switches. And the clock had many 74 series chips used, no MCU. Yeah those were the oldest times.

➡️Nowadays

Lately everything I wanted back then, can be way easier (and cheaply) done with modern MCUs connected through USB. I can’t even, when I remind myself of this project, and the trouble needed back then to program a basic and slow 8bit MCU like 8051.

Hence in recent years my interest got back into electronics and my first keyboards had a 128×64 display, then a 160×128 later and now 320×240 in newest. I thought of using those 5×7 Red/Green LED matrixes again few times, but eventually I didn’t. Nowadays LCDs are cheap and easy to use with any MCU. So it’d be too much work and way less resolution. Even today’s LED matrixes use a dedicated chip. I didn’t even use them for my latest clock, it was still simpler to use an LCD, which can have way more detailed fonts.