Build A Barebones 68000

The 68000 chip was ubiquitous in the computing world well past its heyday in the 1980s. It was used as the basis for many PCs and video game consoles, and even in embedded microcontrollers. Now, one of its niche applications is learning about the internal functions of computers. 68000 builds are fairly common when building homebrew computers from scratch, but projects like these can be complicated and quickly get out of hand. This 68000 project, on the other hand, gets the job done with the absolute minimum of parts and really dives into the assembly language programming on these chips. (Google Translate from Spanish)

[osbox68] built this computer by first simulating its operation. Once he was satisfied with that, the next step was to actually build the device. Along with the MC68008 it only uses two other TTL chips, a respectable 32 kilobytes of ram, and additionally supports a serial port and an expansion bus. A few 74-series chips round out the build including a 74HC574 used for debugging support. With a custom PCB to tie everything together, it’s one of the most minimal 68000 builds we’ve seen that still includes everything needed to be completely functional.

After all, including the TTL and 74XX chips the entire circuit board only uses 10 integrated circuits and a few other passive elements for a completely functional retro computer. [osbox68] also includes complete schematics for building a PCB based on these chips to make construction that much easier. Of course, emulating an old microcontroller instead of using TTL components can save a lot of real estate on a PCB especially if you’re using something like an FPGA.

