## Lämpötila

Lämpötila is an interactive winter hat that monitors the ambient temperature and reflects the analysis of changes in temperature through a series of LEDs accordingly.

Lämpötila Documentation

Lämpötila Video

Lämpötila Process Video

## Capacity Indicator

Concept

I have a bad habit of bringing a lot of things with me in my bag. Whatever the bag may be — backpack, shoulder bag, cross-body bag — my shoulders always end up really sore at the end of the day. So for this project, I wanted to make a visual self-reminder that indicates how heavy the bag is. Putting things into the bag will trigger the first light, or a light load. Putting more things in will trigger the second and third light sequentially as weight increases. Essentially this is to raise self-awareness of how I shouldn’t be putting so much into my bags.

Components

• LilyPad LED White x 3
• Force Sensing Resistor
• Resistor
• Battery (from kit)

Circuit sketch or diagram

Originally what I wanted was six LED lights (2 LEDs in parallel attached to 3 pins) positioned in a circle and have them turn on in sequence as if the lights were rotating. I was hoping that it would ‘rotate’ faster as pressure increased. But I couldn’t get the code to work because there was always a lag before the code looped again. I couldn’t figure out how to make the smooth transition. Super frustrating. If anyone knows how to smooth this loop (below), please let me know!

if (sensorValue < 500){
//Sensor neutral
Serial.print (“Neutral”);
digitalWrite(ledPin, LOW);
digitalWrite(ledPin2, LOW);
digitalWrite(ledPin3, LOW);
}

else if (sensorValue > 500 && sensorValue < 700){
//Sensor pressed
Serial.print(“Pressed”);
digitalWrite(ledPin, HIGH);
delay(300);
digitalWrite(ledPin, LOW);
delay(300);
digitalWrite(ledPin2, HIGH);
delay(300);
digitalWrite(ledPin2, LOW);
delay(300);
digitalWrite(ledPin3, HIGH);
delay(300);
digitalWrite(ledPin3, LOW);
}

So moving forward, I had to change the circuit, shown below. This way, the LED lights are on individual pins.

Code

/*
*Sally Chan/Wearable Tech1/11.02.12
*
*Capacity Indicator
*
* Reads data from a Force Sensing Resistor
* Increasing number of lights turn on according
* the weight applied to sensor.
*/

int ledPin = 9; // LED is connected to digital pin 9
int ledPin2 = 10; // LED is connected to digital pin 10
int ledPin3 = 11; // LED is connected to digital pin 11
int sensorPin = 2; // FSR is connected to analog pin 2
int sensorValue; // Variable to store the value coming from the sensor

void setup()
{
pinMode(ledPin, OUTPUT); // Sets the ledPin to be an output
pinMode(ledPin2, OUTPUT); // Sets the ledPin2 to be an output
pinMode(ledPin3, OUTPUT); // Sets the ledPin3 to be an output
Serial.begin(9600); // Initialize the serial port
}

void loop() // Run over and over again
{

if (sensorValue < 90){ // If value is less than 90, turn all lights off
//Sensor neutral
Serial.print (“Neutral”);
digitalWrite(ledPin, LOW);
digitalWrite(ledPin2, LOW);
digitalWrite(ledPin3, LOW);
}

else if (sensorValue > 90 && sensorValue < 400){ // When weight is applied, and between values 90 and 400, turn one light on
//Sensor pressed
Serial.print(“LIGHT WEIGHT”);
digitalWrite(ledPin, HIGH);
}

else if (sensorValue > 400 && sensorValue < 900){ // When value between 400 and 900, turn two lights on
//Sensor pressed
Serial.print(“ACCEPTABLE WEIGHT”);
digitalWrite(ledPin, HIGH);
digitalWrite(ledPin2, HIGH);
}

else if (sensorValue > 900){ // When value is greater than 900, turn three lights on
//Sensor pressed
Serial.print(“HEAVY WEIGHT”);
digitalWrite(ledPin, HIGH);
digitalWrite(ledPin2, HIGH);
digitalWrite(ledPin3, HIGH);
}

Serial.println(sensorValue); // send that value to the computer
delay(300); // delay for 1/10 of a second
}

