When Worlds Collide: 68008 Bootstrapped By An Arduino Uno


[Peter Bjornx] brings classic microprocessors and modern microcontrollers together with his Arduino bootstrapped 68008 computer. The Motorola 68008 is the 8-bit external bus version of the well-known 68000 (or 68k) microprocessor. A friend gave [Peter] one of these chips, so he built a simple computer around it.

This isn’t one of those clean retrocomputers with every connection carefully planned out and wire wrapped. [Peter’s] created a true hack – a working 68k system on a breadboard created with whatever he had on hand at the time. The real gem of this system is the ROM. [Peter] replaced an EPROM chip with an Arduino.

In the not-so-good-old-days, microprocessors (and many microcontrollers) ran from an external ROM chip. This often was a UV-erasable EPROM. Carefully compiled code was burned into the EPROM with a device programmer. If the code wasn’t perfect, the EPROM had to be pulled and placed under a UV lamp for 20 minutes or so to erase it before it was time to try again. EPROM emulators were available, but they were way too expensive for the hobbyist.

Thankfully those days are far behind us now with the advent of EEPROM and then Flash. [Peter] didn’t want to revisit the past either, so he wrote a simple Arduino sketch which allowed it to act as an EPROM emulator, including address logging via the serial port.

The design still caused [Peter] some headaches, though. His major problem was a classic 68k issue, /DTACK timing. /DTACK or Data Transfer Acknowledge is one of several bus control signals used by the 68k. When the 68k performs a read from the data bus, it waits for /DTACK before it transfers data. The Arduino was too slow to release /DTACK in this case, which caused the 68k to think every read was immediately completed. There is a much clearer explanation of the 68k bus cycles on this Big Mess O Wires page. [Peter’s] solution was simple – a D flip-flop connected to the address strobe took care of the timing issues.

It took quite a bit of tinkering, but the system eventually worked. Peter was able to run the 68008 from its reset vector into a simple loop using the Arduino. It’s only fitting that the 68k program loaded by the Arduino was an LED blinker, everyone’s favorite hardware Hello World.

Thanks [Robert!]

23 thoughts on “When Worlds Collide: 68008 Bootstrapped By An Arduino Uno

  1. Not that it changes it’s HaD worthiness, but I’d consider this a kludge, not a hack. You’re not really repurposing anything for which it wasn’t intended.

    (Yeah, semantics, I know. You can call a spade a spade, but calling it a fork doesn’t make much sense).

  2. Seems like kind of the long way around. What’s wrong with an 8-bit FLASH memory? Microchip has some nice ones.

    I agree about DTACK timing being a pain, but I always thought the annoying part about the 68K boot process was the need to temporarily replace the NMI and RESET interrupt vectors in low RAM with the values stored in boot ROM. IIRC, this involved some fancy footwork with the chip enables for said RAM and ROM and counting the number (8?) of address strobes with a PLD.

    1. Isn’t the whole point that the Arduino flash (and thus the EEPROM that it’s emulating) can be re-uploaded in a few seconds without having to remove anything?

      And yeah, I’d definitely agree that this is a hack, he’s re-purposing an Arduino as a convenient USB-programmable EEPROM emulator to speed up development. There are all sorts of cases where this type of hack comes in handy.

      1. Well…I would have built a FLASH programmer out of the Arduino, and used a socket on the 68K, but that’s just me. I agree that being able to download the boot ROM code into the Arduino is kinda neat.

  3. Considering that 68000 is still an active CPU architecture, this “collision of worlds” is more like “a casual encounter between two old friends”

    but hey “collision of worlds” will get more clicks apparently

  4. It’s nice to see somebody using a classic computer “trick” … back in the late 1980s Harris had a supermini w/8 68030 processors that used a 68000 as a “front panel”, and even earlier than that DEC used a PDP-8 (and later an -11 I think) as the front end for one of the PDP-10 models.

  5. In response to the people mocking the use of an arduino in this project I’d like to point out that I only chose the arduino because we have some lying around at the hackerspace, besides that, I used a flash ROM in a previous project (a 6502 computer that never really worked) and I found their programming unlock algorithm quite annoying ( I eventually got it to work though ) and swapping ROM chips all the time (especially in a breadboard wire mess) isn’t fun either.

    1. “I used a flash ROM in a previous project (a 6502 computer that never really worked) and I found their programming unlock algorithm quite annoying”.

      Did you get caught by the 6502s read before write issue? I think that one got me once back in the 90s.

  6. I can’t believe that with an 60000-based computer designed from the ground up, dealing with the intricacies of DTACK, that no one has mentioned the original solution found by Hal Hardenbergh back in 1981: “DTACK Grounded”! According to him, grounding that pin makes it a much simpler part to use. DTACK only existed for very complex asychronous handshaking, since in 1979 Motorola thought they were building a very expensive minicomputer chip. Now he was talking about the 68000, not the 68008, but apparently it’s the same principle.

    From issue #1 of his newsletter (http://www.easy68k.com/paulrsm/dg/dg01.htm)
    ” it is possible to build very simple systems using the 68000 if you ground DTACK. Naturally, you can then tie BERR to +5, since the data is always acknowledged. Now you have a SYNCHRONOUS data bus, and you can throw out about 93% of Motorola’s application information on the 68000″

    Or in more detail (“page 2” of Issue #6, http://www.easy68k.com/paulrsm/dg/dg06.htm),

    HOW TO BUILD A REALLY SIMPLE 68000 SYSTEM: You may have noticed that the 68000 comes in a very large 64 pin package. Even discounting the four pins used for power and ground, that leaves 60 active pins to worry about. Here is how we go about simplifying things:

    Tie pin 10 FIRMLY to ground. This converts the microprocessor from a HORRENDOUSLY COMPLICATED asynchronous bus device to a NICE TAME synchronous device, just like a 6502.
    Tie the following Pins to +5: 12, 13, 21, 22, 23, 24 and 25.
    Ignore the following pins: 11, 19, 20, 26, 27 and 28.
    Tie pins 17 and 18 together and use them as the RESET input. This in effect reduces the pin count by one.

    After making the changes above, we have eliminated 15 pins. So we are down to 45 active pins and we can STILL address 16.7 megabytes (we have just described the production DTACK GROUNDED boards)!

    THAT’S NOT SIMPLE ENOUGH? You want to drop a small, VERY SMART circuit board into an intelligent instrument? Is 32K bytes enough for ROM, RAM and I/O? Then ignore pins 43, 44, 45, 46, 47, 48, 50, 51 and 52. Now you are down to 36 active pins, about the same as a 6502 or Z80! By the way, with only 32K you will not need address buffers or data buffers. Our original prototype 68000 board didn’t use these buffers and it worked fine. That, sir, is a SIMPLE 68000 system.
    (end quote)

    I believe the DTACK Grounded archive at http://www.easy68k.com/paulrsm/dg/ has been mentioned on Hackaday before.

    Would that idea have simplified his design?

Leave a Reply

Please be kind and respectful to help make the comments section excellent. (Comment Policy)

This site uses Akismet to reduce spam. Learn how your comment data is processed.