July 2010 Archives

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.

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)

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