Bringing up Baby - product development thoughts

Gene BrenimanAugust 15, 20085 comments

Things have just started to get exciting. After months of defining, specifying and designing my latest product, I finally have semi-functional prototypes. After a few side steps during the building and bring-up process, power is applied and most of the low level functions have been verified. Soon, software will meet hardware and debugging can begin in earnest.

Before jumping in and really enjoying the fun (besides I'm now waiting for some new parts to arrive), I thought it would be nice to look back at the steps that brought me to this point. As with almost every project that I have been involved with, this one has taught me a few new lessons. If we don't learn from the challenges we run into, we will continue to face them (over and over....).

What follows is a list of some of the many steps necessary in the creation of a new product, along with some of the checks that should be in place to make sure that problems are spotted as soon as possible. I have also offered some ideas and opinions that might be helpful to anyone willing to learn from others' mistakes and challenges.

Decide on a product

Any good product starts as a good idea. It is important to research existing products and competitors prior to putting large amounts of effort into an idea that might already exists. Keep focused, fight the impulse to add too many features.

Write a specification

If you don't specify what you are going to produce, how will you know if you got it right when you are done? How will know if you are done? For a single-person project a simple specification is sufficient. The more people involved, or the more complex the project, the more detailed the specification will need to be. Again, keep focused and keep the specification limited to the features that are needed.

Block out a design

Begin with a simple block diagram of the product. Get a rough idea of how the features will be implemented (both in hardware and software). Start sizing memory (FLASH. RAM, EEPROM) and speed requirements of your microprocessor (I assume that you are using one, or you might want to look at other websites). Also begin to determine needed items like peripherals, I/O pins and other features. By firming up the design at this point, some of the following steps will get much easier.

Select components

With your rough design in hand, start looking for the parts that will be needed to fulfill the design requirements. This is where I start looking at things like cost and availability. No point in starting off a new product with parts that will no longer be available, or just very hard to obtain (i.e. near end of life). Also, by looking into cost at this point, you can avoid adding a $10.00 part to a potential $5.00 product.

One of the pivotal decisions in most of my designs is picking the microprocessor. By beginning with the information from the sizing exercise of the previous step, we develop a good starting point for this decision. Add to this starting point, issues of development tools (compilers, programmers, emulators, etc.) and experience working with various families of microprocessors to help narrow down the choices. Here too, we need to look at potential risks to the project. Do I want to write low-level USB code in the microprocessor, or use a simple USB to serial converter chip? Now is the time to trade cost for complexity and risk. As an example, by spending an additional $0.50 per board, you could potentially eliminate months of software development by leveraging pre-built functionality over risk intensive development.

I also like to take a little bit of time here to examine growth potential before making a final decision on all the components. Things like, are there pin compatible family members of the microprocessor with more speed and/or memory? With the other components, are there available pin-compatible parts with greater speed and/or precision (i.e. ADC, DAC, references, regulators, etc.)?

When building up your list of components, it is sometimes a good idea to look for parts that are available from a number of vendors (either IC vendors or distributors). It is always better to have choices, should the part you need not be available at the time you will be ordering it. In the past few years this has been a reoccurring problem, as both IC vendors and distributors have been phasing out leaded components. Several times I would look one day, finding ample supply of the parts I needed, only to find that none were available when it was time to place an order. As always, having multiple choices of the components/vendors is better than not having any choices at all.

If while looking for parts, you find a part that you really like, that is not currently stocked, first try and modify your design to eliminate this part. If you can not design around a 'no stock' part, order the part as soon as possible, overlapping the procurement delay with time used to complete your design. There is some risk involved in ordering early, but there is also risk in waiting around for a long lead item that you just got around to ordering. Some vendors/distributors will sample a small quantity of their parts, so that you might be able to get a few, hard-to-get parts to handle your prototype needs.

Generate a schematic

With a good idea of what we want to achieve and a rough idea of the parts we intend to use, we can further firm up the design. For me, the process of generating a schematic is somewhat iterative. As I place components and run wires, any gaps in the design start to stand out. Design checking tools also help to isolate deficiencies in the design (like inputs with no outputs, or multiple outputs on a node). (Note: this will only be helpful if your component models are correct and complete.)

Depending on your tool set, this may also be the time that you define the package types on the devices that you are using. This is the point where you need to look ahead a little bit. Your choice of package types should to take into account several factors, like space available (i.e. board real estate), assembly cost or limitations (i.e. pin pitch and spacing) and PCB costs (i.e. trace width, spacing requirements and hole sizes can effect PCB cost). Looking ahead now, could save you headaches and additional cost later.

Generate a bill of materials

With your schematic complete and all of your components identified, now is a good time to document your choices. By identifying part counts and manufactures part number for all components, you can begin to determine where you are going to get the parts and how much this will cost you. For potential products (as opposed to one-time builds), I like to look at near term needs and future volumes when researching pricing for components. Some manufactures offer deeper price cuts for higher volumes, so thinking about futures volumes can be important to the selection of components at this early point in a potential product life cycle.

Lay out the PCBs

With a complete schematic and a bill of materials, you can now begin laying out your PCB. I usually start by a rough placement of all components, focusing on minimizing all high-speed and/or high-current connections. With a rough placement, I determine the overall dimensions of the board, placement of connectors and location of mounting holes, if any. At this point, I adjust my component positioning, attempting to avoid crowding and, wherever possible, align components on grids, with similar orientations (pin 1 pointing in the same direction).

With the components and connectors in place, I start to work through the power and ground connections first. There are many rules and guides that should be followed in running power and ground traces. I will not attempt to define all of these here, but I will give you a few points to consider.

  • Keep bypass capacitors as close as possible to the appropriate power pins on devices.
  • Use proper trace widths and minimize the length of the traces.
  • Avoid vias or feed-throughs between the bypass capacitors and the power pins.
  • Manage all power and ground paths with 'star patterns', emanating from single points (i.e. main ground connection, or regulator outputs), where possible.
  • Avoid current loops (closed paths, or multiple paths for current flows).
  • Avoid running high-speed signals in parallel to power and ground traces.

In addition to the above points, on boards with a mix of high-speed signals and low-level analog signals, I try to minimize the use of power and ground planes. On these types of boards, the high-speed signals can (and quite often do) capacitively couple through to the power/ground planes inducing noise into the sensitive analog components. In these cases I run thick traces, radiating outward from a single point, towards the components. Power components of like functions (analog or digital) separately and use inductors/ferrite beads to decouple high-frequency signals from the power lines. Most of the boards that I have built have been 4 or more layers. I choose to bury the majority of power and ground traces onto the inner layers (ground on one, power on another), leaving the two outer layers for signal routing.

With power and ground traces laid, I usually focus next on the high-speed and low-level signals. With these signals I attempt to keep the trace lengths as short as possible. In the case of the high-speed signals, I also endeavor to route these traces away from power and ground traces, favoring right angle crosses of inner layer traces, as opposed to running in parallel with them.

Finally, I focus on routing the remaining signals, moving from fastest signals towards the slower, less noise sensitive signals (like pull-up resistors on static pins). With all the traces in place, I go back over the analog sections of the board, looking for areas that could benefit from ground flooding (addition of copper ground planes to protect sensitive areas from noise). I usually attempt to ground flood areas that are using high-impedance inputs and very low-level signals. When using ground flooding, I try to avoid including areas that have high-speed or high-energy signals within them, or running under them, as these may again capacitively couple these signals into the ground flooded copper planes.

Board layout is a very complex process. Much has been written as to the correct steps and procedures. My suggestions are only intended as such. Board layout is more of a practiced art; only years of experience will lead you to the skills necessary to develop good boards that are small, clean, reliable and free from performance diminishing noise.

Recheck layout/test fit parts

Once your board is laid out, take some time to go over your work in detail. I usually print out my board plots on paper checking all component pads for proper fit. Using spare components, I attempt to verify that the part outlines are correct, leaving proper clearance on the pads for good solder joints. I also double check all my connector placements to be sure that the pins and guide pins (if any) all align properly and that the bodies of the connectors are not interfering with other components.

This is also a good time to go over the silk screen layout. Check that the component call-outs are visible, clear and unbroken by vias or feed-throughs. Also check on pin 1 markings (or other markings for proper orientation) for all components. Don't forget polarity marks on polarized parts, i.e. electrolytic capacitors, diodes, etc. The silk screen is a guide of how to assemble and troubleshoot your work; now is the time to make sure it will be helpful.

Order boards

Now you are ready to start spending some serious money. This is where I take a couple of deep breaths and then pull the trigger (or on most websites, click on the submit button). Some PCB vendors have on-line design rule checkers to ensure that your layout does not violate any of their trace width and spacing requirements. If available, use these tools. I have found small difference between vendor tools and my own tools when it comes to spacing checks. I trust the vendor tools, and make and changes that are called out.

Shopping for PCB vendors can be tricky. I have seen some inexpensive boards that were good and some that were bad. Vendors that had in the past, produced high quality boards consistently, later turned out a few boards with broken traces. Wherever possible get recommendations from others when working with a new vendor.

Order parts

Your PCB may take some time to be manufactured and shipped. Often the price that you pay, determines your job's priority in the manufacturing process. I use this time to start ordering my parts. With the bill of material generated in a prior step, you should now know the quantity and value/type of the components you will need. Using this as your guide, place your order for parts.

Keep an eye on quantities when ordering your parts. If for example you need 20 of a given part, check the next higher quantity on the distributor's site to see if it is more cost effective to order 25 parts (at a deeper discount). The spare parts can come in handy later (like during assemble and/or debug stages). Keep in mind that you should have some spare parts on hand to handle any waste in the assembly process (some board assembly houses require that you have 5-10% waste included in your build kits). In the process of building my boards, I usually send a few very tiny parts flying off to who knows where.

Sometimes you may fine that a distributor is out of stock of a part you have identified for your design. This is where good planning can help. By having identified other components or vendors during the part selection step, you should be able to switch over to another part that will work for your design.

Check ordered parts against the Bill of Material

Most likely, your parts will arrive before your PCBs (unless you spent the extra money to expedite their manufacture and/or delivery). As a matter of course, I always re-check the parts against the invoice, looking at the part values, part numbers and quantities. On most integrated components I also check that package type (SOIC, TSSOP, etc) is correct.

On my most recent project I learned a new lesson. I should have carefully checked the somewhat cryptic part numbering on the components themselves. The distributor had made an error and sent me the wrong part. The first thing I should have noticed was the incorrect package. Even though the bag listed the part as a MSOP-8, it was in fact a TSSOP-8. These parts have the same pin pitch, but have different body widths. I was, at the time, willing to accept that I had somehow incorrectly built the component pad layout for this part, rather than suspect that the distributor had sent the wrong thing. Later, during the assembly step, I somehow managed to solder the larger component onto the pads of the smaller footprint. It was only even later, during the debugging of the board, that I found I was unable to get the part to function as expected. After many hours of debugging, I finally began to question the correctness of the part and begin to look at the part marking on the chip. Morals of this lesson:

  • Have some kind of incoming inspection to verify that what you have received is what you expected. Incoming inspection is cheaper that correction of an error.
  • When something does not look right, spend the extra time to determine why it seems wrong. Question everything at the first sign of a problem, and correct the issue at the earliest opportunity.

Check boards for workmanship and shorts

With new boards in hand, I first check the boards (under a microscope) to assure that they appear to be manufactured correctly. In doing this, look for any traces that end abruptly without a via or a component pad (breaks), thinned out traces (over-etched) or shorted traces (under-etched). Also, make sure that drilled holes are centered in the pads (hole registration), as this can point to broken or shorted traces in the inner layers of the board. If your boards are pre-tinned, make sure that there are no high spots in the solder that will make it difficult to place components flatly on the board.

In addition to visual inspection, I usually check electrically for shorts and opens, especially on all power and ground traces, where the effects can be the most damaging (i.e. gross failure and/or the generation of heat and/or smoke).

Assemble boards

If able, I like to hand assemble the first round of prototype boards. This allows me to see any potential areas of the assembly process that might be difficult or unclear for others less familiar with my design. Be sure to keep notes of any findings, as these can become instructions for the next person who needs to build future boards (or input into the next design or re-design process). I try to keep one complete set of documentation (schematic, layout plots, silk screen drawings and bill of materials) that is marked as 'Master', used to track any changes or corrections.

In the assembly process, I like to place smaller (lower profile) components first. I do this to allow myself as much access as possible for using clamping tweezers (self closing or reverse tweezers) to hold components in place while soldering. I moved to the highest pin count or smallest pin pitch components next (assuming that they are also very low profile). I finish by adding all the higher profile components, as I am still be able to hold them place with the tweezers (easier to clamp over lower profile parts). Also, within these groups of component , I try to work outwards from the center of the board to the edges, again making it easier to clamp components in place.

If I am building a couple of prototype boards at a time, I usually choose to add a given component type (or value) to all the boards at once. This limits the handling of components and makes it easier for me to avoid some assembly errors. Repeating the same step over a couple of times makes it easier to see errors, like putting a part in the wrong spot, as we tend to see differences more clearly.

Check out the assembled boards

This is a many step process. The order of steps is often effected by the complexity of the design, the access to good test points and many other factors. What follows are some of the simpler steps that I try to use in all my check out processes.

Start with visual inspection of the boards and the solder joints. Even if I did the soldering (and sometime just because I did the soldering), I like to pass the boards under a microscope one more time to look for errors or mistakes. I look for cold or broken solder joints, excess solder (short circuits or bridges) and correct component placement/orientation. I also look for free solder balls and excess flux build ups left over from the assembly process and clean the boards as necessary.

When the boards 'look' good, it's time again to check electrically for opens and shorts in power and ground paths. Using an ohmmeter, measure the impedance between power and ground paths (in both directions). I also like to check power and ground continuities to all the major components, if possible.

Satisfied that thing should not blow up, I bring up the power and quickly measure voltage levels on all the main power circuits (regulator outputs and inputs, and other voltage source points). Next, I like to check the current draw of the board to assure that it is in the correct range. This sometime requires a little rework or fixturing to accomplish, but it is usually worth the effort. I also like to take a quick temperature reading on the power components (just a quick touch is usually sufficient, as long as it it safe to do so, i.e. no high voltage present in the area).

My next step is usually to connect a device programmer and see if the microprocessor is functioning. Most programmers and devices have a simple method to test the device ID of the chip. If the ID looks good, it's safe to move to the next step (deep breath). Most microprocessors have 'fuses' (programmable settings) that control things like basic modes of operation, oscillator types, etc. My next step is to program these fuses so that the microprocessor begins to function.

Here is where things really get fun. I prefer to take a low level approach to bringing up a board. To verify that the microprocessor is operating at the speed I expect, I have it write a counting pattern to all of the available output pins. I look for a unique squarewave pattern on each of the outputs using an oscilloscope (another deep breath). Looking at the highest frequency output, I compare the value to the target microprocessor frequency. The ratio of these two value should be proportional to the number of instructions taken to increment a variable, output it to a port, and then loop back for the next iteration. Looking at the compiled program listing, you can count the number of instruction cycles needed for the opcodes to complete the loop. The instruction count, times two, should match the ratio between the two frequencies (as the loop needs to be executed twice to toggle an output high then low).

My next steps widely vary based on the design complexity and the available test points, but my goal is to test each function of the circuit with as little interaction from surrounding components as possible. I like to take many small steps with each building on the other to test more and more of the design.

As an example, consider a board with a serial interface. My first step is to have the microprocessor write a single character, over and over. Once verified, I move to the ever popular 'echo' test, where the microprocessor reads a character and then writes back the same character. Next, I assign different characters to actions (like set outputs high or set outputs low). This allows me to build-in test sequences used to more completely test my design.

I continue these sorts of tests, building more and more complexity, until I am satisfied that my circuit is basically functional. Then, using the test code that I have created as a model, I begin to write the real software for my product. As my software grows, to complete the full functionality of my design, I sometime find it useful to drop back to my 'test software' to prove or test some function that I had not previously tested (or completely tested) during the bring up process.

So here I wait. The replacements for the in-correctly shipped parts, are still in transit (FedEx from Thailand), as my distributor of choice is now 'out of stock' on the correct part (their inventory system is most likely still recovering from the mis-binning of parts). Meanwhile, I am building up a couple more boards, so that they will be ready to accept the new parts as they arrive.

In parting, may all of your challenges be not too challenging!


[ - ]
Comment by hkm97July 13, 2009
Good article, comprehensive ! The part I would like to add my two cents in, is the DVT of prototypes. Its very important that the prototype PCB's make it back to the designer so that he can verify the PCB itself, and of course the product functions that need to be verified before the design is handed off to test engineering and production. Far, far to often managers think its a prudent move to have someone else verify the products basic functions before the designer ever knows the prototypes have been recieved in house. It is allways best to have the desiger choose whom will be the owner of DVT for prototypes.
[ - ]
Comment by rxsApril 27, 2010
Thanks .... please share .. ORCAD procedures for baby product .........???
[ - ]
Comment by jkvasanApril 3, 2011
This is a down-right practical and exhaustive description of all those processes involved in product development.
[ - ]
Comment by horsedorfMay 24, 2011
That's a really good concise list of the development process. Well stated!
[ - ]
Comment by Hitesh GambhavaJune 21, 2012
Good article... Very good learning of product design cycle for hardware design freshers !!

To post reply to a comment, click on the 'reply' button attached to each comment. To post a new comment (not a reply to a comment) check out the 'Write a Comment' tab at the top of the comments.

Please login (on the right) if you already have an account on this platform.

Otherwise, please use this form to register (free) an join one of the largest online community for Electrical/Embedded/DSP/FPGA/ML engineers: