Using SMT components with a breadboard:

January 29, 2012 1:42:02 AM CST

I've been using a new technique for breadboarding lately.

side view of the breadboard

It's a fact of life that the electronics industry is moving toward surface-mount components. They have too many advantages to ignore: component density, weight, price, ease of use for pick-and-place robots, plus you don't need to drill and plate a bazillion holes for the leads when you make a circuit board.

Like it or not, it's a good idea for hobbyists to get used to working with them. Trouble is, all the things that make surface-mount parts great for production make them suck for prototyping. They're made for factories that use machines to crank out thousands of copies of the same circuit, not for humans trying to tinker.

Breadboards, meanwhile, are everything surface-mount parts are not. They're made for humans, and they're optimized to make changing a circuit to see what happens as easy as possible.

The picture above shows my way of combining the two.

The technique:

The chips live on breakouts I make myself:

The jumpers are chunks of 30 gauge wire soldered to a pin pulled from a run of pin header. I use a bit of heat-shrink tubing over the joint for strain relief.

The non-pin end of the jumper gets soldered to one of the breakout pads.

The default length for a jumper is 2", a figure worked out on the Goldilocks principle: shorter wires are too short, longer wires are too long. Wires less than 2" don't give you enough reach to be useful. Wires longer than 2" are good in certain places, but if you use them everywhere the assembly gets floppy.

A word on wire strength: you might think of 30 gauge wire as being thin and weak, but putting several short chunks in parallel will surprise you. In groups, they act less like wire and more like thin sheet metal.

The circuit:

This was a toy circuit I built to test the idea.. lots of connections, but simple enough that it wouldn't require debugging.

Running from left to right, the chips are:

  • A 74LVC1G32 OR gate
  • A 74HC14 hex inverter with schmitt-trigger inputs
  • A 74LVC574A eight-bit D-type flip flop

My wiring convention is to use red for power, black for ground, white for input, and blue for output. Yellow is the catch-all color, doing everything that doesn't fall nicely into one of the previous categories.. secondary input for the OR gate, clock and output enable for the '574A.

The '574A is configured as a shift buffer. Flip flop number 7 takes its input from the output of number 6, 6 takes its input from 5, and so on down the row. Those are the white wires running across the breakout. The oddball is flip flop number 0*, which takes input from one of the '14's inverters. That inverter takes input from flip flop number 3.

(* one of the many ways to know when you're talking to a geek: we count things starting from zero, not from one)

Starting from a reset state (all bits low), and assuming that flip flop numbers run 0-7 from left to right, you get the following pattern:

    00000000
    10000000
    11000000
    11100000
    11110000
    01111000
    00111100
    00011110
    00001111
    10000111
    11000011
    11100001
    11110000

Four high bits, then four low bits, then four high ones, etc. It's called an inverting ring buffer, or a 'Johnson buffer'. In this case, it's a 4-bit buffer, because that's where the inverter's input happened to be plugged when I took the picure. Moving it to flip flop 7 would make ther circuit an 8-bit buffer, moving it to flip flop 2 would make it a 3-bit buffer.

Another inverter is configured as a relaxation oscillator using the resistor and capacitor bottom center. It generates the clock signal that makes the '574A do its thing. The remaining pins aren't connected to anything, which is technically a no-no, but got filed under "I'll deal with it if it becomes a problem" and didn't.

The OR gate is there to make things a little more interesting. It controls the oscillator by comparing the clock's output to the signal coming from the pushbutton on the other side of the board:

One of the OR gate's inputs is tied to the switch's pull-up resistor. The other is tied to the clock. The output from the OR gate goes to the timing resistor, which charges the timing capacitor. The clock takes its input from that capacitor.

An OR gate's output is HIGH as long as at least one of its inputs is HIGH, and the switch's pull-up resistor reads HIGH as long as the switch is open. When that happens, the signal from the clock doesn't matter.. HIGH or LOW, the OR gate's output will be the same. The OR gate will charge the timing capacitor to HIGH, then just sit there.

If the timing capacitor is HIGH, the output from the timing inverter (the clock signal) will be LOW. So when the switch is open, the clock remains stuck in the LOW state.

If you close the switch, the pull-up resistor goes LOW. Since the clock is LOW too, the OR gate's output will also go LOW. That allows the timing capacitor to discharge, and when its voltage drops below the inverter's low threshold, the inverter's output will go HIGH. That will send the OR gate's output HIGH, and the whole cycle will start again.

The upshot is that the oscillator only runs while you press the button. The blue LED just left of the switch shows whether the oscillator is running.

Benefits:

I've found that I like building circuits this way more than the traditional way, with DIPs plugged across center of the breadboard. I have more freedom to arrange connections on the board in logical chunks, and I don't have to waste space working around the chip's footprint.

You'll always use one row per pin when you plug a DIP into a breadboard. As often as not, you'll need to put components that connect to the pin on another set of rows, then run jumpers from those rows back to the chip. In effect, every pin you use consumes two rows of breadboard space.

Given that you almost always need a jumper for each pin of an IC anyway, it makes sense to connect those jumpers directly to the IC so they don't waste rows.

The output LEDs are a perfect example:

Each LED takes two rows on the breadboard. For 8 LEDs, that's 16 rows. A DIP version of the '574A would have 10 pins on each side, for a total of 20 more rows.

The chip wouldn't be able to live in the same set of rows as the LEDs because it needs one row per pin, so I'd have to move it down to its own set of rows. A traditional version of this (trivial) circuit would consume 36 rows of the breadboard.

Thing is, a small breadboard like this only has 60 rows. That much of the circuit would fill more than half of the board, and wouldn't leave room for any more chips.

Costs:

There's a lot of front-loaded effort here. Making the jumpers takes time, and chips require many jumpers.

I make them ahead of time, whenever I'm in that "I want to build something but don't want to deal with design problems" mood. It's a good way to keep your hands busy while your mind stays in neutral.

One job is to cut the wire and shrink tubing to length. That goes quickly, and I usually fill a couple of bins with material so I can jump right into soldering when that mood hits. The soldering itself is repetitive, but I balance process efficiency against boredom by doing sets of 16 jumpers at a time. Those go into another bin so I have plenty of jumpers ready when I want to wire up a new chip.

I use pin header because I buy the stuff in lots of 5000. You can also use 3/4" to 1" chunks of 18 gauge copper wire, or .032" copper-clad MIG wire. Those require some extra cutting and cleaning, but they work perfectly well.

Random brain cookies:

Anybody who doesn't cut his speed at the sight of a police car is probably parked.