Designing pcbs for assembly is easy, right? We just squirt all the footprints onto a board layout, connect all the traces, send out the gerbers and position files, and we’re done–right?

Whoa, hold the phone, there, young rogue! Just like we can hack together some working source code with variables named after our best friends, we can also design our PCBs in ways that make it fairly difficult to assemble.

However, by following the agreed-upon design specs, we’ll put ourselves on track for success with automated assembly. If we want another party to put components on our boards, we need to clearly communicate the needed steps to get there. The best way to do so is by following the standards.

Proper Footprint Orientation

Now, for a mom ent, let’s imagine ourselves as the tip of a vacuum pickup tool on a pick-and-place machine. These tools are designed to pick up components on the reel from their centroid and plunk them on their corresponding land pattern. Seems pretty straightforward, right? It is, provided that we design our footprints knowing that they’ll one day come face-to-face with the pick-and-place machine.

To get from the reel to the board, we, the designers, need two bits of information from out part’s datasheet: the part centroid and the reel orientation.

The part centroid is an X-Y location that calls out the center-of-mass of the part. It basically tells the machine: “pick me up from here!” As designers, it’s our responsibility to design all of our footprints such that the footprint origin is set at the part’s centroid. If we forget to do so, the pick-and-place will try to suck up our parts from a location that may not stick very well to the package, such as: the corner.

The reel orientation is the orientation in which the part rests inside the reel. For pick-and-place machines, reels generally get loaded into the machine in only one way. Parts living on that reel, though, could be oriented in one of four ways — with pin 1 in one of four quadrants.

Again, as designers, it’s our responsibility to design all of our footprints such that the footprint orientation matches that of the reel, relative to that of the reel feed direction. In a nutshell, we just need to make sure that pin 1 on our footprint design matches the same quadrant as pin 1 on the reel when it runs through the machine.

Sounds easy, right? Usually, we’re in luck; these two bits of information are in the part’s datasheet. Sadly, though, that’s not always the case. Sometimes, an IC’s primary datasheet may not contain the reel orientation. For that info, they sometimes refer you to a different datasheet with reel information for a specific package type. As an example, have a look at the D-PAK Reel information [PDF] on Vishay’s Diode page.

This practice of splitting off reel information into a separate doc is basically laziness on part of the vendor. I can hear them now: “Why put the reel information on every single part’s datasheet when we can just put it on a separate datasheet that just discusses reel information corresponding to a particular part size?” Nevertheless, while this practice can send us on a wild goose-chase hunting for just one snippet of information, it’s always listed. Sooner or later, someone will need to mass produce a product with a vendor’s part, and this orientation information is vital for assembly.

Unavoidable Footprint Ambiguities:

Against all odds, some parts still don’t have a clear way of indicating their orientation. These parts are usually polarized passives (caps and diodes) with symmetric footprints. Check this capactor package out:

This capacitor (PN: T55P475M010C0200) is polarized, but it has an 0805 land pattern, which is symmetric (unpolarized). Assuming the PCB Assembly house gets the standard position file with the part transform and the gerber files, do they have enough information to figure out which way the cap should go? Unless there’s a mutually-agreed upon default orientation–they don’t!

Here’s the deal: technically, the IPC-7351 Spec has a defined “pin-1” orientation for these components which should match the reel orientation. This spec, which we discussed in the section above, should rule out any ambiguities. The issue, though, is that we, as footprint library makers, are under no such constraints to follow said spec . When we’re creating the library footprint we can put pin-1 in whatever quadrant we want! Here, dear PCB designer, lies the danger in importing some random chum’s footprint library from online. Unless we’ve checked each footprint, we have no guarantee that said chum has designed the footprints to follow the IPC-7351 spec.

When there’s any doubt, you probably will need to help your Assembly House out with a few informative graphics that show the proper orientation. A screenshot of the board layout with a few labels should do.

Working with Parts that Actually Exist

Depending on our design software, sometimes we work with schematic symbols that are tied to parts with specific part numbers. Other times, we can work with strictly symbols and then fill those symbols in with actual part numbers later. If you’re in the second camp, heads-up: before jumping to the layout, be sure that these symbols are associated to footprints that actually match real life parts.

Want an 10 uF ceramic capacitor with an 0805 footprint, an X7R temperature coefficient and a 25 V rating? Too bad! Shoulda’ dug through the Digikeys to see if such a part existed in the first place. In this case, it actually doesn’t.

The risk here is fairly low, but there’s still a chance to assume that a certain resistor of a certain tolerance and power rating will come in the footprint that we expect. In practice, the one place where this might trip us all up is when we punch numbers into an active filter designer tool and get impossible resistor and capacitor values. Be sure to check that these values exist first!

BOM Export

There are two major options for actually getting the components to the manufacturer: either turnkey (assembly house fetches the parts) or consignment (you provide parts to the vendor, usually on reels). Since the assembly house knows the ins-and-outs of their machine far better than we do, assembly houses that offer both usually prefer turnkey. Nevertheless, ask!

