RF module(434Mhz) VirtualWire conflict with interrupt services?

Hello, i am doing the project about the transmit the heart beat rate through RF module , but i dun know why it is unable to transmit the message.If i remove the interrupt() commands on the void setup , the RF module working properly and can transmit the message.Anybody can help i want use virtual wire together with the interrupt heart beat sensor.
I am using the pulse sensor amped and a pair of 434Mhz radio frequency (RF)module.
:confused:
Thanks

Post your code.

#include <VirtualWire.h>
#include <LiquidCrystal.h>
#include <avr/interrupt.h> // interrupts library
#include<Adafruit_MLX90614.h>
LiquidCrystal lcd(8,9,4,5,6,7);
Adafruit_MLX90614 mlx = Adafruit_MLX90614();

// these variables are volatile because they are used during the interrupt service routine!
volatile float 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.
int pulsePin=8;
volatile float tempo=0;
char msg[3];
int LED=1;

void setup(){

Serial.begin(115200); // we agree to talk fast!
mlx.begin();
lcd.begin(16,2);
lcd.clear();
vw_set_tx_pin(12);
vw_set_ptt_inverted(true);
vw_setup(4000);
interruptSetup();
}

void loop(){
sendDataToProcessing(‘S’, Signal); // send Processing the raw Pulse Sensor data
tempo=mlx.readObjectTempC();
sendmsg();
if (QS == true){// Quantified Self flag is true when arduino finds a heartbeat

lcd.clear();
lcd.setCursor(0,0);
lcd.print(“BPM”);
lcd.print(BPM);
Serial.print(BPM);
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

}

delay(20); // take a break

}

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

}

void sendmsg (){

dtostrf(tempo,6,2,msg);
vw_send((uint8_t *)msg, strlen(msg)); // Send control character
vw_wait_tx(); // Wait until the whole message is gone
delay(500);
}

THIS IS THE INTERRUPT CODING (2mS)
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.
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

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 *= 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 = rate[i+1]; // and drop the oldest IBI value_
    _ runningTotal += rate*; // 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

   dtostrf(tempo,6,2,msg);

You can not possibly store some digits, a decimal point, 2 digits after the decimal point and a terminating NULL in a 3 element array.

Please edit your post to add code tags ("</>") button. There must be posting or cut/paste errors, because code like this can’t possibly work properly (rate is an array):

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

Did you write any of this or just copy it from the internet?

VirtualWire requires that the interrupts be enabled in order to work properly. You are doing WAY TOO MUCH in the Timer2 interrupt.

ISR(TIMER2_COMPA_vect){                         // triggered when Timer2 counts to 124
    cli();                                      // disable interrupts while we do this

Interrupts are already disabled in an interrupt service routine.

If you start off your programming adventures by copy/pasting junk, you can expect some problems.

jremington:
If you start off your programming adventures by copy/pasting junk, you can expect some problems.

You misspelled "lots of"... 8)

i know it was the conflict between virtualwire timer and interrupt,can i do it using multitasking or RTOS?

There is no conflict. The program is poorly written and there are "lots of" errors that could be fixed. Some of the errors were introduced by posting the program improperly.

But if you won't respect the forum rules and post properly, you are unlikely to get much more help.

i know it was the conflict between virtualwire timer and interrupt,can i do it using multitasking or RTOS?

The Arduino doesn't do multi-tasking, since it only has one processor. An RTOS will introduce more problems, consume more resources, and not help. So, no.