shirt.c

/* Heartbeat */
/*
>> Pulse Sensor Amped 1.1 <<
This code is for Pulse Sensor Amped by Joel Murphy and Yury Gitman
    www.pulsesensor.com 
    >>> Pulse Sensor purple wire goes to Analog Pin 0 <<<
Pulse Sensor sample aquisition and processing happens in the background via Timer 2 interrupt. 2mS sample rate.
PWM on pins 3 and 11 will not work when using this code, because we are using Timer 2!
The following variables are automatically updated:
Signal :    int that holds the analog signal data straight from the sensor. updated every 2mS.
IBI  :      int that holds the time interval between beats. 2mS resolution.
BPM  :      int that holds the heart rate value, derived every beat, from averaging previous 10 IBI values.
QS  :       boolean that is made true whenever Pulse is found and BPM is updated. User must reset.
Pulse :     boolean that is true when a heartbeat is sensed then false in time with pin13 LED going out.

This code is designed with output serial data to Processing sketch "PulseSensorAmped_Processing-xx"
The Processing sketch is a simple data visualizer. 
All the work to find the heartbeat and determine the heartrate happens in the code below.
Pin 13 LED will blink with heartbeat.
If you want to use pin 13 for something else, adjust the interrupt handler
It will also fade an LED on pin fadePin with every beat. Put an LED and series resistor from fadePin to GND.
Check here for detailed code walkthrough:
http://pulsesensor.myshopify.com/pages/pulse-sensor-amped-arduino-v1dot1

Code Version 02 by Joel Murphy & Yury Gitman  Fall 2012
This update changes the HRV variable name to IBI, which stands for Inter-Beat Interval, for clarity.
Switched the interrupt to Timer2.  500Hz sample rate, 2mS resolution IBI value.
Fade LED pin moved to pin 5 (use of Timer2 disables PWM on pins 3 & 11).
Tidied up inefficiencies since the last version. 
*/

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

// 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, the Inter-Beat Interval
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.

void sendDataToProcessing(char symbol, int data ) {
  Serial.print(symbol);                // symbol prefix tells Processing what type of data is coming
  Serial.println(data);                // the data to send culminating in a carriage return
}

volatile int rate[10];                    // used to hold last ten IBI values
volatile unsigned long sampleCounter = 0;          // used to determine pulse timing
volatile unsigned long lastBeatTime = 0;           // used to find the inter beat interval
volatile int P = 512;                      // used to find peak in pulse wave
volatile int T = 512;                     // used to find trough in pulse wave
volatile int thresh = 512;                // used to find instant moment of heart beat
volatile int amp = 100;                   // used to hold amplitude of pulse waveform
volatile boolean firstBeat = true;        // used to seed rate array so we startup with reasonable BPM
volatile boolean secondBeat = true;       // used to seed rate array so we startup with reasonable BPM

void interruptSetup(){     
  // Initializes Timer2 to throw an interrupt every 2mS.
  TCCR1A = 0x02;     // DISABLE PWM ON DIGITAL PINS 3 AND 11, AND GO INTO CTC MODE
  TCCR1B = 0x04;     // DON'T FORCE COMPARE, 256 PRESCALER 
  OCR1A  = 0X7C;      // SET THE TOP OF THE COUNT TO 124 FOR 500Hz SAMPLE RATE
  TIMSK1 = 0x02;     // ENABLE INTERRUPT ON MATCH BETWEEN TIMER2 AND OCR2A
  sei();             // MAKE SURE GLOBAL INTERRUPTS ARE ENABLED      
} 

void heartRate() {
  //sendDataToProcessing('S', Signal);     // send Processing the raw Pulse Sensor data
  if (QS == true){                       // Quantified Self flag is true when arduino finds a heartbeat
    sendDataToProcessing('B',BPM);   // send heart rate with a 'B' prefix
    sendDataToProcessing('Q',IBI);   // send time between beats with a 'Q' prefix
    QS = false;                      // reset the Quantified Self flag for next time    
  } 
}

// THIS IS THE TIMER 2 INTERRUPT SERVICE ROUTINE. 
// Timer 2 makes sure that we take a reading every 2 miliseconds
ISR(TIMER1_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
        IBI = sampleCounter - lastBeatTime;         // measure time between beats in mS
        lastBeatTime = sampleCounter;               // keep track of time for next pulse
         
        if(firstBeat){                         // if it's the first time we found a beat, if firstBeat == TRUE
          firstBeat = false;                 // clear firstBeat flag
          return;                            // IBI value is unreliable so discard it
         }   
         
         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;                      
            }
          }
          
          // 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
      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 = true;                     // when we get the heartbeat back
  }
  
  sei();                                     // enable interrupts when youre done!
}// end isr

