PrimeIRRecv.cpp

#include "PrimeIR.h"
#include "PrimeIRInt.h"

#ifdef IR_TIMER_USE_ESP32
hw_timer_t *timer;
void IRTimer(); // defined in IRremote.cpp
#endif

#define DURATION 600
static int intervals[] = {3, 5, 7, 11, 13, 17, 19, 23};
static int vals[DURATION / 8];

int popcnt8(uint8_t x) {

    x = (x & 0x55) + (x >> 1 & 0x55);
    x = (x & 0x33) + (x >> 2 & 0x33);
    x = (x & 0x0f) + (x >> 4 & 0x0f);

    return x;
}

//+=============================================================================
// Decodes the received IR message
// Returns 0 if no data ready, 1 if data ready.
// Results of decoding are stored in results
//
int  PrimeIRRecv::decode (decode_results *results)
{
	results->rawbuf   = primeirparams.rawbuf;
	results->rawlen   = primeirparams.rawlen;

	results->overflow = primeirparams.overflow;

	// if (primeirparams.rcvstate != STATE_STOP)  {
	// 	return false ;
	// }

	int len = sizeof(intervals) / sizeof(intervals[0]);
	int res = 0;

	// for (int i = 0; i < DURATION; i++) {
	// 	Serial.print(results->rawbuf[i]);
	// 	Serial.print(" ");
	// }
	// Serial.println();

	if (results->rawlen > DURATION) {
		for (int k = 0; k < len; k++) {
			int p = intervals[k];
			for (int offset = 0; offset < p * 4; offset++) {
				int match = 0;
				int idx = offset;
				int total = 0;
				while (idx < DURATION) {
					int i = idx;
					for (;i < idx + 2 * p; i++) {
						total++;
						if (results->rawbuf[i] == MARK) {
							match++;
						}
					}
					// for (;i < idx + 4 * p; i++) {
					// }
					idx += 4 * p;
				}
				// Serial.println();
				float match_ratio = (float) match / (float)total;
				// Serial.println(match_ratio);
				if (match_ratio > 0.9) {
					res |= (1 << k);
					break;
				}
			}
		}
		if (res > 0) {
			return res;
		}
		Serial.println("decode end!!!");
	} else {
		return false;
	}

	// Throw away and start over
	resume();
	return false;
}

//+=============================================================================
PrimeIRRecv::PrimeIRRecv (int recvpin)
{
	primeirparams.recvpin = recvpin;
	primeirparams.blinkflag = 0;
}

PrimeIRRecv::PrimeIRRecv (int recvpin, int blinkpin)
{
	primeirparams.recvpin = recvpin;
	primeirparams.blinkpin = blinkpin;
	pinMode(blinkpin, OUTPUT);
	primeirparams.blinkflag = 0;
}



//+=============================================================================
// initialization
//
void  PrimeIRRecv::enableIRIn ( )
{
// Interrupt Service Routine - Fires every 50uS
#ifdef ESP32
	// ESP32 has a proper API to setup timers, no weird chip macros needed
	// simply call the readable API versions :)
	// 3 timers, choose #1, 80 divider nanosecond precision, 1 to count up
	timer = timerBegin(1, 80, 1);
	timerAttachInterrupt(timer, &IRTimer, 1);
	// every 50ns, autoreload = true
	timerAlarmWrite(timer, 50, true);
	timerAlarmEnable(timer);
#else
	cli();
	// Setup pulse clock timer interrupt
	// Prescale /8 (16M/8 = 0.5 microseconds per tick)
	// Therefore, the timer interval can range from 0.5 to 128 microseconds
	// Depending on the reset value (255 to 0)
	TIMER_CONFIG_NORMAL();

	// Timer2 Overflow Interrupt Enable
	TIMER_ENABLE_INTR;

	TIMER_RESET;

	sei();  // enable interrupts
#endif

	// Initialize state machine variables
	primeirparams.rcvstate = STATE_IDLE;
	primeirparams.rawlen = 0;

	// Set pin modes
	pinMode(primeirparams.recvpin, INPUT);
}

//+=============================================================================
// Enable/disable blinking of pin 13 on IR processing
//
void  PrimeIRRecv::blink13 (int blinkflag)
{
	primeirparams.blinkflag = blinkflag;
	if (blinkflag)  pinMode(BLINKLED, OUTPUT) ;
}

//+=============================================================================
// Return if receiving new IR signals
//
bool  PrimeIRRecv::isIdle ( )
{
 return (primeirparams.rcvstate == STATE_IDLE || primeirparams.rcvstate == STATE_STOP) ? true : false;
}
//+=============================================================================
// Restart the ISR state machine
//
void  PrimeIRRecv::resume ( )
{
	primeirparams.rcvstate = STATE_IDLE;
	primeirparams.rawlen = 0;
}

//+=============================================================================
// hashdecode - decode an arbitrary IR code.
// Instead of decoding using a standard encoding scheme
// (e.g. Sony, NEC, RC5), the code is hashed to a 32-bit value.
//
// The algorithm: look at the sequence of MARK signals, and see if each one
// is shorter (0), the same length (1), or longer (2) than the previous.
// Do the same with the SPACE signals.  Hash the resulting sequence of 0's,
// 1's, and 2's to a 32-bit value.  This will give a unique value for each
// different code (probably), for most code systems.
//
// http://arcfn.com/2010/01/using-arbitrary-remotes-with-arduino.html
//
// Compare two tick values, returning 0 if newval is shorter,
// 1 if newval is equal, and 2 if newval is longer
// Use a tolerance of 20%
//
int  PrimeIRRecv::compare (unsigned int oldval,  unsigned int newval)
{
	if      (newval < oldval * .8)  return 0 ;
	else if (oldval < newval * .8)  return 2 ;
	else                            return 1 ;
}

//+=============================================================================
// Use FNV hash algorithm: http://isthe.com/chongo/tech/comp/fnv/#FNV-param
// Converts the raw code values into a 32-bit hash code.
// Hopefully this code is unique for each button.
// This isn't a "real" decoding, just an arbitrary value.
//
#define FNV_PRIME_32 16777619
#define FNV_BASIS_32 2166136261

long  PrimeIRRecv::decodeHash (decode_results *results)
{
	long  hash = FNV_BASIS_32;

	// Require at least 6 samples to prevent triggering on noise
	if (results->rawlen < 6)  return false ;

	for (int i = 1;  (i + 2) < results->rawlen;  i++) {
		int value =  compare(results->rawbuf[i], results->rawbuf[i+2]);
		// Add value into the hash
		hash = (hash * FNV_PRIME_32) ^ value;
	}

	results->value       = hash;
	results->bits        = 32;
	results->decode_type = UNKNOWN;

	return true;
}