Merge pull request #1471 from MichaelDvP/dev

Some new/fixed entities

CHANGELOG_LATEST.md

@@ -6,8 +6,13 @@
 
 ## Added
 
+- thermostat boost mode and boost time
+- heatpump energy meters
+
 ## Fixed
 
+- exhaust temperature for some boilers
+
 ## Changed
 
 - HA don't set entity_category to Diagnostic/Configuration for EMS entities [#1459](https://github.com/emsesp/EMS-ESP32/discussions/1459)

interface/src/project/types.ts

@@ -130,7 +130,7 @@ export interface DeviceValue {
   c?: string; // command, optional
   l?: string[]; // list, optional
   h?: string; // help text, optional
-  s?: number; // steps for up/down, optional
+  s?: string; // steps for up/down, optional
   m?: number; // min, optional
   x?: number; // max, optional
 }

src/devices/boiler.cpp

@@ -399,6 +399,12 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const
                               DeviceValueNumOp::DV_NUMOP_DIV100,
                               FL_(meterEHeat),
                               DeviceValueUOM::KWH);
+        register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
+                              &meterHeat_,
+                              DeviceValueType::ULONG,
+                              DeviceValueNumOp::DV_NUMOP_DIV100,
+                              FL_(meterHeat),
+                              DeviceValueUOM::KWH);
         register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
                               &upTimeTotal_,
                               DeviceValueType::TIME,
@@ -720,6 +726,7 @@ Boiler::Boiler(uint8_t device_type, int8_t device_id, uint8_t product_id, const
                               DeviceValueUOM::NONE,
                               MAKE_CF_CB(set_elHeatStep3));
         register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpEA0_, DeviceValueType::BOOL, FL_(hpEA0), DeviceValueUOM::NONE);
