#include "ir_Panasonic.h"

#include <algorithm>

#include <cstring>

#ifndef ARDUINO

#include <string>

#endif

#include "IRrecv.h"

#include "IRsend.h"

#include "IRtext.h"

#include "IRutils.h"

const uint16_t kPanasonicHdrMark = 3456; ///< uSeconds.

const uint16_t kPanasonicHdrSpace = 1728; ///< uSeconds.

const uint16_t kPanasonicBitMark = 432; ///< uSeconds.

const uint16_t kPanasonicOneSpace = 1296; ///< uSeconds.

const uint16_t kPanasonicZeroSpace = 432; ///< uSeconds.

const uint32_t kPanasonicMinCommandLength = 163296; ///< uSeconds.

const uint16_t kPanasonicEndGap = 5000; ///< uSeconds. See #245

const uint32_t kPanasonicMinGap = 74736; ///< uSeconds.

const uint16_t kPanasonicAcSectionGap = 10000; ///< uSeconds.

const uint16_t kPanasonicAcSection1Length = 8;

const uint32_t kPanasonicAcMessageGap = kDefaultMessageGap; // Just a guess.

const uint16_t kPanasonicAc32HdrMark = 3543; ///< uSeconds.

const uint16_t kPanasonicAc32BitMark = 920; ///< uSeconds.

const uint16_t kPanasonicAc32HdrSpace = 3450; ///< uSeconds.

const uint16_t kPanasonicAc32OneSpace = 2575; ///< uSeconds.

const uint16_t kPanasonicAc32ZeroSpace = 828; ///< uSeconds.

const uint16_t kPanasonicAc32SectionGap = 13946; ///< uSeconds.

const uint8_t kPanasonicAc32Sections = 2;

const uint8_t kPanasonicAc32BlocksPerSection = 2;

using irutils::addBoolToString;

using irutils::addFanToString;

using irutils::addIntToString;

using irutils::addLabeledString;

using irutils::addModeToString;

using irutils::addModelToString;

using irutils::addSwingHToString;

using irutils::addSwingVToString;

using irutils::addTempToString;

using irutils::minsToString;

using irutils::setBit;

using irutils::setBits;

#if (SEND_PANASONIC || SEND_DENON)

void IRsend::sendPanasonic64(const uint64_t data, const uint16_t nbits,

const uint16_t repeat) {

sendGeneric(kPanasonicHdrMark, kPanasonicHdrSpace, kPanasonicBitMark,

kPanasonicOneSpace, kPanasonicBitMark, kPanasonicZeroSpace,

kPanasonicBitMark, kPanasonicMinGap, kPanasonicMinCommandLength,

data, nbits, kPanasonicFreq, true, repeat, 50);

}

void IRsend::sendPanasonic(const uint16_t address, const uint32_t data,

const uint16_t nbits, const uint16_t repeat) {

sendPanasonic64(static_cast<uint64_t>(address) << 32 |

static_cast<uint64_t>(data), nbits, repeat);

}

uint64_t IRsend::encodePanasonic(const uint16_t manufacturer,

const uint8_t device,

const uint8_t subdevice,

const uint8_t function) {

uint8_t checksum = device ^ subdevice ^ function;

return ((static_cast<uint64_t>(manufacturer) << 32) |

(static_cast<uint64_t>(device) << 24) |

(static_cast<uint64_t>(subdevice) << 16) |

(static_cast<uint64_t>(function) << 8) | checksum);

}

#endif // (SEND_PANASONIC || SEND_DENON)

#if (DECODE_PANASONIC || DECODE_DENON)

bool IRrecv::decodePanasonic(decode_results *results, uint16_t offset,

const uint16_t nbits, const bool strict,

const uint32_t manufacturer) {

if (strict) { // Compliance checks

switch (nbits) {

case kPanasonic40Bits:

case kPanasonicBits:

break;

default:

return false; // Request is out of spec.

}

}

uint64_t data = 0;

// Match Header + Data + Footer

if (!matchGeneric(results->rawbuf + offset, &data,

results->rawlen - offset, nbits,

kPanasonicHdrMark, kPanasonicHdrSpace,

kPanasonicBitMark, kPanasonicOneSpace,

kPanasonicBitMark, kPanasonicZeroSpace,

kPanasonicBitMark, kPanasonicEndGap, true)) return false;

// Compliance

uint32_t address = data >> 32;

uint32_t command = data;

if (strict) {

if (address != manufacturer) // Verify the Manufacturer code.

return false;

// Verify the checksum.

const uint8_t checksumOrig = data;

uint8_t checksumCalc = (data >> 16) ^ (data >> 8);

if (nbits != kPanasonic40Bits)

checksumCalc ^= (data >> 24);

if (checksumOrig != checksumCalc) return false;

}

// Success

results->value = data;

results->address = address;

results->command = command;

results->decode_type = decode_type_t::PANASONIC;

results->bits = nbits;

return true;

}

#endif // (DECODE_PANASONIC || DECODE_DENON)

#if SEND_PANASONIC_AC

void IRsend::sendPanasonicAC(const uint8_t data[], const uint16_t nbytes,

const 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(const uint16_t pin, const bool inverted,

const bool use_modulation)

: _irsend(pin, inverted, use_modulation) { stateReset(); }

void IRPanasonicAc::stateReset(void) {

memcpy(remote_state, kPanasonicKnownGoodState, kPanasonicAcStateLength);

_temp = 25; // An initial saved desired temp. Completely made up.

_swingh = kPanasonicAcSwingHMiddle; // A similar made up value for H Swing.

}

void IRPanasonicAc::begin(void) { _irsend.begin(); }

bool IRPanasonicAc::validChecksum(const 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(const 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) {

_irsend.sendPanasonicAC(getRaw(), kPanasonicAcStateLength, repeat);

}

#endif // SEND_PANASONIC_AC

void IRPanasonicAc::setModel(const panasonic_ac_remote_model_t model) {

switch (model) {

case panasonic_ac_remote_model_t::kPanasonicDke:

case panasonic_ac_remote_model_t::kPanasonicJke:

case panasonic_ac_remote_model_t::kPanasonicLke:

case panasonic_ac_remote_model_t::kPanasonicNke:

case panasonic_ac_remote_model_t::kPanasonicCkp:

case panasonic_ac_remote_model_t::kPanasonicRkr: break;

// Only proceed if we know what to do.

default: 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;

}

// Reset the Ion filter.

setIon(getIon());

}

panasonic_ac_remote_model_t IRPanasonicAc::getModel(void) {

if (remote_state[23] == 0x89) return kPanasonicRkr;

if (remote_state[17] == 0x00) {

if ((remote_state[21] & 0x10) && (remote_state[23] & 0x01))

return panasonic_ac_remote_model_t::kPanasonicCkp;

if (remote_state[23] & 0x80)

return panasonic_ac_remote_model_t::kPanasonicJke;

}

if (remote_state[17] == 0x06 && (remote_state[13] & 0x0F) == 0x02)

return panasonic_ac_remote_model_t::kPanasonicLke;

if (remote_state[23] == 0x01)

return panasonic_ac_remote_model_t::kPanasonicDke;

if (remote_state[17] == 0x06)

return panasonic_ac_remote_model_t::kPanasonicNke;

return panasonic_ac_remote_model_t::kPanasonicUnknown; // Default

}

uint8_t *IRPanasonicAc::getRaw(void) {

fixChecksum();

return remote_state;

}

void IRPanasonicAc::setRaw(const uint8_t state[]) {

memcpy(remote_state, state, kPanasonicAcStateLength);

}

void IRPanasonicAc::setPower(const bool on) {

setBit(&remote_state[13], kPanasonicAcPowerOffset, on);

}

bool IRPanasonicAc::getPower(void) {

return GETBIT8(remote_state[13], kPanasonicAcPowerOffset);

}

void IRPanasonicAc::on(void) { setPower(true); }

void IRPanasonicAc::off(void) { setPower(false); }

uint8_t IRPanasonicAc::getMode(void) {

return GETBITS8(remote_state[13], kHighNibble, kModeBitsSize);

}

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.

setBits(&remote_state[13], kHighNibble, kModeBitsSize, mode);

}

uint8_t IRPanasonicAc::getTemp(void) {

return GETBITS8(remote_state[14], kPanasonicAcTempOffset,

kPanasonicAcTempSize);

}

void IRPanasonicAc::setTemp(const uint8_t celsius, const bool remember) {

uint8_t temperature;

temperature = std::max(celsius, kPanasonicAcMinTemp);

temperature = std::min(temperature, kPanasonicAcMaxTemp);

if (remember) _temp = temperature;

setBits(&remote_state[14], kPanasonicAcTempOffset, kPanasonicAcTempSize,

temperature);

}

uint8_t IRPanasonicAc::getSwingVertical(void) {

return GETBITS8(remote_state[16], kLowNibble, kNibbleSize);

}

void IRPanasonicAc::setSwingVertical(const uint8_t desired_elevation) {

uint8_t elevation = desired_elevation;

if (elevation != kPanasonicAcSwingVAuto) {

elevation = std::max(elevation, kPanasonicAcSwingVHighest);

elevation = std::min(elevation, kPanasonicAcSwingVLowest);

}

setBits(&remote_state[16], kLowNibble, kNibbleSize, elevation);

}

uint8_t IRPanasonicAc::getSwingHorizontal(void) {

return GETBITS8(remote_state[17], kLowNibble, kNibbleSize);

}

void IRPanasonicAc::setSwingHorizontal(const uint8_t desired_direction) {

switch (desired_direction) {

case kPanasonicAcSwingHAuto:

case kPanasonicAcSwingHMiddle:

case kPanasonicAcSwingHFullLeft:

case kPanasonicAcSwingHLeft:

case kPanasonicAcSwingHRight:

case kPanasonicAcSwingHFullRight: break;

// Ignore anything that isn't valid.

default: 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;

}

setBits(&remote_state[17], kLowNibble, kNibbleSize, direction);

}

void IRPanasonicAc::setFan(const uint8_t speed) {

switch (speed) {

case kPanasonicAcFanMin:

case kPanasonicAcFanLow:

case kPanasonicAcFanMed:

case kPanasonicAcFanHigh:

case kPanasonicAcFanMax:

case kPanasonicAcFanAuto:

setBits(&remote_state[16], kHighNibble, kNibbleSize,

speed + kPanasonicAcFanDelta);

break;

default: setFan(kPanasonicAcFanAuto);

}

}

uint8_t IRPanasonicAc::getFan(void) {

return GETBITS8(remote_state[16], kHighNibble, kNibbleSize) -

kPanasonicAcFanDelta;

}

bool IRPanasonicAc::getQuiet(void) {

switch (getModel()) {

case kPanasonicRkr:

case kPanasonicCkp:

return GETBIT8(remote_state[21], kPanasonicAcQuietCkpOffset);

default:

return GETBIT8(remote_state[21], kPanasonicAcQuietOffset);

}

}

void IRPanasonicAc::setQuiet(const bool on) {

uint8_t offset;

switch (getModel()) {

case kPanasonicRkr:

case kPanasonicCkp: offset = kPanasonicAcQuietCkpOffset; break;

default: offset = kPanasonicAcQuietOffset;

}

if (on) setPowerful(false); // Powerful is mutually exclusive.

setBit(&remote_state[21], offset, on);

}

bool IRPanasonicAc::getPowerful(void) {

switch (getModel()) {

case kPanasonicRkr:

case kPanasonicCkp:

return GETBIT8(remote_state[21], kPanasonicAcPowerfulCkpOffset);

default:

return GETBIT8(remote_state[21], kPanasonicAcPowerfulOffset);

}

}

void IRPanasonicAc::setPowerful(const bool on) {

uint8_t offset;

switch (getModel()) {

case kPanasonicRkr:

case kPanasonicCkp: offset = kPanasonicAcPowerfulCkpOffset; break;

default: offset = kPanasonicAcPowerfulOffset;

}

if (on) setQuiet(false); // Quiet is mutually exclusive.

setBit(&remote_state[21], offset, on);

}

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::_getTime(const uint8_t ptr[]) {

uint16_t result = (GETBITS8(

ptr[1], kLowNibble, kPanasonicAcTimeOverflowSize) <<

(kPanasonicAcTimeSize - kPanasonicAcTimeOverflowSize)) + ptr[0];

if (result == kPanasonicAcTimeSpecial) return 0;

return result;

}

uint16_t IRPanasonicAc::getClock(void) { return _getTime(&remote_state[24]); }

void IRPanasonicAc::_setTime(uint8_t * const ptr,

const uint16_t mins_since_midnight,

const bool round_down) {

uint16_t corrected = std::min(mins_since_midnight, kPanasonicAcTimeMax);

if (round_down) corrected -= corrected % 10;

if (mins_since_midnight == kPanasonicAcTimeSpecial)

corrected = kPanasonicAcTimeSpecial;

ptr[0] = corrected;

setBits(&ptr[1], kLowNibble, kPanasonicAcTimeOverflowSize,

corrected >> (kPanasonicAcTimeSize - kPanasonicAcTimeOverflowSize));

}

void IRPanasonicAc::setClock(const uint16_t mins_since_midnight) {

_setTime(&remote_state[24], mins_since_midnight, false);

}

uint16_t IRPanasonicAc::getOnTimer(void) { return _getTime(&remote_state[18]); }

void IRPanasonicAc::setOnTimer(const uint16_t mins_since_midnight,

const bool enable) {

// Set the timer flag.

setBit(&remote_state[13], kPanasonicAcOnTimerOffset, enable);

// Store the time.

_setTime(&remote_state[18], mins_since_midnight, true);

}

void IRPanasonicAc::cancelOnTimer(void) { setOnTimer(0, false); }

bool IRPanasonicAc::isOnTimerEnabled(void) {

return GETBIT8(remote_state[13], kPanasonicAcOnTimerOffset);

}

uint16_t IRPanasonicAc::getOffTimer(void) {

uint16_t result = (GETBITS8(remote_state[20], 0, 7) << kNibbleSize) |

GETBITS8(remote_state[19], kHighNibble, kNibbleSize);

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;

// Set the timer flag.

setBit(&remote_state[13], kPanasonicAcOffTimerOffset, enable);

// Store the time.

setBits(&remote_state[19], kHighNibble, kNibbleSize, corrected);

setBits(&remote_state[20], 0, 7, corrected >> kNibbleSize);

}

void IRPanasonicAc::cancelOffTimer(void) { setOffTimer(0, false); }

bool IRPanasonicAc::isOffTimerEnabled(void) {

return GETBIT8(remote_state[13], kPanasonicAcOffTimerOffset);

}

bool IRPanasonicAc::getIon(void) {

switch (getModel()) {

case kPanasonicDke:

return GETBIT8(remote_state[kPanasonicAcIonFilterByte],

kPanasonicAcIonFilterOffset);

default:

return false;

}

}

void IRPanasonicAc::setIon(const bool on) {

if (getModel() == kPanasonicDke)

setBit(&remote_state[kPanasonicAcIonFilterByte],

kPanasonicAcIonFilterOffset, on);

}

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;

}

}

