/*
 * Library containing code for the APIs for IR encoding/decoding.
 *
 * Written by Eric B. Wertz
 * Last modified 2010/04/05
 */

#include "ir.h"

/*
 *        PULSELEN
 *         SPACERS---+-------+---+---+-------+---+      REPEAT
 *                   V       V   V   V       V   V      SPACER  
 * ------+          +-+     +-+ +-+ +-+     +-+ +-+ +-------------+          +-+     +-+ +-+ +-+     +-+ +-+ +------...
 *       |          | |     | | | | | |     | | | | |             |          | |     | | | | | |     | | | | |               
 *       |          | |     | | | | | |     | | | | |             |          | |     | | | | | |     | | | | |               
 *       |          | |     | | | | | |     | | | | |             |          | |     | | | | | |     | | | | |               
 *       +----------+ +-----+ +-+ +-+ +-----+ +-+ +-+             +----------+ +-----+ +-+ +-+ +-----+ +-+ +-+               
 *         PREAMBLE       1     0   0     1     0   0               PREAMBLE      1     0   0     1     0   0                
 *
 */
#define PULSELEN_PREAMBLE      2500  // # of usecs preamble is low
#define PULSELEN_ZERO           700  // # of usecs 0-bit is low
#define PULSELEN_ONE           1300  // # of usecs 1-bit is low
#define PULSELEN_SPACER         500  // # of usecs between 0/1 bits
#define PULSELEN_TIMEOUT       3500  // longer than any pulse should be

#define PULSELEN_PREAMBLE_MIN  (PULSELEN_PREAMBLE-300)
#define PULSELEN_PREAMBLE_MAX  (PULSELEN_PREAMBLE+300)
#define PULSELEN_ZERO_MIN      (PULSELEN_ZERO    -200)
#define PULSELEN_ZERO_MAX      (PULSELEN_ZERO    +200)
#define PULSELEN_ONE_MIN       (PULSELEN_ONE     -200)
#define PULSELEN_ONE_MAX       (PULSELEN_ONE     +200)

#define isPulseAPreamble(t) (((t)>PULSELEN_PREAMBLE_MIN) && ((t)<PULSELEN_PREAMBLE_MAX))
#define isPulseAZero(t)     (((t)>PULSELEN_ZERO_MIN)     && ((t)<PULSELEN_ZERO_MAX))
#define isPulseAOne(t)      (((t)>PULSELEN_ONE_MIN)      && ((t)<PULSELEN_ONE_MAX))

#define BURSTLEN_USECS_REPEAT 25000  // key auto-repeat happens after this many microseconds
#define BURSTLEN_USECS_MAX    70000  // longer than any burst is likely to be (22-bit codes, anyway)

/* These are the (in these cases, 12-bit TV) encodings for each of the digits "0".."9" */ 
static unsigned long codesTVDigits[] = {
  //  3210
  //      76543210
    0b100100010000, // key 0
    0b000000010000, // key 1
    0b100000010000, // key 2
    0b010000010000, // key 3
    0b110000010000, // key 4
    0b001000010000, // key 5
    0b101000010000, // key 6
    0b011000010000, // key 7
    0b111000010000, // key 8
    0b000100010000  // key 9
};
#define NUM_TVDIGITCODES   10
#define CODETVDIGIT_BITLEN 12

#define MAX_PULSES (1+((8*sizeof(unsigned long))))

/*
 * This is where the length of the pulses (in microseconds) are stored if needed
 * later (usually for debugging, or learning about new codes).
 * One extra location is allocated because of the Preamble pulse at the beginning.
 */
static unsigned int  pulseLengths[MAX_PULSES];
static byte          numPulseLengths=0;
static unsigned long pulseData=0;

