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.
If you could tell us what your current expertise is, you may get better
advice on what you can do from here. My own collage experience
(University of Illinois, Urbanna), is that little of any practical
experience is gained taking Electrical Engineering. My expertise is
99% self taught.
Before tackling high speed design, I strongly suggest doing basic PCB
design, schematic entry &cetera.
Volumes could, and have, been written on this subject. Google is your
The search term:
PCB design tutorial
Turns up about 783,000 hits; most aren't much good, but there's a few
decent hits on the first page.
I like to view electronics an art. Not knowing where to begin is
a special time in a project.. It's kinda like jumping in bed
with a new girlfriend. Would you like it if somebody was
coaching you while you in bed with a girlfriend.. Probably
not..Go for you our style and explore...
Make a choice... :)
Or course...knowing what others have done can save a lot of
Look for books and articles by authors Howard Johnson and Mark
Electronics, like just about anything else, can be a job, a skill, or
an art - depending on the person doing it. I most enjoy designing
things with 'hardly any parts' that look like 'they shouldn't work'.
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
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.
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
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
12. Now go back and iterate steps 9 to 11 until it's all done and meets
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
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.
PeteS provided an excellent flow guide to this process. PCB design is
partly Art and partly Science. I use PADS-Logic and PADS-PCB (with their
Blaze autorouter), and it is very good, although the parent company Mentor
Graphics has an unreasonable annual maintenance/support scheme (scam?) that
would have me advise anyone not to purchase their package. Cadence is
probably now a better option for high end packages of this type ($5000 to
For your own use and education, you can download from (www.mentor.com)
their complete latest version which is fully usable for very small designs,
and it is a good place to start. They have some good tutorials and sample
designs. Another very valuable resource for users of this product is a very
helpful and friendly forum you can read and join to post questions:
>Here's a typical very simple design flow[...]
>1. Get requirements from customer / marketing.
>. . .
>16. Generate the final BOM[...]
Ken Smith went into even more detail when he covered this: 8-)
Part 2 by George Gonzalez (Ancient_Hacker) is worthy as well:
I have said for many years that design is where Art meets Science.
That's one of the great threads - I didn't remember where they were :)
Good catch for finding them!
> It's kinda like jumping in bed with a new girlfriend.
> Or course...knowing what others have done can save a lot of
Happy New Year 2007!
There is more, but this will serve as a start.