Added support for Bluestar Heavy AC

src/IRrecv.cpp

@@ -1185,6 +1185,10 @@ bool IRrecv::decode(decode_results *results, irparams_t *save,
     DPRINTLN("Attempting York decode");
     if (decodeYork(results, offset, kYorkBits)) return true;
 #endif  // DECODE_YORK
+#if DECODE_BLUESTARHEAVY
+    DPRINTLN("Attempting BluestarHeavy decode");
+    if (decodeBluestarHeavy(results, offset, kBluestarHeavyBits)) return true;
+#endif  // DECODE_BLUESTARHEAVY
   // Typically new protocols are added above this line.
   }
 #if DECODE_HASH

src/IRrecv.h

@@ -883,6 +883,12 @@ class IRrecv {
                   const uint16_t kYorkBits,
                   const bool strict = true);
 #endif  // DECODE_YORK
+#if DECODE_BLUESTARHEAVY
+  bool decodeBluestarHeavy(decode_results *results,
+                  uint16_t kStartOffset,
+                  const uint16_t kBluestarHeavyBits,
+                  const bool strict = true);
+#endif  // DECODE_BLUESTARHEAVY
 };
 
 #endif  // IRRECV_H_

src/IRremoteESP8266.h

@@ -952,6 +952,13 @@
 #define SEND_YORK           _IR_ENABLE_DEFAULT_
 #endif  // SEND_YORK
 
+#ifndef DECODE_BLUESTARHEAVY
+#define DECODE_BLUESTARHEAVY         _IR_ENABLE_DEFAULT_
+#endif  // DECODE_BLUESTARHEAVY
+#ifndef SEND_BLUESTARHEAVY
+#define SEND_BLUESTARHEAVY           _IR_ENABLE_DEFAULT_
+#endif  // SEND_BLUESTARHEAVY 
+
 #if (DECODE_ARGO || DECODE_DAIKIN || DECODE_FUJITSU_AC || DECODE_GREE || \
      DECODE_KELVINATOR || DECODE_MITSUBISHI_AC || DECODE_TOSHIBA_AC || \
      DECODE_TROTEC || DECODE_HAIER_AC || DECODE_HITACHI_AC || \
@@ -970,7 +977,7 @@
      DECODE_KELON168 || DECODE_HITACHI_AC296 || DECODE_CARRIER_AC128 || \
      DECODE_DAIKIN200 || DECODE_HAIER_AC160 || DECODE_TCL96AC || \
      DECODE_BOSCH144 || DECODE_SANYO_AC152 || DECODE_DAIKIN312 || \
-     DECODE_CARRIER_AC84 || DECODE_YORK || \
+     DECODE_CARRIER_AC84 || DECODE_YORK || DECODE_BLUESTARHEAVY || \
      false)
   // Add any DECODE to the above if it uses result->state (see kStateSizeMax)
   // you might also want to add the protocol to hasACState function
@@ -1137,8 +1144,9 @@ enum decode_type_t {
   WOWWEE,
   CARRIER_AC84,  // 125
   YORK,
+  BLUESTARHEAVY,
   // Add new entries before this one, and update it to point to the last entry.
-  kLastDecodeType = YORK,
+  kLastDecodeType = BLUESTARHEAVY,
 };
 
 // Message lengths & required repeat values
@@ -1165,6 +1173,8 @@ const uint16_t kArgo3TimerStateLength = 9;  // Bytes
 const uint16_t kArgo3ConfigStateLength = 4;  // Bytes
 const uint16_t kArgoDefaultRepeat = kNoRepeat;
 const uint16_t kArrisBits = 32;
+const uint16_t kBluestarHeavyStateLength = 13; 
+const uint16_t kBluestarHeavyBits = 104;
 const uint16_t kBosch144StateLength = 18;
 const uint16_t kBosch144Bits = kBosch144StateLength * 8;
 const uint16_t kCoolixBits = 24;
@@ -1437,6 +1447,7 @@ const uint16_t kYorkBits = 136;
 const uint16_t kYorkStateLength = 17;
 
 
+
 // Legacy defines. (Deprecated)
 #define AIWA_RC_T501_BITS             kAiwaRcT501Bits
 #define ARGO_COMMAND_LENGTH           kArgoStateLength

src/IRsend.cpp

