239 lines
8.9 KiB
C++
239 lines
8.9 KiB
C++
// Copyright 2009 Ken Shirriff
|
|
// Copyright 2016 marcosamarinho
|
|
// Copyright 2017 David Conran
|
|
|
|
#include <algorithm>
|
|
#include "IRrecv.h"
|
|
#include "IRsend.h"
|
|
|
|
// SSSS AAA N N Y Y OOO
|
|
// S A A NN N Y Y O O
|
|
// SSS AAAAA N N N Y O O
|
|
// S A A N NN Y O O
|
|
// SSSS A A N N Y OOO
|
|
|
|
// Sanyo SA 8650B originally added from:
|
|
// https://github.com/shirriff/Arduino-IRremote/
|
|
// Sanyo LC7461 support originally by marcosamarinho
|
|
|
|
// Constants
|
|
// Sanyo SA 8650B
|
|
// Ref:
|
|
// https://github.com/z3t0/Arduino-IRremote/blob/master/ir_Sanyo.cpp
|
|
#define SANYO_SA8650B_HDR_MARK 3500U // seen range 3500
|
|
#define SANYO_SA8650B_HDR_SPACE 950U // seen 950
|
|
#define SANYO_SA8650B_ONE_MARK 2400U // seen 2400
|
|
#define SANYO_SA8650B_ZERO_MARK 700U // seen 700
|
|
// usually see 713 - not using ticks as get number wrapround
|
|
#define SANYO_SA8650B_DOUBLE_SPACE_USECS 800U
|
|
#define SANYO_SA8650B_RPT_LENGTH 45000U
|
|
// Sanyo LC7461
|
|
// Ref:
|
|
// https://github.com/marcosamarinho/IRremoteESP8266/blob/master/ir_Sanyo.cpp
|
|
// http://slydiman.narod.ru/scr/kb/sanyo.htm
|
|
// http://pdf.datasheetcatalog.com/datasheet/sanyo/LC7461.pdf
|
|
#define SANYO_LC7461_ADDRESS_MASK ((1 << SANYO_LC7461_ADDRESS_BITS) - 1)
|
|
#define SANYO_LC7461_COMMAND_MASK ((1 << SANYO_LC7461_COMMAND_BITS) - 1)
|
|
#define SANYO_LC7461_HDR_MARK 9000U
|
|
#define SANYO_LC7461_HDR_SPACE 4500U
|
|
#define SANYO_LC7461_BIT_MARK 560U // 1T
|
|
#define SANYO_LC7461_ONE_SPACE 1690U // 3T
|
|
#define SANYO_LC7461_ZERO_SPACE 560U // 1T
|
|
#define SANYO_LC7461_MIN_COMMAND_LENGTH 108000UL
|
|
#define SANYO_LC7461_MIN_GAP SANYO_LC7461_MIN_COMMAND_LENGTH - \
|
|
(SANYO_LC7461_HDR_MARK + SANYO_LC7461_HDR_SPACE + SANYO_LC7461_BITS * \
|
|
(SANYO_LC7461_BIT_MARK + (SANYO_LC7461_ONE_SPACE + \
|
|
SANYO_LC7461_ZERO_SPACE) / 2) \
|
|
+ SANYO_LC7461_BIT_MARK)
|
|
|
|
#if SEND_SANYO
|
|
// Construct a Sanyo LC7461 message.
|
|
//
|
|
// Args:
|
|
// address: The 13 bit value of the address(Custom) portion of the protocol.
|
|
// command: The 8 bit value of the command(Key) portion of the protocol.
|
|
// Returns:
|
|
// An uint64_t with the encoded raw 42 bit Sanyo LC7461 data value.
|
|
//
|
|
// Notes:
|
|
// This protocol uses the NEC protocol timings. However, data is
|
|
// formatted as : address(13 bits), !address, command(8 bits), !command.
|
|
// According with LIRC, this protocol is used on Sanyo, Aiwa and Chinon
|
|
uint64_t IRsend::encodeSanyoLC7461(uint16_t address, uint8_t command) {
|
|
// Mask our input values to ensure the correct bit sizes.
|
|
address &= SANYO_LC7461_ADDRESS_MASK;
|
|
command &= SANYO_LC7461_COMMAND_MASK;
|
|
|
|
uint64_t data = address;
|
|
address ^= SANYO_LC7461_ADDRESS_MASK; // Invert the 13 LSBs.
|
|
// Append the now inverted address.
|
|
data = (data << SANYO_LC7461_ADDRESS_BITS) | address;
|
|
// Append the command.
|
|
data = (data << SANYO_LC7461_COMMAND_BITS) | command;
|
|
command ^= SANYO_LC7461_COMMAND_MASK; // Invert the command.
|
|
// Append the now inverted command.
|
|
data = (data << SANYO_LC7461_COMMAND_BITS) | command;
|
|
|
|
return data;
|
|
}
|
|
|
|
// Send a Sanyo LC7461 message.
|
|
//
|
|
// Args:
|
|
// data: The contents of the command you want to send.
|
|
// nbits: The bit size of the command being sent.
|
|
// repeat: The number of times you want the command to be repeated.
|
|
//
|
|
// Status: BETA / Probably works.
|
|
//
|
|
// Notes:
|
|
// Based on @marcosamarinho's work.
|
|
// This protocol uses the NEC protocol timings. However, data is
|
|
// formatted as : address(13 bits), !address, command (8 bits), !command.
|
|
// According with LIRC, this protocol is used on Sanyo, Aiwa and Chinon
|
|
// Information for this protocol is available at the Sanyo LC7461 datasheet.
|
|
// Repeats are performed similar to the NEC method of sending a special
|
|
// repeat message, rather than duplicating the entire message.
|
|
// Ref:
|
|
// https://github.com/marcosamarinho/IRremoteESP8266/blob/master/ir_Sanyo.cpp
|
|
// http://pdf.datasheetcatalog.com/datasheet/sanyo/LC7461.pdf
|
|
void IRsend::sendSanyoLC7461(uint64_t data, uint16_t nbits, uint16_t repeat) {
|
|
// This protocol appears to be another 42-bit variant of the NEC protcol.
|
|
sendNEC(data, nbits, repeat);
|
|
}
|
|
#endif // SEND_SANYO
|
|
|
|
#if DECODE_SANYO
|
|
// Decode the supplied SANYO LC7461 message.
|
|
//
|
|
// Args:
|
|
// results: Ptr to the data to decode and where to store the decode result.
|
|
// nbits: Nr. 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: BETA / Probably works.
|
|
//
|
|
// Notes:
|
|
// Based on @marcosamarinho's work.
|
|
// This protocol uses the NEC protocol. However, data is
|
|
// formatted as : address(13 bits), !address, command (8 bits), !command.
|
|
// According with LIRC, this protocol is used on Sanyo, Aiwa and Chinon
|
|
// Information for this protocol is available at the Sanyo LC7461 datasheet.
|
|
// Ref:
|
|
// http://slydiman.narod.ru/scr/kb/sanyo.htm
|
|
// https://github.com/marcosamarinho/IRremoteESP8266/blob/master/ir_Sanyo.cpp
|
|
// http://pdf.datasheetcatalog.com/datasheet/sanyo/LC7461.pdf
|
|
bool IRrecv::decodeSanyoLC7461(decode_results *results, uint16_t nbits,
|
|
bool strict) {
|
|
if (strict && nbits != SANYO_LC7461_BITS)
|
|
return false; // Not strictly in spec.
|
|
// This protocol is basically a 42-bit variant of the NEC protocol.
|
|
if (!decodeNEC(results, nbits, false))
|
|
return false; // Didn't match a NEC format (without strict)
|
|
|
|
// Bits 30 to 42+.
|
|
uint16_t address = results->value >> (SANYO_LC7461_BITS -
|
|
SANYO_LC7461_ADDRESS_BITS);
|
|
// Bits 9 to 16.
|
|
uint8_t command = (results->value >> SANYO_LC7461_COMMAND_BITS) &
|
|
SANYO_LC7461_COMMAND_MASK;
|
|
// Compliance
|
|
if (strict) {
|
|
if (results->bits != nbits)
|
|
return false;
|
|
// Bits 17 to 29.
|
|
uint16_t inverted_address =
|
|
(results->value >> (SANYO_LC7461_COMMAND_BITS * 2)) &
|
|
SANYO_LC7461_ADDRESS_MASK;
|
|
// Bits 1-8.
|
|
uint8_t inverted_command = results->value & SANYO_LC7461_COMMAND_MASK;
|
|
if ((address ^ SANYO_LC7461_ADDRESS_MASK) != inverted_address)
|
|
return false; // Address integrity check failed.
|
|
if ((command ^ SANYO_LC7461_COMMAND_MASK) != inverted_command)
|
|
return false; // Command integrity check failed.
|
|
}
|
|
|
|
// Success
|
|
results->decode_type = SANYO_LC7461;
|
|
results->address = address;
|
|
results->command = command;
|
|
return true;
|
|
}
|
|
|
|
/* NOTE: Disabled due to poor quality.
|
|
// Decode the supplied Sanyo SA 8650B message.
|
|
//
|
|
// Args:
|
|
// results: Ptr to the data to decode and where to store the decode result.
|
|
// nbits: Nr. 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: Depricated.
|
|
//
|
|
// NOTE: This decoder looks like rubbish. Only keeping it for compatibility
|
|
// with the Arduino IRremote library. Seriously, don't trust it.
|
|
// If someone has a device that this is supposed to be for, please log an
|
|
// Issue on github with a rawData dump please. We should probably remove
|
|
// it. We think this is a Sanyo decoder - serial = SA 8650B
|
|
// Ref:
|
|
// https://github.com/z3t0/Arduino-IRremote/blob/master/ir_Sanyo.cpp
|
|
bool IRrecv::decodeSanyo(decode_results *results, uint16_t nbits, bool strict) {
|
|
if (results->rawlen < 2 * nbits + HEADER - 1)
|
|
return false; // Shorter than shortest possible.
|
|
if (strict && nbits != SANYO_SA8650B_BITS)
|
|
return false; // Doesn't match the spec.
|
|
|
|
uint16_t offset = 0;
|
|
|
|
// TODO(crankyoldgit): This repeat code looks like garbage, it should never
|
|
// match or if it does, it won't be reliable. We should probably just
|
|
// remove it.
|
|
if (results->rawbuf[offset++] < SANYO_SA8650B_DOUBLE_SPACE_USECS) {
|
|
results->bits = 0;
|
|
results->value = REPEAT;
|
|
results->decode_type = SANYO;
|
|
results->address = 0;
|
|
results->command = 0;
|
|
results->repeat = true;
|
|
return true;
|
|
}
|
|
|
|
// Header
|
|
if (!matchMark(results->rawbuf[offset++], SANYO_SA8650B_HDR_MARK))
|
|
return false;
|
|
// NOTE: These next two lines look very wrong. Treat as suspect.
|
|
if (!matchMark(results->rawbuf[offset++], SANYO_SA8650B_HDR_MARK))
|
|
return false;
|
|
// Data
|
|
uint64_t data = 0;
|
|
while (offset + 1 < results->rawlen) {
|
|
if (!matchSpace(results->rawbuf[offset], SANYO_SA8650B_HDR_SPACE))
|
|
break;
|
|
offset++;
|
|
if (matchMark(results->rawbuf[offset], SANYO_SA8650B_ONE_MARK))
|
|
data = (data << 1) | 1; // 1
|
|
else if (matchMark(results->rawbuf[offset], SANYO_SA8650B_ZERO_MARK))
|
|
data <<= 1; // 0
|
|
else
|
|
return false;
|
|
offset++;
|
|
}
|
|
|
|
if (strict && SANYO_SA8650B_BITS > (offset - 1U) / 2U)
|
|
return false;
|
|
|
|
// Success
|
|
results->bits = (offset - 1) / 2;
|
|
results->decode_type = SANYO;
|
|
results->value = data;
|
|
results->address = 0;
|
|
results->command = 0;
|
|
return true;
|
|
}
|
|
*/
|
|
#endif // DECODE_SANYO
|