Merge pull request #445 from MichaelDvP/dev

Status of changes for the last issues

interface/src/framework/ntp/NTPStatusForm.tsx

@@ -32,11 +32,14 @@ import { extractErrorMessage, formatDateTime, formatLocalDateTime, useRest } fro
 import { AuthenticatedContext } from '../../contexts/authentication';
 
 export const isNtpActive = ({ status }: NTPStatus) => status === NTPSyncStatus.NTP_ACTIVE;
+export const isNtpEnabled = ({ status }: NTPStatus) => status !== NTPSyncStatus.NTP_DISABLED;
 
 export const ntpStatusHighlight = ({ status }: NTPStatus, theme: Theme) => {
   switch (status) {
-    case NTPSyncStatus.NTP_INACTIVE:
+    case NTPSyncStatus.NTP_DISABLED:
       return theme.palette.info.main;
+    case NTPSyncStatus.NTP_INACTIVE:
+      return theme.palette.error.main;
     case NTPSyncStatus.NTP_ACTIVE:
       return theme.palette.success.main;
     default:
@@ -46,6 +49,8 @@ export const ntpStatusHighlight = ({ status }: NTPStatus, theme: Theme) => {
 
 export const ntpStatus = ({ status }: NTPStatus) => {
   switch (status) {
+    case NTPSyncStatus.NTP_DISABLED:
+      return 'Disabled';
     case NTPSyncStatus.NTP_INACTIVE:
       return 'Inactive';
     case NTPSyncStatus.NTP_ACTIVE:
@@ -143,7 +148,7 @@ const NTPStatusForm: FC = () => {
             <ListItemText primary="Status" secondary={ntpStatus(data)} />
           </ListItem>
           <Divider variant="inset" component="li" />
-          {isNtpActive(data) && (
+          {isNtpEnabled(data) && (
             <>
               <ListItem>
                 <ListItemAvatar>

interface/src/project/SettingsCustomization.tsx

@@ -123,15 +123,15 @@ const SettingsCustomization: FC = () => {
              mark it as favorite to be listed at the top of the Dashboard
           </Typography>
           <Typography ml={2} display="block" variant="body2" sx={{ alignItems: 'center', display: 'flex' }}>
-            <EditOffOutlinedIcon color="action" sx={{ fontSize: 13 }} />
+            <EditOffOutlinedIcon color="secondary" sx={{ fontSize: 13 }} />
             &nbsp;make it read-only, only if it has write operation available
           </Typography>
           <Typography ml={2} display="block" variant="body2" sx={{ alignItems: 'center', display: 'flex' }}>
-            <CommentsDisabledOutlinedIcon color="action" sx={{ fontSize: 13 }} />
+            <CommentsDisabledOutlinedIcon color="secondary" sx={{ fontSize: 13 }} />
             &nbsp;excluded it from MQTT and API outputs
           </Typography>
           <Typography ml={2} mb={1} display="block" variant="body2" sx={{ alignItems: 'center', display: 'flex' }}>
-            <VisibilityOffOutlinedIcon color="action" sx={{ fontSize: 13 }} />
+            <VisibilityOffOutlinedIcon color="secondary" sx={{ fontSize: 13 }} />
             &nbsp;hide it from the Dashboard
           </Typography>
         </Box>

interface/src/types/ntp.ts

@@ -1,6 +1,7 @@
 export enum NTPSyncStatus {
-  NTP_INACTIVE = 0,
+  NTP_DISABLED = 0,
-  NTP_ACTIVE = 1
+  NTP_INACTIVE = 1,
+  NTP_ACTIVE = 2
 }
 
 export interface NTPStatus {

lib/framework/NTPSettingsService.cpp

@@ -59,7 +59,7 @@ void NTPSettingsService::configureNTP() {
 }
 
 void NTPSettingsService::configureTime(AsyncWebServerRequest * request, JsonVariant & json) {
-    if (!sntp_enabled() && json.is<JsonObject>()) {
+    if (json.is<JsonObject>()) {
         struct tm tm        = {0};
         String    timeLocal = json["local_time"];
         char *    s         = strptime(timeLocal.c_str(), "%Y-%m-%dT%H:%M:%S", &tm);

lib/framework/NTPStatus.cpp

@@ -36,7 +36,7 @@ void NTPStatus::ntpStatus(AsyncWebServerRequest * request) {
     time_t now = time(nullptr);
 
     // only provide enabled/disabled status for now
-    root["status"] = sntp_enabled() && emsesp::EMSESP::system_.ntp_connected() ? 1 : 0;
+    root["status"] = sntp_enabled() ? emsesp::EMSESP::system_.ntp_connected() ? 2 : 1 : 0;
 
     // the current time in UTC
     root["utc_time"] = toUTCTimeString(gmtime(&now));

src/device_library.h

@@ -109,9 +109,11 @@
 {191, DeviceType::THERMOSTAT, F("FR120"), DeviceFlags::EMS_DEVICE_FLAG_JUNKERS | DeviceFlags::EMS_DEVICE_FLAG_JUNKERS_OLD}, // older model
 {192, DeviceType::THERMOSTAT, F("FW120"), DeviceFlags::EMS_DEVICE_FLAG_JUNKERS},
 
-// Solar Modules - 0x30, 0x2A (for ww)
+// Solar Modules - 0x30 (for solar), 0x2A, 0x41 (for ww)
 { 73, DeviceType::SOLAR, F("SM10"), DeviceFlags::EMS_DEVICE_FLAG_SM10},
+{100, DeviceType::SOLAR, F("ISM DHW"), DeviceFlags::EMS_DEVICE_FLAG_ISM},
 {101, DeviceType::SOLAR, F("ISM1"), DeviceFlags::EMS_DEVICE_FLAG_ISM},
+{103, DeviceType::SOLAR, F("ISM2"), DeviceFlags::EMS_DEVICE_FLAG_ISM},
 {162, DeviceType::SOLAR, F("SM50"), DeviceFlags::EMS_DEVICE_FLAG_SM100},
 {163, DeviceType::SOLAR, F("SM100/MS100"), DeviceFlags::EMS_DEVICE_FLAG_SM100},
 {164, DeviceType::SOLAR, F("SM200/MS200"), DeviceFlags::EMS_DEVICE_FLAG_SM100},

src/devices/solar.cpp

@@ -34,7 +34,7 @@ Solar::Solar(uint8_t device_type, uint8_t device_id, uint8_t product_id, const c
     }
 
     if (flags == EMSdevice::EMS_DEVICE_FLAG_SM100) {
-        if (device_id == 0x2A) {
+        if (device_id == 0x2A) { // SM100 DHW
             register_telegram_type(0x07D6, F("SM100wwTemperature"), false, MAKE_PF_CB(process_SM100wwTemperature));
             register_telegram_type(0x07AA, F("SM100wwStatus"), false, MAKE_PF_CB(process_SM100wwStatus));
             register_telegram_type(0x07AB, F("SM100wwCommand"), false, MAKE_PF_CB(process_SM100wwCommand));
@@ -63,13 +63,31 @@ Solar::Solar(uint8_t device_type, uint8_t device_id, uint8_t product_id, const c
     }
 
     if (flags == EMSdevice::EMS_DEVICE_FLAG_ISM) {
+        if (device_id == 0x41) { // ISM DHW module
+            register_telegram_type(0x34, F("UBAMonitorWW"), false, MAKE_PF_CB(process_MonitorWW));
+        } else {
             register_telegram_type(0x0103, F("ISM1StatusMessage"), true, MAKE_PF_CB(process_ISM1StatusMessage));
             register_telegram_type(0x0101, F("ISM1Set"), true, MAKE_PF_CB(process_ISM1Set));
+            register_telegram_type(0x0104, F("ISM2StatusMessage"), false, MAKE_PF_CB(process_ISM2StatusMessage));
+        }
     }
 
     // device values...
 
-    // special case for a device_id with 0x2A where it's not actual a solar module
+    // special case ISM DHW module
+    if (device_id == 0x41) { // ISM DHW module
+        register_device_value(DeviceValueTAG::TAG_DEVICE_DATA_WW,
+                              &wwSelTemp_,
+                              DeviceValueType::UINT,
+                              nullptr,
+                              FL_(wwSelTemp),
+                              DeviceValueUOM::DEGREES,
+                              MAKE_CF_CB(set_wwSelTemp));
+        register_device_value(DeviceValueTAG::TAG_DEVICE_DATA_WW, &wwTemp_1_, DeviceValueType::USHORT, FL_(div10), FL_(wwCurTemp), DeviceValueUOM::DEGREES);
+        register_device_value(DeviceValueTAG::TAG_DEVICE_DATA_WW, &wwTemp_3_, DeviceValueType::USHORT, FL_(div10), FL_(wwCurTemp2), DeviceValueUOM::DEGREES);
+        return;
+    }
+    // special case for a SM100 DHW device_id with 0x2A where it's not actual a solar module
     if (device_id == 0x2A) {
         register_device_value(DeviceValueTAG::TAG_DEVICE_DATA_WW, &wwTemp_1_, DeviceValueType::USHORT, FL_(div10), FL_(wwTemp1), DeviceValueUOM::DEGREES);
         register_device_value(DeviceValueTAG::TAG_DEVICE_DATA_WW, &wwTemp_3_, DeviceValueType::USHORT, FL_(div10), FL_(wwTemp3), DeviceValueUOM::DEGREES);
@@ -84,8 +102,13 @@ Solar::Solar(uint8_t device_type, uint8_t device_id, uint8_t product_id, const c
                               FL_(wwMaxTemp),
                               DeviceValueUOM::DEGREES,
                               MAKE_CF_CB(set_wwMaxTemp));
-        register_device_value(
+        register_device_value(DeviceValueTAG::TAG_DEVICE_DATA_WW,
-            DeviceValueTAG::TAG_DEVICE_DATA_WW, &wwTemp_, DeviceValueType::UINT, nullptr, FL_(wwTemp), DeviceValueUOM::DEGREES, MAKE_CF_CB(set_wwTemp));
+                              &wwSelTemp_,
+                              DeviceValueType::UINT,
+                              nullptr,
+                              FL_(wwSelTemp),
+                              DeviceValueUOM::DEGREES,
+                              MAKE_CF_CB(set_wwSelTemp));
         register_device_value(DeviceValueTAG::TAG_DEVICE_DATA_WW,
                               &wwRedTemp_,
                               DeviceValueType::UINT,
@@ -128,6 +151,7 @@ Solar::Solar(uint8_t device_type, uint8_t device_id, uint8_t product_id, const c
         return;
     }
 
+    // common solar values for all modules (except dhw)
     register_device_value(DeviceValueTAG::TAG_NONE, &collectorTemp_, DeviceValueType::SHORT, FL_(div10), FL_(collectorTemp), DeviceValueUOM::DEGREES);
     register_device_value(DeviceValueTAG::TAG_NONE, &cylBottomTemp_, DeviceValueType::SHORT, FL_(div10), FL_(cylBottomTemp), DeviceValueUOM::DEGREES);
     register_device_value(DeviceValueTAG::TAG_NONE, &solarPump_, DeviceValueType::BOOL, nullptr, FL_(solarPump), DeviceValueUOM::NONE);
@@ -137,6 +161,7 @@ Solar::Solar(uint8_t device_type, uint8_t device_id, uint8_t product_id, const c
     register_device_value(DeviceValueTAG::TAG_NONE, &collectorShutdown_, DeviceValueType::BOOL, nullptr, FL_(collectorShutdown), DeviceValueUOM::NONE);
     register_device_value(DeviceValueTAG::TAG_NONE, &cylHeated_, DeviceValueType::BOOL, nullptr, FL_(cylHeated), DeviceValueUOM::NONE);
 
+    // values per device flag
     if (flags == EMSdevice::EMS_DEVICE_FLAG_SM10) {
         register_device_value(DeviceValueTAG::TAG_NONE, &solarPumpMod_, DeviceValueType::UINT, nullptr, FL_(solarPumpMod), DeviceValueUOM::PERCENT);
         register_device_value(
@@ -185,6 +210,9 @@ Solar::Solar(uint8_t device_type, uint8_t device_id, uint8_t product_id, const c
 		*/
     }
     if (flags == EMSdevice::EMS_DEVICE_FLAG_ISM) {
+        register_device_value(DeviceValueTAG::TAG_NONE, &cylMiddleTemp_, DeviceValueType::SHORT, FL_(div10), FL_(cylMiddleTemp), DeviceValueUOM::DEGREES);
+        register_device_value(DeviceValueTAG::TAG_NONE, &retHeatAssist_, DeviceValueType::SHORT, FL_(div10), FL_(retHeatAssist), DeviceValueUOM::DEGREES);
+        register_device_value(DeviceValueTAG::TAG_NONE, &m1Valve_, DeviceValueType::BOOL, nullptr, FL_(m1Valve), DeviceValueUOM::NONE);
         register_device_value(DeviceValueTAG::TAG_NONE, &energyLastHour_, DeviceValueType::ULONG, FL_(div10), FL_(energyLastHour), DeviceValueUOM::WH);
     }
 
@@ -582,7 +610,7 @@ void Solar::process_SM100wwStatus(std::shared_ptr<const Telegram> telegram) {
 // data: FF 05 0F 5F 00 01 3C 3C 3C 3C 28 12 46 01 3C 1E 03 07 3C 00 0F 00 05
 void Solar::process_SM100wwParam(std::shared_ptr<const Telegram> telegram) {
     has_update(telegram, wwMaxTemp_, 8);
-    has_update(telegram, wwTemp_, 9);
+    has_update(telegram, wwSelTemp_, 9);
     has_update(telegram, wwRedTemp_, 10);
     has_update(telegram, wwDailyTemp_, 6);
     has_update(telegram, wwDisinfectionTemp_, 12);
@@ -762,6 +790,18 @@ void Solar::process_ISM1StatusMessage(std::shared_ptr<const Telegram> telegram)
     has_bitupdate(telegram, cylHeated_, 9, 2);         // cyl full
 }
 
+/*
+ * Junkers ISM12 Solar Module - type 0x0104 EMS+ for heat assist
+ * ?(0x103), data: 00 00 00 00 00 7A 01 15 00 00 05 37 F0
+ * ?(0x104), data: 01 A9 01 22 27 0F 27 0F 27 0F 27 0F 27 0F 27 0F
+ * ?(0x104), data: 01 01 00 00 00 00 00 27 0F 27 0F (offset 16)
+ */
+void Solar::process_ISM2StatusMessage(std::shared_ptr<const Telegram> telegram) {
+    has_update(telegram, cylMiddleTemp_, 0);  // Temperature Middle of Solar Boiler cyl
+    has_update(telegram, retHeatAssist_, 2);  // return temperature from heating T4
+    has_bitupdate(telegram, m1Valve_, 17, 0); // return valve DUW1 (also 16,0)
+}
+
 /*
  * Junkers ISM1 Solar Module - type 0x0101 EMS+ for setting values
  */
@@ -769,6 +809,16 @@ void Solar::process_ISM1Set(std::shared_ptr<const Telegram> telegram) {
     has_update(telegram, cylMaxTemp_, 6);
 }
 
+/*
+ * Junkers ISM1 Solar DHW Module - type 0x34 ww
+ */
+void Solar::process_MonitorWW(std::shared_ptr<const Telegram> telegram) {
+    has_update(telegram, wwSelTemp_, 0);
+    has_update(telegram, wwTemp_1_, 1);
+    has_update(telegram, wwTemp_3_, 3);
+}
+
+
 /*
  * Settings
  */
@@ -917,54 +967,54 @@ bool Solar::set_SM10MaxFlow(const char * value, const int8_t id) {
 
 // switch heat transfer system on/off
 bool Solar::set_heatTransferSystem(const char * value, const int8_t id) {
-    bool v = false;
+    bool b;
-    if (!Helpers::value2bool(value, v)) {
+    if (!Helpers::value2bool(value, b)) {
         return false;
     }
-    write_command(0x358, 5, v ? 0x01 : 0x00, 0x358);
+    write_command(0x358, 5, b ? 0x01 : 0x00, 0x358);
     return true;
 }
 
 // switch external cylinder on/off
 bool Solar::set_externalCyl(const char * value, const int8_t id) {
-    bool v = false;
+    bool b;
-    if (!Helpers::value2bool(value, v)) {
+    if (!Helpers::value2bool(value, b)) {
         return false;
     }
-    write_command(0x358, 9, v ? 0x01 : 0x00, 0x358);
+    write_command(0x358, 9, b ? 0x01 : 0x00, 0x358);
     return true;
 }
 
 // switch thermal disinfection on/off
 bool Solar::set_thermalDisinfect(const char * value, const int8_t id) {
-    bool v = false;
+    bool b;
-    if (!Helpers::value2bool(value, v)) {
+    if (!Helpers::value2bool(value, b)) {
         return false;
     }
-    write_command(0x358, 10, v ? 0x01 : 0x00, 0x358);
+    write_command(0x358, 10, b ? 0x01 : 0x00, 0x358);
     return true;
 }
 
 // switch heat metering on/off
 bool Solar::set_heatMetering(const char * value, const int8_t id) {
-    bool v = false;
+    bool b;
-    if (!Helpers::value2bool(value, v)) {
+    if (!Helpers::value2bool(value, b)) {
         return false;
     }
-    write_command(0x358, 14, v ? 0x01 : 0x00, 0x358);
+    write_command(0x358, 14, b ? 0x01 : 0x00, 0x358);
     return true;
 }
 
 // switch solar system on/off
 bool Solar::set_solarEnabled(const char * value, const int8_t id) {
-    bool v = false;
+    bool b;
-    if (!Helpers::value2bool(value, v)) {
+    if (!Helpers::value2bool(value, b)) {
         return false;
     }
     if (flags() == EMSdevice::EMS_DEVICE_FLAG_SM10) {
-        write_command(0x96, 0, v ? 0xFF : 0x00, 0x96);
+        write_command(0x96, 0, b ? 0xFF : 0x00, 0x96);
     } else {
-        write_command(0x358, 19, v ? 0x01 : 0x00, 0x358);
+        write_command(0x358, 19, b ? 0x01 : 0x00, 0x358);
     }
     return true;
 }
@@ -992,71 +1042,71 @@ bool Solar::set_solarMode2(const char * value, const int8_t id) {
 
 // switch pumpkick on/off
 bool Solar::set_solarPumpKick(const char * value, const int8_t id) {
-    bool v = false;
+    bool b;
-    if (!Helpers::value2bool(value, v)) {
+    if (!Helpers::value2bool(value, b)) {
         return false;
     }
-    write_command(0x35A, 9, v ? 0x01 : 0x00, 0x35A);
+    write_command(0x35A, 9, b ? 0x01 : 0x00, 0x35A);
     return true;
 }
 
 // switch pump2kick on/off
 bool Solar::set_solarPump2Kick(const char * value, const int8_t id) {
-    bool v = false;
+    bool b;
-    if (!Helpers::value2bool(value, v)) {
+    if (!Helpers::value2bool(value, b)) {
         return false;
     }
-    write_command(0x35D, 0, v ? 0x01 : 0x00, 0x35D);
+    write_command(0x35D, 0, b ? 0x01 : 0x00, 0x35D);
     return true;
 }
 
 // switch plain water mode on/off
 bool Solar::set_plainWaterMode(const char * value, const int8_t id) {
-    bool v = false;
+    bool b;
-    if (!Helpers::value2bool(value, v)) {
+    if (!Helpers::value2bool(value, b)) {
         return false;
     }
-    write_command(0x35A, 10, v ? 0x01 : 0x00, 0x35A);
+    write_command(0x35A, 10, b ? 0x01 : 0x00, 0x35A);
     return true;
 }
 
 // switch double match flow on/off
 bool Solar::set_doubleMatchFlow(const char * value, const int8_t id) {
-    bool v = false;
+    bool b;
-    if (!Helpers::value2bool(value, v)) {
+    if (!Helpers::value2bool(value, b)) {
         return false;
     }
-    write_command(0x35A, 11, v ? 0x01 : 0x00, 0x35A);
+    write_command(0x35A, 11, b ? 0x01 : 0x00, 0x35A);
     return true;
 }
 
 // set climate zone number
 bool Solar::set_climateZone(const char * value, const int8_t id) {
-    int v = 0;
+    int zone;
-    if (!Helpers::value2number(value, v)) {
+    if (!Helpers::value2number(value, zone)) {
         return false;
     }
-    write_command(0x380, 0, v, 0x380);
+    write_command(0x380, 0, zone, 0x380);
     return true;
 }
 
 // collector area in squaremeters
 bool Solar::set_collector1Area(const char * value, const int8_t id) {
-    float v = 0;
+    float area;
-    if (!Helpers::value2float(value, v)) {
+    if (!Helpers::value2float(value, area)) {
         return false;
     }
-    write_command(0x380, 3, (uint16_t)(v * 10), 0x380);
+    write_command(0x380, 3, (uint16_t)(area * 10), 0x380);
     return true;
 }
 
 // collector area in squaremeters
 bool Solar::set_collector2Area(const char * value, const int8_t id) {
-    float v = 0;
+    float area;
-    if (!Helpers::value2float(value, v)) {
+    if (!Helpers::value2float(value, area)) {
         return false;
     }
-    write_command(0x380, 6, (uint16_t)(v * 10), 0x380);
+    write_command(0x380, 6, (uint16_t)(area * 10), 0x380);
     return true;
 }
 
@@ -1082,101 +1132,105 @@ bool Solar::set_collector2Type(const char * value, const int8_t id) {
 
 // priority of cylinders if there are 2
 bool Solar::set_cylPriority(const char * value, const int8_t id) {
-    uint8_t n;
+    uint8_t num;
-    if (!Helpers::value2enum(value, n, FL_(enum_cylprio))) {
+    if (!Helpers::value2enum(value, num, FL_(enum_cylprio))) {
         return false;
     }
-    write_command(0x35F, 3, n, 0x35F);
+    write_command(0x35F, 3, num, 0x35F);
     return true;
 }
 
 bool Solar::set_heatAssist(const char * value, const int8_t id) {
-    float v = 0;
+    float temperature;
-    if (!Helpers::value2temperature(value, v)) {
+    if (!Helpers::value2temperature(value, temperature)) {
         return false;
     }
-    write_command(0x35C, 0, (uint8_t)(v * 10), 0x35C);
+    write_command(0x35C, 0, (uint8_t)(temperature * 10), 0x35C);
     return true;
 }
 
 bool Solar::set_diffControl(const char * value, const int8_t id) {
-    float v = 0;
+    float temperature;
-    if (!Helpers::value2temperature(value, v)) {
+    if (!Helpers::value2temperature(value, temperature)) {
         return false;
     }
-    write_command(0x361, 4, (uint8_t)(v * 10), 0x361);
+    write_command(0x361, 4, (uint8_t)(temperature * 10), 0x361);
     return true;
 }
 
-bool Solar::set_wwTemp(const char * value, const int8_t id) {
+bool Solar::set_wwSelTemp(const char * value, const int8_t id) {
-    float v = 0;
+    int temperature;
-    if (!Helpers::value2temperature(value, v)) {
+    if (!Helpers::value2temperature(value, temperature)) {
         return false;
     }
-    write_command(0x7A6, 9, (uint8_t)v, 0x7A6);
+    if (flags() == EMSdevice::EMS_DEVICE_FLAG_ISM) {
+        write_command(0x35, 3, (uint8_t)temperature, 0x34);
+    } else { // SM100
+        write_command(0x7A6, 9, (uint8_t)temperature, 0x7A6);
+    }
     return true;
 }
 
 bool Solar::set_wwMaxTemp(const char * value, const int8_t id) {
-    float v = 0;
+    int temperature;
-    if (!Helpers::value2temperature(value, v)) {
+    if (!Helpers::value2temperature(value, temperature)) {
         return false;
     }
-    write_command(0x7A6, 8, (uint8_t)v, 0x7A6);
+    write_command(0x7A6, 8, (uint8_t)temperature, 0x7A6);
     return true;
 }
 
 bool Solar::set_wwRedTemp(const char * value, const int8_t id) {
-    float v = 0;
+    int temperature;
-    if (!Helpers::value2temperature(value, v)) {
+    if (!Helpers::value2temperature(value, temperature)) {
         return false;
     }
-    write_command(0x7A6, 10, (uint8_t)v, 0x7A6);
+    write_command(0x7A6, 10, (uint8_t)temperature, 0x7A6);
     return true;
 }
 
 bool Solar::set_wwDailyTemp(const char * value, const int8_t id) {
-    float v = 0;
+    int temperature;
-    if (!Helpers::value2temperature(value, v)) {
+    if (!Helpers::value2temperature(value, temperature)) {
         return false;
     }
-    write_command(0x7A6, 6, (uint8_t)v, 0x7A6);
+    write_command(0x7A6, 6, (uint8_t)temperature, 0x7A6);
     return true;
 }
 
 bool Solar::set_wwDisinfectionTemp(const char * value, const int8_t id) {
-    float v = 0;
+    int temperature;
-    if (!Helpers::value2temperature(value, v)) {
+    if (!Helpers::value2temperature(value, temperature)) {
         return false;
     }
-    write_command(0x7A6, 12, (uint8_t)v, 0x7A6);
+    write_command(0x7A6, 12, (uint8_t)temperature, 0x7A6);
     return true;
 }
 
 bool Solar::set_wwCirc(const char * value, const int8_t id) {
-    bool v = false;
+    bool b;
-    if (!Helpers::value2bool(value, v)) {
+    if (!Helpers::value2bool(value, b)) {
         return false;
     }
-    write_command(0x7A5, 0, v ? 0xFF : 0x00, 0x7A5);
+    write_command(0x7A5, 0, b ? 0xFF : 0x00, 0x7A5);
     return true;
 }
 
 bool Solar::set_wwCircMode(const char * value, const int8_t id) {
-    uint8_t n;
+    uint8_t num;
-    if (!Helpers::value2enum(value, n, FL_(enum_wwCircMode))) {
+    if (!Helpers::value2enum(value, num, FL_(enum_wwCircMode))) {
         return false;
     }
-    write_command(0x7A5, 3, n, 0x7A5);
+    write_command(0x7A5, 3, num, 0x7A5);
     return true;
 }
 
 bool Solar::set_wwKeepWarm(const char * value, const int8_t id) {
-    bool v = false;
+    bool b;
-    if (!Helpers::value2bool(value, v)) {
+    if (!Helpers::value2bool(value, b)) {
         return false;
     }
-    write_command(0x7AE, 0, v ? 0xFF : 0x00, 0x7AE);
+    write_command(0x7AE, 0, b ? 0xFF : 0x00, 0x7AE);
     return true;
 }
 

src/devices/solar.h

@@ -125,7 +125,7 @@ class Solar : public EMSdevice {
 
     // SM100wwParam - 0x07A6
     uint8_t wwMaxTemp_;
-    uint8_t wwTemp_;
+    uint8_t wwSelTemp_;
     uint8_t wwRedTemp_;
     uint8_t wwDailyTemp_;
     uint8_t wwDisinfectionTemp_;
@@ -187,8 +187,10 @@ class Solar : public EMSdevice {
 
     void process_ISM1StatusMessage(std::shared_ptr<const Telegram> telegram);
     void process_ISM1Set(std::shared_ptr<const Telegram> telegram);
+    void process_ISM2StatusMessage(std::shared_ptr<const Telegram> telegram);
+    void process_MonitorWW(std::shared_ptr<const Telegram> telegram);
 
-
+    // settings
     bool set_CollectorMaxTemp(const char * value, const int8_t id);
     bool set_CollectorMinTemp(const char * value, const int8_t id);
     bool set_cylMaxTemp(const char * value, const int8_t id);
@@ -224,7 +226,7 @@ class Solar : public EMSdevice {
     bool set_heatAssist(const char * value, const int8_t id);
     bool set_diffControl(const char * value, const int8_t id);
 
-    bool set_wwTemp(const char * value, const int8_t id);
+    bool set_wwSelTemp(const char * value, const int8_t id);
     bool set_wwMaxTemp(const char * value, const int8_t id);
     bool set_wwRedTemp(const char * value, const int8_t id);
     bool set_wwCirc(const char * value, const int8_t id);
@@ -232,6 +234,7 @@ class Solar : public EMSdevice {
     bool set_wwKeepWarm(const char * value, const int8_t id);
     bool set_wwDisinfectionTemp(const char * value, const int8_t id);
     bool set_wwDailyTemp(const char * value, const int8_t id);
+
 };
 
 } // namespace emsesp

src/devices/thermostat.cpp

@@ -1236,7 +1236,7 @@ void Thermostat::process_RCTime(std::shared_ptr<const Telegram> telegram) {
     time_t now      = time(nullptr);
     tm *   tm_      = localtime(&now);
     bool   tset_    = tm_->tm_year > 110;                       // year 2010 and up, time is valid
-    tm_->tm_year  = telegram->message_data[0] + 100;
+    tm_->tm_year    = (telegram->message_data[0] & 0x7F) + 100; // IVT
     tm_->tm_mon     = telegram->message_data[1] - 1;
     tm_->tm_mday    = telegram->message_data[3];
     tm_->tm_hour    = telegram->message_data[2];
@@ -1244,8 +1244,9 @@ void Thermostat::process_RCTime(std::shared_ptr<const Telegram> telegram) {
     tm_->tm_sec     = telegram->message_data[5];
     tm_->tm_isdst   = telegram->message_data[7] & 0x01;
     time_t ttime    = mktime(tm_);                                // thermostat time
+    bool   ivtclock = (telegram->message_data[0] & 0x80) == 0x80; // dont sync ivt-clock, #439
     // correct thermostat clock if we have valid ntp time, and could write the command
-    if (tset_ && EMSESP::system_.ntp_connected() && !EMSESP::system_.readonly_mode() && has_command(&dateTime_)) {
+    if (!ivtclock && tset_ && EMSESP::system_.ntp_connected() && !EMSESP::system_.readonly_mode() && has_command(&dateTime_)) {
         double difference = difftime(now, ttime);
         if (difference > 15 || difference < -15) {
             set_datetime("ntp", -1); // set from NTP
@@ -1254,6 +1255,10 @@ void Thermostat::process_RCTime(std::shared_ptr<const Telegram> telegram) {
     }
 #ifndef EMSESP_STANDALONE
     if (!tset_ && tm_->tm_year > 110) { // emsesp clock not set, but thermostat clock
+        if (ivtclock) {
+            tm_->tm_isdst = -1;          // determine dst
+            ttime         = mktime(tm_); // thermostat time
+        }
         struct timeval newnow = {.tv_sec = ttime};
         settimeofday(&newnow, nullptr);
         LOG_INFO(F("ems-esp time set from thermostat"));

src/emsesp.cpp

@@ -630,7 +630,6 @@ void EMSESP::publish_device_values(uint8_t device_type) {
 
             } else {
                 // for all other devices add the values to the json
-                json = doc.to<JsonObject>();
                 need_publish |= emsdevice->generate_values(json, DeviceValueTAG::TAG_NONE, true, EMSdevice::OUTPUT_TARGET::MQTT); // nested
             }
 

src/system.cpp

@@ -1205,7 +1205,7 @@ bool System::command_info(const char * value, const int8_t id, JsonObject & outp
                 obj["product id"] = emsdevice->product_id();
                 obj["version"]    = emsdevice->version();
                 obj["entities"]   = emsdevice->count_entities();
-                char result[250];
+                char result[300];
                 (void)emsdevice->show_telegram_handlers(result, sizeof(result), EMSdevice::Handlers::RECEIVED);
                 if (result[0] != '\0') {
                     obj["handlers received"] = result; // don't show handlers if there aren't any

src/web/WebCustomizationService.cpp

@@ -46,8 +46,8 @@ WebCustomizationService::WebCustomizationService(AsyncWebServer * server, FS * f
                securityManager->wrapRequest(std::bind(&WebCustomizationService::reset_customization, this, _1), AuthenticationPredicates::IS_ADMIN));
 
     _masked_entities_handler.setMethod(HTTP_POST);
-    _masked_entities_handler.setMaxContentLength(2048);
+    _masked_entities_handler.setMaxContentLength(4096);
-    _masked_entities_handler.setMaxJsonBufferSize(2048);
+    _masked_entities_handler.setMaxJsonBufferSize(4096);
     server->addHandler(&_masked_entities_handler);
 
     _device_entities_handler.setMethod(HTTP_POST);
@@ -215,6 +215,7 @@ void WebCustomizationService::device_entities(AsyncWebServerRequest * request, J
 // and updates the entity list real-time
 void WebCustomizationService::masked_entities(AsyncWebServerRequest * request, JsonVariant & json) {
     if (json.is<JsonObject>()) {
+        EMSESP::logger().debug(F("Masked entities json size: %d"), measureJson(json));
         // find the device using the unique_id
         for (const auto & emsdevice : EMSESP::emsdevices) {
             if (emsdevice) {