ir_Bosch.h

Go to the documentation of this file.

// Copyright 2022 Nico Thien
 
// Supports:
//   Brand: Bosch,  Model: CL3000i-Set 26 E A/C
//   Brand: Bosch,  Model: RG10A(G2S)BGEF remote
//   Brand: Durastar, Model: RG10R(M2S)/BGEFU1 remote
 
 
#ifndef IR_BOSCH_H_
#define IR_BOSCH_H_
 
#define __STDC_LIMIT_MACROS
#include <stdint.h>
#include <algorithm>
#include <cstring>
#include "IRremoteESP8266.h"
#include "IRsend.h"
#include "IRrecv.h"
#include "IRtext.h"
#include "IRutils.h"
#include "IRplatform.h"
#ifdef UNIT_TEST
#include "IRsend_test.h"
#endif
 
// Constants
const uint16_t kBoschHdrMark = 4366;
const uint16_t kBoschBitMark = 456;
const uint16_t kBoschHdrSpace = 4415;
const uint16_t kBoschOneSpace = 1645;
const uint16_t kBoschZeroSpace = 610;
const uint16_t kBoschFooterSpace = 5235;
const uint16_t kBoschFreq = 38000;  // Hz. (Guessing the most common frequency.)
const uint16_t kBosch144NrOfSections = 3;
const uint16_t kBosch144BytesPerSection = 6;
 
using irutils::addBoolToString;
using irutils::addModeToString;
using irutils::addFanToString;
using irutils::addTempToString;
using std::min;
using std::max;
using std::memcpy;
using std::memcmp;
 
// Modes                Bit[0] to Section 3    Bit[1-2] to Section 1
//                                ModeS3                   ModeS1
const uint8_t kBosch144Cool = 0b000;
const uint8_t kBosch144Dry =  0b011;
const uint8_t kBosch144Auto = 0b101;
const uint8_t kBosch144Heat = 0b110;
const uint8_t kBosch144Fan =  0b010;
 
// Fan Control          Bit[0-5] to Section 3    Bit[6-8] to Section 1
//                                  FanS3                    FanS1
const uint16_t kBosch144Fan20 = 0b111001010;
const uint16_t kBosch144Fan40 = 0b100010100;
const uint16_t kBosch144Fan60 = 0b010011110;
const uint16_t kBosch144Fan80 = 0b001101000;
const uint16_t kBosch144Fan100 = 0b001110010;
const uint16_t kBosch144FanAuto = 0b101110011;
const uint16_t kBosch144FanAuto0 = 0b000110011;
 
// Temperature
const uint8_t kBosch144CelsiusMin = 16;
const uint8_t kBosch144CelsiusMax = 30;
const uint8_t kBosch144CelsiusMap[] = {
    // Bit[0] to Section 3: TempS4 (the "half-degree" bit)
    // Bit[1] to Section 3: TempS3
    // Bit[1-4] to Section 1: TempS1
    0b000010,  // 16C
    0b000000,  // 17C
    0b000100,  // 18C
    0b001100,  // 19C
    0b001000,  // 20C
    0b011000,  // 21C
    0b011100,  // 22C
    0b010100,  // 23C
    0b010000,  // 24C
    0b110000,  // 25C
    0b110100,  // 26C
    0b100100,  // 27C
    0b100000,  // 28C
    0b101000,  // 29C
    0b101100   // 30C
};
 
const uint8_t kBosch144FahrenheitMin = 60;
const uint8_t kBosch144FahrenheitMax = 86;
const uint8_t kBosch144FahrenheitMap[] = {
    // Bit[0] to Section 3: TempS4
    // Bit[1] to Section 3: TempS3
    // Bit[1-4] to Section 1: TempS1
    0b000010,  // 60F
    0b000011,  // 61F
    0b000000,  // 62F
    0b000001,  // 63F
    0b000100,  // 64F
    0b000101,  // 65F
    0b001100,  // 66F
    0b001101,  // 67F
    0b001000,  // 68F
    0b001001,  // 69F
    0b011000,  // 70F
    0b011001,  // 71F
    0b011100,  // 72F
    0b010100,  // 73F
    0b010101,  // 74F
    0b010000,  // 75F
    0b010001,  // 76F
    0b110000,  // 77F
    0b110001,  // 78F
    0b110100,  // 79F
    0b110101,  // 80F
    0b100100,  // 81F
    0b100000,  // 82F
    0b100001,  // 83F
    0b101000,  // 84F
    0b101001,  // 85F
    0b101100   // 86F
};
 
// "OFF" is a 96bit-message    the same as Coolix protocol
const uint8_t kBosch144Off[] = {0xB2, 0x4D, 0x7B, 0x84, 0xE0, 0x1F,
                                0xB2, 0x4D, 0x7B, 0x84, 0xE0, 0x1F};
 
