Author Archive

Assignment 11 – Personal Public Computing (Throwies)

Posted in 11. Project Final Reports on December 12, 2009 by sbisker

The Floating Throwie, Motown Throwie and Ventriloquist Throwie – Explorations in Personal Public Computing

Summary:
I sought to create small, cheap and fun circuits that could be quickly built and deployed by individuals in public spaces. My audience was people with some technical background who might be interested in “livening up” their cities or other public places, adding to a sense of community or just pranking each other.
The term “Throwie” comes from the “LED Throwie”, a piece of electronic urban graffiti invented by Graffiti Research Labs in New York City in 2006. An LED Throwie is created by taking an LED, a watch battery and a magnet and quickly taping them all together such that the LED leads connect to either side to the battery and the magnet is exposed. Then, the whole device is tossed onto a public metal surface, where it sticks and the LED glows for up to weeks at a time for others to see. “Throwie” is now used in the DIY community as a general term for any electronic circuit placed in a public setting by throwing and attaching via a very strong magnet. My three projects sought to see how “Throwies” could be extended using cheap off-the-shelf and hobbyist microcontrollers to add elements of personalization and telepresence to such acts of public performance.
Specifically:
The “Floating Throwie” is a circuit consisting of an LED, magnet and watch battery combination, as well as a microcontroller, a transistor, a pager motor attached to the magnet, and a pair of large helicopter paper wings attached to the whole circuit. After being tossed up, the Floating Throwie is supposed to turn on the pager motor, allowing itself to vibrate free from the magnetic surface and float down (its movement dictated by the helicopter paper wings.) It is designed to create a light show in the soft drifting of the LED. (The “Floating Throwie” does not yet detach properly, though you can throw it and it will vibrate – the design needs iteration.)

The “Motown Throwie” is constructed similarly to above, except that instead of having a pager motor attached to the transistor, a music chip with built-in speaker torn from a Hallmark greeting card is instead wired and operated by the microcontroller. After being placed and a time delay has passed (enough time for someone to find a hiding spot from which to watch people’s reactions), the speaker plays whatever the greeting card company placed on the music chip – in this case, “Ain’t Too Proud to Beg” by the Temptations .

The “Ventriloquist Throwie” is nearly identical to the Motown Throwie, except it uses the chip from a greeting card that allows the sender to record personal, 10-second messages directly onto the chip for playback. The device can thus be thrown up and play back an arbitrary audio recording (such as “Watch your step!” or “Hey, ugly!”, depending on how nice the thrower chooses to be.)

Prior art for this technique includes the “Throwie Talkie”, which uses a ATtiny45 microcontroller and blinks the LED (without additional hardware).

How It Works:
If this section’s a little long-winded, it’s because a) I’m writing it step by step for use in preparing Instructables, and b) it forks whenever the processes for each Throwie differ to avoid repetition and save space on the blog.

It seems the blog can’t handle the hundreds of photos I’ve taken to document my process. I’ve uploaded enough to begin telling the Floating Throwie story with these steps, but for the full picture set, you’ll have to wait for the Instructables (or write me directly).

The heart of each device is a small, $1 computer chip called the ATtiny13a. This chip can be programmed in C to do many things; here we program it to turn on and off small electrical devices attached to the chip. Specifically, a transistor is soldered directly to an output pin of the ATtiny, and receives instructions to turn itself off and on. In turn, the transistor, when on, turns on (by completing a circuit) an outside piece of small electronics. The outside piece of electronics is attached to the transistor either by soldering the transistor collector and emitter pins directly to high and low elements of the electronics (as in the case of the motor) or by soldering wires with metal pads that could be placed on either sides of an existing switch (as in the case of the greeting card speakers.)

The chip is first programmed by using an AVR ISP hardware programmer. Two popular choices for this task are the AVR ISP MKII (from Atmel, and also the one I own), and the USBtinyISP (from Adafruit Industries). If you don’t own a programmer already, I’d actually recommend the USBtinyISP, as it removes the step of externally powering the chip from this process (My understanding is that Adafruit takes care of that for you by letting you give your chip power directly from your laptop.)

The hardware programmer is, in turn, controlled by software. On Windows, the popular choice for this is AVRstudio, whereas in the Mac and Linux worlds, the open-source program avrdude is used (as AVRstudio is Windows-only). We assume you’re running WIndows and can download and run AVRstudio, since it provides a good integrated development environment and can step you through debugging both your code and your hardware programmer connections.
The chip is placed on a breadboard, and six wires are run from the hardware programmer into appropriate pins on the chip (in accordance with the ISP standard.) The chip is then programmed using your software of choice, which talks to the chip via the hardware (ideally at a speed of 125Mhz.) *phew!*

