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.

Lately everything I wanted back then, can be easily (and rather cheaply) done with modern MCUs connected through USB. Hence my recent interest got back into electronics and my keyboards even had a 128×64 display and even a 160×128 one later.

📜Older version

The first (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 😆.