I don’t like to solder. Nor am I very good at it, despite having soldered loads of boards. The temperamental solder never seems to flow where I want it. Surface-mount soldering in particular used to scare me enough that I didn’t even attempt it. A few years back, I gave Wired my opinion that surface mount chips are out of reach for non-professionals, or at least for anyone without advanced skills and special equipment.

Since then I’ve changed my outlook, and I now believe that successful soldering is primarily a matter of self-confidence. The only soldering project you’re 100% guaranteed not to complete is the one you don’t attempt. Sure, you might mess things up horribly, but you probably won’t. And even if you do make a mess so awful that it can’t be salvaged, what’s the worst that can happen? You’ll lose a few dollars worth of parts, but gain valuable practical experience. Consider it the cost of your soldering education.

I arrived at this conclusion after some reflection about my own soldering track record. I promise you, I am not a very skilled solder technician, and yet in all of the many boards I’ve assembled with countless hours of sweat, tears, and swearing:

• I have never destroyed a part
• I have never failed to get the board working

Some day I’ll screw up and ruin a part or a board, but the fact remains that the biggest thing holding me back from more complex soldering projects was not any particular skill or tool, but just the confidence to attempt the project in the first place.

 

BMOW Soldering Q&A

There are tons of great tutorials on the web about the mechanics of soldering, like how to bring the iron and the solder to the joint, and how to drag-solder SMD parts, so I won’t discuss that. Instead, I’d like to share some ideas about my overall approach to soldering, in the hopes that it may help others.

 

Soldering: Now With Undo!

Q: How can I prevent making mistakes when I’m soldering?

You can’t. I used to believe that soldering had to be done perfectly on the first attempt, and mistakes were fatal. Maybe I was vaguely aware of some techniques to fix mistakes, but assumed they were “advanced” techniques that didn’t apply to me. Nothing could be further from the truth! You wouldn’t expect to type a long document on a keyboard without a backspace key, and making and fixing dozens of typos is a normal part of the process. Soldering is just the same. Even on a small board, I normally make five or so soldering mistakes like bridges or misaligned parts, but I’m able to fix them quickly and move on.

Q: So how can I fix mistakes?

Solder wick (desoldering braid) is your friend. Got solder where it shouldn’t be, or too much solder on a joint? Lay the braid on top of the solder you want to remove, then press down on the braid with your iron. The excess solder will be sucked right into the braid. If you’re not soldering with solder wick, then your keyboard doesn’t have a backspace key. Get some.

Flux is even more useful than solder wick. Your solder may have some flux in the core already, but trust me, you need more. I use a flux pen that works just like a magic marker, enabling me to paint flux easily on to any joint or pad. Got a solder bridge between two chip pins? Apply some flux, then touch the pins briefly with the iron, and the bridge will often disappear. Got clumpy solder that doesn’t seem to want to flow where it should? Add more flux and reheat. Still not working? Add more flux. Then add still more. Flux fixes practically anything.

Q: I want a nice, professional-looking board. Won’t all that fixing look messy?

Yes, your board will probably look like crap, but it’s not a beauty contest. Let go of the idea that the board should look pretty. The only important question is whether it works.

Q: What if I make a mistake that I can’t fix?

Whenever I’m assembling a board, I always buy enough parts to build two of them. That way I’m less nervous about screwing up the board, because I can always trash it and try again with the second board if I make a huge mistake.

Before you trash a failed board, though, give it some extra effort in the attempt to fix it, and don’t be shy about it. Solder on some jumper wires. Burn things. Use a hammer. If you break it, you’re no worse off, but you’ll have gained more experience. Then try again with board number two.

 

Small Doesn’t Mean Difficult

Q: Some of those SMD parts are awfully small– those can’t really be hand-soldered with an iron, can they?

Yes, they can, easily. The surface tension of molten solder naturally makes it flow where it should, and soldermask deters it from flowing where it shouldn’t, even for very small parts. Mistakes are easy to fix with soldering wick or flux.

Q: OK, but what about those really tiny parts, with like 0.5 mm pin spacing?

Yes, those too. Easily.

Q: What about those plastic ribbon connectors on LCD screens, with the tiny metal contacts?

Those are even easier.

Q: But what about QFN parts that don’t even have exposed pins?

