Merge pull request #815 from MichaelDvP/dev

Additions for #802, #803

CHANGELOG_LATEST.md

@@ -25,6 +25,7 @@
 - Use HA connectivity device class for Status, added boot time [#751](https://github.com/emsesp/EMS-ESP32/issues/751)
 - Add commands for analog sensors outputs
 - Support for multiple EMS-ESPs with MQTT and HA [[#759](https://github.com/emsesp/EMS-ESP32/issues/759)]
+- Settings for heatpump silent mode and additional heater [[#802](https://github.com/emsesp/EMS-ESP32/issues/802)] [[#803](https://github.com/emsesp/EMS-ESP32/issues/803)]
 
 ## Fixed
 

interface/src/SignIn.tsx

@@ -118,25 +118,25 @@ const SignIn: FC = () => {
             <DEflag style={{ width: 24 }} />
             &nbsp;DE
           </Button>
+          <Button size="small" variant={locale === 'fr' ? 'contained' : 'outlined'} onClick={() => selectLocale('fr')}>
+            <FRflag style={{ width: 24 }} />
+            &nbsp;FR
+          </Button>
           <Button size="small" variant={locale === 'nl' ? 'contained' : 'outlined'} onClick={() => selectLocale('nl')}>
             <NLflag style={{ width: 24 }} />
             &nbsp;NL
           </Button>
-          <Button size="small" variant={locale === 'se' ? 'contained' : 'outlined'} onClick={() => selectLocale('se')}>
-            <SEflag style={{ width: 24 }} />
-            &nbsp;SE
-          </Button>
-          <Button size="small" variant={locale === 'pl' ? 'contained' : 'outlined'} onClick={() => selectLocale('pl')}>
-            <PLflag style={{ width: 24 }} />
-            &nbsp;PL
-          </Button>
           <Button size="small" variant={locale === 'no' ? 'contained' : 'outlined'} onClick={() => selectLocale('no')}>
             <NOflag style={{ width: 24 }} />
             &nbsp;NO
           </Button>
-          <Button size="small" variant={locale === 'fr' ? 'contained' : 'outlined'} onClick={() => selectLocale('fr')}>
+          <Button size="small" variant={locale === 'pl' ? 'contained' : 'outlined'} onClick={() => selectLocale('pl')}>
-            <FRflag style={{ width: 24 }} />
+            <PLflag style={{ width: 24 }} />
-            &nbsp;FR
+            &nbsp;PL
+          </Button>
+          <Button size="small" variant={locale === 'se' ? 'contained' : 'outlined'} onClick={() => selectLocale('se')}>
+            <SEflag style={{ width: 24 }} />
+            &nbsp;SE
           </Button>
         </Box>
 

interface/src/components/layout/LayoutAuthMenu.tsx

@@ -78,29 +78,30 @@ const LayoutAuthMenu: FC = () => {
           <GBflag style={{ width: 16, verticalAlign: 'middle' }} />
           &nbsp;EN
         </MenuItem>
+        <Divider />
         <MenuItem key="de" value="de">
           <DEflag style={{ width: 16, verticalAlign: 'middle' }} />
           &nbsp;DE
         </MenuItem>
+        <MenuItem key="fr" value="fr">
+          <FRflag style={{ width: 16, verticalAlign: 'middle' }} />
+          &nbsp;FR
+        </MenuItem>
         <MenuItem key="nl" value="nl">
           <NLflag style={{ width: 16, verticalAlign: 'middle' }} />
           &nbsp;NL
         </MenuItem>
-        <MenuItem key="se" value="se">
+        <MenuItem key="no" value="no">
-          <SEflag style={{ width: 16, verticalAlign: 'middle' }} />
+          <NOflag style={{ width: 16, verticalAlign: 'middle' }} />
-          &nbsp;SE
+          &nbsp;NO
         </MenuItem>
         <MenuItem key="pl" value="pl">
           <PLflag style={{ width: 16, verticalAlign: 'middle' }} />
           &nbsp;PL
         </MenuItem>
-        <MenuItem key="no" value="no">
+        <MenuItem key="se" value="se">
-          <NOflag style={{ width: 16, verticalAlign: 'middle' }} />
+          <SEflag style={{ width: 16, verticalAlign: 'middle' }} />
-          &nbsp;NO
+          &nbsp;SE
-        </MenuItem>
-        <MenuItem key="fr" value="fr">
-          <FRflag style={{ width: 16, verticalAlign: 'middle' }} />
-          &nbsp;FR
         </MenuItem>
       </TextField>
 

interface/src/i18n/de/index.ts

@@ -115,7 +115,7 @@ const de: Translation = {
   TEMPERATURE: 'Temperatur',
   PHY_TYPE: 'Eth PHY Typ',
   DISABLED: 'deaktiviert',
-  TX_MODE: 'Tx Mode',
+  TX_MODE: 'Tx Modus',
   HARDWARE: 'Hardware',
   EMS_BUS: '{{BUS|EMS BUS}}',
   GENERAL_OPTIONS: 'Allgemeine Optionen',
@@ -249,10 +249,10 @@ const de: Translation = {
   MQTT_INT_HEARTBEAT: 'Heartbeat',
   MQTT_QUEUE: 'MQTT Queue',
   DEFAULT: 'Standard',
-  MQTT_ENTITY_FORMAT: 'Entity ID format',
+  MQTT_ENTITY_FORMAT: 'Entitäts-ID Format',
-  MQTT_ENTITY_FORMAT_0: 'Single instance, long name (v3.4)',
+  MQTT_ENTITY_FORMAT_0: 'Einzelinstanz, Langname (v3.4)',
-  MQTT_ENTITY_FORMAT_1: 'Single instance, short name',
+  MQTT_ENTITY_FORMAT_1: 'Einzelinstanz, MQTT-Namen',
-  MQTT_ENTITY_FORMAT_2: 'Multiple instances, short name',
+  MQTT_ENTITY_FORMAT_1: 'Mehrfachinstanzen, MQTT-Namen',
   MQTT_CLEAN_SESSION: 'Setze `Clean Session`',
   MQTT_RETAIN_FLAG: 'Setze `Retain flag` immer',
   INACTIVE: 'Inaktiv',

interface/src/project/SettingsApplication.tsx

@@ -362,12 +362,13 @@ const SettingsApplication: FC = () => {
             select
           >
             <MenuItem value="en">English (EN)</MenuItem>
+            <Divider />
             <MenuItem value="de">Deutsch (DE)</MenuItem>
-            <MenuItem value="nl">Nederlands (NL)</MenuItem>
-            <MenuItem value="se">Svenska (SE)</MenuItem>
-            <MenuItem value="pl">Polski (PL)</MenuItem>
-            <MenuItem value="no">Norsk (NO)</MenuItem>
             <MenuItem value="fr">Français (FR)</MenuItem>
+            <MenuItem value="nl">Nederlands (NL)</MenuItem>
+            <MenuItem value="no">Norsk (NO)</MenuItem>
+            <MenuItem value="pl">Polski (PL)</MenuItem>
+            <MenuItem value="se">Svenska (SE)</MenuItem>
           </ValidatedTextField>
         </Box>
         {data.led_gpio !== 0 && (

interface/src/project/types.ts

@@ -179,7 +179,8 @@ export enum DeviceValueUOM {
   MV,
   SQM,
   M3,
-  L
+  L,
+  KMIN
 }
 
 export const DeviceValueUOM_s = [
@@ -203,7 +204,8 @@ export const DeviceValueUOM_s = [
   'mV',
   'm²',
   'm³',
-  'l'
+  'l',
+  'K*min'
 ];
 
 export enum AnalogType {

src/device_library.h

@@ -39,7 +39,7 @@
 {167, DeviceType::BOILER, "Cerapur Aero", DeviceFlags::EMS_DEVICE_FLAG_NONE},
 {168, DeviceType::BOILER, "Hybrid Heatpump", DeviceFlags::EMS_DEVICE_FLAG_HYBRID},
 {170, DeviceType::BOILER, "Logano GB212", DeviceFlags::EMS_DEVICE_FLAG_NONE},
-{172, DeviceType::BOILER, "Enviline/Compress 6000AW/Hybrid 7000iAW/SupraEco/Geo 5xx/WLW196i", DeviceFlags::EMS_DEVICE_FLAG_HEATPUMP},
+{172, DeviceType::BOILER, "Enviline/Compress 6000AW/Hybrid 3000-7000iAW/SupraEco/Geo 5xx/WLW196i", DeviceFlags::EMS_DEVICE_FLAG_HEATPUMP},
 {173, DeviceType::BOILER, "Geo 5xx", DeviceFlags::EMS_DEVICE_FLAG_HEATPUMP},
 {195, DeviceType::BOILER, "Condens 5000i/Greenstar 8000/GC9800IW", DeviceFlags::EMS_DEVICE_FLAG_NONE},
 {203, DeviceType::BOILER, "Logamax U122/Cerapur", DeviceFlags::EMS_DEVICE_FLAG_NONE},
@@ -92,7 +92,7 @@
 { 94, DeviceType::THERMOSTAT, "RFM20 Remote", DeviceFlags::EMS_DEVICE_FLAG_NONE}, // 0x18
 {151, DeviceType::THERMOSTAT, "RC25", DeviceFlags::EMS_DEVICE_FLAG_RC25}, // 0x17
 {157, DeviceType::THERMOSTAT, "RC200/CW100", DeviceFlags::EMS_DEVICE_FLAG_RC100}, // 0x18
-{158, DeviceType::THERMOSTAT, "RC300/RC310/Moduline 3000/1010H/CW400/Sense II", DeviceFlags::EMS_DEVICE_FLAG_RC300}, // 0x10
+{158, DeviceType::THERMOSTAT, "RC300/RC310/Moduline 3000/1010H/CW400/Sense II/HPC410", DeviceFlags::EMS_DEVICE_FLAG_RC300}, // 0x10
 {165, DeviceType::THERMOSTAT, "RC100/Moduline 1000/1010", DeviceFlags::EMS_DEVICE_FLAG_RC100}, // 0x18, 0x38
 {172, DeviceType::THERMOSTAT, "Rego 2000/3000", DeviceFlags::EMS_DEVICE_FLAG_RC300}, // 0x10
 {216, DeviceType::THERMOSTAT, "CRF200S", DeviceFlags::EMS_DEVICE_FLAG_CRF | DeviceFlags::EMS_DEVICE_FLAG_NO_WRITE}, // 0x18

src/devices/boiler.cpp

@@ -178,9 +178,13 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const
         register_telegram_type(0x48D, "HpPower", true, MAKE_PF_CB(process_HpPower));
         register_telegram_type(0x48F, "HpOutdoor", false, MAKE_PF_CB(process_HpOutdoor));
         register_telegram_type(0x48A, "HpPool", true, MAKE_PF_CB(process_HpPool));
-        register_telegram_type(0x4A2, "HpInput", false, MAKE_PF_CB(process_HpInput));
+        register_telegram_type(0x4A2, "HpInput", true, MAKE_PF_CB(process_HpInput));
-        register_telegram_type(0x486, "HpInConfig", false, MAKE_PF_CB(process_HpInConfig));
+        register_telegram_type(0x486, "HpInConfig", true, MAKE_PF_CB(process_HpInConfig));
-        register_telegram_type(0x492, "HpHeaterConfig", false, MAKE_PF_CB(process_HpHeaterConfig));
+        register_telegram_type(0x492, "HpHeaterConfig", true, MAKE_PF_CB(process_HpHeaterConfig));
+
+        register_telegram_type(0x488, "HPValve", true, MAKE_PF_CB(process_HpValve));
+        register_telegram_type(0x484, "HPSilentMode", true, MAKE_PF_CB(process_HpSilentMode));
+        register_telegram_type(0x491, "HPAdditionalHeater", true, MAKE_PF_CB(process_HpAdditionalHeater));
     }
 
     /*
@@ -558,6 +562,54 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const
                               FL_(maxHeatDhw),
                               DeviceValueUOM::NONE,
                               MAKE_CF_CB(set_maxHeatDhw));
+        register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
+                              &auxHeaterOnly_,
+                              DeviceValueType::BOOL,
+                              FL_(auxHeaterOnly),
+                              DeviceValueUOM::NONE,
+                              MAKE_CF_CB(set_additionalHeaterOnly));
+        register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
+                              &auxHeater_,
+                              DeviceValueType::BOOL,
+                              FL_(auxHeater),
+                              DeviceValueUOM::NONE,
+                              MAKE_CF_CB(set_additionalHeater));
+        register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
+                              &auxHeaterStatus_,
+                              DeviceValueType::BOOL,
+                              FL_(auxHeaterStatus),
+                              DeviceValueUOM::NONE);
+        register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
+                              &auxHeaterDelay_,
+                              DeviceValueType::USHORT,
+                              DeviceValueNumOp::DV_NUMOP_MUL10,
+                              FL_(auxHeaterDelay),
+                              DeviceValueUOM::KMIN,
+                              MAKE_CF_CB(set_additionalHeaterDelay));
+        register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
+                              &auxHeaterHyst_,
+                              DeviceValueType::USHORT,
+                              DeviceValueNumOp::DV_NUMOP_MUL5,
+                              FL_(auxHeaterHyst),
+                              DeviceValueUOM::KMIN,
+                              MAKE_CF_CB(set_additionalHeaterHyst));
+        register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
+                              &minTempSilent_,
+                              DeviceValueType::INT,
+                              FL_(minTempSilent),
+                              DeviceValueUOM::DEGREES,
+                              MAKE_CF_CB(set_minTempSilent));
+        register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
+                              &tempParMode_,
+                              DeviceValueType::INT,
+                              FL_(tempParMode),
+                              DeviceValueUOM::DEGREES,
+                              MAKE_CF_CB(set_tempParMode));
+        register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
+                              &auxHeatMixValve_,
+                              DeviceValueType::INT,
+                              FL_(auxHeatMixValve),
+                              DeviceValueUOM::PERCENT);
     }
 
     // dhw - DEVICE_DATA_ww topic
@@ -1167,6 +1219,7 @@ void Boiler::process_HpPool(std::shared_ptr<const Telegram> telegram) {
 
 // Heatpump inputs - type 0x4A2
 // Boiler(0x08) -> All(0x00), ?(0x04A2), data: 02 01 01 00 01 00
+// Boiler(0x08) -W-> Me(0x0B), HpInput(0x04A2), data: 20 07 06 01 00 (from #802)
 void Boiler::process_HpInput(std::shared_ptr<const Telegram> telegram) {
     has_update(telegram, hpInput[0].state, 2);
     has_update(telegram, hpInput[1].state, 3);
@@ -1453,6 +1506,28 @@ void Boiler::process_amExtraMessage(std::shared_ptr<const Telegram> telegram) {
 
 #pragma GCC diagnostic pop
 
+// Boiler(0x08) -> All(0x00), ?(0x0484), data: 00 00 14 28 0D 50 00 00 00 02 02 07 28 01 00 02 05 19 0A 0A 03 0D 07 00 0A
+// Boiler(0x08) -> All(0x00), ?(0x0484), data: 01 90 00 F6 28 14 64 00 00 E1 00 1E 00 1E 01 64 01 64 54 20 00 00 (offset 25)
+void Boiler::process_HpSilentMode(std::shared_ptr<const Telegram> telegram) {
+    has_update(telegram, minTempSilent_, 11);
+    has_update(telegram, auxHeaterHyst_, 37);
+}
+
+// Boiler(0x08) -B-> All(0x00), ?(0x0488), data: 8E 00 00 00 00 00 01 03
+void Boiler::process_HpValve(std::shared_ptr<const Telegram> telegram) {
+    has_bitupdate(telegram, auxHeaterStatus_, 0, 2);
+    has_update(telegram, auxHeatMixValve_, 7);
+}
+
+
+// Boiler(0x08) -> All(0x00), ?(0x0491), data: 03 01 00 00 00 02 64 00 00 14 01 2C 00 0A 00 1E 00 1E 00 00 1E 0A 1E 05 05
+void Boiler::process_HpAdditionalHeater(std::shared_ptr<const Telegram> telegram) {
+    has_update(telegram, auxHeaterOnly_, 1);
+    has_update(telegram, auxHeater_, 2);
+    has_update(telegram, tempParMode_, 5);
+    has_update(telegram, auxHeaterDelay_, 16); // is / 10
+}
+
 // Settings AM200
 
 // pos 12: off(00)/Keelbypass(01)/(hc1pump(02) only standalone)
@@ -2394,4 +2469,59 @@ bool Boiler::set_maxHeat(const char * value, const int8_t id) {
     return true;
 }
 
+bool Boiler::set_minTempSilent(const char * value, const int8_t id) {
+    int v;
+    if (Helpers::value2temperature(value, v)) {
+        write_command(0x484, 11, v, 0x484);
+        return true;
+    }
+    return false;
+}
+
+bool Boiler::set_additionalHeaterOnly(const char * value, const int8_t id) {
+    bool v;
+    if (Helpers::value2bool(value, v)) {
+        write_command(0x491, 1, v ? 1 : 0, 0x491);
+        return true;
+    }
+    return false;
+}
+
+bool Boiler::set_additionalHeater(const char * value, const int8_t id) {
+    bool v;
+    if (Helpers::value2bool(value, v)) {
+        write_command(0x491, 2, v ? 1 : 0, 0x491);
+        return true;
+    }
+    return false;
+}
+
+bool Boiler::set_tempParMode(const char * value, const int8_t id) {
+    int v;
+    if (Helpers::value2temperature(value, v)) {
+        write_command(0x491, 5, v, 0x491);
+        return true;
+    }
+    return false;
+}
+
+bool Boiler::set_additionalHeaterDelay(const char * value, const int8_t id) {
+    int v;
+    if (Helpers::value2number(value, v)) {
+        uint8_t data[2] = {(uint8_t)(v >> 8), (uint8_t)v};
+        write_command(0x491, 16, data, 2, 0x491);
+        return true;
+    }
+    return false;
+}
+
+bool Boiler::set_additionalHeaterHyst(const char * value, const int8_t id) {
+    int v;
+    if (Helpers::value2number(value, v)) {
+        uint8_t data[2] = {(uint8_t)(v >> 8), (uint8_t)v};
+        write_command(0x484, 37, data, 2, 0x484);
+        return true;
+    }
+    return false;
+}
 } // namespace emsesp

src/devices/boiler.h

@@ -242,6 +242,15 @@ class Boiler : public EMSdevice {
     int8_t   blockHyst_;     // pos 14?: Hyst. for bolier block (K)
     uint8_t  releaseWait_;   // pos 15: Boiler release wait time (min)
 
+    uint8_t  auxHeaterOnly_;
+    uint8_t  auxHeater_;
+    uint8_t  auxHeaterStatus_;
+    uint16_t auxHeaterDelay_;
+    uint16_t auxHeaterHyst_;
+    int8_t   minTempSilent_;
+    int8_t   tempParMode_;
+    int8_t   auxHeatMixValve_;
+
     /*
   // Hybrid heatpump with telegram 0xBB is readable and writeable in boiler and thermostat
   // thermostat always overwrites settings in boiler
@@ -293,6 +302,9 @@ class Boiler : public EMSdevice {
     void process_amSettingMessage(std::shared_ptr<const Telegram> telegram);
     void process_amCommandMessage(std::shared_ptr<const Telegram> telegram);
     void process_amExtraMessage(std::shared_ptr<const Telegram> telegram);
+    void process_HpSilentMode(std::shared_ptr<const Telegram> telegram);
+    void process_HpAdditionalHeater(std::shared_ptr<const Telegram> telegram);
+    void process_HpValve(std::shared_ptr<const Telegram> telegram);
 
     // commands - none of these use the additional id parameter
     bool        set_ww_mode(const char * value, const int8_t id);
@@ -378,6 +390,12 @@ class Boiler : public EMSdevice {
     inline bool set_maxHeatDhw(const char * value, const int8_t id) {
         return set_maxHeat(value, 4);
     }
+    bool set_minTempSilent(const char * value, const int8_t id);
+    bool set_additionalHeaterOnly(const char * value, const int8_t id);
+    bool set_additionalHeater(const char * value, const int8_t id);
+    bool set_additionalHeaterDelay(const char * value, const int8_t id);
+    bool set_additionalHeaterHyst(const char * value, const int8_t id);
+    bool set_tempParMode(const char * value, const int8_t id);
 
     /*
     bool set_hybridStrategy(const char * value, const int8_t id);

src/devices/thermostat.cpp

@@ -152,6 +152,7 @@ Thermostat::Thermostat(uint8_t device_type, uint8_t device_id, uint8_t product_i
         register_telegram_type(0x23A, "RC300OutdoorTemp", true, MAKE_PF_CB(process_RC300OutdoorTemp));
         register_telegram_type(0x267, "RC300Floordry", false, MAKE_PF_CB(process_RC300Floordry));
         register_telegram_type(0x240, "RC300Settings", true, MAKE_PF_CB(process_RC300Settings));
+        register_telegram_type(0xBB, "HybridSettings", true, MAKE_PF_CB(process_HybridSettings));
 
         // JUNKERS/HT3
     } else if (model == EMSdevice::EMS_DEVICE_FLAG_JUNKERS) {
@@ -172,7 +173,7 @@ Thermostat::Thermostat(uint8_t device_type, uint8_t device_id, uint8_t product_i
                 register_telegram_type(set_typeids[i], "JunkersSet", false, MAKE_PF_CB(process_JunkersSet));
             }
         }
-        register_telegram_type(0xBB, "HybridSettings", true, MAKE_PF_CB(process_JunkersHybridSettings));
+        register_telegram_type(0xBB, "HybridSettings", true, MAKE_PF_CB(process_HybridSettings));
         register_telegram_type(0x23, "JunkersSetMixer", true, MAKE_PF_CB(process_JunkersSetMixer));
         register_telegram_type(0x123, "JunkersRemote", false, MAKE_PF_CB(process_JunkersRemoteMonitor));
         register_telegram_type(0x1D3, "JunkersDhw", true, MAKE_PF_CB(process_JunkersWW));
@@ -869,7 +870,7 @@ void Thermostat::process_JunkersMonitor(std::shared_ptr<const Telegram> telegram
 
 // 0xBB Heatpump optimization
 // ?(0xBB), data: 00 00 00 00 00 00 00 00 00 00 00 FF 02 0F 1E 0B 1A 00 14 03
-void Thermostat::process_JunkersHybridSettings(std::shared_ptr<const Telegram> telegram) {
+void Thermostat::process_HybridSettings(std::shared_ptr<const Telegram> telegram) {
     has_enumupdate(telegram, hybridStrategy_, 12, 1); // cost = 2, temperature = 3, mix = 4
     has_update(telegram, switchOverTemp_, 13);        // full degrees
     has_update(telegram, energyCostRatio_, 14);       // is *10
@@ -3471,6 +3472,64 @@ void Thermostat::register_device_values() {
                               MAKE_CF_CB(set_wwDisinfectHour),
                               0,
                               1431);
+        register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
+                              &hybridStrategy_,
+                              DeviceValueType::ENUM,
+                              FL_(enum_hybridStrategy),
+                              FL_(hybridStrategy),
+                              DeviceValueUOM::NONE,
+                              MAKE_CF_CB(set_hybridStrategy));
+        register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
+                              &switchOverTemp_,
+                              DeviceValueType::INT,
+                              FL_(switchOverTemp),
+                              DeviceValueUOM::DEGREES,
+                              MAKE_CF_CB(set_switchOverTemp),
+                              -20,
+                              20);
+        register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
+                              &energyCostRatio_,
+                              DeviceValueType::UINT,
+                              DeviceValueNumOp::DV_NUMOP_DIV10,
+                              FL_(energyCostRatio),
+                              DeviceValueUOM::NONE,
+                              MAKE_CF_CB(set_energyCostRatio),
+                              0,
+                              20);
+        register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
+                              &fossileFactor_,
+                              DeviceValueType::UINT,
+                              DeviceValueNumOp::DV_NUMOP_DIV10,
+                              FL_(fossileFactor),
+                              DeviceValueUOM::NONE,
+                              MAKE_CF_CB(set_fossileFactor),
+                              0,
+                              5);
+        register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
+                              &electricFactor_,
+                              DeviceValueType::UINT,
+                              DeviceValueNumOp::DV_NUMOP_DIV10,
+                              FL_(electricFactor),
+                              DeviceValueUOM::NONE,
+                              MAKE_CF_CB(set_electricFactor),
+                              0,
+                              5);
+        register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
+                              &delayBoiler_,
+                              DeviceValueType::UINT,
+                              FL_(delayBoiler),
+                              DeviceValueUOM::MINUTES,
+                              MAKE_CF_CB(set_delayBoiler),
+                              5,
+                              120);
+        register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
+                              &tempDiffBoiler_,
+                              DeviceValueType::UINT,
+                              FL_(tempDiffBoiler),
+                              DeviceValueUOM::DEGREES_R,
+                              MAKE_CF_CB(set_tempDiffBoiler),
+                              1,
+                              99);
         break;
     case EMS_DEVICE_FLAG_RC10:
         register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,

src/devices/thermostat.h

@@ -378,7 +378,7 @@ class Thermostat : public EMSdevice {
     void process_JunkersSet2(std::shared_ptr<const Telegram> telegram);
     void process_EasyMonitor(std::shared_ptr<const Telegram> telegram);
     void process_JunkersRemoteMonitor(std::shared_ptr<const Telegram> telegram);
-    void process_JunkersHybridSettings(std::shared_ptr<const Telegram> telegram);
+    void process_HybridSettings(std::shared_ptr<const Telegram> telegram);
     void process_JunkersSetMixer(std::shared_ptr<const Telegram> telegram);
     void process_JunkersWW(std::shared_ptr<const Telegram> telegram);
     void process_RemoteTemp(std::shared_ptr<const Telegram> telegram);

src/emsdevicevalue.cpp

@@ -107,7 +107,7 @@ const char * DeviceValue::DeviceValueUOM_s[] = {
 
     F_(uom_blank),      F_(uom_degrees), F_(uom_degrees), F_(uom_percent), F_(uom_lmin), F_(uom_kwh),  F_(uom_wh),      FL_(hours)[0],
     FL_(minutes)[0],    F_(uom_ua),      F_(uom_bar),     F_(uom_kw),      F_(uom_w),    F_(uom_kb),   FL_(seconds)[0], F_(uom_dbm),
-    F_(uom_fahrenheit), F_(uom_mv),      F_(uom_sqm),     F_(uom_m3),      F_(uom_blank)
+    F_(uom_fahrenheit), F_(uom_mv),      F_(uom_sqm),     F_(uom_m3),      F_(uom_l),    F_(uom_kmin), F_(uom_blank) // connectivity
 
 };
 

src/emsdevicevalue.h

@@ -68,7 +68,8 @@ class DeviceValue {
         SQM,         // 18 square meter
         M3,          // 19 cubic meter
         L,           // 20
-        CONNECTIVITY // 21 - used in HA
+        KMIN,        // 21 - Kelvin * minutes
+        CONNECTIVITY // 22 - used in HA
     };
 
     // TAG mapping - maps to DeviceValueTAG_s in emsdevice.cpp

src/locale_common.h

@@ -215,6 +215,7 @@ MAKE_PSTR(uom_mv, "mV")
 MAKE_PSTR(uom_sqm, "m²")
 MAKE_PSTR(uom_m3, "m³")
 MAKE_PSTR(uom_l, "l")
+MAKE_PSTR(uom_kmin, "K*min")
 
 // MQTT topics and prefixes
 MAKE_PSTR(heating_active, "heating_active")

src/locale_translations.h

@@ -368,6 +368,16 @@ MAKE_PSTR_LIST(maxHeatComp, "maxheatcomp", "heat limit compressor", "Heizgrenze
 MAKE_PSTR_LIST(maxHeatHeat, "maxheatheat", "heat limit heating", "Heizgrenze Heizen", "heat limit heating", "heat limit heating", "limit ciepła dla ogrzewania", "maks varmegrense oppvarming", "limite chaleur chauffage")
 MAKE_PSTR_LIST(maxHeatDhw, "maxheatdhw", "heat limit dhw", "Heizgrenze Warmwasser", "heat limit dhw", "heat limit dhw", "limit ciepła dla c.w.u.", "varmegrense varmtvann", "limite chaleur ecs")
 
+// translations are in order en, de, nl, se, pl, no, fr, .... some missing
+MAKE_PSTR_LIST(auxHeater, "auxheater", "enable auxilliary heater", "Erlaube Zusatzheizer")
+MAKE_PSTR_LIST(auxHeaterStatus, "auxheaterstatus", "auxilliary heater status", "Status Zusatzheizer")
+MAKE_PSTR_LIST(auxHeaterOnly, "auxheateronly", "auxilliary heater only", "nur Zusatzheizer")
+MAKE_PSTR_LIST(auxHeaterDelay, "auxheaterdelay", "auxilliary heater on delay", "Zusatzheizer verzögert ein", "Bijverw. vertraagd aan", "Tillskottfördröjning på", "Opóźn. włączenie dogrz.", "Tilleggsvarmer forsinket på", "Chauff app tempo marche")
+MAKE_PSTR_LIST(auxHeaterHyst, "auxheaterhyst", "auxilliary heater on/off hyst", "Zusatzheizer Schalthysterese", "Aan/uit-hysteresis in verw. bedrijf instellen", "På/av-hystereses Husv.", "Histerez wł/wył Ogrzew.", "På/av-hysterese Oppvar.", "Hystérésis Marche en mode chauffage")
+MAKE_PSTR_LIST(minTempSilent, "mintempsilent", "min. outside temp. for silent mode", "Minimale Aussentemperatur Silentmodus")
+MAKE_PSTR_LIST(tempParMode, "tempparmode", "outside temp. parallel mode", "Aussentemperatur Parallelmodus")
+MAKE_PSTR_LIST(auxHeatMixValve, "auxheatmix", "aux. heater mixing valve", "Mischer Zusatzheizer")
+
 // hybrid heatpump
 MAKE_PSTR_LIST(hybridStrategy, "hybridstrategy", "hybrid control strategy", "Hybrid Strategie", "Hybride strategie", "Hybrid kontrollstrategi", "strategia sterowania hybrydowego", "hybrid kontrollstrategi", "stratégie contrôle hybride")
 MAKE_PSTR_LIST(switchOverTemp, "switchovertemp", "outside switchover temperature", "Außentemperatur für Umschaltung", "Schakeltemperatuur buitentemperatuur", "Utomhus Omställningstemperatur", "zewnętrzna temperatura przełączania", "utendørstemp styring", "basculement par température extérieure")

src/web/WebLogService.cpp

@@ -111,7 +111,7 @@ WebLogService::QueuedLogMessage::QueuedLogMessage(unsigned long id, std::shared_
 
 void WebLogService::operator<<(std::shared_ptr<uuid::log::Message> message) {
 #ifndef EMSESP_STANDALONE
-    if (ESP.getMaxAllocHeap() < 20480) {
+    if (maximum_log_messages_ > 10 && ESP.getMaxAllocHeap() < 41984) {
         maximum_log_messages(maximum_log_messages_ > 25 ? maximum_log_messages_ - 25 : 10);
         // EMSESP::logger().warning("Low memory: WebLog buffer reduced to %d entries", maximum_log_messages_);
     }