The new version of Eagle is on out! The biggest changes coming are a new design feature and an improved autorouter. We are both veterans of Eagle and PCB board design so this blog is intended as both a review and a tutorial of the new features that Eagle v7 brings. Let’s dive right in.
To make the design process more real, we decided to design a circuit from scratch. A simple circuit that Sophi has worked with is one that uses an audio signal to control a hobby servo, which could be used to control an animatronic. It’s a little early for Halloween, but Sophi had used this circuit before and planed on using it again in October. Many thanks to Scary Terry who gave us permission to use his design.
The first thing we did was use the new Hierarchical design feature. This allows you to put the schematic into modules, where each module takes up its own sheet.
Putting the schematic into modules is definitely an improvement over past design possibilities - especially for collaboration and replication. We couldn’t figure out a very efficient way to collaborate (we tried GitHub but it didn’t work very well), and a requested feature would be a way for people to “merge” changes to modules. However, the module layout makes everything look very clean and gives you a good idea of the “big signals” -- i.e. the busses and wires that are going to have to travel longer distances across the board:
Immediately you can see that the UI on the left has a new look. It is laid out in the same order as Eagle always has been, however the symbols look more modern and (for new users) recognizable.
One thing that could be improved upon is that the module names are brought in along with the component name such as TIMER:R5 for a resistor in the TIMER module. This gives you very long names in your silkscreen, which can be annoying for even a board with such spread out components. To take care of this, we ended up shortening the names of the modules and deleting the names of all of the resistors and capacitors. We are unsure of what a good solution to this issue is. Perhaps module names could be on a separate layer so that the layer could be hidden if desired.
This board should be very easy for the Autorouter to pull off as it is all through-hole parts, and the components are widely spaced. We left in the standard DRC. Here is the board before the autoroute:
Autoroute is located in Tools->Autorouter. An Autorouter Main Setup dialog box comes up once selected. In this version, there is a new routing algorithm called Variant with Top Router. From Eagle documentation, this means that the routing is based on a gridless and topological approach.
Eagle’s documentation says that this routing method “produces considerably less vias than the traditional approach”.
Within a few seconds, some of the board has been evaluated and ready to choose a variant. It takes a few minutes to complete the TopRouter, which was significantly longer than it took to complete the other variants. In the bottom right of the screen there is a percentage which shows how close the evaluation of the board is to being completed. In the bottom left of the screen there is a dialog which shows how many of your signals have been routed and how many vias the board contains:
A very useful new feature is that you can preview what each variant does to your board by simply double clicking. We chose variant 4 because it is 100% and also because it looks the best. The TopRouter variant was adequate, but didn’t look as good as the others. All that was left to do was a final review and cleanup the silkscreen:
The finished board looks pretty good-- it cumulatively took less than 6 hours for both of us, and that included time to write down our thoughts and work through any bugs.
Autorouter Test
In addition to designing the board from scratch, we decided to review the autorouter individually. We decided to do two well-known boards, the Arduino Uno Rev3 and the Adafruit Trinket. These boards were selected because they are both extremely well known and of very different levels of complexity.
Adafruit Trinket
First up is the TrinketTrinket. We obtained a copy of the board layout from the Adafruit github library, using the 5V version.
The first thing I did was run my ulp to configure my keyboard shortcuts script, which worked great (for everyone that has had to manually migrate to new versions of Eagle, I highly recommend writing it down in a script!).
One cool feature of the new version of Eagle is that they have moved some of the more useful ULP’s into the menu. For instance, the statistics ULP can be found in Tools -> Statistics. Statistics is one of the metrics we are using to determine whether the Autorouter is doing it’s job, and it looks like we have 152 Wires and 14 vias starting out with the base design.
The first thing I did was test the Autorouter by unrouting all the non-power signals because supposedly it’s never a good idea to use the autorouter for power signals.
We are now down to 75 Wires and 7 vias. I fired up the Autorouter and selected High effort with the following settings:
I hit run and it finished in less than 30 seconds. And to my surprise (since I have never trusted the autorouter), the job came out looking pretty good! At first glance, most of the wires look like they selected good paths and there are only a couple of hanging Air wires that are grounds.
Unfortunately, these issues wouldn’t go away very easily. The standard Trinket board gets around this issue by letting the bottom ground path go through the whole board, being careful to give space between vias.
Part of the problem seemed to be that since I had routed some of the GND, the autorouter decided it was not important. To test this theory, I unrouted all GND paths and ripped up the GND Polygon. The results were fantastic.
After adding a few GND planes:
There are a few problems with this board, mostly because the GND and Power lines are so thin, but overall I am very impressed.
I ran it again with all signals removed:
This too is surprisingly good, which is a testament to how well placed the components are (all power signals are together).
According to the statistics we are at 295 wires and 24 vias-- a far cry from the incredible 152 wires and 14 vias that our friends at Adafruit have managed, but still quite impressive!
The major problem (as with most autoroutes) is that I want some of the signals to be larger. There is a trick for making this happen in Eagle. If you go into the schematics and go to Tools -> Net Classes you can select the minimum width you want a Net. When I am routing signals myself I hate this feature (mostly because many of the chips I use have power signals that are less than 10 mils), but it is a very useful feature to use with the autorouter.
First I went into the Trinket schematic and made the Voltage and GND lines be Power lines. I then changed their net class to be 20 mils (I also did 24 mils but the auto-router couldn’t get to 100% with it).
What happened? The Top Router proved it is a powerful and useful tool:
An amazing 100% routed with the TopRouter (and not routed by anything else) with only 14 vias!!!! (The same as we started with, although it has 260 Wires):
With GND planes added:
This is an absolutely beautiful board design and we cannot say anything except that the Autorouter has absolutely blown us away for this board.
Arduino Uno
We obtained a copy of the board layout from the main Arduino site.
The Arduino UnoArduino Uno started out with an error that the schematic and board are inconsistent. After calling ERC we got the following message:
This turns out to not be a bug, but rather the actual Arduino files are wrong. To solve it we used exp-libs.ulp and used it to export the correct library part in order to correct the Pad footprint.
Now time to test the autorouter. Our starting stats are 829 wires and 72 vias. Let’s see how the autorouter does.
Starting Board - power planes are not visible when a file is first opened, clicking the ratsnest icon re-renders them:
Leaving the power planes, the Atmel microprocessor signal traces and power traces VIN, +5V, +3V, AREF, USBVCC, XUSB, UGND, GND intact and still routed, leaves 363 wires and 48 vias.
With the settings at Low effort and allowing the top and bottom layers to auto direction (Eagle allows you to set preferred trace direction in 16 layers) , GO, Eagle Autorouter, GO:
The Uno takes about 8 minutes to complete 5 routing variants, including the TopRouter with about half as many vias as the original. A nice feature is that you can select each variant and view it before choosing one by pressing End Job.
Optimize4 looks the cleanest, although there are still just a few traces left to be routed. This routing job looks pretty good:
Let’s see what happens when we remove all of the non-power traces around the microprocessor and change the effort to HIGH. This time, there are 22 variants. With the Uno, it is difficult to easily see what is going on in each variant because of the power planes. To unrender the planes so that a clear view of the routing job is available, select a variant, press Evaluate and navigate to the bottom right of the screen.
Clicking on the Routing icon (furthest right) will clear up the render:
Something I think could be improved upon is that the airwires are not visible when you click on each individual variant. In order to get to the airwires, you have to click Evaluate, which renders the power planes again. In this case, cycling through each variant shows that none of them routed the wires around the microprocessor (in case it isn’t clear, that is the 32 pin SMD chip in the top left):
I am not sure why the Autorouter does not route the majority of these signals, the trace sizes are well within the constraints of the DRC and the Net class in the schematic.If you know the answer to this, please let us know in the comments! In any case, the first Uno revision, where I left the signals intact, the Autorouter performed much better. I think for a board with many more signals, it is unrealistic to expect an Autorouter to do everything for you. However, the more our design community uses the Autorouter, the more data will be obtained on these automated tools for future improvements.
Conclusion
Eagle is and has always been a solid board design tool. In particular, it has a strong community presence because of the Free and Lite version offerings. The improved autorouter and new modular schematic design gives new tools to an already solid base. In our opinion, these changes offer significant improvement and will make Eagle better to work with.