4
\$\begingroup\$

Im trying to learn more about the depths of computer design, I;m talking about CPU design. Down to the very very low level of Computer Organization.

I took a few EE (I did a CS degree so...) classes in college, but it was mostly Introduction and Logic gates (which I do understand). However it never went much further than that. Im not looking to build a Computer from scratch or anything, but what would be the most SIMPLE starting point for someone interested in this. I was thinking maybe a 4 bit adder? or something similar? I have done a bit of electronics work, so Soldering and such I know the basics (as well as components).

Ideas/Suggestions for an Intro project? Or some documentation would be super helpful? a few people recommended this book: Elements of Computing Systems

but I do not know how much "hands on" it would be. When I talk simple Im talking about a simple adder using LEDS for the output or something similar.

Im super interested in this but don't know where to start. I have the third edition of Computer Organization and Design, but it doesn't have much hands on stuff.

edit: The depths of my knowledge is basically basic logic gates, I'll need to go back and refresh myself but I do understand adders and such (virtually) but I wouldn't know how to implement them on a breadboard (or any of the hardware parts of it).

edit2: Maybe something similar to this: http://projects.coobird.net/build/building_adder.html

\$\endgroup\$
3
  • 1
    \$\begingroup\$ Sounds to me like you're answering your own question in the edit2. \$\endgroup\$
    – Arturo Gurrola
    Jun 30, 2011 at 18:37
  • \$\begingroup\$ there are many EE courses that teaches at the gatelevel and upwards. a CPU is simple but needs higher-level concepts than gates, so someway or another you need the knowledge you get through those courses! maybe the open courses at MIT's webpage, or if you live close to your college maybe sneak in or check their curriculum? there are many things to learn apart from the ALU even when doing the "school book" RISC cpu. \$\endgroup\$
    – Bjorn Wesen
    Jun 30, 2011 at 21:46
  • \$\begingroup\$ It's easy to overlook: a detailed example, showing a pipelined CPU built out of TTL logic gate chips, is hidden in an appendix of "Computer Organization and Design" by David A. Patterson and John L. Hennessy. \$\endgroup\$
    – davidcary
    Aug 1, 2011 at 12:53

4 Answers 4

Reset to default
6
\$\begingroup\$

I'm not sure how far you want to go with this, but I'm afraid you may become frustrated when you find out how complex your design may become if you want it do something useful, no matter how nice and comprehensive it looked when you started.
Therefore I'm back with the suggestion to your previous question: the FPGA. There are complete so-called "soft processor" designs available free, but you can also build your own, starting from a 2-bit full adder if you want. (And that is what you want if you still have to learn VHDL.) Every FPGA manufacturer has development boards for its products, and there are also third-party boards, with a choice of on-board peripherals, like LEDs, character LCD, buttons, etc.

\$\endgroup\$
1
  • \$\begingroup\$ It's more of a side hobby thing, I want to start out at the MOST MOST basic, like a simple 4 bit adder or something. I don't even need a LCD or anything, maybe just some simple LEDS that denote what was added (in binary)......would be a great first start for me. \$\endgroup\$
    – user3073
    Jun 30, 2011 at 17:46
4
\$\begingroup\$

You wont get very far with just gates, but by all means, conquer the adder, as you mention, in order to satisfy yourself that combinations of gates can accomplish more complicated tasks.

As for where to go from there, it will be easier for you if you begin to think of things in a more integrated way than mere gates; you will actually have a better grasp at the next stage thinking in terms of multiplexers, registers, buffers, arithmetic units, counters and the like. I don't think anyone who only understands gates could look at the gate-level representation of even an 8-bit CPU and immediately know what it does.

So, the next step would probably be to take on sequential logic and state machines. Elevator and traffic light controllers are reasonable problem domains for custom straight-up state machines, even though today, these problems would almost certainly be done with microcontrollers. Even a toy problem state machine like a traffic light controller will give you a feel for sequential digital control circuits.

Once you're confident about sequential logic, it's a short step to realizing that you can connect a bunch of registers, an ALU, and some memory, and then build a state machine that can sequence operations move data values between them. Early 8-bit CPUs weren't much more than this. Some people have success constructing this level of device from 74xx MSI devices.

Beyond that point you would almost certainly be better off working with FPGAs and writing VHDL, for two reasons. One reason is that even rolling your own 8-bit CPU, you'd find that an inordinate amount of wiring is involved, and it only gets worse as complexity goes up; it becomes time consuming and labor intensive. The other reason is, with that much wiring there are bound to be mistakes. It's much faster and easier to edit and recompile than it is to re-wire. With an FPGA, you could take on more complicated CPU features like instruction pipelines and floating point math units, or add video generation, or other complex peripherals.

\$\endgroup\$
4
\$\begingroup\$

For "hands one" experience with digital logic, perhaps you might like one of these projects:

  • electronic dice: a counter that rapidly counts when you hold in the button, then holds that count indefinitely when you release the button, some circuit that turns on 1 to 6 LEDs in each of the simulated dice faces (requires 7 LEDs per face), and a few gates that translate from one to the other.
  • miniature traffic lights: 4 red, 4 bluegreen, and 4 yellow LEDs (for each of 4 directions), with a digital counter as a timer. Optional extra complexity: "push to walk" buttons.
  • miniature garage opener: limit switches at the top and bottom; light beam sensor to detect things standing in the doorway; a button on the wall for people to tell it to move; and a motor that goes pulls the door up or down.
  • electronic lock: 5 or so buttons on top; it pulls the solenoid (for half a second) unlocking the box only when the right combination is punched in. Optional extra complexity: allow the combination to be changed by only pushing buttons, without physical rewiring.

You could build any one of these projects on a breadboard, out of discrete logic gates (i.e., 4000 series chips or 74HC00 series chips), some LEDs and their current-limit resistors, a 5 V power supply, and an oscillator.

"Microprocessor Design" is a rough draft of a book on how to design microprocessors out of things like adders, FSMs, lookup tables, etc.

"Digital Circuits" is a rough draft of a book that discusses how to build adders, FSMs, lookup tables, etc. out of individual digital logic gates.

In principle, those Wikibooks should explain how to build such projects -- could you help us find and fix any gaps that leave out some critical detail?

\$\endgroup\$
0
\$\begingroup\$

Another suggestion would be to simulate the circuits. I'm a bit out of current status, but believe you could download digital circuit simulators freely (or at least cheaply). Once you gained confidence from one or a few actual physical circuits it starts getting tedious to solder things together. On the simulation, soldering turns into simply drawing lines between components. Maybe someone more knowledgeable can suggest one or a few software packages?

This is an early example of a simulator: https://en.wikipedia.org/wiki/CARDboard_Illustrative_Aid_to_Computation

\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge that you have read and understand our privacy policy and code of conduct.