| /* IRrecvPCI.cpp | |
| * Part of IRLib Library for Arduino receiving, decoding, and sending | |
| * infrared signals. See COPYRIGHT.txt and LICENSE.txt for more information. | |
| * | |
| * This module implements the IRrecvPCI receiver class which uses pin change interrupts to | |
| * poll the input pin. This class gives more accurate results than the 50us timer based | |
| * IRrecv but it has other limitations. It uses the Arduino "attachInterrupt()" function | |
| * which can conflict with other libraries. Also unless you use an external buffer and | |
| * enable auto resume this receiver occasionally fails to receive the second of 2 quickly | |
| * sent frames. If you do not have sufficient RAM for a second buffer you should consider | |
| * using the other two available receiver classes. | |
| * | |
| * This receiver is based in part on Arduino firmware for use with AnalysIR IR signal analysis | |
| * software for Windows PCs. Many thanks to the people at http://analysir.com for their | |
| * assistance in developing this section of code. | |
| */ | |
| void IRrecvPCI_Handler();//prototype for interrupt handler | |
| /* Note that the constructor is passed the interrupt number rather than the pin number. | |
| * WARNING: These interrupt numbers which are passed to �attachInterrupt()� are not | |
| * necessarily identical to the interrupt numbers in the datasheet of the processor chip | |
| * you are using. Rather it is a numbering system to the �attachInterrupt()� Arduino | |
| * function. For more information on attachInterrupt see | |
| * http://arduino.cc/en/Reference/AttachInterrupt | |
| */ | |
| IRrecvPCI::IRrecvPCI(uint8_t pin) { | |
| init(); | |
| intrNum=digitalPinToInterrupt(pin); | |
| recvGlobal.recvPin=pin; | |
| } | |
| /* Initializes receiving and attaches the pin change interrupt handler. Call this to | |
| * initialize it again to resume receiving after completing the decoding. Previous versions | |
| * of IRLib had a "resume" method that you should use this in either initializing or resuming. | |
| */ | |
| void IRrecvPCI::enableIRIn(void) { | |
| //See comments on IRrecv::enableIRIn in "IRLibRecv.cpp" for explanation of this logic | |
| if(recvGlobal.newDataAvailable) | |
| return; | |
| recvGlobal.decoderWantsData=true;//otherwise he wouldn't have called | |
| if( (recvGlobal.currentState==STATE_FINISHED) || IRLib_didIROut ) { | |
| IRrecvBase::enableIRIn(); | |
| recvGlobal.timer=micros(); | |
| attachInterrupt(intrNum, IRrecvPCI_Handler, CHANGE); | |
| } | |
| }; | |
| /* Even when not sampling inputs and recording pulse timing, the ISR remains active | |
| * continues to interrupt every 50us however it remains in a do-nothing state. If | |
| * the user wants to truly shut down the ISR they can call this method. | |
| */ | |
| void IRrecvPCI::disableIRIn(void) { | |
| detachInterrupt(intrNum); | |
| IRrecvBase::disableIRIn(); | |
| } | |
| /* Returns true if a frame of data is available in the buffer. Most of the | |
| * handling is done by the base method. Because the ISR only is active when the pin | |
| * is changing, it may not recognize the long gap at the end of the frame so we need to | |
| * test to see if we had a long gap. Because the ISR is active, we need to ensure | |
| * that it doesn't change any variables while we are in the middle of accessing them. | |
| * Unfortunately the ATOMIC_BLOCK macro that we used to use is not supported for | |
| * SAMD 21 platforms so we have to use "noInterrupts();" and "interrupts();" | |
| * This is only necessary for multibyte variables. | |
| */ | |
| bool IRrecvPCI::getResults(void) { | |
| if(recvGlobal.newDataAvailable) { | |
| IRrecvBase::getResults(); | |
| return true; | |
| } | |
| //ISR hasn't detected end of frame so if running we will take a peek | |
| if(recvGlobal.currentState==STATE_RUNNING) { | |
| //Only check for timeout if it is a SPACE | |
| if(digitalRead(recvGlobal.recvPin)) {//pin high means SPACE | |
| uint32_t changeTime; //time of the last change | |
| noInterrupts (); //Ensure atomic access of volatile variable | |
| changeTime=recvGlobal.timer; | |
| interrupts(); //restore interrupts | |
| if( (micros()-changeTime) > recvGlobal.frameTimeout) { | |
| IRLib_IRrecvComplete(3); | |
| IRrecvBase::getResults(); | |
| return true; | |
| } | |
| } | |
| } | |
| return false; | |
| }; | |
| /* This is the interrupt handler used by this class. It is called every time the input | |
| * pin changes from high to low or from low to high. The initial state of the state machine | |
| * is STATE_READY_TO_BEGIN. It waits until it sees a MARK before it switches to | |
| * STATE_RUNNING. Each subsequent interrupt it computes the time since the previous | |
| * interrupt. If it notices a SPACE is especially long then it calls IRLib_IRrecvComplete | |
| * which sets the proper flags to say that we had received data and implements | |
| * auto resume if enabled. The state STATE_FINISHED means that interrupts are continuing | |
| * however the receiver isn't ready for more data. | |
| */ | |
| void IRrecvPCI_Handler(){ | |
| uint32_t volatile changeTime=micros(); | |
| uint32_t deltaTime=changeTime-recvGlobal.timer; | |
| switch(recvGlobal.currentState) { | |
| case STATE_FINISHED: return; | |
| case STATE_RUNNING: | |
| IRLib_doBlink(); | |
| if( !(recvGlobal.recvLength & 1) ){ | |
| if (deltaTime>recvGlobal.frameTimeout) { | |
| IRLib_IRrecvComplete(1);//all finished, reset and possibly do auto resume | |
| return;//don't record final space | |
| } | |
| } | |
| break; | |
| case STATE_READY_TO_BEGIN: | |
| if(digitalRead(recvGlobal.recvPin)) {//pin high means SPACE | |
| return;//don't start until we get a MARK | |
| } else { | |
| recvGlobal.currentState=STATE_RUNNING; | |
| } | |
| break; | |
| }; | |
| recvGlobal.recvBuffer[recvGlobal.recvLength]=deltaTime; | |
| recvGlobal.timer=changeTime; | |
| if(++recvGlobal.recvLength>=RECV_BUF_LENGTH) {//buffer overflows so we quit | |
| IRLib_IRrecvComplete(2); | |
| } | |
| } | |