As a very lucky embedded systems engineer I get to design and build many many PCBs. And when I say many, I mean it. Oftentimes, I can have 2-3 different designs going at the same time. Some designs are simple: a microcontroller with a few components. Others are complex boards with impedance matching, length matching, and BGAs worth upwards of $5k. However, no matter how much each board is worth, the second a new design comes from assembly (If I don’t do it myself) it gets a special treatment. It feels a bit like a police officer interrogating a subject – I’m suspicious of the whole board and until it gives me the truth (and runs as expected) I assume it will lie to me and cause all kind of issues.
Most of the designs work wonderfully. When you take the time, dive into the details to ensure the board will be good on arrival, you’re stacking up the odds in your favor. The board is working before it even leaves for manufacturing (as Sun Tzu said, a war is won before a single battle begins). But, in engineering, like in many other fields, things happen. That power supply specification that you though was right isn’t anymore because the customer asked for changes and there was little time to investigate the ramifications. A manufacturer failed to give you the right spec. The assembly house placed a diode with the reverse orientation. All of these things happen. At best, a few component changes
resolve the issues and everyone is happy. Bluewires on a board are not desirable, but you live with them. The worst, however, is when issues damage the board. You’re left to figure out what went wrong and when you finally do, there’s nothing to be done but change components or build a whole new board (the former brings a whole host of issues). This should never happen for a simple reason – it is mostly an avoidable occurrence.
The most common issue that can destroy a board is power supply problems. The simple reason is that power supply typically produce large currents, large currents create heat, and heat destroys components and PCB (the PCB traces can act as wonderful fuses). Clamping diodes in ICs can handle a signal that is over-voltage (withing a reasonable range), but a power supply will keep trying to pump more and more current until the desired voltage is reached (not likely when a short). This has to go somewhere and will get dissipated by components that are not designed for it. Given this, there is a simple regimen that every board I get goes through:
- All component are visually checked to esnure there’s nothing strange going on. This means checking polarized components for the right orientation, ICs with pin 1 correctly aligned. You’ll be suprised the stuff that Automated Optical Inspection (AOI) doesn’t catch. Checks for any obvious shorts, missing components, etc.
- You can’t power the device. Note that the term short is very subjective. Each multimeter has a different limit for what it considers short and may still emit a beep. Anything below 1 ohm is typically a hard short (metal to metal). Never underestimate this check. This is probably the most overlooked but useful test. If all is OK your board might not work, but it will likely not blow up.
- If possible by design, all on-board power supplies are disconnected from the circuit they power. While disconnected from the load, they’re powered isolated and checked to ensure they’re voltage is correct. Imagine if a mistake is made on the feedback network of a regulator, and 5V is supplied to a 3.3V part? Its happened, but checking the voltage without it being applied to the actual circuit can catch this.
- For powering the on-board power supplies, use a current limited power supply with the limit set to a reasonable figure. You might hit the constant current limit on it, but this will result in a low voltage which is unlike
These simple checks ahead of time have saved me a lot of headaches. Once the board is blown there’s typically little time to build new boards, test them, etc. I hope they’ll help you in your next project as well. When you’re confident the basic design is working, you can lighten up on the checks (assuming you trust assembly).