Part of the reason that retrocomputers are still so popular despite their obsolescence is that it’s possible to understand the entire inner workings of a computer like this, from the transistors all the way up to the software. Comparatively, it will likely be a long time (if ever) before anyone is building a modern computer from discrete components. To illustrate this point, plenty of 8-bit computers are available to either restore from original 80s hardware or to build from kits. And if you’d like to get even deeper into the weeds you can design your own computer including the instruction set completely from the ground up using an FPGA.
This project, called the Moncky project, is a step above the usual 8-bit computer builds as it is actually a 16-bit computer. It is built around an Arty Spartan-7 FPGA dev board running around 20 MHz and has access to 2 x 128 kB dual-port RAM for memory. To access the outside world there is a VGA output, PS/2 capability, SPI, and uses an SD card as a hard drive. This project really shines in the software, though, as the project creator [Kris Demuynck] builds everything from scratch in order to illustrate how everything works for educational purposes, and is currently working on implementing a C compiler to make programming the computer easier.
All of the project files, as well as all of the code, are available on the project’s GitHub page if you’d like to follow along or build on this homebrew 16-bit computer. It’s actually the third iteration of this computer, with the Moncky-1 and Moncky-2 being used to develop the more basic building blocks for this computer. While it’s not the first 16-bit computer we’ve seen implemented on an FPGA, it is one of the few that builds its own RISC instruction set and associated software rather than cloning a known existing processor. We’ve also seen some interesting x86 implementations on an FPGA as well.
Breadboard 8-bit computer builds seem all the rage these days, and with good reason: building your own CPU from the board up using discrete logic chips is a great way to really learn how microprocessors work. Not to mention that it’s an incredible flex. But once you’ve conquered the eight-bit, what do you do? Easy: build a 16-bit computer from 74HC logic chips.
Attentive readers will likely remember this computer’s builder, [Paulo Constantino], from his previous work on 8-bit breadboard computers. As gloriously entropic as that tangled mass of wires was, it must have been a nightmare for [Paulo] to maintain. And so when the time came to upgrade, he wisely chose a more integrated construction method. The construction method is wire-wrapping, with multiple cards plugged into backplane and connected by ribbon cables. The whole card cage is far neater than the previous build, and seems to lend itself to rapid modifications. The top card in the cage acts as a control panel for now; eventually, [Paulo] planes to put a real front panel on the cage to support all the switches and blinkenlights such builds demand. Stretch goals include supporting audio and video and getting the machine online so anyone can log in.
The video below is an overview of the current state of the machine; earlier videos in the playlist cover the design and build in more detail. We hope to see schematics soon, and we’d love to know where to get some of those wire-wrap PCBs for projects of our own.
Slack is either an online collaboration tool, or a religion, depending on who you talk to. Naturally, it’s accessible across all manner of modern platforms, from Windows and MacOS to smartphones. However, some prefer to go further back. At a recent company hackathon, [Yeo Kheng Meng] decided to create a Slack client for Windows 3.1.
Programming for an older OS, in this case, Windows For Workgroups 3.11, requires setting up a viable development environment. Visual C++ 1.52 was pressed into service in this case, being the last version capable of targeting Windows 3.11. The development environment is run on a Windows 2000 virtual machine running on a Mac laptop. This was chosen for its ability to run 16-bit apps, and its Samba compatibility with both Windows 3.11 and Windows 10 and modern Macs.
There were several challenges to face along the way. Old school Windows simply isn’t capable of dealing with HTTPS, necessitating a proxy to handle the exchange of packets with Slack servers. Additionally, memory management was a hassle due to the limits of the 16-bit architecture. Thankfully, an old programming manual from the era was of great help in this regard.
At the end of the hackathon, a usable Slack client was up and running, complete with garish colors from the early Windows era. There’s a few key features missing, such as the ability to resolve user IDs, but overall, the concept works. We’ve seen [Yeo]’s work with this vintage OS before too. Video after the break.
While trying to revive a Donkey Kong Jr arcade board, [Jelmer Bruijn] found himself in the market for an EPROM programmer and became the proud owner of a 1990’s era Dataman S4. Despite its age, it’s a fairly nice tool which allows you to read and write a laundry list of different EPROM types, all without being tied to a computer. The only catch is that a few types of chips need an adapter to work in the Dataman S4, some of which are unsurprisingly no longer available.
After some above and beyond support from the current crew at Dataman set him on the right track, [Jelmer] decided to try his hand at reverse engineering how the old adapters worked so he could build his own. His ultimate goal was to read 40 pin EPROMs on the 32 pin Dataman S4, but in the end he says the information he gathered should be applicable for building other adapters if you ever find yourself in need of such things.
As you might expect, there’s a bit more to the project than a simple pin adapter. [Jelmer] assumed some kind of shift register or latching arrangement would be required to make up for the shortage of pins on the Dataman S4’s ZIF socket. It was just a matter of figuring out how it all went together.
Luckily, [Jelmer] found that the programmer would happily attempt to perform operations on a 16 bit EPROM even though no adapter was physically present. This gave him a chance to probe around with a logic analyzer to figure out what it was trying to accomplish. The trick turned out to be splitting the 16 bit bus into two 8 bit buses which are requested sequentially.
With careful observation, close studying of 16 bit chip datasheets, and much brow furrowing, he was eventually able to come up a design that used five 74xx573 latches and put a schematic together in Eagle. There were a few kinks to iron out when the boards finally arrived, but ultimately the design worked on the first try. [Jelmer] says the same technique should work for 42 pin EPROMs, but as Dataman still actually sell adapters for those he decided not to supply schematics for it.
How do you get 16-bit audio out of an 8-bit microcontroller. We’ll give you a hint: two pins are used. Not helping? Here it comes: two 8-bit DACs PWM outputs are used on this chip, the ATmega1284. One is used for the lower eight bits, the other handles the upper. The two are combined using carefully calculated precision resistor values and the results are beyond what you imagine. This is produced at a bitrate of 44077.135, slightly off from the 44100Hz standard but we challenge you audiophiles to tell the difference. The wave files are served from an SD card read by the chip using the Petit-FatFs library.
There are so many great things about this project. First off, following [Wancheng Zhou’s] example will let anyone with even basic microcontroller skills build a digital audio player for an [Andrew Jackson] and a couple of [Washingtons]. Secondly, those with a medium uC skill level will want to take the idea and implement/debug it for themselves. Bringing it home, [Wancheng] shows how to gauge the quality of the audio output using FFT.
If you didn’t figure it out by the time of year, this is yet another example of a Cornell ECE 4760 final project. Shout out to [Bruce Land] for inspiring awesome projects and requiring extensive documentation of the projects which itself promotes deeper understand all around.
The D16/M is a 16-bit computer built using HCMOS logic chips. It’s a thing of beauty from every angle thanks to the work [John Doran] put into the hobby project. But he didn’t just take pictures of the build and slap them on a webpage. He took the time to publish a remarkable volume of documents for the computer too!
The processor can execute a total of 73 instructions and offers a 100-pin bus for accessing main memory and peripherals. So far he has documented three different peripheral boards, each of which is pluggable thanks to an edge connector that accepts the board. The expansion boards are for system memory, serial communication port, and a clever four-position SD card interface for persistent storage.
Got a question about the system? He wrote a FAQ. Want to learn from his obvious mastery of wire-wrapping? He wrote a wire wrapping tips guide. Like we said, there’s a mountain of documentation and the links to it all are included in his main project page.