Tasmota/lib/IRremoteESP8266-2.5.2.03/src/ir_RC5_RC6.cpp

525 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
const uint16_t kRc5T1 = 889;
const uint32_t kRc5MinCommandLength = 113778;
const uint32_t kRc5MinGap = kRc5MinCommandLength - kRC5RawBits * (2 * kRc5T1);
const uint16_t kRc5ToggleMask = 0x800; // The 12th bit.
const uint16_t kRc5SamplesMin = 11;
// RC-6
// Ref:
// https://en.wikipedia.org/wiki/RC-6
// http://www.pcbheaven.com/userpages/The_Philips_RC6_Protocol/
const uint16_t kRc6Tick = 444;
const uint16_t kRc6HdrMarkTicks = 6;
const uint16_t kRc6HdrMark = kRc6HdrMarkTicks * kRc6Tick;
const uint16_t kRc6HdrSpaceTicks = 2;
const uint16_t kRc6HdrSpace = kRc6HdrSpaceTicks * kRc6Tick;
const uint16_t kRc6RptLengthTicks = 187;
const uint32_t kRc6RptLength = kRc6RptLengthTicks * kRc6Tick;
const uint32_t kRc6ToggleMask = 0x10000UL; // The 17th bit.
const uint16_t kRc6_36ToggleMask = 0x8000; // 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 >= kRC5XBits) { // 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(kRc5T1);
mark(kRc5T1);
// Field/Second start bit.
if (field_bit) { // Send a 1. Normal for RC-5.
space(kRc5T1);
mark(kRc5T1);
} else { // Send a 0. Special case for RC-5X. Means 7th command bit is 1.
mark(kRc5T1);
space(kRc5T1);
}
// Data
for (uint64_t mask = 1ULL << (nbits - 1); mask; mask >>= 1)
if (data & mask) { // 1
space(kRc5T1); // 1 is space, then mark.
mark(kRc5T1);
} else { // 0
mark(kRc5T1); // 0 is mark, then space.
space(kRc5T1);
}
// Footer
space(std::max(kRc5MinGap, kRc5MinCommandLength - 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 << (kRC5Bits - 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 << (kRC5XBits - 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 ^ kRc5ToggleMask; }
#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 == kRC6_36Bits) return data ^ kRc6_36ToggleMask;
return data ^ kRc6ToggleMask;
}
// 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 kRC6Mode0Bits:
return ((address & 0xFFF) << 8) | (command & 0xFF);
case kRC6_36Bits:
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(kRc6HdrMark);
space(kRc6HdrSpace);
// Start bit.
mark(kRc6Tick); // mark, then space == 0x1.
space(kRc6Tick);
// 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 * kRc6Tick; // double-wide trailer bit
else
bitTime = kRc6Tick; // Normal bit
if (data & mask) { // 1
mark(bitTime);
space(bitTime);
} else { // 0
space(bitTime);
mark(bitTime);
}
}
// Footer
space(kRc6RptLength);
}
}
#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.
// maxwidth: Maximum number of successive levels to find in a single level
// (default 3)
// 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, uint8_t maxwidth) {
DPRINT("DEBUG: getRClevel: offset = ");
DPRINTLN(uint64ToString(*offset));
DPRINT("DEBUG: getRClevel: rawlen = ");
DPRINTLN(uint64ToString(results->rawlen));
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 || width > maxwidth * bitTime + 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.
for (avail = maxwidth; avail > 0; avail--) {
if (match(width, avail * bitTime + correction, tolerance, delta)) {
break;
}
}
if (!avail) {
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 < kRc5SamplesMin + kHeader - 1) return false;
// Compliance
if (strict && nbits != kRC5Bits && nbits != kRC5XBits)
return false; // It's neither RC-5 or RC-5X.
uint16_t offset = kStartOffset;
uint16_t used = 0;
bool is_rc5x = false;
uint64_t data = 0;
// Header
// Get start bit #1.
if (getRClevel(results, &offset, &used, kRc5T1) != 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, kRc5T1);
int16_t levelB = getRClevel(results, &offset, &used, kRc5T1);
if (levelA == kSpace && levelB == kMark) { // Matched a 1.
is_rc5x = false;
} else if (levelA == kMark && levelB == kSpace) { // Matched a 0.
if (nbits <= kRC5Bits) 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, kRc5T1);
int16_t levelB = getRClevel(results, &offset, &used, kRc5T1);
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 != kRC5Bits && actual_bits != kRC5XBits)
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 < kHeader + 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 + kHeader + 1)
return false; // Don't have enough entries/samples to be valid.
switch (nbits) {
case kRC6Mode0Bits:
case kRC6_36Bits:
break;
default:
return false; // Asking for the wrong number of bits.
}
}
uint16_t offset = kStartOffset;
// Header
if (!matchMark(results->rawbuf[offset], kRc6HdrMark)) return false;
// Calculate how long the common tick time is based on the header mark.
uint32_t tick = results->rawbuf[offset++] * kRawTick / kRc6HdrMarkTicks;
if (!matchSpace(results->rawbuf[offset++], kRc6HdrSpaceTicks * 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