Claude Code-assisted The entries from 2017 on were added in October 2026, looking back, by Claude Code. Everything that came after the first emulators is also on the hardware projects page. There is also a homage to the Microtronic in German: 35 Jahre Busch Microtronic.
2026 - 11 - 4 : Second Place in the 2026 Hackaday Retrocomputing Challenge
Claude Code-assisted New blog entry, auto-created by Claude Code from historical records and by analyzing Michael's project history.
The Microtronic Phoenix won second place in the 2026 Hackaday Retrocomputing Challenge, out of 230 entries submitted between August 18 and October 27, 2026 - a large field with many strong projects. In the announcement of the winners, Jenny List points out that, unlike other Microtronic emulators, the Phoenix runs the original firmware, and the judges write: "The attention to detail and skill required to make it do its job so accurately by persuading a 1970s microcontroller to reveal its secrets is what makes this project special, and you can count us impressed by it."
The prize is a testament to the collaboration behind the Phoenix. Decle and Michael found how to put the TMS1600 into its undocumented test mode and read out the first version of the ROM, with Decle's TMS1xxx dumping technology (Decle also contributed his disassembler). Jason T. Jacques analyzed and corrected the dump, and built the first breadboard Microtronic running the original firmware on his TMS1xxx emulator - the emulator the Phoenix runs to this day. Michael designed the PCB and did the software integration. The whole story is told in the Microtronic firmware ROM archaeology project.
Three more of Michael's projects received honorable mentions, all three in the "Old Iron" category: the Lazarus daughter board, which brings a Laser VZ-200 with a damaged PCB back to life - "a practical way to recover from this", which "could save other machines aplenty" -, and, where the judges found it "a welcome sight to have several entries using obscure educational computers", the oscilloscope vector graphics on the Philips MC6400 MasterLab and the Kosmos CP1 solving the Towers of Hanoi on an LED matrix. So all three German educational computers of the early 1980s made it into the results.
2026 - 10 - 16 : The Emulators on Busch's Official Microtronic Page
Claude Code-assisted New blog entry, auto-created by Claude Code from historical records and by analyzing Michael's project history.
Busch GmbH & Co. KG in Viernheim, the company that made the Microtronic in 1981 and today makes model railway accessories and model cars, keeps a page about the Microtronic computer system on its official website, with the original manuals for download. Since September 2024, it has also pointed to the community projects: the Arduino Microtronic emulator - with links to Michael's German homage page and the Github repository -, the SD card interface PicoRAM 2090, and Michael's emulator of the 2095 cassette interface, with the video in which the German YouTube channel Mein Elektronik-Hobby demonstrates it.
In 2026, Busch added the Microtronic emulator for the web browser, which runs the original firmware and shows the running program at the same time - "Genial ist, dass der Programmablauf gleichzeitig angezeigt wird" (the brilliant thing is that the program flow is shown at the same time) - and closed with a thank-you: "Vielen Dank an Michael Wessel und sein Team der Microtronic-Freunde" (many thanks to Michael Wessel and his team of Microtronic friends). Forty-five years after the Microtronic, its maker points its customers to the emulators and hardware the community has built for it.
2026 - 10 - 5 : The Microtronic in the Web Browser
Claude Code-assisted New blog entry, auto-created by Claude Code from historical records and by analyzing Michael's project history.
The latest emulator needs no hardware at all: a Microtronic emulator that runs in the web browser. Like the Phoenix, it is not a re-implementation - it runs the original 1981 firmware ROM, on an emulated TMS1600. The program RAM, the display, the keypad, the inputs and outputs and the 1 Hz clock are modelled at pin level, behind a console that is drawn from photos of the real machine. It comes with a library of programs from the manuals, so everybody can now try the Microtronic: there is nothing to build, and nothing to load or install - just open the page.
Claude Code wrote this emulator, and it could only do so by standing on the shoulders of giants: the firmware ROM that the Phoenix team had retrieved, Jason T. Jacques' TMS1xxx emulator as the reference for the CPU, the annotated disassembly of the firmware, and the manuals. The source code is on Github, and there is a video.
The Microtronic's main competitor of the time got the same treatment: the Kosmos CP1 emulator for the browser runs the original Intel 8049 firmware ROM of the CP1. Michael is attached to the CP1 as well, and has built hardware and software for it - for example the Towers of Hanoi on an LED matrix, where a CP1 from 1984 solves the puzzle and an Arduino animates the disks, and a development toolchain with an assembler and a cassette encoder. Both machines, and the Philips MasterLab, are the subject of his write-up Educational Computers in Germany in the 1980s.
2026 - 8 - 1 : The Firmware Explained, the Manuals in English, and VCF West 2026
Claude Code-assisted New blog entry, auto-created by Claude Code from historical records and by analyzing Michael's project history.
Ten years after the first entry on this page, the Microtronic is better documented than ever. There is now an annotated, explained disassembly of the original 1981 firmware ROM (TMS1600). The manuals - both parts of the 2090 computer-system manual and the 2094 "Computerspiele" booklet with its 25 games and experiments - are available in English, hosted by permission of Busch. And the two articles Michael wrote in German for the retro computer magazine LOAD ( LOAD #10 and LOAD #11; first picture) are available as one revised English edition.
New programs appeared, too: a set of "vibe-coded" games, written entirely in Microtronic machine code in conversation with Claude and debugged on real hardware - Tic-Tac-Toe (apparently the first working one for the Microtronic; the listing in the 1981 manual had never been turned into a running program), the Lights-Out puzzle MERLIN in two versions, BLOCKADE, and a new LUNAR LANDER. They use the graphics, speech and memory banks of the PicoRAM 2090, without any firmware changes. Michael's video AI creating AI: Claude codes new games for the 1981 Busch Microtronic shows the games and includes a longer "interview" with Claude about how they were written; a second one shows the Claude-generated Microtronic demos for VCF West 2026.
These programs ran at the Vintage Computer Festival West 2026 at the Computer History Museum, where the Microtronic shared Michael's table with the Kosmos CP1 and the Philips MasterLab - three German educational computers of the 1980s. Claude wrote the demos, the posters and the presentations for the table.
2026 - 6 - 9 : The PicoRAM Family in the LOAD Magazine
Claude Code-assisted New blog entry, auto-created by Claude Code from historical records and by analyzing Michael's project history.
Michael's third article for LOAD, in issue #12 (2026), is about the PicoRAM 2090 and its younger siblings: "Die PicoRAM Familie - Moderne Speicheremulation für klassische Einplatinencomputer" (the PicoRAM family - modern memory emulation for classic single-board computers), in German. A Raspberry Pi Pico replaces the static RAM of the machine and loads and saves its memory contents from SD card - in the Microtronic, the Microprofessor MPF-1, and, with PicoRAM Ultimate, the Heathkit ET-3400, the Lab-Volt 6502 trainer and the Philips MasterLab. The article explains how it works without DMA or PIO, how redundant instructions of the Microtronic become new commands for graphics, sound and speech, and how PicoRAM 2090 won the Grand Prize of the RetroChallenge 2023/10.
Members of the association got the printed issue in June 2026; since October 2026 it is a free PDF download (the article is on pages 54 and 55; there is also a short PDF with just the cover and the article).
2025 - 10 - 3 : The Microtronic and the Kosmos CP1 in the LOAD Magazine
Claude Code-assisted New blog entry, auto-created by Claude Code from historical records and by analyzing Michael's project history.
LOAD is the magazine of the German association for the preservation of classic computers (Verein zum Erhalt klassischer Computer, VzEkC). Its issue #11, with the cover theme "Exotische Systeme", has two articles by Michael, both in German: "Der Busch Microtronic Lerncomputer - Erstaunlich vital" (the Busch Microtronic educational computer - astonishingly alive) and "Der Kosmos CP1 - Lerncomputer aus Stuttgart".
The Microtronic article tells the story of this page in print: the machine and its architecture, and what the community has built for it since - the Arduino emulators, the Next Generation, the PicoRAM 2090, the recovery of the firmware with Decle's disassembler, the MIDI drum computer. The two articles complete a series of three about the educational computers that were available in Germany in the first half of the 1980s. The issue is a free PDF download (the articles start on pages 72 and 76); printed copies can be bought from the association.
For readers who do not read German, there is a translated and extended version: Educational Computers in Germany in the 1980s combines the articles from LOAD #10 and #11 into one revised English edition, with a speed benchmark, the developments of 2025 and 2026, and the Microtronic Phoenix. Claude Code translated, combined and updated it.
2025 - 2 - 18 : Microtronic Phoenix
Claude Code-assisted New blog entry, auto-created by Claude Code from historical records and by analyzing Michael's project history.
All emulators so far re-implemented the behaviour of the Microtronic. The Microtronic Phoenix is different: it is the first emulator that actually runs the original TMS1600 firmware from 1981. It is the result of a collaboration of three people. Decle contributed the technology for dumping TMS1xxx firmware ROMs and a disassembler; Jason T. Jacques wrote the TMS1xxx emulator, designed and breadboarded the prototype hardware, and refined the firmware dump; Michael did the first round of firmware dumping, the PCB design and the software integration.
The project is shared with the community, so that others can experience the 1981 machine as authentically as possible. There is a Hackaday.io project page, and Hackaday and Hackster.io wrote about it. Microchip, the maker of its ATmega644P microcontroller, featured the Phoenix in its "Microchip Makes" posts - on X, Instagram and LinkedIn (first picture) -, some of them with more than 800 likes. Notably, the board in that post is not Michael's: by then, three other Microtronic enthusiasts had already built their own Phoenix from the public Github repository, and the picture shows the build of venice1200.
2024 - 10 - 3 : The Educational Computers Compared: An Article Series in the LOAD Magazine
Claude Code-assisted New blog entry, auto-created by Claude Code from historical records and by analyzing Michael's project history.
Michael's first article for LOAD, the magazine of the German association for the preservation of classic computers (VzEkC), appeared in issue #10: "Computer zum Experimentieren - Der große Vergleichstest der Lerncomputer, Teil 1" (computers for experimenting - the big comparison test of the educational computers, part 1).
In the early 1980s, a new category of home computer appeared in Germany, and only there in this form: the educational or experimenting computer. The article introduces the three main representatives - the Busch Microtronic, the Kosmos CP1 and the Philips MasterLab - compares them, and then looks at the Philips MasterLab in detail. The Microtronic and the Kosmos CP1 got their own articles a year later, in LOAD #11. The issue is a free PDF download (the article starts on page 72).
2024 - 4 - 6 : Microtronic Firmware ROM Archaeology
Claude Code-assisted New blog entry, auto-created by Claude Code from historical records and by analyzing Michael's project history.
The Microtronic is powered by a mask-programmed 4-bit microcontroller from Texas Instruments, the TMS1600, and everything that makes it a Microtronic - its instruction set, the display, the keyboard, the clock, the cassette interface - is firmware in that chip. This firmware had been considered lost for decades. No procedure for reading out a TMS1600 was documented anywhere, and the ROMs of related chips had usually been recovered by destructively opening the chip.
A non-destructive alternative had recently been found for the Radio Shack Science Fair Microcomputer Trainer: an Arduino puts the chip into its test mode, which then delivers the ROM contents over a serial interface. After a lot of trial and error, Decle and Michael got the test mode of the TMS1600 to work, and in April 2024 downloaded a first version of the Microtronic ROM. Jason T. Jacques then took the lead, analyzed and double-checked the dump, and corrected it.
The process is described in the Hackaday.io project Microtronic Firmware ROM Archaeology and, in more technical detail, in Jason's write-up; Michael announced it in the video A Breakthrough in Busch 2090 Microtronic Preservation - We Retrieved the Firmware ROM! With the original firmware in hand, an authentic emulator became possible - the Microtronic Phoenix of the following year.
2023 - 9 - 5 : PicoRAM 2090
Claude Code-assisted New blog entry, auto-created by Claude Code from historical records and by analyzing Michael's project history.
This time not an emulator, but an expansion for the real machine. PicoRAM 2090 replaces the 2114 SRAM chip of the Busch 2090 Microtronic with a Raspberry Pi Pico (RP2040) - and with the memory under its control, it can do much more than store programs:
An SD card interface loads and saves complete memory dumps and exchanges files with a PC. Sixteen memory banks each hold a full Microtronic RAM, selectable by hand or by program. An OLED display with five buttons shows the current address and instruction, even as mnemonics, which helps a lot with programming and debugging. And there are hardware extensions the Microtronic never had: DECtalk-based speech synthesis, a battery-backed real-time clock, sound, and text and graphics output on the OLED display. Programs reach them through extended op-codes; the Microtronic's own "get time" instruction is intercepted, so that it returns the time of the real-time clock.
See the Hackaday.io project, and the articles on Hackaday and Hackster.io. PicoRAM 2090 won the Grand Prize of the RetroChallenge 2023/10 - Michael calls it the project he is most proud of. Werner Capell ("Mein Elektronik-Hobby") published an assembly and demo video (in German). It is dedicated to the memory of his late father, Rudolf Wessel.
2023 - 2 - 2 : A Microtronic Seminar at the SRI Artificial Intelligence Center
Claude Code-assisted New blog entry, auto-created by Claude Code from historical records and by analyzing Michael's project history.
The Microtronic made it into the day job: Michael was invited to present the long-running project in a one-hour seminar at the Artificial Intelligence Center of SRI International. The talk, "Reengineering of a Historical Educational 4bit Microcomputer Trainer with Arduinos", came with the subtitle "And now for something completely different" - a computer scientist's journey into electrical engineering, and by its own disclaimer largely off topic for an AI seminar.
Several of the emulators were on display in the seminar room, from the first breadboard versions to the Next Generation board, each with an explanation sheet. The slides of the talk (PDF, 92 pages) are available, there is a video recording on YouTube, and Michael wrote about the seminar in a LinkedIn post.
2022 - 1 - 2 : A Firmware Update for the Mega Emulator of 2016
Claude Code-assisted New blog entry, auto-created by Claude Code from historical records and by analyzing Michael's project history.
Six years after the last entry about it, the talking Mega Emulator of 2016 received a firmware update. Over the turn of the year 2021 / 2022, Michael carried the patches and bug fixes of the newer emulators back into the code for the Arduino Mega 2560; the commit is dated 2 January 2022. The new version is in the Github repository, as "Mega Emulator Version 4".
The main new feature is more versatile speech output through the Emic 2. In 2016, a program had to send each character digit by digit, with the otherwise meaningless MOV x,x instructions. Now two more op-codes send a whole ASCII character from a pair of registers - 50x for BCD-encoded and 70x for hex-encoded values - and further codes initialize the speech module, start the speech, and wait until it has finished. A small demo program that lets the emulator count aloud from 0 to 9 is built in.
Otherwise: the built-in programs moved from the EEPROM to the program memory, so that the EEPROM no longer has to be prepared first; the 1 Hz clock is driven by a timer interrupt; the CPU throttle no longer blocks, so that the emulator stays responsive; some bugs in the CPU emulation are fixed; and it is faster. Michael shows the update in the video Microtronic Mega Emulator Firmware Update - Extended Speech Op-Codes.
2021 - 10 - 1 : A Retro-Authentic Microtronic Emulator, and a MIDI Drum Computer
Claude Code-assisted New blog entry, auto-created by Claude Code from historical records and by analyzing Michael's project history.
A new take on the 2016 Arduino Uno emulator from the first entries of this page: high-speed Microtronic emulation with an authentic retro user experience. A 7-segment bubble LED display takes the place of the LCD, the built-in program library is larger, and the memory contents are kept in the EEPROM, so that a program survives switching off - which the original could not do.
For the RetroChallenge 2021/10, Michael turned the emulator into a MIDI drum computer, programmed in Microtronic machine language. The sounds come from an X2GS, a small Waveblaster-style MIDI sound module, next to the emulator (first picture; see the video of the real-time pattern-based drum computer). The project was one of the winners.
2020 - 12 - 1 : Microtronic - The Next Generation
Claude Code-assisted New blog entry, auto-created by Claude Code from historical records and by analyzing Michael's project history.
The PCB that the 2016 entry "Playing with KiCad" below was musing about finally exists. Microtronic - The Next Generation is the current version of the Arduino Mega 2560-based emulator, on its own board: SD card storage, emulation of the 2095 cassette interface, a real-time clock, a display with a mnemonics / disassembler mode, sound output, and built-in programs such as Lunar Lander. Hackaday wrote about it in 4-bit Retrocomputer Emulator Gets Custom PCB; it was a winner of the Hackaday Reinvented Retro Contest 2021, and Hackster.io reported.
There is also a sister project by Frank de Jaeger and Manfred Henf, the Microtronic 2nd Generation (last picture): an emulator that installs into an original Busch electronics console, with a 3D-printed keyboard. It runs the same firmware as the Next Generation. Frank shows it in three videos: The new Microtronic 2nd generation, Busch Microtronic 2nd generation (on his channel SynthedMind), and Busch Microtronic 2nd Generation with Busch 2073 synthesizer technik.
2017 - 7 - 2 : An Emulator of the 2095 Cassette Interface
Claude Code-assisted New blog entry, auto-created by Claude Code from historical records and by analyzing Michael's project history.
The 2095 cassette interface, with which the Microtronic saved its programs on tape, is a very rare collector's item these days. Martin Sauter reverse engineered its protocol and built a Raspberry Pi-based tape emulator - see his WirelessMoves blog. Based on his work, Michael wrote an emulator of the 2095 for the Arduino Uno R3. Werner Capell ("Mein Elektronik-Hobby") showcases it in a video on his YouTube channel; there is also Michael's own demo video.
2016 - 5 - 23 : Emulator on the Arduino Blog of Adafruit.com
I have no idea how this happened, but somehow the Mega Emulator also became a featured project on the Arduino blog of Adafruit.com in the "Arduino Monday" series :-) Seems they are working closely with Hackaday.io. I did not announce it to them in any way, but I am flattered by the publicity. After all, the Emulator is using a couple of Adafruit components - the LED backpacks, the Emic 2, and so on.
2016 - 5 - 14 : Playing with KiCad
I am musing about the idea of producing a PCB (printed circuit board) for the emulator project, such that mass production in China can start soon ;-) First step is to learn how to draw schematics in KiCad. These are my first schematics ever - a black and white version, and a color version. Not sure how difficult it will be to make it into a PCB. Interesting idea, though. The front panel elements (buttons, LEDs, etc.) will probably have to go on separate PCBs, such that the whole thing can be mounted without all the wires required for the prototype.
2016 - 5 - 10 : The Emulator is "Featured Project" at Hackaday.com
The Talking Microtronic Mega Computer System Emulator is a "Featured Project" at Hackaday.com :-) If my understanding is correct, it stays "featured" on the front page of Hackaday.com for about a week. Before that, the project had also shown up on the "Atmel Makes" tweet.
The Hackaday.io project page will continue to exist. This page also contains some more general information about the Microtronic, i.e., I documented the 2090 instruction set, as the only source of documentation so far was in German (the Microtronic Manuals). Thanks to Kay Hidde, who saved the whole Hackaday featured page as one single PDF for my archive.
2016 - 4 - 9 : Single Step (STEP) and Breakpoint (BKP) Functionality implemented
I have finally added the breakpoint and single step functionality to the emulator (function keys BKP and STEP). As usual, the latest code of the Mega Emulator Version 3.2 is on GitHub. Goodbye, Microtronic Mega Emulator, we had a great time together!
2016 - 4 - 1 : A Talking Microtronic Emulator - Mega Emulator Version 3
Three months after I started this project, I have probably reached the end of this effort, with the release of Microtronic Mega Emulator Version 3. This version has a built-in Emic 2 Speech Synthesizer Module. The Emic 2 echoes back function key and HEX keypad presses, confirms user actions, describes the emulator status, can read the display contents to the user, etc. Wanna get a quote from Microtronic umm HAL 9000? Just press the right red button under the display (backspace button). Need an answer from the Magical Eight Ball? Use the left red button (cancel button). Also, the clock program PGM 4 uses the speech synthesizer- the current time is spoken with a press of the right yellow cursor key under the LCD. When entering a program, the current address, mnemonic of the current instructions, register contents etc. can be spoken - watch the YouTube video of the talking Microtronic computer.
I had a lot of trouble finishing Version 3. Using more and more memory for strings for storing Emic 2's utterances, I ran into very unstable system behaviors. After a lot of trial and error and some debugging hours it turned out that Arduino's String library was one source of troubles, and the other one was the SDCard library. Both produce memory leaks. Strings can be created comfortably with the String library, and it provides many convenient string manipulation functions such as concatenation, substring ranges etc., but there is no way to release the memory allocated dynamically for strings, and no garbage collection. What's worse, the SDCard library also uses the String library, and simply crashes after being used for a while, leaving you with no trace whatsoever of what went wrong. I regained system stability by removing all references to the String library, and also replaced the SDCard library with the SdFat library. This fixed all stability problems, and the emulator runs stable for hours now.
The Emic 2 has a built-in amplifier, which is surprisingly powerful. The volume can be set with an Emic command. I connected this little Uniden external HAM radio speaker to it, and the voice is clear and loud. That way, no USB-powered speaker is required.
In order to enable the built-in Emic to speak arbitrary sentences like the external Emic that I had reported about here before, I added some "extra meaning" to the MOV instruction. Obviously, one wants to be able to just send an ASCII character to the Emic without having to go through the digital outputs, cables and the additional Arduino Uno on the receiver side, which acted as a byte buffer, BAUD converter and hence, an intelligent interface to the Emic 2. This was achieved as follows. First, a MOV xx / 0xx instruction is basically meaningless, as it merely copies the content of register x onto itself, no meaningful Microtronic program uses them. Hence, I gave MOV xx an additional effect / meaning, namely to also transfer the half-byte / nibble x to the Emic. An ASCII character in decimal coding xy is thus transmitted via the sequence MOV xx, MOV yy / 0xx, 0yy, and more is not required in order to make the Emic 2 speak arbitrary sentences. This is demonstrated in this video. How many characters fit now? Much more than with the external approach... in order to speak a sentence, the Emic first needs a heading S character, and then the text followed by a trailing CR character. The 256 words of Microtronic program memory are hence good for 126 characters. One advantage of the external Emic 2 about which I wrote before is that it can be connected to a real Microtronic, though.
2016 - 3 - 20 : A Speech Synthesizer for the Microtronic (Emulator)
The Emic 2 Speech Module / Speech Synthesizer was sitting on my desk for quite a while now. I finally found some time to realize the Microtronic Speech Synthesizer with it. As I had mentioned previously on this blog, a Speech Module was announced for the Busch Microtronic in the Manual Vol. 1, page 77, in 1981. The Speech Module never got released by Busch (which I don't find too surprising I have to say ;-) ) So, 35 years after that module was announced, you can finally hear the Microtronic speaking with its new Emic 2-based voice, and this also works with the emulator.
One challenge in connecting the Emic 2 to the Microtronic was posed by the different interfaces - whereas the Emic 2 has a serial line with 9600 baud, the Microtronic has 4 digital outputs (at 40 baud or less)... I looked into using hardware (shift registers and buffers, UARTs etc.) for making the Microtronic talk to the Emic 2, but it all seemed much more complicated than simply employing another Arduino Uno acting as a byte buffer and converter. So I did that. I connected the four digital outputs of the Microtronic to the digital Arduino Uno inputs and tried to read some data from this primitive 4-bit wide "data bus". That turned out to be challenging - for some reason, the nibbles I read from the digital ports were unstable, especially when the output changed. I used a counter as a test program, and I would see readings such as 0, 1, 3, 2, 3, 5, 4... I tried to tweak the readings with delays and timings (make sure that a value is read constantly for at least <n> microseconds before returning it etc.), but it was still shaky. Also the digital inputs are very slow to read on the Arduino. I found solutions on the web for solving this problem (reading the PORTB register directly), but still the signals were unstable. I then ended up using the analog inputs of the Arduino, and I did my own threshold-based analog-to-digital conversion. That way I could get reliable readings of fast changing nibbles from the Microtronic "data bus".
The next step was to design a little data exchange protocol. The protocol must allow me to send a stream of ASCII characters to the Arduino, which would assemble a string from them, and send this string off to the Emic 2 via 9600 baud over serial IO, which will then speak that ASCII text string. One problem in designing such a "data exchange protocol" is obviously synchronization. Handshaking is too complicated and costly on the Microtronic side, especially since the thing is so slow, and serial data requires exact timings, start-and-stop bits, or hardware flow control, etc. All very complicated to implement. I figured I wanted a simple "self-clocked" data transmission protocol such that the data / flow synchronization problem does not present itself in the first place. I can transmit one ASCII character by sending two nibbles, and use a '0' after each nibble as the clock. That also means that I am then not allowed to send '0' as data, for any of the nibbles. I solved this by splitting the decimal ASCII encoding of a character into two nibbles, and by adding 1 to each, so '0' never occurs. The first nibble encodes decimal place values hundred and ten (hence, for ASCII codes from 32 to 127 this nibble will have values from 4 to 13 / Hex D), and the second nibble encodes decimal place value one (hence, this nibble will have values from 1 to 10 / Hex A). For example, for 'z' = 122 in decimal ASCII, 'D-0-3-0' will be sent. The Arduino decodes this back into 'z', and puts into a string buffer, until CR 13 is received. This works for all relevant ASCII characters - the Emic 2 needs CR 13 and obviously all characters from 32 to 127. Problem solved. However, timing on the Arduino side was still tricky, but in principle, the protocol is self-clocked.
2016 - 3 - 4 : Interfacing Microtronic Mega Emulator V2 with Busch Electronic Circuits
In order to check whether the emulator was really compatible with the electronic circuits built from the original Busch electronic kits I had ordered a brand-new Busch electronic studio "Profi 6000" from Amazon - it got shipped to the US, and arrived surprisingly fast after five days. I then rebuilt the original sound generator from Busch Microtronic manual Vol. 2, page 55, and it worked, as shown in this YouTube video, but the pitch is off quite a bit, so it sounds quite detuned. I have to try this also with the original Microtronic and check if it makes a difference, or if it is as good as it gets with fixed resistor values for the DA converter / resistor ladder. Well, at least it works in principle, which is good news. Previously, I had only connected a 555-based sound generator on a breadboard successfully.
Since the Arduino is being powered by a strong enough external PSU, there is no need for a 9V battery in the experiments, and the 9V and GND cables were used instead. On the Arduino side, I also had to put in signal diodes at the outputs in order to prevent leakage currents. In addition, I had to switch the inputs to INPUT mode instead of INPUT_PULLUP, since the Busch experiments won't work with inverted logic. So I added 4 pulldown resistors (each 10 kilo Ohms) to the little circuit board which also holds the signal diodes for the outputs, as seen in the pictures on the right. I have tested the inputs and outputs by connecting cables from 1 Hz clock to inputs, and also output to input, and I could successfully read the correct bits from the digital inputs corresponding to the outputs and 1 Hz clock signal.
2016 - 2 - 28 : Microtronic Mega Emulator Version 2 - Now with Case
I mused about the idea of putting the Microtronic Mega Emulator into a case for quite a while. It is done! Here is the YouTube video of the emulator in a case. After a couple of fruitless attempts to precisely cut out a decent face plate on my own with a scroll saw and plywood, I finally admitted to myself that this might be a job for a professional. I hence designed a face plate blueprint and sent it to a custom laser-cutting production service: Pololu. These guys did a terrific job; the quality of the 4 faceplates (2 in blue acrylic, 2 in iced transparent acrylic) is fantastic. The material is thick (3 mm), not wobbly at all, and it took only 5 days from order to delivery. Price: 70 $. I can highly recommend that service, it is awesome!
The next step was to redesign the hardware of the emulator. The backpacks I used for the previous version are great for prototyping, but they are unwieldy to put into a case. Hence, I had to replace the LCD+Keypad shield with a discrete LCD display and discrete N.O. momentary push buttons for the SD card file operations such as directory browsing and file creation, and I also wanted the display to be bigger. Hence I ordered a 4x20 white-on-blue Hitachi HD44780 display with backlight. Previously, I had used the TM1638 8digit 7segment display with 8 LEDs and 8 push buttons. The buttons were used as Microtronic function keys, so they had to be replaced, too. I added a second 4x3 telephone keypad to the system, this time non-matrix encoded as I still had one lying around. This takes up some more PINs on the Arduino side though - but hey, why not use most of the 54 Arduino digital pins, and even more, since also the analog pins can be converted into digital pins! The 8digit 7segment display got replaced with two 'intelligent' blue Adafruit 4digit 7segment display backpacks. What a nice blue color! All this is much easier to fit into a case / face plate, but requires a lot of wires and soldering. The LEDs on the TM1638 module were replaced with ultra-bright LEDs in blue, green, and pink, together with matching resistors to limit the current. As previously, these LEDs display the status of the 4 digital outputs of the Microtronic (set by the DOT op-code), as well as the carry and zero flag, a 1 Hz clock LED, and I also added a CPU heart / blinking light, indicating the speed of the emulation (which is controlled with the CPU throttle potentiometer on the right; the left potentiometer controls the LCD display contrast). Overall cost of material: about 300 $, and approx. 20 hours of work. But it was totally worth it, I had a lot of fun assembling it! I am glad it is done now, though - sorry, family, it will get better now, I promise :-)
You might ask whether I forgot to put some more LEDs into the additional holes in the face plate? These are reserved for cables to be passed through. There are four additional digital input and four additional digital output pins reserved for that purpose on the Arduino board, so one pair of input / output cables per hole. Then, the three remaining holes on the right are for GND, 9V VCC, and 1 Hz clock. This is all that is required to reproduce the electronic experiments / circuits from the Busch manuals. The digital inputs will need additional pull-down resistors though to work correctly - the Arduino features internal pull-up resistors, but no pull-down resistors. With pull-up resistors, the logic levels of the inputs are inverted. One demonstration of how to connect additional circuitry to the digital outputs is this 555-based sound generator. It uses the old mega emulator, but the same thing will also work with version 2.
2016 - 1 - 30 : OCR Scanning of Programs from the Manuals for Microtronic Emulator, Bugfixes to MULT and DIV Instructions
The Microtronic software library is growing quickly, thanks to the ABBYY Screenshot Reader, which allows me to convert the machine code listings from the Microtronic manuals to text files for the emulator effortlessly. ABBYY Screenshot Reader runs in the Windows tray next to the clock. I can open a text editor, select a rectangular region on the screen with the mouse. The text in that region is input to the OCR, and the recognized text is put into the clipboard. Then I can simply paste it into the text editor via Ctrl-v. The recognition is very accurate; occasionally, I am getting a Q or O instead of a 0, an I instead of a 1, and a P instead of a D, but other than this it is almost perfect (less than 1 percent of such errors). I had also tried out some other open-source and freeware solutions, but none were working as smoothly and perfectly as ABBYY Screenshot Reader. Great program! I should soon have all the programs from the Microtronic manuals in the GitHub.
It was when I tested the (trigonometric) sine calculator from Manual 2 that I realized something was wrong... the results were inaccurate and quite off, not at all what was documented in the Manual. It took me a while to realize that the sine program could only achieve the desired, documented result if the multiplication instruction MULT F0B does something extra, and something not documented - it has to set the extra-registers 0-5 to zero (and perhaps more than those?) This is nowhere mentioned in the manuals, but it is clear that it has to be the case, because the division by six via MOVI 160 and DIV F0C at addresses 17 and 18 will only work properly if MULT F0B at address 15 had set the extra-registers 1 to 5 to zero, which are swapped with the working registers via EXRL F0D at address 16 before the division. Without the extra-registers being cleared as a side-effect of MULT F0B at address 15, it will divide by xxxxx6 instead of 000006.
I have made that change, and found another bug - the manual claims that it is an error if the numerator or denominator is zero in a division, and that carry is set then. This certainly makes sense if the denominator is zero, but not for the numerator. I changed that - dividing zero by x now returns zero, not error, and carry is NOT set. Together with the other changes, I was then getting the documented output for the sine calculator.
It seems that "reverse engineering" is difficult - I would not have expected that, as the Microtronic instruction set is documented very accurately and completely. Still, this level of detail is not enough in order to get a working emulator. So far I found one error, and two critical omissions in the documentation which have to be implemented / fixed in order to get a working emulator.
As always, the changes were uploaded to the GitHub repository. I consider playing Tic Tac Toe and a successful sine calculation another milestone :-)
2016 - 1 - 23 : First Fully Functional Version of Arduino Mega Emulator
The Microtronic Arduino Mega Emulator passed two more milestones today. Load and Save Program via PGM 1 and PGM 2 to SDCard is working now, and I played my first round of Lunar Lander!
I implemented a simple filename editor for save, and a simple directory browser on the LCD display for load. Then, I typed in the Lunar Lander program and saved it (LUNAR.MIC). The file names are DOS 8+3, and CR+LF end-of-line coding, just simple text. That way it is possible to edit and create them on the PC with a simple text editor, save them to SDCard, and load them into the emulator. Trying to get Lunar Lander to work I also uncovered some bugs (as expected), this time in the implementation of the DISP op code, and fixed that. Since Lunar Lander is a big program using most of the 2090's instruction set, I am confident that there are not a lot of remaining bugs to be found in the emulator. Playing Lunar Lander after 33 years again was fun - watch the YouTube video here.
It seems that there is a bug in the SDCard library though. For some reason, the emulator requires a reset before loading another program, i.e., the second call to PGM 1 fails, and a lot of crazy characters appear on the display, after which the Arduino crashes. Something wrong with the memory management? The next two pictures are showing the op-code display, and the register content status page.
So, what's next? I would like to implement some "real" digital outputs next. The Arduino Mega still has plenty of digital IO pins left. Currently, the status of the digital output ports is visualized by the LEDs of the LED module only, as set by the digital output instruction (the FEs / DOT op-code). Connecting the Speech Synthesizer to these ports, or the little transistor oscillator sound module from Microtronic Manual Vol. 2 page 52 will be fun, and would be a good first application for the digital outputs. I need to get some parts from Fry's electronics :-)
2016 - 1 - 20 : Busch 2090 Microtronic Arduino MEGA 2560 Emulator
Ported the emulator to the Arduino Mega 2560 - and here is the YouTube video. Now I have enough SRAM to add the LCD+Keypad shield and SDCard (plus Ethernet) shield. The LCD display can be useful for debugging, i.e., showing the current instruction and PC when a program is running as shown in the above video, or for displaying the realtime contents of the 16 4bit registers (plus the 16 extra registers - it has 2 lines of 16 characters! perfect!)
The SDCard can already be read and written to. Finally, unlimited program memory for potentially ALL the Microtronic programs in the world that have ever been written! Will start putting in Lunar Lander and friends soon.
Please notice that getting the SDCard shield and the LCD+Keypad shield to work in combination requires a trick - disconnect PIN 10. Using Arduino extensions headers as shown does the trick. The headers are required for this setup anyways, as the Ethernet RJ45 female jack is too high to allow another shield on top without extension.
I will update the source code on the GitHub page soon, or, rather, create a new repository for the Mega branch of the emulator.
2016 - 1 - 19 : Busch 2090 Microtronic Arduino Emulator - PGM 3 and PGM 4 Clock Programs implemented
The real time clock of the Microtronic Arduino emulator is now working. This YouTube video demonstrates PGM 3 (set time) and PGM 4 (show time). Notice how the clock keeps running in the background while playing (and losing) two rounds of the Nim game (PGM 7).
2016 - 1 - 18 : Busch 2090 Microtronic Arduino Emulator - Nim Game and EEPROM PGM Storage
Another update and bugfixes to the Microtronic Arduino Emulator. Thanks to Martin Sauter, from whom I got the PGM 7 Nim Game machine code! He retrieved it from his real Microtronic (my Microtronic is still in Hamburg, Germany). See it playing the Nim game with me. Also, I moved the PGM Microtronic ROM programs into the EEPROM of the Arduino. This freed a lot of memory and I am no longer getting the "low memory warning"s during compilation of the emulator. Now, in order to use the emulator, another sketch must be loaded into the Uno first - load PGM-EEPROM.ino first, which stores the PGM examples into EEPROM. The busch2090.ino emulator reads the PGM ROM programs from there, and it won't initialize properly if the EEPROM has not been set up properly by PGM-EEPROM.ino first.
2016 - 1 - 16 : Digital Inputs, Reset Button, and CPU Throttle for Microtronic Emulator
A small update to the Microtronic Arduino emulator. Added a reset button, and digital inputs are now read by the DIN FDx instruction. Also added a CPU throttle potentiometer. Here is another YouTube video.
I tried putting the Lunar Lander code into PGM ROM, but failed, since this requires at least 396 bytes, or even 528 bytes if I use the program as a string method with spaces between instructions (e.g., "F01 501 C00 ") for readability. The Uno only has 2 KBs of SRAM. It is of course possible to type in the Lunar Lander program by hand, but I have currently no way of storing programs (I want to add an SDCard shield). The EEPROM might be perfect for storing one complete memory dump (1 KB), but it is not good enough for multiple big programs. I could reorganize the memory, such that only 12 bits per word were used instead of 32 as currently - but it is still not enough memory.
In fact there is enough PROGMEM / flash memory (32 KBs) to store the Lunar Lander, and even a number of other big programs, but the Arduino cannot access the PROGMEM directly. Rather, one needs to retrieve the PROGMEM content into a string buffer first, and go from there. That string buffer has to be in SRAM, and obviously as long as the longest program (ideally, 1 KB, or, with 12 bit words, at least 768 bytes). I don't have that much SRAM space, though.
The easiest solution is to move forward to the Arduino Mega 2560, which has 4 times more SRAM than the Uno (8 KBs). That will be more than enough space, even with the current Microtronic memory organization, and I can comfortably fit in Lunar Lander and the Nim game then (and probably some more programs). Also, the additional drivers required for the yet-to-add SDCard shield and LCD module will need more memory anyways. So, going with the Mega 2560 seems to be the right thing. I have ordered one. Stay tuned, more to come.
2016 - 1 - 13 : Homebrew Busch Microtronic 2090 Emulator on Arduino Uno R3
Got some time recently to tinker with an Arduino Uno R3. I always wanted to build a Busch Microtronic 2090 Emulator, preferably in hardware. This 4bit educational single board computer was my first machine, on which I learned programming. Here is a first version of the emulator on GitHub, and I also uploaded a YouTube video where you can see it in action.
Compared to the original Microtronic, there are a couple of advantages, e.g., the display has 8 digits instead of 6, and I can use this to indicate the status of the machine. Unlike the original, I have a cursor, indicated by a blinking digit. Another advantage is a real stack (of depth 10 currently) - the original Microtronic could not have nested subroutines, apparently they had a single subroutine program counter return register instead of a real stack.
However, my emulator also has a couple of drawbacks currently, which I am still working on. Save and load to tape / cassette is obviously difficult, and it might make more sense to simply add an SDCARD shield to the Arduino for that. Some other functionality is missing as well. The original Microtronic had digital inputs for hardware projects - I might be able to use the leftover Arduino pins D3 - D0 for that. Also, the reset button of the Arduino kills the Microtronic program memory, so I will have to add a reset button which only clears the Microtronic registers. Moreover, the internal clock is not working yet, and neither are the breakpoint and stepping functions for debugging. And then there is testing and more testing... all the op-codes are implemented, but I haven't checked them all yet. I will certainly find some more bugs when I start putting in Lunar Lander from the manual.
Next, some of the original programs which came with the Microtronic in ROM, e.g., the Nim game (PGM 7), are missing from my version, simply because I don't have a real Microtronic at hand currently, and the program listing for Nim is nowhere to be found in the Busch 2090 manuals. I am hoping somebody out there will send me the code; in the meantime, I can put other programs into ROM, e.g. the lunar lander from the first manual is more fun for PGM 7 anyways.
It would also be cool to hook up the emulator with a Speech Synthesizer - I got this one recently, and can't wait to use it. The original Busch manual mentioned (in 1982?) that a Speech Synthesizer expansion board was under development, but it never got released by Busch. And I still like the idea of connecting a Hitachi HD44780 text display to the Microtronic.
So, plenty of project ideas. Given that the code is on GitHub, perhaps people from the community would like to contribute? Looking forward to hearing from you!
Interestingly, from a performance point of view, it seems that the emulator reaches a similar processing speed as the original! Certain operations will be a lot faster, of course, e.g. the division of 9999 by 1 took 40 seconds on the original... Regarding memory requirements, I am noticing that the Uno is almost full. Increasing the stack depth from currently 10 to 255 entries already results in Arduino warnings regarding code instability during compilation, and they indeed show up at runtime then. So there isn't a lot of room for much more. Seems I am pretty much at the limit with what one can do with a little Uno R3. But then, the current implementation is also not very resourceful, wasting some memory, e.g. using 24 bits per machine word where 12 would have been sufficient, and so on. But then, I didn't want to spend days implementing that either (who has all that time).