uint8_t IRPanasonicAc::convertFan(const stdAc::fanspeed_t speed) {

switch (speed) {

case stdAc::fanspeed_t::kMin: return kPanasonicAcFanMin;

case stdAc::fanspeed_t::kLow: return kPanasonicAcFanLow;

case stdAc::fanspeed_t::kMedium: return kPanasonicAcFanMed;

case stdAc::fanspeed_t::kHigh: return kPanasonicAcFanHigh;

case stdAc::fanspeed_t::kMax: return kPanasonicAcFanMax;

default: return kPanasonicAcFanAuto;

}

}

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:

case stdAc::swingv_t::kLow:

case stdAc::swingv_t::kLowest: return (uint8_t)position;

default: return kPanasonicAcSwingVAuto;

}

}

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;

}

}

stdAc::opmode_t IRPanasonicAc::toCommonMode(const uint8_t mode) {

switch (mode) {

case kPanasonicAcCool: return stdAc::opmode_t::kCool;

case kPanasonicAcHeat: return stdAc::opmode_t::kHeat;

case kPanasonicAcDry: return stdAc::opmode_t::kDry;

case kPanasonicAcFan: return stdAc::opmode_t::kFan;

default: return stdAc::opmode_t::kAuto;

}

}

stdAc::fanspeed_t IRPanasonicAc::toCommonFanSpeed(const uint8_t spd) {

switch (spd) {

case kPanasonicAcFanMax: return stdAc::fanspeed_t::kMax;

case kPanasonicAcFanHigh: return stdAc::fanspeed_t::kHigh;

case kPanasonicAcFanMed: return stdAc::fanspeed_t::kMedium;

case kPanasonicAcFanLow: return stdAc::fanspeed_t::kLow;

case kPanasonicAcFanMin: return stdAc::fanspeed_t::kMin;

default: return stdAc::fanspeed_t::kAuto;

}

}