Fortunately, most of that is behind the scenes. You just need to put the chip on a breadboard, (for the MKII) provide it with 3V of power, and hook that power into the chip as appropriate. You wire the chip as follows: 3V goes to Pin 8 or VCC of the chip, GND goes to Pin 4 of the chip, and your resistor of size 4k to 10k connects Pin 1, Reset, to 3V. (The resistor is needed as a pull-up, meaning the programmer can electronically set the Reset pin to on or off as it sees fit. This is needed for proper programming.) I purchased a 3V coin cell CR2032 battery holder with DIP pin connections from Digikey as an easy way of quickly providing my breadboard with power, and that is the technique shown in the pictures below – but a variable power supply will also do the trick.

Then, it’s just a matter of connecting the hardware programmer to your breadboard circuit. The relevant pinouts to programming the ATtiny13a chip are as follows, and can be verified against the datasheet as needed (with the pin closest to the dot being Pin 1, going counter-clockwise as is conventional with integrated circuits):
1: Reset
4: Ground
5: MOSI
6: MISO
7: SCK
8: VCC/High
The corresponding pinouts on the AVR hardware programmer depend on the model; you should consult the datasheet for your programmer. For the AVR ISP MKII, note that a faint little triangle can be seen on the side of the female header; that indicates Pin 1 (MISO) of the ISP header. (Don’t think that the triangle represents the reset pin- a few websites say it does, but they’re wrong, at least on mine. I killed a day barking up that tree.)

Let’s walk through an example to make sure I’ve said it clearly:
Let’s say you want to start by hooking up the MISO pin of the programmer to the MISO pin on the chip. You take a wire and strip both ends of it. One end of the wire goes into the female header on the programmer (for the MKII, Pin 1, by the faint triangle), and the other end goes into the breadboard at Pin 6. To program the chip with the programmer, you must connect all 6 programming leads to their corresponding chip pins in this manner.

To clarify – we are NOT soldering the 6 programming wires onto our chip (that’s precisely why we had to grab a breadboard.) The soldering comes after the chip is programmed.

We program the chip by loading onto it the following code. In AVRstudio, we do this by:
*Selecting “Run” from the menu bar
*Selecting the “Com” button on the toolbar
*Setting your programming speed to 125Mhz
*Selecting “Use program currently in memory” and pressing “Program”.
Refer to the screenshots for details.

Once the ATtiny chip has been programmed, we can pull it off the breadboard and begin building our circuit around the chip. This is done by soldering wires directly onto the DIP pins of the ATtiny chip.

First, we create a connection between the transistor’s base pin, a 1k resistor and Pin 3 (the switch output pin we designated) of the ATtiny13a. No wire will be used to make this – all three can be soldered together in series, as shown. If possible, try to cut the leads shorter before soldering so they stay together once soldered. Also, for every connection from here-on out, heat shrink tubing can be used to help secure the connection – just cut a piece, place it onto the wire *before* soldering away from the point of solder, and then after soldering slide it down to cover the connection.