/* Note PlayBack */
#include "notes.h"
// readCapacitivePin
//  Input: Arduino pin number
//  Output: A number, from 0 to 17 expressing
//  how much capacitance is on the pin
//  When you touch the pin, or whatever you have
//  attached to it, the number will get higher
// #include "pins_arduino.h" // Arduino pre-1.0 needs this
uint8_t readCapacitivePin(int pinToMeasure) {
  // Variables used to translate from Arduino to AVR pin naming
  volatile uint8_t* port;
  volatile uint8_t* ddr;
  volatile uint8_t* pin;
  // Here we translate the input pin number from
  //  Arduino pin number to the AVR PORT, PIN, DDR,
  //  and which bit of those registers we care about.
  byte bitmask;
  port = portOutputRegister(digitalPinToPort(pinToMeasure));
  ddr = portModeRegister(digitalPinToPort(pinToMeasure));
  bitmask = digitalPinToBitMask(pinToMeasure);
  pin = portInputRegister(digitalPinToPort(pinToMeasure));
  // Discharge the pin first by setting it low and output
  *port &= ~(bitmask);
  *ddr  |= bitmask;
  delay(1);
  // Make the pin an input with the internal pull-up on
  *ddr &= ~(bitmask);
  *port |= bitmask;

  // Now see how long the pin to get pulled up. This manual unrolling of the loop
  // decreases the number of hardware cycles between each read of the pin,
  // thus increasing sensitivity.
  uint8_t cycles = 17;
       if (*pin & bitmask) { cycles =  0;}
  else if (*pin & bitmask) { cycles =  1;}
  else if (*pin & bitmask) { cycles =  2;}
  else if (*pin & bitmask) { cycles =  3;}
  else if (*pin & bitmask) { cycles =  4;}
  else if (*pin & bitmask) { cycles =  5;}
  else if (*pin & bitmask) { cycles =  6;}
  else if (*pin & bitmask) { cycles =  7;}
  else if (*pin & bitmask) { cycles =  8;}
  else if (*pin & bitmask) { cycles =  9;}
  else if (*pin & bitmask) { cycles = 10;}
  else if (*pin & bitmask) { cycles = 11;}
  else if (*pin & bitmask) { cycles = 12;}
  else if (*pin & bitmask) { cycles = 13;}
  else if (*pin & bitmask) { cycles = 14;}
  else if (*pin & bitmask) { cycles = 15;}
  else if (*pin & bitmask) { cycles = 16;}

  // Discharge the pin again by setting it low and output
  //  It's important to leave the pins low if you want to 
  //  be able to touch more than 1 sensor at a time - if
  //  the sensor is left pulled high, when you touch
  //  two sensors, your body will transfer the charge between
  //  sensors.
  *port &= ~(bitmask);
  *ddr  |= bitmask;

  return cycles;
}

// Pin the speaker is plugged into.
const int speakerPin    = 8;

// On/Off Button
long playableExpires = 0;
const int buttonPin  = 12;
int buttonPressed    = 0;

// Touch sensor pins.
const int stripOnePin   = 2;
const int stripTwoPin   = 3;
const int stripThreePin = 4;
const int stripFourPin  = 5;
const int stripFivePin  = 6;
const int stripSixPin   = 9;
const int stripSevenPin = 10;
const int stripEightPin = 11;
// Reset all pins to be untouched(0).
int stripOneTouched   = 0;
int stripTwoTouched   = 0; 
int stripThreeTouched = 0;
int stripFourTouched  = 0;
int stripFiveTouched  = 0;
int stripSixTouched   = 0; 
int stripSevenTouched = 0;
int stripEightTouched = 0;

// Whether or not notes should be played.
int playable = 0;

void playStartup() {
 int playTime = 500;
 
 tone(speakerPin, NOTE_E4, playTime); 
 delay(playTime);
 tone(speakerPin, NOTE_G4, playTime);
 delay(playTime);
 tone(speakerPin, NOTE_C5, playTime);
 delay(playTime);
}

void playGoodbye() {
  int playTime = 500;
  
 tone(speakerPin, NOTE_C5, playTime);
 delay(playTime);
 tone(speakerPin, NOTE_G4, playTime);
 delay(playTime);
 tone(speakerPin, NOTE_E4, playTime);
 delay(playTime);
}
   
void play(int pin, int note) {
  if (playable > 0) {
    tone(pin, note);
  }
}

void setup() {
  Serial.begin(9600);
  //interruptSetup();
}

void loop() {
  buttonPressed = readCapacitivePin(buttonPin);
  
  if (buttonPressed > 1) {
    Serial.println("Extending playable time by 120 seconds");
    playStartup();
    playableExpires = millis() + 120000;
  }
  
  if (millis() > playableExpires) {
    if (playable == 1) {
      playable = 0; 
      playGoodbye();
    }
  } else {
    playable = 1; 
  }
  
  // Check if any of the strips are touched.
  stripOneTouched   = readCapacitivePin(stripOnePin);
  stripTwoTouched   = readCapacitivePin(stripTwoPin);
  stripThreeTouched = readCapacitivePin(stripThreePin);
  stripFourTouched  = readCapacitivePin(stripFourPin);
  stripFiveTouched  = readCapacitivePin(stripFivePin);
  stripSixTouched   = readCapacitivePin(stripSixPin);
  stripSevenTouched = readCapacitivePin(stripSevenPin);
  stripEightTouched = readCapacitivePin(stripEightPin);
    
  // If greater than zero then it is being touched.  
  if (stripOneTouched > 1) {
    Serial.println("1 is touched");
    play(speakerPin, NOTE_C4);
  } else if (stripTwoTouched > 1) {
    Serial.println("2 is touched"); 
    play(speakerPin, NOTE_D4);
  } else if (stripThreeTouched > 1) {
    Serial.println("3 is touched");
    play(speakerPin, NOTE_E4);
  } else if (stripFourTouched > 1) {
    Serial.println("4 is touched");
    play(speakerPin, NOTE_F4);
  } else if (stripFiveTouched > 1) {
    Serial.println("5 is touched");
    play(speakerPin, NOTE_G4);
  } else if (stripSixTouched > 1) {
    Serial.println("6 is touched");
    play(speakerPin, NOTE_A4);
  } else if (stripSevenTouched > 1) {
    Serial.println("7 is touched");
    play(speakerPin, NOTE_B4);
  } else if (stripEightTouched > 1) {
    Serial.println("8 is touched");
    play(speakerPin, NOTE_C5);
  } else {
    //Serial.println("no touch");
    noTone(speakerPin);
  }

  //heartRate();

  delay(50);
}