Group members : Alice Borie and Riya Savla
Introduction
Our mood sweater aims to visualize the wearer’s emotions. We created this sweater because we realized there were times when emotion is something that cannot be truly seen. For example, it can be easy to mask and hide our true emotions. In other situations, individuals may also be unable to expressively show emotion because of physical impairments such as muscle degeneration. Our sweater solves these problems by detecting emotion based off biometrics and by displaying them through color.
Technical Details
The sweater works based on inputs of a pulse sensor and a Galvanic Skin Response (GSR) sensor to detect different emotions. The GSR provides data about skin conductance and maps micro perspiration levels to a more active or passive emotion. The GSR works on the simple principle that the wearer’s skin completes the path of the circuit. The voltage difference across the two end of the GSR is measured and values in different ranges correspond to different states of emotion.
The Pulse Sensor, as the name implies, measures heart rate. We used example code available online, to get BPM values and infer emotional state accordingly. We used an Arduino UNO to process the data and control the LED display.
Currently, we are able to distinguish four different emotions – happiness, sadness, anger and a neutral state. Given more time, we would have liked to include temperature sensing of different parts of the body to create a heat map and widen the range of emotions the sweater can detect.
Making the product
We packaged the circuitry neatly, added a switch so the user has more control over whether he wants his emotions to be on display or not and stitched the circuit on to a jacket. The sensors (GSR and Pulse) come out through the jacket’s right sleeve for the user to slip his fingers through them. The LED display sits between the shoulder and the chest and the main circuit sits in the jacket’s pocket.
Arduino Code
// VARIABLES// Heart Rateint pulsePin = 0; // Pulse Sensor purple wire connected to analog pin 0int blinkPin = 13; // pin to blink led at each beatint fadePin = 5; // pin to do fancy classy fading blink at each beatint fadeRate = 0; // used to fade LED on with PWM on fadePin// GSRint redPin = 9;int greenPin = 10;int bluePin = 6;int potPin = 1;int sensorPin = 2;long red = 0xFF0000;long green = 0x00FF00;long blue = 0x000080;long white = 0xFFFFFF;int band = 20;// these variables are volatile because they are used during the interrupt service routine!volatile int BPM; // used to hold the pulse ratevolatile int Signal; // holds the incoming raw datavolatile int IBI = 600; // holds the time between beats, must be seeded!volatile boolean Pulse = false; // true when pulse wave is high, false when it’s lowvolatile boolean QS = false; // becomes true when Arduoino finds a beat.volatile int rate[10]; // array to hold last ten IBI valuesvolatile unsigned long sampleCounter = 0; // used to determine pulse timingvolatile unsigned long lastBeatTime = 0; // used to find IBIvolatile int P =512; // used to find peak in pulse wave, seededvolatile int T = 512; // used to find trough in pulse wave, seededvolatile int thresh = 525; // used to find instant moment of heart beat, seededvolatile int amp = 100; // used to hold amplitude of pulse waveform, seededvolatile boolean firstBeat = true; // used to seed rate array so we startup with reasonable BPMvolatile boolean secondBeat = false; // used to seed rate array so we startup with reasonable BPMvoid setup(){pinMode(blinkPin,OUTPUT); // pin that will blink to your heartbeat!pinMode(fadePin,OUTPUT); // pin that will fade to your heartbeat!Serial.begin(9600); // we agree to talk fast!interruptSetup(); // sets up to read Pulse Sensor signal every 2mS// UN-COMMENT THE NEXT LINE IF YOU ARE POWERING The Pulse Sensor AT LOW VOLTAGE,// AND APPLY THAT VOLTAGE TO THE A-REF PIN// analogReference(EXTERNAL);pinMode(potPin, INPUT); //This is to set the input resistance that comes from potentiometer A1pinMode(sensorPin, INPUT);//This is to set the input resistance from the skinpinMode(redPin, OUTPUT);//This is to set the output for RED LedpinMode(greenPin, OUTPUT);//This is to set the output for green LedpinMode(bluePin, OUTPUT);//This is to set the output for blue(or transparent) Led}void loop(){Serial.println(BPM);int gsr = analogRead(sensorPin);int pot = analogRead(potPin);boolean GSRhigh = (gsr > pot + band);boolean angry = (BPM > 100);boolean sad = ((BPM > 80) && (BPM < 100) && !GSRhigh);boolean happy = (GSRhigh && (BPM > 80) && (BPM < 100));if (angry)//This condition if true indicates the lie{Serial.println(“angry”);Serial.print(“GSR = “);Serial.println(gsr);setColor(red);}/*else if (gsr < pot – band)//This condition if true indicates the need of adjusting the resistance{setColor(blue);}*/else if (sad)//This condition becomes true for other condition becomes false and is at normal resistance{Serial.println(“sad”);Serial.print(“GSR = “);Serial.println(gsr);setColor(blue);}else if (happy)//This condition becomes true for other condition becomes false and is at normal resistance{Serial.println(“happy”);Serial.println(gsr);setColor(green);}else //This condition becomes true for other condition becomes false and is at normal resistance{Serial.println(“nuetral”);Serial.print(“GSR = “);Serial.println(gsr);setColor(white);}}void setColor(long rgb) //This functions sets the colour{int red = rgb >> 16;int green = (rgb >> 8) & 0xFF;int blue = rgb & 0xFF;analogWrite(redPin, 255 – red);analogWrite(greenPin, 255 – green);analogWrite(bluePin, 255 – blue);}void interruptSetup(){// Initializes Timer2 to throw an interrupt every 2mS.TCCR2A = 0x02; // DISABLE PWM ON DIGITAL PINS 3 AND 11, AND GO INTO CTC MODETCCR2B = 0x06; // DON’T FORCE COMPARE, 256 PRESCALEROCR2A = 0X7C; // SET THE TOP OF THE COUNT TO 124 FOR 500Hz SAMPLE RATETIMSK2 = 0x02; // ENABLE INTERRUPT ON MATCH BETWEEN TIMER2 AND OCR2Asei(); // MAKE SURE GLOBAL INTERRUPTS ARE ENABLED}// THIS IS THE TIMER 2 INTERRUPT SERVICE ROUTINE.// Timer 2 makes sure that we take a reading every 2 milisecondsISR(TIMER2_COMPA_vect){ // triggered when Timer2 counts to 124cli(); // disable interrupts while we do thisSignal = analogRead(pulsePin); // read the Pulse SensorsampleCounter += 2; // keep track of the time in mS with this variableint N = sampleCounter – lastBeatTime; // monitor the time since the last beat to avoid noise// find the peak and trough of the pulse waveif(Signal < thresh && N > (IBI/5)*3){ // avoid dichrotic noise by waiting 3/5 of last IBIif (Signal < T){ // T is the troughT = Signal; // keep track of lowest point in pulse wave}}if(Signal > thresh && Signal > P){ // thresh condition helps avoid noiseP = Signal; // P is the peak} // keep track of highest point in pulse wave// NOW IT’S TIME TO LOOK FOR THE HEART BEAT// signal surges up in value every time there is a pulseif (N > 250){ // avoid high frequency noiseif ( (Signal > thresh) && (Pulse == false) && (N > (IBI/5)*3) ){Pulse = true; // set the Pulse flag when we think there is a pulsedigitalWrite(blinkPin,HIGH); // turn on pin 13 LEDIBI = sampleCounter – lastBeatTime; // measure time between beats in mSlastBeatTime = sampleCounter; // keep track of time for next pulseif(secondBeat){ // if this is the second beat, if secondBeat == TRUEsecondBeat = false; // clear secondBeat flagfor(int i=0; i<=9; i++){ // seed the running total to get a realisitic BPM at startuprate[i] = IBI;}}if(firstBeat){ // if it’s the first time we found a beat, if firstBeat == TRUEfirstBeat = false; // clear firstBeat flagsecondBeat = true; // set the second beat flagsei(); // enable interrupts againreturn; // IBI value is unreliable so discard it}// keep a running total of the last 10 IBI valuesword runningTotal = 0; // clear the runningTotal variablefor(int i=0; i<=8; i++){ // shift data in the rate arrayrate[i] = rate[i+1]; // and drop the oldest IBI valuerunningTotal += rate[i]; // add up the 9 oldest IBI values}rate[9] = IBI; // add the latest IBI to the rate arrayrunningTotal += rate[9]; // add the latest IBI to runningTotalrunningTotal /= 10; // average the last 10 IBI valuesBPM = 60000/runningTotal; // how many beats can fit into a minute? that’s BPM!QS = true; // set Quantified Self flag// QS FLAG IS NOT CLEARED INSIDE THIS ISR}}if (Signal < thresh && Pulse == true){ // when the values are going down, the beat is overdigitalWrite(blinkPin,LOW); // turn off pin 13 LEDPulse = false; // reset the Pulse flag so we can do it againamp = P – T; // get amplitude of the pulse wavethresh = amp/2 + T; // set thresh at 50% of the amplitudeP = thresh; // reset these for next timeT = thresh;}if (N > 2500){ // if 2.5 seconds go by without a beatthresh = 512; // set thresh defaultP = 512; // set P defaultT = 512; // set T defaultlastBeatTime = sampleCounter; // bring the lastBeatTime up to datefirstBeat = true; // set these to avoid noisesecondBeat = false; // when we get the heartbeat back}sei(); // enable interrupts when youre done!}// end isr
]]>
Previous academic research indicates that heart rate and SCR can be mapped in the following ways to indicate emotion:
– high/high = happy
– low/medium = sad
– low/low = neutral
– high/medium = angry
We will be using a pulse sensor to measure heart rate and will be building a Galvanic Skin Response (GSR) sensor to measure skin conductance resistance. We will then process the data to map it to each emotion state. The sensors will be placed on two finger tips and the LED display will be clipped to a t-shirt. The happy state will be indicated by a purple light, sad state by a blue light, neutral state by a green light, and angry state by a red light.
]]>Roles: Alice Borie as Scribe, Luke Hottinger – Integrator, Horace Hou as Designer , Vivian Qiu as Designer, Rebecca Wolfinger as Tutor
Introduction
For this project, we were given the prompt to create a dream machine. We took a twist on this prompt and decided to build a machine to create an unpleasant dream – a nightmare.
Our Dream Machine invokes both an ambient pleasant aura of a dream, as well as the unpleasant anxiety of a nightmare, both of which are depicted through change in light and sound. Once the viewer initially steps in, he/she experiences a pleasant soft glow of lights, which only lasts halfway through the dream experience. As the viewer continues to walk through the piece, the lights start to turn on and off at faster frequency. The pleasant soft glow represents the initial calm and peaceful feeling of falling into a dream while the unpleasant, more-frequent lights represent the uneasy and agitated feeling of a nightmare. The frequent nightmarish lights are interweaved with the pleasant dream lights because the experience of a nightmare can be confusingly pleasant. One only realizes that they are in a nightmare towards the end of a dream. The nightmare experience finally ends when the viewer steps out of the project, similar to the jolting awakening we feel once we exit our nightmares. This gradual change in mood serves to represent the progression of our dream experience.
Video
Technical Notes
Our project is a rectangular walkway that hangs from the ceiling. The entrance and exits of our piece are open but our piece consists of two side walls. One side wall is black to shield the viewer from any external lights and the other side is a wall of LED strips that represent the different nightmare states. The LED strips are powered by an external power source and are programmed through an Arduino. The lull in the background is a Pure Data program that continuously runs during the exhibition of this piece.
Photos