My ITP classmate Adam Harvey has invented an anti-paparazzi clutch bag that “communicates the desire to NOT be photographed.”  According to Adam, “when the device detects a camera flash it responds with another flash that obscures the photo.”  Awesome idea Adam!

Apparently one paparazzo doesn’t like the idea too much.  Adam recently received his first hate mail from an angry paparazzo:

“Reducing income for my growing young family”!? Oh no, the paparazzi are breeding?

If he’s worried that the device won’t work, why is this pissed-off paparazzo worried about his economic livelihood?  By the way, for the record, I’ve tried out the prototype, and it definitely works.

In any case, I think that celebs should take a cue from the late King of Pop, Michael Jackson (peace be upon him), and wear a burqa in public to avoid being photographed.  I don’t want to name anyone in particular, but if your last name is Hilton or Beckham, you might want to consider it.

But if you are a celeb that MUST be seen in public sans-burqa (like if you’re in France for the Cannes Film Festival, for example), then check out Adam’s site for more information about his invention.  A limited supply will be available in Spring 2010.

I’m finding more blog posts about the head(banger)phones from across the international Internets.

Here are posts from Australia, Brazil, and France.

The head(banger)phones are a personal music device made up of a pair of headphones and a sensor.  When the user wears the head(banger)phones, the motion and position of her head triggers different sounds, creating a dynamic interactive musical experience.

Source code after the jump:

import ddf.minim.signals.*;
import ddf.minim.*;
import ddf.minim.analysis.*;
import ddf.minim.effects.*;
import processing.serial.*;

int counter = 0;  //variable for controlling tempo
int tempo = 20; //the higher the number, the slower it goes

//minimum and maximum values coming from accelerometer
int minX = 270;
int maxX = 440;
int minY = 270;
int maxY = 440;

Serial myPort;  // The serial port
int accelX=0;
int accelY=0;

Minim minim;
AudioSample kick;
AudioSample x1;
AudioSample x2;
AudioSample x3;
AudioSample x4;
AudioSample x5;
AudioSample x6;
AudioSample y1;
AudioSample y2;
AudioSample y3;
AudioSample y4;
AudioSample y5;
AudioSample y6;

void setup()
{
println(Serial.list());
myPort = new Serial (this, Serial.list()[0], 9600);
minim = new Minim(this);
size(1440,850);
background(0);
textFont(createFont(“Helvetica”, 80));
textAlign(CENTER);
fill(255,0,0);
text(“head(banger)phones”, width/2, height/2 – 50);
fill(255);
text(“(move your head)”, width/2, height/2 + 50);

kick = minim.loadSample(“kick.mp3″, 1440);

x1 = minim.loadSample(“x1.mp3″, 1440);
x2 = minim.loadSample(“x2.mp3″, 1440);
x3 = minim.loadSample(“x3.mp3″, 1440);
x4 = minim.loadSample(“x4.mp3″, 1440);
x5 = minim.loadSample(“x5.mp3″, 1440);
x6 = minim.loadSample(“x6.mp3″, 1440);

y1 = minim.loadSample(“y1.mp3″, 1440);
y2 = minim.loadSample(“y2.mp3″, 1440);
y3 = minim.loadSample(“y3.mp3″, 1440);
y4 = minim.loadSample(“y4.mp3″, 1440);
y5 = minim.loadSample(“y5.mp3″, 1440);
y6 = minim.loadSample(“y6.mp3″, 1440);
}

void draw()
{
counter = (counter+1)%tempo;

if (counter == 0)
{
//always play the kick
kick.trigger();
//play samples according the the X value
if (accelX == 1) {
x1.trigger();
}
else if (accelX == 2) {
x2.trigger();
}
else if (accelX == 3) {
x3.trigger();
}
else if (accelX == 4) {
x4.trigger();
}
else if (accelX == 5) {
x5.trigger();
}
else if (accelX == 6) {
x6.trigger();
}

//play samples according the the Y value
if (accelY == 1) {
y1.trigger();
}
else if (accelY == 2) {
y2.trigger();
}
else if (accelY == 3) {
y3.trigger();
}
else if (accelY == 4) {
y4.trigger();
}
else if (accelY == 5) {
y5.trigger();
}
else if (accelY == 6) {
y6.trigger();
}
}
}

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, ‘,’));
if (sensors.length > 0) {
accelX = int(map(sensors[0], minX,maxX,1,6));
accelY = int(map(sensors[1], minY,maxY,1,6));
println(accelX + “,” +accelY); //debugging to make sure the values are coming through and being translated
}
}
}

//don’t really know what this does, but the Minim sample code says to be sure to do this, so can’t hurt
void stop()
{
x1.close();
x2.close();
x3.close();
x4.close();
x5.close();
x6.close();
y1.close();
y2.close();
y3.close();
y4.close();
y5.close();
y6.close();
minim.stop();
super.stop();
}

I will be presenting the head(banger)phones.  Please come

This is an progress update on my final project for Physical Computing, the head(banger)phones.

Since I presented my work in progress in class two weeks ago, I have moved the accelerometer (pictured above) to the top of the headphones instead of on the side of the left headphone.  I also reconsidered the actual “headbanging” motion required by the user to trigger sounds.  After doing some user testing on myself, I realized that this wasn’t the most comfortable of motions to keep up (or to track in software).  I am still going to retain the name head(banger)phones for the project though, because it sounds cool, is unique enough to show up first on Google, and because the parentheses evoke headphones.

