Project Design



Before you begin

As they say, the best way to finish something is to start; there are
several things you can do to your EagleCad environment to have it start
with comfortable settings every time. I've combined my preferred
initialization and several "macros" for Eagle into a couple reusable
EagleCAD scripts that you can download and use. Simply save them in a
directory that can be found in EagleCAD's SCRIPT path (control
panel->Options->Directories->Scripts) and invoke it in the board or
schematic editor window like this:

script /path/to/SPCoast.scr

Once you have done this, the settings will be autosaved in your .eaglerc startup file and you won't need to rerun these SCRipts again unless you want to change things.

See below for a description of these commands.

Getting EagleCAD:

Scripts: [http://{=mediawiki}/pub/download/scripts/Scripts-SPCoast.scr-SPCoast.scr SPCoast.scr\], \[<http://>{=mediawiki}/pub/download/docs/Documents-PCB-Design-howto-colors.scr colors.scr] and [http://``{=mediawiki}/pub/download/docs/Documents-PCB-Design-howto-layers.scr layers.scr]


I have several computers where I run EagleCAD - laptops, desktops, at home, at TechShop, at work and on the road. The terms of my Eagle license allow this - as long as my alternate personalities aren't using more than one at the same time.

To solve the problem of keeping everything in sync, I created a directory named "eagle" in my Dropbox folder so that, no matter what computer I'm using, I have access to the latest revisions. Eagle lets me define a set of project directories in the main Eagle Control Panel window's [Options->Directories] menu.

Of course, Google Drive, Microsoft OneDrive, and others can be used instead of Dropbox...

  1. Create a -project dir- for your EagleCAD projects in your Dropbox
    folder (I call mine "eagle")


  2. Create subdirs in it for libraries, scripts and CAM files. I chose
    to put all the eagle specific stuff under a common Library


  3. in EagleCADs console window edit the Options->Directories content to match (The entries there are ":" separated lists of directories)

: {width=”500”}
EagleCAD Directory Options

You can see that I have both projects and shared library stuff (dru files, cam jobs, ulp scripts...) in my dropbox hierarchy.

Version Control

Eagle feels stuck in the dark ages when it comes to version control. It presumes a strict 1:1 relationship between a schematic and a board design, and it has no provision for managing versions. Yes, it does create a sequence of .b#1 and .s#2 editing backups as you change things, and yes, it has a robust ULP and SCRipting system, but it leaves everything up to you to handle manually.

There are a couple of attempts out there to add GIT support to Eagle (jotux eagle-diff, lcox esawdust,...), but none really deal with the subtle distinction between backups (for safety as you develop) and archives (for safety after you are done with a version). What follows is the workflow and practices I've developed to address those needs.


It may seem obvious, but names matter, as does consistency. I've chosen to create project directories that are named the same as the project they contain, without any version numbers or added descriptive annotations. In the project directory, I then create a set of versioned subdirectories that hold the various versions and derivations I create for that project, and in those subdirectories, I place the schematic and board files.

My naming scheme is based on major.minor indications, that work in progress is in just another subdirectory, and that the difference between a major and minor version is whether or not the schematic has changed significantly.

In the PC world where I started off, ExpressPCB has a CAD package that links PCBs back to a schematic, but the schematic doesn't know about the boards that are derived from it. This lets me have several different PCB designs based on a single schematic. This fit my workflow of creating a logical design (schematic) and then iterating on various board designs until I decide to fab a sample board.

While EagleCAD doesn't do this the same way, I have found a way to get the same result - a set of versioned project directories with the .sch and .brd files the way they were for that version:

  • I open the project I want to clone/change (i.e., .../Detector/1.0/Detector.sch),
  • Immediately do a "Save As", which pops up a dialog
  • create a new subdirectory (i.e., .../Detector/1.1), and finally
  • save the project there,
When compared to the PC software, this leaves me with extra copies of
the same schematic in each subdirectory, but gives me the unique board



Project Backups

My eagle working directory is a Dropbox folder, and Dropbox supports file versioning and overwrite protections Because of this, I never worry about safety copies of my files unless I'm working on my laptop somewhere with no network access.

Project Archives

Archives, on the other hand, are copies of my project at milestone points in the development life of the project. Maybe I just want to share a design with others for comments, or maybe I want to fab a sample board - or (rarely :smile: ) I'm actually done and ready to fab a larger production batch - at these points in time, it is important to be able to reference the sch/pcb files exactly as they were.

First Attempt

My first workflow based archiving effort leveraged the built in CAM processor and a shell script. Whenever I was ready to share, I ran the EagleCAD CAM processor with a custom JMP-gerber CAM Job, then ran my Makeboard script to create an archive subdirectory, copy the schematic, board and CAM job output files into it, and generate tar and zip files for submission to fabs; the script also copied the resulting gerber zip file to a "CurrentOrders" directory to remind me what I need to order next time I did a fab run:


Second attempt

I quickly got tired of "click CAM, click Load job, click run job, then go to another window and run the shell script". I also found I wanted pictures of the schematic and board that I could post on this website (which entailed more click-and-type-and-click followed by more scripting...). With a bit of googleing and (gasp!) reading the manual, I was able to figure out how to invoke scripts and programs from within EagleCAD. Along the way, I convinced myself that this was too hard, and decided there should be a better way: I could do it the other way around and run a script that invoked EagleCAD. This path had/has its own share of issues - including CadSoft's inability to keep releases backwards compatible, but with a little bit of fiddling once a year or so, it works!

The script I wrote:

  • invokes EagleCAD to generate the CAM job files
  • invokes it again to generate the various images
  • runs Makeboard on the artifacts, and even
  • uploads the results to this website.

I started documenting my projects by adding a DESCRIPTION file to each project directory. EagleCad uses the first line in its control panel to tell you a bit more about the project, and ignores the rest. I took advantage of this and added wiki markup text to the end. Soon, I was adding jpg photos of boards, PDF files and other artifacts, and the script got more and more complex; I refactored it several times now, and it is pretty stable.

The workhorse scripts to look at are Makeboard, DoEagle and Upload2web.

I typically run
doEagle _project_ in the versioned subdir of a project I'm working on to archive and CAM things, followed by
cd ..;upload2web _project_ to update the website.

I wrapped them in a set of Makefiles and am able to easily regenerate all the eagle project info in this wiki with a single command.

Make a symlink to this Makefile in each eagle project subdirectory ( ln -s ../Makefile.project Makefile )

``` {.make .numberLines} SUBDIRS := $(wildcard */.) SUBDIRS := $(subst /.,/,$(SUBDIRS)) PROJECT := $(shell basename $$PWD)

all: upload

upload: $(SUBDIRS) upload2web

subdirs: $(SUBDIRS)

.PHONY: subdirs $(SUBDIRS)

$(SUBDIRS): @echo “==== $@ ====” @(
if [ ! -f $@/Makefile -a ! -h $@/Makefile ]; then (cd $@; set -x; ln -s ../../Makefile.board Makefile); fi;

Makefile.board - in the each individual project version directories.

``` {.make .numberLines}
all: gerbers

        if [ -z "$(PROJECT)" ]; then \
                parent=`cd ..; pwd`; \
                PROJECT=`basename $$parent`; \
        fi; \
        (set -x; doEagle $$PROJECT); 

MacOS/Linux shell scripts:

  • upload2web - a shell script to do CAM processing, archiving and wiki website content updating. Presumes doEagle has been run.
  • DoEagle - a shell script that does the CAM job processing (and more) by invoking EagleCAD from the command line.
  • WalkSite - a shell script to walk thru a project directory tree and validate/fix the file and subdirectory naming schemes
  • mvname - a shell script that renames files in bulk (change foo.* to barbaz.*)

Schematic Layout

Here's where the basic hygiene comes in. There are a few simple, but often unstated, rules that will make things much easier for you when you interact with the larger Eagle community:

  • Use a 0.100" (100 mil) grid for your schematic layout. Gratuitously violating this rule (especially when creating reusable library parts - I'm looking at you, seeed OPL...) will let you create parts that WILL NOT CONNECT to each other. If you mess up, the standard EagleCad ULP ""snap-on-grid-sch.ulp"" can help
    • GRID = SCH mil 100 1 dots on alt mil 50;
  • It can be a pain, but it really helps when it comes time to buy the parts for your project if you assigned correct values to all the parts
    • Since the silk screen for a decimal point is often impossible to see, I use a labeling scheme where the decade multiplier acts a decimal point: 2m, 2m2, 220k, 22k, 2k2, 220R for 2meg, 2.2meg, 220k, 22k, 2.2k and 220 ohms.
    • I'm a bit lazy here - standard things like breakaway 100mil pin headers and standard connectors don't always get a value
  • Use a FRAME-LETTER part on each schematic sheet that records the metadata about that design. Place the Frame origin at (0,0)
  • Use named nets, XREF symbols and grouped subassemblies to keep your schematic neat and organized
    • Use the GND symbol for ground connections instead of running a continuous wire net everywhere on the schematic. (If you use a square pad for grounds on your PCB, it makes it easier to trace/test a board, too!)
    • Use the same VCC symbol for all connections that require that power source (VCC, 5V, 3.3V, VIO,...)
  • I like to use grey dashed lines (layer 97, Info) to separate complex subassemblies into smaller bits (power supply, IO drivers...)

PCB Layout

  • Use a 0.100" (100 mil) grid for your PCB dimensions, with one corner at (0,0).
    • GRID = BRD mil 50 2 dots on alt mil 25;
    • GRID = FINE mil 50 2 dots on alt mil 1;
  • For Seeed Fusion boards (which are priced based on 5cm increments), make it easy on yourself when setting board dimensions: use a 10mm grid with a 5x visible multiplier, set your board dimensions, then change back to the standard 50mil grid.
    • GRID = DIM mm 10 5 lines on alt mm 1;


:   ![](Documents-PCB-Design-howto-EagleCAD-Grid.png "fig:Documents-PCB-Design-howto-EagleCAD-Grid.png"){width="300"}

* Consider amenities like rounded corners and STANDOFFS

    • Standoffs (aka mounting holes) make it easy to mount your board to a case or backboard
    • Rectangular boards are easiest to fabricate and handle, but feel free to make the board outline fit your enclosure.


:   I prefer 50-mil radius rounded corners and a 0-width dimension


:   ![](Documents-PCB-Design-howto-50-mil-radius-dimension.png "fig:Documents-PCB-Design-howto-50-mil-radius-dimension.png"){width="300"}
  • Place parts on a 0.05" (50 mil) grid. The standard EagleCad ULP cmd-snap-board.ulp can help fix an existing board.
  • Use 10mil or 12mil traces as a default, with 8mil as an absolute minimum, as fab problems are more likely with small traces and inexpensive board houses.… Power traces should be 12mil or 16mil (500mA), with 24mil for >1A. For model railroad applications, DCC Track currents may reach 8A or more, with 200-500mil required trace widths!
  • Keep at least 8mil between traces, 12mil between power routes.
  • Manual routing always produces a better board - only use the autorouter for prototypes!
  • Manual routing always produces a better board - only use the autorouter for prototypes! No, this isn't a typo!
    • Route with straight traces and 45 degree corners. Avoid 90 degree corners, especially on hi frequency signal runs or thin traces.
    • Route from the center of every pad, not from the edges
    • Avoid concave trace/pad connections which can allow etchant to eat into the pad/trace.
    • If something will be soldered into a hole, use a via with a larger annular ring (See DRC "Restring" page) so that it is easier to solder
      • A good default: 0.04" (40mil) hole with 0.074" (74mil) diameter (not auto)
  • Use ground pours on both the top and bottom layers.
  • If you use fill polygons, make sure you set an isolate value of at least 8mil to 10mil!
  • Set the default via size to 0.020 (20mil)
    • The smallest via you should use is 0.015 (15mil) (defined by the Drill parameter), smaller invites drilling errors by the board house
  • Any panelized assemblies should have at least 3 (three) FIDUCIALS
    • Placing Fiducials on a board makes it easier to orient stencils and align automated test/assembly fixtures
    • Fiducials (FIDs) are a set of (usually) 3 non-symetrical holes placed around the periphery of a panel of boards such that
      • if there were mounting pins for each fiducial, there would be only one correct way to mount the board (left/right/top/bottom...)
      • the distance between the holes is as large as practical, and
      • the distances between each hole are similar
      • pick and place machines use these FIDs to correctly find and place components on your boards, even if the board is slightly misaligned

{width=”200”} {width=”200”}{width=”300”}

  • EagleCAD's default color schemes are OK, but could be improved. If you do change the colors, be sure to keep the Alpha value (the first 2 hex digits in the color setting in the defaultcolors.scr script) the same (180 or 200 decimal, 0xB4 or 0xC8 in hex) so that the automatic highlighting in Eagle works. The palette entries are grouped into "normal" and "highlight" colors. There are always 8 "normal" colors, followed by the corresponding 8 "highlight" colors. So colors 0..7 are "normal" colors, 8..15 are their "highlight" values, 16..23 are another 8 "normal" colors with 24..31 being their "highlight" values and so on. The "highlight" colors are used to visualize objects, for instance in the SHOW command. The alpha component defines how "opaque" the color is. A value of 0x00 means it is completely transparent (i.e. invisible), while 0xFF means it is totally opaque. The alpha component of the background color is always 0xFF.
  • Note that the palette entry number 0 is used as the background color (in the "white" palette this entry cannot be modified, since this palette will also be used for printing, where the assumption is that the paper (the printer's background color) is always white).
  • If you want to change the colors used when printing your schematic and board, change the "White" palette. Remember, the "colors" used in the LAYERs dialog are really offsets into the color table (so Top=RED below is really Top=(the color in cell 4, which happens to be RED)
  • I use the following colors:
    • Layer 1, Top - Red
    • Layer 16, Bottom - Green
    • Layer 17, Pads - golden brown
    • Layer 18, Vias - golden brown
    • Layer 19, Unrouted - bright orange
    • Layer 20, Dimension - slate
    • Layer 21, tPlace - dark blue
    • Layer 22, bPlace - loghter blue
    • Layer 48, Document - Yellow
    • Layer 49, Reference - Orange
    • Layer 51, tDocu - light yellow
    • Layer 52, bDocu - grey


  • I define several layer aliases that make it easy to focus on different parts of your pcb (see SPCoast.scr)
    • (You could copy/paste these command lines into the text box at the top of your eagle board editor, and then access the resulting menu with a Right-Click on the Layers/DISPLAY icon):

Display = Normal    NONE 1 16 17 18 19 20 21    23    25    27    39      41 42 43 44 45 46 47 48 49 51    101 102 104;
Display = Reverse   NONE   16 17 18 19 20    22    24    26    28     40     42    44 45 46 47          52;
Display = TopSilk    NONE      17 18    20 21                                                         51;
Display = BotSilk    NONE      17 18    20    22                                                         52;
Display = Unrouted  NONE      17    19 20;


  • Place the project name and version on the board (Detector v1.3 2013.12)
  • Add a date code somewhere on the board (bottom is OK)
  • Branding is important: SPCoast boards always have a Railroad Track logo somewhere on the back silkscreen, along with a website reference, a NMRA/Pacific Coast Region plug and the phrase "Model Railroading is fun!":


  • Label text sizes smaller than 40mil are effectively illegible. Consider 32mil to be the absolute minimum, with 50mil a good default.
  • All LEDs, connectors, switches, jumpers and jacks must be labeled with their purpose: Power, Reset, On/Off, IO Port A; not LED3, Switch or RJ45...
  • Unpolarized Connectors and headers must have pin1 marked by a dot or the numeral 1.
  • Pay attention to text alignment - aesthetics matter!

Starting a new project

Although it is boarderline sacreligious to say so, the CadSOFT manuals and tutorials are a good starting point. Go ahead and take the time to read their intro. (pdf).

If you are really new to Eagle, SparkFun has a great getting started tutorial.

Here is a process that I've found to work well for my needs:

  1. In EagleCAD's console window,
    1. create a new project folder with the name of your project
    2. create a new folder under this new project called "1.0" for your first design
    3. in the 1.0 folder, create a new Schematic with the same name as your project


    :   NewProject/
            :   1.0/
                :   NewProject.sch
  2. open the schematic in theEagleCAD schematic editor, and add a FRAME <br \>If you checked out the Libraries section in this guide, you will recall that it is a good idea to maintain a personal library of the components you use frequently. As you find yourself reusing a particular component (like a schematic FRAME), consider copying it to your library:
    • First, open your library (from the Eagle console window or the editor's library menu)
    • Then, in the Eagle console window, navigate to the library and component you want to copy
    • Right click on the component, and click on "Copy to Library"
    • That's it: the component is now copied into your personal library, where you can edit it, add alternate packages or, as I frequently do, delete unwanted or untested variations and footprints.
  3. Back in the schematic editor, work on your schematic
  4. When you have the bulk of your schematic captured in the editor, switch to the board editor. <br \>It will ask if you want to populate the new board with the components from your schematic<br \>say YES.
  5. Continue to the Work on Project tab...

New Revision

Whenever I

  • Send a board out to get Fab'd,
  • want to experiment with some new parts, designs or layouts, or
  • significantly change the schematic,

I create a new VERSION of an existing project by

  1. Opening up the "old" project files in Eagle and then
  2. Using "Save As"
    1. Create a new version-numbered sub directory under the project's top level umbrella directory,
    2. Copy the older version's schematic and board files in it as a starting point.
  3. Immediately update the version info found in both the schematic and on the PCB silkscreen to reflect the new values.

New Version

Whenever I

  • Send a board out to get Fab'd,
  • want to experiment with some new parts, designs or layouts, or
  • significantly change the schematic,

I create a new VERSION of an existing project by

  1. Opening up the "old" project files in Eagle and then
  2. Using "Save As"
    1. Create a new version-numbered sub directory under the project's top level umbrella directory,
    2. Copy the older version's schematic and board files in it as a starting point.
  3. Immediately update the version info found in both the schematic and on the PCB silkscreen to reflect the new values.

Updating a project

What is there to say? It turns out, lots.

This is where your electrical engineering design skills come into play, where the human factors of connector locations, aesthetic board layout and manufacturability come into focus.

  • Trace widths matter - too thin and they won't make it thru the fabrication process, too thick and they won't all fit where they need to go. The Design Rules are usually provided by your chosen fab house, and tell you the smallest things they can reliably do, the minimum spacing between things and around the edges, etc. Most of this info cam be placed into a design rules file, like this one from SparkFun.
  • EagleCad's net classes (under the Edit menu) let you associate trace widths and drill sizes with types of traces. I usually specify "power", "signal" and sometimes "DCC", with minimum widths of 24, 10 and 80 (or sometimes, 120)

EagleCad's design rule check command uses this file to check and validate your project against these constraints. While you can ignore and clear violations, it is prudent to at least understand why a particular layout is violating these constraints.

  • Component choices matter. Parts with the same footprint may appear to have the same functionality, but the datasheets may well say otherwise.
    • open collector outputs -vs- TTL: The latter can both source and sink current, the former can only sink it.
    • Capacitors have secondary characteristics that may matter - ESR is an indication of how much "resistance" a capacitor introduces into an AC circuit; you design might not care, or maybe it does, and won't work as expected with the wrong one.
    • Heat kills components. Remember I = V/R W = V * I
      • Pick your trace widths with their current capacity in mind.
      • Use ground planes and pours as heat sinks under and around voltage regulators.
    • High currents usually mean noise, especially in designs with microcontrollers and analog inputs. google(ground plane app note) will give you several good refresher references...
  1. When "done", skip ahead to the Submit to Fab section ...


If you have a Mac or Linux system, simply use the Makefiles I showed you earlier.

They invoke a couple of shell scripts to

  • generate CAM processor output files (aka gerbers)
  • archive copies of everything in a Archive hierarchy
  • zip the gerbers in a form used by fab houses
  • copy the zip file to a "pending orders" directory
  • (I also run cd ..;upload2web _project_ to update this website.…)

Rename the gerber zip file created by the doEagle script to reflect the board size and color desired:<br \><br \> to<br \><br \>

Point your browser to the Seeed website's [Fusion
product]( and upload
the zip file. I tend to choose:

2 layer

1.6mm thickness is OK
Hasl is OK, ENIG gives you really beautiful gold plated pads for $20 more, not usually worth it for me)
1oz Copper weight is sufficient unless you are building circuits that carry DCC track current, where you may find the added trace thickness that 2oz gives you useful.

If you have several boards to fab at the same time (i.e., a group order for all your friends in the area...), it is worth it to pay more for expedited shipping - while the free shipping may get to the US in a week or so, I've had it take 6 weeks. UPS's worldwide express for $40 isn't as bad as it feels - you still get 10 boards for $50 with a small order...


At its heart, the EagleCAD CAM processing simply takes the contents of specific layers and creates a toolpath file (aka gerber G-Code) that "renders" it. You can choose which layers go into each gerber file in the CAM processor UI. Before I wrapped up the CAM processing with a script, I settled on JMP-gerber as my CAM job file.

The key points to remember are:

  1. CAM job files control which "Eagle Layers" get smooshed into each gerber file.
  2. Each gerber file contains graphic data for one part of the finished PCB (top copper, bottom copper, silkscreen...)
  3. whatever ends up in a gerber file gets used for that part of the PCB.

This leads to the kinds of mistakes that make you feel really foolish (yup, all from boards I've made...):

  • If you tell Eagle to put your tName, tValue, tDocu and Document layers into the Top Copper Layer (.GTL), all your labels and text strings get "printed" in copper on that layer, shorting out the real traces...
  • If you tell Eagle to put your Top layer onto the Top Silkscreen (.GTO) instead of the Top Copper layer, you get a board with no traces on top (but a pretty silkscreen to remind you forever...)
  • If you forget to put component tNames, tValues, Document or tDocu into the Top Silkscreen (.GTO) gerber file, or if you forget to include the file altogether, your board won't have any top silkscreen.

You really should inspect the resulting gerber files to ensure they contain what you think they should contain! All these errors would have been obvious if I'd only looked at the files before sending them out to be fab'd.

  • On the Linux and Mac, the gerbv utility (requires XQuartz and fink on MacOS) is useful to inspect the resulting gerber files
  • You can use an Online Gerber Viewer instead if you don't wish to install gerbv.

For reference, here's what I put into each gerber file:

Top Copper gerb274x .GTL
Layers=Dimension, Top, Pads, Vias
Bottom Copper gerb274x .GBL
Layers= Dimension, Bottom, Pads, Vias
Top SolderPaste gerb274x .GTP
Layers=Dimension, tCream
Top Silkscreen gerb274x .GTO
Layers=Dimension, tPlace, tValues, tDocu
Bottom Silkscreen gerb274x .GBO
Layers=Dimension, bPlace, bValues, bDocu
Top Soldermask gerb274x .GTS
Layers=Dimension, tStop
Bottom Soldermask gerb274x .GBS
Layers=Dimension, bStop
Layers=Drills, Holes


  • Some board houses only need the Dimension layer on one of the gerber files; I put it into every file to avoid problems.
  • For Seeed Fusion, at least, there is no extra cost for a Bottom Silkscreen (GBO) - I use it for SPCoast branding and graphics to make all my boards have something in common with each other.
  • My Production boards don't get the *Names or *Values layers put into the silkscreen gerbers - the boards look cleaner without the text printed on them, and I don't need it when stuffing the boards.
  • Unless explicitly instructed to by your board house, NEVER check the mirror, rotate or "upside down" boxes in the CAM processor.
  • The Top Solderpaste (GTP) gerber file/CAM section is optional - I use SMT components, and use the GTP file to create a solder paste stencil (see Ohararp)


Once you have run the CAM processor, you have a directory full of "artifacts" that need to be packed up in a form used by board fab houses. I've written a shell script that validates the artifacts, packs them into zip (and/or tar) archives, archives them along with copies of the .sch and .brd files that were used to create them, and places copies into a "current orders" directory for convenience in sending multiple boards in a single order.

See: makeboard (Shell script)

After running this script in your current project subdirectory, you end
up with a project directory that contains:




as well as

The intent is for you to rename the #x#... file to reflect the actual
size and features you need to order; I renamed this file to


for a 5cmx5cm board with Blue soldermask, a 1.0mm thickness and HASL plating. You may also want to add an order number to the name to help the board house track your files.


: How do I put several copies of my board design on the same PC board?

You can have the fab house do it for you

See Seeed PCB panelization rules.

You need to document things like panel standoffs, rails and V-Cuts on your PCB outlines (Dimension/Milling layers)

You can do it yourself

As many others did (re: google(eaglecad panel)), I struggled with different ways to efficiently panelize my final board layout, for cost effective fabrication. I tried ULPs that renumbered components, I tried copy/pasting and laying things out again, and finally I saw a suggestion that caused me to do the old shrug-and-then-slap-forehead routine: Break the link between the schematic and board, then simply lay out multiple copies of the board itself in the .brd file, CAM it and voila! The downside is that part numbers on the copies get changed, but since I don't put part numbers on the silkscreen, it doesn't matter to me.

  1. Save your final design to a new subdirectory (e.g., 1.1-panel),
  2. close the schematic window (to sever the auto-consistency magic - you will see a warning message, idnore it),
  3. DISPLAY ALL layers,
  4. GROUP everything,
  5. set the DIM grid snap to the exact width (or height, depending on which way you are replicating) of your board
  6. then COPY GROUP as many times as you need to make your panel
  8. DISPLAY only the Dimension layer,
  9. GROUP all the board dimension outlines,
  10. CHANGE their LAYER to another layer (say, tDocu),
  11. DISPLAY all layers again and create a new board outline in the Dimension layer for the entire panel.

easy, duh!


EagleCAD libraries suffer from decades of cruft accumulation, neglect and changing capabilities. If you want a simple piece of advice,

  • Never trust someone else's library!

If you didn't create it, you don't really know what is in it or if it really works. The part may be obsolete, the outline or holes wrong, it may generate DRC errors when used, etc etc etc. Yes, certain parts (resistors...) may "just work" for you, but the chances are that sometime in the future you will get bit. For example, there are package footprints for SO-16 PCF8574 I2C expanders in the Eagle Libraries that can not be obtained - if you design a board around an un-obtanium package, you will be unpleasantly surprised when Mouser, Digikey or Farnell/Newark can not find the part for you! (if this happens AFTER you sent the gerbers out to get fab'd, you end up with drink coasters...)

Having said that, SparkFun's Libraries and Adafruit's are both a safe bet.

My "work in progress" library is [http://``{=mediawiki}/pub/download/docs/Documents-PCB-Design-howto-SPCoast.lbr SPCoast.lbr]

Remember, you can use the exp-project-lbr.ulp EagleCAD provided ULP to extract library parts out of an existing EagleCAD project (.scr and .brd file set)

Recomended: See KTOWN's great tutorial on creating Eagle Library Components.

What makes a good library?

  • The parts should have all been tested and validated with real parts on a real pcb.
  • Components should all be laid out so that they "fit" together when used in a 0.100" (100 mil) schematic grid and a 0.05" (50mil) PCB grid
    • Schematic: All Part PINs and package centers must be on a 0.100 (100mil) grid
    • PCB: Package centers should be on 0.05 (50mil) grid
    • Of course, package pins need to conform to the actual physical part layout dimensions
    • Many times it is nice to have the symbol in the schematic use a logical instead of physical layout.
  • All components should have standard names
    • U# - Integrated Circuits
    • Q# - Transistors, FETs
    • R#/C#/L# - Resistors, Capacitors, Inductors
    • Y# - Crystals and Resonators, Antennas, too!
    • D# - Diodes (LEDs, Shottkey, Zener...)
    • S# - Switches
    • JP# Jumper pins
    • J# Jacks, connectors, headers
  • You may find a library component that complains about not having a "user definable value"
    • To fix: edit the DEVICE in the library and check the VALUES checkbox, then save and update the library.
  • Names with Dollar signs (U$3) indicate that a library component has no Prefix.
    • To fix: edit the DEVICE in the library and change the PREFIX to one of the above names, save and update the library.
  • Silkscreen layers (I use *Name, *Value, *Place, *Docu, but not Reference) MUST NOT impinge on any Pad - DRC warnings and ugly silk screens will result.
    • To fix: edit the PACKAGE in the Library to fix, save and then update.

What makes a good part footprint?

  • All parts need >NAME and >VALUE, both in the SYMBOL and on each PACKAGE.
  • >NAME must be on the tNames layer, >VALUE must be on the tValue layer.
  • For PACKAGES, >NAME and >VALUE should be at least 32mil in size if you want to be able to read them on the board
  • For SYMBOLS, >NAME and >VALUE should be 70mil in size
  • All PACKAGEs need tPlace indicators of their mechanical size and orientation.
    • Do NOT cover pads or bare copper with any tPlace, tName, tValue or tDocu layer items.
  • The ORIGIN of the symbol or package must be located in the center of the part.
    • Where possible, the part should be symmetric around both the X and Y axises.
  • Every new part must have a DESCRIPTION containing part information and an indication as to whether the part has been proven in a prototype.
    • Use VARIANTS to distinguish between DIP, PDIP, SOIC (etc) package variations.
    • You can use ATTRIBUTES to record vendor names and part numbers; the various BOM ULPs can extract them later.
  • Symbol pin lengths should be short by default.
  • Group POWER pins together on the left side of the symbol, I/O pins on the right.
  • Group banks of functionally similar pins together (all VCC, all GND, all N/Cs, I2C,...)
    • The pin direction setting defines the logical direction of signal flow. It is essential for the Electrical Rule Check (ERC) and for the automatic wiring of the power supply pins. The following possibilities may be used:


:   {\|
|NC || not connected |- |In || input |- |Out ||output
(totem-pole) |- |IO ||in/output (bidirectional) |- |OC ||open
collector or open drain |- |Hiz ||high impedance output (e.g.
3-state) |- |Pas ||passive (for resistors, capacitors etc.) |-
|Pwr ||power input pin (Vcc, Gnd, Vss, Vdd, etc.) |- |Sup
||general supply pin (e.g. for ground symbol) |}
: Default: IO
If Pwr pins are used on a symbol and a corresponding Sup pin exists on the schematic, nets are connected automatically. The Sup pin is not used for components.



Downloadable files mentioned below * [http:///pub/download/docs/Documents-PCB-Design-howto-SPCoast.lbr SPCoast.lbr] EagleCAD Library * [http:///pub/download/docs/Documents-PCB-Design-howto-SPCoast.scr SPCoast.scr] EagleCAD SCRipt * [http:///pub/download/docs/Documents-PCB-Design-howto-SPCoastcolors.scr SPCoastcolors.scr] EagleCAD SCRipt * [http:///pub/download/docs/Documents-PCB-Design-howto-SPCoastlayers.scr SPCoastlayers.scr] EagleCAD SCRipt
If you google("EagleCad"), you will find many articles about making PC boards. Most focus on one or two details - how to place parts, draw traces, and, for the adventuresome, how to make simple parts libraries. What they don't tell you is why you should do things a certain way, what you should do first, and how to make your PCB design experience easier in the long run. For that, you need to dig deeper into CAD support forums, email threads and out-of-the-way blog posts. You might even (shudder) read the very useful documentation from CadSoft! I've tried to collect some of that wisdom here for my own sanity; maybe it will help your's as well :smile:. A little bit of structure is a good thing. When working with PCBs, repeatability and correctness are keys to success. This workflow (and the tools I've written to support it) help take the time consuming "make work" out of the process, and lets me focus board design. :[[Image:Documents-PCB-Design-howto-EagleCAD-plocher-workflow.png|900px]]
My Workflow The problems I'm trying to solve with this workflow are * I've got dozens of different board designs, most with several revisions each. Other than the sheer volume of coffee table coasters that implies, keeping track of them shouldn't be a nightmare. * In order to fix bugs in board designs - or to fab more copies of the good ones - I need to be able to reference the source files (sch, brd...) for EVERY fab run * I don't design boards full time, so I need simple actions, scripts and tools help me "do it the right way" every time * I want to be able to come back to a project after several years and figure out what I was doing, and * I want to easily share things with others - and yet not spend all my time updating web pages.