(Not necessary for purely sound-based applications of Ventriloquist and Motown Throwies) Next, we create a connection between the LED and ground so the LED is lit by Pin 2 of the ATtiny13a. This can be done by simply soldering the long end of the LED to Pin 2, and the short end to Pin 4 (the ATtiny13a’s ground. Again, cutting the leads of the LED shorter before soldering will be helpful – but remember to leave the positive end of the LED longer than the negative end, or you’ll be confused when you go to solder!

Then, you create the connections that tie the microchip’s power pins to the battery. Wires for the chip’s power and ground are soldered to pieces of copper tape, which are then folded in on themselves to give a smooth exterior. This creates reusable “leads” for the circuit, rather than soldering wires directly to the battery. This allows the battery to be quickly attached and replaced.
The wire for ground should be soldered on one end to Pin 4 of the chip, and on the other end to a piece of copper tape.
The wire for high/vcc should be soldered on one end to Pin 8 of the chip, and on the other end to a piece of copper tape.

Now, we can begin connecting the external circuit to the transistor such that electronics can be turned on and off via the microcontroller.

This is done differently for the two types of Throwies.
For the Floating Throwie: Just as we did with the power and ground wires, we take two wires and turn them into copper leads out of our circuit. We take a third wire and use that to connect our motor to the collector pin of our transistor. Effectively, we use the wires to create the following chain:
+3V (Battery High) [ ]———Motor——-Collector, Emitter——-[ ] Ground
where the +3V and Ground are the two sides of the battery, and the Collector and Emitter are the appropriate pins on the transistor.
This creates another set of copper leads, which also need to be connected to the two sides of the battery. To avoid having to tape two sets of leads onto both sides, you can solder the high leads together and the low leads together to make a single set of power leads again.


For the Motown and Ventriloquist Throwies: Just as we did with the power and ground wires, we take two wires and turn them into copper leads out of our circuit. This time, the plain side each wire goes to the two remaining pins on the transistor, and the copper end of each wire goes to the two sides of the switch.

We rip a small piece of paper and tape it to one side of each copper lead. This is done so we only expose each lead to one surface of the switch, rather than accidentally connecting multiple surfaces of the switch at the same time (which would always leave the card running).
Next we connect these leads to our greeting card. The copper lead running from the collector pin on the transistor is taped (exposed side down), to the highest voltage point in the circuit. This is the battery closest to the switch (you can verify this with your multimeter.) Then the copper lead running from the emitter pin on the transistor is slid under the switch, copper side down. The underside of the switch latch should be touching no copper and no parts of the bottom metal circuit; only paper. Here, you’ve created the equivalent of keeping your greeting card closed (and the plastic sliding under the switch to open it) at all times. Now, the switch can only be closed and the music can only be played by your microchip.

It is necessary to tie the grounds of the microcontroller circuit and the external circuit together such that the transistor is able to control the external circuit. This is done in different ways based on the external circuit (whichever is easier for that physical setup.)
For the Floating Throwie, we have already done this by powering both the chip and the motor off of the same power source – so no further work is needed.
For the Motown and Ventriloquist Throwies, the recording/music sound chips have their own power source and ground – so it is easier to use a single wire to tie the sound chip ground to the battery ground, leaving the second power source for the sound chip intact.

Finally, the circuit can be put together.
For the Floating Throwie:
Build the wing: Cut a small pair of helicopter wings out of paper. This can be done by cutting the outline of an “8” out of paper, folding a line down it the long way, and bending the fold on one of its wings outward (keeping the other wing folded inward.) The wing should now have one concave surface and one convex surface when viewed from the top. Then, cut two slits in the center of the wing, through which you can run a piece of string or thin strip of paper. Finally, wrap the string or paper around the microchip, affixing it with tape.
Attach the magnet: Finally, use hot glue to attach the magnet to the end of the vibrating pager motor.
For the Motown and Ventriloquist Throwies:
Use a piece of hot glue to attach the magnet to one side of the circuit board. Then, glue or tape the speaker onto the opposite side of the circuit board. If your card chip has a paper casing, you can contain the circuit in this paper and put the magnet and speakers on the outer sides of this paper. If it does not, you can glue these things with hot glue onto the circuit board safely, as long as you take care not to accidentally short any of the circuit board connections with metal on the magnet or speakers.

Take your watch battery and tape the leads to either side of the battery. Affix to a metal surface, run away, and after 15 seconds…voila!

Electronic Schematics:
For the Floating Throwie:

For the Motown and Ventriloquist Throwie:

Code Outline:

View this document on Scribd

Code for ATtiny13a:

#define F_CPU 1000000UL //Define the speed the clock is running at. Used for the delay.h functions
#include //Include the headers that handles Input/Output function for AVR chips
#include //Include the headers that allow for a delay function
//Prototypes
void Delay_ms(int cnt);
void init_io(void);
//Functions
void Delay_ms(int cnt)
{
while(cnt-->0)
_delay_ms(1);
}

void init_io(void)
{
DDRB = 0xFE;
}

//Main Function
int main(void)
{
init_io(); //Set up the pins that control the LEDs
int i; //Initialize variable to count through each LED
for (;;)
{
//if the code's actual function does not match the comments, please let me know:
//i'm still learning low-level C and actually didn't need it to work *exactly*
//as it claims to be written
PORTB |= (1 << 3); //turn on pin 3 (the LED pin)
Delay_ms(15000); //wait 15 seconds
PORTB &= 0 //turn off all pins (including LED pin)
PORTB |= (1 << 4); //turn on pin 4 (the transistor base pin)
Delay_ms(5000); //wait 5 seconds
PORTB &= 0; //(optional, for demo) turn off all pins (including both LED and transistor)
Delay_ms(5000); //wait 5 seconds and restart the cycle
}
}

Parts list (makes a single throwie):
For Floating Throwie: Miniature Pager Motor (available from electronic goldmine)
For Ventriloquist or Motown Throwie: Hallmark Music or Voice Recording Greeting Card ($5 at any drug store)
ATtiny13a microcontroller, 8-pin DIP format (for manually soldering wires onto the DIP pins – this would be a painful exercise in a surface mount format!)
1k resistor
Thin-gauge insulated wire (ideally the super thin 15 gauge stuff with paint insulation, but rubber should be fine too)
CR2032 3V Lithium Coin Cell Battery
1/2″ Dia by 1/8″ Thick Neodynium Magnet
10mm Diffused LED (for a super bright light visible at night, try to pick a brightness above 5,000 candella – digikey.com is a good source for super bright LEDs in various colors. This can be excluded from the Motown and Ventriloquist Throwies if you want those to go unseen and only heard.)
For Floating Throwie: 2N3904 transistor or other small-signal transistor controlling low-current devices (like our pager motor)
For Ventriloquist or Motown Throwie: An NPN TIP120 Darlington transistoror other similarly high-current transistor (for turning on high-current devices like the greeting card speakers)
Copper foil (thin and about 3″ square for the Floating Throwie, about 3″ by 6″ for the Ventriloquist and Motown Throwies – this is used to create removable power leads so you don’t have to solder wires directly to your batteries each time)
Scotch Tape (for holding batteries onto copper tape leads and attaching magnets as needed)
Solder (or Conductive Epoxy, though I have yet to try holding it together with such glues)
(Optional) Thin width Heat Shrink Tubing (for wrapping around soldered connections. Sorry “thin” is so vague, I’ll check the tubing width when I’m back in lab – but when shrunk, the tubing should wrap snugly around a standard DIP pin)

Tools list:
Soldering iron (ideally temperature controlled)
Exacto Knife (for cutting and stripping paint insulated wire)
AVR ISP MKII or Adafruit USBtinyISP Programmer (for programming ATtiny13a)
USB A-to-B cable (for attaching programmer to your computer’s USB slot)
AVRStudio Software for Windows or AVRdude Software for Windows/Mac/Linux
(here we use AVRStudio for easy of instruction)
Breadboard (for programming)
Resistor in value of ~5k but less than 10k (for programming)
CR2032 Coin Cell Holder with CR2032 Coin Cell Battery, or Variable External Power Supply (not required if using the USBtinyISP.)
22 Gauge (standard) rubber insulated wire, at least 8 pieces of at least 6″ length (6 to connect the chip on the breadboard to the programmer, 1 to connect the chip to breadboard’s external ground, and 1 to connect the chip to breadboard’s external high)
Wire Cutter/Stripper (to cut rubber-gauge wiring for programming, and for shortening leads of resistor, transistor and LED, as desired to make the circuit smaller and more robust. Can also be used to cut optional heat shrink tubing into desired lengths.)
Semi-optional/super helpful Helping Hands/Raised Clamps for your Soldering Station (for holding the circuit while you solder things onto it…it’s a little painful without these)
Optional/helpful: Multimeter (for checking connection quality and measuring voltage levels to check for dead batteries.)
Optional: Lighter or hair dryer (for heating and shrinking optional heat shrink tubing)

Revised Demo Day Poster:

View this document on Scribd

Assignment 10b – No, *this* is the hardest part

Posted in 10. Build the Hardest Part on December 8, 2009 by sbisker

Well, it turns out that using a mechanical mechanism to detach a throwie from a magnetic surface using a 3V coin cell battery is hard. Really hard. I suspect I could do it if I raised the voltage artificially using a Joule Thief circuit, which I just learned about recently…but last week, I realized that the hardest part is *actually* knowing when to stop, so you can still have enough time to make your point before your audience.

Let me explain – the point of this project was never to make a pretty art show using LEDs (although that would have been cool). I picked that scenario because I thought it’d be a fun, whimsical application of a larger area of research I’m currently involved in, that of personal urban (or public) computing. What I really wanted to explore was this question: What happens when anyone can create their own performances (or really, any sort of interactions) – cheaply and easily, with off the shelf technology – in public settings?

I ultimately decided that while it would be “heroic” to plod along and get a Floating Throwie kinda-sorta working by Wednesday, it would far more useful to the class and the audience if I created *alternate* examples of such computing – ones that don’t rely on experimental mechanisms to bring to life on demo day.

Thus, I present to you…the Motown Throwie, and the Ventriloquist Throwie.

What on earth are those, you ask? Well, they’re throwie circuits that use nearly the exact same electronics and code as the Floating Throwie – except that they use those electronics to turn off and on the electronics found in off the shelf Hallmark musical greeting cards. The former is built from a Motown birthday card, and allows you to place a device in a public space, run away, and then have it blast “Ain’t Too Proud to Beg”. The latter is built from a recordable greeting christmas card, and allows you to do the same thing, except blasting a phrase or noise if your own recording. (In this case, it just blasts a whistle – but it can be re-recorded to say “Psst! Over here!” or whatever else suits your fancy.)

In addition to my final report, I intend to prepare an Instructable on the Ventriloquist throwie (perhaps rolling discussion of the Motown throwie into it), and also will be presenting a poster about the general topic of these projects and my other work here at CMU. I will also prepare an academic paper on my experiences to satisfy the 12 unit requirement.

Below you’ll find demo videos for both projects, as well as a draft version of my poster (on Scribd.) Comments on my revised final demo are appreciated.

View this document on Scribd

Assignment 10 – Build The Hardest Part

Posted in 10. Build the Hardest Part on November 24, 2009 by sbisker

My objective for the final project is to experiment with the magnetic “LED throwie.” Specifically, I’m trying to create an LED throwie that can be attached to a magnetic surface and that can, some specified time later, detach itself from the magnetic surface, floating itself back down to earth via a gliding motion (maple seed wing, copter wing, or the like.)

The project consists of three main parts. A) finding a mechanism that can create enough motion of a throwie on a magnetic surface to detach that throwie,  B) creating a circuit that can trigger that motion mechanism at a desired time, and C)  finding a floating mechanism that can be placed onto a throwie that lets it glide to safety once detached.

