Intro to Breadboarding

Way back in the early 1900’s, when hobbyists were just getting started in electronics, experimenters needed a way to quickly get a circuit up and running.  Nearly every kitchen had a small piece of wood for cutting the bread (remember this was before 1928 when sliced bread was invented.)  This piece of wood was about one foot, or so, long by about eight to ten inches wide and about ½” thick.  It was about the perfect size to set up for experimenting with the new electronic circuits.  The aspiring engineer could just take a few nails and hammer them in to the wood and then solder his components right to the nails.  Quick, easy, simple…, and it left your circuit wide open for hooking up meters and other test equipment.  You could also easily extend your circuit by just adding more nails and soldering your components on.  Thus the name for our rapid prototyping system: a breadboard.  The only down side was when Mom went to get her breadboard to slice the bread which just came out of the oven.  She usually disapproved of the shape of her poor cutting board, sometimes vehemently so.

The breadboards we have today are usually not found in the kitchen and are specialized tools meant to allow you to quickly set up new circuits on a temporary basis.  Once you have completed your experiments on the breadboarded circuit, you just pull the components and hook-up wires out of the board and you are ready to begin building your next circuit.  That is what we will be doing in this post.

Take a look at the breadboard drawing shown here.

Each of the squares in our example drawing represents a small hole in the plastic breadboard.  These holes are just the right size to insert a single pin of a DIP IC, or a single lead of a component such as a resistor, diode or capacitor.  Inside each hole is a metal clamp which grabs hold of any lead which is inserted into the hole.  Notice the columns of five holes numbered 1, 2, 3 and so on.  There are two parts to each numbered column.  The first column, numbered 1 consists of two sets of five holes.  These are labeled A through E and F through J.  See how the squares are connected together by small black traces?  In the same way, the metal clamps inside the holes in each set are connected together.  So any pin or lead plugged into one of the columns of holes is electrically connected to any pin or lead plugged into any other hole in that column.  This is how you will be connecting components together in your circuit.

Also, notice that there is a trough down the middle of the breadboard, between the two parts of each column.  This not only separates the two sets of holes physically, it also separates them electrically.  There is no connection between row E and row F of each column.  This trough is exactly 0.3” wide, which is just wide enough to fit a single “narrow” DIP IC across with one set of pins plugged into row E and the opposite set of pins in row F.  See the drawing with the DIP IC plugged in for a better idea of how this looks.

Notice the IC added to the breadboard.

When inserting a DIP IC, you will need to be careful not to bend the pins under the IC and into the trough.  This is like plugging an IC into a socket; use the same precautions.  Once the IC is plugged in like our drawing, each pin is electrically connected to four additional holes for extending the circuit.  For example, look at our drawing; notice that pin 1 of the IC is plugged into hole E3 of the breadboard.  (The pins on a DIP IC are numbered starting just below the notch on the left side of the package and go around the IC counter-clockwise.)  Pin 2 is plugged into hole E4, and so on.  If you wanted to connect a wire to pin 1 of the IC, you would simply plug it into any other hole from A3 through D3, they are all electrically the same.

Finally, most breadboards also include either one or two additional rows of holes above and below the area, which I described above.

See how the power rails are connected horizontally?See how the power rails are connected horizontally?

These are called the Power Rails and are most often used to provide the positive voltage and ground along the entire circuit.  This can make it more convenient to tap into the power anywhere in your circuit that you wish.  Notice that while these are physically grouped in sets of five, the groups are actually connected to each other all the way down the length of the breadboard (as long as you have the short boards – about 3” long, longer breadboards may have each power rail split into two sets).  Many engineers will use the top rail for +5V and the bottom for ground.  If they have two rails on top and two on bottom, they may pick one rail on each side for +5V and the other side for ground.  These rails are often color coded and you may want to pick the red for +5V and the blue or black for ground.  This will make it even easier to tap into power anywhere in your circuit.  This is where the red and black wires from the battery pack on your breadboard will plug in.

 Testing Your Breadboard

To test your breadboard system, take a 330Ω resistor (the resistance is approximate and other close values could be used) and bend both of it’s leads 90˚ to the body of the resistor so that both leads are parallel and point the same way.

Plug one lead of your resistor into the ground power rail and the other lead into hole A1 of the breadboard.  Next, take a green LED, and spread the leads apart 90° from the body of the LED.  Place the LED on the breadboard and mark where to bend the leads, so that they can plug into the breadboard and the LED will be flat against the breadboard.  Plug the cathode lead (negative, the shorter lead) in to hole E1 and the anode lead (positive, the longer lead) into hole F1.  Last, take a short piece of hook-up wire (about 1” long) and strip about ¼” of the insulation off each end.  Plug one end into hole J1 and the other end into the positive rail of the breadboard.  Plug a battery pack into the power bus strips on your breadboard.  The red wire should plug into the +V bus and the black wire should plug into the Ground bus.  Be careful to get the polarity correct or you may burn out the LED (later when you plug in the controller, you may burn that out as well.)  Put fresh AA cells into the battery box and turn the switch to the On position.