// On, 25C, Mode: Auto
const uint8_t kBosch144DefaultState[kBosch144StateLength] = {
  0xB2, 0x4D, 0x1F, 0xE0, 0xC8, 0x37,
  0xB2, 0x4D, 0x1F, 0xE0, 0xC8, 0x37,
  0xD5, 0x65, 0x00, 0x00, 0x00, 0x3A};
 
union Bosch144Protocol {
  uint8_t raw[kBosch144StateLength];  
  struct {
    uint8_t               :8;   // Fixed value 0b10110010 / 0xB2.   ############
    uint8_t InnvertS1_1   :8;   // Invert byte  0b01001101 / 0x4D   #
    uint8_t               :5;   // not used (without timer use)     #
    uint8_t FanS1         :3;   // Fan speed bits in Section 1      #
    uint8_t InnvertS1_2   :8;   // Invert byte                      # Section 1
    uint8_t               :2;   // not used (without timer use)     # =
    uint8_t ModeS1        :2;   // Operation mode bits S1           # Section 2
    uint8_t TempS1        :4;   // Desired temperature (Celsius) S2 #
    uint8_t InnvertS1_3   :8;   // Invert byte (without timer use)  ############
 
    uint8_t               :8;   // Fixed value 0b10110010 / 0xB2.   ############
    uint8_t InnvertS2_1   :8;   // Invert byte  0b01001101 / 0x4D   #
    uint8_t               :5;   // not used (without timer use)     #
    uint8_t FanS2         :3;   // Fan speed bits in Section 2      #
    uint8_t InnvertS2_2   :8;   // Invert byte                      # Section 2
    uint8_t               :2;   // not used (without timer use)     # =
    uint8_t ModeS2        :2;   // Operation mode bits S2           # Section 1
    uint8_t TempS2        :4;   // Desired temperature (Celsius) S2 #
    uint8_t InnvertS2_3   :8;   // Invert byte (without timer use)  ###########
 
    uint8_t               :8;   // Fixed value 0b11010101 / 0xD5    ###########
    uint8_t ModeS3        :1;   // ModeBit in Section 3             #
    uint8_t FanS3         :6;   // Fan speed bits in Section 3      #
    uint8_t               :1;   // Unknown                          #
    uint8_t               :5;   // Unknown                          #
    uint8_t TempS4        :1;   // Desired temp                     #
    uint8_t               :1;   // Unknown                          #
    uint8_t Quiet         :1;   // Silent-Mode                      # Section 3
    uint8_t UseFahrenheit :1;   // Fahrenheit or Celcius            #
    uint8_t               :3;   // Unknown                          #
    uint8_t TempS3        :1;   // Desired temp. Bit in Section3    #
    uint8_t               :3;   // Unknown                          #
    uint8_t               :8;   // Unknown                          #
    uint8_t ChecksumS3    :8;   // Checksum from byte 13-17         ###########
  };
};
 
// Classes
 
class IRBosch144AC {
 public:
  explicit IRBosch144AC(const uint16_t pin, const bool inverted = false,
                      const bool use_modulation = true);
  void stateReset(void);
#if SEND_BOSCH144
  void send(const uint16_t repeat = 0);
  int8_t calibrate(void) { return _irsend.calibrate(); }
#endif  // SEND_BOSCH144
  void begin();
  void setPower(const bool state);
  bool getPower(void) const;
  void setTemp(const uint8_t temp, const bool fahrenheit = false);
  uint8_t getTemp(void) const;
  void setUseFahrenheit(const bool on);
  bool getUseFahrenheit(void) const;
  void setFan(const uint16_t speed);
  uint16_t getFan(void) const;
  void setMode(const uint8_t mode);
  uint8_t getMode(void) const;
  void setQuiet(const bool on);
  bool getQuiet(void) const;
  uint8_t* getRaw(void);
  void setRaw(const uint8_t new_code[],
              const uint16_t length = kBosch144StateLength);
  static uint8_t convertMode(const stdAc::opmode_t mode);
  static uint16_t convertFan(const stdAc::fanspeed_t speed);
  static stdAc::opmode_t toCommonMode(const uint8_t mode);
  static stdAc::fanspeed_t toCommonFanSpeed(const uint16_t speed);
  stdAc::state_t toCommon(void) const;
  String toString(void) const;
#ifndef UNIT_TEST
 
 private:
  IRsend _irsend;  
#else
  IRsendTest _irsend;  
#endif
  Bosch144Protocol _;  
 
  // Internal State settings
  bool powerFlag;
 
  void setInvertBytes();
  void setCheckSumS3();
  void setTempRaw(const uint8_t code);
  uint8_t getTempRaw(void) const;
};
 
#endif  // IR_BOSCH_H_