You can hand-solder those too, using an iron, by tinning all the pads on the board first. A hot-air tool makes it easier.

 

It’s Not About The Tools

Q: What do I need in order to do surface-mount soldering?

Not much beyond what you already have, probably. A regular iron with a regular tip is fine. I use the chisel tip that came with my iron, which is several times larger than the pins on the chips I’m soldering. It’s fine if the tip is larger than the pins, because you’re not going to do pin-by-pin soldering of SMD chips. In fact, for all but the largest SMD packages, the iron tip will always be larger than the pins.

Other essential ingredients:

• Flux. Use a flux pen, flux in a jar, or whatever other form works best for you. Flux everything liberally before soldering. Rule #1: If you’re having difficulty soldering a part, you need to add more flux. If that fails, refer to rule #1.
• Magnifier. Most SMD joints will be too small to see clearly with the naked eye. To inspect finished joints for tiny solder bridges or other defects, you’ll need something to magnify them at least 3x and preferably 10x. I use a cheap 10x loupe, which is like a monocle with a magnifying lens. USB microscopes also work well if you want something fancier.
• Tweezers. You need something to maneuver those little parts into place, and hold them there while you solder them. You’re hands aren’t going to cut it.
• Drug-Free Bloodstream. Your experience may be different, but I can’t do fine pitch SMD work within a few hours of drinking coffee. Even tiny amounts of hand twitching make it nearly impossible to align parts with sub-millimeter accuracy.

 

Circuit Debugging Is Fun

Q: How can I make troubleshooting easier when assembling a board?

Don’t assemble the entire board in one pass. I always assemble boards one functional section at a time, and test that section as much as possible before beginning the next one. This greatly reduces the number of possible causes that must be investigated if a problem is discovered.

The first section on nearly every board is the power section. Solder in the battery or power jack, voltage regulator, and other related parts. Next, measure the resistance between power and ground. Don’t just perform a continuity check, but actually measure the resistance. For most small electronics projects, it should be unmeasurable, or else in the megaohm range. If it’s below about 10K ohms, then you may have a very small solder bridge somewhere. If it’s zero ohms, then you have a dead short between power and ground, or a chip that’s soldered in backwards or something.

If the resistance checks OK, then turn on the power and measure the voltage on all the VCC pins. If it’s not what you expected then stop, and don’t proceed with further assembly until you’ve first fixed the power problem.

For microcontroller projects, I normally add the microcontroller next, as well as the programming header and any other components required to get the MCU running. Connecting with the external programmer and reading the device ID or fuses is a good way to verify that the MCU is working properly.

The remaining functional sections vary greatly depending on the project, but often there’s an LCD or other info display that can be tested first, and then buttons or other input hardware. After each section, recheck the resistance between power and ground before turning the device on, since each new part added brings a risk of an accidental short-circuit.

Q: I assembled the board, and the soldering all looks good, but it doesn’t work. What can I do?

In my experience, failures are almost always caused by short circuits (usually due to solder bridges) or open circuits (cold solder joints, or too little solder).

Short circuits are easier to diagnose, since they can usually be seen under magnification if you look in the right spot. Use your multimeter in continuity check mode, and test for continuity between every signal you suspect has a problem and its neighbors. If you’re fairly certain there’s a short, but can’t find it, then test again by measuring the actual signal-to-signal resistance instead of continuity check mode. For some types of signals, even a very small solder bridge with a resistance of 10K+ ohms can be enough to break the circuit, and those typically won’t produce a beep when in continuity check mode.

If that fails, visually reinspect every chip pin for possible hairline solder bridges to its neighbors, as well as bridges between pins and vias. If you see anything that looks like it could possibly be a short, then apply some flux and reheat the joint to clean it up.

Open circuits are a bit trickier, since they can’t be conclusively diagnosed just by looking at them. If the solder in a joint looks cloudy, or there’s very little solder, then check the continuity with your multimeter to make sure everything’s connected as it should be. When checking continuity to a chip pin, it’s important to touch the probe to the actual pin, and not to the pad underneath the pin, since the pin-to-pad joint itself is often a point of failure.

As with testing for shorts, it may be useful to test open circuits by measuring the actual resistance instead of merely performing a continuity check. If two points that should be connected measure 1K ohm of resistance between them, it may be enough to elicit a continuity check beep, but something is clearly wrong.

