Merge branch 'dev' into core3

src/core/device_library.h

@@ -105,7 +105,7 @@
 {215, DeviceType::THERMOSTAT, "Comfort RF", DeviceFlags::EMS_DEVICE_FLAG_CRF | DeviceFlags::EMS_DEVICE_FLAG_NO_WRITE}, // 0x18
 {216, DeviceType::THERMOSTAT, "CRF200S", DeviceFlags::EMS_DEVICE_FLAG_CRF | DeviceFlags::EMS_DEVICE_FLAG_NO_WRITE}, // 0x18
 {246, DeviceType::THERMOSTAT, "Comfort+2RF", DeviceFlags::EMS_DEVICE_FLAG_CRF | DeviceFlags::EMS_DEVICE_FLAG_NO_WRITE}, // 0x18
-{253, DeviceType::THERMOSTAT, "Rego 3000, UI800, Logamatic BC400", DeviceFlags::EMS_DEVICE_FLAG_BC400}, // 0x10
+{253, DeviceType::THERMOSTAT, "Rego 3000, UI800, Logamatic BC400", DeviceFlags::EMS_DEVICE_FLAG_UI800}, // 0x10
 
 // Thermostat - Sieger - 0x10 / 0x17
 { 66, DeviceType::THERMOSTAT, "ES72, RC20", DeviceFlags::EMS_DEVICE_FLAG_RC20_N}, // 0x17 or remote

src/core/emsdevice.h