Anyway, the new concept is to have the user move his/her head front and back, left and right while wearing the head(banger)phones.  The program will play a constant minimalist beat, and the action of head tilt on 2 axes trigger other sound elements to be played at different degress of head tilt.  In other words, I am composing a musical object that exists in the perceptual space of the headphones, and the user will hear different aspects of the musical object depending on the position of his/her head.

Also, I’ve decided that I don’t actually need to use MIDI at all to make this work.  I can just have the Arduino send a serial out message to Processing, which in turn interprets the accelerometer tilt readings and uses the Minim library to play back samples I have created.

[head(banger)phones part 1]

Here is the simple and straightforward Arduino code I am using to send the accelerometer readings to Processing:

int accelerometerX = 0;
int accelerometerY = 1;

int accelValueX=0;
int accelValueY=0;
void setup()
{
// start serial port at 9600 bps:
Serial.begin(9600);
}

void loop()
{
accelValueX = analogRead(accelerometerX);
accelValueY = analogRead(accelerometerY);
Serial.print(accelValueX, DEC);
Serial.print(“,”);
Serial.println(accelValueY, DEC);
// pause for 10 milliseconds:
//delay(10);
}

Update: Here is my Processing code:

import ddf.minim.signals.*;
import ddf.minim.*;
import ddf.minim.analysis.*;
import ddf.minim.effects.*;
import processing.serial.*;

int counter = 0; //variable for controlling tempo
int tempo = 60; //the higher the number, the slower it goes

//minimum and maximum values coming from accelerometer
int minX = 250;
int maxX = 480;
int minY = 250;
int maxY = 480;

Serial myPort; // The serial port
int accelX=0;
int accelY=0;

Minim minim;
AudioSample x1;
AudioSample x2;
AudioSample x3;
AudioSample x4;
AudioSample x5;
AudioSample x6;
AudioSample y1;
AudioSample y2;
AudioSample y3;
AudioSample y4;
AudioSample y5;
AudioSample y6;

void setup()
{
println(Serial.list());
myPort = new Serial (this, Serial.list()[0], 9600);
minim = new Minim(this);
size(1440,850);
background(0);
textFont(createFont(“Courier”, 80));
textAlign(CENTER);
fill(255);
text(“head(banger)phones”, width/2, height/2 – 50);
text(“(move your head)”, width/2, height/2 + 50);

x1 = minim.loadSample(“x1.mp3″, 1440);
x2 = minim.loadSample(“x2.mp3″, 1440);
x3 = minim.loadSample(“x3.mp3″, 1440);
x4 = minim.loadSample(“x4.mp3″, 1440);
x5 = minim.loadSample(“x5.mp3″, 1440);
x6 = minim.loadSample(“x6.mp3″, 1440);

y1 = minim.loadSample(“y1.mp3″, 1440);
y2 = minim.loadSample(“y2.mp3″, 1440);
y3 = minim.loadSample(“y3.mp3″, 1440);
y4 = minim.loadSample(“y4.mp3″, 1440);
y5 = minim.loadSample(“y5.mp3″, 1440);
y6 = minim.loadSample(“y6.mp3″, 1440);
}

void draw()
{
counter = (counter+1)%tempo;

if (counter == 0)
{
//play samples according the the X value
if (accelX == 1) {
x1.trigger();
}
else if (accelX == 2) {
x2.trigger();
}
else if (accelX == 3) {
x3.trigger();
}
else if (accelX == 4) {
x4.trigger();
}
else if (accelX == 5) {
x5.trigger();
}
else if (accelX == 6) {
x6.trigger();
}

//play samples according the the Y value
if (accelY == 1) {
y1.trigger();
}
else if (accelY == 2) {
y2.trigger();
}
else if (accelY == 3) {
y3.trigger();
}
else if (accelY == 4) {
y4.trigger();
}
else if (accelY == 5) {
y5.trigger();
}
else if (accelY == 6) {
y6.trigger();
}
}
}

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, ‘,’));
if (sensors.length > 0) {
accelX = int(map(sensors[0], minX,maxX,1,6));
accelY = int(map(sensors[1], minY,maxY,1,6));
println(accelX + “,” +accelY); //debugging to make sure the values are coming through and being translated
}
}
}

//don’t really know what this does, but the Minim sample code says to be sure to do this, so can’t hurt
void stop()
{
x1.close();
x2.close();
x3.close();
x4.close();
x5.close();
x6.close();
y1.close();
y2.close();
y3.close();
y4.close();
y5.close();
y6.close();
minim.stop();
super.stop();
}

My final project proposal for Physical Computing at ITP:

head(banger)phones – a personal musical device

A set of headphones rigged with an accelerometer that detects the motion of the user’s head and converts that motion data into MIDI data via an Arduino microprocessor.  The MIDI then triggers percussion sounds in a software synth on the computer, which feeds the audio signal back to the user wearing the headphones.

Here is a video of my proposal to my class.

head(banger)phones from lee-sean on Vimeo.

Liesje, Tim and I finished our midterm project for Physical Computing tonight.  Our original concept was the Voodoo Bear, but after managing to break a couple sensors and a vibration motor in the building process, we decided go with a slightly different concept.

Here it is in action:

The setup allows us to inflict Arduino-based violence against the bear, representing our frustration with the bear and the difficulties of building something from the outside in rather than from the inside out.  It can also be read as a demented commentary on the death penalty (which I’m against) or as a kind of shock therapy that de-incentivizes eating candy – good for people trying to control their diet.  Eat chocolate and the bear dies.

Tim talks more about the process on his blog:

The Electric Chair Bear came to fruition this evening as Liesje, Lee-Sean, and I had a revelation yesterday evening about making the voodoo bear concept we had be a voodoo/electric chair bear.  We were having some serious problems making the servo motors do everything we wanted by building the bear’s components, sensors, and motors from the inside out.  We also destroyed about 3 different things including a flex and stretch sensor and a mini vibrating motor.  This was all due to the structure of the bear and the complexity of inserting motors and sensors into the bear.  We did get the bear to do some cool things with the eye connected to a motor as well as putting an LED into the bear’s eye, so that when you shake an accelerometer the bear’s eye moves and the LED turns on and off.  The accelerometer also turns on another servo motor to give slight motion to an arm.    We constructed a chair that looks like previous teddy bears could have been put to death in, and connected tin foil as a metal helmet, sharp teeth, leg shackles, and a lighting bolt across the chest so that the bear sits in the chair, and when the accelerometer is activated, the bear reacts accordingly and looks like he is being electrocuted.  The lightning bolt really makes it “The Electric Chair Bear,” the anti-care bear.  The acceleromoter is attached to a candy bar as incentive so that when a famished passerby sees it, he will pick it up and activate the acceleromoter.  We also wrote a Processing program so that when the accelerometer is activated, the Electric Chair Bear shakes in the processing sketch that has an image of the bear.  The background also freaks out between blue and red to give an added effect of electric proportions.  We also wrote a function so that when the mouse rolls over the distinctly weird eye in question, the LED turns on.  We are very happy with our Electric Chair Bear, and feel as though this idea is even creepier and better for the Haunted House than the original idea.

Here is the Arduino code:

int servoPin = 11;     // Control pin for servo motor – Eye
int servoPin2 = 12;    // Hand
int minPulse = 500;   // Minimum servo position
int maxPulse = 2500;  // Maximum servo position
int pulse = 0;        // Amount to pulse the servo
int ledPin = 4;
int pulseWidth;

long lastPulse = 0;    // the time in milliseconds of the last pulse
int refreshTime = 20; // the time needed in between pulses

int analogValue = 0;  // the value returned from the analog sensor
int analogPin = 0;    // the analog pin that the sensor’s on

int buttonSwitch = 2;      // switch
int buzzerPin = 8;         //buzzer
int motor = 0;
int sensorValue = 0;     // reading from the sensor
int buttonValue;
int ledOn = 0;
int accelerometer = 0;
int accelValuePrev;
int accelValue;

void setup() {
// configure the serial connection:
pinMode(ledPin, OUTPUT);
pinMode(servoPin, OUTPUT);  // Set servo pin as an output pin
pinMode(servoPin2, OUTPUT);

Serial.begin(9600);
// configure the digital input:
pinMode(buttonSwitch, INPUT);
pinMode(buzzerPin, OUTPUT);
pinMode(accelerometer, INPUT);
digitalWrite(buzzerPin, HIGH);

}

void loop() {
if (Serial.available() > 0) {
ledOn = Serial.read();
if(ledOn == 1){
digitalWrite(ledPin, HIGH);
}
else if (ledOn == 0){
digitalWrite(ledPin, LOW);
}
}
accelValue = analogRead(accelerometer);
sensorValue = digitalRead(buttonSwitch);
buttonValue = sensorValue;

if (abs(accelValue-accelValuePrev) >15){
Serial.print(1, BYTE);
turnServo(180);
delay(20);
turnServo(5);

digitalWrite(buzzerPin, HIGH);
digitalWrite(ledPin, HIGH);

}
else  {
Serial.print(0, BYTE);
digitalWrite(ledPin, LOW);
digitalWrite(buzzerPin, LOW);
}
accelValuePrev = accelValue;
}

void turnServo(int angle) {
int i;
// this loop is done in order to turn the servo motor to the wanted angle
for( i=1;i<angle ;i=i+10 ){

// calculates the amount to pulse to the servo (this servo can turn maximum 180 degrees)
pulse = (i*2500)/180;
// add the minimum amount for the pulse, and the relative position of the given angle
// compared to the maximum angle
pulse += 500+((2000/180)*i);
// pulse the servo motor
pulsout( servoPin, pulse);
pulsout( servoPin2, pulse);
}
}

void pulsout( int servoPin, int pulse) {
digitalWrite(servoPin, HIGH); // Turn the motor on
delayMicroseconds(pulse); // Length of the pulse sets the motor position
digitalWrite(servoPin, LOW); // Turn the motor off
delay(20); // 20 millisecond delay is needed between pulses
}

Here is the Processing code

import processing.serial.*;
Serial myPort;  // The serial port

float  buttonSwitch, accelerometer, accelerometerPrev;
float accelSensitivity = 5;
//the values below are calibrated for use in the processing program

int accel = 0;
PImage[] bear = new PImage [8];
int frame = 0;  //frame counter for vibration