I first tried a lot of different circuit combinations with alligator clips and different interactions with code. For example, I could have them turn on individually and sequentially (A, B, C) or have them turn on sequentially but stay lit (A, AB, ABC). I tried blinking lights as well, but it didn’t seem appropriate for the ‘scale’ concept.

I planned my circuit out so that there would be no over laps. But just to be absolutely certain, I used electrical tape to hide the circuits. It’s not the prettiest, but it’s the fastest way to prevent short circuiting.

I actually had no clue how I would attach the FSR. A needle wouldn’t go through it. So I used fabric glue instead, which worked surprisingly well. Attaching conductive thread to it was a bit of a challenge too since they were so close together.

A view of the LEDs on the front of the back.

Visual documentation of resulting project

What I would change & Other thoughts

• The form factor of the FSR is not the best choice for what I wanted to achieve because it requires that the contents in the bag be concentrated right ON the sensor. It would be ideal if the sensor ran along the entire bottom of the bag so that the measurement of the weight is evenly distributed.
• Originally, putting the sensor on the shoulder strap was an option, but because the bag I used had a skinny strap, I decided to put the FSR on the bottom of the bag instead. But in hindsight, I think the values would have read much better on the shoulder since the pressure would be more even and stable compared to random objects shuffling inside a bag.
• More lights to indicate a wider range of weight
• Since applying pressure to the bottom of the bag with fingers also worked, a change of concept could be a discrete signal for a friend to leave a party early……where the meter would indicate the urgency of leaving 😛

## Wisdom sweater

my idea is to create a sweater that would response to Yes/No question. It always took me too long to make a decision while shopping, so this sweater comes it great help to generate a random answer. I want to make it more humanize by adding ~15 different answers in audio responses. To work the magic, user puts on the headphone that attached within the circuit, asks a question (must be Yes/No one), covering the wrist parts where light sensor placed, and the “wisdom man” in the sweater will tell you the answer.Takes literally 5 seconds! ^^

Circuit diagram (since I stack Arduino Uno to the MP3 Player Shield, the wires connect to the shield instead of Arduino in the diagram):

And the code:

Wisdomsweater_code_Arduino

Sample Audio files

track003

track004

track005

track006

track008

Voice by Cris Mora

## Responsive Wearable (Cat Hood)

For my responsive wearable I was originally going to make a hat that was shaped like a cat… Over the coarse of multiple sketches it ended up becoming a hood.

The general idea behind the piece was that when the wearer is patted on the head (Like patting a cat), the cheeks light up (mimicking a blush?) and a small vibration motor goes off against the back of the wearer’s neck (Like purring).

The end result:

The circuit is sewn onto a separate piece of cotton, a narrow strip, which I then sewed between the outer piece and the lining.

Circuit pieces:

10K resistor

Force Sensor Resistor

cotton to insulate overlapping lines

The Arduino code:

int fsrAnalogPin = 2;
int LEDpin = 11; // connect Red LED to pin 11 (PWM pin)
int LEDbrightness;
int VIBEspeed;

void setup(void) {
Serial.begin(9600); // We’ll send debugging information via the Serial monitor
pinMode(LEDpin, OUTPUT);
pinMode(6, OUTPUT);

}
void loop(void) {
// we’ll need to change the range from the analog reading (0-1023) down to the range
// used by analogWrite (0-255) with map!
LEDbrightness = map(fsrReading, 0, 1023, 0, 255);
VIBEspeed = map(fsrReading, 0, 1023, 0, 255);
// LED gets brighter the harder you press
analogWrite(LEDpin, LEDbrightness);
analogWrite(6, VIBEspeed);
delay(100);
}

## Responsive Wearable: Bra

For this project I wanted to create a bra that could prevent from pervert. The concept is when someone touches the bra the buzzer will make noises. This will be convenient for women, especially those who always take the subway.

Here is the simple sketches of the circuit

Materials:

• Sensor
• Resistor
• Battery (from the kit)

Code:

Based on the sound tutorial

int ledPin = 13;         // LED is connected to digital pin 13

int speakerPin = 9;   // speaker connected to digital pin 9