byte IRReceive(byte           pin,   unsigned long timeoutUsecs,
               unsigned long *pData, byte         *pNumBits)
{
  byte          returnValue=IRRECV_SUCCESS;
  unsigned long t;

  // reset the counters at the beginning of this new pulse
  numPulseLengths = 0;
  pulseData       = 0;

  t = pulseIn(pin, LOW, timeoutUsecs);  // time the length of the next low pulse
  pulseLengths[numPulseLengths++] = t;  // store it away

  if (t == 0) {
    returnValue = IRRECV_TIMEOUT;       // timed-out waiting for the preamble
  }
  else if (!isPulseAPreamble(t)) {
    returnValue = IRRECV_FAILURE;       // the first pulse wasn't a preamble
  }
  else {
    while (1) {
      t = pulseIn(pin, LOW, PULSELEN_TIMEOUT);
      if (t == 0)
        break;  // pulse wait timed-out, either done or dead

      if (numPulseLengths == MAX_PULSES) {
        // too many data bits to fit into an unsigned long!
        returnValue = IRRECV_OVERFLOW;
        break;
      }
      pulseLengths[numPulseLengths++] = t;

      pulseData <<= 1;

      if (isPulseAZero(t))
        pulseData |= 0;
      else if (isPulseAOne(t))
        pulseData |= 1;
      else {
        returnValue = IRRECV_FAILURE;
        break;
      }
    }
  }

  *pData    = pulseData;
  *pNumBits = numPulseLengths;
  return returnValue;
}

/*
 * This is kind of tricky, so first a number of notes/observations:
 * - the first time you wait for a pulse, it should be for the timeout requested.
 *   If nothing happends by then, the request simply times-out -- simple!
 * - after you get the first burst of data and it's good, you just wait for
 *   the next one with a timeout that's basically the same delay that a remote
 *   control would use, and that's BURSTLEN_USECS_REPEAT.
 * - if you ever have IRReceive() return IRRECV_OVERFLOW, you're in some trouble.
 *   If you ever got a good packet before this one, the best that you can hope
 *   for is to go with the data you've already got.  If this was your first try,
 *   then you're pretty screwed because no matter how many times someone tries to
 *   resend you this super-long code, you're never going to be able to deal with it,
 *   so just return an error and give up.
 * - if you ever have IRReceive() return IRRECV_FAILURE, then it may just be that this
 *   transmission that got hosed and you should try to catch a repeated copy if one's
 *   coming.
 * - if you don't receive anything during the timeout period that was specified,
 *   you've simply timed-out -- simple.
 * - if you timeout after the first receipt, it's because you were waiting for a
 *   repeat, and it never came.  No problem, go with whatever data you already got.
 * - if you already have gotten a good packet and another one comes along that's the same,
 *   that's cool, you got a duplicate and you keep trying to catch as many repeats
 *   until they stop.  However, if you get another packet and it's *not* the same as
 *   the one you've already got, you've got a little problem.  We're just going to have
 *   to assume that the first one was the good one, wasn't auto-repeated, and some other
 *   packet came in really quick, so we just drop it (and hope that it'll get resent so
 *   that the next time the application calls IRReceiveDigit() that he'll catch one of
 *   the latter's repeats.
 * - if last lastNumbits is ever ==0, it means we have never gotten a good packet, because
 *   it was initialized to zero and never changed.  Therefore, if it's !=0, it's because
 *   we got somethin' good at least once already.
 */
