1

So the code is working individually for temperature sensor and for heartbeat sensor but when i combine it together it shows wrong values for the temperature sensor

I'm using lm35 temperature sensor and powering by USB

#include <LiquidCrystal.h>


const int rs = 13, en = 12, d4 = 11, d5 = 10, d6 = 9, d7 = 8;
LiquidCrystal lcd(13, 12, 11, 10, 9, 8);

int pulsePin = A0;


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

// Volatile Variables, used in the interrupt service routine!
volatile int BPM ;                   // int that holds raw Analog in 0. updated every 2mS
volatile int Signal;                // holds the incoming raw data
volatile int IBI = 600;             // int that holds the time interval between beats! Must be seeded! 
volatile boolean Pulse = false;     // "True" when User's live heartbeat is detected. "False" when not a "live beat". 
volatile boolean QS = false;        // becomes true when Arduoino finds a beat.

static boolean serialVisual = true;   // Set to 'false' by Default.  Re-set to 'true' to see Arduino Serial Monitor ASCII Visual Pulse 

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

const int sensor = A5;
int tempc ;
float vout;

void setup()
{
  vout =analogRead(sensor); 
  pinMode(sensor,INPUT);
  pinMode(blinkPin,OUTPUT);         // pin that will blink to your heartbeat!
  Serial.begin(9600);             // we agree to talk fast!
  interruptSetup();                 // sets up to read Pulse Sensor signal every 2mS 
                                  // IF YOU ARE POWERING The Pulse Sensor AT VOLTAGE LESS THAN THE BOARD VOLTAGE, 
                                    // UN-COMMENT THE NEXT LINE AND APPLY THAT VOLTAGE TO THE A-REF PIN
                                    //   analogReference(EXTERNAL);   
 lcd.begin(16, 4);
 lcd.clear();
}


//  Where the Magic Happens
void loop()
{

lcd.setCursor(0,0);
lcd.print(" T in c = ");
lcd.print(tempc);
lcd.setCursor(0,1); 

delay(100);
   serialOutput();  

  if (QS == true) // A Heartbeat Was Found
    {     
      // BPM and IBI have been Determined
      // Quantified Self "QS" true when arduino finds a heartbeat
      serialOutputWhenBeatHappens(); // A Beat Happened, Output that to serial.     
      QS = false; // reset the Quantified Self flag for next time  
      tempc=(vout*500)/1023;

    }

  delay(20); //  take a break
}


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      
} 

void serialOutput()
{   // Decide How To Output Serial. 
 if (serialVisual == true)
  {  
     arduinoSerialMonitorVisual('-', Signal);   // goes to function that makes Serial Monitor Visualizer
  } 
 else
  {
      sendDataToSerial('S', Signal);     // goes to sendDataToSerial function
   }        
}

void serialOutputWhenBeatHappens()
{    
 if (serialVisual == true) //  Code to Make the Serial Monitor Visualizer Work
   {   

     int din ;       
      din = analogRead(4);

     Serial.print(BPM);
     Serial.print(", ");
     Serial.print(tempc);
     Serial.print(", ");
     Serial.print(din);
     Serial.print(", ");

     Serial.println();
     lcd.setCursor(0,2);
     lcd.print("Heart-Beat Found ");
     lcd.setCursor(6,3);
     lcd.print(BPM);
     delay(100);
     lcd.clear();
   }
 else
   {
     sendDataToSerial('B',BPM);   // send heart rate with a 'B' prefix
     sendDataToSerial('Q',IBI);   // send time between beats with a 'Q' prefix
   }   
}

void arduinoSerialMonitorVisual(char symbol, int data )
{    
  const int sensorMin = 0;      // sensor minimum, discovered through experiment
  const int sensorMax = 1024;    // sensor maximum, discovered through experiment
  int sensorReading = data; // map the sensor range to a range of 12 options:
  int range = map(sensorReading, sensorMin, sensorMax, 0, 11);
  // do something different depending on the 
  // range value:
}

void sendDataToSerial(char symbol, int data )
{
   Serial.print(symbol);
   Serial.println(data);                
}

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
2
+50

If the provided source is cut down to the lines that have to do with the temperature, it is just this. If you try this sketch it should behave equally "wrong":

const int sensor = A5;
int tempc;
float vout;

void setup()
{
    vout = analogRead(sensor); 
    pinMode(sensor, INPUT);
}

void loop()
{
    lcd.print(tempc);
    tempc = (vout * 500) / 1023;
}

