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

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 final project page

Page 1 of 4 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. (However, I recommend you try the steps below if you are troubleshooting your own milling machine.) 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? 

Image credit Shane Willis. Dystopian senryu by Anna Kaziunas France.

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

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.

Eagle Files

Download Eagle file for the Board:

helloechobutton07.26.2010.brd

Download the Eagle File for the Schematic: helloechobutton07.26.2010.sch

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.

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.

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.

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

1. read an AVR data sheet (ATTtiny 44) - COMPLETE
2. make serial and programming cables - COMPLETE
3. add (at least) a button to the serial echo hello-world board
4. modify the serial echo assembly program to respond to the button
5. modify the serial echo C program to respond to the button
6. For more on items 3-5 —> See Modified Hello Echo - Part I: Hello Echo + Button + FTDI

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 Puppet Master posts.

The Fab Academy Assignment make and program a board

The Project: Fab ISP

The FabISP 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 theUSBtiny andV-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

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 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 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

Tools Used

• Modela milling machine
• Python Cad

Individual Boards / Boards in Stages of Completion

The Assignment

• Make a machine (group project)

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

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:

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);
}

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 ISP 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.

The Fab Academy Assignment

• Interface an input device with an output device.

The Project: Motion Sensing Glowing Skull

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 Kaziunas 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
 ------------------------------------------------------------------*/

// 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;
    }
  }
}

Skills Learned

• Basic wiring
• Modifing Arduino code
• How to read a sensor datasheet

Tools Used

• Arduino
• Paralax motion sensor

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, 3 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:

1. 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:

1. 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:

1. 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:

1. 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

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.

The Fab Academy Assignment

• Machine a mold and cast parts in it

The Project: TARDIS multi-mold cast

Starting with the cad.py created .rml files (for details on the 3D modeling process see my TARDIS: 3D Modeling post), I carved several molds out a block of machinable wax using the Modela milling machine.

Wax Molds

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.

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.)

• 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.
• 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)

Skills Learned

Tools Used

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

The Fab Academy Assignment

• Make a press-fit construction kit

The Project: Laser-Cut Playing Cards Construction Kit

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:

Laser Cutting Video:

Putting Together The Construction Kit:

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

My Final Construction:

Skills Learned

• I leaned how to use Inkscape to create files that would create cut shapes when sent to the laser cutter.

Tools Used

• Epilogue Mini Laser Cutter
• Inkscape

My 3D Modeling and Casting project is to make a model of the outside of the TARDIS. I used the scale and dimensions from G. Hartley’s plans to make an 8 inch model TARDIS.

G. Hartley’s Original Plans

The Fab Academy Assignment

• design a 3D model of a potential semester project
• render it
• extra credit: physically model it

The Project: 3D model of TARDIS

Skills Learned

• Learned how to create a 3D model
• learned to think in three dimensions - advance planning of how objects are put together before modeling.

Tools Used

• Google Sketchup

I used these plans to create a 3-D model in Google Sketchup

However, as the milling machine cannot carve out negative space, the faces on the sides or the model could not be created. In order to create a machinable mold, I had to take the 3D model apart into three sections: the roof, the front door and a side (3 of the sides are the same).

In addition, I also removed some details that were in the original 3D model, like the light on top of the box and the all of the “Police Box” lettering. The light was not transferring properly into the CAD file and the lettering would be too fine for the bit on the milling machine. (I plan to create a sticker or letter by hand). I also scaled the model down from 8 inches high to 4.8” so it could fit within the block of machinable wax.

Shawn Wallace suggested that I cast an LED into the model and use it for the light on top of the box. Brilliant.

The Roof, Side Door and Front Door

Sketchup exports .stl ASCII files and I needed them to be in binary. I opened the files in Meshlab and then exported them as .stl binary files. Next I ran the .stl files through stl2png.py to convert the depths to grayscale.

The final result (roof not shown)

The next steps are: 1. Mill out the 3 of the mold pieces 2. Cast with rubber, making 3 casts of the side view 3. Create a laser-cut box that will hold the mold together when it is being cast with hydrastone. 4. Cast with hydrastone.