Re: hardware board design - beginner... pls help

John Larkin wrote:
On 30 Dec 2006 04:43:27 -0800, "S45" <saturday45@xxxxxxxxx> wrote:

Hello,

I am an electronics graduate and I wish to learn hardware board design.
I would like to learn High speed board design(>100MHz), schematic
entry, signal integrity and prototype testing.

How shall i begin? Whats the flow of board design?. Please let me know
some pointers or web resources.

Thanks

There is an enormous body of technique and lore that is widely
accepted in industry but virtually unknown in academia. And difficult
to pick up on your own. If you can, get a junior-level job in a small
or medium-sized company as an engineering aide or whatever, try to be
as helpful as you can, and learn from the experienced guys. If they
aren't helpful, or it looks like they're not doing good stuff, go
somewhere else.

For example, I've never heard of a college course mentioning, much
less teaching, documentation standards and control; well, maybe one
course taught by a former co-worker who spent time in the real world.

John


So true

For the OP:

Here's a typical very simple design flow and note that each and every stage requires thorough documentation:

1. Get requirements from customer / marketing.

This is more difficult than it sounds; you can't just say 'I want to sample some signal and then control something else based on it' - there has to be a specific link. That a *very* simplistic example, incidentally. There's a lot more - power requirements, battery operation?, chargers, size, weight - there's a thousand and one things (per the old saying) that have to be thoroughly _defined_.

2. Choose the architecture to meet the requirements. This is 90% experience at least. A simple design can be easily found (at least architecturally) on the web, but as things get more complex (and customised) the chances of finding what you need already done lessen (as they should - if it's already been done why are you doing it unless to make something cheaper / better?)

3. Choose the parts to implement the architecture. Again, more difficult than it sounds. Make sure the parts are actually available and not vapour-ware, and are reasonably affordable.

4. Start schematic capture. Notice how far along we are before this even starts? Of course, you'll need to make the parts and symbols yourself (lots of threads on this both here and on sci.electronics.cad) so be prepared to do a lot of paperwork and checking.

Have the parts and symbols checked thoroughly by someone other than yourself if possible (this is a matter of not always being able to see your own errors).

5. If you are doing anything with constraints (anything non-trivial in other words) then make sure you enter the constraints at the schematic level if possible - I well remember setting the constraints for a single sub-system (DDR at 200/400) where setting the constraints took longer than the schematic capture phase - and that was but a small part of that board. Once more, document thoroughly what those constraints are and why they are set that way.

6. Run the various error and warning checks on the schematic; once you have zero errors and zero warnings (well, there are some warnings that are ok, rather like the output of lint), run the netlist.

7. Choose a PCB stack - this is, to a great extent, experience. How many layers, what each layer is (signal, ground, power etc) and make this before even considering importing the netlist. Also, define the board outline and any breakaways (necessary in manufacture) that may be needed.

8. Export the netlist and then import it into the layout tool. You'll need to make sure you have all the device symbols and padstacks set up prior to this. At this time, you should also generate the PCA BOM - note that this is not the final BOM! Again, lots of documentation.

Now, and only now, do we get to layout. This is a subject in it's own right, but here's a typical simple flow:

9. Place the components as required by the various schematic set rules (see above) and anything else that may be relevant (power distribution, signal distances, decoupling devices - again, there's huge numbers of variables)

10. Hand route the power - this can be *very* difficult depending on how many power domains exist. The highest number I've personally done on one board was 27 separate power domains (because I was switching the power to many devices) and set up the power and ground planes (but we'll have to return to them)

11. Hand route any critical signals - autorouters, in general, suck for critical signals, and it's best (usually, imo, ymmv) to route the critical stuff and mark it as fixed and then let the autorouter do it's thing.

12. Now go back and iterate steps 9 to 11 until it's all done and meets the rules.

13. If any pin-swapping was done, go and back-annotate the schematic.

14. Set up the documentation layers and so forth on the layout.

15. Generate gerbers and assembly prints - this is usually known as a fab-pack.

16. Generate the final BOM (including housings, clips, plug-in modules, whatever) and remember to check the PCA BOM - if you are lucky, you can ship it off to be made :)

Note I left out some pretty common steps because they aren't always done, but every single step has to be documented, and there must always be a master document - in my case, that's the spec - from which the design had to flow. This is the absolute minimum.

In addition, I did not introduce the _very_ common issue of an updated netlist in the middle of layout (may my PCB guys forgive me ;) ).

Practical design requires a lot of documentation as well as design skills ;)

As I and others (especially John) noted, there's a lot to it that is usually never encountered in college.

Cheers

PeteS

.

Quantcast