962 lines
31 KiB
C++
962 lines
31 KiB
C++
// Copyright 2015 Kristian Lauszus
|
|
// Copyright 2017, 2018 David Conran
|
|
|
|
#include "ir_Panasonic.h"
|
|
#include <algorithm>
|
|
#ifndef ARDUINO
|
|
#include <string>
|
|
#endif
|
|
#include "IRrecv.h"
|
|
#include "IRsend.h"
|
|
#include "IRutils.h"
|
|
|
|
// PPPP AAA N N AAA SSSS OOO N N IIIII CCCC
|
|
// P P A A NN N A A S O O NN N I C
|
|
// PPPP AAAAA N N N AAAAA SSS O O N N N I C
|
|
// P A A N NN A A S O O N NN I C
|
|
// P A A N N A A SSSS OOO N N IIIII CCCC
|
|
|
|
// Panasonic protocol originally added by Kristian Lauszus from:
|
|
// https://github.com/z3t0/Arduino-IRremote
|
|
// (Thanks to zenwheel and other people at the original blog post)
|
|
//
|
|
// Panasonic A/C support add by crankyoldgit but heavily influenced by:
|
|
// https://github.com/ToniA/ESPEasy/blob/HeatpumpIR/lib/HeatpumpIR/PanasonicHeatpumpIR.cpp
|
|
// Panasonic A/C Clock & Timer support:
|
|
// Reverse Engineering by MikkelTb
|
|
// Code by crankyoldgit
|
|
// Panasonic A/C models supported:
|
|
// A/C Series/models:
|
|
// JKE, LKE, DKE, CKP, RKR, & NKE series. (In theory)
|
|
// CS-YW9MKD, CS-Z9RKR (confirmed)
|
|
// CS-ME14CKPG / CS-ME12CKPG / CS-ME10CKPG
|
|
// A/C Remotes:
|
|
// A75C3747 (confirmed)
|
|
// A75C3704
|
|
// A75C2311 (CKP)
|
|
|
|
// Constants
|
|
// Ref:
|
|
// http://www.remotecentral.com/cgi-bin/mboard/rc-pronto/thread.cgi?26152
|
|
|
|
const uint16_t kPanasonicTick = 432;
|
|
const uint16_t kPanasonicHdrMarkTicks = 8;
|
|
const uint16_t kPanasonicHdrMark = kPanasonicHdrMarkTicks * kPanasonicTick;
|
|
const uint16_t kPanasonicHdrSpaceTicks = 4;
|
|
const uint16_t kPanasonicHdrSpace = kPanasonicHdrSpaceTicks * kPanasonicTick;
|
|
const uint16_t kPanasonicBitMarkTicks = 1;
|
|
const uint16_t kPanasonicBitMark = kPanasonicBitMarkTicks * kPanasonicTick;
|
|
const uint16_t kPanasonicOneSpaceTicks = 3;
|
|
const uint16_t kPanasonicOneSpace = kPanasonicOneSpaceTicks * kPanasonicTick;
|
|
const uint16_t kPanasonicZeroSpaceTicks = 1;
|
|
const uint16_t kPanasonicZeroSpace = kPanasonicZeroSpaceTicks * kPanasonicTick;
|
|
const uint16_t kPanasonicMinCommandLengthTicks = 378;
|
|
const uint32_t kPanasonicMinCommandLength =
|
|
kPanasonicMinCommandLengthTicks * kPanasonicTick;
|
|
const uint16_t kPanasonicEndGap = 5000; // See issue #245
|
|
const uint16_t kPanasonicMinGapTicks =
|
|
kPanasonicMinCommandLengthTicks -
|
|
(kPanasonicHdrMarkTicks + kPanasonicHdrSpaceTicks +
|
|
kPanasonicBits * (kPanasonicBitMarkTicks + kPanasonicOneSpaceTicks) +
|
|
kPanasonicBitMarkTicks);
|
|
const uint32_t kPanasonicMinGap = kPanasonicMinGapTicks * kPanasonicTick;
|
|
|
|
const uint16_t kPanasonicAcSectionGap = 10000;
|
|
const uint16_t kPanasonicAcSection1Length = 8;
|
|
const uint32_t kPanasonicAcMessageGap = kDefaultMessageGap; // Just a guess.
|
|
|
|
#if (SEND_PANASONIC || SEND_DENON)
|
|
// Send a Panasonic formatted message.
|
|
//
|
|
// Args:
|
|
// data: The message to be sent.
|
|
// nbits: The number of bits of the message to be sent. (kPanasonicBits).
|
|
// repeat: The number of times the command is to be repeated.
|
|
//
|
|
// Status: BETA / Should be working.
|
|
//
|
|
// Note:
|
|
// This protocol is a modified version of Kaseikyo.
|
|
void IRsend::sendPanasonic64(uint64_t data, uint16_t nbits, uint16_t repeat) {
|
|
sendGeneric(kPanasonicHdrMark, kPanasonicHdrSpace, kPanasonicBitMark,
|
|
kPanasonicOneSpace, kPanasonicBitMark, kPanasonicZeroSpace,
|
|
kPanasonicBitMark, kPanasonicMinGap, kPanasonicMinCommandLength,
|
|
data, nbits, kPanasonicFreq, true, repeat, 50);
|
|
}
|
|
|
|
// Send a Panasonic formatted message.
|
|
//
|
|
// Args:
|
|
// address: The manufacturer code.
|
|
// data: The data portion to be sent.
|
|
// nbits: The number of bits of the message to be sent. (kPanasonicBits).
|
|
// repeat: The number of times the command is to be repeated.
|
|
//
|
|
// Status: STABLE.
|
|
//
|
|
// Note:
|
|
// This protocol is a modified version of Kaseikyo.
|
|
void IRsend::sendPanasonic(uint16_t address, uint32_t data, uint16_t nbits,
|
|
uint16_t repeat) {
|
|
sendPanasonic64(((uint64_t)address << 32) | (uint64_t)data, nbits, repeat);
|
|
}
|
|
|
|
// Calculate the raw Panasonic data based on device, subdevice, & function.
|
|
//
|
|
// Args:
|
|
// manufacturer: A 16-bit manufacturer code. e.g. 0x4004 is Panasonic.
|
|
// device: An 8-bit code.
|
|
// subdevice: An 8-bit code.
|
|
// function: An 8-bit code.
|
|
// Returns:
|
|
// A raw uint64_t Panasonic message.
|
|
//
|
|
// Status: BETA / Should be working..
|
|
//
|
|
// Note:
|
|
// Panasonic 48-bit protocol is a modified version of Kaseikyo.
|
|
// Ref:
|
|
// http://www.remotecentral.com/cgi-bin/mboard/rc-pronto/thread.cgi?2615
|
|
uint64_t IRsend::encodePanasonic(uint16_t manufacturer, uint8_t device,
|
|
uint8_t subdevice, uint8_t function) {
|
|
uint8_t checksum = device ^ subdevice ^ function;
|
|
return (((uint64_t)manufacturer << 32) | ((uint64_t)device << 24) |
|
|
((uint64_t)subdevice << 16) | ((uint64_t)function << 8) | checksum);
|
|
}
|
|
#endif // (SEND_PANASONIC || SEND_DENON)
|
|
|
|
#if (DECODE_PANASONIC || DECODE_DENON)
|
|
// Decode the supplied Panasonic 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 / Should be working.
|
|
// Note:
|
|
// Panasonic 48-bit protocol is a modified version of Kaseikyo.
|
|
// Ref:
|
|
// http://www.remotecentral.com/cgi-bin/mboard/rc-pronto/thread.cgi?26152
|
|
// http://www.hifi-remote.com/wiki/index.php?title=Panasonic
|
|
bool IRrecv::decodePanasonic(decode_results *results, uint16_t nbits,
|
|
bool strict, uint32_t manufacturer) {
|
|
if (results->rawlen < 2 * nbits + kHeader + kFooter - 1)
|
|
return false; // Not enough entries to be a Panasonic message.
|
|
if (strict && nbits != kPanasonicBits)
|
|
return false; // Request is out of spec.
|
|
|
|
uint64_t data = 0;
|
|
uint16_t offset = kStartOffset;
|
|
|
|
// Header
|
|
if (!matchMark(results->rawbuf[offset], kPanasonicHdrMark)) return false;
|
|
// Calculate how long the common tick time is based on the header mark.
|
|
uint32_t m_tick =
|
|
results->rawbuf[offset++] * kRawTick / kPanasonicHdrMarkTicks;
|
|
if (!matchSpace(results->rawbuf[offset], kPanasonicHdrSpace)) return false;
|
|
// Calculate how long the common tick time is based on the header space.
|
|
uint32_t s_tick =
|
|
results->rawbuf[offset++] * kRawTick / kPanasonicHdrSpaceTicks;
|
|
|
|
// Data
|
|
match_result_t data_result = matchData(
|
|
&(results->rawbuf[offset]), nbits, kPanasonicBitMarkTicks * m_tick,
|
|
kPanasonicOneSpaceTicks * s_tick, kPanasonicBitMarkTicks * m_tick,
|
|
kPanasonicZeroSpaceTicks * s_tick);
|
|
if (data_result.success == false) return false;
|
|
data = data_result.data;
|
|
offset += data_result.used;
|
|
|
|
// Footer
|
|
if (!match(results->rawbuf[offset++], kPanasonicBitMarkTicks * m_tick))
|
|
return false;
|
|
if (offset < results->rawlen &&
|
|
!matchAtLeast(results->rawbuf[offset], kPanasonicEndGap))
|
|
return false;
|
|
|
|
// Compliance
|
|
uint32_t address = data >> 32;
|
|
uint32_t command = data & 0xFFFFFFFF;
|
|
if (strict) {
|
|
if (address != manufacturer) // Verify the Manufacturer code.
|
|
return false;
|
|
// Verify the checksum.
|
|
uint8_t checksumOrig = data & 0xFF;
|
|
uint8_t checksumCalc = ((data >> 24) ^ (data >> 16) ^ (data >> 8)) & 0xFF;
|
|
if (checksumOrig != checksumCalc) return false;
|
|
}
|
|
|
|
// Success
|
|
results->value = data;
|
|
results->address = address;
|
|
results->command = command;
|
|
results->decode_type = PANASONIC;
|
|
results->bits = nbits;
|
|
return true;
|
|
}
|
|
#endif // (DECODE_PANASONIC || DECODE_DENON)
|
|
|
|
#if SEND_PANASONIC_AC
|
|
// Send a Panasonic A/C message.
|
|
//
|
|
// Args:
|
|
// data: Contents of the message to be sent. (Guessing MSBF order)
|
|
// nbits: Nr. of bits of data to be sent. Typically kPanasonicAcBits.
|
|
// repeat: Nr. of additional times the message is to be sent.
|
|
//
|
|
// Status: Beta / Appears to work with real device(s).
|
|
//:
|
|
// Panasonic A/C models supported:
|
|
// A/C Series/models:
|
|
// JKE, LKE, DKE, CKP, RKR, & NKE series.
|
|
// CS-YW9MKD
|
|
// A/C Remotes:
|
|
// A75C3747
|
|
// A75C3704
|
|
//
|
|
void IRsend::sendPanasonicAC(uint8_t data[], uint16_t nbytes, uint16_t repeat) {
|
|
if (nbytes < kPanasonicAcSection1Length) return;
|
|
for (uint16_t r = 0; r <= repeat; r++) {
|
|
// First section. (8 bytes)
|
|
sendGeneric(kPanasonicHdrMark, kPanasonicHdrSpace, kPanasonicBitMark,
|
|
kPanasonicOneSpace, kPanasonicBitMark, kPanasonicZeroSpace,
|
|
kPanasonicBitMark, kPanasonicAcSectionGap, data,
|
|
kPanasonicAcSection1Length, kPanasonicFreq, false, 0, 50);
|
|
// First section. (The rest of the data bytes)
|
|
sendGeneric(kPanasonicHdrMark, kPanasonicHdrSpace, kPanasonicBitMark,
|
|
kPanasonicOneSpace, kPanasonicBitMark, kPanasonicZeroSpace,
|
|
kPanasonicBitMark, kPanasonicAcMessageGap,
|
|
data + kPanasonicAcSection1Length,
|
|
nbytes - kPanasonicAcSection1Length, kPanasonicFreq, false, 0,
|
|
50);
|
|
}
|
|
}
|
|
#endif // SEND_PANASONIC_AC
|
|
|
|
IRPanasonicAc::IRPanasonicAc(uint16_t pin) : _irsend(pin) { stateReset(); }
|
|
|
|
void IRPanasonicAc::stateReset() {
|
|
for (uint8_t i = 0; i < kPanasonicAcStateLength; i++)
|
|
remote_state[i] = kPanasonicKnownGoodState[i];
|
|
_temp = 25; // An initial saved desired temp. Completely made up.
|
|
_swingh = kPanasonicAcSwingHMiddle; // A similar made up value for H Swing.
|
|
}
|
|
|
|
void IRPanasonicAc::begin() { _irsend.begin(); }
|
|
|
|
// Verify the checksum is valid for a given state.
|
|
// Args:
|
|
// state: The array to verify the checksum of.
|
|
// length: The size of the state.
|
|
// Returns:
|
|
// A boolean.
|
|
bool IRPanasonicAc::validChecksum(uint8_t state[], const uint16_t length) {
|
|
if (length < 2) return false; // 1 byte of data can't have a checksum.
|
|
return (state[length - 1] ==
|
|
sumBytes(state, length - 1, kPanasonicAcChecksumInit));
|
|
}
|
|
|
|
uint8_t IRPanasonicAc::calcChecksum(uint8_t state[], const uint16_t length) {
|
|
return sumBytes(state, length - 1, kPanasonicAcChecksumInit);
|
|
}
|
|
|
|
void IRPanasonicAc::fixChecksum(const uint16_t length) {
|
|
remote_state[length - 1] = calcChecksum(remote_state, length);
|
|
}
|
|
|
|
#if SEND_PANASONIC_AC
|
|
void IRPanasonicAc::send(const uint16_t repeat) {
|
|
fixChecksum();
|
|
_irsend.sendPanasonicAC(remote_state, kPanasonicAcStateLength, repeat);
|
|
}
|
|
#endif // SEND_PANASONIC_AC
|
|
|
|
void IRPanasonicAc::setModel(const panasonic_ac_remote_model_t model) {
|
|
switch (model) {
|
|
case kPanasonicDke:
|
|
case kPanasonicJke:
|
|
case kPanasonicLke:
|
|
case kPanasonicNke:
|
|
case kPanasonicCkp:
|
|
case kPanasonicRkr:
|
|
break;
|
|
default: // Only proceed if we know what to do.
|
|
return;
|
|
}
|
|
// clear & set the various bits and bytes.
|
|
remote_state[13] &= 0xF0;
|
|
remote_state[17] = 0x00;
|
|
remote_state[21] &= 0b11101111;
|
|
remote_state[23] = 0x81;
|
|
remote_state[25] = 0x00;
|
|
|
|
switch (model) {
|
|
case kPanasonicLke:
|
|
remote_state[13] |= 0x02;
|
|
remote_state[17] = 0x06;
|
|
break;
|
|
case kPanasonicDke:
|
|
remote_state[23] = 0x01;
|
|
remote_state[25] = 0x06;
|
|
// Has to be done last as setSwingHorizontal has model check built-in
|
|
setSwingHorizontal(_swingh);
|
|
break;
|
|
case kPanasonicNke:
|
|
remote_state[17] = 0x06;
|
|
break;
|
|
case kPanasonicJke:
|
|
break;
|
|
case kPanasonicCkp:
|
|
remote_state[21] |= 0x10;
|
|
remote_state[23] = 0x01;
|
|
break;
|
|
case kPanasonicRkr:
|
|
remote_state[13] |= 0x08;
|
|
remote_state[23] = 0x89;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
panasonic_ac_remote_model_t IRPanasonicAc::getModel() {
|
|
if (remote_state[23] == 0x89) return kPanasonicRkr;
|
|
if (remote_state[17] == 0x00) {
|
|
if ((remote_state[21] & 0x10) && (remote_state[23] & 0x01))
|
|
return kPanasonicCkp;
|
|
if (remote_state[23] & 0x80) return kPanasonicJke;
|
|
}
|
|
if (remote_state[17] == 0x06 && (remote_state[13] & 0x0F) == 0x02)
|
|
return kPanasonicLke;
|
|
if (remote_state[23] == 0x01) return kPanasonicDke;
|
|
if (remote_state[17] == 0x06) return kPanasonicNke;
|
|
return kPanasonicUnknown;
|
|
}
|
|
|
|
uint8_t *IRPanasonicAc::getRaw() {
|
|
fixChecksum();
|
|
return remote_state;
|
|
}
|
|
|
|
void IRPanasonicAc::setRaw(const uint8_t state[]) {
|
|
for (uint8_t i = 0; i < kPanasonicAcStateLength; i++) {
|
|
remote_state[i] = state[i];
|
|
}
|
|
}
|
|
|
|
// Control the power state of the A/C unit.
|
|
//
|
|
// For CKP models, the remote has no memory of the power state the A/C unit
|
|
// should be in. For those models setting this on/true will toggle the power
|
|
// state of the Panasonic A/C unit with the next meessage.
|
|
// e.g. If the A/C unit is already on, setPower(true) will turn it off.
|
|
// If the A/C unit is already off, setPower(true) will turn it on.
|
|
// setPower(false) will leave the A/C power state as it was.
|
|
//
|
|
// For all other models, setPower(true) should set the internal state to
|
|
// turn it on, and setPower(false) should turn it off.
|
|
void IRPanasonicAc::setPower(const bool state) {
|
|
if (state)
|
|
on();
|
|
else
|
|
off();
|
|
}
|
|
|
|
// Return the A/C power state of the remote.
|
|
// Except for CKP models, where it returns if the power state will be toggled
|
|
// on the A/C unit when the next message is sent.
|
|
bool IRPanasonicAc::getPower() {
|
|
return (remote_state[13] & kPanasonicAcPower) == kPanasonicAcPower;
|
|
}
|
|
|
|
void IRPanasonicAc::on() { remote_state[13] |= kPanasonicAcPower; }
|
|
|
|
void IRPanasonicAc::off() { remote_state[13] &= ~kPanasonicAcPower; }
|
|
|
|
uint8_t IRPanasonicAc::getMode() { return remote_state[13] >> 4; }
|
|
|
|
void IRPanasonicAc::setMode(const uint8_t desired) {
|
|
uint8_t mode = kPanasonicAcAuto; // Default to Auto mode.
|
|
switch (desired) {
|
|
case kPanasonicAcFan:
|
|
// Allegedly Fan mode has a temperature of 27.
|
|
setTemp(kPanasonicAcFanModeTemp, false);
|
|
mode = desired;
|
|
break;
|
|
case kPanasonicAcAuto:
|
|
case kPanasonicAcCool:
|
|
case kPanasonicAcHeat:
|
|
case kPanasonicAcDry:
|
|
mode = desired;
|
|
// Set the temp to the saved temp, just incase our previous mode was Fan.
|
|
setTemp(_temp);
|
|
break;
|
|
}
|
|
remote_state[13] &= 0x0F; // Clear the previous mode bits.
|
|
remote_state[13] |= mode << 4;
|
|
}
|
|
|
|
uint8_t IRPanasonicAc::getTemp() { return remote_state[14] >> 1; }
|
|
|
|
// Set the desitred temperature in Celcius.
|
|
// Args:
|
|
// celsius: The temperature to set the A/C unit to.
|
|
// remember: A boolean flag for the class to remember the temperature.
|
|
//
|
|
// Automatically safely limits the temp to the operating range supported.
|
|
void IRPanasonicAc::setTemp(const uint8_t celsius, const bool remember) {
|
|
uint8_t temperature;
|
|
temperature = std::max(celsius, kPanasonicAcMinTemp);
|
|
temperature = std::min(temperature, kPanasonicAcMaxTemp);
|
|
remote_state[14] = temperature << 1;
|
|
if (remember) _temp = temperature;
|
|
}
|
|
|
|
uint8_t IRPanasonicAc::getSwingVertical() { return remote_state[16] & 0x0F; }
|
|
|
|
void IRPanasonicAc::setSwingVertical(const uint8_t desired_elevation) {
|
|
uint8_t elevation = desired_elevation;
|
|
if (elevation != kPanasonicAcSwingVAuto) {
|
|
elevation = std::max(elevation, kPanasonicAcSwingVUp);
|
|
elevation = std::min(elevation, kPanasonicAcSwingVDown);
|
|
}
|
|
remote_state[16] &= 0xF0;
|
|
remote_state[16] |= elevation;
|
|
}
|
|
|
|
uint8_t IRPanasonicAc::getSwingHorizontal() { return remote_state[17]; }
|
|
|
|
void IRPanasonicAc::setSwingHorizontal(const uint8_t desired_direction) {
|
|
switch (desired_direction) {
|
|
case kPanasonicAcSwingHAuto:
|
|
case kPanasonicAcSwingHMiddle:
|
|
case kPanasonicAcSwingHFullLeft:
|
|
case kPanasonicAcSwingHLeft:
|
|
case kPanasonicAcSwingHRight:
|
|
case kPanasonicAcSwingHFullRight:
|
|
break;
|
|
default: // Ignore anything that isn't valid.
|
|
return;
|
|
}
|
|
_swingh = desired_direction; // Store the direction for later.
|
|
uint8_t direction = desired_direction;
|
|
switch (getModel()) {
|
|
case kPanasonicDke:
|
|
case kPanasonicRkr:
|
|
break;
|
|
case kPanasonicNke:
|
|
case kPanasonicLke:
|
|
direction = kPanasonicAcSwingHMiddle;
|
|
break;
|
|
default: // Ignore everything else.
|
|
return;
|
|
}
|
|
remote_state[17] = direction;
|
|
}
|
|
|
|
void IRPanasonicAc::setFan(const uint8_t speed) {
|
|
if (speed <= kPanasonicAcFanMax || speed == kPanasonicAcFanAuto)
|
|
remote_state[16] =
|
|
(remote_state[16] & 0x0F) | ((speed + kPanasonicAcFanOffset) << 4);
|
|
}
|
|
|
|
uint8_t IRPanasonicAc::getFan() {
|
|
return (remote_state[16] >> 4) - kPanasonicAcFanOffset;
|
|
}
|
|
|
|
bool IRPanasonicAc::getQuiet() {
|
|
switch (getModel()) {
|
|
case kPanasonicRkr:
|
|
case kPanasonicCkp:
|
|
return remote_state[21] & kPanasonicAcQuietCkp;
|
|
default:
|
|
return remote_state[21] & kPanasonicAcQuiet;
|
|
}
|
|
}
|
|
|
|
void IRPanasonicAc::setQuiet(const bool state) {
|
|
uint8_t quiet;
|
|
switch (getModel()) {
|
|
case kPanasonicRkr:
|
|
case kPanasonicCkp:
|
|
quiet = kPanasonicAcQuietCkp;
|
|
break;
|
|
default:
|
|
quiet = kPanasonicAcQuiet;
|
|
}
|
|
|
|
if (state) {
|
|
setPowerful(false); // Powerful is mutually exclusive.
|
|
remote_state[21] |= quiet;
|
|
} else {
|
|
remote_state[21] &= ~quiet;
|
|
}
|
|
}
|
|
|
|
bool IRPanasonicAc::getPowerful() {
|
|
switch (getModel()) {
|
|
case kPanasonicRkr:
|
|
case kPanasonicCkp:
|
|
return remote_state[21] & kPanasonicAcPowerfulCkp;
|
|
default:
|
|
return remote_state[21] & kPanasonicAcPowerful;
|
|
}
|
|
}
|
|
|
|
void IRPanasonicAc::setPowerful(const bool state) {
|
|
uint8_t powerful;
|
|
switch (getModel()) {
|
|
case kPanasonicRkr:
|
|
case kPanasonicCkp:
|
|
powerful = kPanasonicAcPowerfulCkp;
|
|
break;
|
|
default:
|
|
powerful = kPanasonicAcPowerful;
|
|
}
|
|
|
|
if (state) {
|
|
setQuiet(false); // Quiet is mutually exclusive.
|
|
remote_state[21] |= powerful;
|
|
} else {
|
|
remote_state[21] &= ~powerful;
|
|
}
|
|
}
|
|
|
|
uint16_t IRPanasonicAc::encodeTime(const uint8_t hours, const uint8_t mins) {
|
|
return std::min(hours, (uint8_t)23) * 60 + std::min(mins, (uint8_t)59);
|
|
}
|
|
|
|
uint16_t IRPanasonicAc::getClock() {
|
|
uint16_t result = ((remote_state[25] & 0b00000111) << 8) + remote_state[24];
|
|
if (result == kPanasonicAcTimeSpecial) return 0;
|
|
return result;
|
|
}
|
|
|
|
void IRPanasonicAc::setClock(const uint16_t mins_since_midnight) {
|
|
uint16_t corrected = std::min(mins_since_midnight, kPanasonicAcTimeMax);
|
|
if (mins_since_midnight == kPanasonicAcTimeSpecial)
|
|
corrected = kPanasonicAcTimeSpecial;
|
|
remote_state[24] = corrected & 0xFF;
|
|
remote_state[25] &= 0b11111000;
|
|
remote_state[25] |= (corrected >> 8);
|
|
}
|
|
|
|
uint16_t IRPanasonicAc::getOnTimer() {
|
|
uint16_t result = ((remote_state[19] & 0b00000111) << 8) + remote_state[18];
|
|
if (result == kPanasonicAcTimeSpecial) return 0;
|
|
return result;
|
|
}
|
|
|
|
void IRPanasonicAc::setOnTimer(const uint16_t mins_since_midnight,
|
|
const bool enable) {
|
|
// Ensure it's on a 10 minute boundary and no overflow.
|
|
uint16_t corrected = std::min(mins_since_midnight, kPanasonicAcTimeMax);
|
|
corrected -= corrected % 10;
|
|
if (mins_since_midnight == kPanasonicAcTimeSpecial)
|
|
corrected = kPanasonicAcTimeSpecial;
|
|
|
|
if (enable)
|
|
remote_state[13] |= kPanasonicAcOnTimer; // Set the Ontimer flag.
|
|
else
|
|
remote_state[13] &= ~kPanasonicAcOnTimer; // Clear the Ontimer flag.
|
|
// Store the time.
|
|
remote_state[18] = corrected & 0xFF;
|
|
remote_state[19] &= 0b11111000;
|
|
remote_state[19] |= (corrected >> 8);
|
|
}
|
|
|
|
void IRPanasonicAc::cancelOnTimer() { setOnTimer(0, false); }
|
|
|
|
bool IRPanasonicAc::isOnTimerEnabled() {
|
|
return remote_state[13] & kPanasonicAcOnTimer;
|
|
}
|
|
|
|
uint16_t IRPanasonicAc::getOffTimer() {
|
|
uint16_t result =
|
|
((remote_state[20] & 0b01111111) << 4) + (remote_state[19] >> 4);
|
|
if (result == kPanasonicAcTimeSpecial) return 0;
|
|
return result;
|
|
}
|
|
|
|
void IRPanasonicAc::setOffTimer(const uint16_t mins_since_midnight,
|
|
const bool enable) {
|
|
// Ensure its on a 10 minute boundary and no overflow.
|
|
uint16_t corrected = std::min(mins_since_midnight, kPanasonicAcTimeMax);
|
|
corrected -= corrected % 10;
|
|
if (mins_since_midnight == kPanasonicAcTimeSpecial)
|
|
corrected = kPanasonicAcTimeSpecial;
|
|
|
|
if (enable)
|
|
remote_state[13] |= kPanasonicAcOffTimer; // Set the OffTimer flag.
|
|
else
|
|
remote_state[13] &= ~kPanasonicAcOffTimer; // Clear the OffTimer flag.
|
|
// Store the time.
|
|
remote_state[19] &= 0b00001111;
|
|
remote_state[19] |= (corrected & 0b00001111) << 4;
|
|
remote_state[20] &= 0b10000000;
|
|
remote_state[20] |= corrected >> 4;
|
|
}
|
|
|
|
void IRPanasonicAc::cancelOffTimer() { setOffTimer(0, false); }
|
|
|
|
bool IRPanasonicAc::isOffTimerEnabled() {
|
|
return remote_state[13] & kPanasonicAcOffTimer;
|
|
}
|
|
|
|
#ifdef ARDUINO
|
|
String IRPanasonicAc::timeToString(const uint16_t mins_since_midnight) {
|
|
String result = "";
|
|
#else
|
|
std::string IRPanasonicAc::timeToString(const uint16_t mins_since_midnight) {
|
|
std::string result = "";
|
|
#endif // ARDUINO
|
|
result += uint64ToString(mins_since_midnight / 60) + ':';
|
|
uint8_t mins = mins_since_midnight % 60;
|
|
if (mins < 10) result += '0'; // Zero pad the minutes.
|
|
return result + uint64ToString(mins);
|
|
}
|
|
|
|
// Convert a standard A/C mode into its native mode.
|
|
uint8_t IRPanasonicAc::convertMode(const stdAc::opmode_t mode) {
|
|
switch (mode) {
|
|
case stdAc::opmode_t::kCool:
|
|
return kPanasonicAcCool;
|
|
case stdAc::opmode_t::kHeat:
|
|
return kPanasonicAcHeat;
|
|
case stdAc::opmode_t::kDry:
|
|
return kPanasonicAcDry;
|
|
case stdAc::opmode_t::kFan:
|
|
return kPanasonicAcFan;
|
|
default:
|
|
return kPanasonicAcAuto;
|
|
}
|
|
}
|
|
|
|
// Convert a standard A/C Fan speed into its native fan speed.
|
|
uint8_t IRPanasonicAc::convertFan(const stdAc::fanspeed_t speed) {
|
|
switch (speed) {
|
|
case stdAc::fanspeed_t::kMin:
|
|
return kPanasonicAcFanMin;
|
|
case stdAc::fanspeed_t::kLow:
|
|
return kPanasonicAcFanMin + 1;
|
|
case stdAc::fanspeed_t::kMedium:
|
|
return kPanasonicAcFanMin + 2;
|
|
case stdAc::fanspeed_t::kHigh:
|
|
return kPanasonicAcFanMin + 3;
|
|
case stdAc::fanspeed_t::kMax:
|
|
return kPanasonicAcFanMax;
|
|
default:
|
|
return kPanasonicAcFanAuto;
|
|
}
|
|
}
|
|
|
|
// Convert a standard A/C vertical swing into its native setting.
|
|
uint8_t IRPanasonicAc::convertSwingV(const stdAc::swingv_t position) {
|
|
switch (position) {
|
|
case stdAc::swingv_t::kHighest:
|
|
case stdAc::swingv_t::kHigh:
|
|
case stdAc::swingv_t::kMiddle:
|
|
return kPanasonicAcSwingVUp;
|
|
case stdAc::swingv_t::kLow:
|
|
case stdAc::swingv_t::kLowest:
|
|
return kPanasonicAcSwingVDown;
|
|
default:
|
|
return kPanasonicAcSwingVAuto;
|
|
}
|
|
}
|
|
|
|
// Convert a standard A/C horizontal swing into its native setting.
|
|
uint8_t IRPanasonicAc::convertSwingH(const stdAc::swingh_t position) {
|
|
switch (position) {
|
|
case stdAc::swingh_t::kLeftMax:
|
|
return kPanasonicAcSwingHFullLeft;
|
|
case stdAc::swingh_t::kLeft:
|
|
return kPanasonicAcSwingHLeft;
|
|
case stdAc::swingh_t::kMiddle:
|
|
return kPanasonicAcSwingHMiddle;
|
|
case stdAc::swingh_t::kRight:
|
|
return kPanasonicAcSwingHRight;
|
|
case stdAc::swingh_t::kRightMax:
|
|
return kPanasonicAcSwingHFullRight;
|
|
default:
|
|
return kPanasonicAcSwingHAuto;
|
|
}
|
|
}
|
|
|
|
// Convert the internal state into a human readable string.
|
|
#ifdef ARDUINO
|
|
String IRPanasonicAc::toString() {
|
|
String result = "";
|
|
#else
|
|
std::string IRPanasonicAc::toString() {
|
|
std::string result = "";
|
|
#endif // ARDUINO
|
|
result += F("Model: ");
|
|
result += uint64ToString(getModel());
|
|
switch (getModel()) {
|
|
case kPanasonicDke:
|
|
result += F(" (DKE)");
|
|
break;
|
|
case kPanasonicJke:
|
|
result += F(" (JKE)");
|
|
break;
|
|
case kPanasonicNke:
|
|
result += F(" (NKE)");
|
|
break;
|
|
case kPanasonicLke:
|
|
result += F(" (LKE)");
|
|
break;
|
|
case kPanasonicCkp:
|
|
result += F(" (CKP)");
|
|
break;
|
|
case kPanasonicRkr:
|
|
result += F(" (RKR)");
|
|
break;
|
|
default:
|
|
result += F(" (UNKNOWN)");
|
|
}
|
|
result += F(", Power: ");
|
|
if (getPower())
|
|
result += F("On");
|
|
else
|
|
result += F("Off");
|
|
result += F(", Mode: ");
|
|
result += uint64ToString(getMode());
|
|
switch (getMode()) {
|
|
case kPanasonicAcAuto:
|
|
result += F(" (AUTO)");
|
|
break;
|
|
case kPanasonicAcCool:
|
|
result += F(" (COOL)");
|
|
break;
|
|
case kPanasonicAcHeat:
|
|
result += F(" (HEAT)");
|
|
break;
|
|
case kPanasonicAcDry:
|
|
result += F(" (DRY)");
|
|
break;
|
|
case kPanasonicAcFan:
|
|
result += F(" (FAN)");
|
|
break;
|
|
default:
|
|
result += F(" (UNKNOWN)");
|
|
}
|
|
result += F(", Temp: ");
|
|
result += uint64ToString(getTemp());
|
|
result += F("C, Fan: ");
|
|
result += uint64ToString(getFan());
|
|
switch (getFan()) {
|
|
case kPanasonicAcFanAuto:
|
|
result += F(" (AUTO)");
|
|
break;
|
|
case kPanasonicAcFanMax:
|
|
result += F(" (MAX)");
|
|
break;
|
|
case kPanasonicAcFanMin:
|
|
result += F(" (MIN)");
|
|
break;
|
|
default:
|
|
result += F(" (UNKNOWN)");
|
|
break;
|
|
}
|
|
result += F(", Swing (Vertical): ");
|
|
result += uint64ToString(getSwingVertical());
|
|
switch (getSwingVertical()) {
|
|
case kPanasonicAcSwingVAuto:
|
|
result += F(" (AUTO)");
|
|
break;
|
|
case kPanasonicAcSwingVUp:
|
|
result += F(" (Full Up)");
|
|
break;
|
|
case kPanasonicAcSwingVDown:
|
|
result += F(" (Full Down)");
|
|
break;
|
|
case 2:
|
|
case 3:
|
|
case 4:
|
|
break;
|
|
default:
|
|
result += F(" (UNKNOWN)");
|
|
break;
|
|
}
|
|
switch (getModel()) {
|
|
case kPanasonicJke:
|
|
case kPanasonicCkp:
|
|
break; // No Horizontal Swing support.
|
|
default:
|
|
result += F(", Swing (Horizontal): ");
|
|
result += uint64ToString(getSwingHorizontal());
|
|
switch (getSwingHorizontal()) {
|
|
case kPanasonicAcSwingHAuto:
|
|
result += F(" (AUTO)");
|
|
break;
|
|
case kPanasonicAcSwingHFullLeft:
|
|
result += F(" (Full Left)");
|
|
break;
|
|
case kPanasonicAcSwingHLeft:
|
|
result += F(" (Left)");
|
|
break;
|
|
case kPanasonicAcSwingHMiddle:
|
|
result += F(" (Middle)");
|
|
break;
|
|
case kPanasonicAcSwingHFullRight:
|
|
result += F(" (Full Right)");
|
|
break;
|
|
case kPanasonicAcSwingHRight:
|
|
result += F(" (Right)");
|
|
break;
|
|
default:
|
|
result += F(" (UNKNOWN)");
|
|
break;
|
|
}
|
|
}
|
|
result += F(", Quiet: ");
|
|
if (getQuiet())
|
|
result += F("On");
|
|
else
|
|
result += F("Off");
|
|
result += F(", Powerful: ");
|
|
if (getPowerful())
|
|
result += F("On");
|
|
else
|
|
result += F("Off");
|
|
result += F(", Clock: ");
|
|
result += timeToString(getClock());
|
|
result += F(", On Timer: ");
|
|
if (isOnTimerEnabled())
|
|
result += timeToString(getOnTimer());
|
|
else
|
|
result += F("Off");
|
|
result += F(", Off Timer: ");
|
|
if (isOffTimerEnabled())
|
|
result += timeToString(getOffTimer());
|
|
else
|
|
result += F("Off");
|
|
return result;
|
|
}
|
|
|
|
#if DECODE_PANASONIC_AC
|
|
// Decode the supplied Panasonic AC 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 kPanasonicAcBits.
|
|
// strict: Flag indicating if we should perform strict matching.
|
|
// Returns:
|
|
// boolean: True if it can decode it, false if it can't.
|
|
//
|
|
// Status: Beta / Appears to work with real device(s).
|
|
//
|
|
// Panasonic A/C models supported:
|
|
// A/C Series/models:
|
|
// JKE, LKE, DKE, & NKE series.
|
|
// CS-YW9MKD
|
|
// A/C Remotes:
|
|
// A75C3747 (Confirmed)
|
|
// A75C3704
|
|
bool IRrecv::decodePanasonicAC(decode_results *results, uint16_t nbits,
|
|
bool strict) {
|
|
if (nbits % 8 != 0) // nbits has to be a multiple of nr. of bits in a byte.
|
|
return false;
|
|
|
|
uint8_t min_nr_of_messages = 1;
|
|
if (strict) {
|
|
if (nbits != kPanasonicAcBits && nbits != kPanasonicAcShortBits)
|
|
return false; // Not strictly a PANASONIC_AC message.
|
|
}
|
|
|
|
if (results->rawlen <
|
|
min_nr_of_messages * (2 * nbits + kHeader + kFooter) - 1)
|
|
return false; // Can't possibly be a valid PANASONIC_AC message.
|
|
|
|
uint16_t dataBitsSoFar = 0;
|
|
uint16_t offset = kStartOffset;
|
|
match_result_t data_result;
|
|
|
|
// Header
|
|
if (!matchMark(results->rawbuf[offset], kPanasonicHdrMark,
|
|
kPanasonicAcTolerance, kPanasonicAcExcess))
|
|
return false;
|
|
// Calculate how long the common tick time is based on the header mark.
|
|
uint32_t m_tick =
|
|
results->rawbuf[offset++] * kRawTick / kPanasonicHdrMarkTicks;
|
|
if (!matchSpace(results->rawbuf[offset], kPanasonicHdrSpace,
|
|
kPanasonicAcTolerance, kPanasonicAcExcess))
|
|
return false;
|
|
// Calculate how long the common tick time is based on the header space.
|
|
uint32_t s_tick =
|
|
results->rawbuf[offset++] * kRawTick / kPanasonicHdrSpaceTicks;
|
|
|
|
uint16_t i = 0;
|
|
// Data (Section #1)
|
|
// Keep reading bytes until we either run out of section or state to fill.
|
|
for (; offset <= results->rawlen - 16 && i < kPanasonicAcSection1Length;
|
|
i++, dataBitsSoFar += 8, offset += data_result.used) {
|
|
data_result = matchData(
|
|
&(results->rawbuf[offset]), 8, kPanasonicBitMarkTicks * m_tick,
|
|
kPanasonicOneSpaceTicks * s_tick, kPanasonicBitMarkTicks * m_tick,
|
|
kPanasonicZeroSpaceTicks * s_tick, kPanasonicAcTolerance,
|
|
kPanasonicAcExcess, false);
|
|
if (data_result.success == false) {
|
|
DPRINT("DEBUG: offset = ");
|
|
DPRINTLN(offset + data_result.used);
|
|
return false; // Fail
|
|
}
|
|
results->state[i] = data_result.data;
|
|
}
|
|
// Section footer.
|
|
if (!matchMark(results->rawbuf[offset++], kPanasonicBitMarkTicks * m_tick,
|
|
kPanasonicAcTolerance, kPanasonicAcExcess))
|
|
return false;
|
|
if (!matchSpace(results->rawbuf[offset++], kPanasonicAcSectionGap,
|
|
kPanasonicAcTolerance, kPanasonicAcExcess))
|
|
return false;
|
|
// Header.
|
|
if (!matchMark(results->rawbuf[offset++], kPanasonicHdrMarkTicks * m_tick,
|
|
kPanasonicAcTolerance, kPanasonicAcExcess))
|
|
return false;
|
|
if (!matchSpace(results->rawbuf[offset++], kPanasonicHdrSpaceTicks * s_tick,
|
|
kPanasonicAcTolerance, kPanasonicAcExcess))
|
|
return false;
|
|
// Data (Section #2)
|
|
// Keep reading bytes until we either run out of data.
|
|
for (; offset <= results->rawlen - 16 && i < nbits / 8;
|
|
i++, dataBitsSoFar += 8, offset += data_result.used) {
|
|
data_result = matchData(
|
|
&(results->rawbuf[offset]), 8, kPanasonicBitMarkTicks * m_tick,
|
|
kPanasonicOneSpaceTicks * s_tick, kPanasonicBitMarkTicks * m_tick,
|
|
kPanasonicZeroSpaceTicks * s_tick, kPanasonicAcTolerance,
|
|
kPanasonicAcExcess, false);
|
|
if (data_result.success == false) {
|
|
DPRINT("DEBUG: offset = ");
|
|
DPRINTLN(offset + data_result.used);
|
|
return false; // Fail
|
|
}
|
|
results->state[i] = data_result.data;
|
|
}
|
|
// Message Footer.
|
|
if (!matchMark(results->rawbuf[offset++], kPanasonicBitMarkTicks * m_tick,
|
|
kPanasonicAcTolerance, kPanasonicAcExcess))
|
|
return false;
|
|
if (offset <= results->rawlen &&
|
|
!matchAtLeast(results->rawbuf[offset++], kPanasonicAcMessageGap))
|
|
return false;
|
|
|
|
// Compliance
|
|
if (strict) {
|
|
// Check the signatures of the section blocks. They start with 0x02& 0x20.
|
|
if (results->state[0] != 0x02 || results->state[1] != 0x20 ||
|
|
results->state[8] != 0x02 || results->state[9] != 0x20)
|
|
return false;
|
|
if (!IRPanasonicAc::validChecksum(results->state, nbits / 8)) return false;
|
|
}
|
|
|
|
// Success
|
|
results->decode_type = PANASONIC_AC;
|
|
results->bits = nbits;
|
|
return true;
|
|
}
|
|
#endif // DECODE_PANASONIC_AC
|