stdAc::swingh_t IRPanasonicAc::toCommonSwingH(const uint8_t pos) {

switch (pos) {

case kPanasonicAcSwingHFullLeft: return stdAc::swingh_t::kLeftMax;

case kPanasonicAcSwingHLeft: return stdAc::swingh_t::kLeft;

case kPanasonicAcSwingHMiddle: return stdAc::swingh_t::kMiddle;

case kPanasonicAcSwingHRight: return stdAc::swingh_t::kRight;

case kPanasonicAcSwingHFullRight: return stdAc::swingh_t::kRightMax;

default: return stdAc::swingh_t::kAuto;

}

}

stdAc::swingv_t IRPanasonicAc::toCommonSwingV(const uint8_t pos) {

if (pos >= kPanasonicAcSwingVHighest && pos <= kPanasonicAcSwingVLowest)

return (stdAc::swingv_t)pos;

else

return stdAc::swingv_t::kAuto;

}

stdAc::state_t IRPanasonicAc::toCommon(void) {

stdAc::state_t result{};

result.protocol = decode_type_t::PANASONIC_AC;

result.model = getModel();

result.power = getPower();

result.mode = toCommonMode(getMode());

result.celsius = true;

result.degrees = getTemp();

result.fanspeed = toCommonFanSpeed(getFan());

result.swingv = toCommonSwingV(getSwingVertical());

result.swingh = toCommonSwingH(getSwingHorizontal());

result.quiet = getQuiet();

result.turbo = getPowerful();

result.filter = getIon();

// Not supported.

result.econo = false;

result.clean = false;

result.light = false;

result.beep = false;

result.sleep = -1;

result.clock = -1;

return result;

}

