Puppet Master final project page with links to all my Fab Academy work:
http://as220.org/~anna)

I designed a very simple set of modular cube-type shelves that can be stacked side by side or on top of each other to form a larger shelf or bookcase. Inner shelves will be attached with metal hardware, as will the back and sides of the shelf Download the .svg file

At this point I have completed all of the Fab Academy assignments to the best of my ability and time constraints.

Note: The shopbot project file that I will be posting shortly was not actually cut due to AS220 not having a shopbot and scheduling issues at the other shopbots in the area.

• See all my fab academy blog posts
• I am still frantically working on updating the: http://www.as220.org/~anna/
• Download the diploma completion checklist (assignments and how they were completed) Depicted below.

I wish that I could relate tips for troubleshooting the Modela milling machine in this post - but I have hit a brick wall. My boards have been milling extremely hairy for weeks - punctuated by a workable board or two out of 50 or so milled.

I have tried:

• changing the bit
• changing / tightening the set screws
• moving the position of the spindle (from high to low - low to high)
• scraping the bed with razorblades to ensure that the boards are level (we accumulate tape and glue on the bed sometimes).
• moving the position of the copper to be milled on the bed (sometimes this helps and but I can not replicate the same results in the same place twice.)
• I have tried using different batches of whatever copper stock we have left in the lab.
• I read the manual - no real help there - mostly Modela specific software tips.
• I tried booting into Windows (we usually run the machine using Ubuntu) to see if there was a “recalibration” or “troubleshooting” program or setting in the Modela software - I couldn’t find anything to run that was machine based.

When I first began using the Modela back in January - I often had these types of problems, but as I became better acquainted with the machine, the boards came out better overall, with an occasional hairy board. However, in the last few weeks I mill almost exclusively mangled boards with the occasional usable board being produced.

As I am completely out of time - I thought I would try to cut my remaining infrared prototype boards for my final project / networking on the vinyl cutter out of flexible copper sheets. The boards are very tiny - I am not sure I can get them off off the sticky background without destroying them. I cut many multiples to use as spare parts for when parts get torn. Hopefully this will work and I can finish my projects.

First - If you have not already compiled your program

See the Very Basic Beginner Assembly Tutorial: How to Use Gavrasm to compile an .asm flie

If you have compiled your program (created a .hex file)

Note: If you do not yet have avrdude installed or if you are a windows user and need avr studio - see Lady Ada’s tutorials for detailed information on how to download, setup, configure and use these programs. Lady Ada’s AVR software installation tutorial:

Once your AVR software tools are installed:

Again - Lady Ada has excellent detailed tutorials on how to use avrdude check the out for details on what the all the commands are and what they do - I will just give the very basics here to help you program a chip.

1. Open your command line interface and navigate to the directory that contains the file you want to flash to the microcontroller.

2. Connect your AVR programmer to your computer - I prefer the usbtiny (also created by Lady Ada and available at a reasonable price from adafruit studios).

3. If your board has an resonator / external clock you will need to set the fuses first before attempting to program the microcontroller. You must do this first. However, once the fuses are set - you do not have to do it again. The fuses are set only once. You can reprogram the microcontroller as many times as you want after the fuses are set.

example to set fuses:

parts used in this example:

• 20 MHz clock
• bsd cable programmer
• microcontroller - attiny44

avrdude -p t44 -c bsd -U lfuse:w:0x7E:m

You need to change the parts in the code above to match the parts you are using in order for it to work. Ask you instructor if you are confused.

example to set fuses: parts used in this example:

• 10 MHz clock
• usbtiny programmer
• microcontroller - attiny45

avrdude -p t45 -c usbtiny -U lfuse:w:0x7E:m

4. If you have set the fuses already or if your board does not have an external clock - here is how to flash / program the microcontroller.

generic example to flash microcontroller:

avrdude -p microcontroller -c programmer -U flash:w:program.hex

example with actual data:

parts used in this example:

• usbtiny programmer
• microcontroller - attiny44

avrdude -p t44 -c usbtiny -U flash:w:freqrx3.hex

This tutorial instructs you on how to compile an assembly language file (.asm) into a .hex flie using Gavrasm (Gerd’s AVR Assembler). the .hex file can then be uploaded to a AVR microntroller using Avrdude (or another program.)

1. Check to see if you have Gavrasm installed.

Open your command line interface and type:

gavrasm

If Gavrasm is installed you will see (your version number may vary):

+------------------------------------------------------------+
| gavrasm gerd's AVR assembler Version 2.5 (C)2010 by DG4FAC |
+------------------------------------------------------------+

2. If Gavrasm is not installed you will get an error.

You can download and install Gavrasm from here: http://www.avr-asm-tutorial.net/gavrasm/index_en.html.

