jenniferho @ itplike a kid in a candy store

Chien and I partnered up for the Physical Computing midterm to create an interactive pinwheel piece. In Chinese culture, a spinning pinwheel symbolizes an outward flow of bad fortune and inward flow of good fortune. In other words, a reversal of luck. We wanted to apply that concept to an art school context to create an “inspiration generator” of sorts. For students, fast deadlines and other high-stress situations can have a myriad of negative effects on the brain and body, including creative deadlock. A student in search of a reversal of such non-productivity can blow on a pinwheel to find a helpful strategy for creative renewal displayed on the center screen. Working in a team? Partners can spin both pinwheels at once to generate strategies tailored for 2 or more people.

For visual effect, a queue of LEDs will also light up in sequence as the pinwheel spins.

Our Processing interface will feature an animated pinwheel (yes, repurposed from an assignment that I submitted for ICM) that will spin when data, via serial communication with the Arduino, is generated through interaction with the Piezo vibration film sensor. Strategies will be placed into strings and displayed at random.

Prototyping in progress…

If we have time, we’d also like to explore adding a musical component…

This lab introduced us to the idea of serial communication between Arduino and Processing. Serial communication allows us to take output data from, in this case, a single sensor and generate a graphical representation of that data in Processing.

For my stupid pet trick, I made a stuffed toy fashioned after an LED and placed a homemade fabric pressure sensor inside to create a hug-o-meter of sorts. The fabric sensor was built using two pieces of conductive lamé fabric (tested first with a multimeter at Mood Fabrics) with a piece of Velostat (antistatic material) sandwiched in between. Hugging the LED toy would trigger a series of (real) LEDs to light up in sequence based on the amount of pressure applied by the hug. A velcro opening at the bottom right of the stuffed toy allows the sensor to be easily inserted/removed.

The circular sensor was the second of two attempts. I had originally created a more rectangular sensor to better accomodate the shape of the LED, but found that it was only effective when pressure was applied directly between the two points of wire contact. I had hoped that creating a circular shape for the second sensor would help this problem, but it also seemed only to work when the pressure was placed between the two points.

The code programmed into the Arduino was modified from the analog input lab from Week 2. When placed inside the toy, the fabric sensor generated an output range of approx. 0-500.

And finally, a paper casing for the Arduino to hide the wires.

This week, I wanted to experiment with using magnetic snaps as a switch. The magnetic snaps were purchased from Mood, a fabric store in the Garment District. Using a sewing machine, I created a soft light switch using cloth and polyester filling, attached jumper wires to the magnetic snaps (no soldering necessary) and connected the wires to the Arduino. When the magnets snapped into place, the four yellow LEDs on the Arduino would light up.

Code:
// declare variables:
int switchPin = 8; // digital input pin for a switch
int yellowLedPin1 = 4; // digital output pin for yellow LEDs
int yellowLedPin2 = 5;
int yellowLedPin3 = 6;
int yellowLedPin4 = 7;
int switchState = 0; // the state of the switch

void setup() {
pinMode(switchPin, INPUT); // set the switch pin to be an input
pinMode(yellowLedPin1, OUTPUT); // set the yellow LED pins to be outputs
pinMode(yellowLedPin2, OUTPUT);
pinMode(yellowLedPin3, OUTPUT);
pinMode(yellowLedPin4, OUTPUT);

Serial.begin(9600);
}

void loop() {
// read the switch input
switchState = digitalRead(switchPin);

Serial.println(switchState);
if (switchState == 1) {
// if the switch is closed:
digitalWrite(yellowLedPin1, HIGH); // turn on the yellow LEDs
digitalWrite(yellowLedPin2, HIGH);
digitalWrite(yellowLedPin3, HIGH);
digitalWrite(yellowLedPin4, HIGH);
}
else {
// if the switch is open:
digitalWrite(yellowLedPin1, LOW); // turn off the yellow LED
digitalWrite(yellowLedPin2, LOW);
digitalWrite(yellowLedPin3, LOW);
digitalWrite(yellowLedPin4, LOW);
}
}

First attempt at soldering.

It’s not pretty and the right side is a little charred. But what matters for now is that it still conducts.

This week’s lab introduced us to Analog Input. This first round utilized the Analog In code provided in the Arduino Examples. What I was hoping to accomplish was an LED that would turn on when the FSR (force sensitive resistor) was pressed and completely off when not pressed. However, the LED seemed to stay on dimly even when the FSR was not in use. When the FSR was pressed slightly, the LED would increase in brightness. When more pressure was applied to the FSR, the LED would flicker.

Code:
int sensorPin = 0;
int ledPin = 9;
int sensorValue = 0;

void setup() {
pinMode(ledPin, OUTPUT);
}

void loop() {
sensorValue = analogRead(sensorPin);
digitalWrite(ledPin, HIGH);
delay(sensorValue);
digitalWrite(ledPin, LOW);
delay(sensorValue);
}

In this second round, I incorporated IF and ELSE statements into the code, which seemed to fix the problem of the flickering lights. Although I’m still not entirely sure why the previous code did not work.

Code:
int sensorPin = 0; // select the input pin for the potentiometer
int ledPin = 9; // select the pin for the LED
int sensorValue = 0; // variable to store the value coming from the sensor

void setup() {
// declare the ledPin as an OUTPUT:
pinMode(ledPin, OUTPUT);
Serial.begin(9600);
}

void loop() {
// read the value from the sensor:
sensorValue = analogRead(sensorPin);

if(sensorValue > 90) { //maximum value at about 112 (when pressed hardest)
digitalWrite(ledPin,HIGH);
}
else {
digitalWrite(ledPin,LOW);
}
Serial.println(sensorValue);
}

Finally, I also explored using the FSR in controlling the brightness of the LED based on how much pressure was applied to the sensor.

Code:
int fsrPin = 0;
int sensorValue = 0;
int led = 9; //PWM: Pulse Width Modulation (Basically a digital pin that can provide analog results.)

void setup() {
// initialize serial communications at 9600 bps:
Serial.begin(9600);
// declare the led pin as an output:
pinMode(led, OUTPUT);
}

void loop() {
sensorValue = analogRead(fsrPin); // read the FSR value
int brightness = map(sensorValue, 10, 112, 0, 255); // FSR values max at 112

analogWrite(led, brightness); // set the LED brightness with the result
Serial.println(sensorValue);
delay(10);
}

And finally, 1 FSR and 3 LEDs.