Category Archives: Physical Computing

Addis Ababa

Well this was an excellent summer, the highlights being working in the Analytics group at the New York Times (indeed) and visiting Addis, Ethiopia for Design for Unicef.  Here is the Addis blog with pictures, notes, and assorted information! http://watercanary.wordpress.com/

Physical Computing Final


Here is my final for Physical Computing, completed in conjunction with Gloria Suzie Kim.

http://www.binaryspark.com/butterfly/

Phys Comp final check-in

Gloria and I have decided to go in a different direction for our Phys Comp final. We enjoyed the natural aesthetic of the Fish pond, but we’d like to try something a little more physical. To that end we plan to create a swarm of butterflies who react to their surroundings, fluttering in agitation when someone blocks their sunshine.

After brainstorming several methods of movement we’ve decided on muscle wire, courtesy of Jameco. There are a number of projects available on their site (including another butterfly-related one) and we’ve pored over their fact sheets for ideas on how to make these things flap.

This example shows how the butterfly would look if it was hung as a mobile. We actually plan to place them on sticks coming up from the ground, or potted plants as if they were in a garden. A photo sensor on the butterflies nose will collect information about the butterfly’s visual surroundings. if A shadow is cast, a current will cause the memory wire to contract, pulling down and closing the butterfly’s wings.

We are using Flexinol 100 HT wire for it’s delicacy and strength. We plan to make the wings out of paper that has been laser cut in into patterns. Our inspiration is this exhibit of Biomimetic Butterflies (http://www.mcleodbutterflies.com/installation/)

And here is our muscle wire test to make sure it’s usable. The wire is being pulsed on for two seconds and off for two seconds in a loop.

PComp Final

Here’s a couple pre-pre notes on the PComp final. The current concept is an elaboration on the PComp Midterm project, the Virtual Fish Pond, completed with Rajan and Gloria. The final would expand this to an interactive pond environment.

The functionality we wish to incorporate into this piece is:

  1. A “lifesize” interactive fish visualization
  2. The ability to scare fish away, either through tapping or “wading” around the pond
  3. The ability to feed the fish with a fish feeder
  4. Environmental feedback from heart, breath, stress, or other body sensors contained on the fish feeder. The feedback would be in the form of some sort of physical reaction undertaken by the pond’s environment.

First concept: Video Scanning. Fish will be projected on the floor, through an IR filter gell. Interactions will be captured through a camera scan of the ensuing shadow patterns and analyzed with software. The camera can be either below the surface (necessitating a large plastic or glass projection area, or above. The feeder controller will communicate with the Arduino through bluetooth.

Second concept: Touch Pad. Fish will be projected on a series of “switches” – a circular pad with connectors that close when placed under pressure, similar to a Dance Dance Revolution gaming pad. The feeder controller will still communicate with the Arduino through bluetooth.

An example of a home made pressure pad using switches:

Transistors doing what they do

Here’s a simple little Transistor lab, showing how a transistor helps my wimpy little Arduino handle the kind of power needed to power a 14 volt incandescent light bulb. It’s glowingly lovely!

The 5V external power comes in to the light 12V, and on the way out gets moderated and messed with by the transistor (and a resistor). That keeps the huge gigantic power draw under control Hey, it’s 14 V. You never know.

A fishy environment

Here is our PhysComp midterm! The following post is by Gloria, originally posted on her blog. Thanks Gloria:

Our midterm group was inspired by Rajan’s idea for a virtual fish tank. After the first few meetings, the original idea of a fish tank evolved into a fish pond for relaxation. We all agreed that the basic ingredients of our project would include fishes, the act of feeding, and stress measurement of the (2) participants. Zoe created the accelerometer based fish food dispenser, I created the GSR (Galvanic Skin Response Sensor) wrist bands, and Rajan created the fishes. During our final group meetings, we combined our codes into one master code that included all of the aforementioned functionalities.

Our latest model of the Fish Pond includes the fish food dispenser which is used to feed the fish by lightly tapping the shaker a few times (too many shakes can make the system crash and we didn’t have time to figure out how to deal with people who fed the fish too much food.) The participants need to feed the fish when the plants and flowers glow red. Then plants and flowers turn green when the fish are getting enough food.

Two participants can wear a wristband, blue or green, that will compare their stress levels: The fishes will react to the more stressed participant and swim over to them in order to comfort them.

If you want to download the code, here is the link.

Coin flippin’

So here’s a quarter, all wired up for a night out on the town. It’s got two light sensors, one on each side, feeding into the Arduino. That info then heads over to Processing where the side facing up at any given moment is displayed. I coated the quarter in clear nail polish first to cut down on sparky badness.

And here’s the code:

import processing.serial.*;     // import the Processing serial library
Serial myPort;                  // The serial port

PImage face;

PImage heads;
PImage tails;

void setup() {
  size(200,200);

  heads = loadImage("heads.jpg");
  tails = loadImage("tails.jpg");

  face=heads;

  // List all the available serial ports
  println(Serial.list());

  myPort = new Serial(this, Serial.list()[16], 9600);

  // read bytes into a buffer until you get a linefeed (ASCII 10):
  myPort.bufferUntil('\n');
}

void draw() {

    image(face, 0, 0); //image defaults to heads

}

// serialEvent  method is run automatically by the Processing applet
// whenever the buffer reaches the  byte value set in the bufferUntil()
// method in the setup():

void serialEvent(Serial myPort) {
  // read the serial buffer:
  String myString = myPort.readStringUntil('\n');
  // if you got any bytes other than the linefeed:
  if (myString != null) {

    myString = trim(myString);

    // split the string at the commas
    // and convert the sections into integers:
    int sensors[] = int(split(myString, ','));

    // print out the values you got:
    for (int sensorNum = 0; sensorNum < sensors.length; sensorNum++) {
      print("Sensor " + sensorNum + ": " + sensors[sensorNum] + "\t");
    }
    // add a linefeed after all the sensor values are printed:
    println();

    if (map(sensors[0], 10,75,0,100) > map(sensors[1], 10,65,0,100)) {
     face=heads;
    println ("one");

    }
    else{
      face=tails;
      println ("two");
    }
  }

}