The hardest part of my project is almost certainly (A), finding a way for the magnet to detach itself. I experimented with muscle wire, electromagnets and relays before finally settling on the vibration of a low-powered pager motor as the most promising way to detach the magnet.

In order to properly test whether the magnet can detach itself without outside force, I had to develop the entire circuit that would be triggering the motor movement. This is because with my hand in the way holding the motor leads to the battery, I tended to inadvertently apply enough force to the magnet to influence whether or not it would detach. In this sense, (B), the construction of the circuit had to be done before (A), the mechanical mechanism could really be tested. So I set about planning and building (B). For (B), I decided to use the ATtiny13a microcontroller (a technique I stole from the Throwie Talkie project). I programmed the microcontroller to wait 15 seconds (just enough time for me to place the throwie and get my hand out of the way) before switching a transistor on to turn on the pager motor (which has the magnet glued to the top of it). I can build this circuit with few enough components that the whole thing can be held together by wires, solder and tube shrink wrap. This video shows the whole circuit in action, and in turn the current status of (A), the detachment mechanism:

and here’s the circuit diagram:

Sorry it’s so fuzzy; I’ll recapture the video in macro mode – I just wanted to be able to post my very first successful test. As you can see, the detachment mechanism is pretty promising, even on this flat surface. In my informal tests without this circuit, I found the perfectly horizontal surface like the one being tested on is actually the *hardest* case to test this out on (because none of the side-to-side vibrational force gets supported by gravity, and there’s little torque on the magnet). Even on this surface, the magnet bounces around and does indeed fall off when it hits an edge (not shown in video). That said, the round Walking To The Sky pole won’t have any edges – so it will have to fall off via sheer momentum, not due to the magnetic surface disappearing. My next test is to take this completed circuit to the statue and see how it does there. If it falls off right away, we win – all I have to do is attach my wings and make sure the wings cause it to float down instead of plummet like a brick. If it doesn’t (and it probably won’t), I have a few more tricks up my sleeve:

*I can add distance between the motor and the magnet via padding on top of the motor (to increase the amount of torque put on the magnet)

*I can add tape to the top of the magnet to weaken the strength of the magnet (though doing so makes it harder to place and sort of ruins the illusion somewhat.)

*I can experiment with strings, making the motor “tug” on the device in such a way to cause the magnet to slip.

*I can work with wheeled magnets, causing the magnet to turn and bounce off the pole. (This idea is still fuzzy. Let’s hope it’s not the last one I get down to.)

Needless to say, even with so much of this project narrowed down into a concrete prototype, there’s quite a bit more experimenting and work to go. But I’d say sorting out the mechanism, selecting pager vibration and testing the circuit to prove the concept of pager vibration as a means of motion and detachment represents the hardest part of my project.

Other updates:

*I experimented with floating mechanisms and found a mechanism that worked fairly quickly – not the maple seed that I envisioned, but rather a simple set of copter wings that can be quickly fashioned out of paper. That set of wings can be easily attached by paper or string to whatever final circuit/mechanical mechanism I come up with.

*As I probably mentioned in class, I scaled back slightly from the “throwie” objective. It turns out that neodynium, the rare-earth magnet used in throwies, is insanely strong. So strong, in fact, that it veers towards magnetic surfaces and sticks even when your aim sucks – which is why it’s great for throwies. However, that same insane strength means it’s insanely hard to detach from a magnetic surface with just a coin cell (3V). This left me with two choices – either give up the low power affordance of throwies (by moving from a single coin cell to more power), or give up the “throwie” of throwies (by switching to a weaker magnet that won’t stick when thrown.) I chose the latter, deciding that ease of construction and weight was more important to me than the “throwing” factor. I hope to eventually find a low-power mechanism that works with neodynium outside of MTI, but given how quickly our demos are due, I had to pick my battles wisely.

