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 Rate

int pulsePin = 0;                 // Pulse Sensor purple wire connected to analog pin 0

int blinkPin = 13;                // pin to blink led at each beat

int fadePin = 5;                  // pin to do fancy classy fading blink at each beat

int fadeRate = 0;                 // used to fade LED on with PWM on fadePin

// GSR

int 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 rate

volatile int Signal;                // holds the incoming raw data

volatile 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 low

volatile boolean QS = false;        // becomes true when Arduoino finds a beat.

volatile int rate[10];                    // array to hold last ten IBI values

volatile unsigned long sampleCounter = 0;          // used to determine pulse timing

volatile unsigned long lastBeatTime = 0;           // used to find IBI

volatile int P =512;                      // used to find peak in pulse wave, seeded

volatile int T = 512;                     // used to find trough in pulse wave, seeded

volatile int thresh = 525;                // used to find instant moment of heart beat, seeded

volatile int amp = 100;                   // used to hold amplitude of pulse waveform, seeded

volatile boolean firstBeat = true;        // used to seed rate array so we startup with reasonable BPM

volatile boolean secondBeat = false;      // used to seed rate array so we startup with reasonable BPM

void 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 A1

pinMode(sensorPin, INPUT);//This is to set the input resistance from the skin

pinMode(redPin, OUTPUT);//This is to set the output for RED Led

pinMode(greenPin, OUTPUT);//This is to set the output for green Led

pinMode(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 MODE

  TCCR2B = 0x06;     // DON’T FORCE COMPARE, 256 PRESCALER

  OCR2A = 0X7C;      // SET THE TOP OF THE COUNT TO 124 FOR 500Hz SAMPLE RATE

  TIMSK2 = 0x02;     // ENABLE INTERRUPT ON MATCH BETWEEN TIMER2 AND OCR2A

  sei();             // 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 miliseconds

ISR(TIMER2_COMPA_vect){                         // triggered when Timer2 counts to 124

  cli();                                      // disable interrupts while we do this

  Signal = analogRead(pulsePin);              // read the Pulse Sensor

  sampleCounter += 2;                         // keep track of the time in mS with this variable

  int N = sampleCounter – lastBeatTime;       // monitor the time since the last beat to avoid noise

    //  find the peak and trough of the pulse wave

  if(Signal < thresh && N > (IBI/5)*3){       // avoid dichrotic noise by waiting 3/5 of last IBI

    if (Signal < T){                        // T is the trough

      T = Signal;                         // keep track of lowest point in pulse wave

    }

  }

  if(Signal > thresh && Signal > P){          // thresh condition helps avoid noise

    P = 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 pulse

  if (N > 250){                                   // avoid high frequency noise

    if ( (Signal > thresh) && (Pulse == false) && (N > (IBI/5)*3) ){

      Pulse = true;                               // set the Pulse flag when we think there is a pulse

      digitalWrite(blinkPin,HIGH);                // turn on pin 13 LED

      IBI = sampleCounter – lastBeatTime;         // measure time between beats in mS

      lastBeatTime = sampleCounter;               // keep track of time for next pulse

      if(secondBeat){                        // if this is the second beat, if secondBeat == TRUE

        secondBeat = false;                  // clear secondBeat flag

        for(int i=0; i<=9; i++){             // seed the running total to get a realisitic BPM at startup

          rate[i] = IBI;

        }

      }

      if(firstBeat){                         // if it’s the first time we found a beat, if firstBeat == TRUE

        firstBeat = false;                   // clear firstBeat flag

        secondBeat = true;                   // set the second beat flag

        sei();                               // enable interrupts again

        return;                              // IBI value is unreliable so discard it

      }

      // keep a running total of the last 10 IBI values

      word runningTotal = 0;                  // clear the runningTotal variable

      for(int i=0; i<=8; i++){                // shift data in the rate array

        rate[i] = rate[i+1];                  // and drop the oldest IBI value

        runningTotal += rate[i];              // add up the 9 oldest IBI values

      }

      rate[9] = IBI;                          // add the latest IBI to the rate array

      runningTotal += rate[9];                // add the latest IBI to runningTotal

      runningTotal /= 10;                     // average the last 10 IBI values

      BPM = 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 over

    digitalWrite(blinkPin,LOW);            // turn off pin 13 LED

    Pulse = false;                         // reset the Pulse flag so we can do it again

    amp = P – T;                           // get amplitude of the pulse wave

    thresh = amp/2 + T;                    // set thresh at 50% of the amplitude

    P = thresh;                            // reset these for next time

    T = thresh;

  }

  if (N > 2500){                           // if 2.5 seconds go by without a beat

    thresh = 512;                          // set thresh default

    P = 512;                               // set P default

    T = 512;                               // set T default

    lastBeatTime = sampleCounter;          // bring the lastBeatTime up to date

    firstBeat = true;                      // set these to avoid noise

    secondBeat = 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