132 lines
5.0 KiB
C++
132 lines
5.0 KiB
C++
// Copyright 2015 Kristian Lauszus
|
|
// Copyright 2017 David Conran
|
|
|
|
/// @file
|
|
/// @brief Support for JVC protocols.
|
|
/// Originally added by Kristian Lauszus
|
|
/// Thanks to zenwheel and other people at the original blog post.
|
|
/// @see http://www.sbprojects.com/knowledge/ir/jvc.php
|
|
|
|
// Supports:
|
|
// Brand: JVC, Model: PTU94023B remote
|
|
|
|
#include <algorithm>
|
|
#include "IRrecv.h"
|
|
#include "IRsend.h"
|
|
#include "IRtimer.h"
|
|
#include "IRutils.h"
|
|
|
|
// Constants
|
|
const uint16_t kJvcTick = 75;
|
|
const uint16_t kJvcHdrMarkTicks = 112;
|
|
const uint16_t kJvcHdrMark = kJvcHdrMarkTicks * kJvcTick;
|
|
const uint16_t kJvcHdrSpaceTicks = 56;
|
|
const uint16_t kJvcHdrSpace = kJvcHdrSpaceTicks * kJvcTick;
|
|
const uint16_t kJvcBitMarkTicks = 7;
|
|
const uint16_t kJvcBitMark = kJvcBitMarkTicks * kJvcTick;
|
|
const uint16_t kJvcOneSpaceTicks = 23;
|
|
const uint16_t kJvcOneSpace = kJvcOneSpaceTicks * kJvcTick;
|
|
const uint16_t kJvcZeroSpaceTicks = 7;
|
|
const uint16_t kJvcZeroSpace = kJvcZeroSpaceTicks * kJvcTick;
|
|
const uint16_t kJvcRptLengthTicks = 800;
|
|
const uint16_t kJvcRptLength = kJvcRptLengthTicks * kJvcTick;
|
|
const uint16_t kJvcMinGapTicks =
|
|
kJvcRptLengthTicks -
|
|
(kJvcHdrMarkTicks + kJvcHdrSpaceTicks +
|
|
kJvcBits * (kJvcBitMarkTicks + kJvcOneSpaceTicks) + kJvcBitMarkTicks);
|
|
const uint16_t kJvcMinGap = kJvcMinGapTicks * kJvcTick;
|
|
|
|
#if SEND_JVC
|
|
/// Send a JVC formatted message.
|
|
/// Status: STABLE / Working.
|
|
/// @param[in] data The message to be sent.
|
|
/// @param[in] nbits The number of bits of message to be sent.
|
|
/// @param[in] repeat The number of times the command is to be repeated.
|
|
/// @see http://www.sbprojects.com/knowledge/ir/jvc.php
|
|
void IRsend::sendJVC(uint64_t data, uint16_t nbits, uint16_t repeat) {
|
|
// Set 38kHz IR carrier frequency & a 1/3 (33%) duty cycle.
|
|
enableIROut(38, 33);
|
|
|
|
IRtimer usecs = IRtimer();
|
|
// Header
|
|
// Only sent for the first message.
|
|
mark(kJvcHdrMark);
|
|
space(kJvcHdrSpace);
|
|
|
|
// We always send the data & footer at least once, hence '<= repeat'.
|
|
for (uint16_t i = 0; i <= repeat; i++) {
|
|
sendGeneric(0, 0, // No Header
|
|
kJvcBitMark, kJvcOneSpace, kJvcBitMark, kJvcZeroSpace,
|
|
kJvcBitMark, kJvcMinGap, data, nbits, 38, true,
|
|
0, // Repeats are handles elsewhere.
|
|
33);
|
|
// Wait till the end of the repeat time window before we send another code.
|
|
uint32_t elapsed = usecs.elapsed();
|
|
// Avoid potential unsigned integer underflow.
|
|
// e.g. when elapsed > kJvcRptLength.
|
|
if (elapsed < kJvcRptLength) space(kJvcRptLength - elapsed);
|
|
usecs.reset();
|
|
}
|
|
}
|
|
|
|
/// Calculate the raw JVC data based on address and command.
|
|
/// Status: STABLE / Works fine.
|
|
/// @param[in] address An 8-bit address value.
|
|
/// @param[in] command An 8-bit command value.
|
|
/// @return A raw JVC message code, suitable for sendJVC()..
|
|
/// @see http://www.sbprojects.com/knowledge/ir/jvc.php
|
|
uint16_t IRsend::encodeJVC(uint8_t address, uint8_t command) {
|
|
return reverseBits((command << 8) | address, 16);
|
|
}
|
|
#endif // SEND_JVC
|
|
|
|
#if DECODE_JVC
|
|
/// Decode the supplied JVC message.
|
|
/// Status: Stable / Known working.
|
|
/// @param[in,out] results Ptr to the data to decode & where to store the result
|
|
/// @param[in] offset The starting index to use when attempting to decode the
|
|
/// raw data. Typically/Defaults to kStartOffset.
|
|
/// @param[in] nbits The number of data bits to expect.
|
|
/// @param[in] strict Flag indicating if we should perform strict matching.
|
|
/// @return True if it can decode it, false if it can't.
|
|
/// @note JVC repeat codes don't have a header.
|
|
/// @see http://www.sbprojects.com/knowledge/ir/jvc.php
|
|
bool IRrecv::decodeJVC(decode_results *results, uint16_t offset,
|
|
const uint16_t nbits, const bool strict) {
|
|
if (strict && nbits != kJvcBits)
|
|
return false; // Must be called with the correct nr. of bits.
|
|
if (results->rawlen <= 2 * nbits + kFooter - 1 + offset)
|
|
return false; // Can't possibly be a valid JVC message.
|
|
|
|
uint64_t data = 0;
|
|
bool isRepeat = true;
|
|
|
|
// Header
|
|
// (Optional as repeat codes don't have the header)
|
|
if (matchMark(results->rawbuf[offset], kJvcHdrMark)) {
|
|
isRepeat = false;
|
|
offset++;
|
|
if (results->rawlen < 2 * nbits + 4)
|
|
return false; // Can't possibly be a valid JVC message with a header.
|
|
if (!matchSpace(results->rawbuf[offset++], kJvcHdrSpace)) return false;
|
|
}
|
|
|
|
// Data + Footer
|
|
if (!matchGeneric(results->rawbuf + offset, &data,
|
|
results->rawlen - offset, nbits,
|
|
0, 0,
|
|
kJvcBitMark, kJvcOneSpace,
|
|
kJvcBitMark, kJvcZeroSpace,
|
|
kJvcBitMark, kJvcMinGap, true)) return false;
|
|
// Success
|
|
results->decode_type = JVC;
|
|
results->bits = nbits;
|
|
results->value = data;
|
|
// command & address are transmitted LSB first, so we need to reverse them.
|
|
results->address = reverseBits(data >> 8, 8); // The first 8 bits sent.
|
|
results->command = reverseBits(data & 0xFF, 8); // The last 8 bits sent.
|
|
results->repeat = isRepeat;
|
|
return true;
|
|
}
|
|
#endif // DECODE_JVC
|