528 lines
18 KiB
C++
528 lines
18 KiB
C++
// Copyright 2009 Ken Shirriff
|
|
// Copyright 2017 David Conran
|
|
|
|
#include <algorithm>
|
|
#include "IRrecv.h"
|
|
#include "IRsend.h"
|
|
#include "IRtimer.h"
|
|
#include "IRutils.h"
|
|
|
|
// RRRRRR CCCCC 555555 XX XX RRRRRR CCCCC 666
|
|
// RR RR CC C 55 XX XX RR RR CC C 66
|
|
// RRRRRR CC _____ 555555 XXXX RRRRRR CC _____ 666666
|
|
// RR RR CC C 5555 XX XX RR RR CC C 66 66
|
|
// RR RR CCCCC 555555 XX XX RR RR CCCCC 66666
|
|
|
|
// RC-5 & RC-6 support added from https://github.com/z3t0/Arduino-IRremote
|
|
// RC-5X support added by David Conran
|
|
|
|
// Constants
|
|
// RC-5/RC-5X
|
|
// Ref:
|
|
// https://en.wikipedia.org/wiki/RC-5
|
|
// http://www.sbprojects.com/knowledge/ir/rc5.php
|
|
#define MIN_RC5_SAMPLES 11U
|
|
#define MIN_RC6_SAMPLES 1U
|
|
#define RC5_T1 889U
|
|
#define RC5_MIN_COMMAND_LENGTH 113778UL
|
|
#define RC5_MIN_GAP (RC5_MIN_COMMAND_LENGTH - RC5_RAW_BITS * (2 * RC5_T1))
|
|
#define RC5_TOGGLE_MASK 0x800U // (The 12th bit)
|
|
// RC-6
|
|
// Ref:
|
|
// https://en.wikipedia.org/wiki/RC-6
|
|
// http://www.pcbheaven.com/userpages/The_Philips_RC6_Protocol/
|
|
#define RC6_TICK 444U
|
|
#define RC6_HDR_MARK_TICKS 6U
|
|
#define RC6_HDR_MARK (RC6_HDR_MARK_TICKS * RC6_TICK)
|
|
#define RC6_HDR_SPACE_TICKS 2U
|
|
#define RC6_HDR_SPACE (RC6_HDR_SPACE_TICKS * RC6_TICK)
|
|
#define RC6_RPT_LENGTH_TICKS 187U
|
|
#define RC6_RPT_LENGTH (RC6_RPT_LENGTH_TICKS * RC6_TICK)
|
|
#define RC6_TOGGLE_MASK 0x10000UL // (The 17th bit)
|
|
#define RC6_36_TOGGLE_MASK 0x8000U // (The 16th bit)
|
|
|
|
// Common (getRClevel())
|
|
const int16_t kMARK = 0;
|
|
const int16_t kSPACE = 1;
|
|
|
|
#if SEND_RC5
|
|
// Send a Philips RC-5/RC-5X packet.
|
|
//
|
|
// Args:
|
|
// data: The message you wish to send.
|
|
// nbits: Bit size of the protocol you want to send.
|
|
// repeat: Nr. of extra times the data will be sent.
|
|
//
|
|
// Status: RC-5 (stable), RC-5X (alpha)
|
|
//
|
|
// Note:
|
|
// Caller needs to take care of flipping the toggle bit.
|
|
// That bit differentiates between key press & key release.
|
|
// For RC-5 it is the MSB of the data.
|
|
// For RC-5X it is the 2nd MSB of the data.
|
|
// Ref:
|
|
// http://www.sbprojects.com/knowledge/ir/rc5.php
|
|
// https://en.wikipedia.org/wiki/RC-5
|
|
// https://en.wikipedia.org/wiki/Manchester_code
|
|
// TODO(anyone):
|
|
// Testing of the RC-5X components.
|
|
void IRsend::sendRC5(uint64_t data, uint16_t nbits, uint16_t repeat) {
|
|
if (nbits > sizeof(data) * 8)
|
|
return; // We can't send something that big.
|
|
bool skipSpace = true;
|
|
bool field_bit = true;
|
|
// Set 36kHz IR carrier frequency & a 1/4 (25%) duty cycle.
|
|
enableIROut(36, 25);
|
|
|
|
if (nbits >= RC5X_BITS) { // Is this a RC-5X message?
|
|
// field bit is the inverted MSB of RC-5X data.
|
|
field_bit = ((data >> (nbits - 1)) ^ 1) & 1;
|
|
nbits--;
|
|
}
|
|
|
|
IRtimer usecTimer = IRtimer();
|
|
for (uint16_t i = 0; i <= repeat; i++) {
|
|
usecTimer.reset();
|
|
|
|
// Header
|
|
// First start bit (0x1). space, then mark.
|
|
if (skipSpace)
|
|
skipSpace = false; // First time through, we assume the leading space().
|
|
else
|
|
space(RC5_T1);
|
|
mark(RC5_T1);
|
|
// Field/Second start bit.
|
|
if (field_bit) { // Send a 1. Normal for RC-5.
|
|
space(RC5_T1);
|
|
mark(RC5_T1);
|
|
} else { // Send a 0. Special case for RC-5X. Means 7th command bit is 1.
|
|
mark(RC5_T1);
|
|
space(RC5_T1);
|
|
}
|
|
|
|
// Data
|
|
for (uint64_t mask = 1ULL << (nbits - 1); mask; mask >>= 1)
|
|
if (data & mask) { // 1
|
|
space(RC5_T1); // 1 is space, then mark.
|
|
mark(RC5_T1);
|
|
} else { // 0
|
|
mark(RC5_T1); // 0 is mark, then space.
|
|
space(RC5_T1);
|
|
}
|
|
// Footer
|
|
space(std::max(RC5_MIN_GAP, RC5_MIN_COMMAND_LENGTH - usecTimer.elapsed()));
|
|
}
|
|
}
|
|
|
|
// Encode a Philips RC-5 data message.
|
|
//
|
|
// Args:
|
|
// address: The 5-bit address value for the message.
|
|
// command: The 6-bit command value for the message.
|
|
// key_released: Boolean flag indicating if the remote key has been released.
|
|
//
|
|
// Returns:
|
|
// A data message suitable for use in sendRC5().
|
|
//
|
|
// Status: Beta / Should be working.
|
|
//
|
|
// Ref:
|
|
// http://www.sbprojects.com/knowledge/ir/rc5.php
|
|
// https://en.wikipedia.org/wiki/RC-5
|
|
uint16_t IRsend::encodeRC5(uint8_t address, uint8_t command,
|
|
bool key_released) {
|
|
return (key_released << (RC5_BITS - 1)) |
|
|
((address & 0x1f) << 6) |
|
|
(command & 0x3F);
|
|
}
|
|
|
|
// Encode a Philips RC-5X data message.
|
|
//
|
|
// Args:
|
|
// address: The 5-bit address value for the message.
|
|
// command: The 7-bit command value for the message.
|
|
// key_released: Boolean flag indicating if the remote key has been released.
|
|
//
|
|
// Returns:
|
|
// A data message suitable for use in sendRC5().
|
|
//
|
|
// Status: Beta / Should be working.
|
|
//
|
|
// Ref:
|
|
// http://www.sbprojects.com/knowledge/ir/rc5.php
|
|
// https://en.wikipedia.org/wiki/RC-5
|
|
uint16_t IRsend::encodeRC5X(uint8_t address, uint8_t command,
|
|
bool key_released) {
|
|
// The 2nd start/field bit (MSB of the return value) is the value of the 7th
|
|
// command bit.
|
|
bool s2 = (command >> 6) & 1;
|
|
return ((uint16_t) s2 << (RC5X_BITS - 1)) |
|
|
encodeRC5(address, command, key_released);
|
|
}
|
|
|
|
// Flip the toggle bit of a Philips RC-5/RC-5X data message.
|
|
// Used to indicate a change of remote button's state.
|
|
//
|
|
// Args:
|
|
// data: The existing RC-5/RC-5X message.
|
|
//
|
|
// Returns:
|
|
// A data message suitable for use in sendRC5() with the toggle bit flipped.
|
|
//
|
|
// Status: STABLE.
|
|
//
|
|
// Ref:
|
|
// http://www.sbprojects.com/knowledge/ir/rc5.php
|
|
// https://en.wikipedia.org/wiki/RC-5
|
|
uint64_t IRsend::toggleRC5(uint64_t data) {
|
|
return data ^ RC5_TOGGLE_MASK;
|
|
}
|
|
#endif // SEND_RC5
|
|
|
|
#if SEND_RC6
|
|
// Flip the toggle bit of a Philips RC-6 data message.
|
|
// Used to indicate a change of remote button's state.
|
|
// For RC-6 (20-bits), it is the 17th least significant bit.
|
|
// for RC-6 (36-bits/Xbox-360), it is the 16th least significant bit.
|
|
//
|
|
// Args:
|
|
// data: The existing RC-6 message.
|
|
// nbits: Nr. of bits in the RC-6 protocol.
|
|
//
|
|
// Returns:
|
|
// A data message suitable for use in sendRC6() with the toggle bit flipped.
|
|
//
|
|
// Status: BETA / Should work fine.
|
|
//
|
|
// Ref:
|
|
// http://www.sbprojects.com/knowledge/ir/rc6.php
|
|
// http://www.righto.com/2010/12/64-bit-rc6-codes-arduino-and-xbox.html
|
|
uint64_t IRsend::toggleRC6(uint64_t data, uint16_t nbits) {
|
|
if (nbits == RC6_36_BITS)
|
|
return data ^ RC6_36_TOGGLE_MASK;
|
|
return data ^ RC6_TOGGLE_MASK;
|
|
}
|
|
|
|
// Encode a Philips RC-6 data message.
|
|
//
|
|
// Args:
|
|
// address: The address (aka. control) value for the message.
|
|
// Includes the field/mode/toggle bits.
|
|
// command: The 8-bit command value for the message. (aka. information)
|
|
// mode: Which protocol to use. Defined by nr. of bits in the protocol.
|
|
//
|
|
// Returns:
|
|
// A data message suitable for use in sendRC6().
|
|
//
|
|
// Status: Beta / Should be working.
|
|
//
|
|
// Ref:
|
|
// http://www.sbprojects.com/knowledge/ir/rc6.php
|
|
// http://www.righto.com/2010/12/64-bit-rc6-codes-arduino-and-xbox.html
|
|
// http://www.pcbheaven.com/userpages/The_Philips_RC6_Protocol/
|
|
uint64_t IRsend::encodeRC6(uint32_t address, uint8_t command,
|
|
uint16_t mode) {
|
|
switch (mode) {
|
|
case RC6_MODE0_BITS:
|
|
return ((address & 0xFFF) << 8) | (command & 0xFF);
|
|
case RC6_36_BITS:
|
|
return ((uint64_t) (address & 0xFFFFFFF) << 8) | (command & 0xFF);
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
// Send a Philips RC-6 packet.
|
|
// Note: Caller needs to take care of flipping the toggle bit (The 4th Most
|
|
// Significant Bit). That bit differentiates between key press & key release.
|
|
//
|
|
// Args:
|
|
// data: The message you wish to send.
|
|
// nbits: Bit size of the protocol you want to send.
|
|
// repeat: Nr. of extra times the data will be sent.
|
|
//
|
|
// Status: Stable.
|
|
//
|
|
// Ref:
|
|
// http://www.sbprojects.com/knowledge/ir/rc6.php
|
|
// http://www.righto.com/2010/12/64-bit-rc6-codes-arduino-and-xbox.html
|
|
// https://en.wikipedia.org/wiki/Manchester_code
|
|
void IRsend::sendRC6(uint64_t data, uint16_t nbits, uint16_t repeat) {
|
|
// Check we can send the number of bits requested.
|
|
if (nbits > sizeof(data) * 8)
|
|
return;
|
|
// Set 36kHz IR carrier frequency & a 1/3 (33%) duty cycle.
|
|
enableIROut(36, 33);
|
|
for (uint16_t r = 0; r <= repeat; r++) {
|
|
// Header
|
|
mark(RC6_HDR_MARK);
|
|
space(RC6_HDR_SPACE);
|
|
// Start bit.
|
|
mark(RC6_TICK); // mark, then space == 0x1.
|
|
space(RC6_TICK);
|
|
// Data
|
|
uint16_t bitTime;
|
|
for (uint64_t i = 1, mask = 1ULL << (nbits - 1); mask; i++, mask >>= 1) {
|
|
if (i == 4) // The fourth bit we send is a "double width trailer bit".
|
|
bitTime = 2 * RC6_TICK; // double-wide trailer bit
|
|
else
|
|
bitTime = RC6_TICK; // Normal bit
|
|
if (data & mask) { // 1
|
|
mark(bitTime);
|
|
space(bitTime);
|
|
} else { // 0
|
|
space(bitTime);
|
|
mark(bitTime);
|
|
}
|
|
}
|
|
// Footer
|
|
space(RC6_RPT_LENGTH);
|
|
}
|
|
}
|
|
#endif // SEND_RC6
|
|
|
|
#if (DECODE_RC5 || DECODE_RC6 || DECODE_LASERTAG)
|
|
// Gets one undecoded level at a time from the raw buffer.
|
|
// The RC5/6 decoding is easier if the data is broken into time intervals.
|
|
// E.g. if the buffer has MARK for 2 time intervals and SPACE for 1,
|
|
// successive calls to getRClevel will return MARK, MARK, SPACE.
|
|
// offset and used are updated to keep track of the current position.
|
|
//
|
|
// Args:
|
|
// results: Ptr to the data to decode and where to store the decode result.
|
|
// offset: Ptr to the currect offset to the rawbuf.
|
|
// used: Ptr to the current used counter.
|
|
// bitTime: Time interval of single bit in microseconds.
|
|
// Returns:
|
|
// int: MARK, SPACE, or -1 for error (The measured time interval is not a
|
|
// multiple of t1.)
|
|
// Ref:
|
|
// https://en.wikipedia.org/wiki/Manchester_code
|
|
int16_t IRrecv::getRClevel(decode_results *results, uint16_t *offset,
|
|
uint16_t *used, uint16_t bitTime,
|
|
uint8_t tolerance, int16_t excess, uint16_t delta) {
|
|
DPRINT("DEBUG: getRClevel: offset = ");
|
|
DPRINTLN(uint64ToString(*offset));
|
|
if (*offset >= results->rawlen) {
|
|
DPRINTLN("DEBUG: getRClevel: SPACE, past end of rawbuf");
|
|
return kSPACE; // After end of recorded buffer, assume SPACE.
|
|
}
|
|
uint16_t width = results->rawbuf[*offset];
|
|
// If the value of offset is odd, it's a MARK. Even, it's a SPACE.
|
|
uint16_t val = ((*offset) % 2) ? kMARK : kSPACE;
|
|
// Check to see if we have hit an inter-message gap (> 20ms).
|
|
if (val == kSPACE && width > 20000 - delta) {
|
|
DPRINTLN("DEBUG: getRClevel: SPACE, hit end of mesg gap.");
|
|
return kSPACE;
|
|
}
|
|
int16_t correction = (val == kMARK) ? excess : -excess;
|
|
|
|
// Calculate the look-ahead for our current position in the buffer.
|
|
uint16_t avail;
|
|
// Note: We want to match in greedy order as the other way leads to
|
|
// mismatches due to overlaps induced by the correction and tolerance
|
|
// values.
|
|
if (match(width, 3 * bitTime + correction, tolerance, delta)) {
|
|
avail = 3;
|
|
} else if (match(width, 2 * bitTime + correction, tolerance, delta)) {
|
|
avail = 2;
|
|
} else if (match(width, bitTime + correction, tolerance, delta)) {
|
|
avail = 1;
|
|
} else {
|
|
DPRINTLN("DEBUG: getRClevel: Unexpected width. Exiting.");
|
|
return -1; // The width is not what we expected.
|
|
}
|
|
|
|
(*used)++; // Count another one of the avail slots as used.
|
|
if (*used >= avail) { // Are we out of look-ahead/avail slots?
|
|
// Yes, so reset the used counter, and move the offset ahead.
|
|
*used = 0;
|
|
(*offset)++;
|
|
}
|
|
if (val == kMARK) {
|
|
DPRINTLN("DEBUG: getRClevel: MARK");
|
|
} else {
|
|
DPRINTLN("DEBUG: getRClevel: SPACE");
|
|
}
|
|
|
|
return val;
|
|
}
|
|
#endif // (DECODE_RC5 || DECODE_RC6 || DECODE_LASERTAG)
|
|
|
|
#if DECODE_RC5
|
|
// Decode the supplied RC-5/RC5X message.
|
|
//
|
|
// Args:
|
|
// results: Ptr to the data to decode and where to store the decode result.
|
|
// nbits: The number of data bits to expect.
|
|
// strict: Flag indicating if we should perform strict matching.
|
|
// Returns:
|
|
// boolean: True if it can decode it, false if it can't.
|
|
//
|
|
// Status: RC-5 (stable), RC-5X (alpha)
|
|
//
|
|
// Note:
|
|
// The 'toggle' bit is included as the 6th (MSB) address bit, the MSB of data,
|
|
// & in the count of bits decoded.
|
|
// Ref:
|
|
// http://www.sbprojects.com/knowledge/ir/rc5.php
|
|
// https://en.wikipedia.org/wiki/RC-5
|
|
// https://en.wikipedia.org/wiki/Manchester_code
|
|
// TODO(anyone):
|
|
// Serious testing of the RC-5X and strict aspects needs to be done.
|
|
bool IRrecv::decodeRC5(decode_results *results, uint16_t nbits, bool strict) {
|
|
if (results->rawlen < MIN_RC5_SAMPLES + HEADER - 1) return false;
|
|
|
|
// Compliance
|
|
if (strict && nbits != RC5_BITS && nbits != RC5X_BITS)
|
|
return false; // It's neither RC-5 or RC-5X.
|
|
|
|
uint16_t offset = OFFSET_START;
|
|
uint16_t used = 0;
|
|
bool is_rc5x = false;
|
|
uint64_t data = 0;
|
|
|
|
// Header
|
|
// Get start bit #1.
|
|
if (getRClevel(results, &offset, &used, RC5_T1) != kMARK) return false;
|
|
// Get field/start bit #2 (inverted bit-7 of the command if RC-5X protocol)
|
|
uint16_t actual_bits = 1;
|
|
int16_t levelA = getRClevel(results, &offset, &used, RC5_T1);
|
|
int16_t levelB = getRClevel(results, &offset, &used, RC5_T1);
|
|
if (levelA == kSPACE && levelB == kMARK) { // Matched a 1.
|
|
is_rc5x = false;
|
|
} else if (levelA == kMARK && levelB == kSPACE) { // Matched a 0.
|
|
if (nbits <= RC5_BITS) return false; // Field bit must be '1' for RC5.
|
|
is_rc5x = true;
|
|
data = 1;
|
|
} else {
|
|
return false; // Not what we expected.
|
|
}
|
|
|
|
// Data
|
|
for (; offset < results->rawlen; actual_bits++) {
|
|
int16_t levelA = getRClevel(results, &offset, &used, RC5_T1);
|
|
int16_t levelB = getRClevel(results, &offset, &used, RC5_T1);
|
|
if (levelA == kSPACE && levelB == kMARK)
|
|
data = (data << 1) | 1; // 1
|
|
else if (levelA == kMARK && levelB == kSPACE)
|
|
data <<= 1; // 0
|
|
else
|
|
break;
|
|
}
|
|
// Footer (None)
|
|
|
|
// Compliance
|
|
if (actual_bits < nbits) return false; // Less data than we expected.
|
|
if (strict && actual_bits != RC5_BITS &&
|
|
actual_bits != RC5X_BITS) return false;
|
|
|
|
// Success
|
|
results->value = data;
|
|
results->address = (data >> 6) & 0x1F;
|
|
results->command = data & 0x3F;
|
|
results->repeat = false;
|
|
if (is_rc5x) {
|
|
results->decode_type = RC5X;
|
|
results->command |= ((uint32_t) is_rc5x) << 6;
|
|
} else {
|
|
results->decode_type = RC5;
|
|
actual_bits--; // RC5 doesn't count the field bit as data.
|
|
}
|
|
results->bits = actual_bits;
|
|
return true;
|
|
}
|
|
#endif // DECODE_RC5
|
|
|
|
#if DECODE_RC6
|
|
// Decode the supplied RC6 message.
|
|
//
|
|
// Args:
|
|
// results: Ptr to the data to decode and where to store the decode result.
|
|
// nbits: The number of data bits to expect.
|
|
// strict: Flag indicating if we should perform strict matching.
|
|
// Returns:
|
|
// boolean: True if it can decode it, false if it can't.
|
|
//
|
|
// Status: Stable.
|
|
//
|
|
// Ref:
|
|
// http://www.sbprojects.com/knowledge/ir/rc6.php
|
|
// https://en.wikipedia.org/wiki/Manchester_code
|
|
// TODO(anyone):
|
|
// Testing of the strict compliance aspects.
|
|
bool IRrecv::decodeRC6(decode_results *results, uint16_t nbits, bool strict) {
|
|
if (results->rawlen < HEADER + 2 + 4) // Up to the double-wide T bit.
|
|
return false; // Smaller than absolute smallest possible RC6 message.
|
|
|
|
if (strict) { // Compliance
|
|
// Unlike typical protocols, the ability to have mark+space, and space+mark
|
|
// as data bits means it is possible to only have nbits of entries for the
|
|
// data portion, rather than the typically required 2 * nbits.
|
|
// Also due to potential melding with the start bit, we can only count
|
|
// the start bit as 1, instead of a more typical 2 value. The header still
|
|
// remains as normal.
|
|
if (results->rawlen < nbits + HEADER + 1)
|
|
return false; // Don't have enough entries/samples to be valid.
|
|
switch (nbits) {
|
|
case RC6_MODE0_BITS:
|
|
case RC6_36_BITS:
|
|
break;
|
|
default:
|
|
return false; // Asking for the wrong number of bits.
|
|
}
|
|
}
|
|
|
|
uint16_t offset = OFFSET_START;
|
|
|
|
// Header
|
|
if (!matchMark(results->rawbuf[offset], RC6_HDR_MARK)) return false;
|
|
// Calculate how long the common tick time is based on the header mark.
|
|
uint32_t tick = results->rawbuf[offset++] * RAWTICK / RC6_HDR_MARK_TICKS;
|
|
if (!matchSpace(results->rawbuf[offset++], RC6_HDR_SPACE_TICKS * tick))
|
|
return false;
|
|
|
|
uint16_t used = 0;
|
|
|
|
// Get the start bit. e.g. 1.
|
|
if (getRClevel(results, &offset, &used, tick) != kMARK) return false;
|
|
if (getRClevel(results, &offset, &used, tick) != kSPACE) return false;
|
|
|
|
uint16_t actual_bits;
|
|
uint64_t data = 0;
|
|
|
|
// Data (Warning: Here be dragons^Wpointers!!)
|
|
for (actual_bits = 0; offset < results->rawlen; actual_bits++) {
|
|
int16_t levelA, levelB; // Next two levels
|
|
levelA = getRClevel(results, &offset, &used, tick);
|
|
// T bit is double wide; make sure second half matches
|
|
if (actual_bits == 3 &&
|
|
levelA != getRClevel(results, &offset, &used, tick))
|
|
return false;
|
|
levelB = getRClevel(results, &offset, &used, tick);
|
|
// T bit is double wide; make sure second half matches
|
|
if (actual_bits == 3 &&
|
|
levelB != getRClevel(results, &offset, &used, tick))
|
|
return false;
|
|
if (levelA == kMARK && levelB == kSPACE) // reversed compared to RC5
|
|
data = (data << 1) | 1; // 1
|
|
else if (levelA == kSPACE && levelB == kMARK)
|
|
data <<= 1; // 0
|
|
else
|
|
break;
|
|
}
|
|
|
|
// More compliance
|
|
if (strict && actual_bits != nbits)
|
|
return false; // Actual nr. of bits didn't match expected.
|
|
|
|
// Success
|
|
results->decode_type = RC6;
|
|
results->bits = actual_bits;
|
|
results->value = data;
|
|
results->address = data >> 8;
|
|
results->command = data & 0xFF;
|
|
return true;
|
|
}
|
|
#endif // DECODE_RC6
|