Theaninova/Arduino-IRremote
1
0
Fork 0
mirror of https://github.com/Theaninova/Arduino-IRremote.git synced 2026-01-20 08:12:53 +00:00
Code Issues Packages Projects Releases Wiki Activity

Bit more cleanup

Browse Source 
Guests have arrived - sanity checkin
This commit is contained in:
Bluechip
2015-06-18 19:52:22 +01:00
parent e6ae660100
commit f5e85e9432
1 changed files with 183 additions and 107 deletions
Download Patch File Download Diff File Expand all files Collapse all files

290
IRremote.cpp
View File

@@ -103,19 +103,22 @@ int MATCH_SPACE (int measured_ticks, int desired_us)
#ifdef SEND_NEC #ifdef SEND_NEC
void IRsend::sendNEC (unsigned long data, int nbits) void IRsend::sendNEC (unsigned long data, int nbits)
{ {
// Set IR carrier frequency
enableIROut(38); enableIROut(38);
mark(NEC_HDR_MARK); mark(NEC_HDR_MARK);
space(NEC_HDR_SPACE); space(NEC_HDR_SPACE);
for (unsigned long mask = 1 << (nbits - 1); mask; mask >>= 1) { for (unsigned long mask = 1 << (nbits - 1); mask; mask >>= 1) {
if (data & mask) { if (data & mask) {
mark(NEC_BIT_MARK); mark(NEC_BIT_MARK);
space(NEC_ONE_SPACE); space(NEC_ONE_SPACE);
} } else {
else {
mark(NEC_BIT_MARK); mark(NEC_BIT_MARK);
space(NEC_ZERO_SPACE); space(NEC_ZERO_SPACE);
} }
} }
mark(NEC_BIT_MARK); mark(NEC_BIT_MARK);
space(0); space(0);
} }
@@ -125,21 +128,24 @@ void IRsend::sendNEC (unsigned long data, int nbits)
#ifdef SEND_WHYNTER #ifdef SEND_WHYNTER
void IRsend::sendWhynter (unsigned long data, int nbits) void IRsend::sendWhynter (unsigned long data, int nbits)
{ {
// Set IR carrier frequency
enableIROut(38); enableIROut(38);
mark(WHYNTER_ZERO_MARK); mark(WHYNTER_ZERO_MARK);
space(WHYNTER_ZERO_SPACE); space(WHYNTER_ZERO_SPACE);
mark(WHYNTER_HDR_MARK); mark(WHYNTER_HDR_MARK);
space(WHYNTER_HDR_SPACE); space(WHYNTER_HDR_SPACE);
for (unsigned long mask = 1 << (nbits - 1); mask; mask >>= 1) { for (unsigned long mask = 1 << (nbits - 1); mask; mask >>= 1) {
if (data & mask) { if (data & mask) {
mark(WHYNTER_ONE_MARK); mark(WHYNTER_ONE_MARK);
space(WHYNTER_ONE_SPACE); space(WHYNTER_ONE_SPACE);
} } else {
else {
mark(WHYNTER_ZERO_MARK); mark(WHYNTER_ZERO_MARK);
space(WHYNTER_ZERO_SPACE); space(WHYNTER_ZERO_SPACE);
} }
} }
mark(WHYNTER_ZERO_MARK); mark(WHYNTER_ZERO_MARK);
space(WHYNTER_ZERO_SPACE); space(WHYNTER_ZERO_SPACE);
} }
@@ -149,15 +155,17 @@ void IRsend::sendWhynter (unsigned long data, int nbits)
#ifdef SEND_SONY #ifdef SEND_SONY
void IRsend::sendSony (unsigned long data, int nbits) void IRsend::sendSony (unsigned long data, int nbits)
{ {
// Set IR carrier frequency
enableIROut(40); enableIROut(40);
mark(SONY_HDR_MARK); mark(SONY_HDR_MARK);
space(SONY_HDR_SPACE); space(SONY_HDR_SPACE);
for (unsigned long mask = 1 << (nbits - 1); mask; mask >>= 1) { for (unsigned long mask = 1 << (nbits - 1); mask; mask >>= 1) {
if (data & mask) { if (data & mask) {
mark(SONY_ONE_MARK); mark(SONY_ONE_MARK);
space(SONY_HDR_SPACE); space(SONY_HDR_SPACE);
} } else {
else {
mark(SONY_ZERO_MARK); mark(SONY_ZERO_MARK);
space(SONY_HDR_SPACE); space(SONY_HDR_SPACE);
} }
@@ -168,11 +176,14 @@ void IRsend::sendSony (unsigned long data, int nbits)
//+============================================================================= //+=============================================================================
void IRsend::sendRaw (unsigned int buf[], int len, int hz) void IRsend::sendRaw (unsigned int buf[], int len, int hz)
{ {
// Set IR carrier frequency
enableIROut(hz); enableIROut(hz);
for (int i = 0; i < len; i++) { for (int i = 0; i < len; i++) {
if (i & 1) space(buf[i]) ; if (i & 1) space(buf[i]) ;
else mark (buf[i]) ; else mark (buf[i]) ;
} }
space(0); // Just to be sure space(0); // Just to be sure
} }
@@ -182,20 +193,23 @@ void IRsend::sendRaw (unsigned int buf[], int len, int hz)
#ifdef SEND_RC5 #ifdef SEND_RC5
void IRsend::sendRC5 (unsigned long data, int nbits) void IRsend::sendRC5 (unsigned long data, int nbits)
{ {
// Set IR carrier frequency
enableIROut(36); enableIROut(36);
mark(RC5_T1); // First start bit mark(RC5_T1); // First start bit
space(RC5_T1); // Second start bit space(RC5_T1); // Second start bit
mark(RC5_T1); // Second start bit mark(RC5_T1); // Second start bit
for (unsigned long mask = 1 << (nbits - 1); mask; mask >>= 1) { for (unsigned long mask = 1 << (nbits - 1); mask; mask >>= 1) {
if (data & mask) { if (data & mask) {
space(RC5_T1); // 1 is space, then mark space(RC5_T1); // 1 is space, then mark
mark(RC5_T1); mark(RC5_T1);
} } else {
else {
mark(RC5_T1); mark(RC5_T1);
space(RC5_T1); space(RC5_T1);
} }
} }
space(0); // Turn off at end space(0); // Turn off at end
} }
#endif #endif
@@ -206,24 +220,25 @@ void IRsend::sendRC5 (unsigned long data, int nbits)
#ifdef SEND_RC6 #ifdef SEND_RC6
void IRsend::sendRC6 (unsigned long data, int nbits) void IRsend::sendRC6 (unsigned long data, int nbits)
{ {
// Set IR carrier frequency
enableIROut(36); enableIROut(36);
mark(RC6_HDR_MARK); mark(RC6_HDR_MARK);
space(RC6_HDR_SPACE); space(RC6_HDR_SPACE);
mark(RC6_T1); // start bit mark(RC6_T1); // start bit
space(RC6_T1); space(RC6_T1);
for (unsigned long mask = 1 << (nbits - 1); mask; mask >>= 1) { for (unsigned long mask = 1 << (nbits - 1); mask; mask >>= 1) {
int t; int t = (i == 3) ? (RC6_T1 * 2) : (RC6_T1) ;
if (i == 3) t = RC6_T1 * 2 ; // double-wide trailer bit
else t = RC6_T1 ;
if (data & mask) { if (data & mask) {
mark(t); mark(t);
space(t); space(t);
} } else {
else {
space(t); space(t);
mark(t); mark(t);
} }
} }
space(0); // Turn off at end space(0); // Turn off at end
} }
#endif #endif
@@ -232,7 +247,9 @@ void IRsend::sendRC6 (unsigned long data, int nbits)
#ifdef SEND_PANASONIC #ifdef SEND_PANASONIC
void IRsend::sendPanasonic (unsigned int address, unsigned long data) void IRsend::sendPanasonic (unsigned int address, unsigned long data)
{ {
// Set IR carrier frequency
enableIROut(35); enableIROut(35);
mark(PANASONIC_HDR_MARK); mark(PANASONIC_HDR_MARK);
space(PANASONIC_HDR_SPACE); space(PANASONIC_HDR_SPACE);
@@ -242,11 +259,13 @@ void IRsend::sendPanasonic (unsigned int address, unsigned long data)
if (address & mask) space(PANASONIC_ONE_SPACE) ; if (address & mask) space(PANASONIC_ONE_SPACE) ;
else space(PANASONIC_ZERO_SPACE) ; else space(PANASONIC_ZERO_SPACE) ;
} }
for (unsigned long mask = 1 << (32 - 1); mask; mask >>= 1) { for (unsigned long mask = 1 << (32 - 1); mask; mask >>= 1) {
mark(PANASONIC_BIT_MARK); mark(PANASONIC_BIT_MARK);
if (data & mask) space(PANASONIC_ONE_SPACE) ; if (data & mask) space(PANASONIC_ONE_SPACE) ;
else space(PANASONIC_ZERO_SPACE) ; else space(PANASONIC_ZERO_SPACE) ;
} }
mark(PANASONIC_BIT_MARK); mark(PANASONIC_BIT_MARK);
space(0); space(0);
} }
@@ -256,11 +275,14 @@ void IRsend::sendPanasonic (unsigned int address, unsigned long data)
#ifdef SEND_JVC #ifdef SEND_JVC
void IRsend::sendJVC (unsigned long data, int nbits, int repeat) void IRsend::sendJVC (unsigned long data, int nbits, int repeat)
{ {
// Set IR carrier frequency
enableIROut(38); enableIROut(38);
if (!repeat){ if (!repeat){
mark(JVC_HDR_MARK); mark(JVC_HDR_MARK);
space(JVC_HDR_SPACE); space(JVC_HDR_SPACE);
} }
for (unsigned long mask = 1 << (nbits - 1); mask; mask >>= 1) { for (unsigned long mask = 1 << (nbits - 1); mask; mask >>= 1) {
if (data & mask) { if (data & mask) {
mark(JVC_BIT_MARK); mark(JVC_BIT_MARK);
@@ -271,6 +293,7 @@ void IRsend::sendJVC (unsigned long data, int nbits, int repeat)
space(JVC_ZERO_SPACE); space(JVC_ZERO_SPACE);
} }
} }
mark(JVC_BIT_MARK); mark(JVC_BIT_MARK);
space(0); space(0);
} }
@@ -280,19 +303,22 @@ void IRsend::sendJVC (unsigned long data, int nbits, int repeat)
#ifdef SEND_SAMSUNG #ifdef SEND_SAMSUNG
void IRsend::sendSAMSUNG (unsigned long data, int nbits) void IRsend::sendSAMSUNG (unsigned long data, int nbits)
{ {
// Set IR carrier frequency
enableIROut(38); enableIROut(38);
mark(SAMSUNG_HDR_MARK); mark(SAMSUNG_HDR_MARK);
space(SAMSUNG_HDR_SPACE); space(SAMSUNG_HDR_SPACE);
for (unsigned long mask = 1 << (nbits - 1); mask; mask >>= 1) { for (unsigned long mask = 1 << (nbits - 1); mask; mask >>= 1) {
if (data & mask) { if (data & mask) {
mark(SAMSUNG_BIT_MARK); mark(SAMSUNG_BIT_MARK);
space(SAMSUNG_ONE_SPACE); space(SAMSUNG_ONE_SPACE);
} } else {
else { mark(SAMSUNG_BIT_MARK);
mark(SAMSUNG_BIT_MARK); space(SAMSUNG_ZERO_SPACE);
space(SAMSUNG_ZERO_SPACE); }
}
} }
mark(SAMSUNG_BIT_MARK); mark(SAMSUNG_BIT_MARK);
space(0); space(0);
} }
@@ -407,48 +433,52 @@ ISR (TIMER_INTR_NAME)
irparams.timer++; // One more 50us tick irparams.timer++; // One more 50us tick
if (irparams.rawlen >= RAWBUF) irparams.rcvstate = STATE_STOP ; // Buffer overflow if (irparams.rawlen >= RAWBUF) irparams.rcvstate = STATE_STOP ; // Buffer overflow
switch(irparams.rcvstate) { switch(irparams.rcvstate) {
case STATE_IDLE: // In the middle of a gap case STATE_IDLE: // In the middle of a gap
if (irdata == MARK) { if (irdata == MARK) {
if (irparams.timer < GAP_TICKS) { if (irparams.timer < GAP_TICKS) {
// Not big enough to be a gap. // Not big enough to be a gap.
irparams.timer = 0; irparams.timer = 0;
}
else {
// gap just ended, record duration and start recording transmission
irparams.rawlen = 0;
irparams.rawbuf[irparams.rawlen++] = irparams.timer;
irparams.timer = 0;
irparams.rcvstate = STATE_MARK;
}
} }
else { break;
// gap just ended, record duration and start recording transmission
irparams.rawlen = 0; case STATE_MARK: // timing MARK
if (irdata == SPACE) { // MARK ended, record time
irparams.rawbuf[irparams.rawlen++] = irparams.timer;
irparams.timer = 0;
irparams.rcvstate = STATE_SPACE;
}
break;
case STATE_SPACE: // timing SPACE
if (irdata == MARK) { // SPACE just ended, record it
irparams.rawbuf[irparams.rawlen++] = irparams.timer; irparams.rawbuf[irparams.rawlen++] = irparams.timer;
irparams.timer = 0; irparams.timer = 0;
irparams.rcvstate = STATE_MARK; irparams.rcvstate = STATE_MARK;
} }
} else { // SPACE
break; if (irparams.timer > GAP_TICKS) {
case STATE_MARK: // timing MARK // big SPACE, indicates gap between codes
if (irdata == SPACE) { // MARK ended, record time // Mark current code as ready for processing
irparams.rawbuf[irparams.rawlen++] = irparams.timer; // Switch to STOP
irparams.timer = 0; // Don't reset timer; keep counting space width
irparams.rcvstate = STATE_SPACE; irparams.rcvstate = STATE_STOP;
} }
break;
case STATE_SPACE: // timing SPACE
if (irdata == MARK) { // SPACE just ended, record it
irparams.rawbuf[irparams.rawlen++] = irparams.timer;
irparams.timer = 0;
irparams.rcvstate = STATE_MARK;
}
else { // SPACE
if (irparams.timer > GAP_TICKS) {
// big SPACE, indicates gap between codes
// Mark current code as ready for processing
// Switch to STOP
// Don't reset timer; keep counting space width
irparams.rcvstate = STATE_STOP;
} }
} break;
break;
case STATE_STOP: // waiting, measuring gap case STATE_STOP: // waiting, measuring gap
if (irdata == MARK) irparams.timer = 0 ; // reset gap timer if (irdata == MARK) irparams.timer = 0 ; // reset gap timer
break; break;
} }
if (irparams.blinkflag) { if (irparams.blinkflag) {
@@ -473,7 +503,9 @@ int IRrecv::decode (decode_results *results)
{ {
results->rawbuf = irparams.rawbuf; results->rawbuf = irparams.rawbuf;
results->rawlen = irparams.rawlen; results->rawlen = irparams.rawlen;
if (irparams.rcvstate != STATE_STOP) return ERR ; if (irparams.rcvstate != STATE_STOP) return ERR ;
#ifdef DECODE_NEC #ifdef DECODE_NEC
DBG_PRINTLN("Attempting NEC decode"); DBG_PRINTLN("Attempting NEC decode");
if (decodeNEC(results)) return DECODED ; if (decodeNEC(results)) return DECODED ;
@@ -550,9 +582,11 @@ long IRrecv::decodeNEC (decode_results *results)
{ {
long data = 0; long data = 0;
int offset = 1; // Skip first space int offset = 1; // Skip first space
// Initial mark // Initial mark
if (!MATCH_MARK(results->rawbuf[offset], NEC_HDR_MARK)) return ERR ; if (!MATCH_MARK(results->rawbuf[offset], NEC_HDR_MARK)) return ERR ;
offset++; offset++;
// Check for repeat // Check for repeat
if (irparams.rawlen == 4 && if (irparams.rawlen == 4 &&
MATCH_SPACE(results->rawbuf[offset], NEC_RPT_SPACE) && MATCH_SPACE(results->rawbuf[offset], NEC_RPT_SPACE) &&
@@ -563,9 +597,11 @@ long IRrecv::decodeNEC (decode_results *results)
return DECODED; return DECODED;
} }
if (irparams.rawlen < 2 * NEC_BITS + 4) return ERR ; if (irparams.rawlen < 2 * NEC_BITS + 4) return ERR ;
// Initial space // Initial space
if (!MATCH_SPACE(results->rawbuf[offset], NEC_HDR_SPACE)) return ERR ; if (!MATCH_SPACE(results->rawbuf[offset], NEC_HDR_SPACE)) return ERR ;
offset++; offset++;
for (int i = 0; i < NEC_BITS; i++) { for (int i = 0; i < NEC_BITS; i++) {
if (!MATCH_MARK(results->rawbuf[offset], NEC_BIT_MARK)) return ERR ; if (!MATCH_MARK(results->rawbuf[offset], NEC_BIT_MARK)) return ERR ;
offset++; offset++;
@@ -574,10 +610,12 @@ long IRrecv::decodeNEC (decode_results *results)
else return ERR ; else return ERR ;
offset++; offset++;
} }
// Success // Success
results->bits = NEC_BITS; results->bits = NEC_BITS;
results->value = data; results->value = data;
results->decode_type = NEC; results->decode_type = NEC;
return DECODED; return DECODED;
} }
#endif #endif
@@ -596,11 +634,13 @@ long IRrecv::decodeSony (decode_results *results)
// Serial.print("IR Gap found: "); // Serial.print("IR Gap found: ");
results->bits = 0; results->bits = 0;
results->value = REPEAT; results->value = REPEAT;
#ifdef DECODE_SANYO
results->decode_type = SANYO; # ifdef DECODE_SANYO
#else results->decode_type = SANYO;
results->decode_type = UNKNOWN; # else
#endif results->decode_type = UNKNOWN;
# endif
return DECODED; return DECODED;
} }
offset++; offset++;
@@ -624,7 +664,7 @@ long IRrecv::decodeSony (decode_results *results)
results->bits = 0; results->bits = 0;
return ERR; return ERR;
} }
results->value = data; results->value = data;
results->decode_type = SONY; results->decode_type = SONY;
return DECODED; return DECODED;
} }
@@ -656,6 +696,7 @@ long IRrecv::decodeWhynter (decode_results *results)
for (int i = 0; i < WHYNTER_BITS; i++) { for (int i = 0; i < WHYNTER_BITS; i++) {
if (!MATCH_MARK(results->rawbuf[offset], WHYNTER_BIT_MARK)) return ERR ; if (!MATCH_MARK(results->rawbuf[offset], WHYNTER_BIT_MARK)) return ERR ;
offset++; offset++;
if (MATCH_SPACE(results->rawbuf[offset], WHYNTER_ONE_SPACE)) data = (data << 1) | 1 ; 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 if (MATCH_SPACE(results->rawbuf[offset],WHYNTER_ZERO_SPACE)) data <<= 1 ;
else return ERR ; else return ERR ;
@@ -664,6 +705,7 @@ long IRrecv::decodeWhynter (decode_results *results)
// trailing mark // trailing mark
if (!MATCH_MARK(results->rawbuf[offset], WHYNTER_BIT_MARK)) return ERR ; if (!MATCH_MARK(results->rawbuf[offset], WHYNTER_BIT_MARK)) return ERR ;
// Success // Success
results->bits = WHYNTER_BITS; results->bits = WHYNTER_BITS;
results->value = data; results->value = data;
@@ -724,7 +766,8 @@ long IRrecv::decodeSanyo (decode_results *results)
results->bits = 0; results->bits = 0;
return ERR; return ERR;
} }
results->value = data;
results->value = data;
results->decode_type = SANYO; results->decode_type = SANYO;
return DECODED; return DECODED;
} }
@@ -761,7 +804,6 @@ long IRrecv::decodeMitsubishi (decode_results *results)
} }
#endif #endif
offset++; offset++;
// Typical // Typical
@@ -770,11 +812,13 @@ long IRrecv::decodeMitsubishi (decode_results *results)
// Initial Space // Initial Space
if (!MATCH_MARK(results->rawbuf[offset], MITSUBISHI_HDR_SPACE)) return ERR ; if (!MATCH_MARK(results->rawbuf[offset], MITSUBISHI_HDR_SPACE)) return ERR ;
offset++; offset++;
while (offset + 1 < irparams.rawlen) { while (offset + 1 < irparams.rawlen) {
if (MATCH_MARK(results->rawbuf[offset], MITSUBISHI_ONE_MARK)) data = (data << 1) | 1 ; 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 if (MATCH_MARK(results->rawbuf[offset], MITSUBISHI_ZERO_MARK)) data <<= 1 ;
else return ERR ; else return ERR ;
offset++; offset++;
if (!MATCH_SPACE(results->rawbuf[offset], MITSUBISHI_HDR_SPACE)) break ; if (!MATCH_SPACE(results->rawbuf[offset], MITSUBISHI_HDR_SPACE)) break ;
offset++; offset++;
} }
@@ -785,7 +829,8 @@ long IRrecv::decodeMitsubishi (decode_results *results)
results->bits = 0; results->bits = 0;
return ERR; return ERR;
} }
results->value = data;
results->value = data;
results->decode_type = MITSUBISHI; results->decode_type = MITSUBISHI;
return DECODED; return DECODED;
} }
@@ -818,6 +863,7 @@ int IRrecv::getRClevel (decode_results *results, int *offset, int *used, int
*used = 0; *used = 0;
(*offset)++; (*offset)++;
} }
DBG_PRINTLN( (val == MARK) ? "MARK" : "SPACE" ); DBG_PRINTLN( (val == MARK) ? "MARK" : "SPACE" );
return val; return val;
} }
@@ -838,14 +884,15 @@ long IRrecv::decodeRC5 (decode_results *results)
for (nbits = 0; offset < irparams.rawlen; nbits++) { for (nbits = 0; offset < irparams.rawlen; nbits++) {
int levelA = getRClevel(results, &offset, &used, RC5_T1); int levelA = getRClevel(results, &offset, &used, RC5_T1);
int levelB = getRClevel(results, &offset, &used, RC5_T1); int levelB = getRClevel(results, &offset, &used, RC5_T1);
if (levelA == SPACE && levelB == MARK) data = (data << 1) | 1 ; // 1 bit if (levelA == SPACE && levelB == MARK) data = (data << 1) | 1 ; // 1 bit
else if (levelA == MARK && levelB == SPACE) data <<= 1 ; // zero bit else if (levelA == MARK && levelB == SPACE) data <<= 1 ; // zero bit
else return ERR ; else return ERR ;
} }
// Success // Success
results->bits = nbits; results->bits = nbits;
results->value = data; results->value = data;
results->decode_type = RC5; results->decode_type = RC5;
return DECODED; return DECODED;
} }
@@ -857,13 +904,17 @@ long IRrecv::decodeRC6 (decode_results *results)
{ {
if (results->rawlen < MIN_RC6_SAMPLES) return ERR ; if (results->rawlen < MIN_RC6_SAMPLES) return ERR ;
int offset = 1; // Skip first space int offset = 1; // Skip first space
// Initial mark // Initial mark
if (!MATCH_MARK(results->rawbuf[offset], RC6_HDR_MARK)) return ERR ; if (!MATCH_MARK(results->rawbuf[offset], RC6_HDR_MARK)) return ERR ;
offset++; offset++;
if (!MATCH_SPACE(results->rawbuf[offset], RC6_HDR_SPACE)) return ERR ; if (!MATCH_SPACE(results->rawbuf[offset], RC6_HDR_SPACE)) return ERR ;
offset++; offset++;
long data = 0;
int used = 0; long data = 0;
int used = 0;
// Get start bit (1) // Get start bit (1)
if (getRClevel(results, &offset, &used, RC6_T1) != MARK) return ERR ; if (getRClevel(results, &offset, &used, RC6_T1) != MARK) return ERR ;
if (getRClevel(results, &offset, &used, RC6_T1) != SPACE) return ERR ; if (getRClevel(results, &offset, &used, RC6_T1) != SPACE) return ERR ;
@@ -884,6 +935,7 @@ long IRrecv::decodeRC6 (decode_results *results)
else if (levelA == SPACE && levelB == MARK) data <<= 1 ; // zero bit else if (levelA == SPACE && levelB == MARK) data <<= 1 ; // zero bit
else return ERR ; // Error else return ERR ; // Error
} }
// Success // Success
results->bits = nbits; results->bits = nbits;
results->value = data; results->value = data;
@@ -907,15 +959,18 @@ long IRrecv::decodePanasonic (decode_results *results)
// decode address // decode address
for (int i = 0; i < PANASONIC_BITS; i++) { for (int i = 0; i < PANASONIC_BITS; i++) {
if (!MATCH_MARK(results->rawbuf[offset++], PANASONIC_BIT_MARK)) return ERR ; if (!MATCH_MARK(results->rawbuf[offset++], PANASONIC_BIT_MARK)) return ERR ;
if (MATCH_SPACE(results->rawbuf[offset],PANASONIC_ONE_SPACE)) data = (data << 1) | 1 ; 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 if (MATCH_SPACE(results->rawbuf[offset],PANASONIC_ZERO_SPACE)) data <<= 1 ;
else return ERR ; else return ERR ;
offset++; offset++;
} }
results->value = (unsigned long)data;
results->value = (unsigned long)data;
results->panasonicAddress = (unsigned int)(data >> 32); results->panasonicAddress = (unsigned int)(data >> 32);
results->decode_type = PANASONIC; results->decode_type = PANASONIC;
results->bits = PANASONIC_BITS; results->bits = PANASONIC_BITS;
return DECODED; return DECODED;
} }
#endif #endif
@@ -924,8 +979,8 @@ long IRrecv::decodePanasonic (decode_results *results)
#ifdef DECODE_LG #ifdef DECODE_LG
long IRrecv::decodeLG (decode_results *results) long IRrecv::decodeLG (decode_results *results)
{ {
long data = 0; long data = 0;
int offset = 1; // Skip first space int offset = 1; // Skip first space
// Initial mark // Initial mark
if (!MATCH_MARK(results->rawbuf[offset], LG_HDR_MARK)) return ERR ; if (!MATCH_MARK(results->rawbuf[offset], LG_HDR_MARK)) return ERR ;
@@ -942,24 +997,25 @@ long IRrecv::decodeLG (decode_results *results)
else return ERR ; else return ERR ;
offset++; offset++;
} }
//Stop bit
// Stop bit
if (!MATCH_MARK(results->rawbuf[offset], LG_BIT_MARK)) return ERR ; if (!MATCH_MARK(results->rawbuf[offset], LG_BIT_MARK)) return ERR ;
// Success // Success
results->bits = LG_BITS; results->bits = LG_BITS;
results->value = data; results->value = data;
results->decode_type = LG; results->decode_type = LG;
return DECODED; return DECODED;
} }
#endif #endif
//+============================================================================= //+=============================================================================
#ifdef DECODE_JVC #ifdef DECODE_JVC
long IRrecv::decodeJVC (decode_results *results) long IRrecv::decodeJVC (decode_results *results)
{ {
long data = 0; long data = 0;
int offset = 1; // Skip first space int offset = 1; // Skip first space
// Check for repeat // Check for repeat
if (irparams.rawlen - 1 == 33 && if (irparams.rawlen - 1 == 33 &&
MATCH_MARK(results->rawbuf[offset], JVC_BIT_MARK) && MATCH_MARK(results->rawbuf[offset], JVC_BIT_MARK) &&
@@ -969,13 +1025,17 @@ long IRrecv::decodeJVC (decode_results *results)
results->decode_type = JVC; results->decode_type = JVC;
return DECODED; return DECODED;
} }
// Initial mark // Initial mark
if (!MATCH_MARK(results->rawbuf[offset], JVC_HDR_MARK)) return ERR ; if (!MATCH_MARK(results->rawbuf[offset], JVC_HDR_MARK)) return ERR ;
offset++; offset++;
if (irparams.rawlen < 2 * JVC_BITS + 1 ) return ERR ; if (irparams.rawlen < 2 * JVC_BITS + 1 ) return ERR ;
// Initial space // Initial space
if (!MATCH_SPACE(results->rawbuf[offset], JVC_HDR_SPACE)) return ERR ; if (!MATCH_SPACE(results->rawbuf[offset], JVC_HDR_SPACE)) return ERR ;
offset++; offset++;
for (int i = 0; i < JVC_BITS; i++) { for (int i = 0; i < JVC_BITS; i++) {
if (!MATCH_MARK(results->rawbuf[offset], JVC_BIT_MARK)) return ERR ; if (!MATCH_MARK(results->rawbuf[offset], JVC_BIT_MARK)) return ERR ;
offset++; offset++;
@@ -984,12 +1044,15 @@ long IRrecv::decodeJVC (decode_results *results)
else return ERR ; else return ERR ;
offset++; offset++;
} }
//Stop bit
// Stop bit
if (!MATCH_MARK(results->rawbuf[offset], JVC_BIT_MARK)) return ERR ; if (!MATCH_MARK(results->rawbuf[offset], JVC_BIT_MARK)) return ERR ;
// Success // Success
results->bits = JVC_BITS; results->bits = JVC_BITS;
results->value = data; results->value = data;
results->decode_type = JVC; results->decode_type = JVC;
return DECODED; return DECODED;
} }
#endif #endif
@@ -1000,11 +1063,13 @@ long IRrecv::decodeJVC (decode_results *results)
#ifdef DECODE_SAMSUNG #ifdef DECODE_SAMSUNG
long IRrecv::decodeSAMSUNG (decode_results *results) long IRrecv::decodeSAMSUNG (decode_results *results)
{ {
long data = 0; long data = 0;
int offset = 1; // Skip first space int offset = 1; // Skip first space
// Initial mark // Initial mark
if (!MATCH_MARK(results->rawbuf[offset], SAMSUNG_HDR_MARK)) return ERR ; if (!MATCH_MARK(results->rawbuf[offset], SAMSUNG_HDR_MARK)) return ERR ;
offset++; offset++;
// Check for repeat // Check for repeat
if (irparams.rawlen == 4 && if (irparams.rawlen == 4 &&
MATCH_SPACE(results->rawbuf[offset], SAMSUNG_RPT_SPACE) && MATCH_SPACE(results->rawbuf[offset], SAMSUNG_RPT_SPACE) &&
@@ -1015,20 +1080,25 @@ long IRrecv::decodeSAMSUNG (decode_results *results)
return DECODED; return DECODED;
} }
if (irparams.rawlen < 2 * SAMSUNG_BITS + 4) return ERR ; if (irparams.rawlen < 2 * SAMSUNG_BITS + 4) return ERR ;
// Initial space // Initial space
if (!MATCH_SPACE(results->rawbuf[offset], SAMSUNG_HDR_SPACE)) return ERR ; if (!MATCH_SPACE(results->rawbuf[offset], SAMSUNG_HDR_SPACE)) return ERR ;
offset++; offset++;
for (int i = 0; i < SAMSUNG_BITS; i++) { for (int i = 0; i < SAMSUNG_BITS; i++) {
if (!MATCH_MARK(results->rawbuf[offset], SAMSUNG_BIT_MARK)) return ERR ; if (!MATCH_MARK(results->rawbuf[offset], SAMSUNG_BIT_MARK)) return ERR ;
offset++; offset++;
if (MATCH_SPACE(results->rawbuf[offset], SAMSUNG_ONE_SPACE)) data = (data << 1) | 1 ; 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 if (MATCH_SPACE(results->rawbuf[offset], SAMSUNG_ZERO_SPACE)) data <<= 1 ;
else return ERR ; else return ERR ;
offset++; offset++;
} }
// Success // Success
results->bits = SAMSUNG_BITS; results->bits = SAMSUNG_BITS;
results->value = data; results->value = data;
results->decode_type = SAMSUNG; results->decode_type = SAMSUNG;
return DECODED; return DECODED;
} }
@@ -1042,8 +1112,8 @@ long IRrecv::decodeSAMSUNG (decode_results *results)
#ifdef DECODE_AIWA_RC_T501 #ifdef DECODE_AIWA_RC_T501
long IRrecv::decodeAiwaRCT501 (decode_results *results) long IRrecv::decodeAiwaRCT501 (decode_results *results)
{ {
int data = 0; int data = 0;
int offset = 1; // skip first garbage read int offset = 1; // skip first garbage read
// Check SIZE // Check SIZE
if (irparams.rawlen < 2 * (AIWA_RC_T501_SUM_BITS) + 4) return ERR ; if (irparams.rawlen < 2 * (AIWA_RC_T501_SUM_BITS) + 4) return ERR ;
@@ -1070,11 +1140,10 @@ long IRrecv::decodeAiwaRCT501 (decode_results *results)
results->bits = (offset - 1) / 2; results->bits = (offset - 1) / 2;
if (results->bits < 42) return ERR ; if (results->bits < 42) return ERR ;
results->value = data; results->value = data;
results->decode_type = AIWA_RC_T501; results->decode_type = AIWA_RC_T501;
return DECODED; return DECODED;
} }
#endif #endif
//+============================================================================= //+=============================================================================
@@ -1120,9 +1189,11 @@ long IRrecv::decodeHash (decode_results *results)
// Add value into the hash // Add value into the hash
hash = (hash * FNV_PRIME_32) ^ value; hash = (hash * FNV_PRIME_32) ^ value;
} }
results->value = hash;
results->bits = 32; results->value = hash;
results->bits = 32;
results->decode_type = UNKNOWN; results->decode_type = UNKNOWN;
return DECODED; return DECODED;
} }
@@ -1151,7 +1222,7 @@ long IRrecv::decodeHash (decode_results *results)
#ifdef SEND_SHARP #ifdef SEND_SHARP
void IRsend::sendSharp (unsigned long data, int nbits) void IRsend::sendSharp (unsigned long data, int nbits)
{ {
unsigned long invertdata = data ^ SHARP_TOGGLE_MASK; unsigned long invertdata = data ^ SHARP_TOGGLE_MASK;
enableIROut(38); enableIROut(38);
// Sending codes in bursts of 3 (normal, inverted, normal) makes transmission // Sending codes in bursts of 3 (normal, inverted, normal) makes transmission
@@ -1161,8 +1232,7 @@ void IRsend::sendSharp (unsigned long data, int nbits)
if (data & mask) { if (data & mask) {
mark(SHARP_BIT_MARK); mark(SHARP_BIT_MARK);
space(SHARP_ONE_SPACE); space(SHARP_ONE_SPACE);
} } else {
else {
mark(SHARP_BIT_MARK); mark(SHARP_BIT_MARK);
space(SHARP_ZERO_SPACE); space(SHARP_ZERO_SPACE);
} }
@@ -1190,15 +1260,17 @@ void IRsend::sendSharp (unsigned int address, unsigned int command)
#ifdef SEND_DISH #ifdef SEND_DISH
void IRsend::sendDISH (unsigned long data, int nbits) void IRsend::sendDISH (unsigned long data, int nbits)
{ {
// Set IR carrier frequency
enableIROut(56); enableIROut(56);
mark(DISH_HDR_MARK); mark(DISH_HDR_MARK);
space(DISH_HDR_SPACE); space(DISH_HDR_SPACE);
for (unsigned long mask = 1 << (nbits - 1); mask; mask >>= 1) { for (unsigned long mask = 1 << (nbits - 1); mask; mask >>= 1) {
if (data & mark) { if (data & mark) {
mark(DISH_BIT_MARK); mark(DISH_BIT_MARK);
space(DISH_ONE_SPACE); space(DISH_ONE_SPACE);
} } else {
else {
mark(DISH_BIT_MARK); mark(DISH_BIT_MARK);
space(DISH_ZERO_SPACE); space(DISH_ZERO_SPACE);
} }
@@ -1215,25 +1287,27 @@ void IRsend::sendDISH (unsigned long data, int nbits)
void IRsend::sendAiwaRCT501 (int code) void IRsend::sendAiwaRCT501 (int code)
{ {
// PRE-DATA, 26 bits, 0x227EEC0 // PRE-DATA, 26 bits, 0x227EEC0
long int pre = 0x227EEC0; unsigned long pre = 0x227EEC0;
int i; int mask;
// Set IR carrier frequency
enableIROut(AIWA_RC_T501_HZ); enableIROut(AIWA_RC_T501_HZ);
// HDR mark + HDR space // HDR mark + HDR space
mark(AIWA_RC_T501_HDR_MARK); mark(AIWA_RC_T501_HDR_MARK);
space(AIWA_RC_T501_HDR_SPACE); space(AIWA_RC_T501_HDR_SPACE);
// Skip leading zero's
pre <<= 6;
// Send pre-data // Send pre-data
for (i = 0; i < 26; i++) { for (unsigned long mask = 1 << (26 - 1); mask; mask >>= 1) {
mark(AIWA_RC_T501_BIT_MARK); mark(AIWA_RC_T501_BIT_MARK);
if (pre & TOPBIT) space(AIWA_RC_T501_ONE_SPACE) ; if (pre & mask) space(AIWA_RC_T501_ONE_SPACE) ;
else space(AIWA_RC_T501_ZERO_SPACE) ; else space(AIWA_RC_T501_ZERO_SPACE) ;
pre <<= 1;
} }
//-v- THIS CODE LOOKS LIKE IT MIGHT BE WRONG - CHECK!
// it only send 15bits and ignores the top bit
// then uses TOPBIT which is bit-31 to check the bit code
// I suspect TOPBIT should be changed to 0x00008000
// Skip firts code bit // Skip firts code bit
code <<= 1; code <<= 1;
// Send code // Send code
@@ -1243,6 +1317,8 @@ void IRsend::sendAiwaRCT501 (int code)
else space(AIWA_RC_T501_ZERO_SPACE) ; else space(AIWA_RC_T501_ZERO_SPACE) ;
code <<= 1; code <<= 1;
} }
//-^- THIS CODE LOOKS LIKE IT MIGHT BE WRONG - CHECK!
// POST-DATA, 1 bit, 0x0 // POST-DATA, 1 bit, 0x0
mark(AIWA_RC_T501_BIT_MARK); mark(AIWA_RC_T501_BIT_MARK);
space(AIWA_RC_T501_ZERO_SPACE); space(AIWA_RC_T501_ZERO_SPACE);