Add basic support for Panasonic A/C 32bit/16bit protocol. (crankyoldg…

…it#1316)

* `sendPanasonicAC32()` & `decodePanasonicAC32()` added.
* Support the short (16 bit) version of the messages used for swing, quiet, & powerful.
* Unit tests for the above.
* LSBF order determined by Temperature ranges.

For crankyoldgit#1307

src/IRrecv.cpp

@@ -884,6 +884,13 @@ bool IRrecv::decode(decode_results *results, irparams_t *save,
  DPRINTLN("Attempting EliteScreens decode");
  if (decodeElitescreens(results, offset)) return true;
 #endif // DECODE_ELITESCREENS
+#if DECODE_PANASONIC_AC32
+ DPRINTLN("Attempting Panasonic AC (32bit) long decode");
+ if (decodePanasonicAC32(results, offset, kPanasonicAc32Bits)) return true;
+ DPRINTLN("Attempting Panasonic AC (32bit) short decode");
+ if (decodePanasonicAC32(results, offset, kPanasonicAc32Bits / 2))
+ return true;
+#endif // DECODE_PANASONIC_AC32
  // Typically new protocols are added above this line.
  }
 #if DECODE_HASH

src/IRrecv.h

@@ -596,7 +596,13 @@ class IRrecv {
  uint16_t offset = kStartOffset,
  const uint16_t nbits = kPanasonicAcBits,
  const bool strict = true);
-#endif
+#endif // DECODE_PANASONIC_AC
+#if DECODE_PANASONIC_AC32
+ bool decodePanasonicAC32(decode_results *results,
+ uint16_t offset = kStartOffset,
+ const uint16_t nbits = kPanasonicAc32Bits,
+ const bool strict = true);
+#endif // DECODE_PANASONIC_AC32
 #if DECODE_PIONEER
  bool decodePioneer(decode_results *results, uint16_t offset = kStartOffset,
  const uint16_t nbits = kPioneerBits,

src/IRremoteESP8266.h

@@ -502,6 +502,13 @@
 #define SEND_PANASONIC_AC _IR_ENABLE_DEFAULT_
 #endif // SEND_PANASONIC_AC
 
+#ifndef DECODE_PANASONIC_AC32
+#define DECODE_PANASONIC_AC32 _IR_ENABLE_DEFAULT_
+#endif // DECODE_PANASONIC_AC32
+#ifndef SEND_PANASONIC_AC32
+#define SEND_PANASONIC_AC32 _IR_ENABLE_DEFAULT_
+#endif // SEND_PANASONIC_AC32
+
 #ifndef DECODE_MWM
 #define DECODE_MWM _IR_ENABLE_DEFAULT_
 #endif // DECODE_MWM
@@ -859,8 +866,9 @@ enum decode_type_t {
  TECHNIBEL_AC,
  MIRAGE,
  ELITESCREENS, // 95
+ PANASONIC_AC32,
  // Add new entries before this one, and update it to point to the last entry.
- kLastDecodeType = ELITESCREENS,
+ kLastDecodeType = PANASONIC_AC32,
 };
 
 // Message lengths & required repeat values
@@ -1022,6 +1030,7 @@ const uint16_t kPanasonicAcStateShortLength = 16;
 const uint16_t kPanasonicAcBits = kPanasonicAcStateLength * 8;
 const uint16_t kPanasonicAcShortBits = kPanasonicAcStateShortLength * 8;
 const uint16_t kPanasonicAcDefaultRepeat = kNoRepeat;
+const uint16_t kPanasonicAc32Bits = 32;
 const uint16_t kPioneerBits = 64;
 const uint16_t kProntoMinLength = 6;
 const uint16_t kRC5RawBits = 14;

src/IRsend.cpp

@@ -639,6 +639,7 @@ uint16_t IRsend::defaultBits(const decode_type_t protocol) {
  case EPSON:
  case NEC:
  case NEC_LIKE:
+ case PANASONIC_AC32:
  case SAMSUNG:
  case SHERWOOD:
  case WHYNTER:
@@ -926,7 +927,12 @@ bool IRsend::send(const decode_type_t type, const uint64_t data,
  case PANASONIC:
  sendPanasonic64(data, nbits, min_repeat);
  break;
-#endif
+#endif // SEND_PANASONIC
+#if SEND_PANASONIC_AC32
+ case PANASONIC_AC32:
+ sendPanasonicAC32(data, nbits, min_repeat);
+ break;
+#endif // SEND_PANASONIC_AC32
 #if SEND_PIONEER
  case PIONEER:
  sendPioneer(data, nbits, min_repeat);

src/IRsend.h

@@ -573,7 +573,12 @@ class IRsend {
  void sendPanasonicAC(const unsigned char data[],
  const uint16_t nbytes = kPanasonicAcStateLength,
  const uint16_t repeat = kPanasonicAcDefaultRepeat);
-#endif
+#endif // SEND_PANASONIC_AC
+#if SEND_PANASONIC_AC32
+ void sendPanasonicAC32(const uint64_t data,
+ const uint16_t nbits = kPanasonicAc32Bits,
+ const uint16_t repeat = kPanasonicAcDefaultRepeat);
+#endif // SEND_PANASONIC_AC32
 #if SEND_PIONEER
  void sendPioneer(const uint64_t data, const uint16_t nbits = kPioneerBits,
  const uint16_t repeat = kNoRepeat);

src/IRtext.cpp

@@ -274,5 +274,6 @@ const PROGMEM char *kAllProtocolNamesStr =
  D_STR_TECHNIBEL_AC "\x0"
  D_STR_MIRAGE "\x0"
  D_STR_ELITESCREENS "\x0"
+ D_STR_PANASONIC_AC32 "\x0"
  ///< New protocol strings should be added just above this line.
  "\x0"; ///< This string requires double null termination.

src/ir_Panasonic.cpp

@@ -25,32 +25,28 @@
 
 // Constants
 /// @see https://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 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;
@@ -926,3 +922,184 @@ bool IRrecv::decodePanasonicAC(decode_results *results, uint16_t offset,
  return true;
 }
 #endif // DECODE_PANASONIC_AC
+
+#if SEND_PANASONIC_AC32
+/// Send a Panasonic AC 32/16bit formatted message.
+/// Status: STABLE / Confirmed working.
+/// @param[in] data containing the IR command.
+/// @param[in] nbits Nr. of bits to send. Usually kPanasonicAc32Bits
+/// @param[in] repeat Nr. of times the message is to be repeated.
+/// @see https://github.com/crankyoldgit/IRremoteESP8266/issues/1307
+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
+/// Decode the supplied Panasonic AC 32/16bit message.
+/// Status: STABLE / Confirmed working.
+/// @param[in,out] results Ptr to the data to decode & where to store the decode
+/// 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.
+/// Typically: kPanasonicAc32Bits or kPanasonicAc32Bits/2
+/// @param[in] strict Flag indicating if we should perform strict matching.
+/// @return A boolean. True if it can decode it, false if it can't.
+/// @see https://github.com/crankyoldgit/IRremoteESP8266/issues/1307
+/// @note Protocol has two known configurations:
+/// (long)
+/// Two sections of identical 32 bit data block pairs. ie. (32+32)+(32+32)=128
+/// or
+/// (short)
+/// A single section of 3 x identical 32 bit data blocks i.e. (32+32+32)=96
+/// Each data block also has a pair of 8 bits repeated identical bits.
+/// e.g. (8+8)+(8+8)=32
+///
+/// So each long version really only has 32 unique bits, and the short version
+/// really only has 16 unique bits.
+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.
+ const bool is_long = (nbits > kPanasonicAc32Bits / 2);
+ const uint16_t min_length = is_long ?
+ kPanasonicAc32Sections * kPanasonicAc32BlocksPerSection *
+ ((2 * nbits) + kHeader + kFooter) - 1 + offset :
+ (kPanasonicAc32BlocksPerSection + 1) * ((4 * nbits) + kHeader) +
+ kFooter - 1 + offset;
+
+ if (results->rawlen < min_length)
+ return false; // Can't possibly be a valid message.
+
+ // Calculate the parameters for the decode based on it's length.
+ uint16_t sections;
+ uint16_t blocks_per_section;
+ if (is_long) {
+ sections = kPanasonicAc32Sections;
+ blocks_per_section = kPanasonicAc32BlocksPerSection;
+ } else {
+ sections = kPanasonicAc32Sections - 1;
+ blocks_per_section = kPanasonicAc32BlocksPerSection + 1;
+ }
+ const uint16_t bits_per_block = nbits / sections;
+
+ uint64_t data = 0;
+ uint64_t section_data = 0;
+ uint32_t prev_section_data;
+
+ // Match all the expected data blocks.
+ for (uint16_t block = 0;
+ block < sections * blocks_per_section;
+ block++) {
+ prev_section_data = section_data;
+ uint16_t used = matchGeneric(results->rawbuf + offset, &section_data,
+ results->rawlen - offset, bits_per_block * 2,
+ kPanasonicAc32HdrMark, kPanasonicAc32HdrSpace,
+ kPanasonicAc32BitMark, kPanasonicAc32OneSpace,
+ kPanasonicAc32BitMark, kPanasonicAc32ZeroSpace,
+ 0, 0, // No Footer
+ false, kUseDefTol, kMarkExcess, false);
+ if (!used) return false;
+ offset += used;
+ // Is it the first block of the section?
+ if (block % blocks_per_section == 0) {
+ // The protocol repeats each byte twice, so to shrink the code we
+ // remove the duplicate bytes in the collected data. We only need to do
+ // this for the first block in a section.
+ uint64_t shrunk_data = 0;
+ uint64_t data_copy = section_data;
+ for (uint8_t i = 0; i < sizeof(data_copy); i += 2) {
+ const uint8_t first_byte = GETBITS64(data_copy,
+ (sizeof(data_copy) - 1) * 8, 8);
+ shrunk_data = (shrunk_data << 8) | first_byte;
+ // Compliance
+ if (strict) {
+ // Every second byte must be a duplicate of the previous.
+ const uint8_t next_byte = GETBITS64(data_copy,
+ (sizeof(data_copy) - 2) * 8, 8);
+ if (first_byte != next_byte) return false;
+ }
+ data_copy <<= 16;
+ }
+ // Keep the data from the first of the block in the section.
+ data = (data << bits_per_block) | shrunk_data;
+ } else { // Not the first block in a section.
+ // Compliance
+ if (strict)
+ // Compare the data from the blocks in pairs.
+ if (section_data != prev_section_data) return false;
+ // Look for the section footer at the end of the blocks.
+ if ((block + 1) % blocks_per_section == 0) {
+ uint64_t junk;
+ used = matchGeneric(results->rawbuf + offset, &junk,
+ results->rawlen - offset, 0,
+ // Header
+ kPanasonicAc32HdrMark, kPanasonicAc32HdrSpace,
+ // No Data
+ 0, 0,
+ 0, 0,
+ // Footer
+ kPanasonicAc32BitMark, kPanasonicAc32SectionGap,
+ true);
+ if (!used) return false;
+ offset += used;
+ }
+ }
+ }
+
+ // Success
+ results->value = data;
+ results->decode_type = decode_type_t::PANASONIC_AC32;
+ results->bits = nbits;
+ results->address = 0;
+ results->command = 0;
+ return true;
+}
+#endif // DECODE_PANASONIC_AC32

src/ir_Panasonic.h

@@ -23,6 +23,8 @@
 // Brand: Panasonic, Model: A75C2616-1 remote (PANASONIC_AC DKE/3)
 // Brand: Panasonic, Model: A75C3704 remote (PANASONIC_AC DKE/3)
 // Brand: Panasonic, Model: A75C3747 remote (PANASONIC_AC JKE/4)
+// Brand: Panasonic, Model: CS-E9CKP series A/C (PANASONIC_AC32)
+// Brand: Panasonic, Model: A75C2295 remote (PANASONIC_AC32)
 
 #ifndef IR_PANASONIC_H_
 #define IR_PANASONIC_H_

src/locale/defaults.h

@@ -670,6 +670,9 @@
 #ifndef D_STR_PANASONIC_AC
 #define D_STR_PANASONIC_AC "PANASONIC_AC"
 #endif // D_STR_PANASONIC_AC
+#ifndef D_STR_PANASONIC_AC32
+#define D_STR_PANASONIC_AC32 D_STR_PANASONIC_AC"32"
+#endif // D_STR_PANASONIC_AC32
 #ifndef D_STR_PIONEER
 #define D_STR_PIONEER "PIONEER"
 #endif // D_STR_PIONEER