32 thoughts on “Build A Barebones 68000

  1. Nice. I like that he uses the fairly uncommon 68008 because it has an 8 bit bus interface in lieu of the 16 bit interface of the more common 68000 (which requires a pair of ram chips and a pair of proms). I always figured to use a 68020 for the same reason. I have a bucket of them and the required socket, and it can be set up to work with an 8 bit bus and thus work with a single ram and rom chip. But it seems that I just never get around to it. And perhaps never will now that I am having so much fun playing with cute little ARM boards.

    1. A quick look at his schematic shows he’s tied the CPU /AS to /DTACK so all bus cycles are effectively terminated by the CPU instead of needing external logic.
      The only downside to that is that anything hanging off the expansion bus can’t delay the end of the cycle.

  2. I remember taking the top off a ‘new’ TI Desktop computer just to to look at one of the new 68000 processors. The DIP IC was HUGE compared to the 6502 machines I was programming for at the time.

    Now you can do more with a PIC chip!

        1. None in all the usual places, all the 486/Pentium based boards that I remember have upgraded (e.g. are now using AMD Embedded G chips).

          You could always contact Intel, because I’m sure that they still make some for legacy millitary/aerospace applications. But the order would need to be a large one.
          e.g. 20K pcs+ BRAND NEW Intel NT80386DX-33 manufactured in 2007 ( )

      1. Not really. The 8088 and 8086 were barely 16 bit processors which could access 20 bits worth of address space. Nothing written for the 24 bit 80286, nor for the 32 bit 80386, could run on the 8088 / 8086. They were compatible in one direction only.

        The m68008 is a 32 bit processor with a 20 bit address bus that’s 100% compatible with the m68008 version that has 22 bits, or the m68000 with 24, and 100% compatible going forward with the m68020 that has 32 (and mostly compatible in reverse).

        1. So?

          We’re talking about building a simple computer, not using it. I know people built simple 68000 systems back then. I think some built simple 8088 boards back then. Hardware wise, it was about the same level of work.

          Nobody built with later CPUs, I have no idea if there’s a good reason or the window had closed.

          1. Later chips weren’t popular for DIY because of the increased complexity of the systems themselves. The 68k through to the 68030 and the Intel x86 series through to the 286 were the last chips that could be dropped onto a hand-drawn double-sided board with a handful of 7400-series chips to get the system running, and would work with traces in a bus being off by significant margins. It used to be that you could get everything for such a computer from a trip or two down to the local electronics shop. MY first 68k was built entirely from parts I got in a pair of trips to the local Radio Shack (And the second trip was just to pick up the parts that were on back-order)

            Even though the 68010/20/30 and 286/386 were capable of being fitted to a simple board, changes to the instruction set (Particularly the move towards virtual memory and privilege levels) made the chips a bit too complex for most hobbyists to build a system on their own unless they were willing to dedicate significant amounts of time to the hobby.

            But of course, there were also external causes like how free time was becoming a rarer and rarer commodity, the rise of inexpensive home computers, the software market shifting towards closed source software with limited hardware support, and many other factors causing a decline in DIY computer building.

  3. This looks pretty similar to the wire-wrapped 68000 computer that we all built in one of the EE courses I took at Texas A&M back in 1990 or so. Don’t really miss debugging wire wrap boards, though it was kind of cool to be able to build a complex circuit without having to make a PCB or do any soldering.

    1. We were using pre built 68000 boards for the microprocessor class at A&M in 1986 but I liked the 68000 so much I build my own. Wrote a simple monitor for it too.

  4. I once was reading data sheets early on for the 68000 for an application embedded in a much larger computer . I found at least one of the 68000 had hardware disk paging and memory protection layers. (kinda blew the doors off my home 1802 based system).

    In hardware, if a program using complex instruction tried to access an address off its current assigned memory page (get that? assigned memory page in a microprocessor), the offending instruction was actually undone and an interrupt was generated to service the page fault. It restored registers to previous values including the PC to rerun the interrupted instruction. At this time memory was still expensive and disks terminally slow, coupled with finite clock speeds. To have this in hardware would have made an impressively efficient system for desktop computing.

    Today this is nothing, but this was 1980. For the time, this was mainframe computer level stuff. The PC was still a 286.

    As an early assembly language programmer the instruction set was symmetrical with the most extensive set of addressing modes for the time. The reason you could run UNIX was you could write position independent code that could be plopped anywhere in memory without modification and run. (its baby predecessor the 6809 could do the same with 8 bit)

    They used something like 18 running identical software for the Harrier Jet engine controllers.

    This was a majorly under appreciated processor.

    1. You might be thinking of the 68010 there – it had the first memory-management unit in the 68k series; and it could recover from bus faults while the 68000 couldn’t (although some people supposedly did it using two 68000s running in parallel but one slightly behind the other – which is insane).

  5. First paying job was programming a Macintosh Plus, where redesigned its GUI as an embedded kiosk application, and then the Mac communicated to a custom board that had 3 different MC68000 CPUs.

    Rasterization software running on the custom board, written in assembly and C, was ported over to the Mac where my kosk app allowed for previewing what would be laser rasterized to film at about 2000 dpi. The entire team were rather infatuated with MC68000s. Indeed, that was much the sentiment in the whole town – a very engineering-centric municipality. (This was a town where Bill Joy coming in to give a lecture was a big event.)

    One benefit of working closely with the EE guys was they’d let me borrow their MC68000 logic analyzer to use for debugging memory stomping bugs on the Mac. I’d pop the cover off the Mac Plus and connect the logic analyzer onto the 68000. (Yeah, the safety concerns there of exposing the CRT would never fly in any modern workplace, and really shouldn’t have then either – but you know, it was a startup.)

    Ah, the good old 68000 – most fun and pleasant CPU of the 80s.

  6. Ah, the “good Ol’ Days” of computers! Now let’s run a preemptive multitasking OS on it, add a 6502 for some sounds, and I don’t know, maybe a few custom chipsets for a blitter or sprite management? Still miss my Amigas…

    1. A friend changed her hardware to another processor and sent me all her RS Color Computer stuff. The CoCo was based on the 68000 predecessor the 6809. It was 8 bit with 16bit registers and internal operations, it also had most of the addressing modes that later became a major subset of the 68000.

      She included an operating system called OS9 (later to become OS9000 for 68k systems). It was a “real-time, process-based, multitasking, multi-user operating system”. At the time the CoCo had no way to interface to a hard drive. It was simple to write a driver and it could talk to my 5 1/4″, 3.5″ or my SCSI hard drive equally. One of the requirements was position independent code. With the 6809 you could write, with a small overhead, code that could run from any address with byte granularity.

      I even set my XT up as a dumb terminal with a serial port and was able to share a word processing program with my wife on the CoCo with completely different settings, like 64 characters wide vs 80. With only one copy of the code in memory shared.

      Turns out it was almost an exact UNIX clone. A few years late I started working on a full blown UNIX system for a massive phone system for Home Shopping. There was nothing I had to relearn.

      On an “8 bit” processor. The 68000 took every feature of that architecture and turbo charged it.

  7. I have a question for all the homebrew computers: what do you do with it? I know designing and building it and making run is majority of fun but once you have it running the way you like it what then? It just gathers dust? I’m thinking of going RC2014 way but i don’t know what i would do with it after making it i don’t know enough about electronics to make my own boards so i could only solder ready made ones.

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.