int sensorPin= A3;      //sensor connected to digital pin A3

void setup()

{

pinMode(ledPin, OUTPUT);    // sets the ledPin to be an output

pinMode(speakerPin, OUTPUT);       // sets the speakerPin to be an output

pinMode(sensorPin, INPUT);     //sets the sensorPin to be an input

}

void loop(){   // run over and over again

// read the input on analog pin 3:

if (sensorValue < 8 ) { //buzzer on

Serial. print (“buzzer on”);

digitalWrite(ledPin,HIGH);            //turn on the LED

beep(speakerPin,6090,500);

} else

Serial. print (“buzzer off”);

digitalWrite(ledPin,LOW);            //turn off the LED

// print out the value you read:

Serial.println(sensorValue);

delay(1);        // delay in between reads for stability

}

void beep (unsigned char speakerPin, int frequencyInHertz, long timeInMilliseconds)     // the sound producing function

{

int x;

long delayAmount = (long)(1000000/frequencyInHertz);

long loopTime = (long)((timeInMilliseconds*1000)/(delayAmount*2));

for (x=0;x<loopTime;x++)

{

digitalWrite(speakerPin,HIGH);

delayMicroseconds(delayAmount);

digitalWrite(speakerPin,LOW);

delayMicroseconds(delayAmount);

}

Then I tried out the circuit and sewed the sensor and resistor in the middle of the bra. Sew the lilypad and buzzer on using normal thread to keep them in place.

Connect all the components together using conductive thread.

Connect the battery with lilypad and sew it onto the bra to keep it in place. Then sew pieces of lace to decorate and hide the components.

Here is the finished piece

I tested it out under a piece of cloth and it works!!

## The Heart T-Shirt

Description

I wanted to create a circuit that measures somebody’s heart beat and incorporate it into a wearable technology, that’s when I came up with the Heart T-Shirt. The shirt requires two people, one to wear the shirt with LEDs and the lily pad arduino and the other to wear a special glove that measure that person’s heart beat. The person wearing the glove must put their hand on the shoulder of the person wearing the shirt in order to measure the heart beat and flash it on the LEDs.

Circuit Sketches

Components include:

• Infrared sensor pair – SEN 00241
• 2 x 10K resistor
• 1 x 270 resistor
• 1 x lilypad power converter
• 1 x Lithium battery
• conductive string
• conductive fabric

Process

I started off with the heart monitor. I began by using a bread board and the two IR sensors. The key was making sure the reading of the heart beat was strong enough. I used this website by Charles Martin as a reference to build the hardware and the software:

http://cmpercussion.blogspot.ca/2009/07/heartbeat-sensor.html

I then developed the code that translated the heart beat into LED flashes. I massaged my code heart monitor code from Charles’ website.

After making sure everything was working on the bread board, I then started making the glove first with the heart monitor. This process took the longest since I had to make the glove twice. The first time I used wire fearing that conductive thread would introduce too much noise into the heart monitor signal however the wire did not hold well and rebuilt it using conductive thread.

I then started putting together the shirt but using chalk to draw the circuit on the shirt. I used a sewing machine to sew the circuit on using conductive thread in the bobbin and regular thread on top.

While I was sewing I used a mulitmeter to make sure everything was connected properly. I then sewed on the LED’s and the arduino Lily pad and conductive fabric to interface with the glove:

This is the final form:

Challenges

The most difficult part was getting the heart monitor to work. It’s very finicky and sometimes I can’t get a stable signal. The other challenge was actually putting the project together. Sewing is not my forte and so it was challenging controlling the sewing machine.

Code

/*******************************************
Based on code by Charles Martin
http://cmpercussion.blogspot.ca/2009/07/heartbeat-sensor.html

*******************************************/

// Pins

const int ledPin = 13;
const int sensePin = 0;

const int HeartRing3Pos = 9;
const int HeartRing1Pos = 11;
const int HeartNeg = 10;
const int HeartPos = 18;
const int HeartBeatEnabled = 16;
const int HeartBeat = A3;
// Hearbeat detect variables
int Delta = 0;
int historySize = 8;
int recentTotal = 0;
boolean highChange = false;
int totalThreshold = 3;
int EnableCounter = 0;
int val = 0;
// Heartbeat Timing
long lastHeartbeatTime = 0;
long debounceDelay = 150;
int currentHeartrate = 0;

//Timer variables
int DelayTimer = 0;
int DelayInterval = 0;
boolean HeartBeatFlag = false;

void setup() {
// initialize the serial communication:
Serial.begin(9600);
// initialize the digital pin as an output:
pinMode(ledPin, OUTPUT);
pinMode(HeartRing3Pos, OUTPUT);
pinMode(HeartRing1Pos, OUTPUT);
pinMode(HeartNeg, OUTPUT);
pinMode(HeartPos, OUTPUT);
pinMode(HeartBeatEnabled, INPUT);
pinMode(HeartBeat, INPUT);

// set negative terminals to low:

digitalWrite(HeartNeg, LOW);
digitalWrite(HeartPos, HIGH);

digitalWrite(HeartRing1Pos, LOW);
digitalWrite(HeartRing3Pos, LOW);
digitalWrite(HeartBeatEnabled, LOW);

DelayTimer = millis();
}

void loop() {

SendHeartBeat();
delay(10);

Serial.println(“lights”);

} else {

Serial.println(“off”);

}

}

