bool IRrecv::decodeLightStrike(decode_results *results) {
long data = 0; // We decode in to here; Start with nothing
int offset = 1; // Index in to results; Skip first entry!?
// Check header "mark"
if (!MATCH_MARK(results->rawbuf[offset], LS_HDR_MARK)) return false;
// Check we have enough data
if (irparams.rawlen < (2 * LS_BITS) + 2)
return false;
// Build the data
for (int i = 0; i < LS_BITS; i++) {
// Determine if the bit is a 1 or 0
offset++;
if (MATCH_SPACE(results->rawbuf[offset], LS_ONE_SPACE))
data = (data << 1) | 1;
else if (MATCH_SPACE(results->rawbuf[offset], LS_ZERO_SPACE))
data = (data << 1) | 0;
else
return false;
// Check data "mark"
offset++;
if (!MATCH_MARK(results->rawbuf[offset], LS_BIT_MARK))
return false;
}
// Success
results->bits = LS_BITS;
results->value = data;
results->decode_type = LIGHTSTRIKE;
return true;
}
bool IRrecv::decodeTagShot (decode_results *results)
{
unsigned long data = 0; // Somewhere to build our code
int offset = 1; // Skip the Gap reading
// Check we have the right amount of data
if (irparams.rawlen != 1 + 2 + (2 * BITS) + 1) return false ;
// Check initial Mark+Space match
if (!MATCH_MARK (results->rawbuf[offset++], HDR_MARK )) return false ;
if (!MATCH_SPACE(results->rawbuf[offset++], HDR_SPACE)) return false ;
// Read the bits in
for (int i = 0; i < BITS; i++) {
// Each bit looks like: MARK + SPACE_1 -> 1
// or : MARK + SPACE_0 -> 0
if (!MATCH_MARK(results->rawbuf[offset++], BIT_MARK)) return false ;
// IR data is big-endian, so we shuffle it in from the right:
if (MATCH_SPACE(results->rawbuf[offset], ONE_SPACE)) data = (data << 1) | 1 ;
else if (MATCH_SPACE(results->rawbuf[offset], ZERO_SPACE)) data = (data << 1) | 0 ;
else return false ;
offset++;
}
// Success
results->bits = BITS;
results->value = data;
results->decode_type = TAGSHOT;
return true;
}
bool IRrecv::decodeLG (decode_results *results)
{
long data = 0;
int offset = 1; // Skip first space
// Check we have the right amount of data
if (irparams.rawlen < (2 * LG_BITS) + 1 ) return false ;
// Initial mark/space
if (!MATCH_MARK(results->rawbuf[offset++], LG_HDR_MARK)) return false ;
if (!MATCH_SPACE(results->rawbuf[offset++], LG_HDR_SPACE)) return false ;
for (int i = 0; i < LG_BITS; i++) {
if (!MATCH_MARK(results->rawbuf[offset++], LG_BIT_MARK)) return false ;
if (MATCH_SPACE(results->rawbuf[offset], LG_ONE_SPACE)) data = (data << 1) | 1 ;
else if (MATCH_SPACE(results->rawbuf[offset], LG_ZERO_SPACE)) data = (data << 1) | 0 ;
else return false ;
offset++;
}
// Stop bit
if (!MATCH_MARK(results->rawbuf[offset], LG_BIT_MARK)) return false ;
// Success
results->bits = LG_BITS;
results->value = data;
results->decode_type = LG;
return true;
}
bool IRrecv::decodePanasonic ()
{
unsigned long long data = 0;
int offset = 1;
if (!MATCH_MARK(irparams.rawbuf[offset++], PANASONIC_HDR_MARK )) return false ;
if (!MATCH_MARK(irparams.rawbuf[offset++], PANASONIC_HDR_SPACE)) return false ;
// decode address
for (int i = 0; i < PANASONIC_BITS; i++) {
if (!MATCH_MARK(irparams.rawbuf[offset++], PANASONIC_BIT_MARK)) return false ;
if (MATCH_SPACE(irparams.rawbuf[offset],PANASONIC_ONE_SPACE )) data = (data << 1) | 1 ;
else if (MATCH_SPACE(irparams.rawbuf[offset],PANASONIC_ZERO_SPACE)) data = (data << 1) | 0 ;
else return false ;
offset++;
}
results.value = (unsigned long)data;
results.address = (unsigned int)(data >> 32);
results.decode_type = PANASONIC;
results.bits = PANASONIC_BITS;
return true;
}
long IRrecvSF::decodePanasonic(decode_resultsSF *results) {
unsigned long long data = 0;
int offset = 1;
if (!MATCH_MARK(results->rawbuf[offset], PANASONIC_HDR_MARK)) {
return ERR;
}
offset++;
if (!MATCH_MARK(results->rawbuf[offset], PANASONIC_HDR_SPACE)) {
return ERR;
}
offset++;
// decode address
for (int i = 0; i < PANASONIC_BITS; i++) {
if (!MATCH_MARK(results->rawbuf[offset++], PANASONIC_BIT_MARK)) {
return ERR;
}
if (MATCH_SPACE(results->rawbuf[offset],PANASONIC_ONE_SPACE)) {
data = (data << 1) | 1;
} else if (MATCH_SPACE(results->rawbuf[offset],PANASONIC_ZERO_SPACE)) {
data <<= 1;
} else {
return ERR;
}
offset++;
}
results->value = (unsigned long)data;
results->panasonicAddress = (unsigned int)(data >> 32);
results->decode_type = PANASONIC;
results->bits = PANASONIC_BITS;
return DECODED;
}
bool IRRemote::decodeSAMSUNG(int rawlen)
{
long data = 0;
int offset = 1; // Skip first space
// Initial mark
if (!MATCH_MARK(_rawbuf[offset], SAMSUNG_HDR_MARK))
{
return false;
}
offset++;
// Check for repeat
if (rawlen == 4 && MATCH_SPACE(_rawbuf[offset], SAMSUNG_RPT_SPACE)
&& MATCH_MARK(_rawbuf[offset + 1], SAMSUNG_BIT_MARK))
{
_bits = 0;
_value = REPEAT;
_decode_type = SAMSUNG;
//TODO see what happens if return false on repeat
//return true;
return false;
}
else if (rawlen < 2 * SAMSUNG_BITS + 4)
{
return false;
}
// Initial space
if (!MATCH_SPACE(_rawbuf[offset], SAMSUNG_HDR_SPACE))
{
return false;
}
offset++;
for (int i = 0; i < SAMSUNG_BITS; i++)
{
if (!MATCH_MARK(_rawbuf[offset], SAMSUNG_BIT_MARK))
{
return false;
}
offset++;
if (MATCH_SPACE(_rawbuf[offset], SAMSUNG_ONE_SPACE))
{
data = (data << 1) | 1;
}
else if (MATCH_SPACE(_rawbuf[offset], SAMSUNG_ZERO_SPACE))
{
data <<= 1;
}
else
{
return false;
}
offset++;
}
// Success
_bits = SAMSUNG_BITS;
_value = data;
_decode_type = SAMSUNG;
return true;
}
long IRrecv::decodeWhynter(decode_results *results) {
long data = 0;
if (irparams.rawlen < 2 * WHYNTER_BITS + 6) {
return ERR;
}
int offset = 1; // Skip first space
// sequence begins with a bit mark and a zero space
if (!MATCH_MARK(results->rawbuf[offset], WHYNTER_BIT_MARK)) {
return ERR;
}
offset++;
if (!MATCH_SPACE(results->rawbuf[offset], WHYNTER_ZERO_SPACE)) {
return ERR;
}
offset++;
// header mark and space
if (!MATCH_MARK(results->rawbuf[offset], WHYNTER_HDR_MARK)) {
return ERR;
}
offset++;
if (!MATCH_SPACE(results->rawbuf[offset], WHYNTER_HDR_SPACE)) {
return ERR;
}
offset++;
// data bits
for (int i = 0; i < WHYNTER_BITS; i++) {
if (!MATCH_MARK(results->rawbuf[offset], WHYNTER_BIT_MARK)) {
return ERR;
}
offset++;
if (MATCH_SPACE(results->rawbuf[offset], WHYNTER_ONE_SPACE)) {
data = (data << 1) | 1;
}
else if (MATCH_SPACE(results->rawbuf[offset],WHYNTER_ZERO_SPACE)) {
data <<= 1;
}
else {
return ERR;
}
offset++;
}
// trailing mark
if (!MATCH_MARK(results->rawbuf[offset], WHYNTER_BIT_MARK)) {
return ERR;
}
// Success
results->bits = WHYNTER_BITS;
results->value = data;
results->decode_type = WHYNTER;
return DECODED;
}
bool IRrecv::decodeMitsubishi (decode_results *results)
{
// Serial.print("?!? decoding Mitsubishi:");Serial.print(irparams.rawlen); Serial.print(" want "); Serial.println( 2 * MITSUBISHI_BITS + 2);
long data = 0;
if (irparams.rawlen < 2 * MITSUBISHI_BITS + 2) return false ;
int offset = 0; // Skip first space
// Initial space
#if 0
// Put this back in for debugging - note can't use #DEBUG as if Debug on we don't see the repeat cos of the delay
Serial.print("IR Gap: ");
Serial.println( results->rawbuf[offset]);
Serial.println( "test against:");
Serial.println(results->rawbuf[offset]);
#endif
#if 0
// Not seeing double keys from Mitsubishi
if (results->rawbuf[offset] < MITSUBISHI_DOUBLE_SPACE_USECS) {
// Serial.print("IR Gap found: ");
results->bits = 0;
results->value = REPEAT;
results->decode_type = MITSUBISHI;
return true;
}
#endif
offset++;
// Typical
// 14200 7 41 7 42 7 42 7 17 7 17 7 18 7 41 7 18 7 17 7 17 7 18 7 41 8 17 7 17 7 18 7 17 7
// Initial Space
if (!MATCH_MARK(results->rawbuf[offset], MITSUBISHI_HDR_SPACE)) return false ;
offset++;
while (offset + 1 < irparams.rawlen) {
if (MATCH_MARK(results->rawbuf[offset], MITSUBISHI_ONE_MARK)) data = (data << 1) | 1 ;
else if (MATCH_MARK(results->rawbuf[offset], MITSUBISHI_ZERO_MARK)) data <<= 1 ;
else return false ;
offset++;
if (!MATCH_SPACE(results->rawbuf[offset], MITSUBISHI_HDR_SPACE)) break ;
offset++;
}
// Success
results->bits = (offset - 1) / 2;
if (results->bits < MITSUBISHI_BITS) {
results->bits = 0;
return false;
}
results->value = data;
results->decode_type = MITSUBISHI;
return true;
}
bool IRRemote::decodeNEC(int rawlen)
{
long data = 0;
int offset = 1; // Skip first space
// Initial mark
if (!MATCH_MARK(_rawbuf[offset], NEC_HDR_MARK))
{
return false;
}
offset++;
// Check for repeat
if (rawlen == 4 && MATCH_SPACE(_rawbuf[offset], NEC_RPT_SPACE)
&& MATCH_MARK(_rawbuf[offset + 1], NEC_BIT_MARK))
{
_bits = 0;
_value = REPEAT;
_decode_type = NEC;
return true;
}
else if (rawlen < 2 * NEC_BITS + 4)
{
return false;
}
// Initial space
if (!MATCH_SPACE(_rawbuf[offset], NEC_HDR_SPACE))
{
return false;
}
offset++;
for (int i = 0; i < NEC_BITS; i++)
{
if (!MATCH_MARK(_rawbuf[offset], NEC_BIT_MARK))
{
return false;
}
offset++;
if (MATCH_SPACE(_rawbuf[offset], NEC_ONE_SPACE))
{
data = (data << 1) | 1;
}
else if (MATCH_SPACE(_rawbuf[offset], NEC_ZERO_SPACE))
{
data <<= 1;
}
else
{
return false;
}
offset++;
}
// Success
_bits = NEC_BITS;
_value = data;
_decode_type = NEC;
return true;
}
long IRrecv::decodeSony(decode_results *results) {
long data = 0;
if (irparams.rawlen < 2 * SONY_BITS + 2) {
return ERR;
}
int offset = 0; // Dont skip first space, check its size
// Some Sony's deliver repeats fast after first
// unfortunately can't spot difference from of repeat from two fast clicks
if (results->rawbuf[offset] < SONY_DOUBLE_SPACE_USECS) {
// Serial.print("IR Gap found: ");
results->bits = 0;
results->value = REPEAT;
#ifdef SANYO
results->decode_type = SANYO;
#else
results->decode_type = UNKNOWN;
#endif
return DECODED;
}
offset++;
// Initial mark
if (!MATCH_MARK(results->rawbuf[offset], SONY_HDR_MARK)) {
return ERR;
}
offset++;
while (offset + 1 < irparams.rawlen) {
if (!MATCH_SPACE(results->rawbuf[offset], SONY_HDR_SPACE)) {
break;
}
offset++;
if (MATCH_MARK(results->rawbuf[offset], SONY_ONE_MARK)) {
data = (data << 1) | 1;
}
else if (MATCH_MARK(results->rawbuf[offset], SONY_ZERO_MARK)) {
data <<= 1;
}
else {
return ERR;
}
offset++;
}
// Success
results->bits = (offset - 1) / 2;
if (results->bits < 12) {
results->bits = 0;
return ERR;
}
results->value = data;
results->decode_type = SONY;
return DECODED;
}
static long decodeJVC(decode_results *results) {
long data = 0;
int offset = 1; // Skip first space
int i = 0;
// Check for repeat
if (irparams.rawlen - 1 == 33 &&
MATCH_MARK(results->rawbuf[offset], JVC_BIT_MARK) &&
MATCH_MARK(results->rawbuf[irparams.rawlen-1], JVC_BIT_MARK)) {
results->bits = 0;
results->value = REPEAT;
results->decode_type = JVC;
return DECODED;
}
// Initial mark
if (!MATCH_MARK(results->rawbuf[offset], JVC_HDR_MARK)) {
return ERR;
}
offset++;
if (irparams.rawlen < 2 * JVC_BITS + 1 ) {
return ERR;
}
// Initial space
if (!MATCH_SPACE(results->rawbuf[offset], JVC_HDR_SPACE)) {
return ERR;
}
offset++;
for (i = 0; i < JVC_BITS; i++) {
if (!MATCH_MARK(results->rawbuf[offset], JVC_BIT_MARK)) {
return ERR;
}
offset++;
if (MATCH_SPACE(results->rawbuf[offset], JVC_ONE_SPACE)) {
data = (data << 1) | 1;
}
else if (MATCH_SPACE(results->rawbuf[offset], JVC_ZERO_SPACE)) {
data <<= 1;
}
else {
return ERR;
}
offset++;
}
// Stop bit
if (!MATCH_MARK(results->rawbuf[offset], JVC_BIT_MARK)){
return ERR;
}
// Success
results->bits = JVC_BITS;
results->value = data;
results->decode_type = JVC;
return DECODED;
}
long IRrecv::decodeSAMSUNG(decode_results *results) {
long data = 0;
int offset = 1; // Skip first space
float kShrink = .9;// GRR - "shrink" recieved sequence
decValue.value = 0;
// Initial mark
if (!MATCH_MARK(results->rawbuf[offset]*kShrink, SAMSUNG_HDR_MARK)) {
decValue.value = 0;//2 //GRR for debugging
return ERR;
}
offset++;
// Check bits
if (irparams.rawlen < 2 * SAMSUNG_BITS + 4) {
decValue.value = 0;//3 //GRR for debugging
return ERR;
}
// Initial space
if (!MATCH_SPACE(results->rawbuf[offset]*kShrink, SAMSUNG_HDR_SPACE)) {
decValue.value = 0;//4 //GRR for debugging
return ERR;
}
offset++;
//Serial.println("OFFSET");
//Serial.println(offset);
for (int i = 0; i < SAMSUNG_BITS; i++) {
if (!MATCH_MARK(results->rawbuf[offset]*kShrink, SAMSUNG_BIT_MARK)) {
decValue.value = 0;//5 //GRR for debugging
return ERR;
}
offset++;
if (MATCH_SPACE(results->rawbuf[offset]*kShrink, SAMSUNG_ONE_SPACE)) {
data = (data << 1) | 1;
}
else if (MATCH_SPACE(results->rawbuf[offset]*kShrink, SAMSUNG_ZERO_SPACE)) {
data <<= 1;
}
else {
decValue.value = 0;//6 //GRR for debugging
return ERR;
}
offset++;
}
// Success
decValue.value = data;
results->bits = SAMSUNG_BITS;
results->value = data;
results->decode_type = SAMSUNG;
return DECODED;
}
long IRrecv::decodeAiwaRCT501(decode_results *results) {
int data = 0;
int offset = 1; // skip first garbage read
// Check SIZE
if(irparams.rawlen < 2 * (AIWA_RC_T501_SUM_BITS) + 4) {
return ERR;
}
// Check HDR
if(!MATCH_MARK(results->rawbuf[offset], AIWA_RC_T501_HDR_MARK)) {
return ERR;
}
offset++;
// Check HDR space
if(!MATCH_SPACE(results->rawbuf[offset], AIWA_RC_T501_HDR_SPACE)) {
return ERR;
}
offset++;
offset += 26; // skip pre-data - optional
while(offset < irparams.rawlen - 4) {
if(MATCH_MARK(results->rawbuf[offset], AIWA_RC_T501_BIT_MARK)) {
offset++;
}
else {
return ERR;
}
// ONE & ZERO
if(MATCH_SPACE(results->rawbuf[offset], AIWA_RC_T501_ONE_SPACE)) {
data = (data << 1) | 1;
}
else if(MATCH_SPACE(results->rawbuf[offset], AIWA_RC_T501_ZERO_SPACE)) {
data <<= 1;
}
else {
// End of one & zero detected
break;
}
offset++;
}
results->bits = (offset - 1) / 2;
if(results->bits < 42) {
return ERR;
}
results->value = data;
results->decode_type = AIWA_RC_T501;
return DECODED;
}
long IRrecv::decodeRCMM(decode_results *results) {
long data = 0;
if (irparams.rawlen < RCMM_BITS + 4) {
return ERR;
}
int offset = 1; // Skip first space
// Initial mark
if (!MATCH_MARK(results->rawbuf[offset], RCMM_HDR_MARK)) {
return ERR;
}
offset++;
if (!MATCH_SPACE(results->rawbuf[offset], RCMM_SPACE)) {
return ERR;
}
offset++;
while (offset + 1 < irparams.rawlen) {
if (!MATCH_MARK(results->rawbuf[offset], RCMM_MARK)) {
return ERR;
}
offset++;
if (MATCH_SPACE(results->rawbuf[offset], RCMM_SPACE)) {
data = (data << 2) | 0;
}
else if (MATCH_SPACE(results->rawbuf[offset], RCMM_SPACE+RCMM_INCREMENT)) {
data = (data << 2) | 1;
}
else if (MATCH_SPACE(results->rawbuf[offset], RCMM_SPACE+2*RCMM_INCREMENT)) {
data = (data << 2) | 2;
}
else if (MATCH_SPACE(results->rawbuf[offset], RCMM_SPACE+3*RCMM_INCREMENT)) {
data = (data << 2) | 3;
}
else {
return ERR;
}
offset++;
}
if (!MATCH_MARK(results->rawbuf[offset], RCMM_MARK)) {
return ERR;
}
// Success
results->bits = (offset - 3);
if (results->bits < RCMM_BITS) {
results->bits = 0;
return ERR;
}
results->value = data;
results->decode_type = RCMM;
return DECODED;
}
//Samsung TV codes imported from http://www.maartendamen.com/2010/05/jeenode-infrared-project-part-1-getting-started/
long IRrecv::decodeSamsung(decode_results *results) {
long data = 0;
int offset = 1; // Skip first space
// Check bits
if (irparams.rawlen < 2 * SAMSUNG_BITS + 4 && irparams.rawlen != 6) {
return ERR;
}
// Initial mark
if (!MATCH_MARK(results->rawbuf[offset], SAMSUNG_HDR_MARK)) {
return ERR;
}
offset++;
// Initial space
if (!MATCH_SPACE(results->rawbuf[offset], SAMSUNG_HDR_SPACE)) {
return ERR;
}
offset++;
//Serial.println("OFFSET");
//Serial.println(offset);
for (int i = 0; i < SAMSUNG_BITS; i++) {
if (!MATCH_MARK(results->rawbuf[offset], SAMSUNG_BIT_MARK)) {
return ERR;
}
offset++;
if (offset == irparams.rawlen)
{
results->bits = SAMSUNG_BITS;
results->value = REPEAT;
results->decode_type = SAMSUNG;
return DECODED;
}
if (MATCH_SPACE(results->rawbuf[offset], SAMSUNG_ONE_SPACE)) {
data = (data << 1) | 1;
}
else if (MATCH_SPACE(results->rawbuf[offset], SAMSUNG_ZERO_SPACE)) {
data <<= 1;
}
else {
return ERR;
}
offset++;
}
// Success
results->bits = SAMSUNG_BITS;
results->value = data;
results->decode_type = SAMSUNG;
return DECODED;
}
// NECs have a repeat only 4 items long
u32 IRrecv_decodeNEC(decode_results *results)
{
u32 data = 0;
u16 offset = 1; // Skip first space
u16 i;
// Initial mark
if (!MATCH_MARK(results->rawbuf[offset], NEC_HDR_MARK)) {
return ERR;
}
offset++;
// Check for repeat
if (irparams.rawlen == 4 &&
MATCH_SPACE(results->rawbuf[offset], NEC_RPT_SPACE) &&
MATCH_MARK(results->rawbuf[offset+1], NEC_BIT_MARK)) {
results->bits = 0;
results->value = REPEAT;
results->decode_type = NEC;
return DECODED;
}
if (irparams.rawlen < 2 * NEC_BITS + 4) {
return ERR;
}
// Initial space
if (!MATCH_SPACE(results->rawbuf[offset], NEC_HDR_SPACE)) {
return ERR;
}
offset++;
for (i = 0; i < NEC_BITS; i++) {
if (!MATCH_MARK(results->rawbuf[offset], NEC_BIT_MARK)) {
return ERR;
}
offset++;
if (MATCH_SPACE(results->rawbuf[offset], NEC_ONE_SPACE)) {
data = (data << 1) | 1;
}
else if (MATCH_SPACE(results->rawbuf[offset], NEC_ZERO_SPACE)) {
data <<= 1;
}
else {
return ERR;
}
offset++;
}
// Success
results->bits = NEC_BITS;
results->value = data;
results->decode_type = NEC;
return DECODED;
}
long IRrecv::decodeSony(decode_results *results) {
unsigned long data = 0;
if (irparams.rawlen < 2 * SONY_BITS + 2) {
return ERR;
}
int offset = 1; // Skip first space
// Initial mark
if (!MATCH_MARK(results->rawbuf[offset], SONY_HDR_MARK)) {
return ERR;
}
offset++;
while (offset + 1 < irparams.rawlen) {
if (!MATCH_SPACE(results->rawbuf[offset], SONY_HDR_SPACE)) {
break;
}
offset++;
if (MATCH_MARK(results->rawbuf[offset], SONY_ONE_MARK)) {
data = (data << 1) | 1;
}
else if (MATCH_MARK(results->rawbuf[offset], SONY_ZERO_MARK)) {
data <<= 1;
}
else {
return ERR;
}
offset++;
}
// Success
results->bits = (offset - 1) / 2;
if (results->bits < 12) {
results->bits = 0;
return ERR;
}
results->value = data;
results->decode_type = SONY;
/*
for ( debugPos = 0; debugPos < 32; debugPos ++ ) {
if ( (results->value >> (32 - debugPos) ) & 0x1 == 0x1 ) {
results->debugBuffer[debugPos] = 0xff;
}
else {
results->debugBuffer[debugPos] = 0x1;
}
}
*/
return DECODED;
}
long IRrecv::decodePanasonic(decode_results *results) {
unsigned long data = 0;
int offset = 1;
if (!MATCH_MARK(results->rawbuf[offset], PANASONIC_HDR_MARK)) {
return ERR;
}
offset++;
if (!MATCH_MARK(results->rawbuf[offset], PANASONIC_HDR_SPACE)) {
return ERR;
}
offset++;
// decode address
for (int i = 0; i < 32; i++) {
if (!MATCH_MARK(results->rawbuf[offset++], PANASONIC_BIT_MARK)) {
return ERR;
}
if (MATCH_SPACE(results->rawbuf[offset],PANASONIC_ONE_SPACE)) {
data = (data << 1) | 1;
} else if (MATCH_SPACE(results->rawbuf[offset],PANASONIC_ZERO_SPACE)) {
data <<= 1;
} else {
return ERR;
}
offset++;
}
results->address = data;
data = 0;
for (int i = 0; i < 16; i++) {
if (!MATCH_MARK(results->rawbuf[offset++], PANASONIC_BIT_MARK)) {
return ERR;
}
if (MATCH_SPACE(results->rawbuf[offset],PANASONIC_ONE_SPACE)) {
data = (data << 1) | 1;
} else if (MATCH_SPACE(results->rawbuf[offset],PANASONIC_ZERO_SPACE)) {
data <<= 1;
} else {
return ERR;
}
offset++;
}
results->value = data;
results->decode_type = PANASONIC;
results->bits = 48;
return DECODED;
}
long IRrecv::decodeLS(decode_results *results) {
long data = 0;
/*if (irparams.rawlen < 2 * SONY_BITS + 2) {
return ERR;
}*/
int offset = 1; // Skip first space
// Initial mark
if (!MATCH_MARK(results->rawbuf[offset], LS_HDR_MARK)) {
return ERR;
}
offset++;
// Initial space
if (!MATCH_SPACE(results->rawbuf[offset], LS_HDR_SPACE)) {
return ERR;
}
offset++;
for (int i = 0; i < 31; i++) {
if (!MATCH_MARK(results->rawbuf[offset], LS_BIT_MARK)) {
Serial.println("Err");
return ERR;
}
offset++;
if (MATCH_SPACE(results->rawbuf[offset], LS_ONE_SPACE)) {
data = (data << 1) | 1;
}
else if (MATCH_SPACE(results->rawbuf[offset], LS_ZERO_SPACE)) {
data <<= 1;
}
else {
Serial.print("Err: ");
Serial.println(i);
return ERR;
}
offset++;
}
// Success
results->bits = (offset - 1) / 2;
/*if (results->bits < 12) {
results->bits = 0;
return ERR;
}*/
results->value = data;
results->decode_type = LS;
return DECODED;
}
// SAMSUNGs have a repeat only 4 items long
long IRrecv::decodeSAMSUNG(decode_results *results) {
long data = 0;
int offset = 1; // Skip first space
// Initial mark
if (!MATCH_MARK(results->rawbuf[offset], SAMSUNG_HDR_MARK)) {
return ERR;
}
offset++;
// Check for repeat
if (irparams.rawlen == 4 &&
MATCH_SPACE(results->rawbuf[offset], SAMSUNG_RPT_SPACE) &&
MATCH_MARK(results->rawbuf[offset+1], SAMSUNG_BIT_MARK)) {
results->bits = 0;
results->value = REPEAT;
results->decode_type = SAMSUNG;
return DECODED;
}
if (irparams.rawlen < 2 * SAMSUNG_BITS + 4) {
return ERR;
}
// Initial space
if (!MATCH_SPACE(results->rawbuf[offset], SAMSUNG_HDR_SPACE)) {
return ERR;
}
offset++;
for (int i = 0; i < SAMSUNG_BITS; i++) {
if (!MATCH_MARK(results->rawbuf[offset], SAMSUNG_BIT_MARK)) {
return ERR;
}
offset++;
if (MATCH_SPACE(results->rawbuf[offset], SAMSUNG_ONE_SPACE)) {
data = (data << 1) | 1;
}
else if (MATCH_SPACE(results->rawbuf[offset], SAMSUNG_ZERO_SPACE)) {
data <<= 1;
}
else {
return ERR;
}
offset++;
}
// Success
results->bits = SAMSUNG_BITS;
results->value = data;
results->decode_type = SAMSUNG;
return DECODED;
}
long IRrecv::decodeSamsung2(decode_results *results) {
unsigned long long data = 0;
int offset = 1;
if (irparams.rawlen < 78)
{
return ERR;
}
if (!MATCH_MARK(results->rawbuf[offset], SAMSUNG2_HDR_MARK)) {
return ERR;
}
offset++;
if (!MATCH_MARK(results->rawbuf[offset], SAMSUNG2_HDR_SPACE)) {
return ERR;
}
offset++;
// decode address
for (int i = 0; i < SAMSUNG2_BITS; i++) {
if (!MATCH_MARK(results->rawbuf[offset++], SAMSUNG2_BIT_MARK)) {
return ERR;
}
if (offset == 36)
{
if (!MATCH_SPACE(results->rawbuf[offset],SAMSUNG2_HDR_SPACE)) {
return ERR;
}
}
else
{
if (MATCH_SPACE(results->rawbuf[offset],SAMSUNG2_ONE_SPACE)) {
data = (data << 1) | 1;
} else if (MATCH_SPACE(results->rawbuf[offset],SAMSUNG2_ZERO_SPACE)) {
data <<= 1;
} else {
return ERR;
}
}
offset++;
}
results->value = (unsigned long)data << 12 ;
results->panasonicAddress = (unsigned int)(data >> 20);
results->decode_type = SAMSUNG2;
results->bits = SAMSUNG2_BITS;
return DECODED;
}
bool IRrecv::decodeNEC (decode_results *results)
{
long data = 0; // We decode in to here; Start with nothing
int offset = 1; // Index in to results; Skip first entry!?
// Check header "mark"
if (!MATCH_MARK(results->rawbuf[offset], NEC_HDR_MARK)) return false ;
offset++;
// Check for repeat
if ( (irparams.rawlen == 4)
&& MATCH_SPACE(results->rawbuf[offset ], NEC_RPT_SPACE)
&& MATCH_MARK (results->rawbuf[offset+1], NEC_BIT_MARK )
) {
results->bits = 0;
results->value = REPEAT;
results->decode_type = NEC;
return true;
}
// Check we have enough data
if (irparams.rawlen < (2 * NEC_BITS) + 4) return false ;
// Check header "space"
if (!MATCH_SPACE(results->rawbuf[offset], NEC_HDR_SPACE)) return false ;
offset++;
// Build the data
for (int i = 0; i < NEC_BITS; i++) {
// Check data "mark"
if (!MATCH_MARK(results->rawbuf[offset], NEC_BIT_MARK)) return false ;
offset++;
// Suppend this bit
if (MATCH_SPACE(results->rawbuf[offset], NEC_ONE_SPACE )) data = (data << 1) | 1 ;
else if (MATCH_SPACE(results->rawbuf[offset], NEC_ZERO_SPACE)) data = (data << 1) | 0 ;
else return false ;
offset++;
}
// Success
results->bits = NEC_BITS;
results->value = data;
results->decode_type = NEC;
return true;
}
/*
* Again we use a generic routine because most protocols have the same basic structure. However we need to
* indicate whether or not the protocol varies the length of the mark or the space to indicate a "0" or "1".
* If "Mark_One" is zero. We assume that the length of the space varies. If "Mark_One" is not zero then
* we assume that the length of Mark varies and the value passed as "Space_Zero" is ignored.
* When using variable length Mark, assumes Head_Space==Space_One. If it doesn't, you need a specialized decoder.
*/
bool IRdecodeBase::decodeGeneric(int Raw_Count, int Head_Mark,int Head_Space, int Mark_One, int Mark_Zero, int Space_One,int Space_Zero) {
// If raw samples count or head mark are zero then don't perform these tests.
// Some protocols need to do custom header work.
long data = 0; int Max; int offset;
if (Raw_Count) {if (rawlen != Raw_Count) return RAW_COUNT_ERROR;}
if (Head_Mark) {if (!MATCH_MARK(rawbuf[1],Head_Mark)) return HEADER_MARK_ERROR;}
if (Head_Space) {if (!MATCH_SPACE(rawbuf[2],Head_Space)) return HEADER_SPACE_ERROR;}
if (Mark_One) {//Length of a mark indicates data "0" or "1". Space_Zero is ignored.
offset=2;//skip initial gap plus header Mark.
Max=rawlen;
while (offset < Max) {
if (!MATCH_SPACE(rawbuf[offset], Space_One)) return DATA_SPACE_ERROR;
offset++;
if (MATCH_MARK(rawbuf[offset], Mark_One)) {
data = (data << 1) | 1;
}
else if (MATCH_MARK(rawbuf[offset], Mark_Zero)) {
data <<= 1;
}
else return DATA_MARK_ERROR;
offset++;
}
bits = (offset - 1) / 2;
}
else {//Mark_One was 0 therefore length of a space indicates data "0" or "1".
Max=rawlen-1; //ignore stop bit
offset=3;//skip initial gap plus two header items
while (offset < Max) {
if (!MATCH_MARK (rawbuf[offset],Mark_Zero)) return DATA_MARK_ERROR;
offset++;
if (MATCH_SPACE(rawbuf[offset],Space_One)) {
data = (data << 1) | 1;
}
else if (MATCH_SPACE (rawbuf[offset],Space_Zero)) {
data <<= 1;
}
else return DATA_SPACE_ERROR;
offset++;
}
bits = (offset - 1) / 2 -1;//didn't encode stop bit
}
// Success
value = data;
return true;
}
long IRrecv::decodeLG(decode_results *results) {
long data = 0;
int offset = 1; // Skip first space
// Initial mark
if (!MATCH_MARK(results->rawbuf[offset], LG_HDR_MARK)) {
return ERR;
}
offset++;
if (irparams.rawlen < 2 * LG_BITS + 1 ) {
return ERR;
}
// Initial space
if (!MATCH_SPACE(results->rawbuf[offset], LG_HDR_SPACE)) {
return ERR;
}
offset++;
for (int i = 0; i < LG_BITS; i++) {
if (!MATCH_MARK(results->rawbuf[offset], LG_BIT_MARK)) {
return ERR;
}
offset++;
if (MATCH_SPACE(results->rawbuf[offset], LG_ONE_SPACE)) {
data = (data << 1) | 1;
}
else if (MATCH_SPACE(results->rawbuf[offset], LG_ZERO_SPACE)) {
data <<= 1;
}
else {
return ERR;
}
offset++;
}
//Stop bit
if (!MATCH_MARK(results->rawbuf[offset], LG_BIT_MARK)){
return ERR;
}
// Success
results->bits = LG_BITS;
results->value = data;
results->decode_type = LG;
return DECODED;
}
u32 IRrecv_decodeRC6(decode_results *results)
{
u16 offset = 1; // Skip first space
u32 data = 0;
u16 used = 0;
u16 nbits;
u16 levelA, levelB; // Next two levels
if (results->rawlen < MIN_RC6_SAMPLES) return ERR;
// Initial mark
if (!MATCH_MARK(results->rawbuf[offset], RC6_HDR_MARK)) return ERR;
offset++;
if (!MATCH_SPACE(results->rawbuf[offset], RC6_HDR_SPACE)) return ERR;
offset++;
// Get start bit (1)
if (IRrecv_getRClevel(results, &offset, &used, RC6_T1) != MARK) return ERR;
if (IRrecv_getRClevel(results, &offset, &used, RC6_T1) != SPACE) return ERR;
for (nbits = 0; offset < results->rawlen; nbits++)
{
levelA = IRrecv_getRClevel(results, &offset, &used, RC6_T1);
if (nbits == 3)
{
// T bit is double wide; make sure second half matches
if (levelA != IRrecv_getRClevel(results, &offset, &used, RC6_T1)) return ERR;
}
levelB = IRrecv_getRClevel(results, &offset, &used, RC6_T1);
if (nbits == 3)
{
// T bit is double wide; make sure second half matches
if (levelB != IRrecv_getRClevel(results, &offset, &used, RC6_T1)) return ERR;
}
if (levelA == MARK && levelB == SPACE)
{
// reversed compared to RC5
// 1 bit
data = (data << 1) | 1;
}
else if (levelA == SPACE && levelB == MARK)
{
// zero bit
data <<= 1;
}
else
{
return ERR; // Error
}
}
// Success
results->bits = nbits;
results->value = data;
results->decode_type = RC6;
return DECODED;
}
static long decodeSony(decode_results *results)
{
long data = 0;
if (irparams.rawlen < 2 * SONY_BITS + 2) {
return ERR;
}
int offset = 1; // Skip first space
// Initial mark
if (!MATCH_MARK(results->rawbuf[offset], SONY_HDR_MARK)) {
return ERR;
}
offset++;
while (offset + 1 < irparams.rawlen) {
if (!MATCH_SPACE(results->rawbuf[offset], SONY_HDR_SPACE)) {
break;
}
offset++;
if (MATCH_MARK(results->rawbuf[offset], SONY_ONE_MARK)) {
data = (data << 1) | 1;
}
else if (MATCH_MARK(results->rawbuf[offset], SONY_ZERO_MARK)) {
data <<= 1;
}
else {
return ERR;
}
offset++;
}
// Success
results->bits = (offset - 1) / 2;
if (results->bits < 12) {
results->bits = 0;
return ERR;
}
results->value = data;
results->decode_type = SONY;
return DECODED;
}
bool IRrecv::decodeSAMSUNG (decode_results *results)
{
long data = 0;
int offset = 1; // Skip first space
// Initial mark
if (!MATCH_MARK(results->rawbuf[offset], SAMSUNG_HDR_MARK)) return false ;
offset++;
// Check for repeat
if ( (irparams.rawlen == 4)
&& MATCH_SPACE(results->rawbuf[offset], SAMSUNG_RPT_SPACE)
&& MATCH_MARK(results->rawbuf[offset+1], SAMSUNG_BIT_MARK)
) {
results->bits = 0;
results->value = REPEAT;
results->decode_type = SAMSUNG;
return true;
}
if (irparams.rawlen < (2 * SAMSUNG_BITS) + 4) return false ;
// Initial space
if (!MATCH_SPACE(results->rawbuf[offset++], SAMSUNG_HDR_SPACE)) return false ;
for (int i = 0; i < SAMSUNG_BITS; i++) {
if (!MATCH_MARK(results->rawbuf[offset++], SAMSUNG_BIT_MARK)) return false ;
if (MATCH_SPACE(results->rawbuf[offset], SAMSUNG_ONE_SPACE)) data = (data << 1) | 1 ;
else if (MATCH_SPACE(results->rawbuf[offset], SAMSUNG_ZERO_SPACE)) data = (data << 1) | 0 ;
else return false ;
offset++;
}
// Success
results->bits = SAMSUNG_BITS;
results->value = data;
results->decode_type = SAMSUNG;
return true;
}
bool IRdecodeNEC::decode(void) {
ATTEMPT_MESSAGE(F("NEC"));
// Check for repeat
if (rawlen == 4 && MATCH_SPACE(rawbuf[2], NEC_RPT_SPACE) &&
MATCH_MARK(rawbuf[3],564)) {
bits = 0;
value = REPEAT;
decode_type = NEC;
return true;
}
if(!decodeGeneric(68, 564*16, 564*8, 0, 564, 564*3, 564)) return false;
decode_type = NEC;
return true;
}
u32 IRrecv_decodePanasonic(decode_results *results)
{
//u32 long data = 0; // PIC18F don't have 64-bit type
u32 data = 0;
u16 offset = 1;
u16 i;
if (!MATCH_MARK(results->rawbuf[offset], PANASONIC_HDR_MARK)) {
return ERR;
}
offset++;
if (!MATCH_MARK(results->rawbuf[offset], PANASONIC_HDR_SPACE)) {
return ERR;
}
offset++;
// decode address
for (i = 0; i < PANASONIC_BITS; i++) {
if (!MATCH_MARK(results->rawbuf[offset++], PANASONIC_BIT_MARK)) {
return ERR;
}
if (MATCH_SPACE(results->rawbuf[offset],PANASONIC_ONE_SPACE)) {
data = (data << 1) | 1;
} else if (MATCH_SPACE(results->rawbuf[offset],PANASONIC_ZERO_SPACE)) {
data <<= 1;
} else {
return ERR;
}
offset++;
}
results->value = (u32)data;
results->panasonicAddress = (u16)(data >> 32);
results->decode_type = PANASONIC;
results->bits = PANASONIC_BITS;
return DECODED;
}
bool IRdecodeRC6::decode(void) {
ATTEMPT_MESSAGE(F("RC6"));
if (rawlen < MIN_RC6_SAMPLES) return RAW_COUNT_ERROR;
// Initial mark
if (!MATCH_MARK(rawbuf[1], RC6_HDR_MARK)) return HEADER_MARK_ERROR;
if (!MATCH_SPACE(rawbuf[2], RC6_HDR_SPACE)) return HEADER_SPACE_ERROR;
int offset=3;//Skip gap and header
long data = 0;
int used = 0;
// Get start bit (1)
if (getRClevel(&offset, &used, RC6_T1) != MARK) return DATA_MARK_ERROR;
if (getRClevel(&offset, &used, RC6_T1) != SPACE) return DATA_SPACE_ERROR;
int nbits;
for (nbits = 0; offset < rawlen; nbits++) {
RCLevel levelA, levelB; // Next two levels
levelA = getRClevel(&offset, &used, RC6_T1);
if (nbits == 3) {
// T bit is double wide; make sure second half matches
if (levelA != getRClevel(&offset, &used, RC6_T1)) return TRAILER_BIT_ERROR;
}
levelB = getRClevel(&offset, &used, RC6_T1);
if (nbits == 3) {
// T bit is double wide; make sure second half matches
if (levelB != getRClevel(&offset, &used, RC6_T1)) return TRAILER_BIT_ERROR;
}
if (levelA == MARK && levelB == SPACE) { // reversed compared to RC5
// 1 bit
data = (data << 1) | 1;
}
else if (levelA == SPACE && levelB == MARK) {
// zero bit
data <<= 1;
}
else {
return DATA_MARK_ERROR;
}
}
// Success
bits = nbits;
value = data;
decode_type = RC6;
return true;
}