+        register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &hpPumpMode_, DeviceValueType::ENUM, FL_(enum_hpPumpMode), FL_(hpPumpMode), DeviceValueUOM::NONE, MAKE_CF_CB(set_hpPumpMode));
         // heatpump DHW settings
         register_device_value(DeviceValueTAG::TAG_BOILER_DATA_WW,
                               &wwAlternatingOper_,
@@ -1065,7 +1072,7 @@ void Boiler::check_active() {
     }
 
     // calculate energy for boiler 0x08 from stored modulation an time in units of 0.01 Wh
-    if (model() != EMS_DEVICE_FLAG_HEATPUMP) {
+    if (model() != EMSdevice::EMS_DEVICE_FLAG_HEATPUMP && model() != EMSdevice::EMS_DEVICE_FLAG_HIU) {
         // remember values from last call
         static uint32_t powLastReadTime_ = uuid::get_uptime();
         static uint8_t  heatBurnPow      = 0;
@@ -1308,10 +1315,10 @@ void Boiler::process_UBAMonitorFastPlus(std::shared_ptr<const Telegram> telegram
 
     // at this point do a quick check to see if the hot water or heating is active
     uint8_t state = EMS_VALUE_UINT_NOTSET;
-    if (telegram->read_value(state, 11)) {
+    if (telegram->read_value(state, 11) && model() != EMSdevice::EMS_DEVICE_FLAG_HIU) {
-        boilerState_ = state & 0x01 ? 0x08 : 0;
+        boilerState_ = state & 0x01 ? 0x08 : 0;  // burnGas
-        boilerState_ |= state & 0x02 ? 0x01 : 0;
+        boilerState_ |= state & 0x02 ? 0x01 : 0; // heatingPump
-        boilerState_ |= state & 0x04 ? 0x02 : 0;
+        boilerState_ |= state & 0x04 ? 0x02 : 0; // 3-way-valve
     }
 
     if (telegram->offset <= 10 && telegram->offset + telegram->message_length > 11) {
@@ -1347,6 +1354,17 @@ void Boiler::process_UBAMonitorSlow(std::shared_ptr<const Telegram> telegram) {
  */
 void Boiler::process_UBAMonitorSlowPlus2(std::shared_ptr<const Telegram> telegram) {
     has_update(telegram, absBurnPow_, 13); // current burner absolute power (percent of rating plate power)
+    if (model() == EMSdevice::EMS_DEVICE_FLAG_HIU) {
+        uint8_t state = EMS_VALUE_UINT_NOTSET;
+        boilerState_  = 0;
+        if (telegram->read_value(state, 2)) {
+            boilerState_ |= state == 1 ? 0x09 : 0; // heating 0/1
+        }
+        state = EMS_VALUE_UINT_NOTSET;
+        if (telegram->read_value(state, 5)) {
+            boilerState_ |= state == 1 ? 0x0A : 0; // dhw 0/1
+        }
+    }
 }
 
 /*
@@ -1815,6 +1833,7 @@ void Boiler::process_HpValve(std::shared_ptr<const Telegram> telegram) {
 void Boiler::process_HpPumps(std::shared_ptr<const Telegram> telegram) {
     has_update(telegram, tempDiffHeat_, 4); // is * 10
     has_update(telegram, tempDiffCool_, 3); // is * 10
+    has_update(telegram, hpPumpMode_, 18);
 }
 
 // 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
@@ -1871,6 +1890,7 @@ void Boiler::process_HpMeters(std::shared_ptr<const Telegram> telegram) {
     has_update(telegram, meterTotal_, 0);
     has_update(telegram, meterComp_, 4);
     has_update(telegram, meterEHeat_, 8);
+    has_update(telegram, meterHeat_, 24);
 }
 
 // HIU unit
@@ -2854,6 +2874,15 @@ bool Boiler::set_hpCircPumpWw(const char * value, const int8_t id) {
     return false;
 }
 
+bool Boiler::set_hpPumpMode(const char * value, const int8_t id) {
+    uint8_t v;
+    if (Helpers::value2enum(value, v, FL_(enum_hpPumpMode))) {
+        write_command(0x48B, 18, v, 0x48B);
+        return true;
+    }
+    return false;
+}
+
 bool Boiler::set_vp_cooling(const char * value, const int8_t id) {
     bool v;
     if (Helpers::value2bool(value, v)) {

src/devices/boiler.h

@@ -101,21 +101,22 @@ class Boiler : public EMSdevice {
     uint8_t wwTapActivated_; // maintenance-mode to switch DHW off
 
     // main
-    uint8_t  reset_;            // for reset command
+    uint8_t  reset_;          // for reset command
-    uint8_t  heatingActive_;    // Central heating is on/off
+    uint8_t  heatingActive_;  // Central heating is on/off
-    uint8_t  tapwaterActive_;   // Hot tap water is on/off
+    uint8_t  tapwaterActive_; // Hot tap water is on/off
-    uint8_t  selFlowTemp_;      // Selected flow temperature
+    uint8_t  selFlowTemp_;    // Selected flow temperature
-    uint8_t  selBurnPow_;       // Burner max power % (can be > 100%)
+    uint8_t  selBurnPow_;     // Burner max power % (can be > 100%)
-    uint8_t  absBurnPow_;       // absolute burner power in % of rating plate
+    uint8_t  absBurnPow_;     // absolute burner power in % of rating plate
-    uint8_t  heatingPumpMod_;   // Pump modulation %
+    uint8_t  heatingPumpMod_; // Pump modulation %
-    int16_t  outdoorTemp_;      // Outside temperature
+    int16_t  outdoorTemp_;    // Outside temperature
-    uint16_t curFlowTemp_;      // Current flow temperature
+    uint16_t curFlowTemp_;    // Current flow temperature
-    uint16_t retTemp_;          // Return temperature
+    uint16_t retTemp_;        // Return temperature
-    uint16_t switchTemp_;       // Switch temperature
+    uint16_t switchTemp_;     // Switch temperature
-    uint8_t  sysPress_;         // System pressure
+    uint8_t  sysPress_;       // System pressure
-    uint16_t boilTemp_;         // Boiler temperature
+    uint16_t boilTemp_;       // Boiler temperature
-    uint16_t exhaustTemp_;      // Exhaust temperature published
+    uint16_t exhaustTemp_;    // Exhaust temperature published
-    uint16_t exhaustTemp1_;     // read from E4
+    // read second value from E4 and initialize it
+    uint16_t exhaustTemp1_ = EMS_VALUE_USHORT_NOTSET;
     uint8_t  burnGas_;          // Gas on/off
     uint8_t  burnGas2_;         // Gas stage 2 on/off
     uint16_t flameCurr_;        // Flame current in micro amps
@@ -218,7 +219,9 @@ class Boiler : public EMSdevice {
     uint32_t meterTotal_;
     uint32_t meterComp_;
     uint32_t meterEHeat_;
+    uint32_t meterHeat_;
     uint8_t  hpEA0_;
+    uint8_t  hpPumpMode_;
 
     // Pool unit
     int8_t poolSetTemp_;
@@ -430,6 +433,7 @@ class Boiler : public EMSdevice {
     bool set_manDefrost(const char * value, const int8_t id);
     bool set_pvCooling(const char * value, const int8_t id);
     bool set_hpCircPumpWw(const char * value, const int8_t id);
+    bool set_hpPumpMode(const char * value, const int8_t id);
 
     bool        set_auxLimit(const char * value, const int8_t id);
     inline bool set_auxMaxLimit(const char * value, const int8_t id) {

src/devices/heatpump.cpp

@@ -33,6 +33,8 @@ Heatpump::Heatpump(uint8_t device_type, uint8_t device_id, uint8_t product_id, c
     register_telegram_type(0x9A0, "HPTemperature", false, MAKE_PF_CB(process_HPTemperature));
     register_telegram_type(0x99B, "HPFlowTemp", false, MAKE_PF_CB(process_HPFlowTemp));
     register_telegram_type(0x99C, "HPComp", false, MAKE_PF_CB(process_HPComp));
+    register_telegram_type(0x4AE, "HPEnergy", true, MAKE_PF_CB(process_HpEnergy));
+    register_telegram_type(0x4AF, "HPMeters", true, MAKE_PF_CB(process_HpMeters));
 
     // device values
     register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &airHumidity_, DeviceValueType::UINT, FL_(airHumidity), DeviceValueUOM::PERCENT);
@@ -146,6 +148,33 @@ Heatpump::Heatpump(uint8_t device_type, uint8_t device_id, uint8_t product_id, c
                           DeviceValueUOM::NONE,
                           MAKE_CF_CB(set_heatDrainPan));
     register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &heatCable_, DeviceValueType::BOOL, FL_(heatCable), DeviceValueUOM::NONE, MAKE_CF_CB(set_heatCable));
+    register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &nrgTotal_, DeviceValueType::ULONG, DeviceValueNumOp::DV_NUMOP_DIV100, FL_(nrgTotal), DeviceValueUOM::KWH);
+    register_device_value(DeviceValueTAG::TAG_BOILER_DATA_WW, &nrgWw_, DeviceValueType::ULONG, DeviceValueNumOp::DV_NUMOP_DIV100, FL_(nrgWw), DeviceValueUOM::KWH);
+    register_device_value(DeviceValueTAG::TAG_DEVICE_DATA, &nrgHeat_, DeviceValueType::ULONG, DeviceValueNumOp::DV_NUMOP_DIV100, FL_(nrgHeat), DeviceValueUOM::KWH);
+    register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
+                          &meterTotal_,
+                          DeviceValueType::ULONG,
+                          DeviceValueNumOp::DV_NUMOP_DIV100,
+                          FL_(meterTotal),
+                          DeviceValueUOM::KWH);
+    register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
+                          &meterComp_,
+                          DeviceValueType::ULONG,
+                          DeviceValueNumOp::DV_NUMOP_DIV100,
+                          FL_(meterComp),
+                          DeviceValueUOM::KWH);
+    register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
+                          &meterEHeat_,
+                          DeviceValueType::ULONG,
+                          DeviceValueNumOp::DV_NUMOP_DIV100,
+                          FL_(meterEHeat),
+                          DeviceValueUOM::KWH);
+    register_device_value(DeviceValueTAG::TAG_DEVICE_DATA,
+                          &meterHeat_,
+                          DeviceValueType::ULONG,
+                          DeviceValueNumOp::DV_NUMOP_DIV100,
+                          FL_(meterHeat),
+                          DeviceValueUOM::KWH);
 }
 
 /*
@@ -226,6 +255,24 @@ void Heatpump::process_HPFunctionTest(std::shared_ptr<const Telegram> telegram)
     has_update(telegram, heatCable_, 10);
 }
 
+// boiler(0x08) -W-> Me(0x0B), ?(0x04AE), data: 00 00 BD C4 00 00 5B 6A 00 00 00 24 00 00 62 59 00 00 00 00 00 00 00 00
+// boiler(0x08) -W-> Me(0x0B), ?(0x04AE), data: 00 00 00 00 00 00 00 00 (offset 24)
+void Heatpump::process_HpEnergy(std::shared_ptr<const Telegram> telegram) {
+    has_update(telegram, nrgTotal_, 0);
+    has_update(telegram, nrgHeat_, 4);
+    has_update(telegram, nrgWw_, 12);
+}
+
+// boiler(0x08) -W-> Me(0x0B), ?(0x04AF), data: 00 00 48 B2 00 00 48 55 00 00 00 5D 00 00 01 78 00 00 00 00 00 00 07 61
+// boiler(0x08) -W-> Me(0x0B), ?(0x04AF), data: 00 00 24 B0 00 00 00 12 00 00 23 A5 00 00 00 4B 00 00 00 00 00 00 00 00 (offset 24)
+// boiler(0x08) -W-> Me(0x0B), ?(0x04AF), data: 00 00 00 00 00 00 00 00 (offset 48)
+void Heatpump::process_HpMeters(std::shared_ptr<const Telegram> telegram) {
+    has_update(telegram, meterTotal_, 0);
+    has_update(telegram, meterComp_, 4);
+    has_update(telegram, meterEHeat_, 8);
+    has_update(telegram, meterHeat_, 24);
+}
+
 /*
  * Broadcast (0x099A), data: 05 00 00 00 00 00 00 37 00 00 1D 00 00 52 00 00 13 01 00 01 7C
  * Broadcast (0x099B), data: 80 00 80 00 01 3C 01 38 80 00 80 00 80 00 01 37 00 00 00 00 64

src/devices/heatpump.h

@@ -67,6 +67,15 @@ class Heatpump : public EMSdevice {
     int16_t hpJr0_;      // low pressure sensor
     int16_t hpJr1_;      // high pressure sensor
 
+    uint32_t nrgTotal_;
+    uint32_t nrgWw_;
+    uint32_t nrgHeat_;
+    uint32_t meterTotal_;
+    uint32_t meterComp_;
+    uint32_t meterEHeat_;
+    uint32_t meterHeat_;
+
+
     void process_HPMonitor1(std::shared_ptr<const Telegram> telegram);
     void process_HPMonitor2(std::shared_ptr<const Telegram> telegram);
     void process_HPSettings(std::shared_ptr<const Telegram> telegram);
@@ -74,6 +83,8 @@ class Heatpump : public EMSdevice {
     void process_HPTemperature(std::shared_ptr<const Telegram> telegram);
     void process_HPFlowTemp(std::shared_ptr<const Telegram> telegram);
     void process_HPComp(std::shared_ptr<const Telegram> telegram);
+    void process_HpEnergy(std::shared_ptr<const Telegram> telegram);
+    void process_HpMeters(std::shared_ptr<const Telegram> telegram);
 
     bool set_controlStrategy(const char * value, const int8_t id);
     bool set_lowNoiseMode(const char * value, const int8_t id);

src/devices/thermostat.cpp

@@ -1052,6 +1052,8 @@ void Thermostat::process_RC300Set(std::shared_ptr<const Telegram> telegram) {
     has_update(telegram, hc->reducetemp, 9);
     has_update(telegram, hc->noreducetemp, 12);
     has_update(telegram, hc->remoteseltemp, 17); // see https://github.com/emsesp/EMS-ESP32/issues/590
+    has_update(telegram, hc->boost, 23);
+    has_update(telegram, hc->boosttime, 24);
     has_update(telegram, hc->cooling, 28);
 }
 
@@ -1096,6 +1098,9 @@ void Thermostat::process_RC300Summer2(std::shared_ptr<const Telegram> telegram)
         has_update(hc->summersetmode, EMS_VALUE_UINT_NOTSET);
     }
     has_update(telegram, hc->summertemp, 1);
+    has_update(telegram, hc->heatondelay, 2);
+    has_update(telegram, hc->heatoffdelay, 3);
+    has_update(telegram, hc->instantstart, 4);
 }
 
 // types 0x29B ff
@@ -2670,7 +2675,75 @@ bool Thermostat::set_switchonoptimization(const char * value, const int8_t id) {
     write_command(curve_typeids[hc->hc()], 4, b ? 0xFF : 0x00, curve_typeids[hc->hc()]);
     return true;
 }
+bool Thermostat::set_boost(const char * value, const int8_t id) {
+    uint8_t                                     hc_num = (id == -1) ? AUTO_HEATING_CIRCUIT : id;
+    std::shared_ptr<Thermostat::HeatingCircuit> hc     = heating_circuit(hc_num);
+    if (hc == nullptr) {
+        return false;
+    }
+    bool b;
+    if (!Helpers::value2bool(value, b)) {
+        return false;
+    }
+    write_command(set_typeids[hc->hc()], 23, b ? 0xFF : 0x00, set_typeids[hc->hc()]);
+    return true;
+}
 
+bool Thermostat::set_boosttime(const char * value, const int8_t id) {
+    uint8_t                                     hc_num = (id == -1) ? AUTO_HEATING_CIRCUIT : id;
+    std::shared_ptr<Thermostat::HeatingCircuit> hc     = heating_circuit(hc_num);
+    if (hc == nullptr) {
+        return false;
+    }
+    int v;
+    if (!Helpers::value2number(value, v)) {
+        return false;
+    }
+    write_command(set_typeids[hc->hc()], 24, (uint8_t)v, set_typeids[hc->hc()]);
+    return true;
+}
+
+bool Thermostat::set_heatondelay(const char * value, const int8_t id) {
+    uint8_t                                     hc_num = (id == -1) ? AUTO_HEATING_CIRCUIT : id;
+    std::shared_ptr<Thermostat::HeatingCircuit> hc     = heating_circuit(hc_num);
+    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()]);
+    return true;
+}
+
+bool Thermostat::set_heatoffdelay(const char * value, const int8_t id) {
+    uint8_t                                     hc_num = (id == -1) ? AUTO_HEATING_CIRCUIT : id;
+    std::shared_ptr<Thermostat::HeatingCircuit> hc     = heating_circuit(hc_num);
+    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()]);
+    return true;
+}
+
+bool Thermostat::set_instantstart(const char * value, const int8_t id) {
+    uint8_t                                     hc_num = (id == -1) ? AUTO_HEATING_CIRCUIT : id;
+    std::shared_ptr<Thermostat::HeatingCircuit> hc     = heating_circuit(hc_num);
+    if (hc == nullptr) {
+        return false;
+    }
+    int v;
+    if (!Helpers::value2number(value, v)) {
+        return false;
+    }
+    write_command(summer2_typeids[hc->hc()], 4, (uint8_t)v, summer2_typeids[hc->hc()]);
+    return true;
+}
 
 // sets the thermostat reducemode for RC35 and RC310
 bool Thermostat::set_reducemode(const char * value, const int8_t id) {
@@ -4272,6 +4345,11 @@ void Thermostat::register_device_values_hc(std::shared_ptr<Thermostat::HeatingCi
                               -1,
                               101);
         register_device_value(tag, &hc->remotehum, DeviceValueType::UINT, FL_(remotehum), DeviceValueUOM::PERCENT, MAKE_CF_CB(set_remotehum), -1, 101);
+        register_device_value(tag, &hc->heatondelay, DeviceValueType::UINT, FL_(heatondelay), DeviceValueUOM::HOURS, MAKE_CF_CB(set_heatondelay), 1, 48);
+        register_device_value(tag, &hc->heatoffdelay, DeviceValueType::UINT, FL_(heatoffdelay), DeviceValueUOM::HOURS, MAKE_CF_CB(set_heatoffdelay), 1, 48);
+        register_device_value(tag, &hc->instantstart, DeviceValueType::UINT, FL_(instantstart), DeviceValueUOM::K, MAKE_CF_CB(set_instantstart), 1, 10);
+        register_device_value(tag, &hc->boost, DeviceValueType::BOOL, FL_(boost), DeviceValueUOM::NONE, MAKE_CF_CB(set_boost));
+        register_device_value(tag, &hc->boosttime, DeviceValueType::UINT, FL_(boosttime), DeviceValueUOM::HOURS, MAKE_CF_CB(set_boosttime));
 
         break;
     case EMS_DEVICE_FLAG_CRF:

src/devices/thermostat.h

@@ -98,6 +98,12 @@ class Thermostat : public EMSdevice {
         uint8_t hpmode;
         uint8_t cooling;
         uint8_t coolingon;
+        // RC300
+        uint8_t heatoffdelay; // 1-48h
+        uint8_t heatondelay;  // 1-48h
+        uint8_t instantstart; // 1-10K
+        uint8_t boost;
+        uint8_t boosttime; // hours
 
         uint8_t hc_num() const {
             return hc_num_;
@@ -439,6 +445,11 @@ class Thermostat : public EMSdevice {
     bool set_wwprio(const char * value, const int8_t id);
     bool set_fastheatup(const char * value, const int8_t id);
     bool set_switchonoptimization(const char * value, const int8_t id);
+    bool set_heatondelay(const char * value, const int8_t id);
+    bool set_heatoffdelay(const char * value, const int8_t id);
+    bool set_instantstart(const char * value, const int8_t id);
+    bool set_boost(const char * value, const int8_t id);
+    bool set_boosttime(const char * value, const int8_t id);
 
     inline bool set_temp(const char * value, const int8_t id) {
         return set_temperature_value(value, id, HeatingCircuit::Mode::AUTO);

src/emsdevice.cpp

@@ -969,19 +969,15 @@ void EMSdevice::generate_values_web(JsonObject & output) {
                 }
                 // handle INTs
                 else {
-                    // add step if it's not 1
-                    if (dv.numeric_operator > 0) {
-                        obj["s"] = (float)1 / dv.numeric_operator;
-                    } else if (dv.numeric_operator < 0) {
-                        obj["s"] = (float)(-1) * dv.numeric_operator;
-                    }
-
                     // add min and max values, if available
                     int16_t  dv_set_min;
                     uint32_t dv_set_max;
                     if (dv.get_min_max(dv_set_min, dv_set_max)) {
                         obj["m"] = dv_set_min;
                         obj["x"] = dv_set_max;
+                        // add steps to numeric values as rendered string to avoid rounding floats in js
+                        char s[10];
+                        obj["s"] = Helpers::render_value(s, (uint32_t)1, dv.numeric_operator);
                     }
                 }
             }

src/locale_common.h

@@ -283,6 +283,7 @@ MAKE_ENUM(enum_flow, FL_(off), FL_(flow), FL_(bufferedflow), FL_(buffer), FL_(la
 MAKE_ENUM(enum_reset, FL_(dash), FL_(maintenance), FL_(error))
 MAKE_ENUM(enum_maxHeat, FL_(0kW), FL_(2kW), FL_(3kW), FL_(4kW), FL_(6kW), FL_(9kW))
 MAKE_ENUM(enum_pumpMode, FL_(proportional), FL_(deltaP1), FL_(deltaP2), FL_(deltaP3), FL_(deltaP4))
+MAKE_ENUM(enum_hpPumpMode, FL_(auto), FL_(continuous))
 
 // thermostat lists
 MAKE_ENUM(enum_ibaMainDisplay, FL_(internal_temperature), FL_(internal_setpoint), FL_(external_temperature), FL_(burner_temperature), FL_(ww_temperature), FL_(functioning_mode), FL_(time), FL_(date), FL_(smoke_temperature))

src/locale_translations.h

@@ -453,6 +453,12 @@ MAKE_TRANSLATION(wwAlternatingOper, "wwalternatingop", "alternating operation",
 MAKE_TRANSLATION(wwAltOpPrioHeat, "wwaltopprioheat", "prioritise heating during dhw", "Heizen bevorzugt vor WW", "Proriteit verwarming boven ww", "", "czas na ogrzewanie w trakcie c.w.u", "prioritert oppvarmning", "", "sıcak kullanım suyu esnasında ısıtmayı öne al", "dare la priorità al riscaldamento durante l'ACS") // TODO translate
 MAKE_TRANSLATION(wwAltOpPrioWw, "wwaltopprioww", "prioritise dhw during heating", "WW bevorzugt vor Heizen", "Prioriteit ww boven verwarming", "", "czas na c.w.u w trakcie ogrzewania", "prioritert varmtvann", "", "ısıtma esnasında sıcak kullanım suyunu öne al", "dare priorità all'acqua calda durante il riscaldamento") // TODO translate
 MAKE_TRANSLATION(hpEA0, "hpea0", "condensate reservoir heating (EA0)", "Heizung Kondensatwanne (EA0)", "", "", "", "", "", "", "") // TODO translate
+MAKE_TRANSLATION(boost, "boost", "boost mode", "Boost", "", "", "", "", "", "", "") // TODO translate
+MAKE_TRANSLATION(boosttime, "boosttime", "boost time", "Boost Dauer", "", "", "", "", "", "", "") // TODO translate
+MAKE_TRANSLATION(hpPumpMode, "hppumpmode", "primary heatpump mode", "Modus Hauptpumpe", "", "", "", "", "", "", "") // TODO translate
+MAKE_TRANSLATION(instantstart, "instantstart", "instant start", "Sofortstart", "", "", "", "", "", "", "") // TODO translate
+MAKE_TRANSLATION(heatondelay, "heatondelay", "heat-on delay", "Einschaltverzögerung Heizen", "", "", "", "", "", "", "") // TODO translate
+MAKE_TRANSLATION(heatoffdelay, "heatoffdelay", "heat-off delay", "Ausschaltverzögerung Heizen", "", "", "", "", "", "", "") // TODO translate
 
 // hybrid heatpump
 MAKE_TRANSLATION(hybridStrategy, "hybridstrategy", "hybrid control strategy", "Hybrid Strategie", "Hybride strategie", "Hybrid kontrollstrategi", "strategia sterowania hybrydowego", "hybrid kontrollstrategi", "stratégie contrôle hybride", "hibrit kontrol stratejisi", "strategia comtrollo ibrido")
@@ -520,6 +526,7 @@ MAKE_TRANSLATION(nomPower, "nompower", "nominal Power", "Brennerleistung", "", "
 MAKE_TRANSLATION(meterTotal, "metertotal", "meter total", "Messung gesamt", "", "", "licznik całkowity", "", "", "", "") // TODO translate
 MAKE_TRANSLATION(meterComp, "metercomp", "meter compressor", "Messung Kompressor", "", "", "licznik sprężarki", "", "", "", "") // TODO translate
 MAKE_TRANSLATION(meterEHeat, "metereheat", "meter e-heater", "Messung E-Heizer", "", "", "licznik e-heater", "", "", "", "") // TODO translate
+MAKE_TRANSLATION(meterHeat, "meterheat", "meter heating", "Messung Heizen", "", "", "licznik grzania", "", "", "", "") // TODO translate
 
 // HIU
 MAKE_TRANSLATION(netFlowTemp, "netflowtemp", "heat network flow temp", "System Vorlauftemperatur", "Netto aanvoertemperatuur", "", "temp. zasilania sieci cieplnej", "", "", "ısıtma şebekesi akış derecesi", "temperatura di mandata della rete di riscaldamento") // TODO translate

src/version.h

@@ -1 +1 @@
-#define EMSESP_APP_VERSION "3.6.5-dev.1"
+#define EMSESP_APP_VERSION "3.6.5-dev.2"