*Note: if you are running a Mac OS (especially a pre-intel / PPC - Power PC Mac see my tutorial on where to get the compiled Gavrasm for PPC Macs or how to compile it yourself. *

3. If Gavrasm is installed — or once you get it installed:

A. navigate to the directory where the file that you want to compile is located.

- if you are unfamilar with unix commands: s To list the files in your current directory type:

ls

To change directory / navigate into a specific listed directory type (where directory name is the name of the directory you want to move to):

cd directoryname

To move upwards in the directory tree structure type”

cd ..

If you know the pathname of the directory that you want - type in the pathname of the directory preceded by “cd”

ex:

cd  /Desktop/mydirectory/mydirectory2

you can find more about general unix commands b doing a general internet search.

B. After navigating the correct directory - type:

gavrasm filename.asm

where “filename.asm” is the name of the assembly file you want to compile.

4. Gavrasm will compile the file for you and produce a .hex file of the same name as the .asm file.

Warnings:

Gavrasm will inform you if there are warnings. For the most part you can ignore the warnings. Ask your Fab Academy instructor if they are something you should be concerned about.

Errors:

If there are errors in compiling your file - Gavrasm will refuse to create a .hex file and will throw a bunch of error messages at you. Use these error messages to fix the problem.

If you don’t understand them - google the error or look at the datasheet for the microcontroller that you are using. See my tutorial on “Datasheet Tips”. Ask your instructor if you are confused - odds are they have encountered this many times. You must fix the errors in the program before it will compile.

5. You can now use your AVR programmer and Avrdude to flash your microcontroller with the .hex file you just created.

Having problems compiling Gavrasm on your Mac? Here is where to get Gavrasm (Gerd’s AVR Assembler) pre-compiled binaries for the Mac OS.

OS X 10.4.11 - Tiger (Power PC)

Download Anna Kaziunas France’s compiled version

OS X 10.5.x - Leopard

Download Kelly Snook’s compiled version

OS X 10.6.x - Snow Leopard

Download David Mellis’ compiled version

Windows & Linux

Pre-compiled binaries for Windows and Linux are available from the Gavrasm homepage. http://www.avr-asm-tutorial.net/gavrasm/index_en.html

<<<<<<<<<<<<<<    dystopian still life 
>>>>>>>>>>>>>>>   an auto-assembling
<<<<<<<<<<<<<<    cyborg zombie? 

Fab Academy Embedded Programming Assignment:

1. add (at least) a button to the serial echo hello-world board
2. modify the serial echo assembly program to respond to the button

I modified the hello serial echo board (my modified echo board version2 - see previous posts) to respond to a button and added an FTDI header so I could use it as a substitute for the internet 0 serial board. (I have a Mac and therefore no serial port).

The behavior is that the LED is always on - but when the button is pressed, it turns off.

Shawn and I modified Elliot’s reprogramming the echo board code.

Here is the code:

; Modified.Hello.Echo.Blink LED.44.asm
;
; blink LED when button is pressed
;
; Code Created At FAB ACADEMY AS220 
; by Shawn Wallace & Elliot Clapp
; Last Modified 08/05/2010  - Anna Kaziunas France
;
; Permission granted for experimental and personal use;

.device attiny44
.org 0
cbi DDRA, 1
sbi DDRB, 2
loop:
    sbic PINA,1
    sbi PORTB, 2
    sbis PINA,1
    cbi PORTB, 2
rjmp loop

Here is How to Get the Board Running:

I use an usbtiny programmer.

Copy the above code into a text file and save it with YourFileName and .asm extension. Compile it using gavrasm:

gavrasm YourFileName.asm

Compiling the file will create a .hex file.

First - set the fuses on your board:

avrdude -p t44 -c usbtiny -U lfuse:w:0x7E:m

Second - flash the attiny44 with the program code you just compiled:

avrdude -p t44 -c usbtiny -U flash:w:YourFileName.hex

I milled out the Internet Zero boards on the Modela. More information on Internet 0 can be found here, and the files for the boards can be found here, under Internet 0.

When I tried to cut the boards out on the Modela, the bit consistently threatened to drag itself through the milled traces, so I used the drill press to perforate the boards and then break them apart. (I didn't have a jewelry saw and the wood saw blade was too wide.) When separating the perforated boards, it is important to carefully apply even pressure to each side of the break. I find the easiest way to do this is to lay the board on a table, with the perforation parallel to the edge of the table (directly over it.) Push down on the piece of the board that hangs off the table, while simultaneously holding the other half down against the table. It should snap easily along your line.

I started to stuff the boards and I hope to get stuff closer to working!

Modified Echo Version 2 - In Production

I am having some issues with the Modela this week. I milled this board last night, but it came out hairy / torn up. I will give it another go tonight.

Download the Board (eagle file):

helloechobutton_07.26.2010.brd

Download the Schematic (eagle file):

Modified Echo Version 1 - Complete But Broken

This version milled out a bit hairy. Some of the traces were broken, so I used jumpers to re-connect them.
There must have been a short somewhere - after stuffing it, setting the fuses and flashing it, I plugged it in to a 9v battery and received a puff of smoke for my efforts. The LED went on - then smoke came out.

In addition, I placed the button too close to the programming header, making it hard to press the button. I am not including the Eagle board or schematic here - see version 2 for a better board.

Back to Eagle!!! See version 2 for a (hopefully) improved and working board).

After we put the spindle together - Shawn and I tested the Mantis to see if it would respond to commands. It looks like Fab Academy AS220 (with a huge effort on Noah’s part) put machine together properly.

The Mantis responded to the following commands (see screenshots) and responded well. The next step is to figure out how to feed an .rml file into the software. (in progress). After that we need to mill a board on the Mantis and see how it turns out.

“Laughing” Die 3D Scan Data

Shell 3D Scan Data

The Fab Academy Assignment The assignment was to scan an object. I used the scanning attachment for the Modela milling machine and the Dr. Picza 3 software that comes with the Modela. The Dr. Picza software works well enough, but unfortunately, it only runs on Windows.

The yellow Modela attachment (see pictures below) taps around the surface of an object using a touch sensor in order to scan a representation of it into the computer.

The objects I scanned were one of Shawn Wallace’s “laughing” dice and a shell we had laying around the lab. The output was saved as screenshots and as an .stl file that can be imported into meshlab and then cleaned up and (hopefully) printed with the Makerbot Cupcake CNC printer.

Laughing Die Scanning Process

Laughing Die Scan Output

Shell Scanning Process

Shell Scan Output

The Fab Academy Assignment

Print an object

This was my first 3D printing attempt, I used a file called “Interlocked Rigs” by ssd available from Thingaverse. I intend to scan and print my own files at a later date.

The Project: 3D Printing Linked Rings

Printing the interlocked rings with the MakerBot.

Printed Object

Cleaning Up the Printed Object

Final Printed Linked Rings

Skills Learned

Learned how to use the MakerBot

Tools Used

Makerbot Cupcake CNC

Putting together the MakerBot Plastruder spindle piece for the MakerBot 3D printer. I would describe the full process, but the MakerBot staff has already provided an excellent tutorial. http://wiki.makerbot.com/plastruder-mk4-assembly

Puppetmaster Project Overview

My final project for Fab Academy is a universal remote I am calling PuppetMaster, due to its ability to control out of reach objects / devices using the fingers. This post details the PuppetMaster boards v.1 - v.2 that use capacitive sensing.

Capacitive Sensing Board Versions

The first working version of the prototype uses capacitive sensing built on the Hello World Step response example, but converted for use with a attiny 44.

I fabbed the board(s) myself, using the standard fab inventory parts.

PuppetMaster Board Version 1 —> pitfalls / issues

I designed my own board based on the hello step response with 3 additional inputs for each of the four fingers. (The hello step response has only one input). As the hello step response example uses the attiny 45 (and does not have enough input / charging pins for 4 inputs), I modified Shawn’s version of the hello step response to work with the attiny 44. This initial version of the PuppetMaster board has a FTDI header and 4 inputs / charge pins. PuppetMaster v.1 However, there was a issue with this initial board and I could not get the modified code for the attiny 44 to work with the Hello.Step.45.py code. I attempted triage, but the board remained flaky. There seemed to be an issue between the ground pin on the chip and power. In addition, I realized that I routed the Tx to Rx wrong on the FTDI header pins. I was using jumpers to work around it initially, but after the version 1 board’s persistent flakiness, I decided to make a version 2 board. I am not including the schematics & Eagle files for version 1 because of these issues.

Code Modification: From attiny 45 to attiny 44

I modified the hello step response assembly language code to work with the attiny 44 microcontroller. Both sets of .asm files are listed below. Attiny 45 FTDI Hello Step Response Code Attiny 44 FTDI Hello Step Response Code

Puppetmaster Board Version 2

Here is the version 2 board with the correctly mapped FTDI header and some slightly shifted components to allow for more space between some problematic components. This board version has been flashed with the attiny 44 code (above) and works with Hello.Step.45.py code.

Eagle Files

Download - PuppetMaster v.2.0 Board Download - PuppetMaster v.2.0 Schematic

CAD Image Files Used to Mill board v.2

Putting the Version 2 Board Together

I ran out of time in the lab and did not get a chance to mill out the board. Instead, I scored the perimeter with a utility knife and broke off the excess edge. Then I used a rasp to file the edges down.

Capacitive Sensing in Action

Using Neil’s term.py program to visualize the initial charging graph and sensor input.

FabDiplomaCompletionChecklist2010.06.09.v.1.1

Puppetmaster Overview

My final project for Fab Academy is a universal remote I am calling PuppetMaster, due to its ability to control out of reach objects / devices using the fingers. This is the revised final project proposal - the first proposal was overly ambitious and encompassed too many sensor types in too short of a time period.

First Working Prototype: The first working prototype (illustrated in the PuppetMaster v.1-v.2 [capacitive sensing] post) uses thin copper sheets to create a capacitive sensor between the index finger and the thumb.

For Fab 6: By Fab Academy graduation I propose that PuppetMaster will consist of a fabbed board that reads gestural input from accelerometers.

Overall Project Goals / Design Considerations:

• Create a remote control that takes input from finger movements / gestures
• Remote is small and wearable (will likely look like a bracelet or a watch) with connections to the fingertips.
• Remote is comfortable enough for long-term wear, will help to relieve hand / joint fatigue

Project Plan

Short Term Project Stages (Completed by Fab 6)

All board(s) will be fabbed, using the standard fab inventory parts with a few exceptions, (the sensors used in the later stages).

The First Stage [capacitive sensing]

• Completed June 2nd - consists of using capacitive sensing as input data.

The Second Stage [ accelerometer input]

• Completion before Fab 6 in August, will include the addition of accelerometer on each finger to record control gestures.
• Simple gestures will be used for input controls.

Long Term Project Stages (Work in Progress - NOT for Fab 6)

• Additional stages (to follow in the in the Fall) will include one mode of control (IR) but other modes (radio, bluetooth) will be added as the project progresses. (See stages outlined in the table below.)
• Eventually, a dial or switching mechanism will be added to switch between the modes. Although the other modes of control mentioned above will be explored, the gestural input will be the primary focus.
• In the final version of this prototype, the user of PuppetMaster will be able to input information via gestures and remote control objects by using sensors embedded in the fingertips.
• These additional modes (combined with the necessary code) will allow the user to control almost any device with hand gestures. I also want to develop a complete gestural language (possibly based on sign language)in tandem with the addition of 6-axis sensors (3 axis gyro, 3 axis accelerometer) to the device.

The Fab Academy Assignment

• Build lab and personal pages in the class archive with your Fall work
• Create “make anything’ home page / project page. See other posts in this blog and http://as220.org/anna
• Contribute to tutorials in the class archive (see tutorials category and posts)
• Prepare a schedule for your final project (See PuppetMaster posts under 13 IP and Business Models and Year Long Projects Categories ).

Fab Academy Module - 06 Embedded Programming

The Assignment

• read an AVR data sheet (ATTtiny 44) - COMPLETE
• make serial and programming cables - COMPLETE
• add (at least) a button to the serial echo hello-world board - See Part II
• modify the serial echo assembly program to respond to the button -See Part II
• modify the serial echo C program to respond to the button -See Part II

The Project: Hello Serial Echo

This hello world board uses a python program (term.py) to send keyboard input over a serial connection from the board to the computer. It is called “serial echo” because when the computer is able to communicate with the board via serial, the python program will allow the keyboard input to be sent to the board and then “echo” it back to the computer. The keyboard input / text will then appear in the python window.

Type the following into the terminal at the prompt:

python term.py /dev/ttyS0 115200

Where “/dev/ttyS0” is the name of the serial port connection to your computer.

When It Is Working - You Should See..

Skills Learned

• I learned how to send data back and forth via a serial connection using Neil’s python program term.py.
• Cable making

Tools Used

• Modela milling machine
• python - term.py
• a computer with a serial connection

Step response board + FTDI + Capacitive sensing

My first step in building this project was to start with the basics. I milled, stuffed and programmed the hello step response board (modified to use the FTDI header by Shawn Wallace). I have a Mac and I can’t troubleshoot / develop at home with the serial header examples.

What You Will See When The Example is Working:

I am using terminal in OS X 10.4.11 - this was the terminal command I used to run the hello step response example and what it will say when it can communicate with the board and begin plotting the graph.

Anna-Kaziunas-Computer:~/Desktop/fab_runs/step annakaziunas$
python hello.step.45.py /dev/tty.usbserial-A600dVDy
finding framing ...
start plotting
0

This is the graph that is displayed:

Here is a screenshot of the charging graph that is produced by Neil’s hello.step.45.py code. This initial charging graph shows the capacitor charging up.

Here is the Capacitive Sensor I Made:

I used thin copper sheets to create the capacitor to test the hello step response board. I hooked them up to jumper wires. When they copper sheets are touching or close to it, the graph will spike up. This indicates that current is flowing through the circuit. When they are far apart the graph will flatten out. This indicates that the circuit is not connected.

For a video of this type of capacitive sensor in action - see the PuppetMaster posts.

The Fab Academy Assignment make and program a board

The Project: Fab ISB

The FabISB was designed by David Mellis. It is an in-system programmer for AVR microcontrollers. Mellis designed it so that it could be produced in a Fab. It’s based on the USBtiny and V-USB firmwares, allowing the ATtiny44 to communicate over the USB connection. It can be programmed with avrdude. See Mellis’s site for more details.

Skills Learned

This was my first board that I put together and programmed at Fab Academy

I learned how to:

• mill a board
• stuff a board
• program a board
• troubleshoot a board

I had a alot of trouble initially with this board and I made at least 6 of these at various stages of completion before I got the final one working. Some of the issues were due to my inexperience and need of practice with soldering and troubleshooting, but I discovered later that many of the problems were also due to the programmer I was using (see below).

Tools Used

• ATMEL Mini AVR ATMEGA STK500 USB Programmer ISP (initially)
  • I had a lot of trouble with this programmer. I could not get it to green light on most of my boards - and when I did get a green light, it was unreliable. It would often go green - then yellow - then red. I would unplug it and then plug it back in and get flashing yellow or green.
  • I also wanted my own programmer to work with at home (the Ateml Mini belonged to the lab), so I purchased the very inexpensive USBtinyISP kit. This turned out to be a great solution. I occasionally have an issue with it heating up the boards a bit, but it doesn’t give me flaky results like the Atmel mini. Without the USBtinyISP, I would not have been able to complete any of the electronics / board related assignments with fabbed boards.

• USBtinyISP AVR Programmer Kit
  • I found this programmer much easier to use than the Atmel Mini.
  • available from Adafruit Industries
  • post on putting it together here (link to post)

The Fab Academy Assignment: make serial and programming cables

Most of the effort in putting the cables together should be directed at figuring out how the pins match up to the wires before attempting to put the cable together.

Headers:

• Use 6-pin headers for the programming cables
• 4 pin headers for everything else (you can use a 6 pin header if you map it correctly, the unused pins will hang off the side of the pins, but that is fine.
• Serial cable header / connector.

The rest of the cable assembly is fairly simple. Using the diagram that you created to match up the pins - thread the wires through the connector, (ensuring they are in the correct pin positions). Then crimp the wires with the connector by pressing down until the header is securely attached.

If you need to split ribbon cable wires into segments in order to map the pins correctly, secure the strands with electrical tape to make it more difficult to pull them out of the header.

Fab Academy Module 15:

Invention, Intellectual Property and Business Models

The Fab Academy Assignment

Develop a plan for distributing your final project.

Distribution Plan

I plan to distribute my PuppetMaster (see Final Project pages in the main navigation for details on this project.) final project through my website as downloadable schematic and board files. Releases will be made available as individual stages are completed. If the project becomes popular, I may consider distributing it as a kit.

It is unlikely that I will patent this device, as patents are expensive and afford little protection unless you are the owner of a large company with deep pockets who is prepared to litigate.

I instead intend to use the Creative Commons for both licensing and helping others to locate these plans. (a non-commercial - modifications allowed - share alike license seems to make the most sense). This will enable me to keep the copyright to my work while allowing others to us, modify and improve it.

I will create and register the actual license when my final project is closer to completion.

Skills Learned

• Creative Commons licensing structure.
• A broad overview of patents and MIT distribution models

The Fab Academy Assignment: build a network with at least two nodes The Project: Internet 0

Progress so far:

• milled out boards:
• 2 leaf nodes
• 1 serial board
• 1 hub board
• made cables
• stuffed boards
• flashed all boards
• tested network

Tools Used

• Modela milling machine
• Python Cad

Individual Boards / Boards in Stages of Completion

Network Operation: I could get the leaf notes to respond to each other. When I pressed the button to connect node 1 to node 2 and vice versa - the LED’s would blink on the opposite board.

The setup went smoothly until I tried to view the IP addresses over the computer via the serial board / port. At first I thought it was the serial board - perhaps there was something wrong with it - but after much troubleshooting, I couldn’t find anything wrong (except it didn’t work). I then tried using an echo board that I knew worked properly, but still not communication with the computer over the serial port. Shawn, Makeda and I worked on it in the lab for a while, but nothing came of it.

The Assignment

• Make a machine (group project)

I've been figuring out how to use Processing. It's open- source, so you can download it for free and find tutorials on the Processing website. I created the image above with one of the simple beginning codes, and the images below were created by modifiying that code. A sort of storm Undulating waves like unraveled knitting Then I figured out how to code different colors. I drew this with a mouse

class header_FTDI(part):
#
# serial comm header
# FTDI 1x6x0.1"
#
def __init__(self,value=''):
self.value = value
self.pad = [point(0,0,0)]
self.labels = []
#
# pin 1: GND
#
self.shape = translate(pad_header,-.08,.0,0)
self.pad.append(point(-.08,.0,0))
self.labels.append(cad_text(self.pad[-1].x,self.pad[-1].y,self.pad[-1].z,'GND',14))
#
# pin 2:CTS#
#
self.shape = add(self.shape,translate(pad_header,-.01,-.0,0))
self.pad.append(point(-.01,-.0,0))
self.labels.append(cad_text(self.pad[-1].x,self.pad[-1].y,self.pad[-1].z,'CTS#',14))

#
# pin 3: VCC
#
self.shape = add(self.shape,translate(pad_header,.06,.0,0))
self.pad.append(point(.06,.0,0))
self.labels.append(cad_text(self.pad[-1].x,self.pad[-1].y,self.pad[-1].z,'VCC',14))

#
# pin 4: TXD
#
self.shape = add(self.shape,translate(pad_header,.13,-.0,0))
self.pad.append(point(.13,-.0,0))
self.labels.append(cad_text(self.pad[-1].x,self.pad[-1].y,self.pad[-1].z,'TXD',14))

#
# pin 5: RXD
#
self.shape = add(self.shape,translate(pad_header,.2,-.0,0))
self.pad.append(point(.2,-.0,0))
self.labels.append(cad_text(self.pad[-1].x,self.pad[-1].y,self.pad[-1].z,'RXD',14))

#
# pin 6: RTS
#
self.shape = add(self.shape,translate(pad_header,.27,-.0,0))
self.pad.append(point(.27,.0,0))
self.labels.append(cad_text(self.pad[-1].x,self.pad[-1].y,self.pad[-1].z,'RTS',14))

Image © Shane Willis

The project page for my PuppetMaster final project (and all of my Fab Academy project content) is located here: http://as220.org/~anna/

I put 1.5g of salt in 1L of water and it went from 2 megaohms to 4 megaohms. Does that seem right to you?

View the project page here.

Can be found here:

http://eclapp.com/fabacademy/

Final Project Overview

My final project for Fab Academy is a universal remote I am calling PuppetMaster, due to its ability to wirelessly control out of reach objects / devices using the fingers. This device enables the user to remotely control infrared receiving devices (such as a television or stereo) from a maximum distance of 100 - 150 feet. The user of PuppetMaster will be able to operate the remote by using switches embedded in the fingertips. The board and power supply will be worn around the wrist like a watch or bracelet. (This makes weight and a small form factor a major design consideration for this project). Additional controls will be added in later stages. (see details below)

Form Factor / General Idea Mockup

If IR model - Infrared LED would be placed on top of hand in wrist strap.

I intend to fab the boards myself, using the standard fab inventory parts with a few exceptions, (especially the sensors used in the later stages). The first stage (to be completed by June 1 for the fab academy final project) consists of one mode of control (IR) but other modes (radio, bluetooth and additional gestural sensors) will be added as the project progresses. (See stages outlined below.) A dial or switching mechanism will be added to switch between the modes. These additional modes (combined with the necessary code) will allow the user to control almost any device with hand gestures. I am also keen to develop a gestural language in tandem with the addition of 6-axis sensors (3 axis gyro, 3 axis accelerometer) to the device.

I intend to use a lithium battery for lighter weight and longer life - that may need to come later, I am not sure I will have time to design a power supply.

Overall Project Goals:

• Create a remote control that takes input from finger movements / gestures
• Remote is small and wearable (will likely look like a bracelet or a watch) with connections to the fingertips.
• Remote is comfortable enough for long-term wear, will help to relieve hand / joint fatigue

Short Term Goals By Stage

Prototype in stages, adding functionality and additional control channels / technologies in each stage

1.0 Stage 1: Infrared

1.1. Use infrared to turn off on devices, navigate devices (most likely television)

1.1.1. Most likely commands:

1.1.1.1.On

1.1.1.2.Off

1.1.1.3.Up channel

1.1.1.4.Down channel

1.1.1.5.Other specialty features?

1.2. Power supply -> LiPo model uses lightweight lithium battery and outputs 5V

1.2.1 This is perfect for the TV-B-Gone style board I want to create / modify / fab

1.3 Parts List for puppetmaster (phase 1 - IR)

1.4. Complete working prototype by 6/01/2010

2.0 Stage 2: Radio Control

2.1. Add radio control to Stage 1 prototype

2.2. Enable mode switching on input device - different modes - different gestures

2.3. Experiment with driving a RC device.

2.4. Complete working prototype by 6/30/2010

3.0 Stage 3: Bluetooth

3.1. Add Bluetooth to Stage 1 prototype

3.2. Enable mode switching on input device - different modes - different gestures

3.3. Experiment with driving a RC device.

3.4. Complete working prototype by 7/30/2010

4.0 Stage 4: 6-axis motion sensors

4.1. Add additional sensors to interface:

4.1.1. 6-axis motion sensors (3 axis gyro, 3 axis accelerometer) to input gestures.

4.2. Complete working prototype by 11/01/2010

5.0 Stage 5: Gestural Language

5.1. Utilize 6-axis motion sensors (3 axis gyro, 3 axis accelerometer) to input gestures.

5.2. Creation of full blown gestural language (possibly based on sign language)

5.3. Complete working prototype by 11/01/2010

6.0 Stage 6: Personal LAN

6.1. Connect to the internet to create personal LAN.

6.1.1. Most likely by fabbing a board that can plug into an iphone,

6.1.2. This board could then provide any other user devices with data access

6.1.3. Could connect to Premonition system

6.2. Complete working prototype by 11/01/2010

Schedule:

Distribution Plan

I plan to distribute this project through my website as downloadable schematics and board files. Releases will be made available as individual stages are completed. If the project becomes popular, I may consider distributing it as a kit.

It is unlikely that I will patent this device, as patents are expensive and afford little protection unless you are the owner of a large company with deep pockets who is prepared to litigate.

I instead intend to use the Creative Commons for both licensing and enableling others to find these plans. (a non-commercial - modifications allowed - share alike license seems to make the most sense). This will enable me to keep the copyright to my work while allowing others to us, modify and improve it.

I've been lasercutting a lot of textiles for a while now. My diorama will be illuminated by a chandelier of lasercut textile and flameworked glass plants. The LEDs will be attached to a photosensor. As ambient light fades, the LEDs will get brighter. These are LEDs that will be within the textile plants.

I assembled these form studies to get a better sense of scale for larger chandeliers. I flameworked these glass components. These forms will also house LEDs. Above are some dolls that I sculpted. I also lampworked the glass eyes, and made the clothes and wigs.

The diorama will display automated figures controlled by servo motors. The figures and the diorama itself will include some cast parts.

My method of distribution for this project is to document the animation, and to use photographs of the diorama as illustrations. My intention is to make a series of these animated dioramas, and use the documents to delineate longer narratives; to illustrate books and compose longer animations that can be distributed.

I initially wanted to do reverse-osmosis water desalination, but then I discovered forward osmosis, which uses ammonia salt to pull the water through membrane, detailed in this page about Yale's evaporative draw-solution system, but then Shawn emailed me a link to Ion Concentration Polarization, which reduces filter clogging, and decided to switch to making an ICP water filtration device with shrinky-dinks In the mean time I noticed that water desalination isn't very fabby, so decided to tack on a PPM/Ph meter and use feedback to calibrate the device.

I then proceeded to accomplish nothing. I don't know how to attach electrodes to anything small, and DuPont doesn't provide samples of Nafion, so I'll have to order some, and right now I'm just concentrating on getting parts together for the salinity meter, but that's a well-documented project I haven't done any research of my own on.

I'm considering switching to building a long-range capacitative+inductive RFID meter with an SD card to do a generic survey of RFID at this point, I guess I didn't panic early enough.

-\n

Stravinsky's first opera was The Rake's Progress, and for years after he always intended to compose another. In 1953 he met with Dylan Thomas in New York to hash out the details of a libretto for an ambitious opera to be commissioned by Boston University. Several possible scenarios were tossed out, including a postapocalyptic love story and a libretto written by a large number of monkeys on typewriters. As fortune would have it, the poet died before the opera could be realized. This machine tells the story of the unfinished opera using the vernacular designs and mechanisms of pinball.

Design

The game components will tell the story of the opera by combining the following elements:

4 possible scripts
12 characters
12 props
12 locales
26 typewriter keys

Each of the elements is keyed to a target on the playfield and has corresponding LED feedback.

General color guidelines for the design are:

Black and white cross-hatch  
Spot complementary colors: orange/blue, purple/yellow  
Collaged b&w paper images

Components

The various components fall into these categories:

 Manual Input
       Flipper
       Plunger
       Coin op

Automatic mechanisms
    Ball return
    Tilt and bump sensing

Tracked Input
    Targets
    Bumpers
    Holes
    Switches

Output
    Lights
    Sound and music
    Score
    Backglass display

In the triage process of the final week I have focused on getting two output systems working; the LED array drivers and the sound and music generator.

The Electronics

The two working playfield ornaments are based on the Fabian Arduino-compatible board.

The Fluxamafet: sixteen N channel MOSFETs on an Atmega168. Controls banks of LED arrays.

The Fluxamamidi: An Atmega168 that generates MIDI sequences for all the sound effects and music in the game. Can read MIDI patches from an SD card and play back according to script and input.

The Fluxamabox (UNFINISHED): A MIDI to audio sound generator based on the ATSAM2195.

The LED arrays

I started by milling a bunch of breakout boards grouping six LEDs into different configurations:

Coupled with the controller, they formed a dreaded floating octopus of wires:

Although they look nice from the front:

For the next group I decided to use the vinyl cutter, which works well for this kind of application:

Programming interface

A Processing interface for visualizing the array. Because Processing is syntactically similar to Arduino, you can cut and paste the model and upload as working firmware.

Here's the Processing code.

Flippers

For now, the flippers are activated by (120V AC) sewing machine solenoids that I happen to have a lot of. I also have a bunch of 5V electromechanical relays that can switch them. Eventually I will swap these out for two-coil flipper solenoids comparable to those at pinballmedic.net.

The Playfield

Just got my pinball balls in the mail:

Here's a picture of the piece of acrylic I cut some holes into for electrodialysis (which also functions as a rough model of a potential ion concentration polarization device.)
Note that I have lack knowledge of even basic electrohydrodynamics, so it's likely this implementation of both of these concepts is completely unsound.

I wrote a small clutter program to change the position of a picture of a Muybridge elephant based on the output of the step response board:
hello.elephant.py
This is the code that runs on the FTDI version of the step response board

It was going to be a skateboard...
Source File

I built Shawn's modified FTDI version of the step response board and got it working, I'll edit this entry to add pictures later.

-\n

XBee Networking from elliot clapp on Vimeo.

Faboost is an automatix-style script to download dependencies for and set up Fab Lab computers.

-\n

Clay model to determine form factor.

Structured light scanning attempt. Figuring out slices for laser cut frame.

PCB designs for buttons and bridge.

Here is a very brief clip of a nodding head.

I attached a doll head that I sculpted (with flameworked glass eyes) to a servo motor. This will be part of a larger diorama of dancing automatons that I'm working on.

The Mantis, built from a kit designed by David Carr as part of the Machines That Make project.

Boards for the Fab Net controller and drivers designed by Ilan Moyer.

Here's a little board that can be used as a button interface to a three axis machine (X+/X-, Y+/Y-, Z-up, Z-down). It is implemented as a voltage divider, so the various button presses can be read on a single analog input pin. Here's the schematic:

I'll have better photos and schematics later in the week after I stress test the thing, but I was happy with how it came out and wanted to post some pictures. The Fabian (named after our cat, though you could pronounce it FAHB-IAN if you want) (oh, and a funny thing happened to Fabian yesterday; he was chasing bees, caught one, and got stung on the lip) is a student-friendly, Arduino-compatible board that can be milled in a Fab Lab. More to come.

This is the first variant of the "Fabian" board that I made; it is the simplest controller for three unipolar stepper motors you can imagine. I thought this might be useful for someone who is building a bootstrap machine with handtools. This board could be used as a controller to mill a better controller, which could then be used to mill out the final parts. Arduino-compatability means there are a lot of people out there who can program it. The firmware is a simple HPGL parser and moveto function.

I'll admit it: I've been having trouble with traces ripping up after repeated use of the surface mount pin headers we've been using in the lab. Here is a solution: a development board for the Attiny45 that is easy to use with a breadboard or to incorporate into a project with through-hole wire connections. It also has a sturdy six pin header for an FTDI USB to TTL cable. The Eagle schematic and board files are linked below:

Schematic

Board

I created this simple interface to control turning on and off an LED that is attached to a microcontroller via the serial port on my Mac. I wanted to see if I could get the ControlIP5 (used to create the GUI), Firmata and serial libraries working together before I tried using more complex hardware. I intend to experiment with driving multiple servos and possibly tinkering with bluetooth using the NXT library as an "cheap" way (it's "cheap" because I already own the Mindstorms hardware) to play around with bluetooth without buying additional bluetooth modules.

The Interface: Default / Initial State:

The interface is simple - the Turn On button turns the light on and the Turn Off button turns it off.

The Interface: Button Rollover State:

Here's the Processing code:

/*-------------------------------------------------------------------
 * Fab Academy -- Module 09: Interface Programming
 *--------------------------------------------------------------------
 * Assignment: Write a user interface for an input &/or output 
 * device.
 *--------------------------------------------------------------------
 * Purpose:  This program is a test to get the controlIP5, Firmata, 
 * and serial libraries working together through the serial port.  
 * This program uses a simple button GUI interface to turn on / of an
 * LED.
 *--------------------------------------------------------------------
 * Anna Kaziunas France - 30 March 2010
 * Combined / Modified example code from:
 * controlIP5 buttons example (included the library download)
 *------------------------------------------------------------------*/


import processing.serial.*;
import cc.arduino.*;
import controlP5.*;

ControlP5 controlP5;
// we have to use controlP5.Button here since there
// would be a conflict if we only use Button to declare button b.
controlP5.Button b;
Arduino arduino;

// Variables
int ledPin = 11;
int buttonValue = 0;
int myColor = color(0);

void setup() {
  arduino = new Arduino(this, Arduino.list()[2], 57600);
  arduino.pinMode(ledPin, Arduino.OUTPUT);
  size(640,480);
  smooth();
  frameRate(30);
  controlP5 = new ControlP5(this);
  controlP5.addButton("Turn_On",255,200,80,100,70);
  controlP5.addButton("Turn_Off",0,200,160,100,70);
  println(Arduino.list());
}

void draw()
{
  background(myColor);
  fill(buttonValue);
  rect(20,20,width-40,height-40);
}

public void controlEvent(ControlEvent theEvent) {
  println(theEvent.controller().name());

}

// function buttonA will receive changes from 
// controller with name Turn_On
public void Turn_On(int theValue) {
  println("a button event from Turn_On: "+theValue);
  myColor = theValue;
  arduino.digitalWrite(ledPin, Arduino.HIGH);
}

// function buttonB will receive changes from 
// controller with name Turn_Off
public void Turn_Off(int theValue) {
  println("a button event from Turn_Off: "+theValue);
  myColor = theValue;
  arduino.digitalWrite(ledPin, Arduino.LOW);
}

The Fluxamaphonic by Elliot Clapp from Shawn Wallace on Vimeo.

These DIY game controllers are made from pennies and cigar boxes.

They are a sample controller for the Fluxly video game, a wizard duel where you have to build your own controller to compete. The interface for the game is implemented in Actionscript and compiled using Adobe's free mxmlc compiler.

Python-GTK notebook

I demonstrate soldering components onto a step response circuit board that was milled on a Modela CNC router. My technique is informed by my soldering experience in silversmithing.

At first, the camera wouldn't focus on close- up shots. Brandon had the great idea of placing a magnifying lens in front of the camera. This setup worked wonderfully!

Today I milled out my first PCB on the Modela. Technically it is not a “printed circuit board”, but machined out of copper-clad PCB stock.

Fab Academy Assignment

The assignment is to design a circuit board, mill it, and program it in assembly language. This post documents Part 1 of this process which entails:

• Designing the board (For this board I used the already created Fab ISB board file - I plan to design a board for a later project).
• Machining the board

Part 2 will document the process of putting the components into the board. Each student had to become acquainted with the following work flow:

• Stuffing components
• Programming

The first step in making a board is to create a tool path to send to the machine:

To Mill the Board:

• Import a PNG image into cad.py.
• Create the tool path in cad.py
• Send to the Modella

To Cut through the Board:

• Import the border PNG image into cad.py
• Create the tool path in cad.py
• Send to the Modella

I am ready for Halloween early this year. For my I/O sensor project for Fab Academy I put together a Arduino-controlled motion sensing glowing skull. When motion is detected by the parallax motion sensor, the board turns on the LEDs in the mouth and fades in and out the LEDs glued into the eye sockets.

Parts List:

• 1 Parallax PIR [Pyroelectric ("Passive") InfraRed)] motion sensor
• A few lengths of wire
• 1 Arduino compatible board (I used a Seeduino (Seeed Studios) I had laying around). I like this board because I can flip the power source switch to turn it off / on.
• 1 9 volt battery
• Mouth: 10mm Red LED (3)
• Eyes: 5mm Red Wide-Angle LED (2)
• 5 in or so metal strip with holes (to house mouth LEDs
• 3 plastic LED holders (to insulate the mouth LED wires from the metal strip)
• super glue / hot glue

Prototyping the Circuit / Interaction + Putting It Together:

Code:

The code works - but needs to be modified, right now after the motion is activated, the lights stay on / fade in and out in an infinite loop until the power is switched off. Look for an update to this post.

Arduino code for the LEDs and Parallax PIR Motion Sensor:

/* -----------------------------------------------------------------
 Anna Kaziunas France
 --------------------------------------------------------------------
 Fab Academy - Sensors I/O Module
 Glowing Skull Project
 03/02/2010
 --------------------------------------------------------------------
 Motion Sensor code:
 Motion Sensor code:I have seen this code a few places,
 it is never attributed to anyone in particular. 
 I saw it last at: http://www.ladyada.net/learn/sensors/pir.html
 --------------------------------------------------------------------
 LED Fader code by: By David A. Mellis - Created 1 Nov 2008
 Modified 17 June 2009: By Tom Igoe
 http://arduino.cc/en/Tutorial/Fading
 --------------------------------------------------------------------
 Combined / Modified by Anna Kaziuans France - 03 March 2010
 --------------------------------------------------------------------
 
 --------------------------------------------------------------------
 Purpose of this Program
 --------------------------------------------------------------------
 Read input value from the sensor
 Determine if motion is present (input is HIGH)
 
 When motion is detected via motion sensor:
 1. Eyes slowly glow red (fade in and out - continue)
 2. Mouth glows (steady)
 
 When motion is not detected after (length of time)
 Switch off LEDs
 
 Switch turns Skull on and off (hardware only)
 ------------------------------------------------------------------*/

// Variables
int ledPinSolid = 13; // choose the pin for the LED
int ledPinFade = 11; //
int inputPinSensor = 2; // choose the input pin (for PIR sensor)
int pirState = LOW; // we start, assuming no motion detected
int val = 0; // variable for reading the pin status

void setup() {
  pinMode(ledPinSolid, OUTPUT); // declare Solid LEDs as output
  pinMode(ledPinFade, OUTPUT); // declare Fader LEDs as output
  pinMode(inputPinSensor, INPUT); // declare sensor as input

  Serial.begin(9600);
}

// Begin Motion Detection
void loop(){
  val = digitalRead(inputPinSensor); // reading input value
  if (val == HIGH) { // if the input is HIGH
    digitalWrite(ledPinSolid, HIGH); // turn LED ON
    // sets the value (range from 0 to 255):
    analogWrite(ledPinFade, HIGH); // turn LED ON
    // fade in from min to max in increments of 5 points:
    for(int fadeValue = 0 ; fadeValue <= 255; fadeValue +=10) {
      // wait for 30 milliseconds to see the fade in effect   
      delay(400);                           
    }

    // fade out from max to min in increments of 5 points:
    for(int fadeValue = 255 ; fadeValue >= 0; fadeValue -=10) {
      // sets the value (range from 0 to 255):
      analogWrite(ledPinFade, fadeValue);        
      // wait for 10 milliseconds to see the dimming effect   
      delay(110);                           
    }
    if (pirState == LOW) { 
      // we have just turned on
      Serial.println("Motion detected Huzzah!");
      // We only want to print on the output change, not state
      pirState = HIGH;
    }
  }
  else {
    digitalWrite(ledPinFade, LOW); // turn Fader LEDs OFF
    digitalWrite(ledPinSolid, LOW); // turn Solid LEDs OFF
    if (pirState == HIGH){
      // we have just turned of
      Serial.println("Motion ended :-(");
      // We only want to print on the output change, not state
      pirState = LOW;
    }
  }
}

This project went through many adaptations and in the end, it did not turn out as a blue box, but more like a weathered garden statue. The hydrostone did not turn out completely white, but grime on the urethane molds made little swirls, further enhancing the marbleized look. It is not bigger on the inside, but the wiring and battery did fit nicely within the internal cavity. A switch turns it on and off. Although this endeavour did not turn out exactly as planned, I learned many things about thinking in 3D and many more about construction and molding objects in 3D.

So what makes this model a “TARDIS” not just a model of a British police box that looks like a light-up garden statue? Honestly, nothing but my intent. I set out to make a model of the TARDIS and that is what it will be called.

The process I used to create this model:

Previous Posts:

1. I designed the TARDIS in Google Sketchup. > See Previous Post: TARDIS: 3D Modeling

2. I used the Modela to mill out the front, individual sides and roof of the model in machinable wax. > See Previous Post: TARDIS: Moldmaking

3. I used the block of machinable wax to create urethane molds of each of the pieces. > See Previous Post: TARDIS: Moldmaking

Laser-Cut The Casting Container:

• I designed and laser cut an adjustable press-fit box to place the individual urethane molds in order to cast the TARDIS in hydrostone. (I also custom-cut shims to key in the urethane mold edges.)

Putting Together the Casting Container / Aligning the Mold:

• When casting, I did my best to align the sides and roof together at the appropriate angles and hoped for the best. An additional laser-cut box with an empty pen casing was inserted into the larger mold when pouring the hydrostone in order to create a cavity for the wires to run form the LED on the top through the cast down into the base where the wiring, battery and other components are housed. The inside box then became part of the cast.

Removing the Casting Container:

• When taking apart the mold, I found that some of the fine details of the windows and the moldings became stuck in the urethane mold or broke off easily. I may not have mixed the hydrostone long enough, or there may have been an issue with the proportions I used. Further experimentation is this matter is needed to determine the source of the problem. This breaking away of the fine detail gave the statuette a weathered appearance, like a tombstone left out in the elements.

Adding the Electrical Components:

• In addition - I wanted to have a LED light on the top to simulate the police box light, so when cutting the outside casting box, I cut a congruent interior box (see number 4. pictures above.) This small inside box allows for an open area for the wiring from the LED through the top of the hole in the stone to the battery. The wiring consists of:
• 1 ultra bright white 10 mm LED
• 1 330 ohm resistor
• 1 small switch
• 1 battery connector and a 9V battery
• A few lengths of wire

I dedicate this project to David Tennant for his the excellent portrayal of the 10th Doctor, which has just come to an end. ;-)

Image © BBC

Anna Kaziunas France
[http://www.kaziunas.com]

Everything I've posted here is hereby licensed CC-NC-SA, unless otherwise specified (or, y'know, if it's a derivative work.)

The Fuxamascanner is still in progress, so I did a quick (20 minutes) scan of a drill bit in Dr. Picza just for the lulz.

halfdrill-blender.stl

screen /dev/ttyS0 Hitting c seems to clear things, o goes to origin, and s begins scanning. No useful output yet, portmon on Windows proved essentially useless, but I have a full log of a picza scanning session in Windows as well.

-\n

Using bazaar with the fab academy repository
This tutorial doesn't have the server setup part like the previous one did, and goes a bit more into managing files.

-\n

I am still working on my Fab Academy 3D Molding and Casting project (a 3D model and cast of the TARDIS. The implementation of my model proved complicated.

Starting with the cad.py created .rml files (for details on the 3D modeling process see my

There were a few mishaps creating these molds. The z-max setting was not high enough on the side mold (you can see where the Modela bit drug through the wax and made lines that were not part of the design.). I learned that it pays to set the z-max close to the max of 1 so that it will clear the edges of the design. However, because this particular design took so long to mill out , 7 hours or so, I opted not to redo it if the damage was minor. Instead, I attempted to repair the damaged areas with wax.

After I made the wax molds, I made casts of each side and the roof using urethane rubber. The door was cast once, but the side needed to be cast 3 times to create the 3D object.

I did not allow for space at the top of the wax molds, so to ensure that the rubber would have enough room to capture the top of the design, I laser-cut some tempered masonite frames in to increase the vertical space for the rubber to fill. These frames also make it a little easier to get the rubber out of the mold. (Credit for the frame idea goes to Elliot Smith - he used this technique on his Moon Crater mold and cast).

Creating and Gluing the Frames

Mixing Urethane / Creating the Molds

At Fab Academy Providence, we used a smooth-on 2 part urethane mold mix. Just mix equal parts of each container (A and B) and mix slowly in a figure eight pattern to minimize the bubbles.

What I learned about this material:

• Mix very thoroughly. Take your time (at least 10 - 15 minutes if you can stand it). The end result will be sticky if the parts are not mixed together well - My first two molds were sticky. (suggested by Neil Gershenfeld)

• Add heat. Heat both accelerates the process and creates a less sticky end product. I used a desk lamp positioned in close proximity to the freshly poured mold. (suggested by Neil Gershenfeld)
• Be careful not to leave the heat on longer than 15 minutes or so and let the wax and rubber cool before removing the rubber mold from the wax.
• I learned the heat lesson the hard way when my mold melted from excessive heat. (see photos below)

Beware of Melting Molds

All The Molds (Good and Bad)

Next Steps:

• Create a box and system for keying in the sides of the police box so it can be cast.
• Get LED, resistor and battery to wire up the light on the top.
• Cast in hydrastone

Anna Kaziunas France
[http://www.kaziunas.com]

When reading through instructables.com, I found a great pattern for a polygon construction kit. I thought I would use it for my first laser cutter / computer controlled cutting project at Fab Academy. The instructable I reviewed is for a plastic lamp shade, but I decided to use playing cards instead and make a construction kit minus the lamp. (Also, the cards are too opaque for a lamp and I didn’t want to take a chance with heat in such a small space.) In the end, I created a sculpture construction kit.

Laser Cutting the Cards:

Putting Together The Construction Kit:

This construction kit shape can be put together to form a variety of shapes.

My Final Construction:

Anna Kaziunas France
[http://www.kaziunas.com]

Published in the MAKE Blog.

Our assignment this time around was to design a circuit board, mill it, and program it in Assembly language. Each student had to become acquainted with the following work flow:

• Designing the board
  
• Machining
  
• Stuffing components
  
• Programming
  

Makeda Stephenson in the Providence Fab Lab

In a Fab Lab, circuit boards are either milled from copper-clad PCB stock or cut on a vinyl cutter from copper tape with conductive adhesive. We try to avoid the etching process in order to limit the used chemistry we have to deal with. Whether etching or cutting, the first step is to choose one of the options for creating a tool path to send to the machine:

1. Draw the circuit as a black and white PNG image and bring it into cad.py for tracing.

2. Draw the circuit using Eagle, a free PCB drafting tool, and export Gerber files, a standard format for PCBs. Gerber files can be converted into PNGs using gerbv or the online tool from circuitpeople.com. Bring the PNGs into cad.py for tracing.

3. Draw the circuit in Eagle and use Eagle's CAM processor to generate mill and drill files that can be sent directly to the machine. This process was described by Marc Boon in a workshop at the Amsterdam Fab Lab in 2008.