If all the continuity checking and resistance measuring fails to identify the problem, then you’ll need to perform live circuit debugging. Turn on the power, and start measuring voltages at various places in the circuit, verifying that the voltages are as expected. For DC voltages, this is easily done with a multimeter. For something like a clock signal with a 50% duty cycle, you can still use a multimeter, and expect the measured voltage to be 50% of the high-t0-low voltage swing of the clock.

For other time-varying signals and data signals, you will probably need to use an oscilloscope to observe what’s happening. A few common symptoms and their causes are:

• stuck at VCC or ground: short-circuit to power, ground, or another DC signal, or an unconnected signal.
• stuck at some middle voltage: contention (two different sources attempting to drive the signal), or an unconnected signal (open circuit).
• sort-of correct-looking signal, but reduced in amplitude and shifted far towards VCC or ground: hairline short-circuit to power, ground, or another DC signal.
• random wavy noise pattern: unconnected signal (open circuit).

If all else fails, then you may need to cut traces or remove parts from the board in order to isolate the problem. Remember, if it’s already broken then you’re unlikely to make matters worse, so don’t be shy about getting in there and banging away to debug the board.

 

Read 7 comments and join the conversation 

What do small scale open hardware projects do about RF interference compliance testing? I’ve been looking into selling assembled versions of a few of my projects like the Backwoods Logger, to people without the time or skill to build their own. If I’m lucky, I might sell a few hundred such units, through a dedicated store web site, or just a page attached to the BMOW blog here. I would want to do this right, which means complying with any applicable certification requirements for consumer electronic devices. In the United Sates, that means FCC Part 15.

After searching for information about FCC requirements, it appears that anything operating at frequencies above 9 kHz requires FCC verification testing, which costs several thousand dollars. This is true for both intentional radiators (WiFi modules, Bluetooth, remote controls, etc)  and unintentional radiators whose emissions are accidental. By that rule, everything from an Arduino clone to a data logger to a robot control board requires FCC testing. You don’t actually need an FCC ID, but you do need to perform the testing and keep your certificate of compliance on file, should the FCC ever ask for it. And your product must include a phrase like “This product complies with FCC requirements for a Class B device.”

I looked for information about how the “major” hobby electronics vendors handled FCC testing, and found that this is a topic no one wants to talk about. It’s like a dark family secret. Discussion threads get responses like “we can’t legally comment on this” and are then locked. Reading between the lines, it seems that while FCC testing is required for virtually every electronic board and module, almost no one actually does it. But because the penalties for non-compliance are worse if you knowingly sell an untested electronic product, nobody is willing to admit that they didn’t perform the tests, or even discuss the subject at all. I’m not going to name any specific vendors, but if you have any circuit boards on your desk that contain a microcontroller or USB chip or other interesting gizmos, check to see if it was FCC tested.

Have you ever sold an electronic product that you designed yourself? Have you ever taken a product through FCC compliance testing? What was your experience? Leave your feedback in the comments.

Read 13 comments and join the conversation 

Exciting news on the Classic Macintosh Floppy Disk Emulator: I successfully transferred two sectors from a virtual 800K floppy disk, and used it to boot a Mac Plus to the “Happy Mac” screen. This proves that all the trickiest parts are working: the drive RPM speed feedback signal, emulation of drive registers, GCR data encoding, correct sector headers / footers / checksums, and modulation of the read sense line to mimic magnetic disk media. Woohoo!

There’s not enough memory to hold a full disk image, so the Mac won’t boot all the way to the Finder yet. More work is needed to load a track’s worth of data at a time and buffer it in RAM, using the Mac’s drive step command to trigger loading of a new track. And of course there’s still the whole question of floppy disk writes in addition to reads… but now that the initial hurdle of basic data transfer has been cleared, I feel much more optimistic about the remaining work.

As described in my previous post, a CPLD implements all the timing-sensitive functions, and generates the signals that are sent to the Mac. It creates an RPM feedback square wave whose frequency varies according to the current track of the emulated floppy drive, in order to mimic the variable-speed behavior of the Mac 800K drive mechanism. It also ensures bits are sent at exactly 2 microsecond intervals, using the transition encoding method of a real drive. This method indicates a logical 1 as a high-to-low transition during a 2 microsecond bit window, and a logical 0 as no high-to-low transition during the window.