In loop() the value of tempc is printed before it is re-calculated from vout.

But vout is written to just one time in setup().

So the "wrong" values you are talking about are always the same value which was measured at start-up time. (You did not mention what is wrong.)


Note: Like documented in the Arduino's library reference, there is no need to set a pin to INPUT mode because it's the default.


I read your comment on @Abel's answer and even watched your video. Since it's not clear what you did I can't say anything why you have jumping values now. (Please write some prose and show the new code in your question the next time.)

If we apply his advice the source will look like this. I removed the setting of the pin mode (see above) and made the sequence of instructions in loop() more logical.

const int sensor = A5;
int tempc;
float vout;

void setup()
{
}

void loop()
{
    vout = analogRead(sensor); 
    tempc = (vout * 500) / 1023;
    lcd.print(tempc);
}

This sketch will show the current temperature tracking the actual value. If not you have another problem independent of the interrupt and the heartbeat sensor.


Additional notes:

  1. analogRead() returns an int. You assign it to a float so here is an implicit conversion.
  2. This float is fine because you do the mapping "by hand." If you'd use map() it could be an int.
  3. The result of the mapping expression is of type float and you assign it to an int. Here is another implicit conversion which removes the fractional part. This is OK because of the accuracy of the measurement.

Now to your assumption that the interrupts disturb the measurement of the temperature.

From the source I don't see any reason. So you might like to proceed like this:

  1. Comment everything that has to do with the heartbeat acquisition, including the timer interrupt. You can do this with /* … */ or #if 0-#endif-pairs. The former can't be "stacked" and the latter need their own lines.
  2. Check whether the temperature is tracked OK.
    • If yes, proceed.
    • If no, your temperature circuitry is faulty in some way. A schematic and a photo (edit your question for this) could be helpful for us. Don't proceed until this is solved.
  3. The timer and its interrupt service routine is actived again but will execute nothing.
  4. Check whether the temperature is OK.
    • If yes, proceed.
    • If no, I'm out of ideas for the moment.
  5. Re-enable the heartbeat acquisition.
  6. Check whether the temperature is OK.
    • If yes, proceed.
    • If no, I'm out of ideas for the moment.
  7. Problem solved.
1

Code seems to lack a repeating update of tempc via

vout =analogRead(sensor);

An alternative might be changing the line for setting tempc to be

tempc=(int) (analogRead(sensor) * 500.0f/1023.0f);
  • thanks for your answer, I'm still a newbie can you please explain more? – Aref Ben Lazrek Nov 13 at 0:36
  • Add that vout = line between QS = false; and tempc = and let me know if issue still persists. Basically you have to update vout before you calculate tempc from it. analogRead is a one shot read on the pin. – Abel Nov 13 at 0:40
  • Thanks, I'll try and keep you updated – Aref Ben Lazrek Nov 13 at 0:53
  • sorry for the late response,I've tried your suggestions but unfortunately I didn't get any result.I think the problem is due to the interrupts() or timer2 instructions because when I add cli() (disable interrupt) before vout=analogRead(sensor); the temperature give me the right value but the pulse sensor stop working . thats what I'm getting currently youtube.com/watch?v=dBPKmYd08U8 thanks – Aref Ben Lazrek Nov 16 at 22:45
0

Why do you compute tempc only after you print out the value in serialOutputWhenBeatHappens`? You also forgot to read the temperature continuously.

Here is how I would do it:

void loop()
{
  // read the sensor before it is printed on the LCD
  vout  = analogRead( sensor ); 

  // here I'm not sure what you are computing 
  // you map the sensor voltage to a range from 0°C to 500°C 
  // do you measure the heartbeat and temperature of a dragon? ;-)
  // this formula is the same as yours
  tempc = ( vout / 1023.0 ) * 500.0;

  // I would also clear the LCD before I write to it
  lcd.clear();

  lcd.setCursor( 0, 0 );
  lcd.print( "T in c = " );
  lcd.print( tempc );
  lcd.setCursor( 0,1 ); 

  // There is no need to slow down the loop here.
  // let it run ...
  // delay(100);

  serialOutput();  

  // A Heartbeat Was Found
  if (QS == true)
  {     
     // BPM and IBI have been Determined
     // Quantified Self "QS" true when arduino finds a heartbeat
     // A Beat Happened, Output that to serial.     
     serialOutputWhenBeatHappens();

     // reset the Quantified Self flag for next time  
     QS = false; 
  }

  // take a break (Why?)
  // delay(20);
}

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.