144 lines
5.0 KiB
C++
144 lines
5.0 KiB
C++
// Copyright 2009 Ken Shirriff
|
|
// Copyright 2017, 2018 David Conran
|
|
// Copyright 2018 Kamil Palczewski
|
|
|
|
#define __STDC_LIMIT_MACROS
|
|
#include <stdint.h>
|
|
#include <algorithm>
|
|
#include "IRrecv.h"
|
|
#include "IRsend.h"
|
|
#include "IRutils.h"
|
|
#include "ir_NEC.h"
|
|
|
|
// PPPP III OOO N N EEEE EEEE RRRR
|
|
// P P I O O NN N E E R R
|
|
// PPPP I O O N N N EEE EEE RRRR
|
|
// P I O O N NN E E R R
|
|
// P III OOO N N EEEE EEEE R RR
|
|
|
|
// Ref:
|
|
// http://adrian-kingston.com/IRFormatPioneer.htm
|
|
|
|
#if SEND_PIONEER
|
|
// Send a raw Pioneer formatted message.
|
|
//
|
|
// Args:
|
|
// data: The message to be sent.
|
|
// nbits: The number of bits of the message to be sent.
|
|
// Typically kPioneerBits.
|
|
// repeat: The number of times the command is to be repeated.
|
|
//
|
|
// Status: BETA / Expected to be working.
|
|
//
|
|
// Ref:
|
|
// http://adrian-kingston.com/IRFormatPioneer.htm
|
|
void IRsend::sendPioneer(const uint64_t data, const uint16_t nbits,
|
|
const uint16_t repeat) {
|
|
// If nbits is to big, or is odd, abort.
|
|
if (nbits > sizeof(data) * 8 || nbits % 2 == 1) return;
|
|
|
|
// send 1st part of the code
|
|
sendNEC(data >> (nbits / 2), nbits / 2, 0);
|
|
// send 2nd part of the code
|
|
sendNEC(data & (((uint64_t)1 << (nbits / 2)) - 1), nbits / 2, repeat);
|
|
}
|
|
|
|
// Calculate the raw Pioneer data code based on two NEC sub-codes
|
|
// Args:
|
|
// address A 16-bit "published" NEC value.
|
|
// command: A 16-bit "published" NEC value.
|
|
// Returns:
|
|
// A raw 64-bit Pioneer message code.
|
|
//
|
|
// Status: BETA / Expected to work.
|
|
//
|
|
// Note:
|
|
// Address & Command can be take from a decode result OR from the spreadsheets
|
|
// located at:
|
|
// https://www.pioneerelectronics.com/PUSA/Support/Home-Entertainment-Custom-Install/IR+Codes/A+V+Receivers
|
|
// where the first part is considered the address,
|
|
// and the second the command.
|
|
// e.g.
|
|
// "A556+AF20" is an Address of 0xA556 & a Command of 0xAF20.
|
|
uint64_t IRsend::encodePioneer(const uint16_t address, const uint16_t command) {
|
|
return (((uint64_t)encodeNEC(address >> 8, address & 0xFF)) << 32) |
|
|
encodeNEC(command >> 8, command & 0xFF);
|
|
}
|
|
#endif // SEND_PIONEER
|
|
|
|
#if DECODE_PIONEER
|
|
// Decode the supplied Pioneer message.
|
|
//
|
|
// Args:
|
|
// results: Ptr to the data to decode and where to store the decode result.
|
|
// nbits: The number of data bits to expect. Typically kPioneerBits.
|
|
// strict: Flag indicating if we should perform strict matching.
|
|
// Returns:
|
|
// boolean: True if it can decode it, false if it can't.
|
|
//
|
|
// Status: BETA / Should be working. (Self decodes & real examples)
|
|
//
|
|
bool IRrecv::decodePioneer(decode_results *results, const uint16_t nbits,
|
|
const bool strict) {
|
|
if (results->rawlen < 2 * (nbits + kHeader + kFooter) - 1)
|
|
return false; // Can't possibly be a valid Pioneer message.
|
|
if (strict && nbits != kPioneerBits)
|
|
return false; // Not strictly an Pioneer message.
|
|
|
|
uint64_t data = 0;
|
|
uint16_t offset = kStartOffset;
|
|
|
|
for (uint16_t section = 0; section < 2; section++) {
|
|
// Header
|
|
if (!matchMark(results->rawbuf[offset], kNecHdrMark)) return false;
|
|
// Calculate how long the lowest tick time is based on the header mark.
|
|
uint32_t mark_tick =
|
|
results->rawbuf[offset++] * kRawTick / kNecHdrMarkTicks;
|
|
if (!matchSpace(results->rawbuf[offset], kNecHdrSpace)) return false;
|
|
// Calculate how long the common tick time is based on the header space.
|
|
uint32_t space_tick =
|
|
results->rawbuf[offset++] * kRawTick / kNecHdrSpaceTicks;
|
|
//
|
|
// Data
|
|
match_result_t data_result = matchData(
|
|
&(results->rawbuf[offset]), nbits / 2, kNecBitMarkTicks * mark_tick,
|
|
kNecOneSpaceTicks * space_tick, kNecBitMarkTicks * mark_tick,
|
|
kNecZeroSpaceTicks * space_tick);
|
|
if (data_result.success == false) return false;
|
|
uint8_t command = data_result.data >> 8;
|
|
uint8_t command_inverted = data_result.data;
|
|
uint8_t address = data_result.data >> 24;
|
|
uint8_t address_inverted = data_result.data >> 16;
|
|
// Compliance
|
|
if (strict) {
|
|
if (command != (command_inverted ^ 0xFF))
|
|
return false; // Command integrity failed.
|
|
if (address != (address_inverted ^ 0xFF))
|
|
return false; // Address integrity failed.
|
|
}
|
|
data = (data << (nbits / 2)) + data_result.data;
|
|
offset += data_result.used;
|
|
// NEC-like commands and addresses are technically in LSB first order so the
|
|
// final versions have to be reversed.
|
|
uint16_t code = reverseBits((command << 8) + address, 16);
|
|
if (section)
|
|
results->command = code;
|
|
else
|
|
results->address = code;
|
|
|
|
// Footer
|
|
if (!matchMark(results->rawbuf[offset++], kNecBitMarkTicks * mark_tick))
|
|
return false;
|
|
if (offset < results->rawlen &&
|
|
!matchAtLeast(results->rawbuf[offset++], kNecMinGapTicks * space_tick))
|
|
return false;
|
|
}
|
|
|
|
// Success
|
|
results->bits = nbits;
|
|
results->value = data;
|
|
results->decode_type = PIONEER;
|
|
return true;
|
|
}
|
|
#endif // DECODE_PIONEER
|