It’s no secret Hackaday loves retrocomputers, classic hardware, and vintage tech. Now that we have a great way to present long-form projects, it only makes sense that we combine our loves with a new build. Over the next few months, I’ll be developing a homebrew computer based on the Motorola 68000 CPU, documenting everything along the way, and building a very capable piece of hardware that will end up hosting a few Hackaday webpages. I already have a solid start on the project and will be posting on our front page to discuss the major parts already in progress, and those yet to come.
There are a few reasons we’re taking on this project. With few exceptions, most of the homebrew projects we see are based around 8-bit micros – specifically the 6502 and Z80. 16 and 32-bit CPUs really aren’t that much more difficult to work with, and if we can spearhead a renaissance of the 68k, 65816, or even a 386 (!), we’re all for that. Also, it’s been suggested that we host the Hackaday Retro site on retro hardware, and what better way to do that by documenting a build on our new project hosting site?
That’s a very brief introduction to this project. Let’s take a closer look at what hardware we’ll be using, what software we’ll get running, and what you can do to help.
While this post is only intended to serve as a very broad overview of what this project will become, there are a few details that are pretty much set in stone:
First off, the hardware
You’re probably wondering what kind of hardware this new project will sport, and how I’m planning on quickly turning ideas and schematics into functional circuits. For that, it’s bullet point time:
A backplane, wirewrap design
This computer will be constructed on separate boards for the CPU, RAM, ROM, and any other peripherals we come up with. All the connections will be wire-wrapped. There are a few reasons for this. First, if you have the wirewrap sockets, wire, and tools, it’s a much better and easier way of prototyping a circuit than a bread board. Second, it’s just so classic; the 68000 was released in 1979, and at the time this was the way to create a one-off computer. Yes, we’ll eventually make some PCBs, but you just can’t top a wirewrap design for ease of prototyping.
A Motorola 68000 CPU
Why the 68k? We see a lot of retro and homebrew computers come in on the tip line, but with few exceptions they’re 8-bit CPUs like the 6502, 6809, and Z80. The 68k was the first popular CPU of the 16-bit era that eventually made its way into Amigas, the original Mac, Sega Genesis/Megadrive, a ton of arcade games, and early UNIX workstations. It’s an amazing, elegant chip that’s able to be used as the brains of a real-world computer that does something useful.
Four Megabytes of RAM
Yeah, you read that correctly. Crazy, isn’t it? With a 24-bit address space, the 68k can address up to 16 Megabytes of RAM without bank switching. Compare this to the 64kilobytes of address space of the 6502 and Z80, and it’s easy to see how much more capable the 68k is. Also, with modern SRAMs, it’s a piece of cake to get zero wait states.
A Yamaha V9938 Video Display Processor
Of course this computer will need some sort of video output and for that we’ve gone with the same video chip found in the MSX2 home computer. I expect this to be mostly used in the 80×24 text mode, but this chip also gives us the ability to some very respectable 16-bit graphics.
Compact Flash/IDE hard drive
Maybe a 6581 SID chip?
The ultimate goal of this project is to build a really cool retrocomputer that’s able to host Hackaday’s retro site. It only makes sense to put Ethernet and some form of storage. We’ll need a keyboard, obviously, and no modern retrocomputer would be complete without the sound chip from the Commodore 64.
How About Some Software?
The TL;DR of the software is: “Something UNIX-ish, with a C compiler.”
Putting a 68k C compiler on this computer isn’t hard, but UNIX is. The first UNIX workstations used two 68000 CPUs – one for normal processing, and another to reset the first if a page fault occurred. Putting a *NIX on something without virtual memory or an MMU is of course possible, but that’s a lot of engineering I’d rather not get into. A much better solution would be uCLinux. It’s designed for embedded systems and has ports for just about everything, including the 68000. This, a C compiler, and a text editor are all anyone really needs for a fully functional computer.
Where we’re going from here
This is just the first post in what will eventually become a very, very long build log. It’s also a great test for our new Hackaday Projects site where most of the development will happen. You can check out the current build log right here and of course use the really cool sidebar comment feature to point out better solutions, circuits, and code.
What you can do
If you’d like to help out between now and the next post, have a look at the build logs on Hackaday Projects, leave a comment, shoot me an email if something’s really annoying you. If you’re feeling really ambitious, build a clone! I’m putting all the schematics up on Github. One last thing. I’d like to give a shout out to Apex Electronics for supplying a ton of wire wrap sockets.
Also, I’d really like to do a few videos of me troubleshooting the inevitable problems I’ll have with an in-circuit emulator. If anyone knows where to get a Fluke 9010a, 9000-68000 pod, or has a better idea for an ICE, drop a note in the comments.
Saddle up for the next few posts: going over the mechanical design of the Hackaday 68k, and blinking an LED with a 24-bit address bus.