To the CPLD setup, I added an ATmega168 AVR microcontroller with 16KB of program Flash memory and 1KB of RAM. The AVR stores two sectors worth of pre-encoded GCR data in Flash memory, and passes it to the CPLD one byte at a time, using ready/ack control signaling. If the AVR doesn’t signal its readiness when the CPLD needs a new byte, then the CPLD will automatically insert a sync byte. This makes it possible to emulate the empty space between sectors on a floppy disk without actually storing or transferring the sync bytes that appear in the inter-sector space. The eventual plan is for the AVR to also load disk image data on-the-fly from an SD card, or possibly over a USB link from a PC, perform GCR encoding on the fly, and also perform GCR decoding to support disk writes as well as reads.

Luckily my first attempt at transferring data wasn’t far off the mark, because the emulator’s Mac interface is nearly impossible to debug. Ideally I could step through the floppy driver routines in the Mac’s ROM while floppy data was being loaded, and see what’s happening at a low level and troubleshoot problems. This is sort of possible, by installing the MacsBug debugger on the Mac, and setting breakpoints inside the ROM driver routines. Unfortunately the Mac’s 68000 CPU lacks hardware breakpoints, so breakpoints in ROM code must be implemented by setting a processor flag to invoke an interrupt handler after every instruction. (RAM breakpoints are implemented by dynamically patching the code.) This makes the Mac run 100-1000 times slower than normal when a breakpoint is set in ROM, rendering it virtually unusable. But even if you have the patience to wait 10 minutes for a breakpoint, I found that my ROM breakpoints didn’t always get hit, though I couldn’t explain why.

After setting up the AVR data transfer and discovering that it didn’t work, I scratched my head for a while, trying to find tools to help determine what was wrong. The first problem I found was that the disk RPM speed feedback I thought was working correctly earlier actually wasn’t. I was able to use MacsBug to see that the floppy driver was returning error -79 “can’t correctly adjust disk speed”, but I had to blindly experiment with different speed values until I hit on one that worked. Then the floppy driver was returning error -67 “can’t find an address mark”, which basically means it can’t make any sense of the data to determine where a sector begins. With zero other info to help troubleshoot, I methodically went through all my design assumptions one-by-one again looking for mistakes, and found a place in the IWM specification where I misinterpreted what Woz meant by a “transition” on the read sense line. At fist I thought a “falling transition in a bit window” meant any transition that falls in the window, but it turns out it literally meant a falling high-to-low transition. After fixing that, holy cow, it worked! I had fully expected needing to dig through half a dozen more problems after that one, so I was literally jumping around and shouting in excitement.

Read 7 comments and join the conversation 

A couple of months ago, I posted a design sketch for an SD-card floppy disk drive emulator for classic Macintosh computers. Recently I finally got motivated enough to start building it. Using one of the oh-so-rare DB-19 connectors that I purchased a few weeks back, I rigged up a cable to connect the Mac’s external floppy port to a breadboard. Then I dug out an old CPLD board I built for an early Tiny CPU test, and wired all the floppy lines to the board’s I/O connector. The board is powered by the +5V from the floppy port.

This particular board has an Altera EPM7128S CPLD, which is so old that it actually runs at 5V (newer CPLDs run at 3.3V or below). That’s great for this purpose, because 5V is what the Mac provides and is also the voltage level on the Mac floppy data lines.

So far, I’ve built a successful blank disk emulator. It identifies itself as an 800K drive to the Mac, initially with no disk. Reading and writing of the interval drive registers works, as well as stepping the drive head. The PWM signal that tells the Mac the current drive motor RPM speed also works. By pushing a button on the board, you can “insert” a disk into the drive, but the disk is blank (it contains all 1’s).

If you push the button while the Mac is waiting for a boot disk, it thinks about it for a minute, then “ejects” the disk and shows the X-disk icon on the screen. If you boot from a regular floppy disk in the internal drive, then push the button to insert an external disk, the Mac asks “This disk is unreadable. Do you want to initialize it?” If you say yes, the Mac responds “Initialization failed! The disk is write-protected!”

It’s not very exciting yet, but it’s a good start. The next step will be to add a microcontroller and an SD card reader. With those pieces in place, I can start passing actual disk data to the CPLD, so it can pass the data on to the Mac.

Read 3 comments and join the conversation