@@ -798,6 +798,8 @@ uint16_t IRsend::defaultBits(const decode_type_t protocol) {
       return kXmpBits;
     case YORK:
       return kYorkBits;
+    case BLUESTARHEAVY:
+      return kBluestarHeavyBits;
     // No default amount of bits.
     case FUJITSU_AC:
     case MWM:
@@ -1434,6 +1436,11 @@ bool IRsend::send(const decode_type_t type, const uint8_t *state,
       sendYork(state, nbytes);
       break;
 #endif  // SEND_YORK
+#if SEND_BLUESTARHEAVY
+    case BLUESTARHEAVY:
+      sendBluestarHeavy(state, nbytes);
+      break;
+#endif  // SEND_BLUESTARHEAVY
     default:
       return false;
   }

src/IRsend.h

@@ -885,7 +885,11 @@ class IRsend {
                     const uint16_t nbytes = kYorkStateLength,
                     const uint16_t repeat = kNoRepeat);
 #endif  // SEND_YORK
-
+#if SEND_BLUESTARHEAVY
+  void sendBluestarHeavy(const unsigned char data[],
+                       const uint16_t nbytes = kBluestarHeavyStateLength,
+                       const uint16_t repeat = kNoRepeat);
+#endif  // SEND_BLUESTARHEAVY
  protected:
 #ifdef UNIT_TEST
 #ifndef HIGH

src/IRtext.cpp

@@ -555,6 +555,8 @@ IRTEXT_CONST_BLOB_DECL(kAllProtocolNamesStr) {
             D_STR_CARRIER_AC84, D_STR_UNSUPPORTED) "\x0"
     COND(DECODE_YORK || SEND_YORK,
             D_STR_YORK, D_STR_UNSUPPORTED) "\x0"
+    COND(DECODE_BLUESTARHEAVY || SEND_BLUESTARHEAVY,
+            D_STR_BLUESTARHEAVY, D_STR_UNSUPPORTED) "\x0"
     ///< New protocol (macro) strings should be added just above this line.
     "\x0"  ///< This string requires double null termination.
 };

src/IRutils.cpp

