//Do the actual blinking off and on
//This is not part of IRrecvBase because it may need to be inside an ISR
//and we cannot pass parameters to them.
void do_Blink(void) {
if (irparams.blinkflag) {
if(irparams.rawlen % 2) {
BLINKLED_ON(); // turn pin 13 LED on
}
else {
BLINKLED_OFF(); // turn pin 13 LED off
}
}
}
int DCF77Transmitter::sendone() {
digitalWrite(DCFOutputPin, Signal_data);
if (flag)
BLINKLED_ON(); // turn pin 13 LED on
delay(OneTime);
digitalWrite(DCFOutputPin, Signal_normal);
if (flag)
BLINKLED_OFF(); // turn pin 13 LED off
delay(BitTime - OneTime);
}
extern "C" void __ISR(_TIMER_2_VECTOR, ipl7) handlesTimer2Ints(void)
#endif
{
TIMER_RESET;
uint8_t irdata = (uint8_t)digitalRead(irparams.recvpin);
irparams.timer++; // One more 50us tick
if (irparams.rawlen >= RAWBUF) {
// Buffer overflow
irparams.rcvstate = STATE_STOP;
}
switch(irparams.rcvstate) {
case STATE_IDLE: // In the middle of a gap
if (irdata == MARK) {
if (irparams.timer < GAP_TICKS) {
// Not big enough to be a gap.
irparams.timer = 0;
}
else {
// gap just ended, record duration and start recording transmission
irparams.rawlen = 0;
irparams.rawbuf[irparams.rawlen++] = irparams.timer;
irparams.timer = 0;
irparams.rcvstate = STATE_MARK;
}
}
break;
case STATE_MARK: // timing MARK
if (irdata == SPACE) { // MARK ended, record time
irparams.rawbuf[irparams.rawlen++] = irparams.timer;
irparams.timer = 0;
irparams.rcvstate = STATE_SPACE;
}
break;
case STATE_SPACE: // timing SPACE
if (irdata == MARK) { // SPACE just ended, record it
irparams.rawbuf[irparams.rawlen++] = irparams.timer;
irparams.timer = 0;
irparams.rcvstate = STATE_MARK;
}
else { // SPACE
if (irparams.timer > GAP_TICKS) {
// big SPACE, indicates gap between codes
// Mark current code as ready for processing
// Switch to STOP
// Don't reset timer; keep counting space width
irparams.rcvstate = STATE_STOP;
}
}
break;
case STATE_STOP: // waiting, measuring gap
if (irdata == MARK) { // reset gap timer
irparams.timer = 0;
}
break;
}
if (irparams.blinkflag) {
if (irdata == MARK) {
BLINKLED_ON(); // turn pin 13 LED on
}
else {
BLINKLED_OFF(); // turn pin 13 LED off
}
}
CLEAR_INTERRUPT();
} // end ISR
void ProcessOne(irparams_t *irparams)
{
// Read if IR Receiver -> SPACE [xmt LED off] or a MARK [xmt LED on]
// digitalRead() is very slow. Optimisation is possible, but makes the code unportable
uint8_t irdata = (uint8_t)digitalRead(irparams->recvpin);
irparams->timer++; // One more 50uS tick
if (irparams->rawlen >= RAWBUF) irparams->rcvstate = STATE_OVERFLOW ; // Buffer overflow
switch(irparams->rcvstate) {
//......................................................................
case STATE_IDLE: // In the middle of a gap
if (irdata == MARK) {
if (irparams->timer < GAP_TICKS) { // Not big enough to be a gap.
irparams->timer = 0;
} else {
// Gap just ended; Record duration; Start recording transmission
irparams->overflow = false;
irparams->rawlen = 0;
irparams->rawbuf[irparams->rawlen++] = irparams->timer;
irparams->timer = 0;
irparams->rcvstate = STATE_MARK;
}
}
break;
//......................................................................
case STATE_MARK: // Timing Mark
if (irdata == SPACE) { // Mark ended; Record time
irparams->rawbuf[irparams->rawlen++] = irparams->timer;
irparams->timer = 0;
irparams->rcvstate = STATE_SPACE;
}
break;
//......................................................................
case STATE_SPACE: // Timing Space
if (irdata == MARK) { // Space just ended; Record time
irparams->rawbuf[irparams->rawlen++] = irparams->timer;
irparams->timer = 0;
irparams->rcvstate = STATE_MARK;
} else if (irparams->timer > GAP_TICKS) { // Space
// A long Space, indicates gap between codes
// Flag the current code as ready for processing
// Switch to STOP
// Don't reset timer; keep counting Space width
irparams->rcvstate = STATE_STOP;
}
break;
//......................................................................
case STATE_STOP: // Waiting; Measuring Gap
if (irdata == MARK) irparams->timer = 0 ; // Reset gap timer
break;
//......................................................................
case STATE_OVERFLOW: // Flag up a read overflow; Stop the State Machine
irparams->overflow = true;
irparams->rcvstate = STATE_STOP;
break;
}
// If requested, flash LED while receiving IR data
if (irparams->blinkflag) {
if (irdata == MARK)
if (irparams->blinkpin) digitalWrite(irparams->blinkpin, HIGH); // Turn user defined pin LED on
else BLINKLED_ON() ; // if no user defined LED pin, turn default LED pin for the hardware on
else if (irparams->blinkpin) digitalWrite(irparams->blinkpin, LOW); // Turn user defined pin LED on
else BLINKLED_OFF() ; // if no user defined LED pin, turn default LED pin for the hardware on
}
}
void IRrecv::RecvIsr(void)
{
TIMER_RESET;
//P2DIR |= BIT0 | BIT1 | BIT2;
// P2OUT ^= BIT2;
uint8_t irdata = (uint8_t)digitalRead(irparams.recvpin);
irparams.timer++; // One more 50us tick
if (irparams.rawlen >= RAWBUF) {
// Buffer overflow
irparams.rcvstate = STATE_STOP;
}
switch(irparams.rcvstate) {
case STATE_IDLE: // In the middle of a gap
//P2OUT |= BIT0;
//P2OUT &= ~BIT1;
//P2OUT &= ~BIT2;
if (irdata == MARK) {
if (irparams.timer < GAP_TICKS) {
// Not big enough to be a gap.
irparams.timer = 0;
}
else {
// gap just ended, record duration and start recording transmission
irparams.rawlen = 0;
irparams.rawbuf[irparams.rawlen++] = irparams.timer;
irparams.timer = 0;
irparams.rcvstate = STATE_MARK;
}
}
break;
case STATE_MARK: // timing MARK
if (irdata == SPACE) { // MARK ended, record time
irparams.rawbuf[irparams.rawlen++] = irparams.timer;
irparams.timer = 0;
irparams.rcvstate = STATE_SPACE;
}
break;
case STATE_SPACE: // timing SPACE
if (irdata == MARK) { // SPACE just ended, record it
irparams.rawbuf[irparams.rawlen++] = irparams.timer;
irparams.timer = 0;
irparams.rcvstate = STATE_MARK;
}
else { // SPACE
if (irparams.timer > GAP_TICKS) {
// big SPACE, indicates gap between codes
// Mark current code as ready for processing
// Switch to STOP
// Don't reset timer; keep counting space width
irparams.rcvstate = STATE_STOP;
}
}
break;
case STATE_STOP: // waiting, measuring gap
if (irdata == MARK) { // reset gap timer
irparams.timer = 0;
}
break;
}
if (irparams.blinkflag) {
if (irdata == MARK) {
BLINKLED_ON(); // turn pin 13 LED on
}
else {
BLINKLED_OFF(); // turn pin 13 LED off
}
}
}
void ProcessOneIRParam(recvparams_t &recvparams){
uint8_t irdata = (uint8_t)digitalRead(recvparams.recvpin);
recvparams.timer++; // One more 50us tick
if (recvparams.rawlen >= RAWBUF) {
// Buffer overflow
recvparams.rcvstate = STATE_STOP;
}
switch(recvparams.rcvstate) {
case STATE_IDLE: // In the middle of a gap
if (irdata == MARK) {
if (recvparams.timer < GAP_TICKS) {
// Not big enough to be a gap.
recvparams.timer = 0;
}
else {
// gap just ended, record duration and start recording transmission
recvparams.rawlen = 0;
recvparams.rawbuf[recvparams.rawlen++] = recvparams.timer;
recvparams.timer = 0;
recvparams.rcvstate = STATE_MARK;
}
}
break;
case STATE_MARK: // timing MARK
if (irdata == SPACE) { // MARK ended, record time
recvparams.rawbuf[recvparams.rawlen++] = recvparams.timer;
recvparams.timer = 0;
recvparams.rcvstate = STATE_SPACE;
}
break;
case STATE_SPACE: // timing SPACE
if (irdata == MARK) { // SPACE just ended, record it
recvparams.rawbuf[recvparams.rawlen++] = recvparams.timer;
recvparams.timer = 0;
recvparams.rcvstate = STATE_MARK;
}
else { // SPACE
if (recvparams.timer > GAP_TICKS) {
// big SPACE, indicates gap between codes
// Mark current code as ready for processing
// Switch to STOP
// Don't reset timer; keep counting space width
recvparams.rcvstate = STATE_STOP;
}
}
break;
case STATE_STOP: // waiting, measuring gap
if (irdata == MARK) { // reset gap timer
recvparams.timer = 0;
}
break;
}
if (recvparams.blinkflag) {
if (irdata == MARK) {
BLINKLED_ON(); // turn pin 13 LED on
}
else {
BLINKLED_OFF(); // turn pin 13 LED off
}
}
}
// TIMER2 interrupt code to collect raw data.
// Widths of alternating SPACE, MARK are recorded in rawbuf.
// Recorded in ticks of 50 microseconds.
// rawlen counts the number of entries recorded so far.
// First entry is the SPACE between transmissions.
// As soon as a SPACE gets long, ready is set, state switches to IDLE, timing of SPACE continues.
// As soon as first MARK arrives, gap width is recorded, ready is cleared, and new logging starts
void handle_interrupt()
{
uint8_t irdata = (uint8_t)digitalRead(irparams.recvpin);
uint32_t now = micros();
uint32_t elapsed;
if (now < irparams.startTime)
elapsed = now+1+(0xFFFFFFFF-irparams.startTime);
else
elapsed = now-irparams.startTime;
elapsed /= USECPERTICK;
if (irparams.rawlen >= RAWBUF) {
// Buffer overflow
irparams.rcvstate = STATE_STOP;
}
switch(irparams.rcvstate) {
case STATE_IDLE: // In the middle of a gap
if (irdata == MARK) {
if (elapsed < GAP_TICKS) {
// Not big enough to be a gap.
irparams.startTime = now;
} else {
// gap just ended, record duration and start recording transmission
irparams.rawlen = 0;
irparams.rawbuf[irparams.rawlen++] = MIN(elapsed, UINT16_MAX);
irparams.startTime = now;
irparams.rcvstate = STATE_MARK;
}
}
break;
case STATE_MARK: // timing MARK
if (irdata == SPACE) { // MARK ended, record time
irparams.rawbuf[irparams.rawlen++] = MIN(elapsed, UINT16_MAX);
irparams.startTime = now;
irparams.rcvstate = STATE_SPACE;
}
break;
case STATE_SPACE: // timing SPACE
if (irdata == MARK) { // SPACE just ended, record it
irparams.rawbuf[irparams.rawlen++] = MIN(elapsed, UINT16_MAX);
irparams.startTime = now;
irparams.rcvstate = STATE_MARK;
}
else { // SPACE
if (elapsed > GAP_TICKS) {
// big SPACE, indicates gap between codes
// Mark current code as ready for processing
// Switch to STOP
// Don't reset timer; keep counting space width
irparams.rcvstate = STATE_STOP;
}
}
break;
case STATE_STOP: // waiting, measuring gap
if (irdata == MARK) { // reset gap timer
irparams.startTime = now;
}
break;
}
if (irparams.blinkflag) {
if (irdata == MARK) {
BLINKLED_ON(); // turn pin 13 LED on
}
else {
BLINKLED_OFF(); // turn pin 13 LED off
}
}
}