Regardless of which process you use, you’ll still need a BOM to tell the vendor what reference corresponds to what part. Each assembly house is different and your BOM might not emerge in a format that’s to their liking. Generally, though, I suggest re-jiggering your BOM such that it’s organized by unique components (i.e: all references should be consolidated into one field). Why? If we imagine ourselves on the assembly end, we need to load our machine with reels of identical components. Getting a BOM from a customer that’s organized by unique component easily lets us identify the number of reels that will need to be loaded into the pick-and-place machine. Again, when in doubt, ask the assembly house how they prefer their BOMs.

Marking DNPs

Occasionally, you’ll have a few components that just aren’t supposed to be populated. In that case, simply omit them from both the BOM and the position file, and assembly house will safely ignore them.

Fiducials

Fiducials serve as coordinate reference points for the pick-and-place machine that’s loading your part. In a nutshell, the machine that’s placing these parts needs to superimpose a coordinate frame on top of the PCB such that part coordinates match up with the correct spots on the board. Two fiducials minimum are needed to do this.

These points let the machine calculate the actual board orientation using trigonometry. Place them as close to the board edge as possible, in opposite corners. The exact placement doesn’t matter, but the farther the two points are from each other, the less error in overlaying the coordinate frame. Three fiducials placed as closely to the corners as possible will also let the machine calculate any skew in the actual PCB layer that may have been introduced when it was being fabricated, although it’s usually not necessary.

Final Footprint Size Checks

Getting boards assembled costs time (sometimes 2 weeks–ouch) and money (from a few hundred to a few grand). Double-checking ourselves might cost us a few hours, but it’s more than worth the two-week wait if we find bugs. Just before we send out the board files for fab, I suggest printing the copper and silkscreen layers at 1x scale on a piece of paper. Then, with the actual components in-hand, put them on a scale image and make sure that, indeed, the footprint pattern checks out OK.

What’s crucial here is that we catch any part sizing issues before the board gets fabbed. This step is especially important if you made any custom footprints or downloaded some chum’s footprints off the wild web. Nevertheless, it’s helpful even if you’re pulling footprints from valid sources. In my mishap here, I just selected the wrong footprint.

Go Where No Young Rogue Has Gone Before

Here on Hackaday, we love the one-off: the Microwave that cries like a Windows XP or the portable console mod that lets us take our GameCube on the go. Many of the triumphs that we feature here are one-offs done by a single engineer — and that’s OK! In those hacks, we don’t need to keep our work tidy. We don’t need to clean up after ourselves in code. If it makes sense to us, it’s all good, right?

Like it or not, there comes a day when we need to do something with our design that, in the basement-hacker’s world, is unspeakable. We need to share it. Sharing might not sound like a big deal, but if we’ve run away from standard practices for too long, we’ll never be able to pull in another after-hours engineers for help. We’ll never be able to communicate with assembly houses or contract manufactures who are supposed to be handling some of the heavy-lifting processes for us. Want to get a machine shop to cut you parts? Looks like we need to learn how to dimension parts with GD&T. Want to get your PCBs assembled? Better put those centroids in the right spot!

Following international design specs actually makes our lives easier in the long run. If we choose to use the agreed-upon standard practices that our fellow engineers use, we’ll all float on the same boat when we need someone else to assemble our boards. We’ll be speaking the same language, the language of the engineer.

The Pre-Fab Checklist:

If you’re making PCBAs that will be assembled professionally, I made a checklist of key points to keep in mind. Keep in mind that there are tons of these online. I suggest picking one that best matches your CAD tool and workflow.

During Symbol/Footprint Library Creation:

Are my library footprints designed with the correct orientation that matches the reel?

Do my library footprint origins match the centroids of the actual part?

Am I using the full part number that also indicates the package type, if various packages exist?

During Schematic Capture:

Are all my parts stocked by vendors that my PCB Assembly House will use, or will my board have lead time because some parts are not immediately available?

Do I know the specs of my “jelly-bean” components (resistors, capacitors, etc.), just in case my Assembly House wants to suggest alternate components that they already have? (Better: can I somehow add these specs into my BOM?)

Do all my schematic symbols and footprints chosen to match real-life components? (Or did I just put in a capacitor with impossible specs for its size?)

Before PCB Layout:

Design Rules: Did I select trace width, trace spacing, via diameter, and via hole sizes that are on par with what my manufacturer can actually fab?

After PCB Layout:

Does my completed layout pass the layout Design-Rule Check? If not, can I justify every error that is flagged?

Before Sending off for Assembly

(Again) Am I using the full part number that also indicates the package type, if various device packages exist for the same component?

Can I export a BOM in a way the PCB Assembly House likes it? (Usually, by unique part number)

Did I remove any DNP components from my BOM and from my position files?

Do I need to clearly indicate the orientation of any ambiguous, polarized components that have symmetric footprints? (Pictures of the layout work here)

References