The first mini project on my journey to my 68k homebrew computer is going to be a minimal implementation consisting only of the following components:
- Terminal interface
Simple right? ROM to store the programs, RAM for working memory, and a terminal interface to type to and read from the system. I’ll use a breadboard to prototype the entire thing but I’m thinking I will have to limit the clock speed to something like 8 or 4 MHz; wiring point to point on a breadboard isn’t exactly a hospitable environment for high frequency signals. I would prefer to wire-wrap the entire thing, kind of like this gorgeous Macintosh prototype but the practice has fallen out of fashion making the supplies rather scarce/expensive.
On a 68k system, memory and peripherals are mapped to the same space. The 24-bit address bus provides 16 MB of memory space, of which the minimal system will use very little of; I settled on 1 MB of ROM and 4 MB of RAM leaving the remaining 11 MB for peripherals and whatever else (so much room for activities). ROM is going to sit between 0x000000 and 0x0FFFFF, RAM between 0x100000 and 0x3FFFF, and the I/O registers somewhere above that. Is this ideal? I’m not sure but I suppose I’ll find out when I start implementing it.
So now for the fun part, picking the actual components! After some cursory searching I settled on the following bits and pieces to put the system together:
- 68010 processor
- 4 x 1 MB 30-pin SIMM RAM modules
- 2 x 512 kB 29F050 flash memory
- 68901 dual UART coupled to a FT232R USB-interface
So why a 68010? Because I found a cheap one! It’s also pin-equivalent to the 680000 with some updates to support virtual memory so for all intents and purposes it’s synonymous, especially for the scope of the minimal implementation. As for the RAM, I decided to go with some 30-pin SIMMs because they can be found anywhere and have decent density. I’ve also always liked the look of the angled sockets; the only challenge will be to find a way to use them with a breadboard. For the ROM I chose two 512 kB flash ICs which have an 8 bit data bus, one for the upper byte and another for the lower byte. Since the 68k doesn’t have a least-significant address bit things are addressed a word (16 bits) at a time. By tying the upper byte flash to address pins [15:8] and the lower byte flash to address pins [7:0] and switching between them using the upper and lower data strobes (UDS/LDS) one can perform byte read/write operations. Finally, I chose the 68901 dual UART simply because it is designed to work as a 68k peripheral by utilizing the same control bus signals. Two serial interface are provided through the IC but I’ll probably just ended up tying one of them to an FTDI USB UART interface.
That’s it for now. In the following posts I will lay out some preliminary schematics and ponder things a little more.
It’s no secret that one of my biggest inspirations is Mr. Steve Wozniak, original Apple co-founder and computer engineer extraordinaire. He helped design my first computer, the venerable Apple IIgs, where I learned from a young age how to program and compute. It had an unquestionably profound impact on my hobbies growing up and my choice of career, but surprisingly enough, it hadn’t crossed my mind how fun and complex of a project it would be to design a computer myself.
It was combination of one of my favorite university classes (computer architecture) and a variety of different homebrew computer projects I’ve run into that encouraged me to think about it a little more seriously. Projects like the Kiwi 68k homebrew computer, 68 Katy, and the MC68000 backplane computer are great examples of modern ventures into classic homebrew computing and have successfully convinced me to attempt my own project.
My first real exposure to development on a Motorola platform was through the 68HC11, an 8-bit microcontroller. It was the platform chosen by my program at the time and it taught me a great deal about assembly programming and electronics. This tied in loosely with my early computing experience on the 65C816/65C02 platforms but I still have a gap in knowledge if I wanted to implement the 68000 used in the projects I had seen. So I bought a couple of books:
The one by Wilcox came highly recommended by savvy 68k homebrewers and it outlines how to build your own 16-bit computer system around the 68000. I grabbed the second book by Triebel and Singh to use a reference for the software development. With these books and a slew of online resources such as the DTACK grounded archives I should have a good start on the project.
Since I would like the computer to be expandable, it seems like a good idea to make it a backplane computer, where the computer sits on a data and address bus shared by all the peripherals in the system. This will mean designing bus arbitration and interrupt decoding logic that I have yet to give serious thought to. Eventually I would like to provide the system with the means to output to a VGA signal, provide stereo sound through the use of a classic esoteric sound IC, and interface with disk and hard drives. There is something very satisfying about the sound of a disk drive stepper motor. Here is a sketch I quickly drew in my logbook of how the system could be laid out:
I would like the chassis to have a graphic LCD that could display a variety of information about the computer and the bus, probably handled by a microcontroller more sophisticated than the homebrew computer itself. Other things I have considered is using the MOSFET-based 74HCxx series for glue logic and the 68HC000 variant of the processor for easier sourcing of parts. If the glue logic gets complicated enough (as I expect it to) then I will also implement a CPLD in VHDL for portions of it. Just thinking about the multidisciplinary facets of this project excites me so much.
I will try not to get ahead of myself, however. If I have learned anything from my past projects (both finished and unfinished) is that I need to take it one step at a time and to not bite off more than I can chew. To pace myself I have decided to keep the scope of my project small at first and expand it as I progress. No backplane, no crazy peripherals, just a simple single board computer capable of running a monitor program through serial. I predict this to be the most exciting
for me yet.