@@ -530,6 +530,7 @@ class EMSdevice {
     static constexpr uint8_t EMS_DEVICE_FLAG_CR120       = 16; // mostly like RC300, but some changes
     static constexpr uint8_t EMS_DEVICE_FLAG_CR11        = 17; // CRF200 only monitor
     static constexpr uint8_t EMS_DEVICE_FLAG_HMC310      = 18;
+    static constexpr uint8_t EMS_DEVICE_FLAG_UI800       = 19;
 
     uint8_t count_entities();
     uint8_t count_entities_fav();

src/core/emsdevicevalue.h

@@ -158,6 +158,7 @@ class DeviceValue {
     enum DeviceValueNumOp : int8_t {
         DV_NUMOP_NONE   = 0, // default
         DV_NUMOP_DIV2   = 2,
+        DV_NUMOP_DIV4   = 4,
         DV_NUMOP_DIV10  = 10,
         DV_NUMOP_DIV60  = 60,
         DV_NUMOP_DIV100 = 100,

src/core/locale_common.h

@@ -191,7 +191,11 @@ MAKE_NOTRANSLATION(rc100, "RC100")
 MAKE_NOTRANSLATION(rc100h, "RC100H")
 MAKE_NOTRANSLATION(tc100, "TC100")
 MAKE_NOTRANSLATION(rc120rf, "RC120RF")
-MAKE_NOTRANSLATION(rc220, "RC220/RT800")
+MAKE_NOTRANSLATION(rc220, "RC220")
+MAKE_NOTRANSLATION(rt800, "RT800")
+MAKE_NOTRANSLATION(cr10, "CR10")
+MAKE_NOTRANSLATION(cr10h, "CR10H")
+MAKE_NOTRANSLATION(cr20rf, "CR20RF")
 MAKE_NOTRANSLATION(single, "single")
 MAKE_NOTRANSLATION(dash, "-")
 MAKE_NOTRANSLATION(BLANK, "")
@@ -371,6 +375,7 @@ MAKE_ENUM(enum_roomsensor, FL_(extern), FL_(intern), FL_(auto))
 MAKE_ENUM(enum_roominfluence, FL_(off), FL_(intern), FL_(extern), FL_(auto))
 MAKE_ENUM(enum_control1, FL_(rc310), FL_(rc200), FL_(rc100), FL_(rc100h), FL_(tc100))
 MAKE_ENUM(enum_control2, FL_(off), FL_(dash), FL_(rc100), FL_(rc100h), FL_(dash), FL_(rc120rf), FL_(rc220), FL_(single)) // BC400
+MAKE_ENUM(enum_control3, FL_(off), FL_(dash), FL_(cr10), FL_(cr10h), FL_(dash), FL_(cr20rf), FL_(rt800), FL_(single)) // UI800
 
 MAKE_ENUM(enum_switchmode, FL_(off), FL_(eco), FL_(comfort), FL_(heat))
 MAKE_ENUM(enum_switchProgMode, FL_(level), FL_(absolute))

src/core/modbus_entity_parameters.hpp

@@ -349,12 +349,12 @@ const std::initializer_list<Modbus::EntityModbusInfo> Modbus::modbus_register_ma
     REGISTER_MAPPING(dt::THERMOSTAT, TAG_TYPE_HC, FL_(remotehum), 46, 1), // remotehum
     REGISTER_MAPPING(dt::THERMOSTAT, TAG_TYPE_HC, FL_(heatondelay), 47, 1), // heatondelay
     REGISTER_MAPPING(dt::THERMOSTAT, TAG_TYPE_HC, FL_(heatoffdelay), 48, 1), // heatoffdelay
-    REGISTER_MAPPING(dt::THERMOSTAT, TAG_TYPE_HC, FL_(instantstart), 49, 1), // instantstart
-    REGISTER_MAPPING(dt::THERMOSTAT, TAG_TYPE_HC, FL_(boost), 50, 1), // boost
-    REGISTER_MAPPING(dt::THERMOSTAT, TAG_TYPE_HC, FL_(boosttime), 51, 1), // boosttime
-    REGISTER_MAPPING(dt::THERMOSTAT, TAG_TYPE_HC, FL_(coolstart), 52, 1), // coolstart
-    REGISTER_MAPPING(dt::THERMOSTAT, TAG_TYPE_HC, FL_(coolondelay), 53, 1), // coolondelay
-    REGISTER_MAPPING(dt::THERMOSTAT, TAG_TYPE_HC, FL_(cooloffdelay), 54, 1), // cooloffdelay
+    REGISTER_MAPPING(dt::THERMOSTAT, TAG_TYPE_HC, FL_(coolondelay), 49, 1), // coolondelay
+    REGISTER_MAPPING(dt::THERMOSTAT, TAG_TYPE_HC, FL_(cooloffdelay), 50, 1), // cooloffdelay
+    REGISTER_MAPPING(dt::THERMOSTAT, TAG_TYPE_HC, FL_(instantstart), 51, 1), // instantstart
+    REGISTER_MAPPING(dt::THERMOSTAT, TAG_TYPE_HC, FL_(boost), 52, 1), // boost
+    REGISTER_MAPPING(dt::THERMOSTAT, TAG_TYPE_HC, FL_(boosttime), 53, 1), // boosttime
+    REGISTER_MAPPING(dt::THERMOSTAT, TAG_TYPE_HC, FL_(coolstart), 54, 1), // coolstart
     REGISTER_MAPPING(dt::THERMOSTAT, TAG_TYPE_HC, FL_(switchProgMode), 55, 1), // switchprogmode
     REGISTER_MAPPING(dt::THERMOSTAT, TAG_TYPE_HC, FL_(redthreshold), 56, 1), // redthreshold
     REGISTER_MAPPING(dt::THERMOSTAT, TAG_TYPE_HC, FL_(solarinfl), 57, 1), // solarinfl

src/core/telegram.cpp

@@ -161,9 +161,9 @@ void RxService::add(uint8_t * data, uint8_t length) {
         }
         if (data[0] != EMSuart::last_tx_src()) { // do not count echos as errors
             telegram_error_count_++;
-            LOG_WARNING("Incomplete Rx: %s", Helpers::data_to_hex(data, length).c_str()); // include CRC
+            LOG_WARNING("Incomplete Rx: %s (crc: %02X)", Helpers::data_to_hex(data, length).c_str(), crc); // include CRC
         } else {
-            LOG_TRACE("Incomplete Rx: %s", Helpers::data_to_hex(data, length).c_str()); // include CRC
+            LOG_TRACE("Incomplete Rx: %s (crc: %02X)", Helpers::data_to_hex(data, length).c_str(), crc); // include CRC
         }
         return;
     }
@@ -276,6 +276,7 @@ void TxService::start() {
 // sends a 1 byte poll which is our own deviceID
 void TxService::send_poll() const {
     // LOG_DEBUG("Ack %02X",ems_bus_id() ^ ems_mask());
+    // if (tx_mode() != EMS_TXMODE_OFF && ems_bus_id() != 0x0D) { // use 0x0D for tests without poll-Ack
     if (tx_mode() != EMS_TXMODE_OFF) {
         EMSuart::send_poll(ems_bus_id() ^ ems_mask());
     }

src/devices/thermostat.cpp

@@ -181,7 +181,9 @@ Thermostat::Thermostat(uint8_t device_type, uint8_t device_id, uint8_t product_i
             register_telegram_type(set_typeids[i], "RC300Set", false, MAKE_PF_CB(process_RC300Set), 29);
             register_telegram_type(summer_typeids[i], "RC300Summer", false, MAKE_PF_CB(process_RC300Summer), 14);
             register_telegram_type(curve_typeids[i], "RC300Curves", false, MAKE_PF_CB(process_RC300Curve), 9);
-            register_telegram_type(summer2_typeids[i], "RC300Summer2", false, MAKE_PF_CB(process_RC300Summer2), 8);
+            if (model != EMSdevice::EMS_DEVICE_FLAG_UI800) {
+                register_telegram_type(summer2_typeids[i], "RC300Sumr2", false, MAKE_PF_CB(process_RC300Summer2), 8);
+            }
         }
         const size_t set2_size = set2_typeids.size();
         for (uint8_t i = 0; i < set2_size; i++) {
@@ -213,7 +215,9 @@ Thermostat::Thermostat(uint8_t device_type, uint8_t device_id, uint8_t product_i
         register_telegram_type(0x16E, "Absent", true, MAKE_PF_CB(process_Absent), 1);
         register_telegram_type(0xBF, "ErrorMessage", false, MAKE_PF_CB(process_ErrorMessageBF));
         register_telegram_type(0xC0, "RCErrorMessage", false, MAKE_PF_CB(process_RCErrorMessage2));
-        register_telegram_type(0x470, "RC300Summer2", true, MAKE_PF_CB(process_RC300Summer2), 8);
+        if (model == EMSdevice::EMS_DEVICE_FLAG_UI800) {
+            register_telegram_type(0x470, "RC300Summer3", true, MAKE_PF_CB(process_RC300Summer3), 8);
+        }
         EMSESP::send_read_request(0xC0, device_id, 0, 20); // read last errorcode on start (only published on errors)
 
         // JUNKERS/HT3
@@ -549,7 +553,7 @@ uint8_t Thermostat::HeatingCircuit::get_mode() const {
         } else {
             return HeatingCircuit::Mode::OFF;
         }
-    } else if (model == EMSdevice::EMS_DEVICE_FLAG_BC400 || model == EMSdevice::EMS_DEVICE_FLAG_CR120) {
+    } else if (model == EMSdevice::EMS_DEVICE_FLAG_BC400 || model == EMSdevice::EMS_DEVICE_FLAG_UI800 || model == EMSdevice::EMS_DEVICE_FLAG_CR120) {
         if (mode_new == 0) {
             return HeatingCircuit::Mode::OFF;
         } else if (mode_new == 1) {
@@ -613,7 +617,7 @@ uint8_t Thermostat::HeatingCircuit::get_mode_type() const {
             return HeatingCircuit::Mode::ON;
         }
     } else if (model == EMSdevice::EMS_DEVICE_FLAG_RC300 || model == EMSdevice::EMS_DEVICE_FLAG_R3000 || model == EMSdevice::EMS_DEVICE_FLAG_BC400
-               || model == EMSdevice::EMS_DEVICE_FLAG_HMC310) {
+               || model == EMSdevice::EMS_DEVICE_FLAG_UI800 || model == EMSdevice::EMS_DEVICE_FLAG_HMC310) {
         if (modetype == 0) {
             return HeatingCircuit::Mode::ECO;
         } else if (modetype == 1) {
@@ -1270,18 +1274,25 @@ void Thermostat::process_RC300Summer(const std::shared_ptr<const Telegram> & tel
     has_update(telegram, hc->comfortPointTemp, 12);
 }
 
+// type 0x470, only BC400/UI800
+// (0x470), data: 01 0E 01 01 02 17 04 48
+void Thermostat::process_RC300Summer3(std::shared_ptr<const Telegram> telegram) {
+    has_update(telegram, hpoperatingmode, 0);
+    has_update(telegram, summertemp, 1);
+    has_update(telegram, heatondelay, 2);
+    has_update(telegram, heatoffdelay, 3);
+    has_update(telegram, instantstart, 4);
+    has_update(telegram, coolstart, 5);
+    has_update(telegram, coolondelay, 6);
+    has_update(telegram, cooloffdelay, 7);
+}
+
 // types 0x471 ff summer2_typeids
 // (0x473), data: 00 11 04 01 01 1C 08 04
 void Thermostat::process_RC300Summer2(const std::shared_ptr<const Telegram> & telegram) {
     auto hc = heating_circuit(telegram);
     if (hc == nullptr) {
-        // telegram 0x470 see https://github.com/emsesp/EMS-ESP32/issues/2686
-        if (telegram->type_id == 0x470 && telegram->message_length > 2) {
-            hc                 = heating_circuit(1);
-            summer2_typeids[0] = 0x470;
-        } else {
-            return;
-        }
+        return;
     }
     if (hc->statusbyte & 1) {
         has_update(telegram, hc->summersetmode, 0);
@@ -1340,7 +1351,7 @@ void Thermostat::process_RC300WWmode(const std::shared_ptr<const Telegram> & tel
     // circulation pump see: https://github.com/Th3M3/buderus_ems-wiki/blob/master/Einstellungen%20der%20Bedieneinheit%20RC310.md
     has_update(telegram, dhw->wwCircPump_, 1); // FF=off, 0=on ?
 
-    if (model() == EMSdevice::EMS_DEVICE_FLAG_BC400 || model() == EMSdevice::EMS_DEVICE_FLAG_HMC310) {
+    if (model() == EMSdevice::EMS_DEVICE_FLAG_BC400 || model() == EMSdevice::EMS_DEVICE_FLAG_UI800 || model() == EMSdevice::EMS_DEVICE_FLAG_HMC310) {
         has_enumupdate(telegram, dhw->wwMode_, 2, {0, 5, 1, 2, 4});
     } else if (model() == EMSdevice::EMS_DEVICE_FLAG_R3000) {
         // https://github.com/emsesp/EMS-ESP32/pull/1722#discussion_r1582823521
@@ -2361,7 +2372,7 @@ bool Thermostat::set_control(const char * value, const int8_t id) {
         }
         // BC400
         // 1-RC100, 2-RC100H, 3-RC200
-    } else if (model() == EMSdevice::EMS_DEVICE_FLAG_BC400) {
+    } else if (model() == EMSdevice::EMS_DEVICE_FLAG_BC400 || model() == EMSdevice::EMS_DEVICE_FLAG_UI800) {
         if (Helpers::value2enum(value, ctrl, FL_(enum_control2))) {
             write_command(hpmode_typeids[hc->hc()], 3, ctrl);
             hc->control = ctrl; // set in advance, dont wait for verify
@@ -2441,7 +2452,7 @@ bool Thermostat::set_wwmode(const char * value, const int8_t id) {
             return false;
         }
         write_command(0xB0, 2, set, 0xB0);
-    } else if (model() == EMSdevice::EMS_DEVICE_FLAG_BC400 || model() == EMSdevice::EMS_DEVICE_FLAG_HMC310) {
+    } else if (model() == EMSdevice::EMS_DEVICE_FLAG_BC400 || model() == EMSdevice::EMS_DEVICE_FLAG_UI800 || model() == EMSdevice::EMS_DEVICE_FLAG_HMC310) {
         if (!Helpers::value2enum(value, set, FL_(enum_wwMode4), {0, 5, 1, 2, 4})) { // off, eco+, eco, comfort, auto
             return false;
         }
@@ -2596,30 +2607,36 @@ bool Thermostat::set_cooling(const char * value, const int8_t id) {
 
 // set cooling delays
 bool Thermostat::set_coolondelay(const char * value, const int8_t id) {
+    float f;
+    if (!Helpers::value2float(value, f)) {
+        return false;
+    }
+    if (model() == EMSdevice::EMS_DEVICE_FLAG_UI800) {
+        write_command(0x470, 6, (uint8_t)(f * 4), 0x470);
+        return true;
+    }
     auto hc = heating_circuit(id);
     if (hc == nullptr) {
         return false;
     }
-
-    int v;
-    if (!Helpers::value2number(value, v)) {
-        return false;
-    }
-    write_command(summer2_typeids[hc->hc()], 6, v, summer2_typeids[hc->hc()]);
+    write_command(summer2_typeids[hc->hc()], 6, (uint8_t)f, summer2_typeids[hc->hc()]);
     return true;
 }
 
 bool Thermostat::set_cooloffdelay(const char * value, const int8_t id) {
+    float f;
+    if (!Helpers::value2float(value, f)) {
+        return false;
+    }
+    if (model() == EMSdevice::EMS_DEVICE_FLAG_UI800) {
+        write_command(0x470, 7, (uint8_t)(f * 4), 0x470);
+        return true;
+    }
     auto hc = heating_circuit(id);
     if (hc == nullptr) {
         return false;
     }
-
-    int v;
-    if (!Helpers::value2number(value, v)) {
-        return false;
-    }
-    write_command(summer2_typeids[hc->hc()], 7, v, summer2_typeids[hc->hc()]);
+    write_command(summer2_typeids[hc->hc()], 7, (uint8_t)f, summer2_typeids[hc->hc()]);
     return true;
 }
 
@@ -3148,6 +3165,7 @@ bool Thermostat::set_mode(const char * value, const int8_t id) {
         mode_list = FL_(enum_mode3);
         break;
     case EMSdevice::EMS_DEVICE_FLAG_BC400:
+    case EMSdevice::EMS_DEVICE_FLAG_UI800:
     case EMSdevice::EMS_DEVICE_FLAG_CR120:
         mode_list = FL_(enum_mode2);
         break;
@@ -3285,6 +3303,7 @@ bool Thermostat::set_mode_n(const uint8_t mode, const int8_t id) {
         offset = EMS_OFFSET_RC35Set_mode;
         break;
     case EMSdevice::EMS_DEVICE_FLAG_BC400:
+    case EMSdevice::EMS_DEVICE_FLAG_UI800:
     case EMSdevice::EMS_DEVICE_FLAG_CR120:
         offset = EMS_OFFSET_RCPLUSSet_mode_new;
         break;
@@ -3324,7 +3343,7 @@ bool Thermostat::set_mode_n(const uint8_t mode, const int8_t id) {
     // set hc->mode temporary until validate is received
     if (model_ == EMSdevice::EMS_DEVICE_FLAG_RC10) {
         hc->mode = set_mode_value >> 1;
-    } else if (model_ == EMSdevice::EMS_DEVICE_FLAG_BC400 || model_ == EMSdevice::EMS_DEVICE_FLAG_CR120) {
+    } else if (model_ == EMSdevice::EMS_DEVICE_FLAG_BC400 || model_ == EMSdevice::EMS_DEVICE_FLAG_UI800 || model_ == EMSdevice::EMS_DEVICE_FLAG_CR120) {
         hc->mode_new = set_mode_value;
     } else if (model_ == EMSdevice::EMS_DEVICE_FLAG_RC300 || model_ == EMSdevice::EMS_DEVICE_FLAG_R3000 || model_ == EMSdevice::EMS_DEVICE_FLAG_HMC310
                || model_ == EMSdevice::EMS_DEVICE_FLAG_RC100) {
@@ -3341,13 +3360,19 @@ bool Thermostat::set_mode_n(const uint8_t mode, const int8_t id) {
 
 // sets the thermostat summermode for RC300
 bool Thermostat::set_summermode(const char * value, const int8_t id) {
+    uint8_t set;
+    if (model() == EMSdevice::EMS_DEVICE_FLAG_UI800) {
+        if (Helpers::value2enum(value, set, FL_(enum_hpoperatingmode))) {
+            write_command(0x470, 0, set, 0x470);
+            return true;
+        }
+        return false;
+    }
     auto hc = heating_circuit(id);
     if (hc == nullptr) {
         return false;
     }
 
-    uint8_t set;
-
     if (is_received(summer2_typeids[hc->hc()])) {
         if ((hc->statusbyte & 1) && Helpers::value2enum(value, set, FL_(enum_summermode))) {
             write_command(summer2_typeids[hc->hc()], 0, set, summer2_typeids[hc->hc()]);
@@ -3493,40 +3518,52 @@ bool Thermostat::set_boosttime(const char * value, const int8_t id) {
 }
 
 bool Thermostat::set_heatondelay(const char * value, const int8_t id) {
+    float f;
+    if (!Helpers::value2float(value, f)) {
+        return false;
+    }
+    if (model() == EMSdevice::EMS_DEVICE_FLAG_UI800) {
+        write_command(0x470, 2, (uint8_t)(f * 4), 0x470);
+        return true;
+    }
     auto hc = heating_circuit(id);
     if (hc == nullptr) {
         return false;
     }
-    int v;
-    if (!Helpers::value2number(value, v)) {
-        return false;
-    }
-    write_command(summer2_typeids[hc->hc()], 2, (uint8_t)v, summer2_typeids[hc->hc()]);
+    write_command(summer2_typeids[hc->hc()], 2, (uint8_t)f, summer2_typeids[hc->hc()]);
     return true;
 }
 
 bool Thermostat::set_heatoffdelay(const char * value, const int8_t id) {
+    float f;
+    if (!Helpers::value2float(value, f)) {
+        return false;
+    }
+    if (model() == EMSdevice::EMS_DEVICE_FLAG_UI800) {
+        write_command(0x470, 3, (uint8_t)(f * 4), 0x470);
+        return true;
+    }
     auto hc = heating_circuit(id);
     if (hc == nullptr) {
         return false;
     }
-    int v;
-    if (!Helpers::value2number(value, v)) {
-        return false;
-    }
-    write_command(summer2_typeids[hc->hc()], 3, (uint8_t)v, summer2_typeids[hc->hc()]);
+    write_command(summer2_typeids[hc->hc()], 3, (uint8_t)f, summer2_typeids[hc->hc()]);
     return true;
 }
 
 bool Thermostat::set_instantstart(const char * value, const int8_t id) {
-    auto hc = heating_circuit(id);
-    if (hc == nullptr) {
-        return false;
-    }
     int v;
     if (!Helpers::value2number(value, v)) {
         return false;
     }
+    if (model() == EMSdevice::EMS_DEVICE_FLAG_UI800) {
+        write_command(0x470, 4, (uint8_t)v, 0x470);
+        return true;
+    }
+    auto hc = heating_circuit(id);
+    if (hc == nullptr) {
+        return false;
+    }
     write_command(summer2_typeids[hc->hc()], 4, (uint8_t)v, summer2_typeids[hc->hc()]);
     return true;
 }
@@ -4051,6 +4088,10 @@ bool Thermostat::set_temperature(const float temperature, const uint8_t mode, co
         validate_typeid = set_typeids[hc->hc()];
         switch (mode) {
         case HeatingCircuit::Mode::SUMMER:
+            if (model == EMSdevice::EMS_DEVICE_FLAG_UI800) {
+                write_command(0x470, 1, temperature, 0x470);
+                return true;
+            }
             if (is_received(summer2_typeids[hc->hc()])) {
                 offset     = 0x01;
                 set_typeid = summer2_typeids[hc->hc()];
@@ -4062,6 +4103,10 @@ bool Thermostat::set_temperature(const float temperature, const uint8_t mode, co
             factor          = 1;
             break;
         case HeatingCircuit::Mode::COOLSTART:
+            if (model == EMSdevice::EMS_DEVICE_FLAG_UI800) {
+                write_command(0x470, 5, temperature, 0x470);
+                return true;
+            }
             offset          = 5;
             set_typeid      = summer2_typeids[hc->hc()];
             validate_typeid = set_typeid;
@@ -4449,6 +4494,7 @@ void Thermostat::register_device_values() {
     case EMSdevice::EMS_DEVICE_FLAG_RC300:
     case EMSdevice::EMS_DEVICE_FLAG_R3000:
     case EMSdevice::EMS_DEVICE_FLAG_BC400:
+    case EMSdevice::EMS_DEVICE_FLAG_UI800:
     case EMSdevice::EMS_DEVICE_FLAG_CR120:
     case EMSdevice::EMS_DEVICE_FLAG_HMC310:
         register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
@@ -4566,6 +4612,70 @@ void Thermostat::register_device_values() {
         register_device_value(
             DeviceValueTAG::TAG_DEVICE_DATA, &pvLowerCool_, DeviceValueType::INT8, FL_(pvLowerCool), DeviceValueUOM::K, MAKE_CF_CB(set_pvLowerCool), -5, 0);
         register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &absent_, DeviceValueType::BOOL, FL_(absent), DeviceValueUOM::NONE, MAKE_CF_CB(set_absent));
+        if (model() == EMSdevice::EMS_DEVICE_FLAG_UI800) {
+            register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
+                                  &hpoperatingmode,
+                                  DeviceValueType::ENUM,
+                                  FL_(enum_hpoperatingmode),
+                                  FL_(hpoperatingmode),
+                                  DeviceValueUOM::NONE,
+                                  MAKE_CF_CB(set_summermode));
+            register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
+                                  &summertemp,
+                                  DeviceValueType::UINT8,
+                                  FL_(summertemp),
+                                  DeviceValueUOM::DEGREES,
+                                  MAKE_CF_CB(set_summertemp),
+                                  10,
+                                  30);
+            register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
+                                  &instantstart,
+                                  DeviceValueType::UINT8,
+                                  FL_(instantstart),
+                                  DeviceValueUOM::K,
+                                  MAKE_CF_CB(set_instantstart),
+                                  1,
+                                  10);
+            register_device_value(
+                DeviceValueTAG::TAG_DEVICE_DATA, &coolstart, DeviceValueType::UINT8, FL_(coolstart), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_coolstart), 20, 35);
+            register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
+                                  &heatondelay,
+                                  DeviceValueType::UINT8,
+                                  DeviceValueNumOp::DV_NUMOP_DIV4,
+                                  FL_(heatondelay),
+                                  DeviceValueUOM::HOURS,
+                                  MAKE_CF_CB(set_heatondelay),
+                                  1,
+                                  48);
+            register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
+                                  &heatoffdelay,
+                                  DeviceValueType::UINT8,
+                                  DeviceValueNumOp::DV_NUMOP_DIV4,
+                                  FL_(heatoffdelay),
+                                  DeviceValueUOM::HOURS,
+                                  MAKE_CF_CB(set_heatoffdelay),
+                                  1,
+                                  48);
+            register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
+                                  &coolondelay,
+                                  DeviceValueType::UINT8,
+                                  DeviceValueNumOp::DV_NUMOP_DIV4,
+                                  FL_(coolondelay),
+                                  DeviceValueUOM::HOURS,
+                                  MAKE_CF_CB(set_coolondelay),
+                                  1,
+                                  48);
+            register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
+                                  &cooloffdelay,
+                                  DeviceValueType::UINT8,
+                                  DeviceValueNumOp::DV_NUMOP_DIV4,
+                                  FL_(cooloffdelay),
+                                  DeviceValueUOM::HOURS,
+                                  MAKE_CF_CB(set_cooloffdelay),
+                                  1,
+                                  48);
+        }
+
         break;
     case EMSdevice::EMS_DEVICE_FLAG_RC10:
         register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
@@ -4908,9 +5018,10 @@ void Thermostat::register_device_values_hc(std::shared_ptr<Thermostat::HeatingCi
     case EMSdevice::EMS_DEVICE_FLAG_RC300:
     case EMSdevice::EMS_DEVICE_FLAG_R3000:
     case EMSdevice::EMS_DEVICE_FLAG_BC400:
+    case EMSdevice::EMS_DEVICE_FLAG_UI800:
     case EMSdevice::EMS_DEVICE_FLAG_CR120:
     case EMSdevice::EMS_DEVICE_FLAG_HMC310:
-        if (model == EMSdevice::EMS_DEVICE_FLAG_BC400 || model == EMSdevice::EMS_DEVICE_FLAG_CR120) {
+        if (model == EMSdevice::EMS_DEVICE_FLAG_BC400 || model == EMSdevice::EMS_DEVICE_FLAG_UI800 || model == EMSdevice::EMS_DEVICE_FLAG_CR120) {
             register_device_value(tag, &hc->mode_new, DeviceValueType::ENUM, FL_(enum_mode2), FL_(mode), DeviceValueUOM::NONE, MAKE_CF_CB(set_mode));
         } else {
             register_device_value(tag, &hc->mode, DeviceValueType::ENUM, FL_(enum_mode), FL_(mode), DeviceValueUOM::NONE, MAKE_CF_CB(set_mode));
@@ -5003,6 +5114,8 @@ void Thermostat::register_device_values_hc(std::shared_ptr<Thermostat::HeatingCi
         register_device_value(tag, &hc->hpminflowtemp, DeviceValueType::UINT8, FL_(hpminflowtemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_hpminflowtemp));
         if (model == EMSdevice::EMS_DEVICE_FLAG_BC400) {
             register_device_value(tag, &hc->control, DeviceValueType::ENUM, FL_(enum_control2), FL_(control), DeviceValueUOM::NONE, MAKE_CF_CB(set_control));
+        } else if (model == EMSdevice::EMS_DEVICE_FLAG_UI800) {
+            register_device_value(tag, &hc->control, DeviceValueType::ENUM, FL_(enum_control3), FL_(control), DeviceValueUOM::NONE, MAKE_CF_CB(set_control));
         } else {
             register_device_value(tag, &hc->control, DeviceValueType::ENUM, FL_(enum_control1), FL_(control), DeviceValueUOM::NONE, MAKE_CF_CB(set_control));
         }
@@ -5018,14 +5131,16 @@ void Thermostat::register_device_values_hc(std::shared_ptr<Thermostat::HeatingCi
                                   101);
             register_device_value(tag, &hc->remotehum, DeviceValueType::CMD, FL_(remotehum), DeviceValueUOM::PERCENT, MAKE_CF_CB(set_remotehum), -1, 101);
         }
-        register_device_value(tag, &hc->heatondelay, DeviceValueType::UINT8, FL_(heatondelay), DeviceValueUOM::HOURS, MAKE_CF_CB(set_heatondelay), 1, 48);
-        register_device_value(tag, &hc->heatoffdelay, DeviceValueType::UINT8, FL_(heatoffdelay), DeviceValueUOM::HOURS, MAKE_CF_CB(set_heatoffdelay), 1, 48);
-        register_device_value(tag, &hc->instantstart, DeviceValueType::UINT8, FL_(instantstart), DeviceValueUOM::K, MAKE_CF_CB(set_instantstart), 1, 10);
+        if (model != EMSdevice::EMS_DEVICE_FLAG_UI800) {
+            register_device_value(tag, &hc->heatondelay, DeviceValueType::UINT8, FL_(heatondelay), DeviceValueUOM::HOURS, MAKE_CF_CB(set_heatondelay), 1, 48);
+            register_device_value(tag, &hc->heatoffdelay, DeviceValueType::UINT8, FL_(heatoffdelay), DeviceValueUOM::HOURS, MAKE_CF_CB(set_heatoffdelay), 1, 48);
+            register_device_value(tag, &hc->coolondelay, DeviceValueType::UINT8, FL_(coolondelay), DeviceValueUOM::HOURS, MAKE_CF_CB(set_coolondelay), 1, 48);
+            register_device_value(tag, &hc->cooloffdelay, DeviceValueType::UINT8, FL_(cooloffdelay), DeviceValueUOM::HOURS, MAKE_CF_CB(set_cooloffdelay), 1, 48);
+            register_device_value(tag, &hc->instantstart, DeviceValueType::UINT8, FL_(instantstart), DeviceValueUOM::K, MAKE_CF_CB(set_instantstart), 1, 10);
+            register_device_value(tag, &hc->coolstart, DeviceValueType::UINT8, FL_(coolstart), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_coolstart), 20, 35);
+        }
         register_device_value(tag, &hc->boost, DeviceValueType::BOOL, FL_(boost), DeviceValueUOM::NONE, MAKE_CF_CB(set_boost));
         register_device_value(tag, &hc->boosttime, DeviceValueType::UINT8, FL_(boosttime), DeviceValueUOM::HOURS, MAKE_CF_CB(set_boosttime));
-        register_device_value(tag, &hc->coolstart, DeviceValueType::UINT8, FL_(coolstart), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_coolstart), 20, 35);
-        register_device_value(tag, &hc->coolondelay, DeviceValueType::UINT8, FL_(coolondelay), DeviceValueUOM::HOURS, MAKE_CF_CB(set_coolondelay), 1, 48);
-        register_device_value(tag, &hc->cooloffdelay, DeviceValueType::UINT8, FL_(cooloffdelay), DeviceValueUOM::HOURS, MAKE_CF_CB(set_cooloffdelay), 1, 48);
         register_device_value(tag,
                               &hc->switchProgMode,
                               DeviceValueType::ENUM,
@@ -5365,9 +5480,10 @@ void Thermostat::register_device_values_dhw(std::shared_ptr<Thermostat::DhwCircu
     case EMSdevice::EMS_DEVICE_FLAG_RC300:
     case EMSdevice::EMS_DEVICE_FLAG_R3000:
     case EMSdevice::EMS_DEVICE_FLAG_BC400:
+    case EMSdevice::EMS_DEVICE_FLAG_UI800:
     case EMSdevice::EMS_DEVICE_FLAG_CR120:
     case EMSdevice::EMS_DEVICE_FLAG_HMC310:
-        if (model() == EMSdevice::EMS_DEVICE_FLAG_BC400 || model() == EMSdevice::EMS_DEVICE_FLAG_HMC310) {
+        if (model() == EMSdevice::EMS_DEVICE_FLAG_BC400 || model() == EMSdevice::EMS_DEVICE_FLAG_UI800 || model() == EMSdevice::EMS_DEVICE_FLAG_HMC310) {
             register_device_value(tag, &dhw->wwMode_, DeviceValueType::ENUM, FL_(enum_wwMode4), FL_(wwMode), DeviceValueUOM::NONE, MAKE_CF_CB(set_wwmode));
         } else if (model() == EMSdevice::EMS_DEVICE_FLAG_R3000) {
             register_device_value(tag, &dhw->wwMode_, DeviceValueType::ENUM, FL_(enum_wwMode5), FL_(wwMode), DeviceValueUOM::NONE, MAKE_CF_CB(set_wwmode));

src/devices/thermostat.h

@@ -241,7 +241,7 @@ class Thermostat : public EMSdevice {
     // check to see if the thermostat is a hybrid of the R300
     inline bool isRC300() const {
         return (model() == EMSdevice::EMS_DEVICE_FLAG_RC300 || model() == EMSdevice::EMS_DEVICE_FLAG_R3000 || model() == EMSdevice::EMS_DEVICE_FLAG_BC400
-                || model() == EMSdevice::EMS_DEVICE_FLAG_CR120 || model() == EMSdevice::EMS_DEVICE_FLAG_HMC310);
+                || model() == EMSdevice::EMS_DEVICE_FLAG_CR120 || model() == EMSdevice::EMS_DEVICE_FLAG_HMC310 || model() == EMSdevice::EMS_DEVICE_FLAG_UI800);
     }
 
     inline uint8_t id2dhw(const int8_t id) const { // returns telegram offset for TAG(id)
@@ -296,6 +296,16 @@ class Thermostat : public EMSdevice {
     uint8_t absent_;
     uint8_t hasSolar_;
 
+    // BC400/UI800 telegram 0x470
+    uint8_t hpoperatingmode;
+    uint8_t summertemp;
+    uint8_t heatondelay;
+    uint8_t heatoffdelay;
+    uint8_t instantstart;
+    uint8_t coolstart;
+    uint8_t coolondelay;
+    uint8_t cooloffdelay;    
+
     // HybridHP
     uint8_t hybridStrategy_;  // co2 = 1, cost = 2, temperature = 3, mix = 4
     int8_t  switchOverTemp_;  // degrees
@@ -451,6 +461,7 @@ class Thermostat : public EMSdevice {
     void process_RC300Set2(const std::shared_ptr<const Telegram> & telegram);
     void process_RC300Summer(const std::shared_ptr<const Telegram> & telegram);
     void process_RC300Summer2(const std::shared_ptr<const Telegram> & telegram);
+    void process_RC300Summer3(const std::shared_ptr<const Telegram> & telegram);
     void process_RC300WWmode(const std::shared_ptr<const Telegram> & telegram);
     void process_RC300WWmode2(const std::shared_ptr<const Telegram> & telegram);
     void process_RC300WWtemp(const std::shared_ptr<const Telegram> & telegram);

src/uart/emsuart_esp32.cpp

@@ -159,7 +159,7 @@ uint8_t EMSuart::transmit(const uint8_t * buf, const uint8_t len) {
         return EMS_TX_STATUS_OK;
     }
 
-   auto tx_mode = tx_mode_ != EMS_TXMODE_AUTO ? tx_mode_ : EMSbus::is_ht3() ? EMS_TXMODE_HT3 : EMSbus::is_ems2() ? EMS_TXMODE_EMSPLUS : EMS_TXMODE_EMS;
+    auto tx_mode = tx_mode_ != EMS_TXMODE_AUTO ? tx_mode_ : EMSbus::is_ht3() ? EMS_TXMODE_HT3 : EMSbus::is_ems2() ? EMS_TXMODE_EMSPLUS : EMS_TXMODE_EMS;
 
     // TXMODE is EMS+ with long delay
     if (tx_mode == EMS_TXMODE_EMSPLUS) {