MTID Final Project Proposal (WIP)

Posted in 9. Project Proposals on November 3, 2009 by sbisker

Nearly finished but not yet; I just wanted to make sure something was posted before class Tuesday in case I’m called on to pitch. The missing components (storyboard diagram and parts shopping list) will be here by Thursday (if not Tuesday).
——-
Gliding/Retrievable LED Throwies

Briefly, I’m interested in embuing LED Throwies with the ability to return to their owner via “gliding” mechanisms. LED Throwies are traditionally a small watch battery, an LED and a rare earth magnet taped together. The resulting item can then glow and be thrown onto a magnetic surface such as a bridge in large quantities (owing to its cheapness and ease of construction). Creating a simple gliding mechanism would both reduce the environmnal impact of unretrievable LED throwies and begin my experimentation into DIY electronics that can “navigate” the urban landscape. (The long-term reach goal is to use this process with a heavier object, a key-chain camera – we start with LEDs for simplicity and to build fluency in the medium.)

My only concern is that I’m not yet sure in what venue it could be published (to meet the paper requirement of the 12 unit course.) Despite its simplicity, I suspect there are many interesting things that you can do with this concept. By keeping the scope constrained, the applications can be better polished. Potential applications include sensor placement, long-term art installations, leaving messages for strangers, etc.

This project feels on the small side to me, which I take as a good sign (as final projects have a way of expanding). This feels both achievable and polishable.

Parts Diagram:

Parts Diagram

Storyboard Diagram: (coming soon)

Shopping Parts List: (coming soon)

Base Goal – Design a LED Throwie, sans magnet, that can be tossed out of a 4th story window, which will glide, float or flutter down to the ground. Initial wing design will attempt to emulate the shape and flying pattern of the common Maple Seed (Whirligig). Make a bunch of them, toss them off the Margaret Morrison courtyard balcony and post the resulting light show to Instructables.

Target Goal – Design an LED Throwie, with magnet, that will stick to a magnetic surface for a certain amount of time. Then, a timer on the throwie (within an ATtiny or similar IC) will release the throwie from that surface at a particular time, floating downward. Mechanisms that might be considered for this sort of action include “pushing off” by buckling SMA, popping loaded springs, and creating a reverse magnetic field. Make a bunch of them, film myself tossing them onto the base of the Walking To The Moon statue with them all slowly detaching themselves and fluttering off at the same time. Post the resulting light show to Instructables.

Reach Goal – Design a throwie (or at least a “sticky”) with the same properties, but with the strength and capacity to hold a keychain digital camera, and the gliding capacity to return a camera safely without breaking it. (Perhaps use a pulley system to get the camera up – I’m more concerned with the retrieval than with the throwing for the camera, since cameras may be too large for traditional throwing placement.) Film myself tossing a keychain camera up to a street pole, bridge roof or other urban surface, let it take pictures for 24 hours, and then return 24 hours later, at which time the camera will glide safely to the ground without being destroyed in the process. Recover the pictures and post the entire process to Instructables.

