Merge pull request #2651 from MichaelDvP/dev

add SRC tags,no remote for Junkers_old

src/core/command.cpp

@@ -131,6 +131,9 @@ uint8_t Command::process(const char * path, const bool is_admin, const JsonObjec
         } else if (input["hs"].is<int>()) {
             id_n = input["hs"];
             id_n += DeviceValueTAG::TAG_HS1 - DeviceValueTAG::TAG_HC1; // hs1 has id 20
+        } else if (input["src"].is<int>()) {
+            id_n = input["src"];
+            id_n += DeviceValueTAG::TAG_SRC1 - DeviceValueTAG::TAG_HC1; // src1 has id 36
         }
     }
 
@@ -268,6 +271,12 @@ const char * Command::parse_command_string(const char * command, int8_t & id) {
     } else if (!strncmp(lowerCmd, "hs", 2) && command[2] >= '1' && command[2] <= '9') {
         id = command[2] - '1' + DeviceValueTAG::TAG_HS1; //20;
         command += 3;
+    } else if (!strncmp(lowerCmd, "src", 3) && command[2] == '1' && command[3] >= '0' && command[3] <= '6') {
+        id = command[3] - '0' + DeviceValueTAG::TAG_SRC10; //46;
+        command += 4;
+    } else if (!strncmp(lowerCmd, "src", 3) && command[2] >= '1' && command[2] <= '9') {
+        id = command[2] - '1' + DeviceValueTAG::TAG_SRC1; //36;
+        command += 3;
     } else if (!strncmp(lowerCmd, "dhw", 3)) { // no number
         id = DeviceValueTAG::TAG_DHW1;
         command += 3;
@@ -387,13 +396,15 @@ uint8_t Command::call(const uint8_t device_type, const char * command, const cha
         flag = CommandFlag::CMD_FLAG_HS;
     } else if (id >= DeviceValueTAG::TAG_AHS1 && id <= DeviceValueTAG::TAG_AHS1) {
         flag = CommandFlag::CMD_FLAG_AHS;
+    } else if (id >= DeviceValueTAG::TAG_SRC1 && id <= DeviceValueTAG::TAG_SRC16) {
+        flag = CommandFlag::CMD_FLAG_SRC;
     }
 
     // see if there is a command registered for this EMS device
     auto cf = find_command(device_type, device_id, cmd, flag);
     if (!cf) {
         // if we don't already have a message set, set it to invalid command
-        if (output["message"]) {
+        if (output["message"].is<const char *>()) {
             LOG_WARNING("Command failed: %s", output["message"].as<const char *>());
             return CommandRet::ERROR;
         } else {
@@ -663,6 +674,9 @@ void Command::show(uuid::console::Shell & shell, uint8_t device_type, bool verbo
                 } else if (cf.has_flags(CommandFlag::CMD_FLAG_HS)) {
                     shell.print(Helpers::translated_word(FL_(tag_hsx)));
                     shell.print(' ');
+                } else if (cf.has_flags(CommandFlag::CMD_FLAG_SRC)) {
+                    shell.print(Helpers::translated_word(FL_(tag_srcx)));
+                    shell.print(' ');
                 }
                 shell.print(Helpers::translated_word(cf.description_));
                 if (!cf.has_flags(CommandFlag::ADMIN_ONLY)) {

src/core/command.h

@@ -36,6 +36,7 @@ enum CommandFlag : uint8_t {
     CMD_FLAG_DHW     = (1 << 1), // 2 TAG_DHW1 - TAG_DHW4
     CMD_FLAG_AHS     = (1 << 2), // 4 TAG_AHS1
     CMD_FLAG_HS      = (1 << 3), // 8 TAG_HS1 - TAG_HS16
+    CMD_FLAG_SRC     = (1 << 4), // 16 TAG_SRC1 - TAG_SRC16
     HIDDEN           = (1 << 6), // 64 do not show in API or Web
     ADMIN_ONLY       = (1 << 7)  // 128 requires authentication
 

src/core/emsdevice.cpp

@@ -644,6 +644,8 @@ void EMSdevice::add_device_value(int8_t                tag,              // to b
             flags |= CommandFlag::CMD_FLAG_HS;
         } else if (tag >= DeviceValueTAG::TAG_AHS1 && tag <= DeviceValueTAG::TAG_AHS1) {
             flags |= CommandFlag::CMD_FLAG_AHS;
+        } else if (tag >= DeviceValueTAG::TAG_SRC1 && tag <= DeviceValueTAG::TAG_SRC16) {
+            flags |= CommandFlag::CMD_FLAG_SRC;
         }
 
         // add the command to our library
@@ -905,7 +907,7 @@ bool EMSdevice::export_values(uint8_t device_type, JsonObject output, const int8
     }
 
     // for nested output add for each tag
-    for (int8_t tag = DeviceValueTAG::TAG_DEVICE_DATA; tag <= DeviceValueTAG::TAG_HS16; tag++) {
+    for (int8_t tag = DeviceValueTAG::TAG_DEVICE_DATA; tag <= DeviceValueTAG::TAG_SRC16; tag++) {
         JsonObject output_hc    = output;
         bool       nest_created = false;
         for (const auto & emsdevice : EMSESP::emsdevices) {
@@ -1899,8 +1901,8 @@ void EMSdevice::mqtt_ha_entity_config_create() {
                 create_device_config = false; // only create the main config once
                 count++;
             }
-            // SRC thermostats mapped to connect/hs1/...
+            // SRC thermostats mapped to connect/src1/...
-            if (dv.tag >= DeviceValueTAG::TAG_HS1 && !strcmp(dv.short_name, FL_(roomtemp)[0])) {
+            if (dv.tag >= DeviceValueTAG::TAG_SRC1 && !strcmp(dv.short_name, FL_(roomtemp)[0])) {
                 Mqtt::publish_ha_climate_config(dv.tag, true, false, dv.min, dv.max);
             }
 

src/core/emsdevicevalue.cpp

@@ -153,7 +153,23 @@ const char * const * DeviceValue::DeviceValueTAG_s[] = {
     FL_(tag_hs13),        // "hs13"
     FL_(tag_hs14),        // "hs14"
     FL_(tag_hs15),        // "hs15"
-    FL_(tag_hs16)         // "hs16"
+    FL_(tag_hs16),        // "hs16"
+    FL_(tag_src1),        // "src1"
+    FL_(tag_src2),        // "src2"
+    FL_(tag_src3),        // "src3"
+    FL_(tag_src4),        // "src4"
+    FL_(tag_src5),        // "src5"
+    FL_(tag_src6),        // "src6"
+    FL_(tag_src7),        // "src7"
+    FL_(tag_src8),        // "src8"
+    FL_(tag_src9),        // "src9"
+    FL_(tag_src10),       // "src10"
+    FL_(tag_src11),       // "src11"
+    FL_(tag_src12),       // "src12"
+    FL_(tag_src13),       // "src13"
+    FL_(tag_src14),       // "src14"
+    FL_(tag_src15),       // "src15"
+    FL_(tag_src16)        // "src16"
 
 };
 
@@ -195,7 +211,24 @@ const char * const DeviceValue::DeviceValueTAG_mqtt[] = {
     FL_(tag_hs13)[0],        // "hs13"
     FL_(tag_hs14)[0],        // "hs14"
     FL_(tag_hs15)[0],        // "hs15"
-    FL_(tag_hs16)[0]         // "hs16"
+    FL_(tag_hs16)[0],        // "hs16"
+    FL_(tag_src1)[0],        // "src1"
+    FL_(tag_src2)[0],        // "src2"
+    FL_(tag_src3)[0],        // "src3"
+    FL_(tag_src4)[0],        // "src4"
+    FL_(tag_src5)[0],        // "src5"
+    FL_(tag_src6)[0],        // "src6"
+    FL_(tag_src7)[0],        // "src7"
+    FL_(tag_src8)[0],        // "src8"
+    FL_(tag_src9)[0],        // "src9"
+    FL_(tag_src10)[0],       // "src10"
+    FL_(tag_src11)[0],       // "src11"
+    FL_(tag_src12)[0],       // "src12"
+    FL_(tag_src13)[0],       // "src13"
+    FL_(tag_src14)[0],       // "src14"
+    FL_(tag_src15)[0],       // "src15"
+    FL_(tag_src16)[0]        // "src16"
+
 
 };
 

src/core/emsdevicevalue.h

@@ -117,7 +117,24 @@ class DeviceValue {
         TAG_HS13,
         TAG_HS14,
         TAG_HS15,
-        TAG_HS16
+        TAG_HS16,
+        TAG_SRC1,
+        TAG_SRC2,
+        TAG_SRC3,
+        TAG_SRC4,
+        TAG_SRC5,
+        TAG_SRC6,
+        TAG_SRC7,
+        TAG_SRC8,
+        TAG_SRC9,
+        TAG_SRC10,
+        TAG_SRC11,
+        TAG_SRC12,
+        TAG_SRC13,
+        TAG_SRC14,
+        TAG_SRC15,
+        TAG_SRC16
+
     };
 
     // states of a device value

src/core/emsesp.cpp

@@ -649,7 +649,7 @@ void EMSESP::publish_device_values(uint8_t device_type) {
     bool         nested       = (Mqtt::is_nested());
 
     // group by device type
-    for (int8_t tag = DeviceValueTAG::TAG_DEVICE_DATA; tag <= DeviceValueTAG::TAG_HS16; tag++) {
+    for (int8_t tag = DeviceValueTAG::TAG_DEVICE_DATA; tag <= DeviceValueTAG::TAG_SRC16; tag++) {
         JsonObject json_tag     = json;
         bool       nest_created = false;
         for (const auto & emsdevice : emsdevices) {

src/core/locale_translations.h

@@ -102,29 +102,47 @@ MAKE_WORD_TRANSLATION(tag_dhw7, "dhw7", "WWK7", "dhw7", "VVK7", "CWU7", "dhw7",
 MAKE_WORD_TRANSLATION(tag_dhw8, "dhw8", "WWK8", "dhw8", "VVK8", "CWU8", "dhw8", "ecs8", "SKS8", "dhw8", "TÚV8", "TUV8")
 MAKE_WORD_TRANSLATION(tag_dhw9, "dhw9", "WWK9", "dhw9", "VVK9", "CWU9", "dhw9", "ecs9", "SKS9", "dhw9", "TÚV9", "TUV9")
 MAKE_WORD_TRANSLATION(tag_dhw10, "dhw10", "WWK10", "dhw10", "VVK10", "CWU10", "dhw10", "ecs10", "SKS10", "dhw10", "TÚV10", "TUV10")
-
+// heatingsources
 MAKE_WORD_TRANSLATION(tag_ahs1, "ahs1", "AHQ1", "ahs1", "AVK1", "AŹC1", "ahs1", "ahs1", "ahs1", "ahs1", "ahs1", "ahs1")
-MAKE_WORD_TRANSLATION(tag_hs1, "hs1", "hs1", "hs1", "VK1", "ŹC1", "hs1", "hs1", "hs1", "hs1", "hs1", "hs1")
+MAKE_WORD_TRANSLATION(tag_hs1, "hs1", "HQ1", "hs1", "VK1", "ŹC1", "hs1", "hs1", "hs1", "hs1", "hs1", "hs1")
-MAKE_WORD_TRANSLATION(tag_hs2, "hs2", "hs2", "hs2", "VK2", "ŹC2", "hs2", "hs2", "hs2", "hs2", "hs2", "hs2")
+MAKE_WORD_TRANSLATION(tag_hs2, "hs2", "HQ2", "hs2", "VK2", "ŹC2", "hs2", "hs2", "hs2", "hs2", "hs2", "hs2")
-MAKE_WORD_TRANSLATION(tag_hs3, "hs3", "hs3", "hs3", "VK3", "ŹC3", "hs3", "hs3", "hs3", "hs3", "hs3", "hs3")
+MAKE_WORD_TRANSLATION(tag_hs3, "hs3", "HQ3", "hs3", "VK3", "ŹC3", "hs3", "hs3", "hs3", "hs3", "hs3", "hs3")
-MAKE_WORD_TRANSLATION(tag_hs4, "hs4", "hs4", "hs4", "VK4", "ŹC4", "hs4", "hs4", "hs4", "hs4", "hs4", "hs4")
+MAKE_WORD_TRANSLATION(tag_hs4, "hs4", "HQ4", "hs4", "VK4", "ŹC4", "hs4", "hs4", "hs4", "hs4", "hs4", "hs4")
-MAKE_WORD_TRANSLATION(tag_hs5, "hs5", "hs5", "hs5", "VK5", "ŹC5", "hs5", "hs5", "hs5", "hs5", "hs5", "hs5")
+MAKE_WORD_TRANSLATION(tag_hs5, "hs5", "HQ5", "hs5", "VK5", "ŹC5", "hs5", "hs5", "hs5", "hs5", "hs5", "hs5")
-MAKE_WORD_TRANSLATION(tag_hs6, "hs6", "hs6", "hs6", "VK6", "ŹC6", "hs6", "hs6", "hs6", "hs6", "hs6", "hs6")
+MAKE_WORD_TRANSLATION(tag_hs6, "hs6", "HQ6", "hs6", "VK6", "ŹC6", "hs6", "hs6", "hs6", "hs6", "hs6", "hs6")
-MAKE_WORD_TRANSLATION(tag_hs7, "hs7", "hs7", "hs7", "VK7", "ŹC7", "hs7", "hs7", "hs7", "hs7", "hs7", "hs7")
+MAKE_WORD_TRANSLATION(tag_hs7, "hs7", "HQ7", "hs7", "VK7", "ŹC7", "hs7", "hs7", "hs7", "hs7", "hs7", "hs7")
-MAKE_WORD_TRANSLATION(tag_hs8, "hs8", "hs8", "hs8", "VK8", "ŹC8", "hs8", "hs8", "hs8", "hs8", "hs8", "hs8")
+MAKE_WORD_TRANSLATION(tag_hs8, "hs8", "HQ8", "hs8", "VK8", "ŹC8", "hs8", "hs8", "hs8", "hs8", "hs8", "hs8")
-MAKE_WORD_TRANSLATION(tag_hs9, "hs9", "hs9", "hs9", "VK9", "ŹC9", "hs9", "hs9", "hs9", "hs9", "hs9", "hs9")
+MAKE_WORD_TRANSLATION(tag_hs9, "hs9", "HQ9", "hs9", "VK9", "ŹC9", "hs9", "hs9", "hs9", "hs9", "hs9", "hs9")
-MAKE_WORD_TRANSLATION(tag_hs10, "hs10", "hs10", "hs10", "VK10", "ŹC10", "hs10", "hs10", "hs10", "hs10", "hs10", "hs10")
+MAKE_WORD_TRANSLATION(tag_hs10, "hs10", "HQ10", "hs10", "VK10", "ŹC10", "hs10", "hs10", "hs10", "hs10", "hs10", "hs10")
-MAKE_WORD_TRANSLATION(tag_hs11, "hs11", "hs11", "hs11", "VK11", "ŹC11", "hs11", "hs11", "hs11", "hs11", "hs11", "hs11")
+MAKE_WORD_TRANSLATION(tag_hs11, "hs11", "HQ11", "hs11", "VK11", "ŹC11", "hs11", "hs11", "hs11", "hs11", "hs11", "hs11")
-MAKE_WORD_TRANSLATION(tag_hs12, "hs12", "hs12", "hs12", "VK12", "ŹC12", "hs12", "hs12", "hs12", "hs12", "hs12", "hs12")
+MAKE_WORD_TRANSLATION(tag_hs12, "hs12", "HQ12", "hs12", "VK12", "ŹC12", "hs12", "hs12", "hs12", "hs12", "hs12", "hs12")
-MAKE_WORD_TRANSLATION(tag_hs13, "hs13", "hs13", "hs13", "VK13", "ŹC13", "hs13", "hs13", "hs13", "hs13", "hs13", "hs13")
+MAKE_WORD_TRANSLATION(tag_hs13, "hs13", "HQ13", "hs13", "VK13", "ŹC13", "hs13", "hs13", "hs13", "hs13", "hs13", "hs13")
-MAKE_WORD_TRANSLATION(tag_hs14, "hs14", "hs14", "hs14", "VK14", "ŹC14", "hs14", "hs14", "hs14", "hs14", "hs14", "hs14")
+MAKE_WORD_TRANSLATION(tag_hs14, "hs14", "HQ14", "hs14", "VK14", "ŹC14", "hs14", "hs14", "hs14", "hs14", "hs14", "hs14")
-MAKE_WORD_TRANSLATION(tag_hs15, "hs15", "hs15", "hs15", "VK15", "ŹC15", "hs15", "hs15", "hs15", "hs15", "hs15", "hs15")
+MAKE_WORD_TRANSLATION(tag_hs15, "hs15", "HQ15", "hs15", "VK15", "ŹC15", "hs15", "hs15", "hs15", "hs15", "hs15", "hs15")
-MAKE_WORD_TRANSLATION(tag_hs16, "hs16", "hs16", "hs16", "VK16", "ŹC16", "hs16", "hs16", "hs16", "hs16", "hs16", "hs16")
+MAKE_WORD_TRANSLATION(tag_hs16, "hs16", "HQ16", "hs16", "VK16", "ŹC16", "hs16", "hs16", "hs16", "hs16", "hs16", "hs16")
+// single room thermostats
+MAKE_WORD_TRANSLATION(tag_src1, "src1", "SRC1")
+MAKE_WORD_TRANSLATION(tag_src2, "src2", "SRC2")
+MAKE_WORD_TRANSLATION(tag_src3, "src3", "SRC3")
+MAKE_WORD_TRANSLATION(tag_src4, "src4", "SRC4")
+MAKE_WORD_TRANSLATION(tag_src5, "src5", "SRC5")
+MAKE_WORD_TRANSLATION(tag_src6, "src6", "SRC6")
+MAKE_WORD_TRANSLATION(tag_src7, "src7", "SRC7")
+MAKE_WORD_TRANSLATION(tag_src8, "src8", "SRC8")
+MAKE_WORD_TRANSLATION(tag_src9, "src9", "SRC9")
+MAKE_WORD_TRANSLATION(tag_src10, "src10", "SRC10")
+MAKE_WORD_TRANSLATION(tag_src11, "src11", "SRC11")
+MAKE_WORD_TRANSLATION(tag_src12, "src12", "SRC12")
+MAKE_WORD_TRANSLATION(tag_src13, "src13", "SRC13")
+MAKE_WORD_TRANSLATION(tag_src14, "src14", "SRC14")
+MAKE_WORD_TRANSLATION(tag_src15, "src15", "SRC15")
+MAKE_WORD_TRANSLATION(tag_src16, "src16", "SRC16")
 
 MAKE_WORD_TRANSLATION(tag_hcx, "hc<n>", "HK<n>", "hc<n>", "VK<n>", "OG<n>", "hc<n>", "hc<n>", "ID<n>", "hc<n>", "hc<n>", "hc<n>")
 MAKE_WORD_TRANSLATION(tag_dhwx, "dhw[n]", "WWK[n]", "dhw[n]", "VVK[n]", "CWU[n]", "dhw[n]", "ecs[n]", "SKS[n]", "dhw[n]", "TÚV[n]", "TUV[n]")
 MAKE_WORD_TRANSLATION(tag_ahsx, "ahs<n>", "AHQ<n>", "ahs<n>", "AVK<n>", "AŹC<n>", "ahs<n>", "ahs<n>", "ahs<n>", "ahs<n>", "ahs<n>", "ahs<n>")
 MAKE_WORD_TRANSLATION(tag_hsx, "hs<n>", "HQ<n>", "hs<n>", "VK<n>", "ŹC<n>", "hs<n>", "hs<n>", "hs<n>", "hs<n>", "hs<n>", "hs<n>")
+MAKE_WORD_TRANSLATION(tag_srcx, "src<n>", "SRC<n>")
 
 // General
 MAKE_WORD_TRANSLATION(on, "on", "an", "aan", "på", "włączono", "på", "on", "açık", "on", "zap", "zap")

src/core/modbus.cpp

@@ -86,56 +86,24 @@ int8_t Modbus::tag_to_type(int8_t tag) {
         return TAG_TYPE_DEVICE_DATA;
 
     case DeviceValue::TAG_HC1:
-        return TAG_TYPE_HC;
-
     case DeviceValue::TAG_HC2:
-        return TAG_TYPE_HC;
-
     case DeviceValue::TAG_HC3:
-        return TAG_TYPE_HC;
-
     case DeviceValue::TAG_HC4:
-        return TAG_TYPE_HC;
-
     case DeviceValue::TAG_HC5:
-        return TAG_TYPE_HC;
-
     case DeviceValue::TAG_HC6:
-        return TAG_TYPE_HC;
-
     case DeviceValue::TAG_HC7:
-        return TAG_TYPE_HC;
-
     case DeviceValue::TAG_HC8:
         return TAG_TYPE_HC;
 
     case DeviceValue::TAG_DHW1:
-        return TAG_TYPE_DHW;
-
     case DeviceValue::TAG_DHW2:
-        return TAG_TYPE_DHW;
-
     case DeviceValue::TAG_DHW3:
-        return TAG_TYPE_DHW;
-
     case DeviceValue::TAG_DHW4:
-        return TAG_TYPE_DHW;
-
     case DeviceValue::TAG_DHW5:
-        return TAG_TYPE_DHW;
-
     case DeviceValue::TAG_DHW6:
-        return TAG_TYPE_DHW;
-
     case DeviceValue::TAG_DHW7:
-        return TAG_TYPE_DHW;
-
     case DeviceValue::TAG_DHW8:
-        return TAG_TYPE_DHW;
-
     case DeviceValue::TAG_DHW9:
-        return TAG_TYPE_DHW;
-
     case DeviceValue::TAG_DHW10:
         return TAG_TYPE_DHW;
 
@@ -143,53 +111,40 @@ int8_t Modbus::tag_to_type(int8_t tag) {
         return TAG_TYPE_AHS;
 
     case DeviceValue::TAG_HS1:
-        return TAG_TYPE_HS;
-
     case DeviceValue::TAG_HS2:
-        return TAG_TYPE_HS;
-
     case DeviceValue::TAG_HS3:
-        return TAG_TYPE_HS;
-
     case DeviceValue::TAG_HS4:
-        return TAG_TYPE_HS;
-
     case DeviceValue::TAG_HS5:
-        return TAG_TYPE_HS;
-
     case DeviceValue::TAG_HS6:
-        return TAG_TYPE_HS;
-
     case DeviceValue::TAG_HS7:
-        return TAG_TYPE_HS;
-
     case DeviceValue::TAG_HS8:
-        return TAG_TYPE_HS;
-
     case DeviceValue::TAG_HS9:
-        return TAG_TYPE_HS;
-
     case DeviceValue::TAG_HS10:
-        return TAG_TYPE_HS;
-
     case DeviceValue::TAG_HS11:
-        return TAG_TYPE_HS;
-
     case DeviceValue::TAG_HS12:
-        return TAG_TYPE_HS;
-
     case DeviceValue::TAG_HS13:
-        return TAG_TYPE_HS;
-
     case DeviceValue::TAG_HS14:
-        return TAG_TYPE_HS;
-
     case DeviceValue::TAG_HS15:
-        return TAG_TYPE_HS;
-
     case DeviceValue::TAG_HS16:
         return TAG_TYPE_HS;
 
+    case DeviceValue::TAG_SRC1:
+    case DeviceValue::TAG_SRC2:
+    case DeviceValue::TAG_SRC3:
+    case DeviceValue::TAG_SRC4:
+    case DeviceValue::TAG_SRC5:
+    case DeviceValue::TAG_SRC6:
+    case DeviceValue::TAG_SRC7:
+    case DeviceValue::TAG_SRC8:
+    case DeviceValue::TAG_SRC9:
+    case DeviceValue::TAG_SRC10:
+    case DeviceValue::TAG_SRC11:
+    case DeviceValue::TAG_SRC12:
+    case DeviceValue::TAG_SRC13:
+    case DeviceValue::TAG_SRC14:
+    case DeviceValue::TAG_SRC15:
+    case DeviceValue::TAG_SRC16:
+        return TAG_TYPE_SRC;
     default:
         return INVALID_TAG_TYPE;
     }

src/core/modbus.h

@@ -84,6 +84,7 @@ class Modbus {
         TAG_TYPE_DHW         = DeviceValue::DeviceValueTAG::TAG_DHW1,
         TAG_TYPE_AHS         = DeviceValue::DeviceValueTAG::TAG_AHS1,
         TAG_TYPE_HS          = DeviceValue::DeviceValueTAG::TAG_HS1,
+        TAG_TYPE_SRC         = DeviceValue::DeviceValueTAG::TAG_SRC1,
         INVALID_TAG_TYPE     = -2
     };
 

src/devices/connect.cpp

@@ -26,6 +26,9 @@ Connect::Connect(uint8_t device_type, uint8_t device_id, uint8_t product_id, con
     : EMSdevice(device_type, device_id, product_id, version, name, flags, brand) {
     if (device_id == 0x50) { // RF Base
         register_telegram_type(0xD1, "RFOutdoorTemp", false, MAKE_PF_CB(process_OutdoorTemp));
+        register_telegram_type(0x06, "RCTime", false, MAKE_PF_CB(process_RCTime));
+
+        register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &dateTime_, DeviceValueType::STRING, FL_(tpl_datetime), FL_(dateTime), DeviceValueUOM::NONE);
         register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
                               &outdoorTemp_,
                               DeviceValueType::INT16,
@@ -53,13 +56,31 @@ void Connect::process_OutdoorTemp(std::shared_ptr<const Telegram> telegram) {
     has_update(telegram, outdoorTemp_, 0);
 }
 
+// sent if thermostat is connected
+// https://github.com/emsesp/EMS-ESP32/issues/2277
+void Connect::process_RCTime(std::shared_ptr<const Telegram> telegram) {
+    if (telegram->offset || telegram->message_length < 10) {
+        return;
+    }
+    char time[sizeof(dateTime_)];
+    snprintf(time,
+             sizeof(time),
+             "%02d.%02d.%04d %02d:%02d",
+             telegram->message_data[3],
+             telegram->message_data[1],
+             telegram->message_data[0] + 2000,
+             telegram->message_data[2],
+             telegram->message_data[4]);
+    has_update(dateTime_, time, sizeof(dateTime_));
+}
+
 /* other values from 0x50 RF base
 (0x087F), data: 00 00
 (0x0880), data: 01 04
 (0x0889), data: 00 80 80 01
 */
 void Connect::register_device_values_room(std::shared_ptr<Connect::RoomCircuit> room) {
-    auto tag = DeviceValueTAG::TAG_HS1 + room->room();
+    auto tag = DeviceValueTAG::TAG_SRC1 + room->room();
     register_device_value(tag, &room->temp_, DeviceValueType::INT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(roomTemp), DeviceValueUOM::DEGREES);
     register_device_value(tag, &room->humidity_, DeviceValueType::INT8, FL_(airHumidity), DeviceValueUOM::PERCENT);
     register_device_value(tag, &room->dewtemp_, DeviceValueType::INT16, DeviceValueNumOp::DV_NUMOP_DIV10, FL_(dewTemperature), DeviceValueUOM::DEGREES);
@@ -156,7 +177,7 @@ void Connect::process_roomThermostatData(std::shared_ptr<const Telegram> telegra
 // Settings:
 
 bool Connect::set_mode(const char * value, const int8_t id) {
-    auto rc = room_circuit(id - DeviceValueTAG::TAG_HS1);
+    auto rc = room_circuit(id - DeviceValueTAG::TAG_SRC1);
     if (rc == nullptr) {
         return false;
     }
@@ -170,7 +191,7 @@ bool Connect::set_mode(const char * value, const int8_t id) {
 }
 
 bool Connect::set_seltemp(const char * value, const int8_t id) {
-    auto rc = room_circuit(id - DeviceValueTAG::TAG_HS1);
+    auto rc = room_circuit(id - DeviceValueTAG::TAG_SRC1);
     if (rc == nullptr) {
         return false;
     }
@@ -184,7 +205,7 @@ bool Connect::set_seltemp(const char * value, const int8_t id) {
 }
 
 bool Connect::set_name(const char * value, const int8_t id) {
-    auto rc = room_circuit(id - DeviceValueTAG::TAG_HS1);
+    auto rc = room_circuit(id - DeviceValueTAG::TAG_SRC1);
     if (rc == nullptr || value == nullptr || strlen(value) > 50) {
         return false;
     }

src/devices/connect.h

@@ -64,7 +64,9 @@ class Connect : public EMSdevice {
     std::vector<std::shared_ptr<Connect::RoomCircuit>> room_circuits_;
 
     void    process_OutdoorTemp(std::shared_ptr<const Telegram> telegram);
+    void    process_RCTime(std::shared_ptr<const Telegram> telegram);
     int16_t outdoorTemp_;
+    char    dateTime_[30]; // date and time stamp
 };
 
 } // namespace emsesp

src/devices/thermostat.cpp

@@ -2071,7 +2071,7 @@ bool Thermostat::set_remotetemp(const char * value, const int8_t id) {
         hc->remotetemp = (int16_t)(f * 10);
     }
 
-    if (model() == EMSdevice::EMS_DEVICE_FLAG_JUNKERS) {
+    if (model() == EMSdevice::EMS_DEVICE_FLAG_JUNKERS && !has_flags(EMSdevice::EMS_DEVICE_FLAG_JUNKERS_OLD)) {
         Roomctrl::set_remotetemp(Roomctrl::FB10, hc->hc(), hc->remotetemp); // FB10
     } else if (model() == EMSdevice::EMS_DEVICE_FLAG_RC35 || model() == EMSdevice::EMS_DEVICE_FLAG_RC30_N) {
         Roomctrl::set_remotetemp(Roomctrl::RC20, hc->hc(), hc->remotetemp); // RC20