refactor: improved freeze protection & overheat protection; added desc for OT options

For Baxi Slim with Bertelli

.gitignore

@@ -1,5 +1,6 @@
 .pio
 .vscode
+.PVS-Studio
 build/*
 data/*
 managed_components/*

README.md

@@ -71,5 +71,10 @@ All available information and instructions can be found in the wiki:
       * [Connection](https://github.com/Laxilef/OTGateway/wiki/OT-adapters#connection)
       * [Leds on board](https://github.com/Laxilef/OTGateway/wiki/OT-adapters#leds-on-board)
 
-___
+## Gratitude
-This project is tested with BrowserStack.
+* To the developers of the libraries used: [OpenTherm Library](https://github.com/ihormelnyk/opentherm_library), [ESP8266Scheduler](https://github.com/nrwiersma/ESP8266Scheduler), [ArduinoJson](https://github.com/bblanchon/ArduinoJson), [NimBLE-Arduino](https://github.com/h2zero/NimBLE-Arduino), [ArduinoMqttClient](https://github.com/arduino-libraries/ArduinoMqttClient), [ESPTelnet](https://github.com/LennartHennigs/ESPTelnet), [FileData](https://github.com/GyverLibs/FileData), [GyverPID](https://github.com/GyverLibs/GyverPID), [GyverBlinker](https://github.com/GyverLibs/GyverBlinker), [FileData](https://github.com/GyverLibs/FileData), [OneWireNg](https://github.com/pstolarz/OneWireNg) & [OneWire](https://github.com/PaulStoffregen/OneWire)
+* To the [PlatformIO](https://platformio.org/) Team
+* To the team and contributors of the [pioarduino](https://github.com/pioarduino/platform-espressif32) project
+* To the [BrowserStack](https://www.browserstack.com/) team. This project is tested with BrowserStack.
+* To the [PVS-Studio](https://pvs-studio.com/pvs-studio/?utm_source=website&utm_medium=github&utm_campaign=open_source) - static analyzer for C, C++, C#, and Java code.
+* And of course to the contributors for their contribution to the development of the project!

lib/CustomOpenTherm/CustomOpenTherm.h

@@ -7,7 +7,7 @@ public:
   typedef std::function<void(unsigned long, byte)> BeforeSendRequestCallback;
   typedef std::function<void(unsigned long, unsigned long, OpenThermResponseStatus, byte)> AfterSendRequestCallback;
 
-  CustomOpenTherm(int inPin = 4, int outPin = 5, bool isSlave = false) : OpenTherm(inPin, outPin, isSlave) {}
+  CustomOpenTherm(int inPin = 4, int outPin = 5, bool isSlave = false, bool alwaysReceive = false) : OpenTherm(inPin, outPin, isSlave, alwaysReceive) {}
   ~CustomOpenTherm() {}
 
   CustomOpenTherm* setDelayCallback(DelayCallback callback = nullptr) {
@@ -28,8 +28,8 @@ public:
     return this;
   }
 
-  unsigned long sendRequest(unsigned long request, byte attempts = 5, byte _attempt = 0) {
+  unsigned long sendRequest(unsigned long request) override {
-    _attempt++;
+    this->sendRequestAttempt++;
 
     while (!this->isReady()) {
       if (this->delayCallback) {
@@ -40,15 +40,10 @@ public:
     }
 
     if (this->beforeSendRequestCallback) {
-      this->beforeSendRequestCallback(request, _attempt);
+      this->beforeSendRequestCallback(request, this->sendRequestAttempt);
     }
 
-    unsigned long _response;
+    if (this->sendRequestAsync(request)) {
-    OpenThermResponseStatus _responseStatus = OpenThermResponseStatus::NONE;
-    if (!this->sendRequestAsync(request)) {
-      _response = 0;
-
-    } else {
       do {
         if (this->delayCallback) {
           this->delayCallback(150);
@@ -56,42 +51,25 @@ public:
 
         this->process();
       } while (this->status != OpenThermStatus::READY && this->status != OpenThermStatus::DELAY);
-
-      _response = this->getLastResponse();
-      _responseStatus = this->getLastResponseStatus();
     }
 
     if (this->afterSendRequestCallback) {
-      this->afterSendRequestCallback(request, _response, _responseStatus, _attempt);
+      this->afterSendRequestCallback(request, this->response, this->responseStatus, this->sendRequestAttempt);
     }
 
-    if (_responseStatus == OpenThermResponseStatus::SUCCESS || _responseStatus == OpenThermResponseStatus::INVALID || _attempt >= attempts) {
+    if (this->responseStatus == OpenThermResponseStatus::SUCCESS || this->responseStatus == OpenThermResponseStatus::INVALID) {
-      return _response;
+      this->sendRequestAttempt = 0;
+      return this->response;
+
+    } else if (this->sendRequestAttempt >= this->sendRequestMaxAttempts) {
+      this->sendRequestAttempt = 0;
+      return this->response;
 
     } else {
-      return this->sendRequest(request, attempts, _attempt);
+      return this->sendRequest(request);
     }
   }
 
-  unsigned long setBoilerStatus(bool enableCentralHeating, bool enableHotWater, bool enableCooling, bool enableOutsideTemperatureCompensation, bool enableCentralHeating2, bool summerWinterMode, bool dhwBlocking, uint8_t lb = 0) {
-    unsigned int data = enableCentralHeating
-      | (enableHotWater << 1)
-      | (enableCooling << 2)
-      | (enableOutsideTemperatureCompensation << 3)
-      | (enableCentralHeating2 << 4)
-      | (summerWinterMode << 5)
-      | (dhwBlocking << 6);
-    
-    data <<= 8;
-    data |= lb;
-
-    return this->sendRequest(buildRequest(
-      OpenThermMessageType::READ_DATA,
-      OpenThermMessageID::Status,
-      data
-    ));
-  }
-
   bool sendBoilerReset() {
     unsigned int data = 1;
     data <<= 8;
@@ -128,12 +106,38 @@ public:
     return isValidResponse(response) && isValidResponseId(response, OpenThermMessageID::RemoteRequest);
   }
 
+  static bool isCh2Active(unsigned long response)
+  {
+      return response & 0x20;
+  }
+
   static bool isValidResponseId(unsigned long response, OpenThermMessageID id) {
     byte responseId = (response >> 16) & 0xFF;
 
     return (byte)id == responseId;
   }
 
+  static uint8_t getResponseMessageTypeId(unsigned long response) {
+    return (response << 1) >> 29;
+  }
+
+  static const char* getResponseMessageTypeString(unsigned long response) {
+    uint8_t msgType = getResponseMessageTypeId(response);
+
+    switch (msgType) {
+      case (uint8_t) OpenThermMessageType::READ_ACK:
+      case (uint8_t) OpenThermMessageType::WRITE_ACK:
+      case (uint8_t) OpenThermMessageType::DATA_INVALID:
+      case (uint8_t) OpenThermMessageType::UNKNOWN_DATA_ID:
+        return CustomOpenTherm::messageTypeToString(
+          static_cast<OpenThermMessageType>(msgType)
+        );
+
+      default:
+        return "UNKNOWN";
+    }
+  }
+
   // converters
   template <class T>
   static unsigned int toFloat(const T val) {
@@ -145,6 +149,8 @@ public:
   }
 
 protected:
+  const uint8_t sendRequestMaxAttempts = 5;
+  uint8_t sendRequestAttempt = 0;
   DelayCallback delayCallback;
   BeforeSendRequestCallback beforeSendRequestCallback;
   AfterSendRequestCallback afterSendRequestCallback;

platformio.ini

@@ -14,12 +14,12 @@ extra_configs = secrets.default.ini
 core_dir = .pio
 
 [env]
-version = 1.5.4
+version = 1.5.5
 framework = arduino
 lib_deps = 
 	bblanchon/ArduinoJson@^7.3.0
 	;ihormelnyk/OpenTherm Library@^1.1.5
-	https://github.com/ihormelnyk/opentherm_library#master
+	https://github.com/Laxilef/opentherm_library#esp32_timer
 	arduino-libraries/ArduinoMqttClient@^0.1.8
 	lennarthennigs/ESP Telnet@^2.2
 	gyverlibs/FileData@^1.0.2
@@ -84,7 +84,7 @@ board_build.ldscript = eagle.flash.4m1m.ld
 ;platform_packages = 
 ;  framework-arduinoespressif32 @ https://github.com/espressif/arduino-esp32.git#3.0.5
 ;  framework-arduinoespressif32-libs @ https://github.com/espressif/esp32-arduino-lib-builder/releases/download/idf-release_v5.1/esp32-arduino-libs-idf-release_v5.1-33fbade6.zip
-platform = https://github.com/pioarduino/platform-espressif32/releases/download/53.03.13/platform-espressif32.zip
+platform = https://github.com/pioarduino/platform-espressif32/releases/download/54.03.20/platform-espressif32.zip
 platform_packages =
 board_build.partitions = esp32_partitions.csv
 lib_deps =
@@ -291,6 +291,11 @@ framework = arduino, espidf
 platform_packages = ${esp32_defaults.platform_packages}
 board = esp32-c6-devkitm-1
 board_build.partitions = ${esp32_defaults.board_build.partitions}
+board_build.embed_txtfiles = 
+	managed_components/espressif__esp_insights/server_certs/https_server.crt
+	managed_components/espressif__esp_rainmaker/server_certs/rmaker_mqtt_server.crt
+	managed_components/espressif__esp_rainmaker/server_certs/rmaker_claim_service_server.crt
+	managed_components/espressif__esp_rainmaker/server_certs/rmaker_ota_server.crt
 lib_deps = ${esp32_defaults.lib_deps}
 lib_ignore = 
 	${esp32_defaults.lib_ignore}

src/HaHelper.h

@@ -395,7 +395,7 @@ public:
     doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->statusTopic.c_str();
     doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
     doc[FPSTR(HA_ENTITY_CATEGORY)] = FPSTR(HA_ENTITY_CATEGORY_DIAGNOSTIC);
-    doc[FPSTR(HA_DEVICE_CLASS)] = F("signal_strength");
+    //doc[FPSTR(HA_DEVICE_CLASS)] = F("signal_strength");
     doc[FPSTR(HA_STATE_CLASS)] = FPSTR(HA_STATE_CLASS_MEASUREMENT);
     doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = FPSTR(HA_UNIT_OF_MEASUREMENT_PERCENT);
     doc[FPSTR(HA_ICON)] = F("mdi:signal");

src/MainTask.h

@@ -29,6 +29,7 @@ protected:
   enum class PumpStartReason {NONE, HEATING, ANTISTUCK};
 
   Blinker* blinker = nullptr;
+  unsigned long miscRunned = 0;
   unsigned long lastHeapInfo = 0;
   unsigned int minFreeHeap = 0;
   unsigned int minMaxFreeBlockHeap = 0;
@@ -42,6 +43,8 @@ protected:
   bool telnetStarted = false;
   bool emergencyDetected = false;
   unsigned long emergencyFlipTime = 0;
+  bool freezeDetected = false;
+  unsigned long freezeDetectedTime = 0;
 
   #if defined(ARDUINO_ARCH_ESP32)
   const char* getTaskName() override {
@@ -150,17 +153,16 @@ protected:
 
       Sensors::setConnectionStatusByType(Sensors::Type::MANUAL, false, false);
     }
-    this->yield();
 
-    this->emergency();
+    this->yield();
+    if (this->misc()) {
+      this->yield();
+    }
     this->ledStatus();
-    this->cascadeControl();
-    this->externalPump();
-    this->yield();
-
 
     // telnet
     if (this->telnetStarted) {
+      this->yield();
       telnetStream->loop();
       this->yield();
     }
@@ -179,14 +181,27 @@ protected:
 
     // heap info
     this->heap();
+  }
 
+  bool misc() {
+    if (millis() - this->miscRunned < 1000) {
+      return false;
+    }
 
-    // restart
+    // restart if required
     if (this->restartSignalReceived && millis() - this->restartSignalReceivedTime > 15000) {
       this->restartSignalReceived = false;
 
       ESP.restart();
     }
+
+    this->heating();
+    this->emergency();
+    this->cascadeControl();
+    this->externalPump();
+    this->miscRunned = millis();
+    
+    return true;
   }
 
   void heap() {
@@ -196,6 +211,7 @@ protected:
     // critical heap
     if (!vars.states.restarting && (freeHeap < 2048 || maxFreeBlockHeap < 2048)) {
       this->restartSignalReceivedTime = millis();
+      this->restartSignalReceived = true;
       vars.states.restarting = true;
     }
 
@@ -227,6 +243,65 @@ protected:
     }
   }
 
+  void heating() {
+    // freeze protection
+    if (!settings.heating.enabled) {
+      float lowTemp = 255.0f;
+      uint8_t availableSensors = 0;
+
+      if (Sensors::existsConnectedSensorsByPurpose(Sensors::Purpose::INDOOR_TEMP)) {
+        auto value = Sensors::getMeanValueByPurpose(Sensors::Purpose::INDOOR_TEMP, Sensors::ValueType::PRIMARY);
+        if (value < lowTemp) {
+          lowTemp = value;
+        }
+        
+        availableSensors++;
+      }
+
+      if (Sensors::existsConnectedSensorsByPurpose(Sensors::Purpose::HEATING_TEMP)) {
+        auto value = Sensors::getMeanValueByPurpose(Sensors::Purpose::HEATING_TEMP, Sensors::ValueType::PRIMARY);
+        if (value < lowTemp) {
+          lowTemp = value;
+        }
+        
+        availableSensors++;
+      }
+
+      if (Sensors::existsConnectedSensorsByPurpose(Sensors::Purpose::HEATING_RETURN_TEMP)) {
+        auto value = Sensors::getMeanValueByPurpose(Sensors::Purpose::HEATING_RETURN_TEMP, Sensors::ValueType::PRIMARY);
+        if (value < lowTemp) {
+          lowTemp = value;
+        }
+
+        availableSensors++;
+      }
+
+      if (availableSensors && lowTemp <= settings.heating.freezeProtection.lowTemp) {
+        if (!this->freezeDetected) {
+          this->freezeDetected = true;
+          this->freezeDetectedTime = millis();
+
+        } else if (millis() - this->freezeDetectedTime > (settings.heating.freezeProtection.thresholdTime * 1000)) {
+          this->freezeDetected = false;
+          settings.heating.enabled = true;
+          fsSettings.update();
+
+          Log.sinfoln(
+            FPSTR(L_MAIN),
+            F("Heating turned on by freeze protection, current low temp: %.2f, threshold: %hhu"),
+            lowTemp, settings.heating.freezeProtection.lowTemp
+          );
+        }
+
+      } else if (this->freezeDetected) {
+        this->freezeDetected = false;
+      }
+
+    } else if (this->freezeDetected) {
+      this->freezeDetected = false;
+    }
+  }
+
   void emergency() {
     // flags
     uint8_t emergencyFlags = 0b00000000;

src/OpenThermTask.h

@@ -93,8 +93,13 @@ protected:
     this->instance->setAfterSendRequestCallback([this](unsigned long request, unsigned long response, OpenThermResponseStatus status, byte attempt) {
       Log.sverboseln(
         FPSTR(L_OT),
-        F("ID: %4d   Request: %8lx   Response: %8lx   Attempt: %2d   Status: %s"),
+        F("ID: %4d   Request: %8lx   Response: %8lx   Msg type: %s   Attempt: %2d   Status: %s"),
-        CustomOpenTherm::getDataID(request), request, response, attempt, CustomOpenTherm::statusToString(status)
+        CustomOpenTherm::getDataID(request),
+        request,
+        response,
+        CustomOpenTherm::getResponseMessageTypeString(response),
+        attempt,
+        CustomOpenTherm::statusToString(status)
       );
 
       if (status == OpenThermResponseStatus::SUCCESS) {
@@ -138,7 +143,12 @@ protected:
       return;
 
     } else if (this->instance->status == OpenThermStatus::NOT_INITIALIZED) {
-      this->instance->begin();
+      if (!this->instance->begin()) {
+        Log.swarningln(FPSTR(L_OT), F("Failed begin"));
+
+        this->delay(5000);
+        return;
+      }
     }
 
     // RX LED GPIO setup
@@ -159,12 +169,15 @@ protected:
 
     // Heating settings
     vars.master.heating.enabled = this->isReady()
-      && (settings.heating.enabled || vars.emergency.state) 
+      && settings.heating.enabled
       && vars.cascadeControl.input 
-      && !vars.master.heating.blocking;
+      && !vars.master.heating.blocking
+      && !vars.master.heating.overheat;
 
     // DHW settings
-    vars.master.dhw.enabled = settings.opentherm.options.dhwSupport && settings.dhw.enabled;
+    vars.master.dhw.enabled = settings.opentherm.options.dhwSupport 
+      && settings.dhw.enabled 
+      && !vars.master.dhw.overheat;
     vars.master.dhw.targetTemp = settings.dhw.target;
 
     // CH2 settings
@@ -195,6 +208,12 @@ protected:
       summerWinterMode = vars.master.heating.enabled == summerWinterMode;
     }
 
+    // DHW blocking
+    bool dhwBlocking = settings.opentherm.options.dhwBlocking;
+    if (settings.opentherm.options.dhwStateAsDhwBlocking) {
+      dhwBlocking = vars.master.dhw.enabled == dhwBlocking;
+    }
+
     unsigned long response = this->instance->setBoilerStatus(
       vars.master.heating.enabled,
       vars.master.dhw.enabled,
@@ -202,7 +221,7 @@ protected:
       settings.opentherm.options.nativeHeatingControl,
       vars.master.ch2.enabled,
       summerWinterMode,
-      settings.opentherm.options.dhwBlocking,
+      dhwBlocking,
       statusLb
     );
 
@@ -212,6 +231,27 @@ protected:
         F("Failed receive boiler status: %s"),
         CustomOpenTherm::statusToString(this->instance->getLastResponseStatus())
       );
+      
+    } else {
+      vars.slave.heating.active = CustomOpenTherm::isCentralHeatingActive(response);
+      vars.slave.dhw.active = settings.opentherm.options.dhwSupport ? CustomOpenTherm::isHotWaterActive(response) : false;
+      vars.slave.flame = CustomOpenTherm::isFlameOn(response);
+      vars.slave.cooling = CustomOpenTherm::isCoolingActive(response);
+      vars.slave.ch2.active = CustomOpenTherm::isCh2Active(response);
+      vars.slave.fault.active = CustomOpenTherm::isFault(response);
+
+      if (!settings.opentherm.options.ignoreDiagState) {
+        vars.slave.diag.active = CustomOpenTherm::isDiagnostic(response);
+
+      } else if (vars.slave.diag.active) {
+        vars.slave.diag.active = false;
+      }
+  
+      Log.snoticeln(
+        FPSTR(L_OT), F("Received boiler status. Heating: %hhu; DHW: %hhu; flame: %hhu; cooling: %hhu; channel 2: %hhu; fault: %hhu; diag: %hhu"),
+        vars.slave.heating.active, vars.slave.dhw.active,
+        vars.slave.flame, vars.slave.cooling, vars.slave.ch2.active, vars.slave.fault.active, vars.slave.diag.active
+      );
     }
 
     // 5 request retries
@@ -257,6 +297,15 @@ protected:
       Sensors::setConnectionStatusByType(Sensors::Type::OT_FAN_SPEED_SETPOINT, false);
       Sensors::setConnectionStatusByType(Sensors::Type::OT_FAN_SPEED_CURRENT, false);
 
+      Sensors::setConnectionStatusByType(Sensors::Type::OT_BURNER_STARTS, false);
+      Sensors::setConnectionStatusByType(Sensors::Type::OT_DHW_BURNER_STARTS, false);
+      Sensors::setConnectionStatusByType(Sensors::Type::OT_HEATING_PUMP_STARTS, false);
+      Sensors::setConnectionStatusByType(Sensors::Type::OT_DHW_PUMP_STARTS, false);
+      Sensors::setConnectionStatusByType(Sensors::Type::OT_BURNER_HOURS, false);
+      Sensors::setConnectionStatusByType(Sensors::Type::OT_DHW_BURNER_HOURS, false);
+      Sensors::setConnectionStatusByType(Sensors::Type::OT_HEATING_PUMP_HOURS, false);
+      Sensors::setConnectionStatusByType(Sensors::Type::OT_DHW_PUMP_HOURS, false);
+
       this->initialized = false;
       this->disconnectedTime = millis();
       vars.slave.connected = false;
@@ -310,34 +359,60 @@ protected:
       Log.sinfoln(FPSTR(L_OT_DHW), vars.master.dhw.enabled ? F("Enabled") : F("Disabled"));
     }
 
-    vars.slave.heating.active = CustomOpenTherm::isCentralHeatingActive(response);
-    vars.slave.dhw.active = settings.opentherm.options.dhwSupport ? CustomOpenTherm::isHotWaterActive(response) : false;
-    vars.slave.flame = CustomOpenTherm::isFlameOn(response);
-    vars.slave.cooling = CustomOpenTherm::isCoolingActive(response);
-    vars.slave.fault.active = CustomOpenTherm::isFault(response);
-    vars.slave.diag.active = CustomOpenTherm::isDiagnostic(response);
-
-    Log.snoticeln(
-      FPSTR(L_OT), F("Received boiler status. Heating: %hhu; DHW: %hhu; flame: %hhu; cooling: %hhu; fault: %hhu; diag: %hhu"),
-      vars.slave.heating.active, vars.slave.dhw.active,
-      vars.slave.flame, vars.slave.cooling, vars.slave.fault.active, vars.slave.diag.active
-    );
-
     // These parameters will be updated every minute
     if (millis() - this->prevUpdateNonEssentialVars > 60000) {
+      // Set date & time
+      if (settings.opentherm.options.setDateAndTime) {
+        struct tm ti;
+
+        if (getLocalTime(&ti)) {
+          if (this->setYear(&ti)) {
+            Log.sinfoln(FPSTR(L_OT), F("Year of date set successfully"));
+
+          } else {
+            Log.sinfoln(FPSTR(L_OT), F("Failed set year of date"));
+          }
+
+          if (this->setDayAndMonth(&ti)) {
+            Log.sinfoln(FPSTR(L_OT), F("Day and month of date set successfully"));
+
+          } else {
+            Log.sinfoln(FPSTR(L_OT), F("Failed set day and month of date"));
+          }
+
+          if (this->setTime(&ti)) {
+            Log.sinfoln(FPSTR(L_OT), F("Time set successfully"));
+
+          } else {
+            Log.sinfoln(FPSTR(L_OT), F("Failed set time"));
+          }
+        }
+      }
+
+      // Get min modulation level & max power
       if (this->updateMinModulationLevel()) {
         Log.snoticeln(
           FPSTR(L_OT), F("Received min modulation: %hhu%%, max power: %.2f kW"),
           vars.slave.modulation.min, vars.slave.power.max
         );
         
-        if (settings.opentherm.maxModulation < vars.slave.modulation.min) {
+        if (settings.heating.maxModulation < vars.slave.modulation.min) {
-          settings.opentherm.maxModulation = vars.slave.modulation.min;
+          settings.heating.maxModulation = vars.slave.modulation.min;
           fsSettings.update();
 
           Log.swarningln(
-            FPSTR(L_SETTINGS_OT), F("Updated min modulation: %hhu%%"),
+            FPSTR(L_SETTINGS_HEATING), F("Updated min modulation: %hhu%%"),
-            settings.opentherm.maxModulation
+            settings.heating.maxModulation
+          );
+        }
+
+        if (settings.dhw.maxModulation < vars.slave.modulation.min) {
+          settings.dhw.maxModulation = vars.slave.modulation.min;
+          fsSettings.update();
+
+          Log.swarningln(
+            FPSTR(L_SETTINGS_DHW), F("Updated min modulation: %hhu%%"),
+            settings.dhw.maxModulation
           );
         }
 
@@ -356,29 +431,6 @@ protected:
         Log.swarningln(FPSTR(L_OT), F("Failed receive min modulation and max power"));
       }
 
-      if (!vars.master.heating.enabled && settings.opentherm.options.modulationSyncWithHeating) {
-        if (this->setMaxModulationLevel(0)) {
-          Log.snoticeln(FPSTR(L_OT), F("Set max modulation: 0% (response: %hhu%%)"), vars.slave.modulation.max);
-
-        } else {
-          Log.swarningln(FPSTR(L_OT), F("Failed set max modulation: 0% (response: %hhu%%)"), vars.slave.modulation.max);
-        }
-
-      } else {
-        if (this->setMaxModulationLevel(settings.opentherm.maxModulation)) {
-          Log.snoticeln(
-            FPSTR(L_OT), F("Set max modulation: %hhu%% (response: %hhu%%)"),
-            settings.opentherm.maxModulation, vars.slave.modulation.max
-          );
-
-        } else {
-          Log.swarningln(
-            FPSTR(L_OT), F("Failed set max modulation: %hhu%% (response: %hhu%%)"),
-            settings.opentherm.maxModulation, vars.slave.modulation.max
-          );
-        }
-      }
-
 
       // Get DHW min/max temp (if necessary)
       if (settings.opentherm.options.dhwSupport && settings.opentherm.options.getMinMaxTemp) {
@@ -503,9 +555,160 @@ protected:
         vars.slave.diag.code = 0;
       }
 
+      // Update burner starts
+      if (Sensors::getAmountByType(Sensors::Type::OT_BURNER_STARTS, true)) {
+        if (this->updateBurnerStarts()) {
+          Log.snoticeln(FPSTR(L_OT), F("Received burner starts: %hu"), vars.slave.stats.burnerStarts);
+
+          Sensors::setValueByType(
+            Sensors::Type::OT_BURNER_STARTS, vars.slave.stats.burnerStarts,
+            Sensors::ValueType::PRIMARY, true, true
+          );
+
+        } else {
+          Log.swarningln(FPSTR(L_OT), F("Failed receive burner starts"));
+        }
+      }
+
+      // Update DHW burner starts
+      if (Sensors::getAmountByType(Sensors::Type::OT_DHW_BURNER_STARTS, true)) {
+        if (this->updateDhwBurnerStarts()) {
+          Log.snoticeln(FPSTR(L_OT), F("Received DHW burner starts: %hu"), vars.slave.stats.dhwBurnerStarts);
+
+          Sensors::setValueByType(
+            Sensors::Type::OT_DHW_BURNER_STARTS, vars.slave.stats.dhwBurnerStarts,
+            Sensors::ValueType::PRIMARY, true, true
+          );
+
+        } else {
+          Log.swarningln(FPSTR(L_OT), F("Failed receive DHW burner starts"));
+        }
+      }
+
+      // Update heating pump starts
+      if (Sensors::getAmountByType(Sensors::Type::OT_HEATING_PUMP_STARTS, true)) {
+        if (this->updateHeatingPumpStarts()) {
+          Log.snoticeln(FPSTR(L_OT), F("Received heating pump starts: %hu"), vars.slave.stats.heatingPumpStarts);
+
+          Sensors::setValueByType(
+            Sensors::Type::OT_HEATING_PUMP_STARTS, vars.slave.stats.heatingPumpStarts,
+            Sensors::ValueType::PRIMARY, true, true
+          );
+
+        } else {
+          Log.swarningln(FPSTR(L_OT), F("Failed receive heating pump starts"));
+        }
+      }
+
+      // Update DHW pump starts
+      if (Sensors::getAmountByType(Sensors::Type::OT_DHW_PUMP_STARTS, true)) {
+        if (this->updateDhwPumpStarts()) {
+          Log.snoticeln(FPSTR(L_OT), F("Received DHW pump starts: %hu"), vars.slave.stats.dhwPumpStarts);
+
+          Sensors::setValueByType(
+            Sensors::Type::OT_DHW_PUMP_STARTS, vars.slave.stats.dhwPumpStarts,
+            Sensors::ValueType::PRIMARY, true, true
+          );
+
+        } else {
+          Log.swarningln(FPSTR(L_OT), F("Failed receive DHW pump starts"));
+        }
+      }
+
+      // Update burner hours
+      if (Sensors::getAmountByType(Sensors::Type::OT_BURNER_HOURS, true)) {
+        if (this->updateBurnerHours()) {
+          Log.snoticeln(FPSTR(L_OT), F("Received burner hours: %hu"), vars.slave.stats.burnerHours);
+
+          Sensors::setValueByType(
+            Sensors::Type::OT_BURNER_HOURS, vars.slave.stats.burnerHours,
+            Sensors::ValueType::PRIMARY, true, true
+          );
+
+        } else {
+          Log.swarningln(FPSTR(L_OT), F("Failed receive burner hours"));
+        }
+      }
+
+      // Update DHW burner hours
+      if (Sensors::getAmountByType(Sensors::Type::OT_DHW_BURNER_HOURS, true)) {
+        if (this->updateDhwBurnerHours()) {
+          Log.snoticeln(FPSTR(L_OT), F("Received DHW burner hours: %hu"), vars.slave.stats.dhwBurnerHours);
+
+          Sensors::setValueByType(
+            Sensors::Type::OT_DHW_BURNER_HOURS, vars.slave.stats.dhwBurnerHours,
+            Sensors::ValueType::PRIMARY, true, true
+          );
+
+        } else {
+          Log.swarningln(FPSTR(L_OT), F("Failed receive DHW burner hours"));
+        }
+      }
+
+      // Update heating pump hours
+      if (Sensors::getAmountByType(Sensors::Type::OT_HEATING_PUMP_HOURS, true)) {
+        if (this->updateHeatingPumpHours()) {
+          Log.snoticeln(FPSTR(L_OT), F("Received heating pump hours: %hu"), vars.slave.stats.heatingPumpHours);
+
+          Sensors::setValueByType(
+            Sensors::Type::OT_HEATING_PUMP_HOURS, vars.slave.stats.heatingPumpHours,
+            Sensors::ValueType::PRIMARY, true, true
+          );
+
+        } else {
+          Log.swarningln(FPSTR(L_OT), F("Failed receive heating pump hours"));
+        }
+      }
+
+      // Update DHW pump hours
+      if (Sensors::getAmountByType(Sensors::Type::OT_DHW_PUMP_HOURS, true)) {
+        if (this->updateDhwPumpHours()) {
+          Log.snoticeln(FPSTR(L_OT), F("Received DHW pump hours: %hu"), vars.slave.stats.dhwPumpHours);
+
+          Sensors::setValueByType(
+            Sensors::Type::OT_DHW_PUMP_HOURS, vars.slave.stats.dhwPumpHours,
+            Sensors::ValueType::PRIMARY, true, true
+          );
+
+        } else {
+          Log.swarningln(FPSTR(L_OT), F("Failed receive DHW pump hours"));
+        }
+      }
+
+      // Auto fault reset
+      if (settings.opentherm.options.autoFaultReset && vars.slave.fault.active && !vars.actions.resetFault) {
+        vars.actions.resetFault = true;
+      }
+
+      // Auto diag reset
+      if (settings.opentherm.options.autoDiagReset && vars.slave.diag.active && !vars.actions.resetDiagnostic) {
+        vars.actions.resetDiagnostic = true;
+      }
+
       this->prevUpdateNonEssentialVars = millis();
     }
 
+    // Set max modulation level
+    uint8_t targetMaxModulation = vars.slave.modulation.max;
+    if (vars.slave.heating.active) {
+      targetMaxModulation = settings.heating.maxModulation;
+
+    } else if (vars.slave.dhw.active) {
+      targetMaxModulation = settings.dhw.maxModulation;
+    }
+
+    if (this->setMaxModulationLevel(targetMaxModulation)) {
+      Log.snoticeln(
+        FPSTR(L_OT), F("Set max modulation: %hhu%% (response: %hhu%%)"),
+        targetMaxModulation, vars.slave.modulation.max
+      );
+
+    } else {
+      Log.swarningln(
+        FPSTR(L_OT), F("Failed set max modulation: %hhu%% (response: %hhu%%)"),
+        targetMaxModulation, vars.slave.modulation.max
+      );
+    }
 
     // Update modulation level
     if (
@@ -1114,6 +1317,84 @@ protected:
         }
       }
     }
+
+
+    // Heating overheat control
+    if (settings.heating.overheatProtection.highTemp > 0 && settings.heating.overheatProtection.lowTemp > 0) {
+      float highTemp = convertTemp(
+        max({
+          vars.slave.heating.currentTemp,
+          vars.slave.heating.returnTemp,
+          vars.slave.heatExchangerTemp
+        }),
+        settings.opentherm.unitSystem,
+        settings.system.unitSystem
+      );
+
+      if (vars.master.heating.overheat) {
+        if ((float) settings.heating.overheatProtection.lowTemp - highTemp + 0.0001f >= 0.0f) {
+          vars.master.heating.overheat = false;
+
+          Log.sinfoln(
+            FPSTR(L_OT_HEATING), F("Overheating not detected. Current high temp: %.2f, threshold (low): %hhu"),
+            highTemp, settings.heating.overheatProtection.lowTemp
+          );
+        }
+
+      } else if (vars.slave.heating.active) {
+        if (highTemp - (float) settings.heating.overheatProtection.highTemp + 0.0001f >= 0.0f) {
+          vars.master.heating.overheat = true;
+
+          Log.swarningln(
+            FPSTR(L_OT_HEATING), F("Overheating detected! Current high temp: %.2f, threshold (high): %hhu"),
+            highTemp, settings.heating.overheatProtection.highTemp
+          );
+        }
+      }
+
+    } else if (vars.master.heating.overheat) {
+      vars.master.heating.overheat = false;
+    }
+
+    // DHW overheat control
+    if (settings.dhw.overheatProtection.highTemp > 0 && settings.dhw.overheatProtection.lowTemp > 0) {
+      float highTemp = convertTemp(
+        max({
+          vars.slave.heating.currentTemp,
+          vars.slave.heating.returnTemp,
+          vars.slave.heatExchangerTemp,
+          vars.slave.dhw.currentTemp,
+          vars.slave.dhw.currentTemp2,
+          vars.slave.dhw.returnTemp
+        }),
+        settings.opentherm.unitSystem,
+        settings.system.unitSystem
+      );
+
+      if (vars.master.dhw.overheat) {
+        if ((float) settings.dhw.overheatProtection.lowTemp - highTemp + 0.0001f >= 0.0f) {
+          vars.master.dhw.overheat = false;
+
+          Log.sinfoln(
+            FPSTR(L_OT_DHW), F("Overheating not detected. Current high temp: %.2f, threshold (low): %hhu"),
+            highTemp, settings.dhw.overheatProtection.lowTemp
+          );
+        }
+
+      } else if (vars.slave.dhw.active) {
+        if (highTemp - (float) settings.dhw.overheatProtection.highTemp + 0.0001f >= 0.0f) {
+          vars.master.dhw.overheat = true;
+
+          Log.swarningln(
+            FPSTR(L_OT_DHW), F("Overheating detected! Current high temp: %.2f, threshold (high): %hhu"),
+            highTemp, settings.dhw.overheatProtection.highTemp
+          );
+        }
+      }
+
+    } else if (vars.master.dhw.overheat) {
+      vars.master.dhw.overheat = false;
+    }
   }
 
   void initialize() {
@@ -1179,17 +1460,17 @@ protected:
 
   bool needSetDhwTemp(const float target) {
     return millis() - this->dhwSetTempTime > this->dhwSetTempInterval
-      || fabsf(target - vars.slave.dhw.targetTemp) > 0.001f;
+      || fabsf(target - vars.slave.dhw.targetTemp) > 0.05f;
   }
 
   bool needSetHeatingTemp(const float target) {
     return millis() - this->heatingSetTempTime > this->heatingSetTempInterval
-      || fabsf(target - vars.slave.heating.targetTemp) > 0.001f;
+      || fabsf(target - vars.slave.heating.targetTemp) > 0.05f;
   }
 
   bool needSetCh2Temp(const float target) {
     return millis() - this->ch2SetTempTime > this->ch2SetTempInterval
-      || fabsf(target - vars.slave.ch2.targetTemp) > 0.001f;
+      || fabsf(target - vars.slave.ch2.targetTemp) > 0.05f;
   }
 
   bool updateSlaveConfig() {
@@ -1228,6 +1509,64 @@ protected:
     return true;
   }
 
+  bool setYear(const struct tm *ptm) {
+    const unsigned int request = (ptm->tm_year + 1900) & 0xFFFF;
+    const unsigned long response = this->instance->sendRequest(CustomOpenTherm::buildRequest(
+      OpenThermRequestType::WRITE_DATA,
+      OpenThermMessageID::Year,
+      request
+    ));
+
+    if (!CustomOpenTherm::isValidResponse(response)) {
+      return false;
+
+    } else if (!CustomOpenTherm::isValidResponseId(response, OpenThermMessageID::Year)) {
+      return false;
+    }
+
+    return CustomOpenTherm::getUInt(response) == request;
+  }
+
+  bool setDayAndMonth(const struct tm *ptm) {
+    const uint8_t month = (ptm->tm_mon + 1) & 0xFF;
+    const unsigned int request = (month << 8) | (ptm->tm_mday & 0xFF);
+    const unsigned long response = this->instance->sendRequest(CustomOpenTherm::buildRequest(
+      OpenThermRequestType::WRITE_DATA,
+      OpenThermMessageID::Date,
+      request
+    ));
+
+    if (!CustomOpenTherm::isValidResponse(response)) {
+      return false;
+
+    } else if (!CustomOpenTherm::isValidResponseId(response, OpenThermMessageID::Date)) {
+      return false;
+    }
+
+    return CustomOpenTherm::getUInt(response) == request;
+  }
+
+  bool setTime(const struct tm *ptm) {
+    const uint8_t dayOfWeek = ptm->tm_wday == 0 ? 6 : ptm->tm_wday - 1;
+    const unsigned int request = ((dayOfWeek & 0x07) << 13)
+      | ((ptm->tm_hour & 0x1F) << 8)
+      | (ptm->tm_min & 0x3F);
+    
+    const unsigned long response = this->instance->sendRequest(CustomOpenTherm::buildRequest(
+      OpenThermRequestType::WRITE_DATA,
+      OpenThermMessageID::DayTime,
+      request
+    ));
+
+    if (!CustomOpenTherm::isValidResponse(response)) {
+      return false;
+
+    } else if (!CustomOpenTherm::isValidResponseId(response, OpenThermMessageID::DayTime)) {
+      return false;
+    }
+
+    return CustomOpenTherm::getUInt(response) == request;
+  }
 
   bool setMaxModulationLevel(const uint8_t value) {
     const unsigned int request = CustomOpenTherm::toFloat(value);
@@ -1350,7 +1689,7 @@ protected:
     return CustomOpenTherm::getUInt(response) == request;
   }
 
-  bool setMaxHeatingTemp(const uint8_t temperature) {
+  bool setMaxHeatingTemp(const float temperature) {
     const unsigned int request = CustomOpenTherm::temperatureToData(temperature);
     const unsigned long response = this->instance->sendRequest(CustomOpenTherm::buildRequest(
       OpenThermMessageType::WRITE_DATA,
@@ -1640,6 +1979,158 @@ protected:
     return true;
   }
 
+  bool updateBurnerStarts() {
+    const unsigned long response = this->instance->sendRequest(CustomOpenTherm::buildRequest(
+      OpenThermRequestType::READ_DATA,
+      OpenThermMessageID::SuccessfulBurnerStarts,
+      0
+    ));
+
+    if (!CustomOpenTherm::isValidResponse(response)) {
+      return false;
+
+    } else if (!CustomOpenTherm::isValidResponseId(response, OpenThermMessageID::SuccessfulBurnerStarts)) {
+      return false;
+    }
+
+    vars.slave.stats.burnerStarts = CustomOpenTherm::getUInt(response);
+
+    return true;
+  }
+
+  bool updateDhwBurnerStarts() {
+    const unsigned long response = this->instance->sendRequest(CustomOpenTherm::buildRequest(
+      OpenThermRequestType::READ_DATA,
+      OpenThermMessageID::DHWBurnerStarts,
+      0
+    ));
+
+    if (!CustomOpenTherm::isValidResponse(response)) {
+      return false;
+
+    } else if (!CustomOpenTherm::isValidResponseId(response, OpenThermMessageID::DHWBurnerStarts)) {
+      return false;
+    }
+
+    vars.slave.stats.dhwBurnerStarts = CustomOpenTherm::getUInt(response);
+
+    return true;
+  }
+
+  bool updateHeatingPumpStarts() {
+    const unsigned long response = this->instance->sendRequest(CustomOpenTherm::buildRequest(
+      OpenThermRequestType::READ_DATA,
+      OpenThermMessageID::CHPumpStarts,
+      0
+    ));
+
+    if (!CustomOpenTherm::isValidResponse(response)) {
+      return false;
+
+    } else if (!CustomOpenTherm::isValidResponseId(response, OpenThermMessageID::CHPumpStarts)) {
+      return false;
+    }
+
+    vars.slave.stats.heatingPumpStarts = CustomOpenTherm::getUInt(response);
+
+    return true;
+  }
+
+  bool updateDhwPumpStarts() {
+    const unsigned long response = this->instance->sendRequest(CustomOpenTherm::buildRequest(
+      OpenThermRequestType::READ_DATA,
+      OpenThermMessageID::DHWPumpValveStarts,
+      0
+    ));
+
+    if (!CustomOpenTherm::isValidResponse(response)) {
+      return false;
+
+    } else if (!CustomOpenTherm::isValidResponseId(response, OpenThermMessageID::DHWPumpValveStarts)) {
+      return false;
+    }
+
+    vars.slave.stats.dhwPumpStarts = CustomOpenTherm::getUInt(response);
+
+    return true;
+  }
+
+  bool updateBurnerHours() {
+    const unsigned long response = this->instance->sendRequest(CustomOpenTherm::buildRequest(
+      OpenThermRequestType::READ_DATA,
+      OpenThermMessageID::BurnerOperationHours,
+      0
+    ));
+
+    if (!CustomOpenTherm::isValidResponse(response)) {
+      return false;
+
+    } else if (!CustomOpenTherm::isValidResponseId(response, OpenThermMessageID::BurnerOperationHours)) {
+      return false;
+    }
+
+    vars.slave.stats.burnerHours = CustomOpenTherm::getUInt(response);
+
+    return true;
+  }
+
+  bool updateDhwBurnerHours() {
+    const unsigned long response = this->instance->sendRequest(CustomOpenTherm::buildRequest(
+      OpenThermRequestType::READ_DATA,
+      OpenThermMessageID::DHWBurnerOperationHours,
+      0
+    ));
+
+    if (!CustomOpenTherm::isValidResponse(response)) {
+      return false;
+
+    } else if (!CustomOpenTherm::isValidResponseId(response, OpenThermMessageID::DHWBurnerOperationHours)) {
+      return false;
+    }
+
+    vars.slave.stats.dhwBurnerHours = CustomOpenTherm::getUInt(response);
+
+    return true;
+  }
+
+  bool updateHeatingPumpHours() {
+    const unsigned long response = this->instance->sendRequest(CustomOpenTherm::buildRequest(
+      OpenThermRequestType::READ_DATA,
+      OpenThermMessageID::CHPumpOperationHours,
+      0
+    ));
+
+    if (!CustomOpenTherm::isValidResponse(response)) {
+      return false;
+
+    } else if (!CustomOpenTherm::isValidResponseId(response, OpenThermMessageID::CHPumpOperationHours)) {
+      return false;
+    }
+
+    vars.slave.stats.heatingPumpHours = CustomOpenTherm::getUInt(response);
+
+    return true;
+  }
+
+  bool updateDhwPumpHours() {
+    const unsigned long response = this->instance->sendRequest(CustomOpenTherm::buildRequest(
+      OpenThermRequestType::READ_DATA,
+      OpenThermMessageID::DHWPumpValveOperationHours,
+      0
+    ));
+
+    if (!CustomOpenTherm::isValidResponse(response)) {
+      return false;
+
+    } else if (!CustomOpenTherm::isValidResponseId(response, OpenThermMessageID::DHWPumpValveOperationHours)) {
+      return false;
+    }
+
+    vars.slave.stats.dhwPumpHours = CustomOpenTherm::getUInt(response);
+
+    return true;
+  }
+
   bool updateModulationLevel() {
     const unsigned long response = this->instance->sendRequest(CustomOpenTherm::buildRequest(
       OpenThermRequestType::READ_DATA,

src/RegulatorTask.h

@@ -60,11 +60,11 @@ protected:
     this->hysteresis();
 
     vars.master.heating.targetTemp = settings.heating.target;
-    vars.master.heating.setpointTemp = constrain(
+    vars.master.heating.setpointTemp = roundf(constrain(
       this->getHeatingSetpointTemp(),
       this->getHeatingMinSetpointTemp(),
       this->getHeatingMaxSetpointTemp()
-    );
+    ), 0);
 
     Sensors::setValueByType(
       Sensors::Type::HEATING_SETPOINT_TEMP, vars.master.heating.setpointTemp,

src/Sensors.h

@@ -26,6 +26,15 @@ public:
     OT_FAN_SPEED_SETPOINT   = 17,
     OT_FAN_SPEED_CURRENT    = 18,
 
+    OT_BURNER_STARTS        = 19,
+    OT_DHW_BURNER_STARTS    = 20,
+    OT_HEATING_PUMP_STARTS  = 21,
+    OT_DHW_PUMP_STARTS      = 22,
+    OT_BURNER_HOURS         = 23,
+    OT_DHW_BURNER_HOURS     = 24,
+    OT_HEATING_PUMP_HOURS   = 25,
+    OT_DHW_PUMP_HOURS       = 26,
+    
     NTC_10K_TEMP            = 50,
     DALLAS_TEMP             = 51,
     BLUETOOTH               = 52,
@@ -46,6 +55,7 @@ public:
     EXHAUST_TEMP          = 7,
     MODULATION_LEVEL      = 8,
 
+    NUMBER                = 247,
     POWER_FACTOR          = 248,
     POWER                 = 249,
     FAN_SPEED             = 250,
@@ -128,7 +138,7 @@ public:
     }
 
     uint8_t amount = 0;
-    for (uint8_t id = 0; id < getMaxSensorId(); id++) {
+    for (uint8_t id = 0; id <= getMaxSensorId(); id++) {
       if (settings[id].type == type && (!onlyEnabled || settings[id].enabled)) {
         amount++;
       }
@@ -142,7 +152,7 @@ public:
       return 0;
     }
 
-    for (uint8_t id = 0; id < getMaxSensorId(); id++) {
+    for (uint8_t id = 0; id <= getMaxSensorId(); id++) {
       if (strcmp(settings[id].name, name) == 0) {
         return id;
       }
@@ -157,7 +167,7 @@ public:
     }
 
     String refObjectId;
-    for (uint8_t id = 0; id < getMaxSensorId(); id++) {
+    for (uint8_t id = 0; id <= getMaxSensorId(); id++) {
       Sensors::makeObjectId(refObjectId, settings[id].name);
       if (refObjectId.equals(objectId)) {
         return id;
@@ -237,7 +247,7 @@ public:
     uint8_t updated = 0;
     
     // read sensors data for current instance
-    for (uint8_t sensorId = 0; sensorId < getMaxSensorId(); sensorId++) {
+    for (uint8_t sensorId = 0; sensorId <= getMaxSensorId(); sensorId++) {
       auto& sSensor = settings[sensorId];
       
       // only target & valid sensors
@@ -301,7 +311,7 @@ public:
     uint8_t updated = 0;
     
     // read sensors data for current instance
-    for (uint8_t sensorId = 0; sensorId < getMaxSensorId(); sensorId++) {
+    for (uint8_t sensorId = 0; sensorId <= getMaxSensorId(); sensorId++) {
       auto& sSensor = settings[sensorId];
       
       // only target & valid sensors
@@ -330,7 +340,7 @@ public:
     float value = 0.0f;
     uint8_t amount = 0;
 
-    for (uint8_t id = 0; id < getMaxSensorId(); id++) {
+    for (uint8_t id = 0; id <= getMaxSensorId(); id++) {
       auto& sSensor = settings[id];
       auto& rSensor = results[id];
 
@@ -356,7 +366,7 @@ public:
       return 0;
     }
 
-    for (uint8_t id = 0; id < getMaxSensorId(); id++) {
+    for (uint8_t id = 0; id <= getMaxSensorId(); id++) {
       if (settings[id].purpose == purpose && results[id].connected) {
         return true;
       }

src/Settings.h

@@ -59,7 +59,6 @@ struct Settings {
     byte rxLedGpio = DEFAULT_OT_RX_LED_GPIO;
     uint8_t memberId = 0;
     uint8_t flags = 0;
-    uint8_t maxModulation = 100;
     float minPower = 0.0f;
     float maxPower = 0.0f;
 
@@ -72,9 +71,13 @@ struct Settings {
       bool heatingToCh2 = false;
       bool dhwToCh2 = false;
       bool dhwBlocking = false;
-      bool modulationSyncWithHeating = false;
+      bool dhwStateAsDhwBlocking = false;
       bool maxTempSyncWithTargetTemp = true;
       bool getMinMaxTemp = true;
+      bool ignoreDiagState = false;
+      bool autoFaultReset = false;
+      bool autoDiagReset = false;
+      bool setDateAndTime = false;
       bool nativeHeatingControl = false;
       bool immergasFix = false;
     } options;
@@ -104,6 +107,17 @@ struct Settings {
     float turboFactor = 7.5f;
     byte minTemp = DEFAULT_HEATING_MIN_TEMP;
     byte maxTemp = DEFAULT_HEATING_MAX_TEMP;
+    uint8_t maxModulation = 100;
+
+    struct {
+      uint8_t highTemp = 95;
+      uint8_t lowTemp = 90;
+    } overheatProtection;
+
+    struct {
+      uint8_t lowTemp = 10;
+      unsigned short thresholdTime = 600;
+    } freezeProtection;
   } heating;
 
   struct {
@@ -111,6 +125,12 @@ struct Settings {
     float target = DEFAULT_DHW_TARGET_TEMP;
     byte minTemp = DEFAULT_DHW_MIN_TEMP;
     byte maxTemp = DEFAULT_DHW_MAX_TEMP;
+    uint8_t maxModulation = 100;
+    
+    struct {
+      uint8_t highTemp = 95;
+      uint8_t lowTemp = 90;
+    } overheatProtection;
   } dhw;
 
   struct {
@@ -275,6 +295,7 @@ struct Variables {
       bool blocking = false;
       bool enabled = false;
       bool indoorTempControl = false;
+      bool overheat = false;
       float setpointTemp = 0.0f;
       float targetTemp = 0.0f;
       float currentTemp = 0.0f;
@@ -287,6 +308,7 @@ struct Variables {
 
     struct {
       bool enabled = false;
+      bool overheat = false;
       float targetTemp = 0.0f;
       float currentTemp = 0.0f;
       float returnTemp = 0.0f;
@@ -350,6 +372,17 @@ struct Variables {
       uint16_t supply = 0;
     } fanSpeed;
 
+    struct {
+      uint16_t burnerStarts = 0;
+      uint16_t dhwBurnerStarts = 0;
+      uint16_t heatingPumpStarts = 0;
+      uint16_t dhwPumpStarts = 0;
+      uint16_t burnerHours = 0;
+      uint16_t dhwBurnerHours = 0;
+      uint16_t heatingPumpHours = 0;
+      uint16_t dhwPumpHours = 0;
+    } stats;
+
     struct {
       bool active = false;
       bool enabled = false;
@@ -375,6 +408,7 @@ struct Variables {
     } dhw;
 
     struct {
+      bool active = false;
       bool enabled = false;
       float targetTemp = 0.0f;
       float currentTemp = 0.0f;

src/defines.h

@@ -16,7 +16,7 @@
 
 #define THERMOSTAT_INDOOR_DEFAULT_TEMP  20
 #define THERMOSTAT_INDOOR_MIN_TEMP      5
-#define THERMOSTAT_INDOOR_MAX_TEMP      30
+#define THERMOSTAT_INDOOR_MAX_TEMP      40
 
 #define DEFAULT_NTC_NOMINAL_RESISTANCE  10000.0f
 #define DEFAULT_NTC_NOMINAL_TEMP        25.0f

src/strings.h

@@ -42,6 +42,8 @@ const char S_ANTI_STUCK_TIME[]                      PROGMEM = "antiStuckTime";
 const char S_AP[]                                   PROGMEM = "ap";
 const char S_APP_VERSION[]                          PROGMEM = "appVersion";
 const char S_AUTH[]                                 PROGMEM = "auth";
+const char S_AUTO_DIAG_RESET[]                      PROGMEM = "autoDiagReset";
+const char S_AUTO_FAULT_RESET[]                     PROGMEM = "autoFaultReset";
 const char S_BACKTRACE[]                            PROGMEM = "backtrace";
 const char S_BATTERY[]                              PROGMEM = "battery";
 const char S_BAUDRATE[]                             PROGMEM = "baudrate";
@@ -66,6 +68,7 @@ const char S_DATE[]                                 PROGMEM = "date";
 const char S_DEADBAND[]                             PROGMEM = "deadband";
 const char S_DHW[]                                  PROGMEM = "dhw";
 const char S_DHW_BLOCKING[]                         PROGMEM = "dhwBlocking";
+const char S_DHW_STATE_AS_DHW_BLOCKING[]            PROGMEM = "dhwStateAsDhwBlocking";
 const char S_DHW_SUPPORT[]                          PROGMEM = "dhwSupport";
 const char S_DHW_TO_CH2[]                           PROGMEM = "dhwToCh2";
 const char S_DIAG[]                                 PROGMEM = "diag";
@@ -81,6 +84,7 @@ const char S_EQUITHERM[]                            PROGMEM = "equitherm";
 const char S_EXTERNAL_PUMP[]                        PROGMEM = "externalPump";
 const char S_FACTOR[]                               PROGMEM = "factor";
 const char S_FAULT[]                                PROGMEM = "fault";
+const char S_FREEZE_PROTECTION[]                    PROGMEM = "freezeProtection";
 const char S_FILTERING[]                            PROGMEM = "filtering";
 const char S_FILTERING_FACTOR[]                     PROGMEM = "filteringFactor";
 const char S_FLAGS[]                                PROGMEM = "flags";
@@ -96,11 +100,13 @@ const char S_HEATING[]                              PROGMEM = "heating";
 const char S_HEATING_TO_CH2[]                       PROGMEM = "heatingToCh2";
 const char S_HEATING_STATE_TO_SUMMER_WINTER_MODE[]  PROGMEM = "heatingStateToSummerWinterMode";
 const char S_HIDDEN[]                               PROGMEM = "hidden";
+const char S_HIGH_TEMP[]                            PROGMEM = "highTemp";
 const char S_HOME_ASSISTANT_DISCOVERY[]             PROGMEM = "homeAssistantDiscovery";
 const char S_HOSTNAME[]                             PROGMEM = "hostname";
 const char S_HUMIDITY[]                             PROGMEM = "humidity";
 const char S_HYSTERESIS[]                           PROGMEM = "hysteresis";
 const char S_ID[]                                   PROGMEM = "id";
+const char S_IGNORE_DIAG_STATE[]                    PROGMEM = "ignoreDiagState";
 const char S_IMMERGAS_FIX[]                         PROGMEM = "immergasFix";
 const char S_INDOOR_TEMP[]                          PROGMEM = "indoorTemp";
 const char S_INDOOR_TEMP_CONTROL[]                  PROGMEM = "indoorTempControl";
@@ -114,6 +120,7 @@ const char S_I_MULTIPLIER[]                         PROGMEM = "i_multiplier";
 const char S_K_FACTOR[]                             PROGMEM = "k_factor";
 const char S_LOGIN[]                                PROGMEM = "login";
 const char S_LOG_LEVEL[]                            PROGMEM = "logLevel";
+const char S_LOW_TEMP[]                             PROGMEM = "lowTemp";
 const char S_MAC[]                                  PROGMEM = "mac";
 const char S_MASTER[]                               PROGMEM = "master";
 const char S_MAX[]                                  PROGMEM = "max";
@@ -131,7 +138,6 @@ const char S_MIN_POWER[]                            PROGMEM = "minPower";
 const char S_MIN_TEMP[]                             PROGMEM = "minTemp";
 const char S_MODEL[]                                PROGMEM = "model";
 const char S_MODULATION[]                           PROGMEM = "modulation";
-const char S_MODULATION_SYNC_WITH_HEATING[]         PROGMEM = "modulationSyncWithHeating";
 const char S_MQTT[]                                 PROGMEM = "mqtt";
 const char S_NAME[]                                 PROGMEM = "name";
 const char S_NATIVE_HEATING_CONTROL[]               PROGMEM = "nativeHeatingControl";
@@ -147,6 +153,8 @@ const char S_OPTIONS[]                              PROGMEM = "options";
 const char S_OUTDOOR_TEMP[]                         PROGMEM = "outdoorTemp";
 const char S_OUT_GPIO[]                             PROGMEM = "outGpio";
 const char S_OUTPUT[]                               PROGMEM = "output";
+const char S_OVERHEAT[]                             PROGMEM = "overheat";
+const char S_OVERHEAT_PROTECTION[]                  PROGMEM = "overheatProtection";
 const char S_PASSWORD[]                             PROGMEM = "password";
 const char S_PID[]                                  PROGMEM = "pid";
 const char S_PORT[]                                 PROGMEM = "port";
@@ -173,6 +181,7 @@ const char S_SENSORS[]                              PROGMEM = "sensors";
 const char S_SERIAL[]                               PROGMEM = "serial";
 const char S_SERVER[]                               PROGMEM = "server";
 const char S_SETTINGS[]                             PROGMEM = "settings";
+const char S_SET_DATE_AND_TIME[]                    PROGMEM = "setDateAndTime";
 const char S_SIGNAL_QUALITY[]                       PROGMEM = "signalQuality";
 const char S_SIZE[]                                 PROGMEM = "size";
 const char S_SLAVE[]                                PROGMEM = "slave";

src/utils.h

@@ -449,7 +449,6 @@ void settingsToJson(const Settings& src, JsonVariant dst, bool safe = false) {
     opentherm[FPSTR(S_RX_LED_GPIO)] = src.opentherm.rxLedGpio;
     opentherm[FPSTR(S_MEMBER_ID)] = src.opentherm.memberId;
     opentherm[FPSTR(S_FLAGS)] = src.opentherm.flags;
-    opentherm[FPSTR(S_MAX_MODULATION)] = src.opentherm.maxModulation;
     opentherm[FPSTR(S_MIN_POWER)] = roundf(src.opentherm.minPower, 2);
     opentherm[FPSTR(S_MAX_POWER)] = roundf(src.opentherm.maxPower, 2);
 
@@ -462,9 +461,13 @@ void settingsToJson(const Settings& src, JsonVariant dst, bool safe = false) {
     otOptions[FPSTR(S_HEATING_TO_CH2)] = src.opentherm.options.heatingToCh2;
     otOptions[FPSTR(S_DHW_TO_CH2)] = src.opentherm.options.dhwToCh2;
     otOptions[FPSTR(S_DHW_BLOCKING)] = src.opentherm.options.dhwBlocking;
-    otOptions[FPSTR(S_MODULATION_SYNC_WITH_HEATING)] = src.opentherm.options.modulationSyncWithHeating;
+    otOptions[FPSTR(S_DHW_STATE_AS_DHW_BLOCKING)] = src.opentherm.options.dhwStateAsDhwBlocking;
     otOptions[FPSTR(S_MAX_TEMP_SYNC_WITH_TARGET_TEMP)] = src.opentherm.options.maxTempSyncWithTargetTemp;
     otOptions[FPSTR(S_GET_MIN_MAX_TEMP)] = src.opentherm.options.getMinMaxTemp;
+    otOptions[FPSTR(S_IGNORE_DIAG_STATE)] = src.opentherm.options.ignoreDiagState;
+    otOptions[FPSTR(S_AUTO_FAULT_RESET)] = src.opentherm.options.autoFaultReset;
+    otOptions[FPSTR(S_AUTO_DIAG_RESET)] = src.opentherm.options.autoDiagReset;
+    otOptions[FPSTR(S_SET_DATE_AND_TIME)] = src.opentherm.options.setDateAndTime;
     otOptions[FPSTR(S_NATIVE_HEATING_CONTROL)] = src.opentherm.options.nativeHeatingControl;
     otOptions[FPSTR(S_IMMERGAS_FIX)] = src.opentherm.options.immergasFix;
 
@@ -491,12 +494,26 @@ void settingsToJson(const Settings& src, JsonVariant dst, bool safe = false) {
   heating[FPSTR(S_TURBO_FACTOR)] = roundf(src.heating.turboFactor, 3);
   heating[FPSTR(S_MIN_TEMP)] = src.heating.minTemp;
   heating[FPSTR(S_MAX_TEMP)] = src.heating.maxTemp;
+  heating[FPSTR(S_MAX_MODULATION)] = src.heating.maxModulation;
+
+  auto heatingOverheatProtection = heating[FPSTR(S_OVERHEAT_PROTECTION)].to<JsonObject>();
+  heatingOverheatProtection[FPSTR(S_HIGH_TEMP)] = src.heating.overheatProtection.highTemp;
+  heatingOverheatProtection[FPSTR(S_LOW_TEMP)] = src.heating.overheatProtection.lowTemp;
+
+  auto freezeProtection = heating[FPSTR(S_FREEZE_PROTECTION)].to<JsonObject>();
+  freezeProtection[FPSTR(S_LOW_TEMP)] = src.heating.freezeProtection.lowTemp;
+  freezeProtection[FPSTR(S_THRESHOLD_TIME)] = src.heating.freezeProtection.thresholdTime;
 
   auto dhw = dst[FPSTR(S_DHW)].to<JsonObject>();
   dhw[FPSTR(S_ENABLED)] = src.dhw.enabled;
   dhw[FPSTR(S_TARGET)] = roundf(src.dhw.target, 1);
   dhw[FPSTR(S_MIN_TEMP)] = src.dhw.minTemp;
   dhw[FPSTR(S_MAX_TEMP)] = src.dhw.maxTemp;
+  dhw[FPSTR(S_MAX_MODULATION)] = src.dhw.maxModulation;
+
+  auto dhwOverheatProtection = dhw[FPSTR(S_OVERHEAT_PROTECTION)].to<JsonObject>();
+  dhwOverheatProtection[FPSTR(S_HIGH_TEMP)] = src.dhw.overheatProtection.highTemp;
+  dhwOverheatProtection[FPSTR(S_LOW_TEMP)] = src.dhw.overheatProtection.lowTemp;
 
   auto equitherm = dst[FPSTR(S_EQUITHERM)].to<JsonObject>();
   equitherm[FPSTR(S_ENABLED)] = src.equitherm.enabled;
@@ -811,15 +828,6 @@ bool jsonToSettings(const JsonVariantConst src, Settings& dst, bool safe = false
       }
     }
 
-    if (!src[FPSTR(S_OPENTHERM)][FPSTR(S_MAX_MODULATION)].isNull()) {
-      unsigned char value = src[FPSTR(S_OPENTHERM)][FPSTR(S_MAX_MODULATION)].as<unsigned char>();
-
-      if (value > 0 && value <= 100 && value != dst.opentherm.maxModulation) {
-        dst.opentherm.maxModulation = value;
-        changed = true;
-      }
-    }
-
     if (!src[FPSTR(S_OPENTHERM)][FPSTR(S_MIN_POWER)].isNull()) {
       float value = src[FPSTR(S_OPENTHERM)][FPSTR(S_MIN_POWER)].as<float>();
 
@@ -928,11 +936,11 @@ bool jsonToSettings(const JsonVariantConst src, Settings& dst, bool safe = false
       }
     }
 
-    if (src[FPSTR(S_OPENTHERM)][FPSTR(S_OPTIONS)][FPSTR(S_MODULATION_SYNC_WITH_HEATING)].is<bool>()) {
+    if (src[FPSTR(S_OPENTHERM)][FPSTR(S_OPTIONS)][FPSTR(S_DHW_STATE_AS_DHW_BLOCKING)].is<bool>()) {
-      bool value = src[FPSTR(S_OPENTHERM)][FPSTR(S_OPTIONS)][FPSTR(S_MODULATION_SYNC_WITH_HEATING)].as<bool>();
+      bool value = src[FPSTR(S_OPENTHERM)][FPSTR(S_OPTIONS)][FPSTR(S_DHW_STATE_AS_DHW_BLOCKING)].as<bool>();
 
-      if (value != dst.opentherm.options.modulationSyncWithHeating) {
+      if (value != dst.opentherm.options.dhwStateAsDhwBlocking) {
-        dst.opentherm.options.modulationSyncWithHeating = value;
+        dst.opentherm.options.dhwStateAsDhwBlocking = value;
         changed = true;
       }
     }
@@ -955,6 +963,42 @@ bool jsonToSettings(const JsonVariantConst src, Settings& dst, bool safe = false
       }
     }
 
+    if (src[FPSTR(S_OPENTHERM)][FPSTR(S_OPTIONS)][FPSTR(S_IGNORE_DIAG_STATE)].is<bool>()) {
+      bool value = src[FPSTR(S_OPENTHERM)][FPSTR(S_OPTIONS)][FPSTR(S_IGNORE_DIAG_STATE)].as<bool>();
+
+      if (value != dst.opentherm.options.ignoreDiagState) {
+        dst.opentherm.options.ignoreDiagState = value;
+        changed = true;
+      }
+    }
+
+    if (src[FPSTR(S_OPENTHERM)][FPSTR(S_OPTIONS)][FPSTR(S_AUTO_FAULT_RESET)].is<bool>()) {
+      bool value = src[FPSTR(S_OPENTHERM)][FPSTR(S_OPTIONS)][FPSTR(S_AUTO_FAULT_RESET)].as<bool>();
+
+      if (value != dst.opentherm.options.autoFaultReset) {
+        dst.opentherm.options.autoFaultReset = value;
+        changed = true;
+      }
+    }
+
+    if (src[FPSTR(S_OPENTHERM)][FPSTR(S_OPTIONS)][FPSTR(S_AUTO_DIAG_RESET)].is<bool>()) {
+      bool value = src[FPSTR(S_OPENTHERM)][FPSTR(S_OPTIONS)][FPSTR(S_AUTO_DIAG_RESET)].as<bool>();
+
+      if (value != dst.opentherm.options.autoDiagReset) {
+        dst.opentherm.options.autoDiagReset = value;
+        changed = true;
+      }
+    }
+
+    if (src[FPSTR(S_OPENTHERM)][FPSTR(S_OPTIONS)][FPSTR(S_SET_DATE_AND_TIME)].is<bool>()) {
+      bool value = src[FPSTR(S_OPENTHERM)][FPSTR(S_OPTIONS)][FPSTR(S_SET_DATE_AND_TIME)].as<bool>();
+
+      if (value != dst.opentherm.options.setDateAndTime) {
+        dst.opentherm.options.setDateAndTime = value;
+        changed = true;
+      }
+    }
+
     if (src[FPSTR(S_OPENTHERM)][FPSTR(S_OPTIONS)][FPSTR(S_NATIVE_HEATING_CONTROL)].is<bool>()) {
       bool value = src[FPSTR(S_OPENTHERM)][FPSTR(S_OPTIONS)][FPSTR(S_NATIVE_HEATING_CONTROL)].as<bool>();
 
@@ -1301,6 +1345,59 @@ bool jsonToSettings(const JsonVariantConst src, Settings& dst, bool safe = false
   }
 
 
+  if (!src[FPSTR(S_HEATING)][FPSTR(S_MAX_MODULATION)].isNull()) {
+    unsigned char value = src[FPSTR(S_HEATING)][FPSTR(S_MAX_MODULATION)].as<unsigned char>();
+
+    if (value > 0 && value <= 100 && value != dst.heating.maxModulation) {
+      dst.heating.maxModulation = value;
+      changed = true;
+    }
+  }
+
+  if (!src[FPSTR(S_HEATING)][FPSTR(S_OVERHEAT_PROTECTION)][FPSTR(S_HIGH_TEMP)].isNull()) {
+    unsigned char value = src[FPSTR(S_HEATING)][FPSTR(S_OVERHEAT_PROTECTION)][FPSTR(S_HIGH_TEMP)].as<unsigned char>();
+
+    if (isValidTemp(value, dst.system.unitSystem, 0.0f, 100.0f) && value != dst.heating.overheatProtection.highTemp) {
+      dst.heating.overheatProtection.highTemp = value;
+      changed = true;
+    }
+  }
+
+  if (!src[FPSTR(S_HEATING)][FPSTR(S_OVERHEAT_PROTECTION)][FPSTR(S_LOW_TEMP)].isNull()) {
+    unsigned char value = src[FPSTR(S_HEATING)][FPSTR(S_OVERHEAT_PROTECTION)][FPSTR(S_LOW_TEMP)].as<unsigned char>();
+
+    if (isValidTemp(value, dst.system.unitSystem, 0.0f, 99.0f) && value != dst.heating.overheatProtection.lowTemp) {
+      dst.heating.overheatProtection.lowTemp = value;
+      changed = true;
+    }
+  }
+
+  if (dst.heating.overheatProtection.highTemp < dst.heating.overheatProtection.lowTemp) {
+    dst.heating.overheatProtection.highTemp = dst.heating.overheatProtection.lowTemp;
+    changed = true;
+  }
+
+  if (!src[FPSTR(S_HEATING)][FPSTR(S_FREEZE_PROTECTION)][FPSTR(S_LOW_TEMP)].isNull()) {
+    unsigned short value = src[FPSTR(S_HEATING)][FPSTR(S_FREEZE_PROTECTION)][FPSTR(S_LOW_TEMP)].as<uint8_t>();
+
+    if (isValidTemp(value, dst.system.unitSystem, 1, 30) && value != dst.heating.freezeProtection.lowTemp) {
+      dst.heating.freezeProtection.lowTemp = value;
+      changed = true;
+    }
+  }
+
+  if (!src[FPSTR(S_HEATING)][FPSTR(S_FREEZE_PROTECTION)][FPSTR(S_THRESHOLD_TIME)].isNull()) {
+    unsigned short value = src[FPSTR(S_HEATING)][FPSTR(S_FREEZE_PROTECTION)][FPSTR(S_THRESHOLD_TIME)].as<unsigned short>();
+
+    if (value >= 30 && value <= 1800) {
+      if (value != dst.heating.freezeProtection.thresholdTime) {
+        dst.heating.freezeProtection.thresholdTime = value;
+        changed = true;
+      }
+    }
+  }
+
+
   // dhw
   if (src[FPSTR(S_DHW)][FPSTR(S_ENABLED)].is<bool>()) {
     bool value = src[FPSTR(S_DHW)][FPSTR(S_ENABLED)].as<bool>();
@@ -1334,6 +1431,38 @@ bool jsonToSettings(const JsonVariantConst src, Settings& dst, bool safe = false
     changed = true;
   }
 
+  if (!src[FPSTR(S_DHW)][FPSTR(S_MAX_MODULATION)].isNull()) {
+    unsigned char value = src[FPSTR(S_DHW)][FPSTR(S_MAX_MODULATION)].as<unsigned char>();
+
+    if (value > 0 && value <= 100 && value != dst.dhw.maxModulation) {
+      dst.dhw.maxModulation = value;
+      changed = true;
+    }
+  }
+
+  if (!src[FPSTR(S_DHW)][FPSTR(S_OVERHEAT_PROTECTION)][FPSTR(S_HIGH_TEMP)].isNull()) {
+    unsigned char value = src[FPSTR(S_DHW)][FPSTR(S_OVERHEAT_PROTECTION)][FPSTR(S_HIGH_TEMP)].as<unsigned char>();
+
+    if (isValidTemp(value, dst.system.unitSystem, 0.0f, 100.0f) && value != dst.dhw.overheatProtection.highTemp) {
+      dst.dhw.overheatProtection.highTemp = value;
+      changed = true;
+    }
+  }
+
+  if (!src[FPSTR(S_DHW)][FPSTR(S_OVERHEAT_PROTECTION)][FPSTR(S_LOW_TEMP)].isNull()) {
+    unsigned char value = src[FPSTR(S_DHW)][FPSTR(S_OVERHEAT_PROTECTION)][FPSTR(S_LOW_TEMP)].as<unsigned char>();
+
+    if (isValidTemp(value, dst.system.unitSystem, 0.0f, 99.0f) && value != dst.dhw.overheatProtection.lowTemp) {
+      dst.dhw.overheatProtection.lowTemp = value;
+      changed = true;
+    }
+  }
+
+  if (dst.dhw.overheatProtection.highTemp < dst.dhw.overheatProtection.lowTemp) {
+    dst.dhw.overheatProtection.highTemp = dst.dhw.overheatProtection.lowTemp;
+    changed = true;
+  }
+
 
   if (!safe) {
     // external pump
@@ -1692,6 +1821,7 @@ bool jsonToSensorSettings(const uint8_t sensorId, const JsonVariantConst src, Se
       case static_cast<uint8_t>(Sensors::Purpose::EXHAUST_TEMP):
       case static_cast<uint8_t>(Sensors::Purpose::MODULATION_LEVEL):
 
+      case static_cast<uint8_t>(Sensors::Purpose::NUMBER):
       case static_cast<uint8_t>(Sensors::Purpose::POWER_FACTOR):
       case static_cast<uint8_t>(Sensors::Purpose::POWER):
       case static_cast<uint8_t>(Sensors::Purpose::FAN_SPEED):
@@ -1736,6 +1866,15 @@ bool jsonToSensorSettings(const uint8_t sensorId, const JsonVariantConst src, Se
       case static_cast<uint8_t>(Sensors::Type::OT_FAN_SPEED_SETPOINT):
       case static_cast<uint8_t>(Sensors::Type::OT_FAN_SPEED_CURRENT):
 
+      case static_cast<uint8_t>(Sensors::Type::OT_BURNER_STARTS):
+      case static_cast<uint8_t>(Sensors::Type::OT_DHW_BURNER_STARTS):
+      case static_cast<uint8_t>(Sensors::Type::OT_HEATING_PUMP_STARTS):
+      case static_cast<uint8_t>(Sensors::Type::OT_DHW_PUMP_STARTS):
+      case static_cast<uint8_t>(Sensors::Type::OT_BURNER_HOURS):
+      case static_cast<uint8_t>(Sensors::Type::OT_DHW_BURNER_HOURS):
+      case static_cast<uint8_t>(Sensors::Type::OT_HEATING_PUMP_HOURS):
+      case static_cast<uint8_t>(Sensors::Type::OT_DHW_PUMP_HOURS):
+
       case static_cast<uint8_t>(Sensors::Type::NTC_10K_TEMP):
       case static_cast<uint8_t>(Sensors::Type::DALLAS_TEMP):
       case static_cast<uint8_t>(Sensors::Type::BLUETOOTH):
@@ -1955,6 +2094,7 @@ void varsToJson(const Variables& src, JsonVariant dst) {
   mHeating[FPSTR(S_ENABLED)] = src.master.heating.enabled;
   mHeating[FPSTR(S_BLOCKING)] = src.master.heating.blocking;
   mHeating[FPSTR(S_INDOOR_TEMP_CONTROL)] = src.master.heating.indoorTempControl;
+  mHeating[FPSTR(S_OVERHEAT)] = src.master.heating.overheat;
   mHeating[FPSTR(S_SETPOINT_TEMP)] = roundf(src.master.heating.setpointTemp, 2);
   mHeating[FPSTR(S_TARGET_TEMP)] = roundf(src.master.heating.targetTemp, 2);
   mHeating[FPSTR(S_CURRENT_TEMP)] = roundf(src.master.heating.currentTemp, 2);
@@ -1966,6 +2106,7 @@ void varsToJson(const Variables& src, JsonVariant dst) {
 
   auto mDhw = master[FPSTR(S_DHW)].to<JsonObject>();
   mDhw[FPSTR(S_ENABLED)] = src.master.dhw.enabled;
+  mDhw[FPSTR(S_OVERHEAT)] = src.master.dhw.overheat;
   mDhw[FPSTR(S_TARGET_TEMP)] = roundf(src.master.dhw.targetTemp, 2);
   mDhw[FPSTR(S_CURRENT_TEMP)] = roundf(src.master.dhw.currentTemp, 2);
   mDhw[FPSTR(S_RETURN_TEMP)] = roundf(src.master.dhw.returnTemp, 2);

src_data/locales/en.json

@@ -117,6 +117,7 @@
         
         "mHeatEnabled": "Heating enabled",
         "mHeatBlocking": "Heating blocked",
+        "mHeatOverheat": "Heating overheat",
         "sHeatActive": "Heating active",
         "mHeatSetpointTemp": "Heating setpoint temp",
         "mHeatTargetTemp": "Heating target temp",
@@ -126,6 +127,7 @@
         "mHeatOutdoorTemp": "Heating, outdoor temp",
 
         "mDhwEnabled": "DHW enabled",
+        "mDhwOverheat": "DHW overheat",
         "sDhwActive": "DHW active",
         "mDhwTargetTemp": "DHW target temp",
         "mDhwCurrTemp": "DHW current temp",
@@ -201,6 +203,7 @@
         "dhwFlowRate": "DHW, flow rate",
         "exhaustTemp": "Exhaust temperature",
         "modLevel": "Modulation level (in percents)",
+        "number": "Number (raw)",
         "powerFactor": "Power (in percent)",
         "power": "Power (in kWt)",
         "fanSpeed": "Fan speed",
@@ -231,6 +234,14 @@
         "otSolarCollectorTemp": "OpenTherm, solar collector temp",
         "otFanSpeedSetpoint": "OpenTherm, setpoint fan speed",
         "otFanSpeedCurrent": "OpenTherm, current fan speed",
+        "otBurnerStarts": "OpenTherm, number of burner starts",
+        "otDhwBurnerStarts": "OpenTherm, number of burner starts (DHW)",
+        "otHeatingPumpStarts": "OpenTherm, number of pump starts (heating)",
+        "otDhwPumpStarts": "OpenTherm, number of pump starts (DHW)",
+        "otBurnerHours": "OpenTherm, number of burner operating hours",
+        "otDhwBurnerHours": "OpenTherm, number of burner operating hours (DHW)",
+        "otHeatingPumpHours": "OpenTherm, number of pump operating hours (heating)",
+        "otDhwPumpHours": "OpenTherm, number of pump operating hours (DHW)",
         
         "ntcTemp": "NTC sensor",
         "dallasTemp": "DALLAS sensor",
@@ -292,6 +303,25 @@
         "min": "Minimum temperature",
         "max": "Maximum temperature"
       },
+      "maxModulation": "Max modulation level",
+      "ohProtection": {
+        "title": "Overheating protection",
+        "desc": "<b>Note:</b> This feature can be useful if the built-in boiler overheating protection does not work or does not work correctly and the heat carrier boils. To disable, set 0 as <b>high</b> and <b>low</b> temperature.",
+        "highTemp": {
+          "title": "High temperature threshold",
+          "note": "Threshold at which the burner will be forcibly switched off"
+        },
+        "lowTemp": {
+          "title": "Low temperature threshold",
+          "note": "Threshold at which the burner can be turned on again"
+        }
+      },
+      "freezeProtection": {
+        "title": "Freeze protection",
+        "desc": "Heating will be forced to turn on if the heat carrier or indoor temperature drops below <b>Low temperature</b> during <b>Waiting time</b>.",
+        "lowTemp": "Low temperature threshold",
+        "thresholdTime": "Waiting time <small>(sec)</small>"
+      },
 
       "portal": {
         "login": "Login",
@@ -375,7 +405,6 @@
         "ledGpio": "RX LED GPIO",
         "memberId": "Master member ID",
         "flags": "Master flags",
-        "maxMod": "Max modulation level",
         "minPower": {
           "title": "Min boiler power <small>(kW)</small>",
           "note": "This value is at 0-1% boiler modulation level. Typically found in the boiler specification as \"minimum useful heat output\"."
@@ -386,7 +415,8 @@
         },
 
         "options": {
-          "desc": "Options",
+          "title": "Options (additional settings)",
+          "desc": "Options can change the logic of the boiler. Not all options are documented in the protocol, so the same option can have different effects on different boilers.<br /><b>Note:</b> There is no need to change anything if everything works well.",
           "dhwSupport": "DHW support",
           "coolingSupport": "Cooling support",
           "summerWinterMode": "Summer/winter mode",
@@ -395,9 +425,13 @@
           "heatingToCh2": "Duplicate heating to CH2",
           "dhwToCh2": "Duplicate DHW to CH2",
           "dhwBlocking": "DHW blocking",
-          "modulationSyncWithHeating": "Sync modulation with heating",
+          "dhwStateAsDhwBlocking": "DHW state as DHW blocking",
           "maxTempSyncWithTargetTemp": "Sync max heating temp with target temp",
           "getMinMaxTemp": "Get min/max temp from boiler",
+          "ignoreDiagState": "Ignore diag state",
+          "autoFaultReset": "Auto fault reset <small>(not recommended!)</small>",
+          "autoDiagReset": "Auto diag reset <small>(not recommended!)</small>",
+          "setDateAndTime": "Set date & time on boiler",
           "immergasFix": "Fix for Immergas boilers"
         },
 

src_data/locales/it.json

@@ -117,6 +117,7 @@
         
         "mHeatEnabled": "Riscaldamento attivato",
         "mHeatBlocking": "Riscaldamento bloccato",
+        "mHeatOverheat": "Riscaldamento surriscaldamento",
         "sHeatActive": "Riscaldamento attivo",
         "mHeatSetpointTemp": "Temp riscaldamento impostato",
         "mHeatTargetTemp": "Target Temp caldaia",
@@ -126,6 +127,7 @@
         "mHeatOutdoorTemp": "Riscaldamento, temp esterna",
 
         "mDhwEnabled": "ACS attivata",
+        "mDhwOverheat": "ACS surriscaldamento",
         "sDhwActive": "ACS attiva",
         "mDhwTargetTemp": "ACS temp impostata",
         "mDhwCurrTemp": "ACS temp attuale",
@@ -201,6 +203,7 @@
         "dhwFlowRate": "ACS, prelievo",
         "exhaustTemp": "Temperatura fumi",
         "modLevel": "Livello Modulazione (%)",
+        "number": "Numero (raw)",
         "powerFactor": "Potenza (%)",
         "power": "Potenza (in kW)",
         "fanSpeed": "Velocità ventilatore",
@@ -231,6 +234,14 @@
         "otSolarCollectorTemp": "OpenTherm, temp collettore solare",
         "otFanSpeedSetpoint": "OpenTherm, velocità ventola impostata",
         "otFanSpeedCurrent": "OpenTherm, velocità ventola attuale",
+        "otBurnerStarts": "OpenTherm, numero di avviamenti del bruciatore",
+        "otDhwBurnerStarts": "OpenTherm, numero di avviamenti del bruciatore (ACS)",
+        "otHeatingPumpStarts": "OpenTherm, numero di avviamenti della pompa (riscaldamento)",
+        "otDhwPumpStarts": "OpenTherm, numero di avviamenti della pompa (ACS)",
+        "otBurnerHours": "OpenTherm, numero di ore di funzionamento del bruciatore",
+        "otDhwBurnerHours": "OpenTherm, numero di ore di funzionamento del bruciatore (ACS)",
+        "otHeatingPumpHours": "OpenTherm, numero di ore di funzionamento della pompa (riscaldamento)",
+        "otDhwPumpHours": "OpenTherm, numero di ore di funzionamento della pompa (ACS)",
         
         "ntcTemp": "Sensore NTC",
         "dallasTemp": "Sensore DALLAS",
@@ -292,6 +303,25 @@
         "min": "Temperatura minima",
         "max": "Temperatura massima"
       },
+      "maxModulation": "Max livello modulazione",
+      "ohProtection": {
+        "title": "Protezione contro il surriscaldamento",
+        "desc": "<b>Nota:</b> questa funzione può essere utile se la protezione contro il surriscaldamento integrata nella caldaia non funziona o non funziona correttamente e il fluido termovettore bolle. Per disattivarla, impostare 0 come temperatura <b>alta</b> e <b>bassa</b>.",
+        "highTemp": {
+          "title": "Soglia di temperatura alta",
+          "note": "Soglia alla quale il bruciatore verrà spento forzatamente"
+        },
+        "lowTemp": {
+          "title": "Soglia di temperatura bassa",
+          "note": "Soglia alla quale il bruciatore può essere riacceso"
+        }
+      },
+      "freezeProtection": {
+        "title": "Protezione antigelo",
+        "desc": "Il riscaldamento verrà attivato forzatamente se la temperatura del vettore di calore o interna scende al di sotto della <b>temperatura minima</b> durante il <b>tempo di attesa</b>.",
+        "lowTemp": "Soglia di temperatura minima",
+        "thresholdTime": "Tempo di attesa <small>(sec)</small>"
+      },
 
       "portal": {
         "login": "Login",
@@ -375,7 +405,6 @@
         "ledGpio": "RX LED GPIO",
         "memberId": "Master member ID",
         "flags": "Master flags",
-        "maxMod": "Max livello modulazione",
         "minPower": {
           "title": "Potenza minima caldaia <small>(kW)</small>",
           "note": "Questo valore corrisponde allo livello 0-1% di modulazione della caldaia. Di solito si trova nelle specifiche delle caldaia come \"potenza minima disponibile\"."
@@ -386,7 +415,8 @@
         },
 
         "options": {
-          "desc": "Opzioni",
+          "title": "Opzioni (impostazioni aggiuntive)",
+          "desc": "Le opzioni possono modificare la logica della caldaia. Non tutte le opzioni sono documentate nel protocollo, quindi la stessa opzione può avere effetti diversi su caldaie diverse.<br /><b>Nota:</b> Non è necessario modificare nulla se tutto funziona correttamente.",
           "dhwSupport": "Supporto ACS",
           "coolingSupport": "Supporto rafferscamento",
           "summerWinterMode": "Modalità Estate/inverno",
@@ -395,9 +425,13 @@
           "heatingToCh2": "Riproduci riscaldamento su CH2",
           "dhwToCh2": "Riproduci ACS su CH2",
           "dhwBlocking": "Bloccare ACS",
-          "modulationSyncWithHeating": "Sincronizzare modulazione con caldaia",
+          "dhwStateAsDhwBlocking": "Stato ACS come bloccare ACS",
           "maxTempSyncWithTargetTemp": "Sincronizza la temperatura massima di riscaldamento con la temperatura target",
           "getMinMaxTemp": "Prendi temp min/max dalla caldaia",
+          "ignoreDiagState": "Ignora lo stato diagnostico",
+          "autoFaultReset": "Ripristino automatico degli errori <small>(sconsigliato!)</small>",
+          "autoDiagReset": "Ripristino diagnostico automatica <small>(sconsigliato!)</small>",
+          "setDateAndTime": "Imposta data e ora sulla caldaia",
           "immergasFix": "Fix per caldiaie Immergas"
         },
 

src_data/locales/ru.json

@@ -117,6 +117,7 @@
         
         "mHeatEnabled": "Отопление",
         "mHeatBlocking": "Блокировка отопления",
+        "mHeatOverheat": "Отопление, перегрев",
         "sHeatActive": "Активность отопления",
         "mHeatSetpointTemp": "Отопление, уставка",
         "mHeatTargetTemp": "Отопление, целевая температура",
@@ -126,6 +127,7 @@
         "mHeatOutdoorTemp": "Отопление, наружная темп.",
 
         "mDhwEnabled": "ГВС",
+        "mDhwOverheat": "ГВС, перегрев",
         "sDhwActive": "Активность ГВС",
         "mDhwTargetTemp": "ГВС, целевая температура",
         "mDhwCurrTemp": "ГВС, текущая температура",
@@ -201,6 +203,7 @@
         "dhwFlowRate": "ГВС, расход/скорость потока",
         "exhaustTemp": "Температура выхлопных газов",
         "modLevel": "Уровень модуляции (в процентах)",
+        "number": "Число (raw)",
         "powerFactor": "Мощность (в процентах)",
         "power": "Мощность (в кВт)",
         "fanSpeed": "Скорость вентилятора",
@@ -231,6 +234,14 @@
         "otSolarCollectorTemp": "OpenTherm, темп. солн. коллектора",
         "otFanSpeedSetpoint": "OpenTherm, установленная мощн. вентилятора",
         "otFanSpeedCurrent": "OpenTherm, текущая мощн. вентилятора",
+        "otBurnerStarts": "OpenTherm, кол-во запусков горелки",
+        "otDhwBurnerStarts": "OpenTherm, кол-во запусков горелки (ГВС)",
+        "otHeatingPumpStarts": "OpenTherm, кол-во запусков насоса (отопление)",
+        "otDhwPumpStarts": "OpenTherm, кол-во запусков насоса (ГВС)",
+        "otBurnerHours": "OpenTherm, кол-во часов работы горелки",
+        "otDhwBurnerHours": "OpenTherm, кол-во часов работы горелки (ГВС)",
+        "otHeatingPumpHours": "OpenTherm, кол-во часов работы насоса (отопление)",
+        "otDhwPumpHours": "OpenTherm, кол-во часов работы насоса (ГВС)",
         
         "ntcTemp": "NTC датчик",
         "dallasTemp": "DALLAS датчик",
@@ -292,6 +303,25 @@
         "min": "Мин. температура",
         "max": "Макс. температура"
       },
+      "maxModulation": "Макс. уровень модуляции",
+      "ohProtection": {
+        "title": "Защита от перегрева",
+        "desc": "<b>Примечание:</b> Эта функция может быть полезна, если встроенная защита от перегрева котла не срабатывает или срабатывает некорректно и теплоноситель закипает. Для отключения установите 0 в качестве <b>верхнего</b> и <b>нижнего</b> порога температуры.",
+        "highTemp": {
+          "title": "Верхний порог температуры",
+          "note": "Порог, при котором горелка будет принудительно отключена"
+        },
+        "lowTemp": {
+          "title": "Нижний порог температуры",
+          "note": "Порог, при котором горелка может быть включена снова"
+        }
+      },
+      "freezeProtection": {
+        "title": "Защита от замерзания",
+        "desc": "Отопление будет принудительно включено, если темп. теплоносителя или внутренняя темп. опустится ниже <b>нижнего порога</b> в течение <b>времени ожидания</b>.",
+        "lowTemp": "Нижний порог температуры",
+        "thresholdTime": "Время ожидания <small>(сек)</small>"
+      },
 
       "portal": {
         "login": "Логин",
@@ -375,7 +405,6 @@
         "ledGpio": "RX LED GPIO",
         "memberId": "Master member ID",
         "flags": "Master flags",
-        "maxMod": "Макс. уровень модуляции",
         "minPower": {
           "title": "Мин. мощность котла <small>(кВт)</small>",
           "note": "Это значение соответствует уровню модуляции котла 0–1%. Обычно можно найти в спецификации котла как \"минимальная полезная тепловая мощность\"."
@@ -386,7 +415,8 @@
         },
 
         "options": {
-          "desc": "Опции",
+          "title": "Опции (дополнительные настройки)",
+          "desc": "Опции могут менять логику работы котла. Не все опции задокументированы в протоколе, поэтому одна и та же опция может иметь разный эффект на разных котлах.<br /><b>Примечание:</b> Нет необходимости что-то менять, если всё работает хорошо.",
           "dhwSupport": "Поддержка ГВС",
           "coolingSupport": "Поддержка охлаждения",
           "summerWinterMode": "Летний/зимний режим",
@@ -395,9 +425,13 @@
           "heatingToCh2": "Дублировать параметры отопления в канал 2",
           "dhwToCh2": "Дублировать параметры ГВС в канал 2",
           "dhwBlocking": "DHW blocking",
-          "modulationSyncWithHeating": "Синхронизировать модуляцию с отоплением",
+          "dhwStateAsDhwBlocking": "DHW blocking в качестве состояния ГВС",
           "maxTempSyncWithTargetTemp": "Синхронизировать макс. темп. отопления с целевой темп.",
           "getMinMaxTemp": "Получать мин. и макс. температуру от котла",
+          "ignoreDiagState": "Игнорировать состояние диагностики",
+          "autoFaultReset": "Автоматический сброс ошибок <small>(не рекомендуется!)</small>",
+          "autoDiagReset": "Автоматический сброс диагностики <small>(не рекомендуется!)</small>",
+          "setDateAndTime": "Устанавливать время и дату на котле",
           "immergasFix": "Фикс для котлов Immergas"
         },
 

src_data/pages/dashboard.html

@@ -184,6 +184,10 @@
                   <th scope="row" data-i18n>dashboard.states.mHeatBlocking</th>
                   <td><i class="mHeatBlocking"></i></td>
                 </tr>
+                <tr>
+                  <th scope="row" data-i18n>dashboard.states.mHeatOverheat</th>
+                  <td><i class="mHeatOverheat"></i></td>
+                </tr>
                 <tr>
                   <th scope="row" data-i18n>dashboard.states.sHeatActive</th>
                   <td><i class="sHeatActive"></i></td>
@@ -218,6 +222,10 @@
                   <th scope="row" data-i18n>dashboard.states.mDhwEnabled</th>
                   <td><i class="mDhwEnabled"></i></td>
                 </tr>
+                <tr>
+                  <th scope="row" data-i18n>dashboard.states.mDhwOverheat</th>
+                  <td><i class="mDhwOverheat"></i></td>
+                </tr>
                 <tr>
                   <th scope="row" data-i18n>dashboard.states.sDhwActive</th>
                   <td><i class="sDhwActive"></i></td>
@@ -261,16 +269,16 @@
 
           <details>
             <summary><b data-i18n>dashboard.section.diag</b></summary>
-            <pre><b>Vendor:</b>             <span class="sVendor"></span>
+            <pre><b>Vendor:</b>         <span class="sVendor"></span>
-<b>Member ID:</b>          <span class="sMemberId"></span>
+<b>Member ID:</b>      <span class="sMemberId"></span>
-<b>Flags:</b>              <span class="sFlags"></span>
+<b>Flags:</b>          <span class="sFlags"></span>
-<b>Type:</b>               <span class="sType"></span>
+<b>Type:</b>           <span class="sType"></span>
-<b>AppVersion:</b>         <span class="sAppVersion"></span>
+<b>AppVersion:</b>     <span class="sAppVersion"></span>
-<b>OT version:</b>         <span class="sProtocolVersion"></span>
+<b>OT version:</b>     <span class="sProtocolVersion"></span>
-<b>Modulation limits:</b>  <span class="sModMin"></span>...<span class="sAbsModMax"></span> %, curr. max: <span class="sModMax"></span> %
+<b>Modulation:</b>     min: <span class="sModMin"></span> %, curr. max: <span class="sModMax"></span> %
-<b>Power limits:</b>       <span class="sPowerMin"></span>...<span class="sPowerMax"></span> kW
+<b>Power limits:</b>   <span class="sPowerMin"></span>...<span class="sPowerMax"></span> kW
-<b>Heating limits:</b>     <span class="sHeatMinTemp"></span>...<span class="sHeatMaxTemp"></span> <span class="tempUnit"></span>
+<b>Heating limits:</b> <span class="sHeatMinTemp"></span>...<span class="sHeatMaxTemp"></span> <span class="tempUnit"></span>
-<b>DHW limits:</b>         <span class="sDhwMinTemp"></span>...<span class="sDhwMaxTemp"></span> <span class="tempUnit"></span></pre>
+<b>DHW limits:</b>     <span class="sDhwMinTemp"></span>...<span class="sDhwMaxTemp"></span> <span class="tempUnit"></span></pre>
           </details>
         </div>
       </article>
@@ -508,7 +516,6 @@
             setValue('.tempUnit', temperatureUnit(unitSystem));
             setValue('.pressureUnit', pressureUnit(unitSystem));
             setValue('.volumeUnit', volumeUnit(unitSystem));
-            setValue('.sAbsModMax', result.opentherm.maxModulation);
 
           } catch (error) {
             console.log(error);
@@ -612,6 +619,11 @@
               result.master.heating.blocking ? "red" : "green"
             );
             setState('.mHeatIndoorTempControl', result.master.heating.indoorTempControl);
+            setStatus(
+              '.mHeatOverheat',
+              result.master.heating.overheat ? "success" : "error",
+              result.master.heating.overheat ? "red" : "green"
+            );
             setValue('.mHeatSetpointTemp', result.master.heating.setpointTemp);
             setValue('.mHeatTargetTemp', result.master.heating.targetTemp);
             setValue('.mHeatCurrTemp', result.master.heating.currentTemp);
@@ -622,6 +634,11 @@
             setValue('.mHeatMaxTemp', result.master.heating.maxTemp);
 
             setState('.mDhwEnabled', result.master.dhw.enabled);
+            setStatus(
+              '.mDhwOverheat',
+              result.master.dhw.overheat ? "success" : "error",
+              result.master.dhw.overheat ? "red" : "green"
+            );
             setValue('.mDhwTargetTemp', result.master.dhw.targetTemp);
             setValue('.mDhwCurrTemp', result.master.dhw.currentTemp);
             setValue('.mDhwRetTemp', result.master.dhw.returnTemp);

src_data/pages/sensors.html

@@ -69,6 +69,7 @@
                       <option value="6" data-i18n>sensors.purposes.dhwFlowRate</option>
                       <option value="7" data-i18n>sensors.purposes.exhaustTemp</option>
                       <option value="8" data-i18n>sensors.purposes.modLevel</option>
+                      <option value="247" data-i18n>sensors.purposes.number</option>
                       <option value="248" data-i18n>sensors.purposes.powerFactor</option>
                       <option value="249" data-i18n>sensors.purposes.power</option>
                       <option value="250" data-i18n>sensors.purposes.fanSpeed</option>
@@ -102,6 +103,14 @@
                       <option value="16" data-i18n>sensors.types.otSolarCollectorTemp</option>
                       <option value="17" data-i18n>sensors.types.otFanSpeedSetpoint</option>
                       <option value="18" data-i18n>sensors.types.otFanSpeedCurrent</option>
+                      <option value="19" data-i18n>sensors.types.otBurnerStarts</option>
+                      <option value="20" data-i18n>sensors.types.otDhwBurnerStarts</option>
+                      <option value="21" data-i18n>sensors.types.otHeatingPumpStarts</option>
+                      <option value="22" data-i18n>sensors.types.otDhwPumpStarts</option>
+                      <option value="23" data-i18n>sensors.types.otBurnerHours</option>
+                      <option value="24" data-i18n>sensors.types.otDhwBurnerHours</option>
+                      <option value="25" data-i18n>sensors.types.otHeatingPumpHours</option>
+                      <option value="26" data-i18n>sensors.types.otDhwPumpHours</option>
 
                       <option value="50" data-i18n>sensors.types.ntcTemp</option>
                       <option value="51" data-i18n>sensors.types.dallasTemp</option>

src_data/pages/settings.html

@@ -202,6 +202,55 @@
                 </label>
               </div>
 
+              <label>
+                <span data-i18n>settings.maxModulation</span>
+                <input type="number" inputmode="numeric" name="heating[maxModulation]" min="1" max="100" step="1" required>
+              </label>
+
+              <hr />
+
+              <details>
+                <summary><b data-i18n>settings.ohProtection.title</b></summary>
+
+                <div class="grid">
+                  <label>
+                    <span data-i18n>settings.ohProtection.highTemp.title</span>
+                    <input type="number" inputmode="numeric" name="heating[overheatProtection][highTemp]" min="0" max="0" step="1" required>
+                    <small data-i18n>settings.ohProtection.highTemp.note</small>
+                  </label>
+
+                  <label>
+                    <span data-i18n>settings.ohProtection.lowTemp.title</span>
+                    <input type="number" inputmode="numeric" name="heating[overheatProtection][lowTemp]" min="0" max="0" step="1" required>
+                    <small data-i18n>settings.ohProtection.lowTemp.note</small>
+                  </label>
+                </div>
+
+                <small data-i18n>settings.ohProtection.desc</small>
+              </details>
+
+              <hr />
+
+              <details>
+                <summary><b data-i18n>settings.freezeProtection.title</b></summary>
+
+                <div class="grid">
+                  <label>
+                    <span data-i18n>settings.freezeProtection.lowTemp</span>
+                    <input type="number" inputmode="numeric" name="heating[freezeProtection][lowTemp]" min="0" max="0" step="1" required>
+                  </label>
+
+                  <label>
+                    <span data-i18n>settings.freezeProtection.thresholdTime</span>
+                    <input type="number" inputmode="numeric" name="heating[freezeProtection][thresholdTime]" min="30" max="1800" step="1" required>
+                  </label>
+                </div>
+
+                <small data-i18n>settings.freezeProtection.desc</small>
+              </details>
+
+              <br />
+
               <button type="submit" data-i18n>button.save</button>
             </form>
           </div>
@@ -226,6 +275,35 @@
                 </label>
               </div>
 
+              <label>
+                <span data-i18n>settings.maxModulation</span>
+                <input type="number" inputmode="numeric" name="dhw[maxModulation]" min="1" max="100" step="1" required>
+              </label>
+
+              <hr />
+
+              <details>
+                <summary><b data-i18n>settings.ohProtection.title</b></summary>
+
+                <div class="grid">
+                  <label>
+                    <span data-i18n>settings.ohProtection.highTemp.title</span>
+                    <input type="number" inputmode="numeric" name="dhw[overheatProtection][highTemp]" min="0" max="0" step="1" required>
+                    <small data-i18n>settings.ohProtection.highTemp.note</small>
+                  </label>
+
+                  <label>
+                    <span data-i18n>settings.ohProtection.lowTemp.title</span>
+                    <input type="number" inputmode="numeric" name="dhw[overheatProtection][lowTemp]" min="0" max="0" step="1" required>
+                    <small data-i18n>settings.ohProtection.lowTemp.note</small>
+                  </label>
+                </div>
+
+                <small data-i18n>settings.ohProtection.desc</small>
+              </details>
+
+              <br />
+
               <button type="submit" data-i18n>button.save</button>
             </form>
           </div>
@@ -457,11 +535,6 @@
                   <span data-i18n>settings.ot.flags</span>
                   <input type="number" inputmode="numeric" name="opentherm[flags]" min="0" max="255" step="1" required>
                 </label>
-
-                <label>
-                  <span data-i18n>settings.ot.maxMod</span>
-                  <input type="number" inputmode="numeric" name="opentherm[maxModulation]" min="1" max="100" step="1" required>
-                </label>
               </div>
 
               <div class="grid">
@@ -478,77 +551,107 @@
                 </label>
               </div>
 
-              <fieldset>
+              <details>
-                <legend data-i18n>settings.ot.options.desc</legend>
+                <summary><b data-i18n>settings.ot.options.title</b></summary>
 
-                <label>
+                <div>
-                  <input type="checkbox" name="opentherm[options][dhwSupport]" value="true">
+                  <fieldset>
-                  <span data-i18n>settings.ot.options.dhwSupport</span>
+                    <small data-i18n>settings.ot.options.desc</small>
-                </label>
+                  </fieldset>
 
-                <label>
+                  <fieldset>
-                  <input type="checkbox" name="opentherm[options][coolingSupport]" value="true">
+                    <label>
-                  <span data-i18n>settings.ot.options.coolingSupport</span>
+                      <input type="checkbox" name="opentherm[options][dhwSupport]" value="true">
-                </label>
+                      <span data-i18n>settings.ot.options.dhwSupport</span>
+                    </label>
 
-                <label>
+                    <label>
-                  <input type="checkbox" name="opentherm[options][summerWinterMode]" value="true">
+                      <input type="checkbox" name="opentherm[options][coolingSupport]" value="true">
-                  <span data-i18n>settings.ot.options.summerWinterMode</span>
+                      <span data-i18n>settings.ot.options.coolingSupport</span>
-                </label>
+                    </label>
 
-                <label>
+                    <label>
-                  <input type="checkbox" name="opentherm[options][heatingStateToSummerWinterMode]" value="true">
+                      <input type="checkbox" name="opentherm[options][summerWinterMode]" value="true">
-                  <span data-i18n>settings.ot.options.heatingStateToSummerWinterMode</span>
+                      <span data-i18n>settings.ot.options.summerWinterMode</span>
-                </label>
+                    </label>
 
-                <label>
+                    <label>
-                  <input type="checkbox" name="opentherm[options][ch2AlwaysEnabled]" value="true">
+                      <input type="checkbox" name="opentherm[options][heatingStateToSummerWinterMode]" value="true">
-                  <span data-i18n>settings.ot.options.ch2AlwaysEnabled</span>
+                      <span data-i18n>settings.ot.options.heatingStateToSummerWinterMode</span>
-                </label>
+                    </label>
 
-                <label>
+                    <label>
-                  <input type="checkbox" name="opentherm[options][heatingToCh2]" value="true">
+                      <input type="checkbox" name="opentherm[options][ch2AlwaysEnabled]" value="true">
-                  <span data-i18n>settings.ot.options.heatingToCh2</span>
+                      <span data-i18n>settings.ot.options.ch2AlwaysEnabled</span>
-                </label>
+                    </label>
 
-                <label>
+                    <label>
-                  <input type="checkbox" name="opentherm[options][dhwToCh2]" value="true">
+                      <input type="checkbox" name="opentherm[options][heatingToCh2]" value="true">
-                  <span data-i18n>settings.ot.options.dhwToCh2</span>
+                      <span data-i18n>settings.ot.options.heatingToCh2</span>
-                </label>
+                    </label>
 
-                <label>
+                    <label>
-                  <input type="checkbox" name="opentherm[options][dhwBlocking]" value="true">
+                      <input type="checkbox" name="opentherm[options][dhwToCh2]" value="true">
-                  <span data-i18n>settings.ot.options.dhwBlocking</span>
+                      <span data-i18n>settings.ot.options.dhwToCh2</span>
-                </label>
+                    </label>
 
-                <label>
+                    <label>
-                  <input type="checkbox" name="opentherm[options][modulationSyncWithHeating]" value="true">
+                      <input type="checkbox" name="opentherm[options][dhwBlocking]" value="true">
-                  <span data-i18n>settings.ot.options.modulationSyncWithHeating</span>
+                      <span data-i18n>settings.ot.options.dhwBlocking</span>
-                </label>
+                    </label>
 
-                <label>
+                    <label>
-                  <input type="checkbox" name="opentherm[options][maxTempSyncWithTargetTemp]" value="true">
+                      <input type="checkbox" name="opentherm[options][dhwStateAsDhwBlocking]" value="true">
-                  <span data-i18n>settings.ot.options.maxTempSyncWithTargetTemp</span>
+                      <span data-i18n>settings.ot.options.dhwStateAsDhwBlocking</span>
-                </label>
+                    </label>
 
-                <label>
+                    <label>
-                  <input type="checkbox" name="opentherm[options][getMinMaxTemp]" value="true">
+                      <input type="checkbox" name="opentherm[options][maxTempSyncWithTargetTemp]" value="true">
-                  <span data-i18n>settings.ot.options.getMinMaxTemp</span>
+                      <span data-i18n>settings.ot.options.maxTempSyncWithTargetTemp</span>
-                </label>
+                    </label>
 
-                <label>
+                    <label>
-                  <input type="checkbox" name="opentherm[options][immergasFix]" value="true">
+                      <input type="checkbox" name="opentherm[options][getMinMaxTemp]" value="true">
-                  <span data-i18n>settings.ot.options.immergasFix</span>
+                      <span data-i18n>settings.ot.options.getMinMaxTemp</span>
-                </label>
+                    </label>
 
-                <hr />
+                    <label>
-                <label>
+                      <input type="checkbox" name="opentherm[options][ignoreDiagState]" value="true">
-                  <input type="checkbox" name="opentherm[options][nativeHeatingControl]" value="true">
+                      <span data-i18n>settings.ot.options.ignoreDiagState</span>
-                  <span data-i18n>settings.ot.nativeHeating.title</span><br />
+                    </label>
-                  <small data-i18n>settings.ot.nativeHeating.note</small>
-                </label>
-              </fieldset>
 
+                    <label>
+                      <input type="checkbox" name="opentherm[options][autoFaultReset]" value="true">
+                      <span data-i18n>settings.ot.options.autoFaultReset</span>
+                    </label>
+
+                    <label>
+                      <input type="checkbox" name="opentherm[options][autoDiagReset]" value="true">
+                      <span data-i18n>settings.ot.options.autoDiagReset</span>
+                    </label>
+
+                    <label>
+                      <input type="checkbox" name="opentherm[options][setDateAndTime]" value="true">
+                      <span data-i18n>settings.ot.options.setDateAndTime</span>
+                    </label>
+
+                    <label>
+                      <input type="checkbox" name="opentherm[options][immergasFix]" value="true">
+                      <span data-i18n>settings.ot.options.immergasFix</span>
+                    </label>
+
+                    <hr />
+
+                    <label>
+                      <input type="checkbox" name="opentherm[options][nativeHeatingControl]" value="true">
+                      <span data-i18n>settings.ot.nativeHeating.title</span><br />
+                      <small data-i18n>settings.ot.nativeHeating.note</small>
+                    </label>
+                  </fieldset>
+                </div>
+              </details>
+              
+              <br />
               <button type="submit" data-i18n>button.save</button>
             </form>
           </div>
@@ -788,7 +891,6 @@
           setInputValue("[name='opentherm[rxLedGpio]']", data.opentherm.rxLedGpio < 255 ? data.opentherm.rxLedGpio : '');
           setInputValue("[name='opentherm[memberId]']", data.opentherm.memberId);
           setInputValue("[name='opentherm[flags]']", data.opentherm.flags);
-          setInputValue("[name='opentherm[maxModulation]']", data.opentherm.maxModulation);
           setInputValue("[name='opentherm[minPower]']", data.opentherm.minPower);
           setInputValue("[name='opentherm[maxPower]']", data.opentherm.maxPower);
           setCheckboxValue("[name='opentherm[options][dhwSupport]']", data.opentherm.options.dhwSupport);
@@ -799,9 +901,13 @@
           setCheckboxValue("[name='opentherm[options][heatingToCh2]']", data.opentherm.options.heatingToCh2);
           setCheckboxValue("[name='opentherm[options][dhwToCh2]']", data.opentherm.options.dhwToCh2);
           setCheckboxValue("[name='opentherm[options][dhwBlocking]']", data.opentherm.options.dhwBlocking);
-          setCheckboxValue("[name='opentherm[options][modulationSyncWithHeating]']", data.opentherm.options.modulationSyncWithHeating);
+          setCheckboxValue("[name='opentherm[options][dhwStateAsDhwBlocking]']", data.opentherm.options.dhwStateAsDhwBlocking);
           setCheckboxValue("[name='opentherm[options][maxTempSyncWithTargetTemp]']", data.opentherm.options.maxTempSyncWithTargetTemp);
           setCheckboxValue("[name='opentherm[options][getMinMaxTemp]']", data.opentherm.options.getMinMaxTemp);
+          setCheckboxValue("[name='opentherm[options][ignoreDiagState]']", data.opentherm.options.ignoreDiagState);
+          setCheckboxValue("[name='opentherm[options][autoFaultReset]']", data.opentherm.options.autoFaultReset);
+          setCheckboxValue("[name='opentherm[options][autoDiagReset]']", data.opentherm.options.autoDiagReset);
+          setCheckboxValue("[name='opentherm[options][setDateAndTime]']", data.opentherm.options.setDateAndTime);
           setCheckboxValue("[name='opentherm[options][nativeHeatingControl]']", data.opentherm.options.nativeHeatingControl);
           setCheckboxValue("[name='opentherm[options][immergasFix]']", data.opentherm.options.immergasFix);
           setBusy('#ot-settings-busy', '#ot-settings', false);
@@ -851,6 +957,20 @@
           });
           setInputValue("[name='heating[hysteresis]']", data.heating.hysteresis);
           setInputValue("[name='heating[turboFactor]']", data.heating.turboFactor);
+          setInputValue("[name='heating[maxModulation]']", data.heating.maxModulation);
+          setInputValue("[name='heating[overheatProtection][highTemp]']", data.heating.overheatProtection.highTemp, {
+            "min": 0,
+            "max": data.system.unitSystem == 0 ? 100 : 212
+          });
+          setInputValue("[name='heating[overheatProtection][lowTemp]']", data.heating.overheatProtection.lowTemp, {
+            "min": 0,
+            "max": data.system.unitSystem == 0 ? 99 : 211
+          });
+          setInputValue("[name='heating[freezeProtection][lowTemp]']", data.heating.freezeProtection.lowTemp, {
+            "min": data.system.unitSystem == 0 ? 1 : 34,
+            "max": data.system.unitSystem == 0 ? 30 : 86
+          });
+          setInputValue("[name='heating[freezeProtection][thresholdTime]']", data.heating.freezeProtection.thresholdTime);
           setBusy('#heating-settings-busy', '#heating-settings', false);
 
           // DHW
@@ -862,14 +982,22 @@
             "min": data.system.unitSystem == 0 ? 1 : 33,
             "max": data.system.unitSystem == 0 ? 100 : 212
           });
+          setInputValue("[name='dhw[maxModulation]']", data.dhw.maxModulation);
+          setInputValue("[name='dhw[overheatProtection][highTemp]']", data.dhw.overheatProtection.highTemp, {
+            "min": 0,
+            "max": data.system.unitSystem == 0 ? 100 : 212
+          });
+          setInputValue("[name='dhw[overheatProtection][lowTemp]']", data.dhw.overheatProtection.lowTemp, {
+            "min": 0,
+            "max": data.system.unitSystem == 0 ? 99 : 211
+          });
           setBusy('#dhw-settings-busy', '#dhw-settings', false);
 
           // Emergency mode
-          setInputValue("[name='emergency[tresholdTime]']", data.emergency.tresholdTime);
           if (data.opentherm.options.nativeHeatingControl) {
             setInputValue("[name='emergency[target]']", data.emergency.target, {
               "min": data.system.unitSystem == 0 ? 5 : 41,
-              "max": data.system.unitSystem == 0 ? 30 : 86
+              "max": data.system.unitSystem == 0 ? 40 : 104
             });
 
           } else {
@@ -878,7 +1006,7 @@
               "max": data.heating.maxTemp,
             });
           }
-
+          setInputValue("[name='emergency[tresholdTime]']", data.emergency.tresholdTime);
           setBusy('#emergency-settings-busy', '#emergency-settings', false);
 
           // Equitherm

src_data/styles/app.css

@@ -3,6 +3,10 @@
     --pico-block-spacing-vertical: calc(var(--pico-spacing) * 0.75);
     --pico-block-spacing-horizontal: calc(var(--pico-spacing) * 0.75);
   }
+
+  .logo {
+    font-size: 1.2rem;
+  }
 }
 
 @media (min-width: 768px) {
@@ -10,6 +14,10 @@
     --pico-block-spacing-vertical: var(--pico-spacing);
     --pico-block-spacing-horizontal: var(--pico-spacing);
   }
+
+  .logo {
+    font-size: 1.25rem;
+  }
 }
 
 @media (min-width: 1024px) {
@@ -17,6 +25,10 @@
     --pico-block-spacing-vertical: calc(var(--pico-spacing) * 1.25);
     --pico-block-spacing-horizontal: calc(var(--pico-spacing) * 1.25);
   }
+
+  .logo {
+    font-size: 1.25rem;
+  }
 }
 
 @media (min-width: 1280px) {
@@ -25,6 +37,10 @@
     --pico-block-spacing-horizontal: calc(var(--pico-spacing) * 1.5);
   }
 
+  .logo {
+    font-size: 1.3rem;
+  }
+
   .container {
     max-width: 1000px;
   }
@@ -36,6 +52,10 @@
     --pico-block-spacing-horizontal: calc(var(--pico-spacing) * 1.75);
   }
 
+  .logo {
+    font-size: 1.3rem;
+  }
+
   .container {
     max-width: 1000px;
   }
@@ -111,7 +131,7 @@ tr.network:hover {
   border-radius: var(--pico-border-radius);
   color: var(--pico-code-kbd-color);
   font-weight: bolder;
-  font-size: 1.3rem;
+  /*font-size: 1.3rem;*/
   font-family: var(--pico-font-family-monospace);
 }