String IRPanasonicAc::toString(void) {

String result = "";

result.reserve(180); // Reserve some heap for the string to reduce fragging.

result += addModelToString(decode_type_t::PANASONIC_AC, getModel(), false);

result += addBoolToString(getPower(), kPowerStr);

result += addModeToString(getMode(), kPanasonicAcAuto, kPanasonicAcCool,

kPanasonicAcHeat, kPanasonicAcDry, kPanasonicAcFan);

result += addTempToString(getTemp());

result += addFanToString(getFan(), kPanasonicAcFanHigh, kPanasonicAcFanLow,

kPanasonicAcFanAuto, kPanasonicAcFanMin,

kPanasonicAcFanMed, kPanasonicAcFanMax);

result += addSwingVToString(getSwingVertical(), kPanasonicAcSwingVAuto,

kPanasonicAcSwingVHighest,

kPanasonicAcSwingVHigh,

kPanasonicAcSwingVAuto, // Upper Middle is unused

kPanasonicAcSwingVMiddle,

kPanasonicAcSwingVAuto, // Lower Middle is unused

kPanasonicAcSwingVLow,

kPanasonicAcSwingVLowest,

// Below are unused.

kPanasonicAcSwingVAuto,

kPanasonicAcSwingVAuto,

kPanasonicAcSwingVAuto,

kPanasonicAcSwingVAuto);

switch (getModel()) {

case kPanasonicJke:

case kPanasonicCkp:

break; // No Horizontal Swing support.

default:

result += addSwingHToString(getSwingHorizontal(), kPanasonicAcSwingHAuto,

kPanasonicAcSwingHFullLeft,

kPanasonicAcSwingHLeft,

kPanasonicAcSwingHMiddle,

kPanasonicAcSwingHRight,

kPanasonicAcSwingHFullRight,

// Below are unused.

kPanasonicAcSwingHAuto,

kPanasonicAcSwingHAuto,

kPanasonicAcSwingHAuto,

kPanasonicAcSwingHAuto,

kPanasonicAcSwingHAuto);

}

result += addBoolToString(getQuiet(), kQuietStr);

result += addBoolToString(getPowerful(), kPowerfulStr);

if (getModel() == kPanasonicDke)

result += addBoolToString(getIon(), kIonStr);

result += addLabeledString(minsToString(getClock()), kClockStr);

result += addLabeledString(

isOnTimerEnabled() ? minsToString(getOnTimer()) : kOffStr,

kOnTimerStr);

result += addLabeledString(

isOffTimerEnabled() ? minsToString(getOffTimer()) : kOffStr,

kOffTimerStr);

return result;

}