@@ -169,6 +169,7 @@ bool hasACState(const decode_type_t protocol) {
     // This is kept sorted by name
     case AMCOR:
     case ARGO:
+    case BLUESTARHEAVY:
     case BOSCH144:
     case CARRIER_AC84:
     case CARRIER_AC128:

src/ir_BluestarHeavy.cpp

@@ -0,0 +1,150 @@
+// Copyright 2020 David Conran (crankyoldgit)
+/// @file
+/// @brief Support for BluestarHeavy protocol
+
+// Supports:
+//   Brand: Bluestar,  Model: TODO add device and remote
+
+#include "IRrecv.h"
+#include "IRsend.h"
+#include "IRutils.h"
+
+// WARNING: This probably isn't directly usable. It's a guide only.
+
+// See https://github.com/crankyoldgit/IRremoteESP8266/wiki/Adding-support-for-a-new-IR-protocol
+// for details of how to include this in the library.
+const uint16_t kBluestarHeavyHdrMark = 4912;
+const uint16_t kBluestarHeavyBitMark = 465;
+const uint16_t kBluestarHeavyHdrSpace = 5058;
+const uint16_t kBluestarHeavyOneSpace = 1548;
+const uint16_t kBluestarHeavyZeroSpace = 572;
+const uint16_t kBluestarHeavyFreq = 38000;  // Hz. (Guessing the most common frequency.)
+//const uint16_t kBluestarHeavyBits = 104;  // Move to IRremoteESP8266.h
+//const uint16_t kBluestarHeavyStateLength = 13;  // Move to IRremoteESP8266.h
+const uint16_t kBluestarHeavyOverhead = 3;
+// DANGER: More than 64 bits detected. A uint64_t for 'data' won't work!
+
+
+#if SEND_BLUESTARHEAVY
+// Alternative >64bit function to send BLUESTARHEAVY messages
+// Function should be safe over 64 bits.
+/// Send a BluestarHeavy formatted message.
+/// Status: ALPHA / Untested.
+/// @param[in] data An array of bytes containing the IR command.
+///                 It is assumed to be in MSB order for this code.
+/// e.g.
+/// @code
+///   uint8_t data[kBluestarHeavyStateLength] = {0xD5, 0xFE, 0xD7, 0x4F, 0xFA, 0x5F, 0xFA, 0x5F, 0xFF, 0x7F, 0x5C, 0xFD, 0xDC};
+/// @endcode
+/// @param[in] nbytes Nr. of bytes of data in the array. (>=kBluestarHeavyStateLength)
+/// @param[in] repeat Nr. of times the message is to be repeated.
+void IRsend::sendBluestarHeavy(const uint8_t data[], const uint16_t nbytes, const uint16_t repeat) {
+  for (uint16_t r = 0; r <= repeat; r++) {
+    uint16_t pos = 0;
+    // Data Section #2
+    // e.g.
+    //   bits = 104; bytes = 13;
+    //   *(data + pos) = {0xD5, 0xFE, 0xD7, 0x4F, 0xFA, 0x5F, 0xFA, 0x5F, 0xFF, 0x7F, 0x5C, 0xFD, 0xDC};
+    sendGeneric(kBluestarHeavyHdrMark, kBluestarHeavyHdrSpace,
+                kBluestarHeavyBitMark, kBluestarHeavyOneSpace,
+                kBluestarHeavyBitMark, kBluestarHeavyZeroSpace,
+                kBluestarHeavyHdrMark, kDefaultMessageGap,
+                data + pos, nbytes,  // Bytes
+                kBluestarHeavyFreq, true, kNoRepeat, kDutyDefault);
+    pos += nbytes;  // Adjust by how many bytes of data we sent
+  }
+}
+#endif  // SEND_BLUESTARHEAVY
+
+
+// DANGER: More than 64 bits detected. A uint64_t for 'data' won't work!
+// #if DECODE_BLUESTARHEAVY
+// // Function should be safe up to 64 bits.
+// /// Decode the supplied BluestarHeavy message.
+// /// Status: ALPHA / Untested.
+// /// @param[in,out] results Ptr to the data to decode & where to store the decode
+// /// @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 A boolean. True if it can decode it, false if it can't.
+
+
+// bool IRrecv::decodeBluestarHeavy(decode_results *results, uint16_t offset, const uint16_t nbits, const bool strict) {
+//   if (results->rawlen < 2 * nbits + kBluestarHeavyOverhead - offset)
+//     return false;  // Too short a message to match.
+//   if (strict && nbits != kBluestarHeavyBits)
+//     return false;
+
+//   uint64_t data = 0;
+//   match_result_t data_result;
+
+//   // Header
+//   if (!matchMark(results->rawbuf[offset++], kBluestarHeavyHdrMark))
+//     return false;
+//   if (!matchSpace(results->rawbuf[offset++], kBluestarHeavyHdrSpace))
+//     return false;
+
+//   // Data Section #1
+//   // e.g. data_result.data = 0xD5FED74FFA5FFA5FFF7F5CFDDC, nbits = 104
+//   data_result = matchData(&(results->rawbuf[offset]), 104,
+//                           kBluestarHeavyBitMark, kBluestarHeavyOneSpace,
+//                           kBluestarHeavyBitMark, kBluestarHeavyZeroSpace);
+//   offset += data_result.used;
+//   if (data_result.success == false) return false;  // Fail
+//   data <<= 104;  // Make room for the new bits of data.
+//   data |= data_result.data;
+
+//   // Header
+//   if (!matchMark(results->rawbuf[offset++], kBluestarHeavyHdrMark))
+//     return false;
+
+//   // Success
+//   results->decode_type = decode_type_t::BLUESTARHEAVY;
+//   results->bits = nbits;
+//   results->value = data;
+//   results->command = 0;
+//   results->address = 0;
+//   return true;
+// }
+// #endif  // DECODE_BLUESTARHEAVY
+
+#if DECODE_BLUESTARHEAVY
+// Function should be safe over 64 bits.
+/// Decode the supplied BluestarHeavy message.
+/// Status: ALPHA / Untested.
+/// @param[in,out] results Ptr to the data to decode & where to store the decode
+/// @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 A boolean. True if it can decode it, false if it can't.
+bool IRrecv::decodeBluestarHeavy(decode_results *results, uint16_t offset, const uint16_t nbits, const bool strict) {
+  if (results->rawlen < 2 * nbits + kBluestarHeavyOverhead - offset)
+    return false;  // Too short a message to match.
+  if (strict && nbits != kBluestarHeavyBits)
+    return false;
+
+  uint16_t pos = 0;
+  uint16_t used = 0;
+
+  // Data Section #2
+  // e.g.
+  //   bits = 104; bytes = 13;
+  //   *(results->state + pos) = {0xD5, 0xFE, 0xD7, 0x4F, 0xFA, 0x5F, 0xFA, 0x5F, 0xFF, 0x7F, 0x5C, 0xFD, 0xDC};
+  used = matchGeneric(results->rawbuf + offset, results->state + pos,
+                      results->rawlen - offset, 104,
+                      kBluestarHeavyHdrMark, kBluestarHeavyHdrSpace,
+                      kBluestarHeavyBitMark, kBluestarHeavyOneSpace,
+                      kBluestarHeavyBitMark, kBluestarHeavyZeroSpace,
+                      kBluestarHeavyHdrMark, kDefaultMessageGap, true);
+  if (used == 0) return false;  // We failed to find any data.
+  offset += used;  // Adjust for how much of the message we read.
+  pos += 13;  // Adjust by how many bytes of data we read
+
+  // Success
+  results->decode_type = decode_type_t::BLUESTARHEAVY;
+  results->bits = nbits;
+  return true;
+}
+#endif  // DECODE_BLUESTARHEAVY

src/locale/defaults.h

@@ -751,6 +751,9 @@ D_STR_INDIRECT " " D_STR_MODE
 #ifndef D_STR_ARRIS
 #define D_STR_ARRIS "ARRIS"
 #endif  // D_STR_ARRIS
+#ifndef D_STR_BLUESTARHEACY
+#define D_STR_BLUESTARHEAVY "BLUESTARHEAVY"
+#endif  // D_STR_TESTEXAMPLE
 #ifndef D_STR_BOSCH
 #define D_STR_BOSCH "BOSCH"
 #endif  // D_STR_BOSCH