void setup()
{
println(Serial.list());
myPort = new Serial (this, Serial.list()[0], 9600);
size(600,800);
noStroke();
bear[0] = loadImage(“voodoo-bear_blue_small.jpg”);
bear[1] = loadImage(“voodoo-bear_red_small.jpg”);
bear[2] = loadImage(“voodoo-left-red.jpg”);
bear[3] = loadImage(“voodoo-left-blue.jpg”);
bear[4] = loadImage(“voodoo-bear_blue_small.jpg”);
bear[5] = loadImage(“voodoo-bear_red_small.jpg”);
bear[6] = loadImage(“voodoo-right-blue.jpg”);
bear[7] = loadImage(“voodoo-right-red.jpg”);
image(bear[0], 0,0);
}

void draw()
{
frame = (frame+1)%8;
//turn background red if mouse gets close to the zombie eye
if(dist(mouseX, mouseY, 240, 190) < 56)
{
fill(255,0,0,160); //transparent red
myPort.write(1); //send one to Arduino to turn on eye
image(bear[1], 0,0);
//ellipse(240,190,55,55);  //Finding the eye
}
else {
image(bear[0], 0,0);
// myPort.write(0);
}
if(accel==1){
shakeBear();
}
}

void serialEvent (Serial myPort) {
// get the byte:
int inByte = myPort.read();
// print it:
println(inByte);
accel = inByte;
}

void shakeBear(){
image (bear[frame], 0,0);
}

More photos and videos on Flickr.

The connectors on the DC motor are extremely fragile.  I managed to break one off accidentally, so I had to borrow Tim’s motor.  I haven’t had the best of luck lately with components.  While working on our midterm project, the Voodoo Bear, we managed to break a flex sensor and a stretch sensor today.

In any case, I got the DC motor to work:

With the addition of a potentiometer and the additional code provided, I now have a potentiometer-controlled spastic DC motor!

In other news, we managed to complete most of the construction on the Voodoo Bear today. We put two servomotors into the bear. One makes the bear blink and the other one makes the bear’s arm wave. The servos and other components are affixed to a flexible “skeleton” inside the bear that is made out of thick ethernet cables.

I worked with Tim and Liesje yesterday on our Physical Computing midterm, the Voodoo Bear, which is a bit like Frankenstein’s monster, built from the shell of a Build-a-Bear and various wires, sensors and other components.  The bear will move in reaction to human actions on a connected Processing program or through triggering sensors built into the bear.  Click on the schematic below for details.  Still very much a work in progress, so I’ll save full the explanation for later.

In this week’s lab, we learned about Serial Duplex and continued to learn more about how to get Arduino and Processing to talk to each other.

In my spin on the lab, I hooked up 2 potentiometers through the Arduino to control the frequency and panning of a sine wave in Processing that is manifested on screen and as audio.  I don’t know why I chose red and blue for the sine waves.  Maybe I’ve been watching too much TV coverage of the presidential campaign.  In any case, the effect is that of a sine wave of doom or a poser theremin.

To get Processing to play sound, I used the Minim library.  I basically poached some example code from the Minim site and tweaked it so the sound responds to analog ins from the Arduino instead of mouseX and Y in the original sketch.

I hope to use more exciting sensors later on to make it more expressive and musical when I get back from fall break next week, but it took me awhile to tweak the software side of things and the computer store was already closed by the time I got around to this. Here it is in action:

My digital camera didn’t pick up the audio very well, so here is an MP3 of some “music” I made.  And here is another attempt.

And finally, here is the Processing code:

import processing.serial.*;     // import the Processing serial library
import ddf.minim.*;
import ddf.minim.signals.*;

Serial myPort;                  // The serial port
AudioOutput out;
SineWave sine;
int sensors[] = new int[2];

int passX;
int passY;

void setup(){
myPort = new Serial(this, Serial.list()[0], 9600);
myPort.bufferUntil(‘\n’);
size(512, 200);
// always start Minim before you do anything with it
Minim.start(this);
// get a line out from Minim, default sample rate is 44100, bit depth is 16
out = Minim.getLineOut(Minim.STEREO, 512);
// create a sine wave Oscillator, set to 440 Hz, at 0.5 amplitude, sample rate 44100 to match the line out
sine = new SineWave(440, 0.5, 44100);
// set the portamento speed on the oscillator to 200 milliseconds
sine.portamento(200);
// add the oscillator to the line out
out.addSignal(sine);
passX = 0;
passY = 0;
}

