It's amazing how much I've been able to learn about circuits over the past year. While working at Walt Disney Imagineering and Universal Creative, I was able to hack together working prototypes using maker electronics like arduinos and breadboards. This week, we were able to mill, solder, and program our own programming board. By following the meticulous instructions created by Brian, I was able to create my first programming board in a little over 4 hours... and then a second one in about 45 minutes, once I'd learned the ropes.
There are two main ways to use a mill for PCB fabrication. The first is tracing. Using a 1/64th endmill (very delicate!), the mill etches the copper surface, leaving behind the electrical connections for the circuit. The second is cutting. Once the board has been traces, using a 1/32nd endmill, the mill will cut through the board based on an outline sketch. In our class, we had access to the mods interface which allowed us to change a variety of parameters.
Figure 1: Traces Line Test
Figure 2: Traces Line Results (PC: Burhan Azeem)
Before milling my circuit, as a group, our CBA section characterized our mill, so when we design circuits in the future we consider the physical limitations of the mill. To do this we uploaded the above PNG and noted the results. As you can see, it's difficult for the endmill to cut super fine details after a certain thickness.
Figure 3: FabTinyISP Trace
For tracing, upon uploading a black and white png image (see above), I was able to adjust the tool diameter (1/64th in this case), cut depth, and number and spacing of offsets from the original trace. If the offsets were 1, then the mill would only cut around the outline of the png which would make it difficult to solder the connections later. With an offset of 0 (in the software), the mill would raster all of the black space on the board, which would take longer, but result in a clean board. In practice, an offset of 4 with a stepover of .5 allowed for a mostly rastered board, with enough of a boundary to cleanly solder all the components.
Figure 4: FabTinyISP Milling
For cutting, again, I uploaded a black and white png image where the outline between the black and white denoted where the mill should cut. I could adjust the tool diameter (1/32nd in this case), cut depth, max depth, and number of offsets. Because I wanted to cut out the board, I didn't need to offset the path along the surface of the board, but instead vertically adjust the mill between each pass to cut through the PCB. Because the board was approximately .072 inches thick, the max depth was set to .072 inches, with a cut depth of .024 inches, which resulted in three iterations of cutting the board. The first time I tried to cut out my board took much longer than expected. The mill was not adjusting the height between each pass, resulting in a board that was only cut a third of the way through. To remedy this, I manually set the height of the mill between each pass allowing me to cut out the board. The next time I tried to cutout the board, I learned that I might not have been pressing down hard enough on the endmill while screwing it into it's housing on the mill. I believe that might have contributed to the issues during my first attempt at cutting, but I wasn't able to replicate the error to verify.
Figure 5: Complete Board Schematic
Figure 6: Completed Physical Board
In terms of the physical set up for tracing and cutting the board, I used a Roland MDX-20 milling machine. There was already a sacrificial layer of PCB on the mill platform, so I attached my piece of PCB using double sided tape to the sacrificial layer. In the mods interface, I adjusted the origin x and y position of the endmill, the speed, and the jog height between each tracing path. I made sure to record the origin x and y position as those values needed to align for tracing and cutting the board. Tracing the board took approximately five minutes, while cutting the board happened in about a minute. When complete, I easily removed the board using a flat metal scraper.
Figure 7: Don't try this.
Over the past year, I have dramatically improved my soldering skills (see above picture where I thought I could get away with using molding clay to hold my LEDs on a 3D printed board -- spoiler alert, not a great idea). This was an advantage this week, as the compenents we were soldering onto the board were very small. There are three main types of soldering components, through-hole, surface-mount, and chip-scale. Through-hole components have prongs that can be stuck into breadboards or through circuits to solder on the back. We used surface-mount components that were smaller than what I had used in the past, but with some practice they were fairly straight forward to solder.
Figure 8: FabTinyISP Components
Before I started soldering, I laid out all of my components on a piece of tape. There were six resistors to be soldered (ranging from 49 ohms to 1000 ohms). One capacitor was soldered on to the board (100nF). There were four diodes on the board (two were 3.3v and two were LEDs). Lastly, the 3x2 header and the ATtiny45 had to be soldered onto the board. I found it helpful to lay out everything onto a sheet of paper (with tape and labels) as well as diagram my circuit so I could quickly reference where each piece was going onto the board (and what their orientation should be, when relevant). For full instructions and specifications, check out HTMaA's documentation.
Figure 9: Soldering Components
The first time I soldered everything onto my board, I realized that my LEDs were not oriented correctly, and in the process of desoldering, I lifted the copper trace pad connecting the red LED. I decided to make a new board (more soldering practice, yay) and my second attempt went by a lot faster. I was able to solder all the components in approximately 30 minutes. When I first attempted to plug in the USB, I realized that my pads were not thick enough, so I went back and added more solder. Additionally, I sanded the soldered USB pad so the board would snuggly and securely fit in the USB connector.
Figure 10: Programming Light on Board
The final step was to program the board. I followed the Linux instructions and ran into no issues programming the ATtiny45. There was one physical step when programming the board to keep in mind. If you plan on powering other boards using the 3x2 header on your FabTinyISP board (which is powered by the USB and limited to 500mA), you should not desolder the jumper connection. Otherwise, definitely desolder the jumper connection. If you want to power many LEDs in series for example, you will have to desolder the jumper connection and power the LED breakout board or strip seperately.