#if DECODE_PANASONIC_AC

bool IRrecv::decodePanasonicAC(decode_results *results, uint16_t offset,

const uint16_t nbits, const bool strict) {

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 + offset)

return false; // Can't possibly be a valid PANASONIC_AC message.

// Match Header + Data #1 + Footer

uint16_t used;

used = matchGeneric(results->rawbuf + offset, results->state,

results->rawlen - offset, kPanasonicAcSection1Length * 8,

kPanasonicHdrMark, kPanasonicHdrSpace,

kPanasonicBitMark, kPanasonicOneSpace,

kPanasonicBitMark, kPanasonicZeroSpace,

kPanasonicBitMark, kPanasonicAcSectionGap, false,

kPanasonicAcTolerance, kPanasonicAcExcess, false);

if (!used) return false;

offset += used;

// Match Header + Data #2 + Footer

if (!matchGeneric(results->rawbuf + offset,

results->state + kPanasonicAcSection1Length,

results->rawlen - offset,

nbits - kPanasonicAcSection1Length * 8,

kPanasonicHdrMark, kPanasonicHdrSpace,

kPanasonicBitMark, kPanasonicOneSpace,

kPanasonicBitMark, kPanasonicZeroSpace,

kPanasonicBitMark, kPanasonicAcMessageGap, true,

kPanasonicAcTolerance, kPanasonicAcExcess, false))

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 = decode_type_t::PANASONIC_AC;

results->bits = nbits;

return true;

}

#endif // DECODE_PANASONIC_AC

#if SEND_PANASONIC_AC32

void IRsend::sendPanasonicAC32(const uint64_t data, const uint16_t nbits,

const uint16_t repeat) {

uint16_t section_bits;

uint16_t sections;

uint16_t blocks;

// Calculate the section, block, and bit sizes based on the requested bit size

if (nbits > kPanasonicAc32Bits / 2) { // A long message

section_bits = nbits / kPanasonicAc32Sections;

sections = kPanasonicAc32Sections;

blocks = kPanasonicAc32BlocksPerSection;

} else { // A short message

section_bits = nbits;

sections = kPanasonicAc32Sections - 1;

blocks = kPanasonicAc32BlocksPerSection + 1;

}

for (uint16_t r = 0; r <= repeat; r++) {

for (uint8_t section = 0; section < sections; section++) {

uint64_t section_data;

section_data = GETBITS64(data, section_bits * (sections - section - 1),

section_bits);

// Duplicate bytes in the data.

uint64_t expanded_data = 0;

for (uint8_t i = 0; i < sizeof(expanded_data); i++) {

const uint8_t first_byte = section_data >> 56;

for (uint8_t i = 0; i < 2; i++)

expanded_data = (expanded_data << 8) | first_byte;

section_data <<= 8;

}

// Two data blocks per section (i.e. 1 + a repeat)

sendGeneric(kPanasonicAc32HdrMark, kPanasonicAc32HdrSpace, // Header

kPanasonicAc32BitMark, kPanasonicAc32OneSpace, // Data

kPanasonicAc32BitMark, kPanasonicAc32ZeroSpace,

0, 0, // No Footer

expanded_data, section_bits * 2, kPanasonicFreq, false,

blocks - 1, // Repeat

50);

// Section Footer

sendGeneric(kPanasonicAc32HdrMark, kPanasonicAc32HdrSpace, // Header

0, 0, 0, 0, // No Data

kPanasonicAc32BitMark, kPanasonicAc32SectionGap, // Footer

data, 0, // No data (bits)

kPanasonicFreq, true, 0, 50);

}

}

}

#endif // SEND_PANASONIC_AC32

#if DECODE_PANASONIC_AC32

bool IRrecv::decodePanasonicAC32(decode_results *results, uint16_t offset,

const uint16_t nbits, const bool strict) {

if (strict && (nbits != kPanasonicAc32Bits &&

nbits != kPanasonicAc32Bits / 2))

return false; // Not strictly a valid bit size.

// Determine if this is a long or a short message we are looking for.