void draw()
{
background(0,50);
stroke(255);
// draw the waveforms
for(int i = 0; i < out.left.size()-1; i++)
{
stroke(#FF0000); //left is red
line(i, 50 + out.left.get(i)*50, i+1, 50 + out.left.get(i+1)*50);
stroke(#0023FC); //right is blue
line(i, 150 + out.right.get(i)*50, i+1, 150 + out.right.get(i+1)*50);
}
float freq = map(passY, 0, 1023, 1500, 60);
sine.setFreq(freq);
// pan always changes smoothly to avoid crackles getting into the signal
// note that we could call setPan on out, instead of on sine
// this would sound the same, but the waveforms in out would not reflect the panning
float pan = map(passX, 0, 1023, -1, 1);
sine.setPan(pan);
}

void stop()
{
out.close();
super.stop();
}

void serialEvent(Serial myPort)
{
// read the serial buffer:
String myString = myPort.readStringUntil(‘\n’);
myString = trim(myString);
int sensors[] = int(split(myString, ‘,’));
for (int sensorNum = 0; sensorNum < sensors.length; sensorNum++)
{
// print(“Sensor ” + sensorNum + “: ” + sensors[sensorNum] + “\t”);
}
passX = sensors[0];
passY = sensors[1];
//println();
//print(“PassX= ” + passX + “, PassY= ” + passY);
//println();

}

I worked on this week’s lab with Meredith.  First we set everything up as specified in the lab.  No real problems, pretty straight forward as the video below shows.

Then we wanted to visualize the signal from the serial in a more personal, creative way, so I adapted the big orange circle and blue background from an old ICM project and tried to link the pot reading to the diameter of the circle.  Something stopped working though.  We started double checking wires and scanning every line of the code, but we still could not get the Arduino to talk to Processing.  Then we had a “duh” moment nearly an hour later and just ran the Arduino setup program again.  Then it worked.  Still don’t know why Arduino “forgot” how to output to Processing, even though we didn’t do anything.

The circle diameter did move along with the pot, but there was this nasty flicker that really bothered me, which made me not want to mess with the sketch anymore.  In any case, I think we got the hang of Serial Output.

Here is the code we used:

import processing.serial.*;

Serial myPort; // The serial port
float bigOrangeCircleDiameter = 1; //the big orange circle starts out really small
int bigOrangeCircleGrowthRate = 5;

void setup ()
{
size(800, 800); // window size
myPort = new Serial(this, Serial.list()[0], 9600);
}

void draw()
{
}

void serialEvent(Serial myport)
{
rectMode(CORNER);
noStroke();

// get the byte:
int inByte = myPort.read();
// print it:
println(inByte);

//Draw the big orange circle that grows and shrinks
fill(247,101,42); //Orange fill
bigOrangeCircleDiameter = map (inByte, 0, 255, 0,800);
ellipse(width/2,height/2,bigOrangeCircleDiameter,bigOrangeCircleDiameter);
background(68,66,211,20); //turn the background blue
}

Physical Computing Week 4 – Evil Servobot from lee-sean on Vimeo.

I decided to take a riff on the lab assignment and attempt to create pure evil with limited resources (and skills for that matter).  I hooked up the servo to a photocell via the Arduino, which controls the movement of the servo based on how much light the photocell detects.  Then I added an LED that dims/brightens, also following the analog reading on the photocell.  And for the final step (and the one the really unleashed pure evil), I added a small speaker that modulates its audio output, also according to the photocell reading.  With all the wires going into the LED and servo acting as anchors, the Evil Servobot is able to dance and shake its demonic robot hips.

Here is the code:

int servoPin = 2;     // Control pin for servo motor
int buzzerPin = 5;
int ledPin = 11;  // Control pin for buzzer
int minPulse = 500;   // Minimum servo position
int maxPulse = 2500;  // Maximum servo position
int pulse = 0;        // Amount to pulse the servo
int brightness = 0;        //pitch of the

long lastPulse = 0;    // the time in milliseconds of the last pulse
int refreshTime = 20; // the time needed in between pulses

int analogValue = 0;  // the value returned from the analog sensor
int analogPin = 0;    // the analog pin that the sensor’s on

void setup() {
pinMode(servoPin, OUTPUT);  // Set servo pin as an output pin
pinMode(buzzerPin, OUTPUT); //set buzzer pin as output
pinMode(ledPin, OUTPUT);  //set LED as output
pulse = minPulse;           // Set the motor position value to the minimum
Serial.begin(9600);
}

void loop() {

analogValue = analogRead(analogPin);      // read the analog input
brightness = map(analogValue,0,800,0,255);
pulse = map(analogValue,0,800,minPulse,maxPulse);    // convert the analog value
// to a range between minPulse
// and maxPulse.
// pulse the servo again if rhe refresh time (20 ms) have passed:
Serial.println(analogValue);
if (millis() – lastPulse >= refreshTime) {
digitalWrite(servoPin, HIGH);   // Turn the motor on
delayMicroseconds(pulse);       // Length of the pulse sets the motor position
digitalWrite(servoPin, LOW);    // Turn the motor off
analogWrite(ledPin,brightness);
analogWrite(buzzerPin,analogValue*10);
lastPulse = millis();           // save the time of the last pulse
}
}

First we made a basic LED circuit:

We wired everything up according to the diagram, but nothing happened.  After getting some help from Michael, one of the residents, we discovered that we had mistaken a transistor for a voltage regulator (the three-pronged black thingie with the hole on top).  It’s definitely an easy mistake to make, especially since they look exactly alike except for the cryptic type printed on the parts.  Anyway, as you can see in the video above, we did get the basic LED circuit to work after all.

Measure the voltage across the switch as you did in the last step, both in the on position and the off position. Measure the voltage across the LED and the resistor as well. Does the total resistance across all the components add up to the voltage between power and ground on your board? Remember, in any circuit, all of the voltage must be used up. If the voltage across all the components doesn’t add up, that indicates to you that some of the electrical energy is getting converted to light, heat, and other forms of energy. No component is 100% efficient, so there’s always some loss.

Using the multimeter, we got the following voltage measurements.  Of course, they did not add up to 5 volts, but that is because of the energy loss to heat and light.

Switch (on) = 0v
Switch (off) = -3.4v

LED (on) = 1.7v
LED (off) = 0v

Resistor (on) = 2.45v
Resistor (off) = 0v

Totals:
On = 0 + 1.7 + 2.45 = 4.15v
Off = 3.4 + 0 + 0 = 3.4v

Then we wired up 2 LEDs in series:

Voltage across 1st LED = 2.47v
Voltage across 2nd LED = 2.47v

There was no need for a resistor in this circuit as the LEDs were acting as resistors when arranged in this manner.

Adding the 3rd LED made all LED’s much dimmer as their resistance was too much, voltage reading was 1.59v per LED.

Now moving on to LEDs in parallel:

Although the circuit looks ok in the photo, there was actually too much voltage for the LEDs and one of them burned out after the photo op, so we had to add a resistor in the mix.

The amperage reading on the multimeter was 12 on a 20m scale, therefore 12 milliamps.

And finally, we modified the circuit to supply a variable voltage output with a potentiometer:

When off the voltage reading was 0v
When fully turned in the other direction and LED at its brightest, the voltage reading was 2.08v
Halfway between the two, LED was dim and the reading was 1.78v

More video from Catherine here.

First, we reconstructed the potentiometer and LED breadboard & Arduino setup according to the lab documentation.  After getting familiar with the hardware last week, this week was much easier, and we were able to get the everything to work right very quickly.  The LED gets brighter or dimmer depending on the position of the potentiometer.

Then we decided to do a riff on the theme.  We replaced the pot with a photocell, which required an extra resistor to work correctly, since the photocell only has 2 prongs, while the pot has 3 connections.  We then tweaked the Arduino program by adding an if-else statement to create a kind of nightlight.  When there is a light shining on the photocell, the LED turns off.  When the lamp is turned off, the LED turns on.  The aluminum foil around the red LED is just for aesthetic effect.

Here is the code we used:

int potPin = 0; // Analog input pin that the potentiometer is attached to
int potValue = 0; // value read from the pot
int led = 9; // PWM pin that the LED is on. n.b. PWM 0 is on digital pin 9

void setup() {
// initialize serial communications at 9600 bps:
Serial.begin(9600);
}

void loop() {
potValue = analogRead(potPin); // read the pot value
Serial.println(potValue); // print the pot value back to the debugger pane
if(potValue>70)
{
analogWrite(led, potValue); // PWM the LED with the pot value
}
else
{
analogWrite(led, 0); // this turns the LED off
}
//delay(10); // wait 10 milliseconds before the next loop
}

Observation Assignment

The goal of this assignment is to develop the habit of detailed observation of what people physically do when they use the kinds of technologies we’re developing. In order to develop good physical interfaces, you need to know how people use existing ones. Do learn this, it helps to observe carefully, and to limit your assumptions as to what the person’s intentions are while you’re observing.

Counting Daily Uses

To begin with, take a one-hour hour walk or ride around the city. Try to travel as far as you can from your start and get back in an hour, this will give more variety. Take note of every time you see a person using a digital device. This could be anything from buying and using a Metrocard on the subway to playing video games in an arcade to making cell phone calls to using an ATM to swiping an ID at the gym. With each action you note, take note of:

* location and time of day
* apparent intent of the actor
* time taken for the action
* number of people involved
* motor skills needed (hands, legs, seeing, hearing, etc)

Collect your notes on your blog. Do this in pairs, with one person observing and the other keeping notes. Alternate roles as well.

The goal of this stage is to notice how many everyday technology interactions we experience that we’re largely unconscious of, and what it takes to do them. In many cases, the success of these transactions depends on the lack of attention we have to pay to completing them. The goal of most of these moments is not to use a technology, but to reach some other goal.

We chose to walk around Greenwich Village, in the immediate vicinity of NYU.  We noticed that the overwhelming majority of human-technology interactions we observed on the streets of NY involved mobile devices (cellphones, iPhones, Blackberries) and portable music players (iPods, CD players, etc).  We also observed a large degree of multitasking: people listening to music or talking/texting on their phones while walking/cycling down the street, a process that involves quite a bit of coordination between the senses and human motor functions.  For listening to music while walking the streets of NY, the intended purpose seems to be escape – a way of isolating oneself from the excess of sensory stimuli.  However, for people on their cellphones, the intended purpose seems to be connection with others, even when alone in the streets.  Technology thus allows us to be both isolated and alone (with headphones and iPod) or hyperconnected to others we know (cellphones) when we are in public space.  Headphones and portable music players act as an invisible wall that shields us from others, while cellphones and their ilk act as extensions of our voices and ears that allow us to reach out to those not in our physical vicinity.  This projection of the senses is both freeing and constricting.  By being able to multitask, for example, taking a walk and talking on your phone, one is freed from the physical constraints of having to be face to face to communicate with others.  But at the same time, the tether of social cohesion and pressures is extended.  One is not really “away” if one is reachable by cellphone or Blackberry.  Herein lies the paradox of technology – we are simultaneously liberated and constrained by it.

Well, enough holding forth for me.  Click below to read the raw data we collected.

Sept 11, 2008 – New York City
Observation: Lee-Sean
Note-taking: Liangjie

12:34 PM / Broadway & Waverly
guy walking with cd-player (finger – pressing, ear – headset – listening)

12:34 PM / Broadway & Waverly
girl talking on cellphone (hands – holding, mouth)

12:35 PM / Subway @ 8th St.
guy swiping metro card, entering the subway (hands, arms, ears – listening to the beep)

12:35 PM / Broadway & Astor Pl.
man talking on cellphone (hands, mouth)
girl listening to ipod (ears)

12:36 PM / Broadway & 8th St.
guy playing with iphone (hands/fingers, eyes)

12:37 PM / 8th St. (lens & craft)
shop clerk operating computer with mouse (hands, fingers, arms, eyes)

12:37 PM / Broadway & 8th St.
guy checking time/text message on his iphone (eyes, hands, not-talking)

12:38 PM / 8th St. & St. Green
woman at the cash register (finger, eyes)

12:39 PM / 8th St.
fedex guy working with portable POS (finger, eyes, hands)

12:40 PM / 8th St.
women in car at steering wheel

12:40 PM / 8th St. & University Pl.
women with baby, holding cellphone with shoulder and cheek (shoulder, face, mouth)

12:41 PM / 8th St. & University Pl.
tour guide talking on the bus with microphone (hand, mouth, arm)

12:45 PM / 8th St. & 5th Ave.
guy standing at the entrance, red flag in hand, watching traffic (hand, eyes)

12:46 PM / 8th St. & 6 Ave.
postman scanning mail with scanner (hands, eyes)
guy wearing headset and talking on cellphone (ear, mouth)

12:47 PM / 8th St. & 6th Ave.
woman sitting in shop using nail-dryer

12:48 PM / 8th St. & 6th Ave.
police officer carrying walkie-talkie and ticket printer(?) on the waist (waist)

12:49 PM / 9th St. & 6th Ave
guy standing and holding a big subway ad board beside a parking cab. (hands arms legs)

12:49 PM / 9th St. & 6th Ave
guy texting on cellphone (fingers eyes hands)

12:50 PM / 9th St. & 6th Ave
guy walking through the automatic door (body, legs)

12:50 PM / 9th St. & 6th Ave, village paper party store
guy climbing onto the ladder (hands, feet)

12:52 PM / Greenwich Ave & 10th St.
truck driver horning (hands, ears)

12:53 PM / Greenwich Ave & 10th St.
window cleaning operating the elevator/basket (hands, eyes)
guy texting on cellphone

12:54 PM / Greenwich Ave & 10th St.
woman at auto car door(?)

12:54 PM / W 10th St.
girl holding digital camera shooting a firefighter and baby (in front of a fire truck) (hands, legs, eyes, mouth – directing)

12:55 PM / W 10th St.
man playing with ipod/iphone, sitting on stairs(fingers,eyes)
guying walking along the street without looking, playing his iphone (eyes, hands, legs, feet – balancing?)

12:57 PM / 10th St. & 7th Ave.
guy standing, finger touching iphone (fingers,eyes,another hand)

12:57 PM / 10th St. & 7th Ave.
man and woman talking on cellphones while sitting on the bench.(hands, mouth)
girl having camera hung around neck (?)

12:59 PM / Christopher St. & 7th Ave. A Park
woman texting on cellphone (finger, eye, hand)
guy showing picture from camera to a friend sitting next to him on the bench (hands, finger, eyes, mouth)
girl listening to mp3 player, tuning channels/tracks, showing pictures from it to friend (hand, fingers, mouth, ears, eyes)

Switch! Observations by Liangjie.  Note-taking by Lee-Sean.

West 4th & Grove
1:03 PM
A man is standing and texting on his cell phone (fingers)
A man is cycling w/ headphones on, listening to music (arms, legs, hands, feet, ears, eyes)

1:04 PM
A man talks on cellphone while walking down the street (hand, arm, legs, eyes)

7th Avenue & Grove
1:05 PM
A girl listening to iPod is walking down the street (hand, arm, legs, eyes)

Bleeker & Barrow
1:06 PM
A man is sitting while talking on his cellphone and smoking (both hands)

7th Ave& Bleeker
Another man is pacing, carrying a pizza, waiting to for the crosswalk to change (eyes, hand)

1:07 PM
A policewomen inspects a parking meter (hand, eyes)

1:09 PM
A man listens to iPod while walking up 7th Ave @ Bedford (legs, ears)
Another man is carrying a cellphone on a keyring, it is swinging as he walks (legs, hand)

7th Ave & Bedford
1:10 PM
Man cycles down the street.  He wears a helmut, but is not sitting on the seat of the bike. (hands, arms, legs, eyes)

Bedford & Carmine
1:12 PM
Man cycles by on a portable mini-bike.  No cell phone.  (eyes, both arms and legs)
Man carries shoebox w/ sticker on it.  He grabs the box on the edge to carry it because there is no handle (hand)

1:13 PM
Man paces while talking on cellphone (mouth, hand, ear, legs)

1:14 PM
Man in pickup truck tries to park by backing into a space.
Another man w/ cell phone is standing and talking
Pacing man from 1:13 starts walking towards Houston street w/ a suitcase in his other hand while still talking on cellphone.

1:15 PM
Man jogs by while listening to iPod.  (eyes, ears, legs)

1:16 PM
A girl walks by w/ her backpack in front of her (arms, back, legs, eyes)

6th Ave & Bedford
1:18 PM
Man in bodega is scraping thorns off of flowers with a knife (hands, eyes)
Another man inserts coins into parking meter (hand, eyes)
A woman stands while talking on cellphone

1:19 PM
10 Downing Street – Construction zone
Man carries tool belt on waist
Another 2 men are in a lift, hammering at a brick façade (hands, eyes, balance)

1:20 PM
Downing & Bleeker
Men unload a truck w/ gloves and a trolley (hands, arms, legs, back, eyes)

1:21 PM
Man walks by, listening to iPod (legs, eyes, ears)
Another man looks through trash bags carried in a supermarket trolley (hands, eyes, searching)
A woman takes a picture (eyes, hands)

1:22 PM
Father Demo Square
Another woman takes a picture
No one on cellphone now.  Most people eating and/or reading
Man looks at watch to check out the time (arm, eye)
Woman walks by talking on cellphone

1:24 PM
Man takes a picture of woman while smoking cigarette (both hands, eyes)
Girl talks on cellphone

1:28 PM
Minetta Lane & MacDougal
2 men in lift on top of a van fix a sign on a restaurant (arms, eyes, hands)
Man makes ice cream cone with a cone making tool (hands, eyes)

1:30 PM
MacDougal & 3rd Street
Man delivers fridge w/ a hand cart (hands, arms, legs, eyes)

3rd & Sullivan
Girl talks on cellphone while walking
Man looks through window of a building, trying to find somebody to leave a flower delivery with (hands, eyes)

1:32 PM
3rd & Thompson
Man looks at cellphone
Another talks on cellphone

3rd & La Guardia
Man walks while listening to iPod

1:34 PM
Woman texts on phone while pushing a stroller.

Interactivity is a fuzz term that is hard to define.  Crawford says that “the term interactivity is overused and underunderstood.”  As a buzzword, it has been applied to things as absurd as a rug for children and even shampoo!  Many things/activities claiming to be interactive are really not.

While he does not claim to have the final definition of interactivity, Crawford does propose that interactivity be defined “in terms of a conversation: a cyclic process in which two actors alternately listen, think, and speak.”  If this is the case, then the ultimate interactive activity is direct human social interaction.  But other activities that humans engage in with objects

Participation is not interactivity.  Movies, plays, music and dance are for the most part, not interactive.

Also, Crawford says that interactivity is not a Boolean property, meaning it is not a binary either/or situation.  There are varying degrees of interactivity.

So maybe interactivity is like porn: controversial, misunderstood, difficult to define, but you know it when you see it.  Like porn, interactivity has varying degrees.  Softcore-Hardcore.  Low interactivity-High interactivity.

Perhaps the definition of interactivity itself should be interactive.  Ok, that’s pretentiously meta.  But if interactivity is such a virtue, then a conversation is essential to its definition and application.

So why bother with this interactivity stuff?

Crawford declares that “interactive communication is superior to conventional, one-way communication” and that “interactivity is the computer’s intrinsic competitive advantage.”

Interactivity is both old and new.  It is hardwired into mammalian animal behavior as well as a trait of modern computers.  Interactivity is a conversational process that helps humans/mammals learn through play.  So it is something that we (people/animals) have in common with computers.  So as computers get more interactive does it mean that they too are able to learn, and become more similar to humans/animals?

Crawford promotes interactivity as a new and exciting field for artists to explore.  He also quotes a Chinese proverb, “I hear and I forget; I see and I remember; I do and I understand.”  I have heard and seen the gospel of interactivity, now it is time for me to do before I truly understand.

This is my documentation of my first week of Physical Computing at ITP.  What is physical computing?  According to the syllabus:

Physical Computing is an approach to learning how humans communicate through computers that starts by considering how humans express themselves physically. In this course, we take the human body as a given, and attempt to design computing applications within the limits of its expression.

To realize this goal, you’ll learn how a computer converts the changes in energy given off by our bodies (in the form of sound, light, motion, and other forms) into changing electronic signals that it can read interpret. You’ll learn about the sensors that do this, and about very simple computers called microcontrollers that read sensors and convert their output into data. Finally, you’ll learn how microcontrollers communicate with other computers.

Physical computing takes a hands-on approach, which means that you spend a lot of time building circuits, soldering, writing programs, building structures to hold sensors and controls, and figuring out how best to make all of these things relate to a person’s expression.

For me, physical computing means building things with wires, circuits, sensors, switches and microprocessors.  We are using Arduino microprocessors in class to control our creations.  Our lab this week involved building a simple digital input/output system that makes two LEDs alternately flash when you press the switch.

Besides a photosensor theremin that I built in high school based on some plans I got off the internet, I have never really done any physical computing stuff before, hence my perplexed look in the photo above.  I basically just set about recreating the plans in the lab instructions while familiarizing myself with working with the materials.  The color-coded wires really help.  Red is for power, black is for ground, and the light blue is for input/output signals.

Soldering was a little bit scary for me.  We were supposed to solder the switch to two of the light blue wires.  First, I wrapped the wires onto the switch, and then put everything in the helping hands.  Then I melted some solder onto the iron to coat it, and then put the soldering iron onto the connection along with a bit of solder and melted it all together.  It only took a couple seconds.  My soldering job was ugly, but nothing exploded and the project worked, so I guess practice will make perfect.

Reading the resistors was a little bit tricky.  Resistors have these little colored stripe patterns on them that tell you how many Ohms they are.  They all kind of looked the same to me.  I really had to squint to see the patterns.  And I just got my eyes checked, so I don’t need new glasses.  They are just really small!  Note to self:  I need to get a magnifying glass.

After I thought I had everything set up, the red light was flashing, but the yellow light didn’t do anything.  Careful inspection revealed that I had one end of the yellow LED plugged in the wrong whole.  Once again, a magnifying glass would have helped.  Anyway, finally it worked!

Here is my successful project: