The Mite is a simple single-board computer that I designed and built, based on the 65C02 processor. This is essentially the processor that powered the microcomputers of my youth, the ones on which I learned to program -- computers of the late 1970's and early 1980's like the Commodore PET, the Apple II, and the BBC Micro. The difference is that in the 1970s, the original 6502 was based on NMOS technology; the 65C02 is a CMOS implementation that is much more energy-efficient and can run considerably faster.
I chose the name "Mite" to signal that it was small and to express my ambivalence about whether it would actually work. I also liked the idea that the name perhaps foreshadows further designs -- the Mote, say, or the Mate (or even the Mute and the Mete).
If you are interested in these things, there's an amazing collection of resources available on 6502.org that will tell you anything you might need to know about how to design and build anything around a 6502, and a tremendously supportive community of hobbyists in the discussion forum there who are eager to help out new folks. You'll find Garth Wilson's invaluable 6502 Primer there, and that's absolutely the place to start. The design of the Mite has little (yet) that's especially original or unique to distinguish it from the many designs that you'll find via that site such as Grant Searle's minimal design.
I've always been a software person; hardware is not my forte at all, which is partly why I embarked on this project in the first place. It's a voyage of discovery, for sure, even though, from a technical perspective, nothing I'm doing is particularly difficult.
The primary elements of the design are a 65C02 clocked at 4MHz, with 32KB of SRAM and 32KB of EEPROM (although some of the ROM space is masked by I/O). The base system has a 6551 ACIA for RS232 serial communication, and two 6522 VIAs for more flexible input and output. The current version also supports PS/2 keyboard input decoded by an ATtiny26 microcontroller, high-resolution video through an RA8875 daughtercard interfaced via SPI, and mass storage on an SD card, also interfaced through SPI. Here is the full parts list:
Here is a full list of parts. Well, almost full: I don't have the 65C51 on there because they are no longer made (WDC does make one but it has a bug in it that they seem to have no interest in fixing, so I sourced mine as used parts) nor the AT28HC256 (since through-hole versions seem hard to come by individually via regular suppliers). I may have left off other items by mistake. I sourced these parts from Mouser, but Jameco, Mouser, and Digikey are all good sources of parts.
For the first couple of years of its life, the Mite was on a solderless breadboard. (Yes, years. I work slowly.) Eventually, I wanted a more solid platform and created a wire-wrap prototype, and, a couple of years later, a PCB. The breadboard version used 74xx logic for address decoding but PCB and WW versions the GAL instead, which gives me a much better decoding with a more compact footprint (and has support for the planned 9918A video processor). On the solderless breadboard, the Mite ran at 2MHz; the current board is running at 4MHz (and will probably run much faster; the lowest-rated part is the 6551, but if one doesn't need serial I/O>, then it should run at up to 14MHz).
After many years of deferred promises, I finally have schematics here. This schematic is for the V1.1 PCB; V1.0 had a couple of bugs. As I write this page, I'm waiting for my first set of V1.1 boards to arrive, but I'm confident that it'll be bug-free. (Hilarious, no? I'll update things if it turns out that I've made another bone-headed error.)
As an added bonus: gerbers! And if you were actually trying to build one yourself, you would also need a ROM image, the JEDEC file to program the GAL, and the firmware for the ATTiny26 to read the keyboard.
If you REALLY want to mess around, how about the Kicad files?
As the hardware reaches each next stage of evolution, my attention shifts to the software (and then back again). I first wrote a simple monitor for the Mite in 6502 assembly language, which I can use to examine and change memory, enter programs, and run them. It includes a disassembler for the 65C02 (although no assembler; code is cross-assembled from my laptop). Most usefully, I developed and incorporated an implementation of XMODEM within the monitor which let me upload programs from my laptop (since there was no local long-term storage on the Mite at that point). Writing so much code in assembly language involves a process of unlearning lots of automated patterns from high level languages that's really quite enjoyable.
I wrote an ANS-ish implementation of FORTH, also in 6502 assembly language. (ANS-ish means that, where in doubt, it's compatible with the ANS standard, and that as I continue to work on it, it is asymptotically approaching that spec.) I extended it to include an implementation of the SPI protocol (bit-banged through a 6522 VIA) and of the FAT16 filesystem, which lets me read and write to microSD cards. The machine boots into a simple disk manager program which is actually FORTH in disguise and supports a basic command linen for reading and manipulating files and loading and running executable images. Other programs can call into the FORTH ROM if they want to access mass storage.
The programs I rely on principally are FORTH, a screen editor, and a standalone implementation of YMODEM for file transfers, although it is easier to just swap the micro-SD card between the Mite and some other computer. I have been working on an interactive assembler and disassembler hosted directly on the computer, although it is only partially complete so far. There are also bits and pieces written towards a Pascal compiler.
There is a version of MS Basic running (not in ROM, but loading from the SD card); I may at some point try to get BBC Basic running.
For software development and cross-assembling on my Mac, I use the xa cross-assembler (I've made some use of ca65, but have yet to port cc65). I've made extensive use of the Symon 6502 simulator, which has a compatible memory map to the early Mite and support, in recent updates, for 65C02 opcodes. Before the Mite became self-contained, I used Serial as my terminal program.
The github repository for my monitor is at https://github.com/dourish/mitemon, while the Forth system is at https://github.com/dourish/secnd.
Future plans include proper IRQ support, a real (and faster) SPU bus, video on the processor bus, a more compact layout, a case, large files and directories, more language support, a pony, ...
There are some videos showing various stages of the project on YouTube. And some photos:
