Added IRDecoder

Author: wpi-boaw

src/IRdecoder.cpp

@@ -0,0 +1,105 @@
+#include <IRdecoder.h>
+
+/* Interprets an IR remote with NEC encoding. See IRdecoder.h for more explanation. */
+
+void handleIRsensor(void)
+{
+  decoder.handleIRsensor();
+}
+
+void IRDecoder::init(void)
+{
+  pinMode(irPin, INPUT);
+  attachInterrupt(digitalPinToInterrupt(irPin), ::handleIRsensor, CHANGE);
+}
+
+void IRDecoder::handleIRsensor(void)
+{
+  uint32_t currUS = micros();
+
+  if(!digitalRead(irPin)) // FALLING edge
+  {
+    fallingEdge = currUS; 
+  }
+
+  else // RISING edge
+  {
+    risingEdge = currUS;
+
+    //and process
+    uint32_t delta = risingEdge - fallingEdge; //length of pulse, in us
+    uint32_t codeLength = risingEdge - lastRisingEdge;
+    lastRisingEdge = risingEdge;
+    
+    if(delta > 8500 && delta < 9500) // received a start pulse
+    {
+      index = 0;
+      state = IR_PREAMBLE;
+      return;
+    }
+    
+   /* a pulse is supposed to be 562.5 us, but it varies based on the RC device, plus
+    * the receiver is NOT optimized for IR remotes --
+    * it's actually optimized for sensitivity. So I set the maximum accepted pulse
+    * length to 700us. On the ESP32 (others?), the pulse is sometimes coming in at ~515 us,
+    * so lowering the bottom to 500.
+    */
+
+    else if(delta < 500 || delta > 700) // pulse wasn't right length => error
+    {
+      state = IR_ERROR;
+      return;
+    }
+
+    else if(state == IR_PREAMBLE)
+    {
+      //preamble is 4.5 ms, but we have to add the ~560 us burst to it
+      if(codeLength < 5300 && codeLength > 4800) //preamble
+      {
+        currCode = 0;
+        state = IR_ACTIVE;
+      }
+
+      //repeat code is a 2.25 ms space + 560 us burst
+      else if(codeLength < 3300 && codeLength > 2700) //repeat code
+      {
+        state = IR_REPEAT;
+        if(((currCode ^ (currCode >> 8)) & 0x00ff0000) != 0x00ff0000) {state = IR_ERROR;} //but recheck code!
+        else lastReceiveTime = millis(); //not really used
+      }
+    }
+
+    else if(state == IR_ACTIVE)
+    {
+      //short burst is nominally 1.125 ms
+      if(codeLength < 1300 && codeLength > 900) //short = 0
+      {
+        index++;
+      }
+      
+      //long burst is nominally 2.25 ms
+      else if(codeLength < 2500 && codeLength > 2000) //long = 1
+      {
+        currCode += ((uint32_t)1 << index);
+        index++;
+      }
+      
+      else //error
+      {
+        state = IR_ERROR;
+      }
+
+      if(index == 32) //full set of bits
+      {
+        //first, check for errors (kinda' ugly, but it works)
+        if(((currCode ^ (currCode >> 8)) & 0x00ff0000) != 0x00ff0000) {state = IR_ERROR;}
+
+        else //we're good to go
+        {        
+          state = IR_COMPLETE;
+          lastReceiveTime = millis();
+        }
+      }
+    }
+  }
+}

src/IRdecoder.h

@@ -0,0 +1,89 @@
+#include <Arduino.h>
+
+/*
+ * A class to interpret IR remotes with NEC encoding. NEC encoding sends four bytes:
+ * 
+ * [device ID, ~divice ID, key code, ~key code]
+ * 
+ * Sending the inverse allow for easy error checking (and reduces saturation in the receiver).
+ * 
+ * Codes are send in little endian; this library reverses upon reception, so the first bit received
+ * is in the LSB of currCode. That means that the key code is found in bits [23..16] of currCode
+ * 
+ * https://techdocs.altium.com/display/FPGA/NEC+Infrared+Transmission+Protocol
+ * 
+ * This does not interpret the codes into which key was pressed. That needs to be 
+ * mapped on a remote by remote basis.
+ */
+
+/*
+ * TO DO:
+ * - (MED) Possibly indicate repeat code instead of just "refreshing" the latest code?
+ * - (LOW) Consider a better way to indicate that a valid code has been entered;
+ *   returning -1 is OK if we return a 16-bit number (so 255 is a valid code),
+ *   but there may be a more elegant solution.
+ * - (MED) Add ability to use PCINT library to this generic library. Use a derived class?
+ */
+
+class IRDecoder
+{
+private:
+  enum IR_STATE
+  {
+    IR_READY,    //idle, returns to this state after you request a code
+    IR_PREAMBLE, //received the start burst, waiting for first bit
+    IR_REPEAT,   //received repeat code (part of NEC protocol); last code will be returned
+    IR_ACTIVE,   //have some bits, but not yet complete
+    IR_COMPLETE, //a valid code has been received
+    IR_ERROR
+  }; //an error occurred; won't return a valid code
+
+  uint8_t irPin;
+
+  IR_STATE state = IR_READY; //a simple state machine for managing reception
+
+  volatile uint32_t lastReceiveTime = 0; //not really used -- could be used to sunset codes
+
+  volatile uint32_t currCode = 0; //the most recently received valid code
+  volatile uint8_t index = 0;     //for tracking which bit we're on
+
+  volatile uint32_t fallingEdge = 0;
+  volatile uint32_t risingEdge = 0;
+
+  volatile uint32_t lastRisingEdge = 0; //used for tracking spacing between rising edges, i.e., bit value
+
+public:
+  IRDecoder(uint8_t pin) : irPin(pin) {}
+  void init(void);           //call this in the setup()
+  void handleIRsensor(void); //ISR
+
+  uint32_t getCode(void) //returns the most recent valid code; returns zero if there was an error or nothing new
+  {
+    if (state == IR_COMPLETE || state == IR_REPEAT)
+    {
+      state = IR_READY;
+      return currCode;
+    }
+    else
+      return 0;
+  }
+
+  int16_t getKeyCode(bool acceptRepeat = false) //returns the most recent key code; returns -1 on error (not sure if 0 can be a code or not!!!)
+  {
+    if (state == IR_COMPLETE || (acceptRepeat == true && state == IR_REPEAT))
+    {
+      state = IR_READY;
+      return (currCode >> 16) & 0x0ff; 
+    }
+    //else if(state == IR_ERROR) return currCode; //for debugging, if needed
+    else
+      return -1;
+  }
+};
+
+class IRDecoder32U4 : public IRDecoder
+{
+  IRDecoder32U4(uint8_t pin) : IRDecoder(pin) {}
+};
+
+extern IRDecoder decoder;