void SendHeartBeat() {
// Turn off LED
digitalWrite(ledPin, LOW);
HeartBeatFlag = false;

//Calculate Delta

// Find new recent total
// replace indexed recent value
// increment index

//Debug
//Serial.println(recentTotal);

// Decide whether to start an LED Blink.
if (recentTotal >= totalThreshold) {
// Possible heartbeart, check time
if (millis() – lastHeartbeatTime >= debounceDelay) {
// Heartbeat
digitalWrite(ledPin, HIGH);
//digitalWrite(HeartBeatOut, HIGH); // send out current heart rate
HeartBeatFlag = true;

currentHeartrate = 60000 / (millis() – lastHeartbeatTime);
lastHeartbeatTime = millis();

}
}
}

// read the other heart beat

if (HeartBeatFlag == true) {

digitalWrite(HeartRing1Pos, HIGH);
digitalWrite(HeartRing3Pos, HIGH);

} else {

digitalWrite(HeartRing1Pos, LOW);
digitalWrite(HeartRing3Pos, LOW);
}
}

## Responsive Wearable..Egan O

My project uses:

• Actuator: vibe motor
• Battery : pack from the kit

My project is a vibrating ponytail. I was inspired by the last class where we talked a lot about Amy Mullins and all the amputees and disabled vs. ableness. I thought it might be interesting to work with the idea of adding to the body to make it able to do things it could not before. However, I also wanted this function to be completely not practical or useful. Think, like what can we do to ourselves if we don’t need prothetic legs or arms? If we have a

working body or super body already where else can we go? The answer? Make your hair move !

So I used a simple circuit, and the “Blink Sketch” and a vibe motor. The vibe motor vibrates just like the LED would blink. I wanted to use a flex sensor in my project but it was not realized because of problems with the sensor and stuff. I don’t think it was the right sensor for the job. I wanted to use a flex sensor to sense when you nodded your head, like saying “yes”. Then when you nodded yes the pony tail would vibrate and be all excited. As if you just answered “yes” to something really fun. But I could not get the sensor in there so that will be revisited.

For my materials I used a coiled structure (foam & fabric) and hair that sticks out the top. I wanted to it look like a horse pony tail that people wear, because I love the way they look and I thought that would be a good excited “yes” pony tail.

My code :

/*
Turns on an LED on for one second, then off for one second, repeatedly.

This example code is in the public domain.
*/

// Pin 13 has an LED connected on most Arduino boards.
// give it a name:
int led = 11;

// the setup routine runs once when you press reset:
void setup() {
// initialize the digital pin as an output.
pinMode(led, OUTPUT);
}

// the loop routine runs over and over again forever:
void loop() {
digitalWrite(led, HIGH); // turn the LED on (HIGH is the voltage level)
delay(1000); // wait for a second
digitalWrite(led, LOW); // turn the LED off by making the voltage LOW
delay(1000); // wait for a second
}