byte IRReceiveDigit(byte pin, unsigned long timeoutUsecs)
{
  unsigned long tm, lastRawdata;
  byte          i, lastNumbits=0;
  boolean       firstTime=true, done=false;

  tm = timeoutUsecs;
  while (!done) {
    unsigned long rawdata;
    byte          numbits, retval;

    retval = IRReceive(pin, tm, &rawdata, &numbits);
    tm = BURSTLEN_USECS_REPEAT;

    if (retval == IRRECV_OVERFLOW) {
      if (lastNumbits == 0)
           return IRRECV_TVDIGIT_FAILURE; // give up--waiting for repeats of overflows is useless
      else done = true;                   // got some good data before, go with it
    }
    else if (retval == IRRECV_FAILURE) {
      // no change, just hang around and see if the next try works out
    }
    else if (retval == IRRECV_TIMEOUT) {
      if (firstTime)
           return IRRECV_TVDIGIT_TIMEOUT; // we waited for as long as asked, and nada
      else done = true;                   // no auto-repeats were found, so go with what we got
    }
    else {
      // this is the case where were a burst of data got through just fine

      if (lastNumbits == 0) {
        // this is the first time getting a good packet--remember it for future comparisons
        lastRawdata = rawdata;
        lastNumbits = numbits;
      }
      else {
        if ((rawdata == lastRawdata) && (numbits == lastNumbits)) {
          // looks good, a duplicate of the last one, just keep trying to eat-up the repeats
        }
        else {
          // uh, not good -- just drop this data, and go with what we already got
          done = true;
        }
      }
    }

    firstTime = false;
  }

  // search through list of encoded data to see which digit it corresponds to
  for (i=0; i<NUM_TVDIGITCODES; i++) {
    if (codesTVDigits[i] == lastRawdata)
      return i;        // found what I was looking for... done.
  }
  return IRRECV_TVDIGIT_FAILURE; // didn't match any of our digit codes!
}

/*
 * Return all the data having to do with the previous pulse that we received
 */
unsigned int *IRGetLastPulseData(byte *pNumBits, unsigned long *pData)
{
  *pNumBits = numPulseLengths;
  *pData    = pulseData;
  return pulseLengths;
}

/*
 * Use the Serial port to print out the pulse length values from the last receive attempt.
 * This is useful when debugging, or for decoding new pulses.
 */
void printPulseData()
{
  byte i;

  for (i=0; i<numPulseLengths; i++) {
    Serial.print(pulseLengths[i]);
    Serial.print(',');
  }

  Serial.print("0b");
  for (i=numPulseLengths-1; i>0; i--)   // -1 to skip preamble
    Serial.print(((pulseData >> (i-1)) & 0x1) ? '1' : '0');
  Serial.print  ('/');
  Serial.println((int)(numPulseLengths-1));
}

/*
 * A 38kHz frequency yields a 26.3us period.  When you split the cycle in
 * half, each part should be roughly 13.15us -- however, because there's some
 * non-negligible time taken getting in-and-out of the function calls, it turns
 * out that 10 is the right parameter to get us closest to a 26.3us period.
 *
 * NB: This routine does not take into account different Arduino clock speeds
 * when picking the parameter to delayMicroseconds().  Hopefully the change in
 * overhead isn't too significant.
 * NB: This routine does not handle the case where the micros() counter
 * rolls-over (as mentioned in the micros() documentation).
 */
void IRSendPulse(byte pin, unsigned int usecs)
{
  unsigned int i, numPulses=(usecs/26);// 38kHz has 26.3usec period

  for (i=0; i<numPulses; i++) {
    digitalWrite(pin, HIGH);
    delayMicroseconds(10);
    digitalWrite(pin, LOW);
    delayMicroseconds(10);
  }
}

void IRSend(byte pin, unsigned long data, byte numBits)
{
  byte i;

  IRSendPulse(pin, PULSELEN_PREAMBLE);
  delayMicroseconds(PULSELEN_SPACER);

  for (i=numBits; i>0; i--)  {
    byte theBit = bitRead(data, i-1);
    IRSendPulse(pin, (theBit == 1) ? PULSELEN_ONE : PULSELEN_ZERO);
    if (i > 1)
      delayMicroseconds(PULSELEN_SPACER); // no extra delay after last pulse
  }
}

void IRSendDigit(byte pin, byte digit)
{
  IRSend(pin, codesTVDigits[digit], CODETVDIGIT_BITLEN);
  delayMicroseconds(BURSTLEN_USECS_REPEAT);
  IRSend(pin, codesTVDigits[digit], CODETVDIGIT_BITLEN);
  delayMicroseconds(BURSTLEN_USECS_REPEAT);
  IRSend(pin, codesTVDigits[digit], CODETVDIGIT_BITLEN);
}