The Nibbler: A 4-bit CPU Built With 7400 Logic


Maybe we shouldn’t say “built” since [Steve Chamberlin] hasn’t actually heated up his iron yet. From the finished schematic above that is puzzling at first, until you realize the scope of the project. His Nibbler implements a 4-bit CPU using 7400 logic chips. Because he’s come up with the architecture himself he’s taking a lot of steps to check all of his work before committing to a PCB.

We linked to his category for the project which is still in progress. Most recently he wrote a program to prove that it’ll run on the hardware. That’s a feat considering this is still just a design idea. It was made possible because he wrote a simulator based on the design. The C++ tool simulates data and control buses and features a full set of debugging tools.

Careful testing of the design before the build is the best possible way to go. The simulator and debugging tools will be useful for software development even after the hardware is built. And testing before wiring is a must as these things get out of control quickly in terms of soldering complexity.

[via Dangerous Prototypes]

23 thoughts on “The Nibbler: A 4-bit CPU Built With 7400 Logic

      1. I did actually build it — the processor (on four boards) is ready, and so is the combination programmer’s front panel, diagnostics board and remote testing system (on two boards — the diagnostics are pretty useful). I have schematics for a bunch of other cards and I’ll be building those next.

        The documentation on the web was very lacking, so after I got the first programs running I decided to take some time off to put all of the LaTeX docs on the web and I’m still doing that now. Life (and work) have been sucking up my time in the past few months so it’s slow going. But this was never meant to be a short-term project!

    1. ive been trying to do that
      word length: 4bits
      registers: A-4,B-4,PC-8,C-1
      HEX-name-desc-C1-space used
      #08-#0F-ldi-load next operand into A-8
      #00-lda-load value from memory at AB-1
      #01-sta-store A at address B*C-1
      #02-mov-swap A to B-1
      #03-add-add A to B put into A-1
      #04-sub-subtract A from B put into A-1
      #05-and-and A to B-or A to B-1
      #06-not-not A to B-1
      #07-jmp-jump to address AB if C = 1-1
      something like this, its as simple as i can make it without compromising the functionality
      but it would only be able to access 32 bytes of ram and rest would have to be rom

    1. Karnaugh maps can be somewhat helpful, but not really all that valuable in real life where you’ll have common sub expressions, real gates (not just and/or/not, but also xor, nand, nor, and limited range of number of inputs), devices with multiple gates that you want to share efficiently, and timing requirements.

    1. Certainly, in fact the author is no stranger to such things. Check out his site; he’s built CPUs on FPGAs and CPLDs as well as a larger CPU than this one on wire a wire wrap board.

  1. This is cute. We had to do this for my sophomore EE classes. Each student had to draw up all the K-maps, find the optimal solution, and then demonstrate it. We built everything up on breadboards. Of course, DIP packages were a lot easier to obtain in the 90’s than they are now. But you could still easily build all this by soldering the parts to surfboards and then putting them in breadboards, if you didn’t want the expense of a PCB.

      1. SMD is easier to obtain for certain components and in some cases, cheaper. All too often, places seem to charge more for THT as well. My guess is there is a demand for certain THT parts for legacy repairs when a SMD with a small PCB will work as well.

    1. I’d try to breadboard it first.

      Why? Because if I wire-wrapped it, then had to change *a wire*, sure it’d be the bottom-most one on a pin, and I’d have to undo several to get to it. Breadboarding, it’s easier to rip up and re-do.

      … and hmmm, [Poose], I’m not sure these kids know how to wire-wrap ;-)

    2. I think I still have my wire wrap tools in the basement…old skool rules!

      Seriously, I like this project — there’s no better way to understand how a computer works than by building one. Simulations and FPGAs are nice, but nothing beats playing with actual hardware, where every wire has to be right.

  2. This, exactly this, was the final project for U.C. Berkeley’s CS150 class, Intro to Computer Hardware, when I took it back in 1990. The teaching team had spent the entire semester’s labs showing us how to use 7400 series chips, but the very last two labs were how to use these Xilinx FPGA programmable boards some grad students had made. My team asked the teacher and lab assistant if we could use the Xilinx boards since they were in the lab, and they shrugged and said, ‘why not?’ So we did. Our final project was two Xilinx chips with a half dozen or so other chips on a single breadboard. Every other project in the class was four or five breadboards worth of 7400 series chips with what looked like miles of wire connecting them…..Ours worked…not everyone else’s did.

    But as far as proving it’ll work? It works….it did 23 years ago when our class did it.

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.