RemoteReceiver.cpp

/* 
 * RemoteSwitch library v2.0.0 made by Randy Simons http://randysimons.nl
 * See RemoteSwitchSender.h for details.
 *
 * License: "Free BSD license". See license.txt
 */

#include "RemoteReceiver.h"


/************
* RemoteReceiver
************/

unsigned short RemoteReceiver::_interrupt;
volatile unsigned short RemoteReceiver::_state;
unsigned short RemoteReceiver::_minRepeats;
RemoteReceiverCallBack RemoteReceiver::_callback;
boolean RemoteReceiver::_inCallback = false;

void RemoteReceiver::init(unsigned short interrupt, unsigned short minRepeats, RemoteReceiverCallBack callback) {
	_interrupt = interrupt;
	_minRepeats = minRepeats;
	_callback = callback;	
	
	enable();
}

void RemoteReceiver::enable() {
	_state = -1;
	attachInterrupt(_interrupt, interruptHandler, CHANGE);
}

void RemoteReceiver::disable() {
	detachInterrupt(_interrupt);
}


void RemoteReceiver::interruptHandler() {
	static unsigned int period;			//Calculated duration of 1 period
	static unsigned short receivedBit;	//Contains "bit" currently receiving
	static unsigned long receivedCode;	//Contains received code
	static unsigned long previousCode;	//Contains previous received code
	static unsigned short repeats = 0;	//The number of times the an identical code is received in a row.
	static unsigned long lastChange=0;	//Timestamp of previous edge
	static unsigned int min1Period, max1Period, min3Period, max3Period;

	unsigned long currentTime=micros();
	unsigned int duration=currentTime-lastChange; //Duration = Time between edges
	lastChange=currentTime;

	if (_state==-1) { //Waiting for sync-signal		
		if (duration>3720) { //==31*120 minimal time between two edges before decoding starts.
			//Sync signal received.. Preparing for decoding			
			period=duration/31;
			receivedCode=previousCode=repeats=0;

			//Allow for large error-margin. ElCheapo-hardware :( 
			min1Period=period*4/10; //Avoid floating point math; saves memory.
			max1Period=period*16/10;
			min3Period=period*23/10;
			max3Period=period*37/10;
		} 
		else {
			return;
		}
	} else if (_state<48) { //Decoding message
		//bit part durations can ONLY be 1 or 3 periods.
		if (duration>=min1Period && duration<=max1Period) {
			bitClear(receivedBit,_state%4); //Note: this sets the bits in reversed order! Correct order would be: 3-(_state%4), but that's overhead we don't want.
		} 
		else if (duration>=min3Period && duration<=max3Period) {
			bitSet(receivedBit,_state%4); //Note: this sets the bits in reversed order!
		} 
		else { //Otherwise the entire sequence is invalid
			_state=-1;
			return;
		}

		if ((_state%4)==3) { //Last bit part?
			//Shift
			receivedCode*=3;
			//Decode bit.
			if (receivedBit==B1010) {  //short long short long == B0101, but bits are set in reversed order, so compare to B1010
				//bit "0" received
				receivedCode+=0; //I hope the optimizer handles this ;)
			} 
			else if (receivedBit==B0101) { //long short long short == B101, but bits are set in reversed order, so compare to B0101
				//bit "1" received
				receivedCode+=1;
			} 
			else if (receivedBit==B0110) { //short long long short. Reversed too, but makes no difference.
				//bit "f" received
				receivedCode+=2;
			} 
			else {
				//Bit was rubbish. Abort.
				_state=-1;
				return;
			}      
		}    
	} else if (_state==48) { //Waiting for sync bit part 1
		//Must be 1 period.
		if (duration<min1Period || duration>max1Period) {
			_state=-1;
			return;
		}
	} else { //Waiting for sync bit part 2 
		//Must be 31 periods.
		if (duration<period*25 || duration>period*36) {
		  _state=-1;
		  return;
		}

		//receivedCode is a valid code!
		
		if (receivedCode!=previousCode) {
			repeats=0;
			previousCode=receivedCode;
		}
		
		repeats++;
		
		if (repeats>=_minRepeats) {
			if (!_inCallback) {
				_inCallback = true;
				(_callback)(receivedCode, period);
				_inCallback = false;
			}
			//Reset after callback.
			_state=-1;
			return;			
		}
		
		//Reset for next round
		receivedCode = 0;
		_state=0; //no need to wait for another sync-bit!    
		return;
	}

	_state++;
	return;
}

boolean RemoteReceiver::isReceiving(int waitMillis) {
	unsigned long startTime=millis();
	
	int waited; //signed int!
	do {
		if (_state!=-1) {
			return true;
		}
		waited = (millis()-startTime);
	} while(waited>=0 && waited <= waitMillis); //Yes, clock wraps every 50 days. And then you'd have to wait for a looooong time.
	
	return false;
}