A breadboard from another project. Notice the power indicator, like I described in the text.

The LED should burn fairly brightly, you should be able to see it light even in bright indoor lighting.  If your LED does not light up, check the wiring of your battery pack, the red and black power wires going to the rails of your breadboard and the LED, resistor and wire.  If the LED lights, but is dim, replace or recharge your battery.  Start off with freshly charged cells and your set should give you hours of experimenting before the battery needs to be recharged or replaced.

Now, remove the LED and the resistor.  Trim the leads so that the components sit tightly against the surface of the breadboard.  Since you will be trimming the leads of your LED, the cathode will no longer be the shorter lead and you will need to be very careful that you get the polarity of the LED correct.  This will make the circuit more stable, and your test circuit can be used as a power indicator for any future experimenting that you wish to do.  You may even want to put a few dabs of epoxy or hot-glue on the resistor and LED to hold them permanently in place.

A Revelation!

Still working on getting the hang of this blogging stuff.  Just thought of something – guess what?  I don’t HAVE to stay on one project until it is completed.  (All right, you veteran bloggers, you can stop laughing now and get up off the floor; ok, so I can be slow on some things sometimes.)  As an engineer, you will rarely get the chance to work on a single project until completion, and so it will be with this blog too.

Anyway, I do have an update to the Ultimate RISC computer that Professor Jones described.  I started to write the emulation for the Parallax QuickStart board ( .  I really love this little board, and when I add Bean’s Propeller Embedded BASIC (PE-BASIC, it feels kind of like the old small computers from the ’70s.

Well, back in the mid-70s, I wrote an emulator for Bell Labs’ CardIAC computer (   This cardboard computer taught the user how computers work on a very basic level.  Because of the CardIAC, I was light years ahead in understanding machine (and thus assembly) language.  Then, back in the early-90s, I dusted it off and morphed it into a visual CPU simulator for a microprocessor course that I was teaching.  Once more, I was starting to work on it to morph it into this Move computer.  I wanted it to be in “kinda” hardware (the Propeller would output an address and read/write to an external memory or I/O device.

After getting a good start, I decided that I was really doing a “proof of concept” project with this.  I really want to do a complete H/W Move Computer, not just a hardware emulation.  So, I am going to re-do this project:  the first implementation will be a purely software version (written in something with a little more horsepower than PE-BASIC, sorry Bean, but an integer-only language without any string handling or other things, while great for an embedded control system, leaves a bit to be desired for this Move Computer.)

My second implementation will then be a simple 4-bit proof of concept done in SSL (Small-Scale Logic) and MSL (Medium-Scale Logic) ICs, such as the 74LS00 or maybe the 4000 family chips.  This will be followed by an actually usable 16-bit or more computer, again done in SSL and MSL.

Here is the block diagram for my Move Computer:

The Control unit will need to generate 8 signals:

Internal to CPU:

  • MAR_WR (Memory Address Register Write or Load)
  • MDR_WR (Memory Data Register Write or Load)
  • MDR_RD (Memory Data Register Read)
  • PCRADDR_RD (Program Count Register Address – hardwired to all 1s, I.E. FFFF)
  • CTRL_RESET (Reset the binary counter to the micro-instruction step)

And external to CPU

  • WR (Write – for Memory or I/O)
  • RD (Read – for Memory or I/O)
  • PCR_INCR (PCR Increment)


All control signals go to 1
ACCU (Accumulator) = 0000
PCR (Program Count Register) = 0000

The microcode for the CPU will be pretty simple.  The processor will fetch the contents of the source location and then store it in the destination location.

Fetch the contents of the next Source memory location in the program into the MDR.

1)  PCRADDR_RD = 0 & MAR_WR = 0
2)  PCRADDR_RD = 1, MAR_WR = 1
3)  MAR_WR = 0
4)  MAR_WR = 1, PCR_INCR = 0
5)  PCR_INCR = 1, RD = 0
6)  MDR_WR = 0
7)  MDR_WR = 1
8)  RD = 1

Store the contents of the MDR into the next Destination memory location in the program.

1)  PCRADDR_RD = 0 & MAR_WR = 0
2)  PCRADDR_RD = 1, MAR_WR = 1
3)  MAR_WR = 0
4)  MAR_WR = 1, PCR_INCR = 0
5)  PCR_INCR = 1, MDR_RD = 0
6)  WR = 0
7)  WR = 1
8)  MDR_RD = 1

This looks like it will work, next I will test it in software.  If I stay with this microcode, you will notice that it takes exactly 16 steps.  I would not need the CTRL_Reset signal in that case, just running the sequencer clock beyond the 15(Decimal) or 1111b would start it over again without any need to reset the counter.

Well, that seems to be it for the initial design phase, I will implement it in software and present it in the next posting of this project (with other posts between these, of course.)