Mill PCBs using Adobe Illustrator

I elected to design a couple circuit boards using a vector graphics editor rather than Eagle cad. This allows for smooth organic traces and arbitrary graphics, but can make fabricating the boards difficult. I would recommend Eagle cad or some other program that can output gerber files if you are designing a board that you might some day want to mass produce. These instructions and scripts pertain specifically to the "Modela 3D plotter" devices. These instructions are absurd and more of a satire of actual PCB milling.

Quick preview

0 - sketch it up

1 - rasterize

2 - screw around in Gimp

3 - convert to mill file using python

4 - adjust and mill board

5 - export to SVG & use python to turn SVG into drill file

7 - manually adjust and drill board

Software links

cad.py (for generating mill code, from here)

circle.py (for extracting circles form .svg and converting them to modela drill file)

modela-move.py (for manually positioning the mill)

modela-send.py (for sending a .rml to the mill with buffering)

realign.py (for applying affine transformations to .rml files)

stats.py (for getting .rml plotting bounds for sanity check)

- files not guaranteed for correctness, may generate commands that break mill, be careful

- realign hates negative numbers

- note to self : hosting on dropbox, move later

- requires python serial libraries and BeautifulSoup packages to run

0 - Draw the board. I set up a 0.25" grid which is good for 0.1" pitch components. Use circles only for component pads, and put a circle at the center of each pad. This makes it possible to strip out the circle positions with a script to generate a drill file. I connect pads with smooth splines and add custom artwork. Routing and positioning is all done by hand.

1 - Export your file and process through "cad.py" script from fab-lab to generate code for your milling machines. In fact, "cad.py" crashed when I tried to process SVG directly. Instead, rasterize the SVG at 600 DPI and process it as a .PNG. A few things to watch out for : Adobe Illustrator uses a default 72 DPI, while Inkscape uses 90 dpi. That is, units in the exported SVG file will be in 1/72nds of an inch from Ilustrator, and 1/90ths of an inch from Inkscape. Hence, opening a SVG at a DPI other than what it was created at may cause problems.

2 - I never thought I'd be using The Gimp for circuit board design. Open the 600DPI rasterized file. First, make the background is opaque, and invert the file such that traces are white and the background is black. Then apply gaussian blur followed by threshold to round out the traces, and manually corrected close traces with the paintbrush. Gaussian blus+threshold can also be used to shrink or grow the size of board features if you are having trouble with traces being too thin or too close together, but watch out for accidentally merging traces. This is absolutely absurd, but it works, and cad.py liked .PNG more than .SVG.

3 - We wrote a collection of utility scripts for the Modela milling device. These include

realign.py for apply arbitrary affine transformations to a mill file (works on standard in/out, redirect files to/from these IO streams to read/write from files). This is useful for moving the file co-ordinates to just the right spot in mill co-ordinates. This is also useful for manually aligning drill files or two sided circuit boards, since they seem to be a bit off sometimes. It can't handle negative coordinates at the moment.

The file stats.py simply prints out the number of plotting commands (redirect files to standard in), followed by the minimum and maximum x and y coordinates of the milling file. This is good for a sanity check to make sure your file is in the right location. It can't handle negative coordinates at the moment.

The file modela-move.py accepts x,y,z coordinates and moves the mill to that position.

The file models-send.py accepts a .rml file piped from standard in and sends it to the milling machine. This script is necessary to avoid overflowing the command buffer on the mill.

4 - Use realign.py to move the output of cad.py to the correct position for milling. Use stats.py to double check that your board is where you think it is. Calibrate and position the mill. You probably want to make sure the x,y,z speeds are set slow. I have been using the slowest speed of "1" because I broke way to many bits going faster. Read up on the Modela mill or ask the mill owner to train you in its operation. TODO : collect some useful links here ?

5 - Prepare the drill file. To do this, redirect a SVG of the board to the "circles.py" script. This script will extract the centers of all circles, remove duplicate circles, and create a semi-sane set of drilling commands. However, it does not use exactly the same coordinate transforms as cad.py, hence drill files are off anywhere from 5 to 40 mils ( the machine uses 'mil' as the basic unit, which is 1/1000" ). Whatever transform you applied with realign.py to the board file, do this also to the drill file.

6 - Manually adjust your pen down height to be 50 mils above the board. Run a test run to see how far off the drill file is, and use realign to move it to the correct position. I really wish I had a better procedure here. When the first hole looks aligned, set pen down to -80 mils and drill. Make sure there is something underneath the board so you don't dril through the bottom of your milling bed.

This actually works. I milled nine boards the the past couple days. Designing circuit boards in drawing programs, and using gaussian blur and paintbrush aren't generally part of the workflow for circuit board production. You can also just print off the board and use the toner transfer method, then drill by hand.

The results look nice, though 0.1" pitch is as small as it can go for through-hole work. SMT probably has a higher resolution since you don't have to worry about the holes.

p.s. : I dislike how google sends the blog post out to the RSS feed when its first created, such that subsequent grammar corrections are not reflected in people who read this blog via RSS reader. I guess this just means I should proof-read better.