Assignment 8 – The United State Machine

Posted in 8. Finite State Machines, Uncategorized on October 26, 2009 by sbisker

I decided to reduce this entire assignment down to a bad pun.
This state machine lets you navigate between “States” – specifically, the northeastern United States – as you try to plan a road trip from Pennsylvania to Maine. States are connected to each other where their land masses touch (no chartering jets). The challenge of this game is to navigate between these states without being shown a map – you have to remember which states touch where, and which will form the shortest path in your head. The state diagram is, thus, just a map of the united states – but I’ve included my adjacency diagram marking the connections between states as well as said map in the photos below.
Since I didn’t have access to 10 switches, I experimented with using copper tape to make my own “switch panels” – grounded strips that can be raised high by using a 5V “state selection wand” (in this case, a wire literally plugged into the 5V pin of the Arduino.) This process is explained both in the pictures and in the end of the video.
The Arduino enforces proper movements and only lets you move from valid state to valid state – you can tell you’ve made a valid move when your “Steps Taken” counter increases by one (and the red Steps Taken light blinks the number of steps you’ve now taken.) Once you finally reach Maine, the green Win light turns on and the Steps Taken light repeatedly blinks the total number of steps you took (number of states you passed through, including duplicates) in your trip. Test your geography and see if you can’t plot a road trip through the smallest number of states from memory!

My Arduino Sketch:
SolomonBisker_Assignment9

My Copper Tape Switch Instructable:
Using Copper Tape To Create A Digital Selection PadMore DIY How To Projects

Assignment 7- A Mario becomes a Frog (but not Frog Mario)

Posted in 7. A Mechanical Automaton on October 20, 2009 by sbisker

I originally has hoped to design a two part system – the first part being a little paper “Mario” figurine that jumped up and down, and the second part being a little mario level background that scrolled behind it. I imagined that the mario figurine would move up and down on a cam, and the level background would scroll behind it on a friction tread. This was slightly ambitious – I’d never really built my own gear system in my life (save for Lego), and for this I decided to create my own gear, tread and cam system from scratch using a laser cutter – but I thought it’d be worth a shot.

After much cutting, re-cutting, hammering, unhammering, rehammering, drilling, aligning, taping, untaping…you get the picture…I wound up having all of the physical pieces in place. However, I realized that my initial idea of how a cam worked was slightly off – a cam only pushes something up and down if that item is being pushed onto the cam by gravity and held straight in place somehow. I understood this fact, but failed to realized that the up and down motion is not something that could easily happen *in front of* the tread system (that is, in three dimensions) – which is what would have been necessary for the effect to work.

At this point, I’d plowed quite a bit of time into the thing – and in the two dimensions the gears worked well in, was only left with a functional tread system and a spare, wobbly gear. I lamented my fate for a bit until I talked with Cheng, who noted that the wobbly gear actually gave the rubber band a jerky effect. I’d been struggling to get the rubber band to move consistently smoothly on the tread for a while – but she suggested I take the opposite approach, and turn that occasional jerkiness into an aspect of the intended movement. Which is how I wound up turning my Mario scene into a frog “hopping” scene. 🙂 The entire thing is hand-powered; I had planned to run off of a single motor but
having to secure the motor in a way that kept the motor gear both flush and able to turn freely was becoming an exercise in futility.

So, after much ado, a frog hopping:

Brainstorming – Jump It/Hit It

Posted in Brainstorming on October 20, 2009 by sbisker

Our group (myself, Melissa Acoste and Anthony Zhang) chose to brainstorm an idea for the playground.

We envisioned a semi-transparent rubber-esque cover stretched out over a large rectangular box filled with springs. The cover would probably be similar in feel and tension to a trampoline, and the springs in the box would act not unlike those in a mattress. These springs would be used to detect when pressure is pushed on a particular area of the rubber cover – and when the cover is pressed, an internal projector or other similar system would cause a colored blob to appear visually where the person has pressed. The size and shape of the blob would vary primarily with the force of the impact on the springs (with some element of randomness as well.)

This screen would be movable on a large hinge into both a flat position (to use ones entire body to “Jump It”) and an upright position (to “Hit it” with parts of ones body or with objects like baseballs) In this way, we see the same item taking on totally different uses depending on the child’s choice (and some joy is derived from the simple act of moving this thing on its giant hinge).
IMG_0666