chore: bump version to 1.5.5

Baxi Ampera resets the maximum modulation level to 0 when the heating is turned off

.gitignore

@@ -1,8 +1,13 @@
 .pio
 .vscode
-build/*.bin
+build/*
 data/*
+managed_components/*
+node_modules/*
 secrets.ini
-node_modules
 package-lock.json
+*.lock
+sdkconfig.*
+CMakeLists.txt
+!sdkconfig.defaults
 !.gitkeep

README.md

@@ -1,49 +1,55 @@
 <div align="center">
-   
-   ![logo](/assets/logo.svg)
-   <br>
+
    [![GitHub version](https://img.shields.io/github/release/Laxilef/OTGateway.svg?include_prereleases)](https://github.com/Laxilef/OTGateway/releases)
    [![GitHub download](https://img.shields.io/github/downloads/Laxilef/OTGateway/total.svg)](https://github.com/Laxilef/OTGateway/releases/latest)
    [![License](https://img.shields.io/github/license/Laxilef/OTGateway.svg)](LICENSE.txt)
    [![Telegram](https://img.shields.io/badge/Telegram-Channel-33A8E3)](https://t.me/otgateway)
-   
+
 </div>
+<hr />
+
+![Dashboard](/assets/poster-1.png) 
+![Configuration](/assets/poster-2.png) 
+![Integration with HomeAssistant](/assets/poster-3.png)
 
 ## Features
-- Hot water temperature control
+- DHW temperature control
 - Heating temperature control
 - Smart heating temperature control modes:
    - PID
    - Equithermic curves - adjusts the temperature based on indoor and outdoor temperatures
-- Hysteresis setting (for accurate maintenance of room temperature)
-- Ability to connect an external sensors to monitor outdoor and indoor temperature ([compatible sensors](https://github.com/Laxilef/OTGateway/wiki/Compatibility#temperature-sensors))
-- Emergency mode. If the Wi-Fi connection is lost or the gateway cannot connect to the MQTT server, the mode will turn on. This mode will automatically maintain the set temperature and prevent your home from freezing. In this mode it is also possible to use equithermal curves (weather-compensated control).
-- Automatic error reset (not with all boilers)
+- Hysteresis setting _(for accurate maintenance of room temperature)_
+- Ability to connect [additional (external) sensors](https://github.com/Laxilef/OTGateway/wiki/Compatibility#temperature-sensors): Dallas (1-wire), NTC 10k, Bluetooth (BLE). Makes it possible to monitor indoor and outdoor temperatures, temperatures on pipes/heat exchangers/etc.
+- Emergency mode. In any dangerous situation _(loss of connection with Wifi, MQTT, sensors, etc)_ it will not let you and your home freeze.
+- Ability of remote fault reset _(not with all boilers)_
 - Diagnostics:
-  - The process of heating: works/does not work
-  - The process of heating water for hot water: working/not working
-  - Display of boiler errors
-  - Burner status (flame): on/off
-  - Burner modulation level in percent
-  - Pressure in the heating system
-  - Gateway status (depending on errors and connection status)
-  - Boiler connection status via OpenTherm interface
-  - The current temperature of the heat carrier (usually the return heat carrier)
-  - Set heat carrier temperature (depending on the selected mode)
-  - Current hot water temperature
+  - Displaying gateway status
+  - Displaying the connection status to the boiler via OpenTherm
+  - Displaying the fault status and fault code
+  - Displaying the diagnostic status & diagnostic code
+  - Display of the process of heating: works/does not work
+  - Display of burner (flame) status: on/off
+  - Display of burner modulation level in percent
+  - Display of pressure in the heating system
+  - Display of current temperature of the heat carrier
+  - Display of return temperature of the heat carrier
+  - Display of setpoint heat carrier temperature (useful when using PID or Equitherm)
+  - Display of the process of DHW: working/not working
+  - Display of current DHW temperature
+  - _And other information..._
 - [Home Assistant](https://www.home-assistant.io/) integration via MQTT. The ability to create any automation for the boiler!
 
-![logo](/assets/ha.png)
-
 ## Documentation
 All available information and instructions can be found in the wiki:
 
 * [Home](https://github.com/Laxilef/OTGateway/wiki)
    * [Quick Start](https://github.com/Laxilef/OTGateway/wiki#quick-start)
    * [Build firmware](https://github.com/Laxilef/OTGateway/wiki#build-firmware)
-   * [Flash firmware via ESP Flash Download Tool](https://github.com/Laxilef/OTGateway/wiki#flash-firmware-via-esp-flash-download-tool)
+   * [Flashing via Web Flasher](https://github.com/Laxilef/OTGateway/wiki#flashing-via-web-flasher)
+   * [Flashing via ESP Flash Download Tool](https://github.com/Laxilef/OTGateway/wiki#flashing-via-esp-flash-download-tool)
    * [Settings](https://github.com/Laxilef/OTGateway/wiki#settings)
       * [External temperature sensors](https://github.com/Laxilef/OTGateway/wiki#external-temperature-sensors)
+      * [Other external sensors](https://github.com/Laxilef/OTGateway/wiki#other-external-sensors)
       * [Reporting indoor/outdoor temperature from any Home Assistant sensor](https://github.com/Laxilef/OTGateway/wiki#reporting-indooroutdoor-temperature-from-any-home-assistant-sensor)
       * [Reporting outdoor temperature from Home Assistant weather integration](https://github.com/Laxilef/OTGateway/wiki#reporting-outdoor-temperature-from-home-assistant-weather-integration)
       * [DHW meter](https://github.com/Laxilef/OTGateway/wiki#dhw-meter)
@@ -52,6 +58,7 @@ All available information and instructions can be found in the wiki:
       * [Ratios](https://github.com/Laxilef/OTGateway/wiki#ratios)
       * [Fit coefficients](https://github.com/Laxilef/OTGateway/wiki#fit-coefficients)
    * [PID mode](https://github.com/Laxilef/OTGateway/wiki#pid-mode)
+   * [Logs and debug](https://github.com/Laxilef/OTGateway/wiki#logs-and-debug)
 * [Compatibility](https://github.com/Laxilef/OTGateway/wiki/Compatibility)
    * [Boilers](https://github.com/Laxilef/OTGateway/wiki/Compatibility#boilers)
    * [Boards](https://github.com/Laxilef/OTGateway/wiki/Compatibility#boards)
@@ -64,24 +71,5 @@ 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)
 
-
-
-## Dependencies
-- [ESP8266Scheduler](https://github.com/nrwiersma/ESP8266Scheduler) (for ESP8266)
-- [ESP32Scheduler](https://github.com/laxilef/ESP32Scheduler) (for ESP32)
-- [ArduinoJson](https://github.com/bblanchon/ArduinoJson)
-- [OpenTherm Library](https://github.com/ihormelnyk/opentherm_library)
-- [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)
-- [DallasTemperature](https://github.com/milesburton/Arduino-Temperature-Control-Library)
-- [TinyLogger](https://github.com/laxilef/TinyLogger)
-
-## Debug
-To display DEBUG messages you must enable debug in settings (switch is disabled by default).
-You can connect via Telnet to read messages. IP: ESP8266 ip, port: 23
-
 ___
 This project is tested with BrowserStack.

gulpfile.js

@@ -34,6 +34,10 @@ let paths = {
     {
       src: 'src_data/locales/*.json',
       dest: 'data/static/locales/'
+    },
+    {
+      src: 'src_data/*.json',
+      dest: 'data/static/'
     }
   ],
   static: [
@@ -44,6 +48,10 @@ let paths = {
     {
       src: 'src_data/images/*.*',
       dest: 'data/static/images/'
+    },
+    {
+      src: 'src_data/*.txt',
+      dest: 'data/static/'
     }
   ],
   pages: {

lib/BufferedWebServer/BufferedWebServer.h

@@ -12,16 +12,17 @@ public:
 
   template <class T>
   void send(int code, T contentType, const JsonVariantConst content, bool pretty = false) {
+    auto contentLength = pretty ? measureJsonPretty(content) : measureJson(content);
+
     #ifdef ARDUINO_ARCH_ESP8266
     if (!this->webServer->chunkedResponseModeStart(code, contentType)) {
       this->webServer->send(505, F("text/html"), F("HTTP1.1 required"));
       return;
     }
 
-    this->webServer->setContentLength(measureJson(content));
+    this->webServer->setContentLength(contentLength);
     #else
-    this->webServer->setContentLength(CONTENT_LENGTH_UNKNOWN);
-    this->webServer->sendHeader(F("Content-Length"), String(measureJson(content)));
+    this->webServer->setContentLength(contentLength);
     this->webServer->send(code, contentType, emptyString);
     #endif
 

lib/CustomOpenTherm/CustomOpenTherm.h

@@ -3,15 +3,15 @@
 
 class CustomOpenTherm : public OpenTherm {
 public:
-  typedef std::function<void()> YieldCallback;
+  typedef std::function<void(unsigned int)> DelayCallback;
   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* setYieldCallback(YieldCallback callback = nullptr) {
-    this->yieldCallback = callback;
+  CustomOpenTherm* setDelayCallback(DelayCallback callback = nullptr) {
+    this->delayCallback = callback;
 
     return this;
   }
@@ -28,76 +28,48 @@ public:
     return this;
   }
 
-  unsigned long sendRequest(unsigned long request, byte attempts = 5, byte _attempt = 0) {
-    _attempt++;
+  unsigned long sendRequest(unsigned long request) override {
+    this->sendRequestAttempt++;
 
     while (!this->isReady()) {
-      if (this->yieldCallback) {
-        this->yieldCallback();
-      } else {
-        ::yield();
+      if (this->delayCallback) {
+        this->delayCallback(150);
       }
 
       this->process();
     }
 
     if (this->beforeSendRequestCallback) {
-      this->beforeSendRequestCallback(request, _attempt);
+      this->beforeSendRequestCallback(request, this->sendRequestAttempt);
     }
 
-    unsigned long _response;
-    OpenThermResponseStatus _responseStatus = OpenThermResponseStatus::NONE;
-    if (!this->sendRequestAsync(request)) {
-      _response = 0;
-
-    } else {
-      while (true) {
-        this->process();
-
-        if (this->status == OpenThermStatus::READY || this->status == OpenThermStatus::DELAY) {
-          break;
-        } else if (this->yieldCallback) {
-          this->yieldCallback();
-        } else {
-          ::yield();
+    if (this->sendRequestAsync(request)) {
+      do {
+        if (this->delayCallback) {
+          this->delayCallback(150);
         }
-      }
 
-      _response = this->getLastResponse();
-      _responseStatus = this->getLastResponseStatus();
+        this->process();
+      } while (this->status != OpenThermStatus::READY && this->status != OpenThermStatus::DELAY);
     }
 
     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) {
-      return _response;
+    if (this->responseStatus == OpenThermResponseStatus::SUCCESS || this->responseStatus == OpenThermResponseStatus::INVALID) {
+      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;
@@ -136,10 +108,31 @@ public:
 
   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) {
@@ -151,7 +144,9 @@ public:
   }
 
 protected:
-  YieldCallback yieldCallback;
+  const uint8_t sendRequestMaxAttempts = 5;
+  uint8_t sendRequestAttempt = 0;
+  DelayCallback delayCallback;
   BeforeSendRequestCallback beforeSendRequestCallback;
   AfterSendRequestCallback afterSendRequestCallback;
 };

lib/NetworkUtils/NetworkMgr.h

@@ -148,10 +148,10 @@ namespace NetworkUtils {
       // set policy manual for work 13 ch
       {
         #ifdef ARDUINO_ARCH_ESP8266
-        wifi_country_t country = {"CN", 1, 13, WIFI_COUNTRY_POLICY_AUTO};
+        wifi_country_t country = {"JP", 1, 14, WIFI_COUNTRY_POLICY_MANUAL};
         wifi_set_country(&country);
         #elif defined(ARDUINO_ARCH_ESP32)
-        const wifi_country_t country = {"CN", 1, 13, CONFIG_ESP32_PHY_MAX_WIFI_TX_POWER, WIFI_COUNTRY_POLICY_AUTO};
+        const wifi_country_t country = {"JP", 1, 14, CONFIG_ESP32_PHY_MAX_WIFI_TX_POWER, WIFI_COUNTRY_POLICY_MANUAL};
         esp_wifi_set_country(&country);
         #endif
       }
@@ -384,7 +384,7 @@ namespace NetworkUtils {
   protected:
     const unsigned int reconnectInterval = 15000;
     const unsigned int failedConnectTimeout = 185000;
-    const unsigned int connectionTimeout = 5000;
+    const unsigned int connectionTimeout = 10000;
     const unsigned int resetConnectionTimeout = 90000;
 
     YieldCallback yieldCallback = []() {

lib/WebServerHandlers/StaticPage.h

@@ -1,8 +1,5 @@
 #include <FS.h>
 #include <detail/mimetable.h>
-#if defined(ARDUINO_ARCH_ESP32)
-  #include <detail/RequestHandlersImpl.h>
-#endif
 
 using namespace mime;
 
@@ -54,13 +51,6 @@ public:
       if (this->eTag.isEmpty()) {
         if (server._eTagFunction) {
           this->eTag = (server._eTagFunction)(*this->fs, this->path);
-
-        } else {
-          #if defined(ARDUINO_ARCH_ESP8266)
-          this->eTag = esp8266webserver::calcETag(*this->fs, this->path);
-          #elif defined(ARDUINO_ARCH_ESP32)
-          this->eTag = StaticRequestHandler::calcETag(*this->fs, this->path);
-          #endif
         }
       }
 

platformio.ini

@@ -14,14 +14,13 @@ extra_configs = secrets.default.ini
 core_dir = .pio
 
 [env]
-version = 1.5.0
+version = 1.5.5
 framework = arduino
 lib_deps = 
-	bblanchon/ArduinoJson@^7.1.0
+	bblanchon/ArduinoJson@^7.3.0
 	;ihormelnyk/OpenTherm Library@^1.1.5
-	https://github.com/ihormelnyk/opentherm_library#master
-	;arduino-libraries/ArduinoMqttClient@^0.1.8
-	https://github.com/Laxilef/ArduinoMqttClient.git#esp32_core_310
+	https://github.com/Laxilef/opentherm_library#esp32_timer
+	arduino-libraries/ArduinoMqttClient@^0.1.8
 	lennarthennigs/ESP Telnet@^2.2
 	gyverlibs/FileData@^1.0.2
 	gyverlibs/GyverPID@^3.3.2
@@ -85,13 +84,13 @@ 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.10-rc3/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 =
 	${env.lib_deps}
 	laxilef/ESP32Scheduler@^1.0.1
-nimble_lib = h2zero/NimBLE-Arduino@^1.4.2
+nimble_lib = h2zero/NimBLE-Arduino@^2.1.0
 lib_ignore = 
 extra_scripts = 
 	post:tools/esp32.py
@@ -211,6 +210,7 @@ build_flags =
 	${esp32_defaults.build_flags}
 	-D ARDUINO_USB_MODE=0
 	-D ARDUINO_USB_CDC_ON_BOOT=1
+	-D CONFIG_BT_NIMBLE_EXT_ADV=1
 	-D USE_BLE=1
 	-D DEFAULT_OT_IN_GPIO=35
 	-D DEFAULT_OT_OUT_GPIO=36
@@ -234,6 +234,7 @@ build_unflags =
 build_type = ${esp32_defaults.build_type}
 build_flags = 
 	${esp32_defaults.build_flags}
+	-D CONFIG_BT_NIMBLE_EXT_ADV=1
 	-D USE_BLE=1
 	-D DEFAULT_OT_IN_GPIO=8
 	-D DEFAULT_OT_OUT_GPIO=10
@@ -286,12 +287,40 @@ build_flags =
 
 [env:esp32_c6]
 platform = ${esp32_defaults.platform}
+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}
+extra_scripts = ${esp32_defaults.extra_scripts}
+build_unflags = 
+	-mtext-section-literals
+build_type = ${esp32_defaults.build_type}
+build_flags = 
+	${esp32_defaults.build_flags}
+	-D USE_BLE=1
+	-D DEFAULT_OT_IN_GPIO=15
+	-D DEFAULT_OT_OUT_GPIO=23
+	-D DEFAULT_SENSOR_OUTDOOR_GPIO=0
+	-D DEFAULT_SENSOR_INDOOR_GPIO=0
+	-D DEFAULT_STATUS_LED_GPIO=11
+	-D DEFAULT_OT_RX_LED_GPIO=10
+
+[env:otthing] 
+platform = ${esp32_defaults.platform}
+platform_packages = ${esp32_defaults.platform_packages}
+board = lolin_c3_mini
+board_build.partitions = ${esp32_defaults.board_build.partitions}
 lib_deps = 
 	${esp32_defaults.lib_deps}
-	;${esp32_defaults.nimble_lib}
+	${esp32_defaults.nimble_lib}
 lib_ignore = ${esp32_defaults.lib_ignore}
 extra_scripts = ${esp32_defaults.extra_scripts}
 build_unflags = 
@@ -299,5 +328,12 @@ build_unflags =
 build_type = ${esp32_defaults.build_type}
 build_flags = 
 	${esp32_defaults.build_flags}
-	; Currently the NimBLE library is incompatible with ESP32 C6
-	;-D USE_BLE=1
+	-D CONFIG_BT_NIMBLE_EXT_ADV=1
+	-D USE_BLE=1
+	-D DEFAULT_OT_IN_GPIO=3
+	-D DEFAULT_OT_OUT_GPIO=1
+;	-D DEFAULT_SENSOR_OUTDOOR_GPIO=0
+;	-D DEFAULT_SENSOR_INDOOR_GPIO=1
+	-D DEFAULT_STATUS_LED_GPIO=8
+	-D DEFAULT_OT_RX_LED_GPIO=2
+	-D OT_BYPASS_RELAY_GPIO=20

sdkconfig.defaults

@@ -0,0 +1,33 @@
+# Source:
+# https://github.com/pioarduino/platform-espressif32/tree/main/examples/espidf-arduino-h2zero-BLE_scan
+
+CONFIG_FREERTOS_HZ=1000
+CONFIG_MBEDTLS_PSK_MODES=y
+CONFIG_MBEDTLS_KEY_EXCHANGE_PSK=y
+CONFIG_BOOTLOADER_COMPILER_OPTIMIZATION_SIZE=y
+CONFIG_COMPILER_OPTIMIZATION_SIZE=y
+CONFIG_ESPTOOLPY_FLASHSIZE_4MB=y
+CONFIG_ESPTOOLPY_HEADER_FLASHSIZE_UPDATE=y
+
+#
+# BT config
+CONFIG_BT_ENABLED=y
+CONFIG_BTDM_CTRL_MODE_BLE_ONLY=y
+CONFIG_BTDM_CTRL_MODE_BR_EDR_ONLY=n
+CONFIG_BTDM_CTRL_MODE_BTDM=n
+CONFIG_BT_BLUEDROID_ENABLED=n
+CONFIG_BT_NIMBLE_ENABLED=y
+
+#
+# Arduino Configuration
+CONFIG_AUTOSTART_ARDUINO=y
+CONFIG_ARDUINO_SELECTIVE_COMPILATION=y
+CONFIG_ARDUINO_SELECTIVE_Zigbee=n
+CONFIG_ARDUINO_SELECTIVE_Matter=n
+CONFIG_ARDUINO_SELECTIVE_WiFiProv=n
+CONFIG_ARDUINO_SELECTIVE_BLE=n
+CONFIG_ARDUINO_SELECTIVE_BluetoothSerial=n
+CONFIG_ARDUINO_SELECTIVE_SimpleBLE=n
+CONFIG_ARDUINO_SELECTIVE_RainMaker=n
+CONFIG_ARDUINO_SELECTIVE_OpenThread=n
+CONFIG_ARDUINO_SELECTIVE_Insights=n

src/HaHelper.h

@@ -181,7 +181,7 @@ public:
     if (sSensor.type == Sensors::Type::BLUETOOTH) {
       // available state topic
       doc[FPSTR(HA_AVAILABILITY)][1][FPSTR(HA_TOPIC)] = doc[FPSTR(HA_STATE_TOPIC)];
-      doc[FPSTR(HA_AVAILABILITY)][1][FPSTR(HA_VALUE_TEMPLATE)] = AVAILABILITY_SENSOR_CONN;
+      doc[FPSTR(HA_AVAILABILITY)][1][FPSTR(HA_VALUE_TEMPLATE)] = JsonString(AVAILABILITY_SENSOR_CONN, true);
 
       String sName = sSensor.name;
       switch (vType) {
@@ -254,7 +254,7 @@ public:
     } else {
       // available state topic
       doc[FPSTR(HA_AVAILABILITY)][1][FPSTR(HA_TOPIC)] = doc[FPSTR(HA_STATE_TOPIC)];
-      doc[FPSTR(HA_AVAILABILITY)][1][FPSTR(HA_VALUE_TEMPLATE)] = AVAILABILITY_SENSOR_CONN;
+      doc[FPSTR(HA_AVAILABILITY)][1][FPSTR(HA_VALUE_TEMPLATE)] = JsonString(AVAILABILITY_SENSOR_CONN, true);
 
       doc[FPSTR(HA_NAME)] = sSensor.name;
       doc[FPSTR(HA_VALUE_TEMPLATE)] = F("{{ value_json.value|float(0)|round(2) }}");
@@ -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");
@@ -970,7 +970,7 @@ public:
     JsonDocument doc;
     doc[FPSTR(HA_AVAILABILITY)][0][FPSTR(HA_TOPIC)] = this->statusTopic.c_str();
     doc[FPSTR(HA_AVAILABILITY)][1][FPSTR(HA_TOPIC)] = this->stateTopic.c_str();
-    doc[FPSTR(HA_AVAILABILITY)][1][FPSTR(HA_VALUE_TEMPLATE)] = AVAILABILITY_OT_CONN;
+    doc[FPSTR(HA_AVAILABILITY)][1][FPSTR(HA_VALUE_TEMPLATE)] = JsonString(AVAILABILITY_OT_CONN, true);
     doc[FPSTR(HA_AVAILABILITY_MODE)] = F("all");
     doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
     doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectIdWithPrefix(F("heating"));
@@ -991,7 +991,7 @@ public:
     JsonDocument doc;
     doc[FPSTR(HA_AVAILABILITY)][0][FPSTR(HA_TOPIC)] = this->statusTopic.c_str();
     doc[FPSTR(HA_AVAILABILITY)][1][FPSTR(HA_TOPIC)] = this->stateTopic.c_str();
-    doc[FPSTR(HA_AVAILABILITY)][1][FPSTR(HA_VALUE_TEMPLATE)] = AVAILABILITY_OT_CONN;
+    doc[FPSTR(HA_AVAILABILITY)][1][FPSTR(HA_VALUE_TEMPLATE)] = JsonString(AVAILABILITY_OT_CONN, true);
     doc[FPSTR(HA_AVAILABILITY_MODE)] = F("all");
     doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
     doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectIdWithPrefix(F("dhw"));
@@ -1012,7 +1012,7 @@ public:
     JsonDocument doc;
     doc[FPSTR(HA_AVAILABILITY)][0][FPSTR(HA_TOPIC)] = this->statusTopic.c_str();
     doc[FPSTR(HA_AVAILABILITY)][1][FPSTR(HA_TOPIC)] = this->stateTopic.c_str();
-    doc[FPSTR(HA_AVAILABILITY)][1][FPSTR(HA_VALUE_TEMPLATE)] = AVAILABILITY_OT_CONN;
+    doc[FPSTR(HA_AVAILABILITY)][1][FPSTR(HA_VALUE_TEMPLATE)] = JsonString(AVAILABILITY_OT_CONN, true);
     doc[FPSTR(HA_AVAILABILITY_MODE)] = F("all");
     doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
     doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectIdWithPrefix(F("flame"));
@@ -1033,7 +1033,7 @@ public:
     JsonDocument doc;
     doc[FPSTR(HA_AVAILABILITY)][0][FPSTR(HA_TOPIC)] = this->statusTopic.c_str();
     doc[FPSTR(HA_AVAILABILITY)][1][FPSTR(HA_TOPIC)] = this->stateTopic.c_str();
-    doc[FPSTR(HA_AVAILABILITY)][1][FPSTR(HA_VALUE_TEMPLATE)] = AVAILABILITY_OT_CONN;
+    doc[FPSTR(HA_AVAILABILITY)][1][FPSTR(HA_VALUE_TEMPLATE)] = JsonString(AVAILABILITY_OT_CONN, true);
     doc[FPSTR(HA_AVAILABILITY_MODE)] = F("all");
     doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
     doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectIdWithPrefix(F("fault"));
@@ -1054,7 +1054,7 @@ public:
     JsonDocument doc;
     doc[FPSTR(HA_AVAILABILITY)][0][FPSTR(HA_TOPIC)] = this->statusTopic.c_str();
     doc[FPSTR(HA_AVAILABILITY)][1][FPSTR(HA_TOPIC)] = this->stateTopic.c_str();
-    doc[FPSTR(HA_AVAILABILITY)][1][FPSTR(HA_VALUE_TEMPLATE)] = AVAILABILITY_OT_CONN;
+    doc[FPSTR(HA_AVAILABILITY)][1][FPSTR(HA_VALUE_TEMPLATE)] = JsonString(AVAILABILITY_OT_CONN, true);
     doc[FPSTR(HA_AVAILABILITY_MODE)] = F("all");
     doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
     doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectIdWithPrefix(FPSTR(HA_ENTITY_CATEGORY_DIAGNOSTIC));
@@ -1215,7 +1215,7 @@ public:
 
     doc[FPSTR(HA_MIN_TEMP)] = minTemp;
     doc[FPSTR(HA_MAX_TEMP)] = maxTemp;
-    doc[FPSTR(HA_TEMP_STEP)] = 0.5f;
+    doc[FPSTR(HA_TEMP_STEP)] = 0.1f;
     doc[FPSTR(HA_EXPIRE_AFTER)] = this->expireAfter;
     doc.shrinkToFit();
 

src/MainTask.h

@@ -38,6 +38,7 @@ protected:
   unsigned long heatingDisabledTime = 0;
   PumpStartReason extPumpStartReason = PumpStartReason::NONE;
   unsigned long externalPumpStartTime = 0;
+  bool ntpStarted = false;
   bool telnetStarted = false;
   bool emergencyDetected = false;
   unsigned long emergencyFlipTime = 0;
@@ -109,6 +110,16 @@ protected:
     }
 
     if (network->isConnected()) {
+      if (!this->ntpStarted) {
+        if (strlen(settings.system.ntp.server)) {
+          configTime(0, 0, settings.system.ntp.server);
+          setenv("TZ", settings.system.ntp.timezone, 1);
+          tzset();
+
+          this->ntpStarted = true;
+        }
+      }
+
       if (!this->telnetStarted && telnetStream != nullptr) {
         telnetStream->begin(23, false);
         this->telnetStarted = true;
@@ -124,6 +135,10 @@ protected:
       Sensors::setConnectionStatusByType(Sensors::Type::MANUAL, !settings.mqtt.enabled || vars.mqtt.connected, false);
 
     } else {
+      if (this->ntpStarted) {
+        this->ntpStarted = false;
+      }
+
       if (this->telnetStarted) {
         telnetStream->stop();
         this->telnetStarted = false;
@@ -181,6 +196,7 @@ protected:
     // critical heap
     if (!vars.states.restarting && (freeHeap < 2048 || maxFreeBlockHeap < 2048)) {
       this->restartSignalReceivedTime = millis();
+      this->restartSignalReceived = true;
       vars.states.restarting = true;
     }
 
@@ -229,7 +245,7 @@ protected:
         emergencyFlags |= 0b00000010;
       }
       
-      if (settings.opentherm.nativeHeatingControl) {
+      if (settings.opentherm.options.nativeHeatingControl) {
         emergencyFlags |= 0b00000100;
       }
     }

src/MqttTask.h

@@ -70,8 +70,8 @@ public:
     this->prevPubVarsTime = 0;
   }
 
-  inline void rebuildHaEntity(uint8_t sensorId, Sensors::Settings& prevSettings) {
-    this->queueRebuildingHaEntities[sensorId] = prevSettings;
+  inline void reconfigureSensor(uint8_t sensorId, Sensors::Settings& prevSettings) {
+    this->queueReconfigureSensors[sensorId] = prevSettings;
   }
 
 protected:
@@ -81,7 +81,7 @@ protected:
   MqttWriter* writer = nullptr;
   UnitSystem currentUnitSystem = UnitSystem::METRIC;
   bool currentHomeAssistantDiscovery = false;
-  std::unordered_map<uint8_t, Sensors::Settings> queueRebuildingHaEntities;
+  std::unordered_map<uint8_t, Sensors::Settings> queueReconfigureSensors;
   unsigned short readyForSendTime = 30000;
   unsigned long lastReconnectTime = 0;
   unsigned long connectedTime = 0;
@@ -120,7 +120,6 @@ protected:
     #endif
 
     // client settings
-    this->client->setKeepAliveInterval(15000);
     this->client->setTxPayloadSize(256);
     #ifdef ARDUINO_ARCH_ESP8266
     this->client->setConnectionTimeout(1000);
@@ -197,14 +196,14 @@ protected:
 
       this->haHelper->setDevicePrefix(settings.mqtt.prefix);
       this->haHelper->updateCachedTopics();
+
       this->client->stop();
+      this->client->setKeepAliveInterval(settings.mqtt.interval * 10000);
       this->client->setId(networkSettings.hostname);
       this->client->setUsernamePassword(settings.mqtt.user, settings.mqtt.password);
-
       this->client->beginWill(this->haHelper->getDeviceTopic(F("status")).c_str(), 7, true, 1);
       this->client->print(F("offline"));
       this->client->endWill();
-
       this->client->connect(settings.mqtt.server, settings.mqtt.port);
       this->lastReconnectTime = millis();
       this->yield();
@@ -277,8 +276,8 @@ protected:
         this->publishNonStaticHaEntities();
       }
 
-
-      for (auto& [sensorId, prevSettings] : this->queueRebuildingHaEntities) {
+      // rebuilding ha configs
+      for (auto& [sensorId, prevSettings] : this->queueReconfigureSensors) {
         Log.sinfoln(FPSTR(L_MQTT_HA), F("Rebuilding config for sensor #%hhu '%s'"), sensorId, prevSettings.name);
 
         // delete old config
@@ -298,15 +297,6 @@ protected:
               this->haHelper->deleteSignalQualityDynamicSensor(prevSettings);
               this->haHelper->deleteDynamicSensor(prevSettings, Sensors::ValueType::TEMPERATURE);
               break;
-            
-            case Sensors::Type::MANUAL:
-              this->client->unsubscribe(
-                this->haHelper->getDeviceTopic(
-                  F("sensors"),
-                  Sensors::makeObjectId(prevSettings.name).c_str(),
-                  F("set")
-                ).c_str()
-              );
 
             default:
               this->haHelper->deleteDynamicSensor(prevSettings, Sensors::ValueType::PRIMARY);
@@ -334,26 +324,51 @@ protected:
             this->haHelper->publishSignalQualityDynamicSensor(sSettings, false);
             this->haHelper->publishDynamicSensor(sSettings, Sensors::ValueType::TEMPERATURE, settings.system.unitSystem);
             break;
-
-          case Sensors::Type::MANUAL: 
-            this->client->subscribe(
-              this->haHelper->getDeviceTopic(
-                F("sensors"),
-                Sensors::makeObjectId(prevSettings.name).c_str(),
-                F("set")
-              ).c_str()
-            );
           
           default:
             this->haHelper->publishDynamicSensor(sSettings, Sensors::ValueType::PRIMARY, settings.system.unitSystem);
         }
       }
-      this->queueRebuildingHaEntities.clear();
 
     } else if (this->currentHomeAssistantDiscovery) {
       this->currentHomeAssistantDiscovery = false;
     }
 
+    // reconfigure manual sensors
+    for (auto& [sensorId, prevSettings] : this->queueReconfigureSensors) {
+      // unsubscribe from old topic
+      if (strlen(prevSettings.name) && prevSettings.enabled) {
+        if (prevSettings.type == Sensors::Type::MANUAL) {
+          this->client->unsubscribe(
+            this->haHelper->getDeviceTopic(
+              F("sensors"),
+              Sensors::makeObjectId(prevSettings.name).c_str(),
+              F("set")
+            ).c_str()
+          );
+        }
+      }
+
+      if (!Sensors::hasEnabledAndValid(sensorId)) {
+        continue;
+      }
+
+      // subscribe to new topic
+      auto& sSettings = Sensors::settings[sensorId];
+      if (sSettings.type == Sensors::Type::MANUAL) {
+        this->client->subscribe(
+          this->haHelper->getDeviceTopic(
+            F("sensors"),
+            Sensors::makeObjectId(sSettings.name).c_str(),
+            F("set")
+          ).c_str()
+        );
+      }
+    }
+
+    // clear queue
+    this->queueReconfigureSensors.clear();
+
     if (this->newConnection) {
       this->newConnection = false;
     }
@@ -367,6 +382,26 @@ protected:
 
     this->client->subscribe(this->haHelper->getDeviceTopic(F("settings/set")).c_str());
     this->client->subscribe(this->haHelper->getDeviceTopic(F("state/set")).c_str());
+
+    // subscribe to manual sensors
+    for (uint8_t sensorId = 0; sensorId <= Sensors::getMaxSensorId(); sensorId++) {
+      if (!Sensors::hasEnabledAndValid(sensorId)) {
+        continue;
+      }
+
+      auto& sSettings = Sensors::settings[sensorId];
+      if (sSettings.type != Sensors::Type::MANUAL) {
+        continue;
+      }
+
+      this->client->subscribe(
+        this->haHelper->getDeviceTopic(
+          F("sensors"),
+          Sensors::makeObjectId(sSettings.name).c_str(),
+          F("set")
+        ).c_str()
+      );
+    }
   }
 
   void onDisconnect() {
@@ -514,15 +549,6 @@ protected:
           this->haHelper->publishSignalQualityDynamicSensor(sSettings, false);
           this->haHelper->publishDynamicSensor(sSettings, Sensors::ValueType::TEMPERATURE, settings.system.unitSystem);
           break;
-
-        case Sensors::Type::MANUAL:
-          this->client->subscribe(
-            this->haHelper->getDeviceTopic(
-              F("sensors"),
-              Sensors::makeObjectId(sSettings.name).c_str(),
-              F("set")
-            ).c_str()
-          );
         
         default:
           this->haHelper->publishDynamicSensor(sSettings, Sensors::ValueType::PRIMARY, settings.system.unitSystem);
@@ -532,13 +558,13 @@ protected:
 
   bool publishNonStaticHaEntities(bool force = false) {
     static byte _heatingMinTemp, _heatingMaxTemp, _dhwMinTemp, _dhwMaxTemp = 0;
-    static bool _indoorTempControl, _dhwPresent = false;
+    static bool _indoorTempControl, _dhwSupport = false;
 
     bool published = false;
-    if (force || _dhwPresent != settings.opentherm.dhwPresent) {
-      _dhwPresent = settings.opentherm.dhwPresent;
+    if (force || _dhwSupport != settings.opentherm.options.dhwSupport) {
+      _dhwSupport = settings.opentherm.options.dhwSupport;
 
-      if (_dhwPresent) {
+      if (_dhwSupport) {
         this->haHelper->publishInputDhwMinTemp(settings.system.unitSystem);
         this->haHelper->publishInputDhwMaxTemp(settings.system.unitSystem);
         this->haHelper->publishDhwState();
@@ -569,7 +595,7 @@ protected:
       published = true;
     }
 
-    if (_dhwPresent && (force || _dhwMinTemp != settings.dhw.minTemp || _dhwMaxTemp != settings.dhw.maxTemp)) {
+    if (_dhwSupport && (force || _dhwMinTemp != settings.dhw.minTemp || _dhwMaxTemp != settings.dhw.maxTemp)) {
       _dhwMinTemp = settings.dhw.minTemp;
       _dhwMaxTemp = settings.dhw.maxTemp;
 

src/OpenThermTask.h

@@ -10,17 +10,21 @@ public:
   }
 
 protected:
-  const unsigned short readyTime = 60000;
-  const unsigned short heatingSetTempInterval = 60000;
-  const unsigned short dhwSetTempInterval = 60000;
-  const unsigned short ch2SetTempInterval = 60000;
-  const unsigned int initializingInterval = 3600000;
+  const unsigned short readyTime = 60000u;
+  const unsigned int resetBusInterval = 120000u;
+  const unsigned short heatingSetTempInterval = 60000u;
+  const unsigned short dhwSetTempInterval = 60000u;
+  const unsigned short ch2SetTempInterval = 60000u;
+  const unsigned int initializingInterval = 3600000u;
 
   CustomOpenTherm* instance = nullptr;
   unsigned long instanceCreatedTime = 0;
   byte instanceInGpio = 0;
   byte instanceOutGpio = 0;
   bool initialized = false;
+  unsigned long connectedTime = 0;
+  unsigned long disconnectedTime = 0;
+  unsigned long resetBusTime = 0;
   unsigned long initializedTime = 0;
   unsigned long lastSuccessResponse = 0;
   unsigned long prevUpdateNonEssentialVars = 0;
@@ -69,6 +73,11 @@ protected:
       return;
     }
 
+    #ifdef OT_BYPASS_RELAY_GPIO
+    pinMode(OT_BYPASS_RELAY_GPIO, OUTPUT);
+    digitalWrite(OT_BYPASS_RELAY_GPIO, true);
+    #endif
+
     // create instance
     this->instance = new CustomOpenTherm(settings.opentherm.inGpio, settings.opentherm.outGpio);
 
@@ -76,6 +85,7 @@ protected:
     this->instanceCreatedTime = millis();
     this->instanceInGpio = settings.opentherm.inGpio;
     this->instanceOutGpio = settings.opentherm.outGpio;
+    this->resetBusTime = millis();
     this->initialized = false;
 
     Log.sinfoln(FPSTR(L_OT), F("Started. GPIO IN: %hhu, GPIO OUT: %hhu"), settings.opentherm.inGpio, settings.opentherm.outGpio);
@@ -83,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"),
-        CustomOpenTherm::getDataID(request), request, response, attempt, CustomOpenTherm::statusToString(status)
+        F("ID: %4d   Request: %8lx   Response: %8lx   Msg type: %s   Attempt: %2d   Status: %s"),
+        CustomOpenTherm::getDataID(request),
+        request,
+        response,
+        CustomOpenTherm::getResponseMessageTypeString(response),
+        attempt,
+        CustomOpenTherm::statusToString(status)
       );
 
       if (status == OpenThermResponseStatus::SUCCESS) {
@@ -98,11 +113,9 @@ protected:
       }
     });
 
-    this->instance->setYieldCallback([this]() {
-      this->delay(25);
+    this->instance->setDelayCallback([this](unsigned int time) {
+      this->delay(time);
     });
-
-    this->instance->begin();
   }
 
   void loop() {
@@ -128,6 +141,14 @@ protected:
     if (this->instance == nullptr) {
       this->delay(5000);
       return;
+
+    } else if (this->instance->status == OpenThermStatus::NOT_INITIALIZED) {
+      if (!this->instance->begin()) {
+        Log.swarningln(FPSTR(L_OT), F("Failed begin"));
+
+        this->delay(5000);
+        return;
+      }
     }
 
     // RX LED GPIO setup
@@ -153,18 +174,18 @@ protected:
       && !vars.master.heating.blocking;
 
     // DHW settings
-    vars.master.dhw.enabled = settings.opentherm.dhwPresent && settings.dhw.enabled;
+    vars.master.dhw.enabled = settings.opentherm.options.dhwSupport && settings.dhw.enabled;
     vars.master.dhw.targetTemp = settings.dhw.target;
 
     // CH2 settings
-    vars.master.ch2.enabled = settings.opentherm.heatingCh2Enabled
-      || (settings.opentherm.heatingCh1ToCh2 && vars.master.heating.enabled)
-      || (settings.opentherm.dhwToCh2 && settings.opentherm.dhwPresent && settings.dhw.enabled);
+    vars.master.ch2.enabled = settings.opentherm.options.ch2AlwaysEnabled
+      || (settings.opentherm.options.heatingToCh2 && vars.master.heating.enabled)
+      || (settings.opentherm.options.dhwToCh2 && settings.opentherm.options.dhwSupport && settings.dhw.enabled);
 
-    if (settings.opentherm.heatingCh1ToCh2) {
+    if (settings.opentherm.options.heatingToCh2) {
       vars.master.ch2.targetTemp = vars.master.heating.setpointTemp;
 
-    } else if (settings.opentherm.dhwToCh2) {
+    } else if (settings.opentherm.options.dhwToCh2) {
       vars.master.ch2.targetTemp = vars.master.dhw.targetTemp;
     }
 
@@ -174,18 +195,24 @@ protected:
 
     // Immergas fix
     // https://arduino.ru/forum/programmirovanie/termostat-opentherm-na-esp8266?page=15#comment-649392
-    if (settings.opentherm.immergasFix) {
+    if (settings.opentherm.options.immergasFix) {
       statusLb = 0xCA;
     }
 
+    // Summer/winter mode
+    bool summerWinterMode = settings.opentherm.options.summerWinterMode;
+    if (settings.opentherm.options.heatingStateToSummerWinterMode) {
+      summerWinterMode = vars.master.heating.enabled == summerWinterMode;
+    }
+
     unsigned long response = this->instance->setBoilerStatus(
       vars.master.heating.enabled,
       vars.master.dhw.enabled,
-      false,
-      settings.opentherm.nativeHeatingControl,
+      settings.opentherm.options.coolingSupport,
+      settings.opentherm.options.nativeHeatingControl,
       vars.master.ch2.enabled,
-      settings.opentherm.summerWinterMode,
-      settings.opentherm.dhwBlocking,
+      summerWinterMode,
+      settings.opentherm.options.dhwBlocking,
       statusLb
     );
 
@@ -195,15 +222,49 @@ 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.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; 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
+      );
     }
 
-    if (!vars.slave.connected && millis() - this->lastSuccessResponse < 1150) {
-      Log.sinfoln(FPSTR(L_OT), F("Connected"));
+    // 5 request retries
+    // 1000ms maximum response waiting time
+    // 100ms delay between requests
+    // +15%
+    // 5 * (1000 + 100) * 1.15 = 6325 ms
+    if (!vars.slave.connected && millis() - this->lastSuccessResponse < 6325) {
+      Log.sinfoln(
+        FPSTR(L_OT),
+        F("Connected, downtime: %lu s."),
+        (millis() - this->disconnectedTime) / 1000
+      );
       
+      this->connectedTime = millis();
       vars.slave.connected = true;
       
-    } else if (vars.slave.connected && millis() - this->lastSuccessResponse > 1150) {
-      Log.swarningln(FPSTR(L_OT), F("Disconnected"));
+    } else if (vars.slave.connected && millis() - this->lastSuccessResponse > 6325) {
+      Log.swarningln(
+        FPSTR(L_OT),
+        F("Disconnected, uptime: %lu s."),
+        (millis() - this->connectedTime) / 1000  
+      );
 
       // Mark sensors as disconnected
       Sensors::setConnectionStatusByType(Sensors::Type::OT_OUTDOOR_TEMP, false);
@@ -226,7 +287,17 @@ 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;
     }
 
@@ -242,6 +313,20 @@ protected:
       vars.slave.diag.active = false;
       vars.slave.diag.code = 0;
 
+      // reset bus
+      if (millis() - this->disconnectedTime > this->resetBusInterval) {
+        if (millis() - this->resetBusTime > this->resetBusInterval) {
+          Log.sinfoln(FPSTR(L_OT), F("Reset bus..."));
+
+          this->instance->end();
+          this->instance->status = OpenThermStatus::NOT_INITIALIZED;
+
+          digitalWrite(this->instanceOutGpio, LOW);
+          this->resetBusTime = millis();
+          this->delay(5000);
+        }
+      }
+
       return;
     }
 
@@ -264,33 +349,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.dhwPresent ? CustomOpenTherm::isHotWaterActive(response) : false;
-    vars.slave.flame = CustomOpenTherm::isFlameOn(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; fault: %hhu; diag: %hhu"),
-      vars.slave.heating.active, vars.slave.dhw.active,
-      vars.slave.flame, 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) {
-          settings.opentherm.maxModulation = vars.slave.modulation.min;
+        if (settings.heating.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%%"),
-            settings.opentherm.maxModulation
+            FPSTR(L_SETTINGS_HEATING), F("Updated min modulation: %hhu%%"),
+            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
           );
         }
 
@@ -309,32 +421,9 @@ protected:
         Log.swarningln(FPSTR(L_OT), F("Failed receive min modulation and max power"));
       }
 
-      if (!vars.master.heating.enabled && settings.opentherm.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.dhwPresent && settings.opentherm.getMinMaxTemp) {
+      if (settings.opentherm.options.dhwSupport && settings.opentherm.options.getMinMaxTemp) {
         if (this->updateMinMaxDhwTemp()) {
           uint8_t convertedMinTemp = convertTemp(
             vars.slave.dhw.minTemp,
@@ -380,7 +469,7 @@ protected:
 
 
       // Get heating min/max temp
-      if (settings.opentherm.getMinMaxTemp) {
+      if (settings.opentherm.options.getMinMaxTemp) {
         if (this->updateMinMaxHeatingTemp()) {
           uint8_t convertedMinTemp = convertTemp(
             vars.slave.heating.minTemp,
@@ -456,9 +545,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 (
@@ -520,7 +760,7 @@ protected:
     }
 
     // Update DHW temp
-    if (settings.opentherm.dhwPresent && Sensors::getAmountByType(Sensors::Type::OT_DHW_TEMP, true)) {
+    if (settings.opentherm.options.dhwSupport && Sensors::getAmountByType(Sensors::Type::OT_DHW_TEMP, true)) {
       bool result = this->updateDhwTemp();
 
       if (result) {
@@ -546,7 +786,7 @@ protected:
     }
 
     // Update DHW temp 2
-    if (settings.opentherm.dhwPresent && Sensors::getAmountByType(Sensors::Type::OT_DHW_TEMP2, true)) {
+    if (settings.opentherm.options.dhwSupport && Sensors::getAmountByType(Sensors::Type::OT_DHW_TEMP2, true)) {
       if (this->updateDhwTemp2()) {
         float convertedDhwTemp2 = convertTemp(
           vars.slave.dhw.currentTemp2,
@@ -570,7 +810,7 @@ protected:
     }
 
     // Update DHW flow rate
-    if (settings.opentherm.dhwPresent && Sensors::getAmountByType(Sensors::Type::OT_DHW_FLOW_RATE, true)) {
+    if (settings.opentherm.options.dhwSupport && Sensors::getAmountByType(Sensors::Type::OT_DHW_FLOW_RATE, true)) {
       if (this->updateDhwFlowRate()) {
         float convertedDhwFlowRate = convertVolume(
           vars.slave.dhw.flowRate,
@@ -643,7 +883,7 @@ protected:
 
     // Update CH2 temp
     if (Sensors::getAmountByType(Sensors::Type::OT_CH2_TEMP, true)) {
-      if (vars.master.ch2.enabled && !settings.opentherm.nativeHeatingControl) {
+      if (vars.master.ch2.enabled && !settings.opentherm.options.nativeHeatingControl) {
         if (this->updateCh2Temp()) {
           float convertedCh2Temp = convertTemp(
             vars.slave.ch2.currentTemp,
@@ -942,7 +1182,7 @@ protected:
     }
 
     // Native heating control
-    if (settings.opentherm.nativeHeatingControl) {
+    if (settings.opentherm.options.nativeHeatingControl) {
       // Converted current indoor temp
       float convertedTemp = convertTemp(vars.master.heating.indoorTemp, settings.system.unitSystem, settings.opentherm.unitSystem);
 
@@ -958,7 +1198,7 @@ protected:
       }
 
       // Set current CH2 indoor temp
-      if (settings.opentherm.heatingCh1ToCh2) {
+      if (settings.opentherm.options.heatingToCh2) {
         if (this->setRoomTempCh2(convertedTemp)) {
           Log.sinfoln(
             FPSTR(L_OT_HEATING), F("Set current CH2 indoor temp: %.2f (converted: %.2f, response: %.2f)"),
@@ -990,7 +1230,7 @@ protected:
       }
 
       // Set target CH2 temp
-      if (settings.opentherm.heatingCh1ToCh2 && this->needSetCh2Temp(convertedTemp)) {
+      if (settings.opentherm.options.heatingToCh2 && this->needSetCh2Temp(convertedTemp)) {
         if (this->setRoomSetpointCh2(convertedTemp)) {
           this->ch2SetTempTime = millis();
 
@@ -1006,20 +1246,25 @@ protected:
     }
 
     // Normal heating control
-    if (!settings.opentherm.nativeHeatingControl && vars.master.heating.enabled) {
+    if (!settings.opentherm.options.nativeHeatingControl && vars.master.heating.enabled) {
       // Converted target heating temp
       float convertedTemp = convertTemp(vars.master.heating.setpointTemp, settings.system.unitSystem, settings.opentherm.unitSystem);
 
       if (this->needSetHeatingTemp(convertedTemp)) {
         // Set max heating temp
-        if (this->setMaxHeatingTemp(convertedTemp)) {
-          Log.sinfoln(
-            FPSTR(L_OT_HEATING), F("Set max heating temp: %.2f (converted: %.2f)"),
-            vars.master.heating.setpointTemp, convertedTemp
-          );
+        if (settings.opentherm.options.maxTempSyncWithTargetTemp) {
+          if (this->setMaxHeatingTemp(convertedTemp)) {
+            Log.sinfoln(
+              FPSTR(L_OT_HEATING), F("Set max heating temp: %.2f (converted: %.2f)"),
+              vars.master.heating.setpointTemp, convertedTemp
+            );
 
-        } else {
-          Log.swarningln(FPSTR(L_OT_HEATING), F("Failed set max heating temp"));
+          } else {
+            Log.swarningln(
+              FPSTR(L_OT_HEATING), F("Failed set max heating temp: %.2f (converted: %.2f)"),
+              vars.master.heating.setpointTemp, convertedTemp
+            );
+          }
         }
 
         // Set target heating temp
@@ -1038,8 +1283,8 @@ protected:
     }
 
     // Set CH2 temp
-    if (!settings.opentherm.nativeHeatingControl && vars.master.ch2.enabled) {
-      if (settings.opentherm.heatingCh1ToCh2 || settings.opentherm.dhwToCh2) {
+    if (!settings.opentherm.options.nativeHeatingControl && vars.master.ch2.enabled) {
+      if (settings.opentherm.options.heatingToCh2 || settings.opentherm.options.dhwToCh2) {
         // Converted target CH2 temp
         float convertedTemp = convertTemp(
           vars.master.ch2.targetTemp,
@@ -1127,17 +1372,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() {
@@ -1176,6 +1421,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);
@@ -1298,7 +1601,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,
@@ -1588,6 +1891,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/PortalTask.h

@@ -1,10 +1,12 @@
 //#define PORTAL_CACHE "max-age=86400"
 #define PORTAL_CACHE nullptr
 #ifdef ARDUINO_ARCH_ESP8266
+#include <ESP8266mDNS.h>
 #include <ESP8266WebServer.h>
 #include <Updater.h>
 using WebServer = ESP8266WebServer;
 #else
+#include <ESPmDNS.h>
 #include <WebServer.h>
 #include <Update.h>
 #endif
@@ -53,7 +55,7 @@ protected:
   bool webServerEnabled = false;
   bool dnsServerEnabled = false;
   unsigned long webServerChangeState = 0;
-  unsigned long dnsServerChangeState = 0;
+  bool mDnsState = false;
 
   #if defined(ARDUINO_ARCH_ESP32)
   const char* getTaskName() override {
@@ -616,7 +618,7 @@ protected:
       }
 
       if (changed) {
-        tMqtt->rebuildHaEntity(sensorId, prevSettings);
+        tMqtt->reconfigureSensor(sensorId, prevSettings);
         fsSensorsSettings.update();
       }
     });
@@ -858,6 +860,7 @@ protected:
       }
     });
 
+    this->webServer->serveStatic("/robots.txt", LittleFS, "/static/robots.txt", PORTAL_CACHE);
     this->webServer->serveStatic("/favicon.ico", LittleFS, "/static/images/favicon.ico", PORTAL_CACHE);
     this->webServer->serveStatic("/static", LittleFS, "/static", PORTAL_CACHE);
   }
@@ -872,6 +875,16 @@ protected:
       this->startWebServer();
       Log.straceln(FPSTR(L_PORTAL_WEBSERVER), F("Started: AP up or STA connected"));
 
+      // Enabling mDNS
+      if (!this->mDnsState && settings.portal.mdns) {
+        if (MDNS.begin(networkSettings.hostname)) {
+          MDNS.addService("http", "tcp", 80);
+          this->mDnsState = true;
+
+          Log.straceln(FPSTR(L_PORTAL_WEBSERVER), F("mDNS enabled and service added"));
+        }
+      }
+
       #ifdef ARDUINO_ARCH_ESP8266
       ::optimistic_yield(1000);
       #endif
@@ -880,13 +893,29 @@ protected:
       this->stopWebServer();
       Log.straceln(FPSTR(L_PORTAL_WEBSERVER), F("Stopped: AP and STA down"));
 
+      // Disabling mDNS
+      if (this->mDnsState) {
+        MDNS.end();
+        this->mDnsState = false;
+
+        Log.straceln(FPSTR(L_PORTAL_WEBSERVER), F("mDNS disabled"));
+      }
+
       #ifdef ARDUINO_ARCH_ESP8266
       ::optimistic_yield(1000);
       #endif
     }
 
+    // Disabling mDNS if disabled in settings
+    if (this->mDnsState && !settings.portal.mdns) {
+      MDNS.end();
+      this->mDnsState = false;
+
+      Log.straceln(FPSTR(L_PORTAL_WEBSERVER), F("mDNS disabled"));
+    }
+
     // dns server
-    if (!this->stateDnsServer() && this->stateWebServer() && network->isApEnabled() && network->hasApClients() && millis() - this->dnsServerChangeState >= this->changeStateInterval) {
+    if (!this->stateDnsServer() && !network->isConnected() && network->isApEnabled() && this->stateWebServer()) {
       this->startDnsServer();
       Log.straceln(FPSTR(L_PORTAL_DNSSERVER), F("Started: AP up"));
       
@@ -894,9 +923,9 @@ protected:
       ::optimistic_yield(1000);
       #endif
 
-    } else if (this->stateDnsServer() && (!network->isApEnabled() || !this->stateWebServer())) {
+    } else if (this->stateDnsServer() && (network->isConnected() || !network->isApEnabled() || !this->stateWebServer())) {
       this->stopDnsServer();
-      Log.straceln(FPSTR(L_PORTAL_DNSSERVER), F("Stopped: AP down"));
+      Log.straceln(FPSTR(L_PORTAL_DNSSERVER), F("Stopped: AP down/STA connected"));
 
       #ifdef ARDUINO_ARCH_ESP8266
       ::optimistic_yield(1000);
@@ -1006,7 +1035,6 @@ protected:
 
     this->dnsServer->start(53, "*", network->getApIp());
     this->dnsServerEnabled = true;
-    this->dnsServerChangeState = millis();
   }
 
   void stopDnsServer() {
@@ -1017,6 +1045,5 @@ protected:
     //this->dnsServer->processNextRequest();
     this->dnsServer->stop();
     this->dnsServerEnabled = false;
-    this->dnsServerChangeState = millis();
   }
 };

src/RegulatorTask.h

@@ -39,7 +39,7 @@ protected:
     this->indoorSensorsConnected = Sensors::existsConnectedSensorsByPurpose(Sensors::Purpose::INDOOR_TEMP);
     //this->outdoorSensorsConnected = Sensors::existsConnectedSensorsByPurpose(Sensors::Purpose::OUTDOOR_TEMP);
 
-    if (settings.equitherm.enabled || settings.pid.enabled || settings.opentherm.nativeHeatingControl) {
+    if (settings.equitherm.enabled || settings.pid.enabled || settings.opentherm.options.nativeHeatingControl) {
       vars.master.heating.indoorTempControl = true;
       vars.master.heating.minTemp = THERMOSTAT_INDOOR_MIN_TEMP;
       vars.master.heating.maxTemp = THERMOSTAT_INDOOR_MAX_TEMP;
@@ -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,
@@ -93,7 +93,7 @@ protected:
   void hysteresis() {
     bool useHyst = false;
     if (settings.heating.hysteresis > 0.01f && this->indoorSensorsConnected) {
-      useHyst = settings.equitherm.enabled || settings.pid.enabled || settings.opentherm.nativeHeatingControl;
+      useHyst = settings.equitherm.enabled || settings.pid.enabled || settings.opentherm.options.nativeHeatingControl;
     }
 
     if (useHyst) {
@@ -110,13 +110,13 @@ protected:
   }
 
   inline float getHeatingMinSetpointTemp() {
-    return settings.opentherm.nativeHeatingControl
+    return settings.opentherm.options.nativeHeatingControl
       ? vars.master.heating.minTemp
       : settings.heating.minTemp;
   }
 
   inline float getHeatingMaxSetpointTemp() {
-    return settings.opentherm.nativeHeatingControl
+    return settings.opentherm.options.nativeHeatingControl
       ? vars.master.heating.maxTemp
       : settings.heating.maxTemp;
   }
@@ -137,7 +137,7 @@ protected:
     if (vars.emergency.state) {
       return settings.emergency.target;
 
-    } else if (settings.opentherm.nativeHeatingControl) {
+    } else if (settings.opentherm.options.nativeHeatingControl) {
       return settings.heating.target;
 
     } else if (!settings.equitherm.enabled && !settings.pid.enabled) {
@@ -196,6 +196,7 @@ protected:
       //if (vars.parameters.heatingEnabled) {
       if (settings.heating.enabled && this->indoorSensorsConnected) {
         pidRegulator.Kp = settings.heating.turbo ? 0.0f : settings.pid.p_factor;
+        pidRegulator.Ki = settings.pid.i_factor;
         pidRegulator.Kd = settings.pid.d_factor;
 
         pidRegulator.setLimits(settings.pid.minTemp, settings.pid.maxTemp);
@@ -203,12 +204,22 @@ protected:
         pidRegulator.input = vars.master.heating.indoorTemp;
         pidRegulator.setpoint = settings.heating.target;
 
-        if (fabsf(pidRegulator.Ki - settings.pid.i_factor) >= 0.0001f) {
+        /*if (fabsf(pidRegulator.Ki - settings.pid.i_factor) >= 0.0001f) {
           pidRegulator.Ki = settings.pid.i_factor;
           pidRegulator.integral = 0.0f;
           pidRegulator.getResultNow();
 
           Log.sinfoln(FPSTR(L_REGULATOR_PID), F("Integral sum has been reset"));
+        }*/
+
+        float error = pidRegulator.setpoint - pidRegulator.input;
+        bool hasDeadband = (error > -(settings.pid.deadband.thresholdHigh))
+          && (error < settings.pid.deadband.thresholdLow);
+
+        if (hasDeadband) {
+          pidRegulator.Kp *= settings.pid.deadband.p_multiplier;
+          pidRegulator.Ki *= settings.pid.deadband.i_multiplier;
+          pidRegulator.Kd *= settings.pid.deadband.d_multiplier;
         }
 
         float pidResult = pidRegulator.getResultTimer();

src/Sensors.h

@@ -25,6 +25,15 @@ public:
     OT_SOLAR_COLLECTOR_TEMP = 16,
     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,
@@ -46,6 +55,7 @@ public:
     EXHAUST_TEMP          = 7,
     MODULATION_LEVEL      = 8,
 
+    NUMBER                = 247,
     POWER_FACTOR          = 248,
     POWER                 = 249,
     FAN_SPEED             = 250,

src/SensorsTask.h

@@ -31,12 +31,19 @@ protected:
   const unsigned short dallasSearchInterval = 60000;
   const unsigned short dallasPollingInterval = 10000;
   const unsigned short globalPollingInterval = 15000;
+  #if USE_BLE
+  const unsigned int bleSetDtInterval = 7200000;
+  #endif
 
   std::unordered_map<uint8_t, OneWire> owInstances;
   std::unordered_map<uint8_t, DallasTemperature> dallasInstances;
   std::unordered_map<uint8_t, unsigned long> dallasSearchTime;
   std::unordered_map<uint8_t, bool> dallasPolling;
   std::unordered_map<uint8_t, unsigned long> dallasLastPollingTime;
+  #if USE_BLE
+  std::unordered_map<uint8_t, bool> bleSubscribed;
+  std::unordered_map<uint8_t, unsigned long> bleLastSetDtTime;
+  #endif
   unsigned long globalLastPollingTime = 0;
 
   #if defined(ARDUINO_ARCH_ESP32)
@@ -83,8 +90,11 @@ protected:
       pollingNtcSensors();
       this->yield();
 
+      #if USE_BLE
+      cleanBleInstances();
       pollingBleSensors();
       this->yield();
+      #endif
 
       this->globalLastPollingTime = millis();
     }
@@ -175,16 +185,19 @@ protected:
         continue;
       }
 
-      if (millis() - this->dallasSearchTime[gpio] > this->dallasSearchInterval) {
-        this->dallasSearchTime[gpio] = millis();
-        instance.begin();
-
-        Log.straceln(
-          FPSTR(L_SENSORS_DALLAS),
-          F("GPIO %hhu, devices on bus: %hhu, DS18* devices: %hhu"),
-          gpio, instance.getDeviceCount(), instance.getDS18Count()
-        );
+      if (millis() - this->dallasSearchTime[gpio] < this->dallasSearchInterval) {
+        continue;
       }
+
+      this->dallasSearchTime[gpio] = millis();
+      this->owInstances[gpio].reset();
+      instance.begin();
+
+      Log.straceln(
+        FPSTR(L_SENSORS_DALLAS),
+        F("GPIO %hhu, devices on bus: %hhu, DS18* devices: %hhu"),
+        gpio, instance.getDeviceCount(), instance.getDS18Count()
+      );
     }
   }
 
@@ -274,25 +287,14 @@ protected:
       unsigned long ts = millis();
 
       if (this->dallasPolling[gpio]) {
-        auto minPollingTime = instance.millisToWaitForConversion(12);
+        unsigned long minPollingTime = instance.millisToWaitForConversion(12) * 2;
         unsigned long estimatePollingTime = ts - this->dallasLastPollingTime[gpio];
 
         // check conversion time
+        // isConversionComplete does not work with chinese clones!
         if (estimatePollingTime < minPollingTime) {
           continue;
         }
-        
-        // check conversion
-        bool conversionComplete = instance.isConversionComplete();
-        if (!conversionComplete) {
-          if (estimatePollingTime > (minPollingTime * 2)) {
-            this->dallasPolling[gpio] = false;
-
-            Log.swarningln(FPSTR(L_SENSORS_DALLAS), F("GPIO %hhu, timeout receiving data"), gpio);
-          }
-
-          continue;
-        }
 
         // read sensors data for current instance
         for (uint8_t sensorId = 0; sensorId <= Sensors::getMaxSensorId(); sensorId++) {
@@ -345,28 +347,6 @@ protected:
           continue;
         }
 
-        // check sensors on bus
-        if (!instance.getDeviceCount()) {
-          for (uint8_t sensorId = 0; sensorId <= Sensors::getMaxSensorId(); sensorId++) {
-            auto& sSensor = Sensors::settings[sensorId];
-            
-            // only target & valid sensors
-            if (!sSensor.enabled || sSensor.type != Sensors::Type::DALLAS_TEMP || sSensor.purpose == Sensors::Purpose::NOT_CONFIGURED) {
-              continue;
-
-            } else if (sSensor.gpio != gpio || isEmptyAddress(sSensor.address)) {
-              continue;
-            }
-            
-            auto& rSensor = Sensors::results[sensorId];
-            if (rSensor.signalQuality > 0) {
-              rSensor.signalQuality--;
-            }
-          }
-
-          continue;
-        }
-
         // start polling
         instance.setResolution(12);
         instance.requestTemperatures();
@@ -378,26 +358,6 @@ protected:
     }
   }
 
-  void pollingBleSensors() {
-    #if USE_BLE
-    if (!NimBLEDevice::getInitialized() && millis() > 5000) {
-      Log.sinfoln(FPSTR(L_SENSORS_BLE), F("Initialized"));
-      BLEDevice::init("");
-      NimBLEDevice::setPower(ESP_PWR_LVL_P9);
-    }
-
-    for (uint8_t sensorId = 0; sensorId <= Sensors::getMaxSensorId(); sensorId++) {
-      auto& sSensor = Sensors::settings[sensorId];
-      
-      if (!sSensor.enabled || sSensor.type != Sensors::Type::BLUETOOTH || sSensor.purpose == Sensors::Purpose::NOT_CONFIGURED) {
-        continue;
-      }
-
-      connectToBleDevice(sensorId);
-    }
-    #endif
-  }
-
   void pollingNtcSensors() {
     for (uint8_t sensorId = 0; sensorId <= Sensors::getMaxSensorId(); sensorId++) {
       auto& sSensor = Sensors::settings[sensorId];
@@ -443,64 +403,182 @@ protected:
     }
   }
 
-  bool connectToBleDevice(const uint8_t sensorId) {
+  #if USE_BLE
+  void cleanBleInstances() {
     #if USE_BLE
-    if (!NimBLEDevice::getInitialized()) {
-      return false;
+    if (!NimBLEDevice::isInitialized()) {
+      return;
+    }
+
+    for (auto client : NimBLEDevice::getConnectedClients()) {
+      auto address = client->getPeerAddress();
+      bool used = false;
+
+      for (uint8_t sensorId = 0; sensorId <= Sensors::getMaxSensorId(); sensorId++) {
+        auto& sSensor = Sensors::settings[sensorId];
+        
+        if (!sSensor.enabled || sSensor.type != Sensors::Type::BLUETOOTH || sSensor.purpose == Sensors::Purpose::NOT_CONFIGURED) {
+          continue;
+        }
+        
+        auto pAddress = address.getVal();
+        uint8_t addr[] = {
+          pAddress[5], pAddress[4], pAddress[3],
+          pAddress[2], pAddress[1], pAddress[0]
+        };
+
+        if (isEqualAddress(addr, sSensor.address, sizeof(addr))) {
+          used = true;
+          break;
+        }
+      }
+
+      if (!used) {
+        Log.sinfoln(
+          FPSTR(L_SENSORS_BLE), F("Deleted unused client connected to %s"),
+          address.toString().c_str()
+        );
+
+        NimBLEDevice::deleteClient(client);
+      }
+    }
+    #endif
+  }
+
+  void pollingBleSensors() {
+    if (!NimBLEDevice::isInitialized() && millis() > 5000) {
+      Log.sinfoln(FPSTR(L_SENSORS_BLE), F("Initialized"));
+      BLEDevice::init("");
+      NimBLEDevice::setPower(9);
+    }
+
+    for (uint8_t sensorId = 0; sensorId <= Sensors::getMaxSensorId(); sensorId++) {
+      auto& sSensor = Sensors::settings[sensorId];
+      auto& rSensor = Sensors::results[sensorId];
+      
+      if (!sSensor.enabled || sSensor.type != Sensors::Type::BLUETOOTH || sSensor.purpose == Sensors::Purpose::NOT_CONFIGURED) {
+        continue;
+      }
+
+      auto client = this->getBleClient(sensorId);
+      if (client == nullptr) {
+        continue;
+      }
+
+      if (!client->isConnected()) {
+        this->bleSubscribed[sensorId] = false;
+        this->bleLastSetDtTime[sensorId] = 0;
+
+        if (client->connect()) {
+          Log.sinfoln(
+            FPSTR(L_SENSORS_BLE), F("Sensor #%hhu '%s': connected to %s"),
+            sensorId, sSensor.name, client->getPeerAddress().toString().c_str()
+          );
+
+        } else {
+          Log.swarningln(
+            FPSTR(L_SENSORS_BLE), F("Sensor #%hhu '%s': failed connecting to %s"),
+            sensorId, sSensor.name, client->getPeerAddress().toString().c_str()
+          );
+
+          continue;
+        }
+      }
+      
+      if (!this->bleSubscribed[sensorId]) {
+        if (this->subscribeToBleDevice(sensorId, client)) {
+          this->bleSubscribed[sensorId] = true;
+
+        } else {
+          this->bleSubscribed[sensorId] = false;
+          client->disconnect();
+          continue;
+        }
+      }
+
+      // Mark connected
+      Sensors::setConnectionStatusById(sensorId, true, true);
+
+      if (!this->bleLastSetDtTime[sensorId] || millis() - this->bleLastSetDtTime[sensorId] > this->bleSetDtInterval) {
+        struct tm ti;
+        
+        if (getLocalTime(&ti)) {
+          if (this->setDateOnBleSensor(client, &ti)) {
+            Log.sinfoln(
+              FPSTR(L_SENSORS_BLE), F("Sensor #%hhu '%s', successfully set date: %02d.%02d.%04d %02d:%02d:%02d"),
+              sensorId, sSensor.name,
+              ti.tm_mday, ti.tm_mon + 1, ti.tm_year + 1900, ti.tm_hour, ti.tm_min, ti.tm_sec
+            );
+
+          } else {
+            Log.swarningln(
+              FPSTR(L_SENSORS_BLE), F("Sensor #%hhu '%s', failed set date: %02d.%02d.%04d %02d:%02d:%02d"),
+              sensorId, sSensor.name,
+              ti.tm_mday, ti.tm_mon + 1, ti.tm_year + 1900, ti.tm_hour, ti.tm_min, ti.tm_sec
+            );
+          }
+
+          this->bleLastSetDtTime[sensorId] = millis();
+        }
+      }
+    }
+  }
+
+  NimBLEClient* getBleClient(const uint8_t sensorId) {
+    if (!NimBLEDevice::isInitialized()) {
+      return nullptr;
     }
 
     auto& sSensor = Sensors::settings[sensorId];
     auto& rSensor = Sensors::results[sensorId];
 
     if (!sSensor.enabled || sSensor.type != Sensors::Type::BLUETOOTH || sSensor.purpose == Sensors::Purpose::NOT_CONFIGURED) {
-      return false;
+      return nullptr;
     }
     
     uint8_t addr[6] = {
       sSensor.address[0], sSensor.address[1], sSensor.address[2],
       sSensor.address[3], sSensor.address[4], sSensor.address[5]
     };
-    const NimBLEAddress address = NimBLEAddress(addr);
+    const auto address = NimBLEAddress(addr, 0);
     
-    NimBLEClient* pClient = nullptr;
-    pClient = NimBLEDevice::getClientByPeerAddress(address);
-
+    NimBLEClient* pClient = NimBLEDevice::getClientByPeerAddress(address);
     if (pClient == nullptr) {
       pClient = NimBLEDevice::getDisconnectedClient();
     }
 
     if (pClient == nullptr) {
-      if (NimBLEDevice::getClientListSize() >= NIMBLE_MAX_CONNECTIONS) {
-        return false;
+      if (NimBLEDevice::getCreatedClientCount() >= NIMBLE_MAX_CONNECTIONS) {
+        return nullptr;
       }
 
       pClient = NimBLEDevice::createClient();
-      pClient->setConnectTimeout(5);
-    }
-
-    if(pClient->isConnected()) {
-      if (!rSensor.connected) {
-        rSensor.connected = true;
+      if (pClient == nullptr) {
+        return nullptr;
       }
 
-      return true;
+      /**
+       *  Set initial connection parameters:
+       *  These settings are safe for 3 clients to connect reliably, can go faster if you have less
+       *  connections. Timeout should be a multiple of the interval, minimum is 100ms.
+       *  Min interval: 12 * 1.25ms = 15, Max interval: 12 * 1.25ms = 15, 0 latency, 1000 * 10ms = 10000ms timeout
+       */
+      pClient->setConnectionParams(12, 12, 0, 1000);
+      pClient->setConnectTimeout(5000);
+      pClient->setSelfDelete(false, true);
     }
 
-    if (!pClient->connect(address)) {
-      Log.swarningln(
-        FPSTR(L_SENSORS_BLE), F("Sensor #%hhu '%s': failed connecting to %s"),
-        sensorId, sSensor.name, address.toString().c_str()
-      );
-
-      NimBLEDevice::deleteClient(pClient);
-      return false;
+    if (!pClient->isConnected()) {
+      pClient->setPeerAddress(address);
     }
 
-    Log.sinfoln(
-      FPSTR(L_SENSORS_BLE), F("Sensor #%hhu '%s': connected to %s"),
-      sensorId, sSensor.name, address.toString().c_str()
-    );
+    return pClient;
+  }
 
+  bool subscribeToBleDevice(const uint8_t sensorId, NimBLEClient* pClient) {
+    auto& sSensor = Sensors::settings[sensorId];
+    auto pAddress = pClient->getPeerAddress().toString().c_str();
+    
     NimBLERemoteService* pService = nullptr;
     NimBLERemoteCharacteristic* pChar = nullptr;
 
@@ -510,13 +588,13 @@ protected:
     if (!pService) {
       Log.straceln(
         FPSTR(L_SENSORS_BLE), F("Sensor #%hhu '%s': failed to find env service (%s) on device %s"),
-        sensorId, sSensor.name, serviceUuid.toString().c_str(), address.toString().c_str()
+        sensorId, sSensor.name, serviceUuid.toString().c_str(), pAddress
       );
 
     } else {
       Log.straceln(
         FPSTR(L_SENSORS_BLE), F("Sensor #%hhu '%s': found env service (%s) on device %s"),
-        sensorId, sSensor.name, serviceUuid.toString().c_str(), address.toString().c_str()
+        sensorId, sSensor.name, serviceUuid.toString().c_str(), pAddress
       );
 
       // 0x2A6E - Notify temperature x0.01C (pvvx)
@@ -525,176 +603,21 @@ protected:
         NimBLEUUID charUuid((uint16_t) 0x2A6E);
         pChar = pService->getCharacteristic(charUuid);
 
-        if (pChar && pChar->canNotify()) {
+        if (pChar && (pChar->canNotify() || pChar->canIndicate())) {
           Log.straceln(
             FPSTR(L_SENSORS_BLE), F("Sensor #%hhu '%s': found temp char (%s) in env service on device %s"),
-            sensorId, sSensor.name, charUuid.toString().c_str(), address.toString().c_str()
+            sensorId, sSensor.name, charUuid.toString().c_str(), pAddress
           );
 
-          tempNotifyCreated = pChar->subscribe(true, [sensorId](NimBLERemoteCharacteristic* pChar, uint8_t* pData, size_t length, bool isNotify) {
-            if (pChar == nullptr) {
-              return;
-            }
-
-            NimBLERemoteService* pService = pChar->getRemoteService();
-            if (pService == nullptr) {
-              return;
-            }
-
-            NimBLEClient* pClient = pService->getClient();
-            if (pClient == nullptr) {
-              return;
-            }
-
-            auto& sSensor = Sensors::settings[sensorId];
-
-            if (length != 2) {
-              Log.swarningln(
-                FPSTR(L_SENSORS_BLE),
-                F("Sensor #%hhu '%s': invalid notification data at temp char (%s) on device %s"),
-                sensorId,
-                sSensor.name,
-                pChar->getUUID().toString().c_str(),
-                pClient->getPeerAddress().toString().c_str()
-              );
-
-              return;
-            }
-
-            float rawTemp = (pChar->getValue<int16_t>() * 0.01f);
-            Log.straceln(
-              FPSTR(L_SENSORS_BLE),
-              F("Sensor #%hhu '%s': received temp: %.2f"),
-              sensorId, sSensor.name, rawTemp
-            );
-
-            // set temp
-            Sensors::setValueById(sensorId, rawTemp, Sensors::ValueType::TEMPERATURE, true, true);
-
-            // update rssi
-            Sensors::setValueById(sensorId, pClient->getRssi(), Sensors::ValueType::RSSI, false, false);
-          });
-
-          if (tempNotifyCreated) {
-            Log.straceln(
-              FPSTR(L_SENSORS_BLE), F("Sensor #%hhu '%s': subscribed to temp char (%s) in env service on device %s"),
-              sensorId, sSensor.name,
-              charUuid.toString().c_str(), address.toString().c_str()
-            );
-
-          } else {
-            Log.swarningln(
-              FPSTR(L_SENSORS_BLE), F("Sensor #%hhu '%s': failed to subscribe to temp char (%s) in env service on device %s"),
-              sensorId, sSensor.name,
-              charUuid.toString().c_str(), address.toString().c_str()
-            );
-          }
-        }
-      }
-
-
-      // 0x2A1F - Notify temperature x0.1C (atc1441/pvvx)
-      if (!tempNotifyCreated) {
-        NimBLEUUID charUuid((uint16_t) 0x2A1F);
-        pChar = pService->getCharacteristic(charUuid);
-
-        if (pChar && pChar->canNotify()) {
-          Log.straceln(
-            FPSTR(L_SENSORS_BLE), F("Sensor #%hhu '%s': found temp char (%s) in env service on device %s"),
-            sensorId, sSensor.name, charUuid.toString().c_str(), address.toString().c_str()
-          );
-
-          tempNotifyCreated = pChar->subscribe(true, [sensorId](NimBLERemoteCharacteristic* pChar, uint8_t* pData, size_t length, bool isNotify) {
-            if (pChar == nullptr) {
-              return;
-            }
-
-            NimBLERemoteService* pService = pChar->getRemoteService();
-            if (pService == nullptr) {
-              return;
-            }
-
-            NimBLEClient* pClient = pService->getClient();
-            if (pClient == nullptr) {
-              return;
-            }
-
-            auto& sSensor = Sensors::settings[sensorId];
-
-            if (length != 2) {
-              Log.swarningln(
-                FPSTR(L_SENSORS_BLE),
-                F("Sensor #%hhu '%s': invalid notification data at temp char (%s) on device %s"),
-                sensorId,
-                sSensor.name,
-                pChar->getUUID().toString().c_str(),
-                pClient->getPeerAddress().toString().c_str()
-              );
-
-              return;
-            }
-
-            float rawTemp = (pChar->getValue<int16_t>() * 0.1f);
-            Log.straceln(
-              FPSTR(L_SENSORS_BLE),
-              F("Sensor #%hhu '%s': received temp: %.2f"),
-              sensorId, sSensor.name, rawTemp
-            );
-
-            // set temp
-            Sensors::setValueById(sensorId, rawTemp, Sensors::ValueType::TEMPERATURE, true, true);
-
-            // update rssi
-            Sensors::setValueById(sensorId, pClient->getRssi(), Sensors::ValueType::RSSI, false, false);
-          });
-
-          if (tempNotifyCreated) {
-            Log.straceln(
-              FPSTR(L_SENSORS_BLE), F("Sensor #%hhu '%s': subscribed to temp char (%s) in env service on device %s"),
-              sensorId, sSensor.name,
-              charUuid.toString().c_str(), address.toString().c_str()
-            );
-
-          } else {
-            Log.swarningln(
-              FPSTR(L_SENSORS_BLE), F("Sensor #%hhu '%s': failed to subscribe to temp char (%s) in env service on device %s"),
-              sensorId, sSensor.name,
-              charUuid.toString().c_str(), address.toString().c_str()
-            );
-          }
-        }
-      }
-
-      if (!tempNotifyCreated) {
-        Log.swarningln(
-          FPSTR(L_SENSORS_BLE), F("Sensor #%hhu '%s': not found supported temp chars in env service on device %s"),
-          sensorId, sSensor.name, address.toString().c_str()
-        );
-
-        pClient->disconnect();
-        return false;
-      }
-
-
-      // 0x2A6F - Notify about humidity x0.01% (pvvx)
-      {
-        bool humidityNotifyCreated = false;
-        if (!humidityNotifyCreated) {
-          NimBLEUUID charUuid((uint16_t) 0x2A6F);
-          pChar = pService->getCharacteristic(charUuid);
-
-          if (pChar && pChar->canNotify()) {
-            Log.straceln(
-              FPSTR(L_SENSORS_BLE), F("Sensor #%hhu '%s': found humidity char (%s) in env service on device %s"),
-              sensorId, sSensor.name, charUuid.toString().c_str(), address.toString().c_str()
-            );
-
-            humidityNotifyCreated = pChar->subscribe(true, [sensorId](NimBLERemoteCharacteristic* pChar, uint8_t* pData, size_t length, bool isNotify) {
+          pChar->unsubscribe();
+          tempNotifyCreated = pChar->subscribe(
+            pChar->canNotify(),
+            [sensorId](NimBLERemoteCharacteristic* pChar, uint8_t* pData, size_t length, bool isNotify) {
               if (pChar == nullptr) {
                 return;
               }
 
-              NimBLERemoteService* pService = pChar->getRemoteService();
+              const NimBLERemoteService* pService = pChar->getRemoteService();
               if (pService == nullptr) {
                 return;
               }
@@ -709,7 +632,7 @@ protected:
               if (length != 2) {
                 Log.swarningln(
                   FPSTR(L_SENSORS_BLE),
-                  F("Sensor #%hhu '%s': invalid notification data at humidity char (%s) on device %s"),
+                  F("Sensor #%hhu '%s': invalid notification data at temp char (%s) on device %s"),
                   sensorId,
                   sSensor.name,
                   pChar->getUUID().toString().c_str(),
@@ -719,32 +642,199 @@ protected:
                 return;
               }
 
-              float rawHumidity = (pChar->getValue<uint16_t>() * 0.01f);
+              float rawTemp = (pChar->getValue<int16_t>() * 0.01f);
               Log.straceln(
                 FPSTR(L_SENSORS_BLE),
-                F("Sensor #%hhu '%s': received humidity: %.2f"),
-                sensorId, sSensor.name, rawHumidity
+                F("Sensor #%hhu '%s': received temp: %.2f"),
+                sensorId, sSensor.name, rawTemp
               );
 
-              // set humidity
-              Sensors::setValueById(sensorId, rawHumidity, Sensors::ValueType::HUMIDITY, true, true);
+              // set temp
+              Sensors::setValueById(sensorId, rawTemp, Sensors::ValueType::TEMPERATURE, true, true);
 
               // update rssi
               Sensors::setValueById(sensorId, pClient->getRssi(), Sensors::ValueType::RSSI, false, false);
-            });
+            }
+          );
+
+          if (tempNotifyCreated) {
+            Log.straceln(
+              FPSTR(L_SENSORS_BLE), F("Sensor #%hhu '%s': subscribed to temp char (%s) in env service on device %s"),
+              sensorId, sSensor.name,
+              charUuid.toString().c_str(), pAddress
+            );
+
+          } else {
+            Log.swarningln(
+              FPSTR(L_SENSORS_BLE), F("Sensor #%hhu '%s': failed to subscribe to temp char (%s) in env service on device %s"),
+              sensorId, sSensor.name,
+              charUuid.toString().c_str(), pAddress
+            );
+          }
+        }
+      }
+
+
+      // 0x2A1F - Notify temperature x0.1C (atc1441/pvvx)
+      if (!tempNotifyCreated) {
+        NimBLEUUID charUuid((uint16_t) 0x2A1F);
+        pChar = pService->getCharacteristic(charUuid);
+
+        if (pChar && (pChar->canNotify() || pChar->canIndicate())) {
+          Log.straceln(
+            FPSTR(L_SENSORS_BLE), F("Sensor #%hhu '%s': found temp char (%s) in env service on device %s"),
+            sensorId, sSensor.name, charUuid.toString().c_str(), pAddress
+          );
+
+          pChar->unsubscribe();
+          tempNotifyCreated = pChar->subscribe(
+            pChar->canNotify(),
+            [sensorId](NimBLERemoteCharacteristic* pChar, uint8_t* pData, size_t length, bool isNotify) {
+              if (pChar == nullptr) {
+                return;
+              }
+
+              const NimBLERemoteService* pService = pChar->getRemoteService();
+              if (pService == nullptr) {
+                return;
+              }
+
+              NimBLEClient* pClient = pService->getClient();
+              if (pClient == nullptr) {
+                return;
+              }
+
+              auto& sSensor = Sensors::settings[sensorId];
+
+              if (length != 2) {
+                Log.swarningln(
+                  FPSTR(L_SENSORS_BLE),
+                  F("Sensor #%hhu '%s': invalid notification data at temp char (%s) on device %s"),
+                  sensorId,
+                  sSensor.name,
+                  pChar->getUUID().toString().c_str(),
+                  pClient->getPeerAddress().toString().c_str()
+                );
+
+                return;
+              }
+
+              float rawTemp = (pChar->getValue<int16_t>() * 0.1f);
+              Log.straceln(
+                FPSTR(L_SENSORS_BLE),
+                F("Sensor #%hhu '%s': received temp: %.2f"),
+                sensorId, sSensor.name, rawTemp
+              );
+
+              // set temp
+              Sensors::setValueById(sensorId, rawTemp, Sensors::ValueType::TEMPERATURE, true, true);
+
+              // update rssi
+              Sensors::setValueById(sensorId, pClient->getRssi(), Sensors::ValueType::RSSI, false, false);
+            }
+          );
+
+          if (tempNotifyCreated) {
+            Log.straceln(
+              FPSTR(L_SENSORS_BLE), F("Sensor #%hhu '%s': subscribed to temp char (%s) in env service on device %s"),
+              sensorId, sSensor.name,
+              charUuid.toString().c_str(), pAddress
+            );
+
+          } else {
+            Log.swarningln(
+              FPSTR(L_SENSORS_BLE), F("Sensor #%hhu '%s': failed to subscribe to temp char (%s) in env service on device %s"),
+              sensorId, sSensor.name,
+              charUuid.toString().c_str(), pAddress
+            );
+          }
+        }
+      }
+
+      if (!tempNotifyCreated) {
+        Log.swarningln(
+          FPSTR(L_SENSORS_BLE), F("Sensor #%hhu '%s': not found supported temp chars in env service on device %s"),
+          sensorId, sSensor.name, pAddress
+        );
+
+        pClient->disconnect();
+        return false;
+      }
+
+
+      // 0x2A6F - Notify about humidity x0.01% (pvvx)
+      {
+        bool humidityNotifyCreated = false;
+        if (!humidityNotifyCreated) {
+          NimBLEUUID charUuid((uint16_t) 0x2A6F);
+          pChar = pService->getCharacteristic(charUuid);
+
+          if (pChar && (pChar->canNotify() || pChar->canIndicate())) {
+            Log.straceln(
+              FPSTR(L_SENSORS_BLE), F("Sensor #%hhu '%s': found humidity char (%s) in env service on device %s"),
+              sensorId, sSensor.name, charUuid.toString().c_str(), pAddress
+            );
+
+            pChar->unsubscribe();
+            humidityNotifyCreated = pChar->subscribe(
+              pChar->canNotify(),
+              [sensorId](NimBLERemoteCharacteristic* pChar, uint8_t* pData, size_t length, bool isNotify) {
+                if (pChar == nullptr) {
+                  return;
+                }
+
+                const NimBLERemoteService* pService = pChar->getRemoteService();
+                if (pService == nullptr) {
+                  return;
+                }
+
+                NimBLEClient* pClient = pService->getClient();
+                if (pClient == nullptr) {
+                  return;
+                }
+
+                auto& sSensor = Sensors::settings[sensorId];
+
+                if (length != 2) {
+                  Log.swarningln(
+                    FPSTR(L_SENSORS_BLE),
+                    F("Sensor #%hhu '%s': invalid notification data at humidity char (%s) on device %s"),
+                    sensorId,
+                    sSensor.name,
+                    pChar->getUUID().toString().c_str(),
+                    pClient->getPeerAddress().toString().c_str()
+                  );
+
+                  return;
+                }
+
+                float rawHumidity = (pChar->getValue<uint16_t>() * 0.01f);
+                Log.straceln(
+                  FPSTR(L_SENSORS_BLE),
+                  F("Sensor #%hhu '%s': received humidity: %.2f"),
+                  sensorId, sSensor.name, rawHumidity
+                );
+
+                // set humidity
+                Sensors::setValueById(sensorId, rawHumidity, Sensors::ValueType::HUMIDITY, true, true);
+
+                // update rssi
+                Sensors::setValueById(sensorId, pClient->getRssi(), Sensors::ValueType::RSSI, false, false);
+              }
+            );
 
             if (humidityNotifyCreated) {
               Log.straceln(
                 FPSTR(L_SENSORS_BLE), F("Sensor #%hhu '%s': subscribed to humidity char (%s) in env service on device %s"),
                 sensorId, sSensor.name,
-                charUuid.toString().c_str(), address.toString().c_str()
+                charUuid.toString().c_str(), pAddress
               );
 
             } else {
               Log.swarningln(
                 FPSTR(L_SENSORS_BLE), F("Sensor #%hhu '%s': failed to subscribe to humidity char (%s) in env service on device %s"),
                 sensorId, sSensor.name,
-                charUuid.toString().c_str(), address.toString().c_str()
+                charUuid.toString().c_str(), pAddress
               );
             }
           }
@@ -753,7 +843,7 @@ protected:
         if (!humidityNotifyCreated) {
           Log.swarningln(
             FPSTR(L_SENSORS_BLE), F("Sensor #%hhu '%s': not found supported humidity chars in env service on device %s"),
-            sensorId, sSensor.name, address.toString().c_str()
+            sensorId, sSensor.name, pAddress
           );
         }
       }
@@ -767,13 +857,13 @@ protected:
       if (!pService) {
         Log.straceln(
           FPSTR(L_SENSORS_BLE), F("Sensor #%hhu '%s': failed to find battery service (%s) on device %s"),
-          sensorId, sSensor.name, serviceUuid.toString().c_str(), address.toString().c_str()
+          sensorId, sSensor.name, serviceUuid.toString().c_str(), pAddress
         );
 
       } else {
         Log.straceln(
           FPSTR(L_SENSORS_BLE), F("Sensor #%hhu '%s': found battery service (%s) on device %s"),
-          sensorId, sSensor.name, serviceUuid.toString().c_str(), address.toString().c_str()
+          sensorId, sSensor.name, serviceUuid.toString().c_str(), pAddress
         );
 
         // 0x2A19 - Notify the battery charge level 0..99% (pvvx)
@@ -782,68 +872,72 @@ protected:
           NimBLEUUID charUuid((uint16_t) 0x2A19);
           pChar = pService->getCharacteristic(charUuid);
 
-          if (pChar && pChar->canNotify()) {
+          if (pChar && (pChar->canNotify() || pChar->canIndicate())) {
             Log.straceln(
               FPSTR(L_SENSORS_BLE), F("Sensor #%hhu '%s': found battery char (%s) in battery service on device %s"),
-              sensorId, sSensor.name, charUuid.toString().c_str(), address.toString().c_str()
+              sensorId, sSensor.name, charUuid.toString().c_str(), pAddress
             );
 
-            batteryNotifyCreated = pChar->subscribe(true, [sensorId](NimBLERemoteCharacteristic* pChar, uint8_t* pData, size_t length, bool isNotify) {
-              if (pChar == nullptr) {
-                return;
-              }
+            pChar->unsubscribe();
+            batteryNotifyCreated = pChar->subscribe(
+              pChar->canNotify(),
+              [sensorId](NimBLERemoteCharacteristic* pChar, uint8_t* pData, size_t length, bool isNotify) {
+                if (pChar == nullptr) {
+                  return;
+                }
 
-              NimBLERemoteService* pService = pChar->getRemoteService();
-              if (pService == nullptr) {
-                return;
-              }
+                const NimBLERemoteService* pService = pChar->getRemoteService();
+                if (pService == nullptr) {
+                  return;
+                }
 
-              NimBLEClient* pClient = pService->getClient();
-              if (pClient == nullptr) {
-                return;
-              }
+                NimBLEClient* pClient = pService->getClient();
+                if (pClient == nullptr) {
+                  return;
+                }
 
-              auto& sSensor = Sensors::settings[sensorId];
+                auto& sSensor = Sensors::settings[sensorId];
 
-              if (length != 1) {
-                Log.swarningln(
+                if (length != 1) {
+                  Log.swarningln(
+                    FPSTR(L_SENSORS_BLE),
+                    F("Sensor #%hhu '%s': invalid notification data at battery char (%s) on device %s"),
+                    sensorId,
+                    sSensor.name,
+                    pChar->getUUID().toString().c_str(),
+                    pClient->getPeerAddress().toString().c_str()
+                  );
+
+                  return;
+                }
+
+                auto rawBattery = pChar->getValue<uint8_t>();
+                Log.straceln(
                   FPSTR(L_SENSORS_BLE),
-                  F("Sensor #%hhu '%s': invalid notification data at battery char (%s) on device %s"),
-                  sensorId,
-                  sSensor.name,
-                  pChar->getUUID().toString().c_str(),
-                  pClient->getPeerAddress().toString().c_str()
+                  F("Sensor #%hhu '%s': received battery: %hhu"),
+                  sensorId, sSensor.name, rawBattery
                 );
 
-                return;
+                // set battery
+                Sensors::setValueById(sensorId, rawBattery, Sensors::ValueType::BATTERY, true, true);
+                
+                // update rssi
+                Sensors::setValueById(sensorId, pClient->getRssi(), Sensors::ValueType::RSSI, false, false);
               }
-
-              auto rawBattery = pChar->getValue<uint8_t>();
-              Log.straceln(
-                FPSTR(L_SENSORS_BLE),
-                F("Sensor #%hhu '%s': received battery: %.2f"),
-                sensorId, sSensor.name, rawBattery
-              );
-
-              // set battery
-              Sensors::setValueById(sensorId, rawBattery, Sensors::ValueType::BATTERY, true, true);
-              
-              // update rssi
-              Sensors::setValueById(sensorId, pClient->getRssi(), Sensors::ValueType::RSSI, false, false);
-            });
+            );
 
             if (batteryNotifyCreated) {
               Log.straceln(
                 FPSTR(L_SENSORS_BLE), F("Sensor #%hhu '%s': subscribed to battery char (%s) in battery service on device %s"),
                 sensorId, sSensor.name,
-                charUuid.toString().c_str(), address.toString().c_str()
+                charUuid.toString().c_str(), pAddress
               );
 
             } else {
               Log.swarningln(
                 FPSTR(L_SENSORS_BLE), F("Sensor #%hhu '%s': failed to subscribe to battery char (%s) in battery service on device %s"),
                 sensorId, sSensor.name,
-                charUuid.toString().c_str(), address.toString().c_str()
+                charUuid.toString().c_str(), pAddress
               );
             }
           }
@@ -852,34 +946,49 @@ protected:
         if (!batteryNotifyCreated) {
           Log.swarningln(
             FPSTR(L_SENSORS_BLE), F("Sensor #%hhu '%s': not found supported battery chars in battery service on device %s"),
-            sensorId, sSensor.name, address.toString().c_str()
+            sensorId, sSensor.name, pAddress
           );
         }
       }
     }
 
     return true;
-    #else
-    return false;
-    #endif
   }
 
+  bool setDateOnBleSensor(NimBLEClient* pClient, const struct tm *ptm) {
+    auto ts = mkgmtime(ptm);
+
+    uint8_t data[5] = {};
+    data[0] = 0x23;
+    data[1] = ts & 0xff;
+    data[2] = (ts >> 8) & 0xff;
+    data[3] = (ts >> 16) & 0xff;
+    data[4] = (ts >> 24) & 0xff;
+
+    return pClient->setValue(
+      NimBLEUUID((uint16_t) 0x1f10),
+      NimBLEUUID((uint16_t) 0x1f1f),
+      NimBLEAttValue(data, sizeof(data))
+    );
+  }
+  #endif
+
   void updateConnectionStatus() {
     for (uint8_t sensorId = 0; sensorId <= Sensors::getMaxSensorId(); sensorId++) {
       auto& sSensor = Sensors::settings[sensorId];
       auto& rSensor = Sensors::results[sensorId];
 
       if (rSensor.connected && !sSensor.enabled) {
-        rSensor.connected = false;
+        Sensors::setConnectionStatusById(sensorId, false, false);
 
       } else if (rSensor.connected && sSensor.type == Sensors::Type::NOT_CONFIGURED) {
-        rSensor.connected = false;
+        Sensors::setConnectionStatusById(sensorId, false, false);
 
       } else if (rSensor.connected && sSensor.purpose == Sensors::Purpose::NOT_CONFIGURED) {
-        rSensor.connected = false;
+        Sensors::setConnectionStatusById(sensorId, false, false);
 
       } else if (sSensor.type != Sensors::Type::MANUAL && rSensor.connected && (millis() - rSensor.activityTime) > this->disconnectedTimeout) {
-        rSensor.connected = false;
+        Sensors::setConnectionStatusById(sensorId, false, false);
 
       }/* else if (!rSensor.connected) {
         rSensor.connected = true;
@@ -888,7 +997,8 @@ protected:
   }
 
   static bool isEqualAddress(const uint8_t *addr1, const uint8_t *addr2, const uint8_t length = 8) {
-    bool result = true;
+    return memcmp(addr1, addr2, length) == 0;
+    /*bool result = true;
 
     for (uint8_t i = 0; i < length; i++) {
       if (addr1[i] != addr2[i]) {
@@ -897,7 +1007,7 @@ protected:
       }
     }
 
-    return result;
+    return result;*/
   }
 
   static bool isEmptyAddress(const uint8_t *addr, const uint8_t length = 8) {

src/Settings.h

@@ -36,6 +36,11 @@ struct Settings {
       unsigned short port = DEFAULT_TELNET_PORT;
     } telnet;
 
+    struct {
+      char server[49] = "pool.ntp.org";
+      char timezone[49] = "UTC0";
+    } ntp;
+
     UnitSystem unitSystem = UnitSystem::METRIC;
     byte statusLedGpio = DEFAULT_STATUS_LED_GPIO;
   } system;
@@ -44,6 +49,7 @@ struct Settings {
     bool auth = false;
     char login[13] = DEFAULT_PORTAL_LOGIN;
     char password[33] = DEFAULT_PORTAL_PASSWORD;
+    bool mdns = true;
   } portal;
 
   struct {
@@ -53,20 +59,27 @@ 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;
 
-    bool dhwPresent = true;
-    bool summerWinterMode = false;
-    bool heatingCh2Enabled = true;
-    bool heatingCh1ToCh2 = false;
-    bool dhwToCh2 = false;
-    bool dhwBlocking = false;
-    bool modulationSyncWithHeating = false;
-    bool getMinMaxTemp = true;
-    bool nativeHeatingControl = false;
-    bool immergasFix = false;
+    struct {
+      bool dhwSupport = true;
+      bool coolingSupport = false;
+      bool summerWinterMode = false;
+      bool heatingStateToSummerWinterMode = false;
+      bool ch2AlwaysEnabled = true;
+      bool heatingToCh2 = false;
+      bool dhwToCh2 = false;
+      bool dhwBlocking = 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;
   } opentherm;
 
   struct {
@@ -93,6 +106,7 @@ struct Settings {
     float turboFactor = 7.5f;
     byte minTemp = DEFAULT_HEATING_MIN_TEMP;
     byte maxTemp = DEFAULT_HEATING_MAX_TEMP;
+    uint8_t maxModulation = 100;
   } heating;
 
   struct {
@@ -100,16 +114,26 @@ struct Settings {
     float target = DEFAULT_DHW_TARGET_TEMP;
     byte minTemp = DEFAULT_DHW_MIN_TEMP;
     byte maxTemp = DEFAULT_DHW_MAX_TEMP;
+    uint8_t maxModulation = 100;
   } dhw;
 
   struct {
     bool enabled = false;
     float p_factor = 2.0f;
-    float i_factor = 0.0055f;
+    float i_factor = 0.002f;
     float d_factor = 0.0f;
-    unsigned short dt = 180;
+    unsigned short dt = 300;
     short minTemp = 0;
     short maxTemp = DEFAULT_HEATING_MAX_TEMP;
+
+    struct {
+      bool enabled = true;
+      float p_multiplier = 1.0f;
+      float i_multiplier = 0.05f;
+      float d_multiplier = 1.0f;
+      float thresholdHigh = 0.5f;
+      float thresholdLow = 1.0f;
+    } deadband;
   } pid;
 
   struct {
@@ -287,6 +311,7 @@ struct Variables {
 
     bool connected = false;
     bool flame = false;
+    bool cooling = false;
     float pressure = 0.0f;
     float heatExchangerTemp = 0.0f;
 
@@ -329,6 +354,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;

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
@@ -55,7 +55,7 @@
 #endif
 
 #ifndef DEFAULT_HOSTNAME
-  #define DEFAULT_HOSTNAME "opentherm"
+  #define DEFAULT_HOSTNAME ""
 #endif
 
 #ifndef DEFAULT_AP_SSID
@@ -111,7 +111,7 @@
 #endif
 
 #ifndef DEFAULT_MQTT_PREFIX
-  #define DEFAULT_MQTT_PREFIX "opentherm"
+  #define DEFAULT_MQTT_PREFIX ""
 #endif
 
 #ifndef DEFAULT_OT_IN_GPIO

src/idf_component.yml

@@ -0,0 +1,3 @@
+dependencies:
+  idf: ">=5.3.2"
+  h2zero/esp-nimble-cpp: ">=2.2.1"

src/main.cpp

@@ -102,6 +102,12 @@ void setup() {
       break;
   }
 
+  // generate hostname if it is empty
+  if (!strlen(networkSettings.hostname)) {
+    strcpy(networkSettings.hostname, getChipId("otgateway-").c_str());
+    fsNetworkSettings.update();
+  }
+
   network = (new NetworkMgr)
     ->setHostname(networkSettings.hostname)
     ->setStaCredentials(
@@ -148,6 +154,12 @@ void setup() {
       break;
   }
 
+  // generate mqtt prefix if it is empty
+  if (!strlen(settings.mqtt.prefix)) {
+    strcpy(settings.mqtt.prefix, getChipId("otgateway_").c_str());
+    fsSettings.update();
+  }
+
   // Logs settings
   if (!settings.system.serial.enabled) {
     Serial.end();

src/strings.h

@@ -3,192 +3,209 @@
   #define PROGMEM 
 #endif
 
-const char L_SETTINGS[]                        PROGMEM = "SETTINGS";
-const char L_SETTINGS_OT[]                     PROGMEM = "SETTINGS.OT";
-const char L_SETTINGS_DHW[]                    PROGMEM = "SETTINGS.DHW";
-const char L_SETTINGS_HEATING[]                PROGMEM = "SETTINGS.HEATING";
-const char L_NETWORK[]                         PROGMEM = "NETWORK";
-const char L_NETWORK_SETTINGS[]                PROGMEM = "NETWORK.SETTINGS";
-const char L_PORTAL_WEBSERVER[]                PROGMEM = "PORTAL.WEBSERVER";
-const char L_PORTAL_DNSSERVER[]                PROGMEM = "PORTAL.DNSSERVER";
-const char L_PORTAL_CAPTIVE[]                  PROGMEM = "PORTAL.CAPTIVE";
-const char L_PORTAL_OTA[]                      PROGMEM = "PORTAL.OTA";
-const char L_MAIN[]                            PROGMEM = "MAIN";
-const char L_MQTT[]                            PROGMEM = "MQTT";
-const char L_MQTT_HA[]                         PROGMEM = "MQTT.HA";
-const char L_MQTT_MSG[]                        PROGMEM = "MQTT.MSG";
-const char L_OT[]                              PROGMEM = "OT";
-const char L_OT_DHW[]                          PROGMEM = "OT.DHW";
-const char L_OT_HEATING[]                      PROGMEM = "OT.HEATING";
-const char L_OT_CH2[]                          PROGMEM = "OT.CH2";
-const char L_SENSORS[]                         PROGMEM = "SENSORS";
-const char L_SENSORS_SETTINGS[]                PROGMEM = "SENSORS.SETTINGS";
-const char L_SENSORS_DALLAS[]                  PROGMEM = "SENSORS.DALLAS";
-const char L_SENSORS_NTC[]                     PROGMEM = "SENSORS.NTC";
-const char L_SENSORS_BLE[]                     PROGMEM = "SENSORS.BLE";
-const char L_REGULATOR[]                       PROGMEM = "REGULATOR";
-const char L_REGULATOR_PID[]                   PROGMEM = "REGULATOR.PID";
-const char L_REGULATOR_EQUITHERM[]             PROGMEM = "REGULATOR.EQUITHERM";
-const char L_CASCADE_INPUT[]                   PROGMEM = "CASCADE.INPUT";
-const char L_CASCADE_OUTPUT[]                  PROGMEM = "CASCADE.OUTPUT";
-const char L_EXTPUMP[]                         PROGMEM = "EXTPUMP";
+const char L_SETTINGS[]                             PROGMEM = "SETTINGS";
+const char L_SETTINGS_OT[]                          PROGMEM = "SETTINGS.OT";
+const char L_SETTINGS_DHW[]                         PROGMEM = "SETTINGS.DHW";
+const char L_SETTINGS_HEATING[]                     PROGMEM = "SETTINGS.HEATING";
+const char L_NETWORK[]                              PROGMEM = "NETWORK";
+const char L_NETWORK_SETTINGS[]                     PROGMEM = "NETWORK.SETTINGS";
+const char L_PORTAL_WEBSERVER[]                     PROGMEM = "PORTAL.WEBSERVER";
+const char L_PORTAL_DNSSERVER[]                     PROGMEM = "PORTAL.DNSSERVER";
+const char L_PORTAL_CAPTIVE[]                       PROGMEM = "PORTAL.CAPTIVE";
+const char L_PORTAL_OTA[]                           PROGMEM = "PORTAL.OTA";
+const char L_MAIN[]                                 PROGMEM = "MAIN";
+const char L_MQTT[]                                 PROGMEM = "MQTT";
+const char L_MQTT_HA[]                              PROGMEM = "MQTT.HA";
+const char L_MQTT_MSG[]                             PROGMEM = "MQTT.MSG";
+const char L_OT[]                                   PROGMEM = "OT";
+const char L_OT_DHW[]                               PROGMEM = "OT.DHW";
+const char L_OT_HEATING[]                           PROGMEM = "OT.HEATING";
+const char L_OT_CH2[]                               PROGMEM = "OT.CH2";
+const char L_SENSORS[]                              PROGMEM = "SENSORS";
+const char L_SENSORS_SETTINGS[]                     PROGMEM = "SENSORS.SETTINGS";
+const char L_SENSORS_DALLAS[]                       PROGMEM = "SENSORS.DALLAS";
+const char L_SENSORS_NTC[]                          PROGMEM = "SENSORS.NTC";
+const char L_SENSORS_BLE[]                          PROGMEM = "SENSORS.BLE";
+const char L_REGULATOR[]                            PROGMEM = "REGULATOR";
+const char L_REGULATOR_PID[]                        PROGMEM = "REGULATOR.PID";
+const char L_REGULATOR_EQUITHERM[]                  PROGMEM = "REGULATOR.EQUITHERM";
+const char L_CASCADE_INPUT[]                        PROGMEM = "CASCADE.INPUT";
+const char L_CASCADE_OUTPUT[]                       PROGMEM = "CASCADE.OUTPUT";
+const char L_EXTPUMP[]                              PROGMEM = "EXTPUMP";
 
 
-const char S_ACTIONS[]                         PROGMEM = "actions";
-const char S_ACTIVE[]                          PROGMEM = "active";
-const char S_ADDRESS[]                         PROGMEM = "address";
-const char S_ANTI_STUCK_INTERVAL[]             PROGMEM = "antiStuckInterval";
-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_BACKTRACE[]                       PROGMEM = "backtrace";
-const char S_BATTERY[]                         PROGMEM = "battery";
-const char S_BAUDRATE[]                        PROGMEM = "baudrate";
-const char S_BLOCKING[]                        PROGMEM = "blocking";
-const char S_BSSID[]                           PROGMEM = "bssid";
-const char S_BUILD[]                           PROGMEM = "build";
-const char S_CASCADE_CONTROL[]                 PROGMEM = "cascadeControl";
-const char S_CHANNEL[]                         PROGMEM = "channel";
-const char S_CHIP[]                            PROGMEM = "chip";
-const char S_CODE[]                            PROGMEM = "code";
-const char S_CONNECTED[]                       PROGMEM = "connected";
-const char S_CONTINUES[]                       PROGMEM = "continues";
-const char S_CORE[]                            PROGMEM = "core";
-const char S_CORES[]                           PROGMEM = "cores";
-const char S_CRASH[]                           PROGMEM = "crash";
-const char S_CURRENT_TEMP[]                    PROGMEM = "currentTemp";
-const char S_DATA[]                            PROGMEM = "data";
-const char S_DATE[]                            PROGMEM = "date";
-const char S_DHW[]                             PROGMEM = "dhw";
-const char S_DHW_BLOCKING[]                    PROGMEM = "dhwBlocking";
-const char S_DHW_PRESENT[]                     PROGMEM = "dhwPresent";
-const char S_DHW_TO_CH2[]                      PROGMEM = "dhwToCh2";
-const char S_DIAG[]                            PROGMEM = "diag";
-const char S_DNS[]                             PROGMEM = "dns";
-const char S_DT[]                              PROGMEM = "dt";
-const char S_D_FACTOR[]                        PROGMEM = "d_factor";
-const char S_EMERGENCY[]                       PROGMEM = "emergency";
-const char S_ENABLED[]                         PROGMEM = "enabled";
-const char S_ENV[]                             PROGMEM = "env";
-const char S_EPC[]                             PROGMEM = "epc";
-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_FILTERING[]                       PROGMEM = "filtering";
-const char S_FILTERING_FACTOR[]                PROGMEM = "filteringFactor";
-const char S_FLAGS[]                           PROGMEM = "flags";
-const char S_FLAME[]                           PROGMEM = "flame";
-const char S_FLASH[]                           PROGMEM = "flash";
-const char S_FREE[]                            PROGMEM = "free";
-const char S_FREQ[]                            PROGMEM = "freq";
-const char S_GATEWAY[]                         PROGMEM = "gateway";
-const char S_GET_MIN_MAX_TEMP[]                PROGMEM = "getMinMaxTemp";
-const char S_GPIO[]                            PROGMEM = "gpio";
-const char S_HEAP[]                            PROGMEM = "heap";
-const char S_HEATING[]                         PROGMEM = "heating";
-const char S_HEATING_CH1_TO_CH2[]              PROGMEM = "heatingCh1ToCh2";
-const char S_HEATING_CH2_ENABLED[]             PROGMEM = "heatingCh2Enabled";
-const char S_HIDDEN[]                          PROGMEM = "hidden";
-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_IMMERGAS_FIX[]                    PROGMEM = "immergasFix";
-const char S_INDOOR_TEMP[]                     PROGMEM = "indoorTemp";
-const char S_INDOOR_TEMP_CONTROL[]             PROGMEM = "indoorTempControl";
-const char S_IN_GPIO[]                         PROGMEM = "inGpio";
-const char S_INPUT[]                           PROGMEM = "input";
-const char S_INTERVAL[]                        PROGMEM = "interval";
-const char S_INVERT_STATE[]                    PROGMEM = "invertState";
-const char S_IP[]                              PROGMEM = "ip";
-const char S_I_FACTOR[]                        PROGMEM = "i_factor";
-const char S_K_FACTOR[]                        PROGMEM = "k_factor";
-const char S_LOGIN[]                           PROGMEM = "login";
-const char S_LOG_LEVEL[]                       PROGMEM = "logLevel";
-const char S_MAC[]                             PROGMEM = "mac";
-const char S_MASTER[]                          PROGMEM = "master";
-const char S_MAX[]                             PROGMEM = "max";
-const char S_MAX_FREE_BLOCK[]                  PROGMEM = "maxFreeBlock";
-const char S_MAX_MODULATION[]                  PROGMEM = "maxModulation";
-const char S_MAX_POWER[]                       PROGMEM = "maxPower";
-const char S_MAX_TEMP[]                        PROGMEM = "maxTemp";
-const char S_MEMBER_ID[]                       PROGMEM = "memberId";
-const char S_MIN[]                             PROGMEM = "min";
-const char S_MIN_FREE[]                        PROGMEM = "minFree";
-const char S_MIN_MAX_FREE_BLOCK[]              PROGMEM = "minMaxFreeBlock";
-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";
-const char S_NETWORK[]                         PROGMEM = "network";
-const char S_N_FACTOR[]                        PROGMEM = "n_factor";
-const char S_OFFSET[]                          PROGMEM = "offset";
-const char S_ON_ENABLED_HEATING[]              PROGMEM = "onEnabledHeating";
-const char S_ON_FAULT[]                        PROGMEM = "onFault";
-const char S_ON_LOSS_CONNECTION[]              PROGMEM = "onLossConnection";
-const char S_OPENTHERM[]                       PROGMEM = "opentherm";
-const char S_OUTDOOR_TEMP[]                    PROGMEM = "outdoorTemp";
-const char S_OUT_GPIO[]                        PROGMEM = "outGpio";
-const char S_OUTPUT[]                          PROGMEM = "output";
-const char S_PASSWORD[]                        PROGMEM = "password";
-const char S_PID[]                             PROGMEM = "pid";
-const char S_PORT[]                            PROGMEM = "port";
-const char S_PORTAL[]                          PROGMEM = "portal";
-const char S_POST_CIRCULATION_TIME[]           PROGMEM = "postCirculationTime";
-const char S_POWER[]                           PROGMEM = "power";
-const char S_PREFIX[]                          PROGMEM = "prefix";
-const char S_PROTOCOL_VERSION[]                PROGMEM = "protocolVersion";
-const char S_PURPOSE[]                         PROGMEM = "purpose";
-const char S_P_FACTOR[]                        PROGMEM = "p_factor";
-const char S_REAL_SIZE[]                       PROGMEM = "realSize";
-const char S_REASON[]                          PROGMEM = "reason";
-const char S_RESET_DIAGNOSTIC[]                PROGMEM = "resetDiagnostic";
-const char S_RESET_FAULT[]                     PROGMEM = "resetFault";
-const char S_RESET_REASON[]                    PROGMEM = "resetReason";
-const char S_RESTART[]                         PROGMEM = "restart";
-const char S_RETURN_TEMP[]                     PROGMEM = "returnTemp";
-const char S_REV[]                             PROGMEM = "rev";
-const char S_RSSI[]                            PROGMEM = "rssi";
-const char S_RX_LED_GPIO[]                     PROGMEM = "rxLedGpio";
-const char S_SDK[]                             PROGMEM = "sdk";
-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_SIGNAL_QUALITY[]                  PROGMEM = "signalQuality";
-const char S_SIZE[]                            PROGMEM = "size";
-const char S_SLAVE[]                           PROGMEM = "slave";
-const char S_SSID[]                            PROGMEM = "ssid";
-const char S_STA[]                             PROGMEM = "sta";
-const char S_STATE[]                           PROGMEM = "state";
-const char S_STATIC_CONFIG[]                   PROGMEM = "staticConfig";
-const char S_STATUS_LED_GPIO[]                 PROGMEM = "statusLedGpio";
-const char S_SETPOINT_TEMP[]                   PROGMEM = "setpointTemp";
-const char S_SUBNET[]                          PROGMEM = "subnet";
-const char S_SUMMER_WINTER_MODE[]              PROGMEM = "summerWinterMode";
-const char S_SYSTEM[]                          PROGMEM = "system";
-const char S_TARGET[]                          PROGMEM = "target";
-const char S_TARGET_TEMP[]                     PROGMEM = "targetTemp";
-const char S_TELNET[]                          PROGMEM = "telnet";
-const char S_TEMPERATURE[]                     PROGMEM = "temperature";
-const char S_THRESHOLD_TIME[]                  PROGMEM = "thresholdTime";
-const char S_TOTAL[]                           PROGMEM = "total";
-const char S_TRESHOLD_TIME[]                   PROGMEM = "tresholdTime";
-const char S_TURBO[]                           PROGMEM = "turbo";
-const char S_TURBO_FACTOR[]                    PROGMEM = "turboFactor";
-const char S_TYPE[]                            PROGMEM = "type";
-const char S_T_FACTOR[]                        PROGMEM = "t_factor";
-const char S_UNIT_SYSTEM[]                     PROGMEM = "unitSystem";
-const char S_UPTIME[]                          PROGMEM = "uptime";
-const char S_USE[]                             PROGMEM = "use";
-const char S_USE_DHCP[]                        PROGMEM = "useDhcp";
-const char S_USER[]                            PROGMEM = "user";
-const char S_VALUE[]                           PROGMEM = "value";
-const char S_VERSION[]                         PROGMEM = "version";
+const char S_ACTIONS[]                              PROGMEM = "actions";
+const char S_ACTIVE[]                               PROGMEM = "active";
+const char S_ADDRESS[]                              PROGMEM = "address";
+const char S_ANTI_STUCK_INTERVAL[]                  PROGMEM = "antiStuckInterval";
+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";
+const char S_BLOCKING[]                             PROGMEM = "blocking";
+const char S_BSSID[]                                PROGMEM = "bssid";
+const char S_BUILD[]                                PROGMEM = "build";
+const char S_CASCADE_CONTROL[]                      PROGMEM = "cascadeControl";
+const char S_CHANNEL[]                              PROGMEM = "channel";
+const char S_CH2_ALWAYS_ENABLED[]                   PROGMEM = "ch2AlwaysEnabled";
+const char S_CHIP[]                                 PROGMEM = "chip";
+const char S_CODE[]                                 PROGMEM = "code";
+const char S_CONNECTED[]                            PROGMEM = "connected";
+const char S_CONTINUES[]                            PROGMEM = "continues";
+const char S_COOLING[]                              PROGMEM = "cooling";
+const char S_COOLING_SUPPORT[]                      PROGMEM = "coolingSupport";
+const char S_CORE[]                                 PROGMEM = "core";
+const char S_CORES[]                                PROGMEM = "cores";
+const char S_CRASH[]                                PROGMEM = "crash";
+const char S_CURRENT_TEMP[]                         PROGMEM = "currentTemp";
+const char S_DATA[]                                 PROGMEM = "data";
+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_SUPPORT[]                          PROGMEM = "dhwSupport";
+const char S_DHW_TO_CH2[]                           PROGMEM = "dhwToCh2";
+const char S_DIAG[]                                 PROGMEM = "diag";
+const char S_DNS[]                                  PROGMEM = "dns";
+const char S_DT[]                                   PROGMEM = "dt";
+const char S_D_FACTOR[]                             PROGMEM = "d_factor";
+const char S_D_MULTIPLIER[]                         PROGMEM = "d_multiplier";
+const char S_EMERGENCY[]                            PROGMEM = "emergency";
+const char S_ENABLED[]                              PROGMEM = "enabled";
+const char S_ENV[]                                  PROGMEM = "env";
+const char S_EPC[]                                  PROGMEM = "epc";
+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_FILTERING[]                            PROGMEM = "filtering";
+const char S_FILTERING_FACTOR[]                     PROGMEM = "filteringFactor";
+const char S_FLAGS[]                                PROGMEM = "flags";
+const char S_FLAME[]                                PROGMEM = "flame";
+const char S_FLASH[]                                PROGMEM = "flash";
+const char S_FREE[]                                 PROGMEM = "free";
+const char S_FREQ[]                                 PROGMEM = "freq";
+const char S_GATEWAY[]                              PROGMEM = "gateway";
+const char S_GET_MIN_MAX_TEMP[]                     PROGMEM = "getMinMaxTemp";
+const char S_GPIO[]                                 PROGMEM = "gpio";
+const char S_HEAP[]                                 PROGMEM = "heap";
+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_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";
+const char S_IN_GPIO[]                              PROGMEM = "inGpio";
+const char S_INPUT[]                                PROGMEM = "input";
+const char S_INTERVAL[]                             PROGMEM = "interval";
+const char S_INVERT_STATE[]                         PROGMEM = "invertState";
+const char S_IP[]                                   PROGMEM = "ip";
+const char S_I_FACTOR[]                             PROGMEM = "i_factor";
+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_MAC[]                                  PROGMEM = "mac";
+const char S_MASTER[]                               PROGMEM = "master";
+const char S_MAX[]                                  PROGMEM = "max";
+const char S_MAX_FREE_BLOCK[]                       PROGMEM = "maxFreeBlock";
+const char S_MAX_MODULATION[]                       PROGMEM = "maxModulation";
+const char S_MAX_POWER[]                            PROGMEM = "maxPower";
+const char S_MAX_TEMP[]                             PROGMEM = "maxTemp";
+const char S_MAX_TEMP_SYNC_WITH_TARGET_TEMP[]       PROGMEM = "maxTempSyncWithTargetTemp";
+const char S_MDNS[]                                 PROGMEM = "mdns";
+const char S_MEMBER_ID[]                            PROGMEM = "memberId";
+const char S_MIN[]                                  PROGMEM = "min";
+const char S_MIN_FREE[]                             PROGMEM = "minFree";
+const char S_MIN_MAX_FREE_BLOCK[]                   PROGMEM = "minMaxFreeBlock";
+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_MQTT[]                                 PROGMEM = "mqtt";
+const char S_NAME[]                                 PROGMEM = "name";
+const char S_NATIVE_HEATING_CONTROL[]               PROGMEM = "nativeHeatingControl";
+const char S_NETWORK[]                              PROGMEM = "network";
+const char S_NTP[]                                  PROGMEM = "ntp";
+const char S_N_FACTOR[]                             PROGMEM = "n_factor";
+const char S_OFFSET[]                               PROGMEM = "offset";
+const char S_ON_ENABLED_HEATING[]                   PROGMEM = "onEnabledHeating";
+const char S_ON_FAULT[]                             PROGMEM = "onFault";
+const char S_ON_LOSS_CONNECTION[]                   PROGMEM = "onLossConnection";
+const char S_OPENTHERM[]                            PROGMEM = "opentherm";
+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_PASSWORD[]                             PROGMEM = "password";
+const char S_PID[]                                  PROGMEM = "pid";
+const char S_PORT[]                                 PROGMEM = "port";
+const char S_PORTAL[]                               PROGMEM = "portal";
+const char S_POST_CIRCULATION_TIME[]                PROGMEM = "postCirculationTime";
+const char S_POWER[]                                PROGMEM = "power";
+const char S_PREFIX[]                               PROGMEM = "prefix";
+const char S_PROTOCOL_VERSION[]                     PROGMEM = "protocolVersion";
+const char S_PURPOSE[]                              PROGMEM = "purpose";
+const char S_P_FACTOR[]                             PROGMEM = "p_factor";
+const char S_P_MULTIPLIER[]                         PROGMEM = "p_multiplier";
+const char S_REAL_SIZE[]                            PROGMEM = "realSize";
+const char S_REASON[]                               PROGMEM = "reason";
+const char S_RESET_DIAGNOSTIC[]                     PROGMEM = "resetDiagnostic";
+const char S_RESET_FAULT[]                          PROGMEM = "resetFault";
+const char S_RESET_REASON[]                         PROGMEM = "resetReason";
+const char S_RESTART[]                              PROGMEM = "restart";
+const char S_RETURN_TEMP[]                          PROGMEM = "returnTemp";
+const char S_REV[]                                  PROGMEM = "rev";
+const char S_RSSI[]                                 PROGMEM = "rssi";
+const char S_RX_LED_GPIO[]                          PROGMEM = "rxLedGpio";
+const char S_SDK[]                                  PROGMEM = "sdk";
+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";
+const char S_SSID[]                                 PROGMEM = "ssid";
+const char S_STA[]                                  PROGMEM = "sta";
+const char S_STATE[]                                PROGMEM = "state";
+const char S_STATIC_CONFIG[]                        PROGMEM = "staticConfig";
+const char S_STATUS_LED_GPIO[]                      PROGMEM = "statusLedGpio";
+const char S_SETPOINT_TEMP[]                        PROGMEM = "setpointTemp";
+const char S_SUBNET[]                               PROGMEM = "subnet";
+const char S_SUMMER_WINTER_MODE[]                   PROGMEM = "summerWinterMode";
+const char S_SYSTEM[]                               PROGMEM = "system";
+const char S_TARGET[]                               PROGMEM = "target";
+const char S_TARGET_TEMP[]                          PROGMEM = "targetTemp";
+const char S_TELNET[]                               PROGMEM = "telnet";
+const char S_TEMPERATURE[]                          PROGMEM = "temperature";
+const char S_THRESHOLD_HIGH[]                       PROGMEM = "thresholdHigh";
+const char S_THRESHOLD_LOW[]                        PROGMEM = "thresholdLow";
+const char S_THRESHOLD_TIME[]                       PROGMEM = "thresholdTime";
+const char S_TIMEZONE[]                             PROGMEM = "timezone";
+const char S_TOTAL[]                                PROGMEM = "total";
+const char S_TRESHOLD_TIME[]                        PROGMEM = "tresholdTime";
+const char S_TURBO[]                                PROGMEM = "turbo";
+const char S_TURBO_FACTOR[]                         PROGMEM = "turboFactor";
+const char S_TYPE[]                                 PROGMEM = "type";
+const char S_T_FACTOR[]                             PROGMEM = "t_factor";
+const char S_UNIT_SYSTEM[]                          PROGMEM = "unitSystem";
+const char S_UPTIME[]                               PROGMEM = "uptime";
+const char S_USE[]                                  PROGMEM = "use";
+const char S_USE_DHCP[]                             PROGMEM = "useDhcp";
+const char S_USER[]                                 PROGMEM = "user";
+const char S_VALUE[]                                PROGMEM = "value";
+const char S_VERSION[]                              PROGMEM = "version";

src/utils.h

@@ -1,5 +1,75 @@
 #include <Arduino.h>
 
+String getChipId(const char* prefix = nullptr, const char* suffix = nullptr) {
+  String chipId;
+  chipId.reserve(
+    6
+    + (prefix != nullptr ? strlen(prefix) : 0)
+    + (suffix != nullptr ? strlen(suffix) : 0)
+  );
+  
+  if (prefix != nullptr) {
+    chipId.concat(prefix);
+  }
+
+  uint32_t cid = 0;
+  #if defined(ARDUINO_ARCH_ESP8266)
+  cid = ESP.getChipId();
+  #elif defined(ARDUINO_ARCH_ESP32)
+  // https://github.com/espressif/arduino-esp32/blob/master/libraries/ESP32/examples/ChipID/GetChipID/GetChipID.ino
+  for (uint8_t i = 0; i < 17; i = i + 8) {
+    cid |= ((ESP.getEfuseMac() >> (40 - i)) & 0xff) << i;
+  }
+  #endif
+
+  chipId += String(cid, HEX);
+
+  if (suffix != nullptr) {
+    chipId.concat(suffix);
+  }
+
+  chipId.trim();
+  return chipId;
+}
+
+bool isLeapYear(short year) {
+  if (year % 4 != 0) {
+    return false;
+  }
+
+  if (year % 100 != 0) {
+    return true;
+  }
+
+  return (year % 400) == 0;
+}
+
+// convert UTC tm time to time_t epoch time
+// source: https://github.com/cyberman54/ESP32-Paxcounter/blob/master/src/timekeeper.cpp
+time_t mkgmtime(const struct tm *ptm) {
+  const int SecondsPerMinute = 60;
+  const int SecondsPerHour = 3600;
+  const int SecondsPerDay = 86400;
+  const int DaysOfMonth[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
+  time_t secs = 0;
+  // tm_year is years since 1900
+  int year = ptm->tm_year + 1900;
+  for (int y = 1970; y < year; ++y) {
+    secs += (isLeapYear(y) ? 366 : 365) * SecondsPerDay;
+  }
+  // tm_mon is month from 0..11
+  for (int m = 0; m < ptm->tm_mon; ++m) {
+    secs += DaysOfMonth[m] * SecondsPerDay;
+    if (m == 1 && isLeapYear(year))
+      secs += SecondsPerDay;
+  }
+  secs += (ptm->tm_mday - 1) * SecondsPerDay;
+  secs += ptm->tm_hour * SecondsPerHour;
+  secs += ptm->tm_min * SecondsPerMinute;
+  secs += ptm->tm_sec;
+  return secs;
+}
+
 inline bool isDigit(const char* ptr) {
   char* endPtr;
   strtol(ptr, &endPtr, 10);
@@ -359,6 +429,10 @@ void settingsToJson(const Settings& src, JsonVariant dst, bool safe = false) {
     telnet[FPSTR(S_ENABLED)] = src.system.telnet.enabled;
     telnet[FPSTR(S_PORT)] = src.system.telnet.port;
 
+    auto ntp = system[FPSTR(S_NTP)].to<JsonObject>();
+    ntp[FPSTR(S_SERVER)] = src.system.ntp.server;
+    ntp[FPSTR(S_TIMEZONE)] = src.system.ntp.timezone;
+
     system[FPSTR(S_UNIT_SYSTEM)] = static_cast<uint8_t>(src.system.unitSystem);
     system[FPSTR(S_STATUS_LED_GPIO)] = src.system.statusLedGpio;
 
@@ -366,6 +440,7 @@ void settingsToJson(const Settings& src, JsonVariant dst, bool safe = false) {
     portal[FPSTR(S_AUTH)] = src.portal.auth;
     portal[FPSTR(S_LOGIN)] = src.portal.login;
     portal[FPSTR(S_PASSWORD)] = src.portal.password;
+    portal[FPSTR(S_MDNS)] = src.portal.mdns;
 
     auto opentherm = dst[FPSTR(S_OPENTHERM)].to<JsonObject>();
     opentherm[FPSTR(S_UNIT_SYSTEM)] = static_cast<uint8_t>(src.opentherm.unitSystem);
@@ -374,19 +449,26 @@ 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);
-    opentherm[FPSTR(S_DHW_PRESENT)] = src.opentherm.dhwPresent;
-    opentherm[FPSTR(S_SUMMER_WINTER_MODE)] = src.opentherm.summerWinterMode;
-    opentherm[FPSTR(S_HEATING_CH2_ENABLED)] = src.opentherm.heatingCh2Enabled;
-    opentherm[FPSTR(S_HEATING_CH1_TO_CH2)] = src.opentherm.heatingCh1ToCh2;
-    opentherm[FPSTR(S_DHW_TO_CH2)] = src.opentherm.dhwToCh2;
-    opentherm[FPSTR(S_DHW_BLOCKING)] = src.opentherm.dhwBlocking;
-    opentherm[FPSTR(S_MODULATION_SYNC_WITH_HEATING)] = src.opentherm.modulationSyncWithHeating;
-    opentherm[FPSTR(S_GET_MIN_MAX_TEMP)] = src.opentherm.getMinMaxTemp;
-    opentherm[FPSTR(S_NATIVE_HEATING_CONTROL)] = src.opentherm.nativeHeatingControl;
-    opentherm[FPSTR(S_IMMERGAS_FIX)] = src.opentherm.immergasFix;
+
+    auto otOptions = opentherm[FPSTR(S_OPTIONS)].to<JsonObject>();
+    otOptions[FPSTR(S_DHW_SUPPORT)] = src.opentherm.options.dhwSupport;
+    otOptions[FPSTR(S_COOLING_SUPPORT)] = src.opentherm.options.coolingSupport;
+    otOptions[FPSTR(S_SUMMER_WINTER_MODE)] = src.opentherm.options.summerWinterMode;
+    otOptions[FPSTR(S_HEATING_STATE_TO_SUMMER_WINTER_MODE)] = src.opentherm.options.heatingStateToSummerWinterMode;
+    otOptions[FPSTR(S_CH2_ALWAYS_ENABLED)] = src.opentherm.options.ch2AlwaysEnabled;
+    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_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;
 
     auto mqtt = dst[FPSTR(S_MQTT)].to<JsonObject>();
     mqtt[FPSTR(S_ENABLED)] = src.mqtt.enabled;
@@ -411,12 +493,14 @@ 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 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 equitherm = dst[FPSTR(S_EQUITHERM)].to<JsonObject>();
   equitherm[FPSTR(S_ENABLED)] = src.equitherm.enabled;
@@ -433,6 +517,14 @@ void settingsToJson(const Settings& src, JsonVariant dst, bool safe = false) {
   pid[FPSTR(S_MIN_TEMP)] = src.pid.minTemp;
   pid[FPSTR(S_MAX_TEMP)] = src.pid.maxTemp;
 
+  auto pidDeadband = pid[FPSTR(S_DEADBAND)].to<JsonObject>();
+  pidDeadband[FPSTR(S_ENABLED)] = src.pid.deadband.enabled;
+  pidDeadband[FPSTR(S_P_MULTIPLIER)] = src.pid.deadband.p_multiplier;
+  pidDeadband[FPSTR(S_I_MULTIPLIER)] = src.pid.deadband.i_multiplier;
+  pidDeadband[FPSTR(S_D_MULTIPLIER)] = src.pid.deadband.d_multiplier;
+  pidDeadband[FPSTR(S_THRESHOLD_HIGH)] = src.pid.deadband.thresholdHigh;
+  pidDeadband[FPSTR(S_THRESHOLD_LOW)] = src.pid.deadband.thresholdLow;
+
   if (!safe) {
     auto externalPump = dst[FPSTR(S_EXTERNAL_PUMP)].to<JsonObject>();
     externalPump[FPSTR(S_USE)] = src.externalPump.use;
@@ -514,6 +606,24 @@ bool jsonToSettings(const JsonVariantConst src, Settings& dst, bool safe = false
       }
     }
 
+    if (!src[FPSTR(S_SYSTEM)][FPSTR(S_NTP)][FPSTR(S_SERVER)].isNull()) {
+      String value = src[FPSTR(S_SYSTEM)][FPSTR(S_NTP)][FPSTR(S_SERVER)].as<String>();
+
+      if (value.length() < sizeof(dst.system.ntp.server) && !value.equals(dst.system.ntp.server)) {
+        strcpy(dst.system.ntp.server, value.c_str());
+        changed = true;
+      }
+    }
+
+    if (!src[FPSTR(S_SYSTEM)][FPSTR(S_NTP)][FPSTR(S_TIMEZONE)].isNull()) {
+      String value = src[FPSTR(S_SYSTEM)][FPSTR(S_NTP)][FPSTR(S_TIMEZONE)].as<String>();
+
+      if (value.length() < sizeof(dst.system.ntp.timezone) && !value.equals(dst.system.ntp.timezone)) {
+        strcpy(dst.system.ntp.timezone, value.c_str());
+        changed = true;
+      }
+    }
+
     if (!src[FPSTR(S_SYSTEM)][FPSTR(S_UNIT_SYSTEM)].isNull()) {
       uint8_t value = src[FPSTR(S_SYSTEM)][FPSTR(S_UNIT_SYSTEM)].as<unsigned char>();
       UnitSystem prevUnitSystem = dst.system.unitSystem;
@@ -597,6 +707,20 @@ bool jsonToSettings(const JsonVariantConst src, Settings& dst, bool safe = false
       }
     }
 
+    if (dst.portal.auth && (!strlen(dst.portal.login) || !strlen(dst.portal.password))) {
+      dst.portal.auth = false;
+      changed = true;
+    }
+
+    if (src[FPSTR(S_PORTAL)][FPSTR(S_MDNS)].is<bool>()) {
+      bool value = src[FPSTR(S_PORTAL)][FPSTR(S_MDNS)].as<bool>();
+
+      if (value != dst.portal.mdns) {
+        dst.portal.mdns = value;
+        changed = true;
+      }
+    }
+
 
     // opentherm
     if (!src[FPSTR(S_OPENTHERM)][FPSTR(S_UNIT_SYSTEM)].isNull()) {
@@ -691,15 +815,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>();
 
@@ -718,101 +833,155 @@ bool jsonToSettings(const JsonVariantConst src, Settings& dst, bool safe = false
       }
     }
 
-    if (src[FPSTR(S_OPENTHERM)][FPSTR(S_DHW_PRESENT)].is<bool>()) {
-      bool value = src[FPSTR(S_OPENTHERM)][FPSTR(S_DHW_PRESENT)].as<bool>();
+    if (src[FPSTR(S_OPENTHERM)][FPSTR(S_OPTIONS)][FPSTR(S_DHW_SUPPORT)].is<bool>()) {
+      bool value = src[FPSTR(S_OPENTHERM)][FPSTR(S_OPTIONS)][FPSTR(S_DHW_SUPPORT)].as<bool>();
 
-      if (value != dst.opentherm.dhwPresent) {
-        dst.opentherm.dhwPresent = value;
+      if (value != dst.opentherm.options.dhwSupport) {
+        dst.opentherm.options.dhwSupport = value;
         changed = true;
       }
     }
 
-    if (src[FPSTR(S_OPENTHERM)][FPSTR(S_SUMMER_WINTER_MODE)].is<bool>()) {
-      bool value = src[FPSTR(S_OPENTHERM)][FPSTR(S_SUMMER_WINTER_MODE)].as<bool>();
+    if (src[FPSTR(S_OPENTHERM)][FPSTR(S_OPTIONS)][FPSTR(S_COOLING_SUPPORT)].is<bool>()) {
+      bool value = src[FPSTR(S_OPENTHERM)][FPSTR(S_OPTIONS)][FPSTR(S_COOLING_SUPPORT)].as<bool>();
 
-      if (value != dst.opentherm.summerWinterMode) {
-        dst.opentherm.summerWinterMode = value;
+      if (value != dst.opentherm.options.coolingSupport) {
+        dst.opentherm.options.coolingSupport = value;
         changed = true;
       }
     }
 
-    if (src[FPSTR(S_OPENTHERM)][FPSTR(S_HEATING_CH2_ENABLED)].is<bool>()) {
-      bool value = src[FPSTR(S_OPENTHERM)][FPSTR(S_HEATING_CH2_ENABLED)].as<bool>();
+    if (src[FPSTR(S_OPENTHERM)][FPSTR(S_OPTIONS)][FPSTR(S_SUMMER_WINTER_MODE)].is<bool>()) {
+      bool value = src[FPSTR(S_OPENTHERM)][FPSTR(S_OPTIONS)][FPSTR(S_SUMMER_WINTER_MODE)].as<bool>();
 
-      if (value != dst.opentherm.heatingCh2Enabled) {
-        dst.opentherm.heatingCh2Enabled = value;
+      if (value != dst.opentherm.options.summerWinterMode) {
+        dst.opentherm.options.summerWinterMode = value;
+        changed = true;
+      }
+    }
 
-        if (dst.opentherm.heatingCh2Enabled) {
-          dst.opentherm.heatingCh1ToCh2 = false;
-          dst.opentherm.dhwToCh2 = false;
+    if (src[FPSTR(S_OPENTHERM)][FPSTR(S_OPTIONS)][FPSTR(S_HEATING_STATE_TO_SUMMER_WINTER_MODE)].is<bool>()) {
+      bool value = src[FPSTR(S_OPENTHERM)][FPSTR(S_OPTIONS)][FPSTR(S_HEATING_STATE_TO_SUMMER_WINTER_MODE)].as<bool>();
+
+      if (value != dst.opentherm.options.heatingStateToSummerWinterMode) {
+        dst.opentherm.options.heatingStateToSummerWinterMode = value;
+        changed = true;
+      }
+    }
+
+    if (src[FPSTR(S_OPENTHERM)][FPSTR(S_OPTIONS)][FPSTR(S_CH2_ALWAYS_ENABLED)].is<bool>()) {
+      bool value = src[FPSTR(S_OPENTHERM)][FPSTR(S_OPTIONS)][FPSTR(S_CH2_ALWAYS_ENABLED)].as<bool>();
+
+      if (value != dst.opentherm.options.ch2AlwaysEnabled) {
+        dst.opentherm.options.ch2AlwaysEnabled = value;
+
+        if (dst.opentherm.options.ch2AlwaysEnabled) {
+          dst.opentherm.options.heatingToCh2 = false;
+          dst.opentherm.options.dhwToCh2 = false;
         }
 
         changed = true;
       }
     }
 
-    if (src[FPSTR(S_OPENTHERM)][FPSTR(S_HEATING_CH1_TO_CH2)].is<bool>()) {
-      bool value = src[FPSTR(S_OPENTHERM)][FPSTR(S_HEATING_CH1_TO_CH2)].as<bool>();
+    if (src[FPSTR(S_OPENTHERM)][FPSTR(S_OPTIONS)][FPSTR(S_HEATING_TO_CH2)].is<bool>()) {
+      bool value = src[FPSTR(S_OPENTHERM)][FPSTR(S_OPTIONS)][FPSTR(S_HEATING_TO_CH2)].as<bool>();
 
-      if (value != dst.opentherm.heatingCh1ToCh2) {
-        dst.opentherm.heatingCh1ToCh2 = value;
+      if (value != dst.opentherm.options.heatingToCh2) {
+        dst.opentherm.options.heatingToCh2 = value;
 
-        if (dst.opentherm.heatingCh1ToCh2) {
-          dst.opentherm.heatingCh2Enabled = false;
-          dst.opentherm.dhwToCh2 = false;
+        if (dst.opentherm.options.heatingToCh2) {
+          dst.opentherm.options.ch2AlwaysEnabled = false;
+          dst.opentherm.options.dhwToCh2 = false;
         }
 
         changed = true;
       }
     }
 
-    if (src[FPSTR(S_OPENTHERM)][FPSTR(S_DHW_TO_CH2)].is<bool>()) {
-      bool value = src[FPSTR(S_OPENTHERM)][FPSTR(S_DHW_TO_CH2)].as<bool>();
+    if (src[FPSTR(S_OPENTHERM)][FPSTR(S_OPTIONS)][FPSTR(S_DHW_TO_CH2)].is<bool>()) {
+      bool value = src[FPSTR(S_OPENTHERM)][FPSTR(S_OPTIONS)][FPSTR(S_DHW_TO_CH2)].as<bool>();
 
-      if (value != dst.opentherm.dhwToCh2) {
-        dst.opentherm.dhwToCh2 = value;
+      if (value != dst.opentherm.options.dhwToCh2) {
+        dst.opentherm.options.dhwToCh2 = value;
 
-        if (dst.opentherm.dhwToCh2) {
-          dst.opentherm.heatingCh2Enabled = false;
-          dst.opentherm.heatingCh1ToCh2 = false;
+        if (dst.opentherm.options.dhwToCh2) {
+          dst.opentherm.options.ch2AlwaysEnabled = false;
+          dst.opentherm.options.heatingToCh2 = false;
         }
 
         changed = true;
       }
     }
 
-    if (src[FPSTR(S_OPENTHERM)][FPSTR(S_DHW_BLOCKING)].is<bool>()) {
-      bool value = src[FPSTR(S_OPENTHERM)][FPSTR(S_DHW_BLOCKING)].as<bool>();
+    if (src[FPSTR(S_OPENTHERM)][FPSTR(S_OPTIONS)][FPSTR(S_DHW_BLOCKING)].is<bool>()) {
+      bool value = src[FPSTR(S_OPENTHERM)][FPSTR(S_OPTIONS)][FPSTR(S_DHW_BLOCKING)].as<bool>();
 
-      if (value != dst.opentherm.dhwBlocking) {
-        dst.opentherm.dhwBlocking = value;
+      if (value != dst.opentherm.options.dhwBlocking) {
+        dst.opentherm.options.dhwBlocking = value;
         changed = true;
       }
     }
 
-    if (src[FPSTR(S_OPENTHERM)][FPSTR(S_MODULATION_SYNC_WITH_HEATING)].is<bool>()) {
-      bool value = src[FPSTR(S_OPENTHERM)][FPSTR(S_MODULATION_SYNC_WITH_HEATING)].as<bool>();
+    if (src[FPSTR(S_OPENTHERM)][FPSTR(S_OPTIONS)][FPSTR(S_MAX_TEMP_SYNC_WITH_TARGET_TEMP)].is<bool>()) {
+      bool value = src[FPSTR(S_OPENTHERM)][FPSTR(S_OPTIONS)][FPSTR(S_MAX_TEMP_SYNC_WITH_TARGET_TEMP)].as<bool>();
 
-      if (value != dst.opentherm.modulationSyncWithHeating) {
-        dst.opentherm.modulationSyncWithHeating = value;
+      if (value != dst.opentherm.options.maxTempSyncWithTargetTemp) {
+        dst.opentherm.options.maxTempSyncWithTargetTemp = value;
         changed = true;
       }
     }
 
-    if (src[FPSTR(S_OPENTHERM)][FPSTR(S_GET_MIN_MAX_TEMP)].is<bool>()) {
-      bool value = src[FPSTR(S_OPENTHERM)][FPSTR(S_GET_MIN_MAX_TEMP)].as<bool>();
+    if (src[FPSTR(S_OPENTHERM)][FPSTR(S_OPTIONS)][FPSTR(S_GET_MIN_MAX_TEMP)].is<bool>()) {
+      bool value = src[FPSTR(S_OPENTHERM)][FPSTR(S_OPTIONS)][FPSTR(S_GET_MIN_MAX_TEMP)].as<bool>();
 
-      if (value != dst.opentherm.getMinMaxTemp) {
-        dst.opentherm.getMinMaxTemp = value;
+      if (value != dst.opentherm.options.getMinMaxTemp) {
+        dst.opentherm.options.getMinMaxTemp = value;
         changed = true;
       }
     }
 
-    if (src[FPSTR(S_OPENTHERM)][FPSTR(S_NATIVE_HEATING_CONTROL)].is<bool>()) {
-      bool value = src[FPSTR(S_OPENTHERM)][FPSTR(S_NATIVE_HEATING_CONTROL)].as<bool>();
+    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.nativeHeatingControl) {
-        dst.opentherm.nativeHeatingControl = value;
+      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>();
+
+      if (value != dst.opentherm.options.nativeHeatingControl) {
+        dst.opentherm.options.nativeHeatingControl = value;
 
         if (value) {
           dst.equitherm.enabled = false;
@@ -823,11 +992,11 @@ bool jsonToSettings(const JsonVariantConst src, Settings& dst, bool safe = false
       }
     }
 
-    if (src[FPSTR(S_OPENTHERM)][FPSTR(S_IMMERGAS_FIX)].is<bool>()) {
-      bool value = src[FPSTR(S_OPENTHERM)][FPSTR(S_IMMERGAS_FIX)].as<bool>();
+    if (src[FPSTR(S_OPENTHERM)][FPSTR(S_OPTIONS)][FPSTR(S_IMMERGAS_FIX)].is<bool>()) {
+      bool value = src[FPSTR(S_OPENTHERM)][FPSTR(S_OPTIONS)][FPSTR(S_IMMERGAS_FIX)].as<bool>();
 
-      if (value != dst.opentherm.immergasFix) {
-        dst.opentherm.immergasFix = value;
+      if (value != dst.opentherm.options.immergasFix) {
+        dst.opentherm.options.immergasFix = value;
         changed = true;
       }
     }
@@ -923,7 +1092,7 @@ bool jsonToSettings(const JsonVariantConst src, Settings& dst, bool safe = false
   if (src[FPSTR(S_EQUITHERM)][FPSTR(S_ENABLED)].is<bool>()) {
     bool value = src[FPSTR(S_EQUITHERM)][FPSTR(S_ENABLED)].as<bool>();
 
-    if (!dst.opentherm.nativeHeatingControl) {
+    if (!dst.opentherm.options.nativeHeatingControl) {
       if (value != dst.equitherm.enabled) {
         dst.equitherm.enabled = value;
         changed = true;
@@ -967,7 +1136,7 @@ bool jsonToSettings(const JsonVariantConst src, Settings& dst, bool safe = false
   if (src[FPSTR(S_PID)][FPSTR(S_ENABLED)].is<bool>()) {
     bool value = src[FPSTR(S_PID)][FPSTR(S_ENABLED)].as<bool>();
 
-    if (!dst.opentherm.nativeHeatingControl) {
+    if (!dst.opentherm.options.nativeHeatingControl) {
       if (value != dst.pid.enabled) {
         dst.pid.enabled = value;
         changed = true;
@@ -1038,6 +1207,60 @@ bool jsonToSettings(const JsonVariantConst src, Settings& dst, bool safe = false
     changed = true;
   }
 
+  if (src[FPSTR(S_PID)][FPSTR(S_DEADBAND)][FPSTR(S_ENABLED)].is<bool>()) {
+    bool value = src[FPSTR(S_PID)][FPSTR(S_DEADBAND)][FPSTR(S_ENABLED)].as<bool>();
+
+    if (value != dst.pid.deadband.enabled) {
+      dst.pid.deadband.enabled = value;
+      changed = true;
+    }
+  }
+
+  if (!src[FPSTR(S_PID)][FPSTR(S_DEADBAND)][FPSTR(S_P_MULTIPLIER)].isNull()) {
+    float value = src[FPSTR(S_PID)][FPSTR(S_DEADBAND)][FPSTR(S_P_MULTIPLIER)].as<float>();
+
+    if (value >= 0 && value <= 1 && fabsf(value - dst.pid.deadband.p_multiplier) > 0.0001f) {
+      dst.pid.deadband.p_multiplier = roundf(value, 3);
+      changed = true;
+    }
+  }
+
+  if (!src[FPSTR(S_PID)][FPSTR(S_DEADBAND)][FPSTR(S_I_MULTIPLIER)].isNull()) {
+    float value = src[FPSTR(S_PID)][FPSTR(S_DEADBAND)][FPSTR(S_I_MULTIPLIER)].as<float>();
+
+    if (value >= 0 && value <= 1 && fabsf(value - dst.pid.deadband.i_multiplier) > 0.0001f) {
+      dst.pid.deadband.i_multiplier = roundf(value, 3);
+      changed = true;
+    }
+  }
+
+  if (!src[FPSTR(S_PID)][FPSTR(S_DEADBAND)][FPSTR(S_D_MULTIPLIER)].isNull()) {
+    float value = src[FPSTR(S_PID)][FPSTR(S_DEADBAND)][FPSTR(S_D_MULTIPLIER)].as<float>();
+
+    if (value >= 0 && value <= 1 && fabsf(value - dst.pid.deadband.d_multiplier) > 0.0001f) {
+      dst.pid.deadband.d_multiplier = roundf(value, 3);
+      changed = true;
+    }
+  }
+
+  if (!src[FPSTR(S_PID)][FPSTR(S_DEADBAND)][FPSTR(S_THRESHOLD_HIGH)].isNull()) {
+    float value = src[FPSTR(S_PID)][FPSTR(S_DEADBAND)][FPSTR(S_THRESHOLD_HIGH)].as<float>();
+
+    if (value >= 0.0f && value <= 5.0f && fabsf(value - dst.pid.deadband.thresholdHigh) > 0.0001f) {
+      dst.pid.deadband.thresholdHigh = roundf(value, 2);
+      changed = true;
+    }
+  }
+
+  if (!src[FPSTR(S_PID)][FPSTR(S_DEADBAND)][FPSTR(S_THRESHOLD_LOW)].isNull()) {
+    float value = src[FPSTR(S_PID)][FPSTR(S_DEADBAND)][FPSTR(S_THRESHOLD_LOW)].as<float>();
+
+    if (value >= 0.0f && value <= 5.0f && fabsf(value - dst.pid.deadband.thresholdLow) > 0.0001f) {
+      dst.pid.deadband.thresholdLow = roundf(value, 2);
+      changed = true;
+    }
+  }
+
 
   // heating
   if (src[FPSTR(S_HEATING)][FPSTR(S_ENABLED)].is<bool>()) {
@@ -1100,6 +1323,16 @@ 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;
+    }
+  }
+
+
   // dhw
   if (src[FPSTR(S_DHW)][FPSTR(S_ENABLED)].is<bool>()) {
     bool value = src[FPSTR(S_DHW)][FPSTR(S_ENABLED)].as<bool>();
@@ -1133,6 +1366,15 @@ 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 (!safe) {
     // external pump
@@ -1326,7 +1568,7 @@ bool jsonToSettings(const JsonVariantConst src, Settings& dst, bool safe = false
   // force check emergency target
   {
     float value = !src[FPSTR(S_EMERGENCY)][FPSTR(S_TARGET)].isNull() ? src[FPSTR(S_EMERGENCY)][FPSTR(S_TARGET)].as<float>() : dst.emergency.target;
-    bool noRegulators = !dst.opentherm.nativeHeatingControl;
+    bool noRegulators = !dst.opentherm.options.nativeHeatingControl;
     bool valid = isValidTemp(
       value,
       dst.system.unitSystem,
@@ -1351,7 +1593,7 @@ bool jsonToSettings(const JsonVariantConst src, Settings& dst, bool safe = false
 
   // force check heating target
   {
-    bool indoorTempControl = dst.equitherm.enabled || dst.pid.enabled || dst.opentherm.nativeHeatingControl;
+    bool indoorTempControl = dst.equitherm.enabled || dst.pid.enabled || dst.opentherm.options.nativeHeatingControl;
     float minTemp = indoorTempControl ? THERMOSTAT_INDOOR_MIN_TEMP : dst.heating.minTemp;
     float maxTemp = indoorTempControl ? THERMOSTAT_INDOOR_MAX_TEMP : dst.heating.maxTemp;
 
@@ -1491,6 +1733,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):
@@ -1535,6 +1778,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):
@@ -1632,7 +1884,7 @@ bool jsonToSensorSettings(const uint8_t sensorId, const JsonVariantConst src, Se
   if (!src[FPSTR(S_FACTOR)].isNull()) {
     float value = src[FPSTR(S_FACTOR)].as<float>();
 
-    if (value > 0.09f && value <= 10.0f && fabsf(value - dst.factor) > 0.0001f) {
+    if (value > 0.09f && value <= 100.0f && fabsf(value - dst.factor) > 0.0001f) {
       dst.factor = roundf(value, 3);
       changed = true;
     }
@@ -1720,6 +1972,7 @@ void varsToJson(const Variables& src, JsonVariant dst) {
   slave[FPSTR(S_PROTOCOL_VERSION)] = src.slave.appVersion;
   slave[FPSTR(S_CONNECTED)] = src.slave.connected;
   slave[FPSTR(S_FLAME)] = src.slave.flame;
+  slave[FPSTR(S_COOLING)] = src.slave.cooling;
 
   auto sModulation = slave[FPSTR(S_MODULATION)].to<JsonObject>();
   sModulation[FPSTR(S_MIN)] = src.slave.modulation.min;

src_data/locales/en.json

@@ -87,6 +87,18 @@
         "turbo": "Turbo mode"
       },
 
+      "notify": {
+        "fault": {
+          "title": "Boiler Fault state is active!",
+          "note": "It is recommended to inspect the boiler and study the documentation to interpret the fault code:"
+        },
+        "diag": {
+          "title": "Boiler Diagnostic state is active!",
+          "note": "Perhaps your boiler needs inspection? It is recommended study the documentation to interpret the diag code:"
+        },
+        "reset": "Try reset"
+      },
+
       "states": {
         "mNetworkConnected": "Network connection",
         "mMqttConnected": "MQTT connection",
@@ -97,8 +109,9 @@
 
         "sConnected": "OpenTherm connection",
         "sFlame": "Flame",
+        "sCooling": "Cooling",
         "sFaultActive": "Fault",
-        "sFaultCode": "Faul code",
+        "sFaultCode": "Fault code",
         "sDiagActive": "Diagnostic",
         "sDiagCode": "Diagnostic code",
         
@@ -188,6 +201,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",
@@ -218,6 +232,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",
@@ -279,11 +301,13 @@
         "min": "Minimum temperature",
         "max": "Maximum temperature"
       },
+      "maxModulation": "Max modulation level",
 
       "portal": {
         "login": "Login",
         "password": "Password",
-        "auth": "Require authentication"
+        "auth": "Require authentication",
+        "mdns": "Use mDNS"
       },
 
       "system": {
@@ -302,6 +326,11 @@
             "title": "Telnet port",
             "note": "Default: 23"
           }
+        },
+        "ntp": {
+          "server": "NTP server",
+          "timezone": "Timezone",
+          "timezonePresets": "Select preset..."
         }
       },
 
@@ -334,7 +363,19 @@
         "i": "I factor",
         "d": "D factor",
         "dt": "DT <small>in seconds</small>",
-        "noteMinMaxTemp": "<b>Important:</b> When using «Equitherm» and «PID» at the same time, the min and max temperatures limit the influence on the «Equitherm» result temperature.<br />Thus, if the min temperature is set to -15 and the max temperature is set to 15, then the final heat carrier setpoint will be from <code>equitherm_result - 15</code> to <code>equitherm_result + 15</code>."
+        "limits": {
+          "title": "Limits",
+          "note": "<b>Important:</b> When using «Equitherm» and «PID» at the same time, the min and max temperatures limit the influence on the «Equitherm» result temperature.<br />Thus, if the min temperature is set to -15 and the max temperature is set to 15, then the final heat carrier setpoint will be from <code>equitherm_result - 15</code> to <code>equitherm_result + 15</code>."
+        },
+        "deadband": {
+          "title": "Deadband",
+          "note": "Deadband is a range around the target temperature where PID regulation becomes less active. Within this range, the algorithm can reduce intensity or pause adjustments to avoid overreacting to small fluctuations.<br /><br />For instance, with a target temperature of 22°, a lower threshold of 1.0, and an upper threshold of 0.5, the deadband operates between 21° and 22.5°. If the I coefficient is 0.0005 and the I multiplier is 0.05, then within the deadband, the I coefficient becomes: <code>0.0005 * 0.05 = 0.000025</code>",
+          "p_multiplier": "Multiplier for P factor",
+          "i_multiplier": "Multiplier for I factor",
+          "d_multiplier": "Multiplier for D factor",
+          "thresholdHigh": "Threshold high",
+          "thresholdLow": "Threshold low"
+        }
       },
 
       "ot": {
@@ -344,7 +385,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\"."
@@ -356,14 +396,20 @@
 
         "options": {
           "desc": "Options",
-          "dhwPresent": "DHW present",
+          "dhwSupport": "DHW support",
+          "coolingSupport": "Cooling support",
           "summerWinterMode": "Summer/winter mode",
-          "heatingCh2Enabled": "Heating CH2 always enabled",
-          "heatingCh1ToCh2": "Duplicate heating CH1 to CH2",
+          "heatingStateToSummerWinterMode": "Heating state as summer/winter mode",
+          "ch2AlwaysEnabled": "CH2 always enabled",
+          "heatingToCh2": "Duplicate heating to CH2",
           "dhwToCh2": "Duplicate DHW to CH2",
           "dhwBlocking": "DHW blocking",
-          "modulationSyncWithHeating": "Sync modulation with heating",
+          "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

@@ -0,0 +1,485 @@
+{
+  "values": {
+    "logo": "OpenTherm Gateway",
+    "nav": {
+      "license": "Licenza",
+      "source": "Codice",
+      "help": "Aiuto",
+      "issues": "Problemi e domande",
+      "releases": "Versione"
+    },
+    "dbm": "dBm",
+    "kw": "kW",
+    "time": {
+      "days": "d.",
+      "hours": "h.",
+      "min": "min.",
+      "sec": "sec."
+    },
+
+    "button": {
+      "upgrade": "Aggiorna",
+      "restart": "Riavvia",
+      "save": "Salva",
+      "saved": "Salvato",
+      "refresh": "Ricarica",
+      "restore": "Recupera",
+      "restored": "Recuperato",
+      "backup": "Backup",
+      "wait": "Attendi...",
+      "uploading": "caricamento...",
+      "success": "Riuscito",
+      "error": "Errore"
+    },
+
+    "index": {
+      "title": "OpenTherm Gateway",
+
+      "section": {
+        "network": "Rete",
+        "system": "Sistema"
+      },
+
+      "system": {
+        "build": {
+          "title": "Build",
+          "version": "Versione",
+          "date": "Data",
+          "core": "Core",
+          "sdk": "SDK"
+        },
+        "uptime": "Tempo di attività",
+        "memory": {
+          "title": "Memoria libera",
+          "maxFreeBlock": "max free block",
+          "min": "min"
+        },
+        "board": "Scheda",
+        "chip": {
+          "model": "Chip",
+          "cores": "Cores",
+          "freq": "frequenza"
+        },
+        "flash": {
+          "size": "Dimensioni del flash",
+          "realSize": "dimensione reale"
+        },
+        "lastResetReason": "Motivo ultimo Reset"
+      }
+    },
+
+    "dashboard": {
+      "name": "Pannello",
+      "title": "Pannello - OpenTherm Gateway",
+
+      "section": {
+        "control": "Controlli",
+        "states": "Stato",
+        "sensors": "Sensori",
+        "diag": "Diagnostica OpenTherm"
+      },
+
+      "thermostat": {
+        "heating": "Riscaldamento",
+        "dhw": "ACS",
+        "temp.current": "Attuale",
+        "enable": "Attiva",
+        "turbo": "Turbo"
+      },
+
+      "notify": {
+        "fault": {
+          "title": "Rilevamento guasti caldiaia attivo!",
+          "note": "Si consiglia di ispezionare la caldaia e studiare la documentazione per interpretare il codice di errore:"
+        },
+        "diag": {
+          "title": "Stato diagnostica Caldaia attivo!",
+          "note": "Forse la tua caldaia ha bisogno di un'ispezione? Si consiglia di studiare la documentazione per interpretare il codice diagnostico:"
+        },
+        "reset": "Prova a resettare"
+      },
+
+      "states": {
+        "mNetworkConnected": "Connessione Rete",
+        "mMqttConnected": "Connessione MQTT",
+        "mEmergencyState": "Modo Emergenza",
+        "mExtPumpState": "Pompa esterna",
+        "mCascadeControlInput": "Controllo a cascata (input)",
+        "mCascadeControlOutput": "Controllo a cascata (output)",
+
+        "sConnected": "Connessione OpenTherm",
+        "sFlame": "Fiamma",
+        "sCooling": "Raffrescamento",
+        "sFaultActive": "Anomalia",
+        "sFaultCode": "Codice anomalia",
+        "sDiagActive": "Diagnostica",
+        "sDiagCode": "Codice Diagnostica",
+        
+        "mHeatEnabled": "Riscaldamento attivato",
+        "mHeatBlocking": "Riscaldamento bloccato",
+        "sHeatActive": "Riscaldamento attivo",
+        "mHeatSetpointTemp": "Temp riscaldamento impostato",
+        "mHeatTargetTemp": "Target Temp caldaia",
+        "mHeatCurrTemp": "Temp attuale riscaldamento",
+        "mHeatRetTemp": "Temp ritorno riscaldamento",
+        "mHeatIndoorTemp": "Riscaldamento, temp interna",
+        "mHeatOutdoorTemp": "Riscaldamento, temp esterna",
+
+        "mDhwEnabled": "ACS attivata",
+        "sDhwActive": "ACS attiva",
+        "mDhwTargetTemp": "ACS temp impostata",
+        "mDhwCurrTemp": "ACS temp attuale",
+        "mDhwRetTemp": "ACS temp ricircolo"
+      },
+
+      "sensors": {
+        "values": {
+          "temp": "Temperatura",
+          "humidity": "Umidità",
+          "battery": "Batteria",
+          "rssi": "RSSI"
+        }
+      }
+    },
+
+    "network": {
+      "title": "Rete - OpenTherm Gateway",
+      "name": "Impostazioni rete",
+
+      "section": {
+        "static": "Impostazioni statico",
+        "availableNetworks": "Reti disponibili",
+        "staSettings": "Impostazioni WiFi",
+        "apSettings": "Impostazioni AP"
+      },
+
+      "scan": {
+        "pos": "#",
+        "info": "Info"
+      },
+
+      "wifi": {
+        "ssid": "SSID",
+        "password": "Password",
+        "channel": "Canale",
+        "signal": "Segnale",
+        "connected": "Connesso"
+      },
+
+      "params": {
+        "hostname": "Hostname",
+        "dhcp": "Usa DHCP",
+        "mac": "MAC",
+        "ip": "IP",
+        "subnet": "Subnet",
+        "gateway": "Gateway",
+        "dns": "DNS"
+      },
+
+      "sta": {
+        "channel.note": "Metti 0 per auto selezione"
+      }
+    },
+
+    "sensors": {
+      "title": "Impostazione sensori - OpenTherm Gateway",
+      "name": "Impostazione sensori",
+
+      "enabled": "Attivato",
+      "sensorName": {
+        "title": "Nome sensore",
+        "note": "Può contenere solo: a-z, A-Z, 0-9, _ e spazi"
+      },
+      "purpose": "Funzione",
+      "purposes": {
+        "outdoorTemp": "Temperatura esterna",
+        "indoorTemp": "Temperatura interna",
+        "heatTemp": "Riscaldamento, temperatura mandata",
+        "heatRetTemp": "Riscaldamento, temperatura ritorno",
+        "dhwTemp": "ACS, temperatura",
+        "dhwRetTemp": "ACS, temperatura ritorno",
+        "dhwFlowRate": "ACS, prelievo",
+        "exhaustTemp": "Temperatura fumi",
+        "modLevel": "Livello Modulazione (%)",
+        "number": "Numero (raw)",
+        "powerFactor": "Potenza (%)",
+        "power": "Potenza (in kW)",
+        "fanSpeed": "Velocità ventilatore",
+        "co2": "CO2",
+        "pressure": "Pressione",
+        "humidity": "Umidità",
+        "temperature": "Temperatura",
+        "notConfigured": "Non configurato"
+      },
+      "type": "Tipo/sorgente",
+      "types": {
+        "otOutdoorTemp": "OpenTherm, temp esterna",
+        "otHeatTemp": "OpenTherm, riscaldamento, temp",
+        "otHeatRetTemp": "OpenTherm, riscaldamento, temp ritorno",
+        "otDhwTemp": "OpenTherm, ACS, temperatura",
+        "otDhwTemp2": "OpenTherm, ACS, temperatura 2",
+        "otDhwFlowRate": "OpenTherm, ACS, prelievo",
+        "otCh2Temp": "OpenTherm, canale 2, temp",
+        "otExhaustTemp": "OpenTherm, temp fumi",
+        "otHeatExchangerTemp": "OpenTherm, temp scambiatore",
+        "otPressure": "OpenTherm, pressione",
+        "otModLevel": "OpenTherm, livello modulazione",
+        "otCurrentPower": "OpenTherm, potenza attuale",
+        "otExhaustCo2": "OpenTherm, CO2 fumi",
+        "otExhaustFanSpeed": "OpenTherm, velocità ventola fumi",
+        "otSupplyFanSpeed": "OpenTherm, velocità ventola supporto",
+        "otSolarStorageTemp": "OpenTherm, temp accumulo solare",
+        "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",
+        "bluetooth": "Sensore BLE",
+        "heatSetpointTemp": "Riscaldamento, temp impostata",
+        "manual": "Manuale via MQTT/API",
+        "notConfigured": "Non configurato"
+      },
+      "gpio": "GPIO",
+      "address": {
+        "title": "Indirizzo sensore",
+        "note": "Per l'autoriconoscimento del sensore DALLAS lasciare quello di default, per sensore BLE richiede indirizzo MAC"
+      },
+      "correction": {
+        "desc": "Correzione del valore",
+        "offset": "Compensazione (offset)",
+        "factor": "Moltiplicatore"
+      },
+      "filtering": {
+        "desc": "Filtraggio valore",
+        "enabled": {
+          "title": "Filtraggio attivo",
+          "note": "Può servire in caso vi siano molti sbalzi nel grafico. Il filtro usato è \"Running Average\"."
+        },
+        "factor": {
+          "title": "Fattore di filtrazione",
+          "note": "Quanto più basso è il valore, tanto più graduale e prolungata sarà la variazione dei valori numerici."
+        }
+      }
+    },
+
+    "settings": {
+      "title": "Impostazioni - OpenTherm Gateway",
+      "name": "Impostazioni",
+
+      "section": {
+        "portal": "Impostazioni Accesso",
+        "system": "Impostazioni sistema",
+        "diag": "Diagnostica",
+        "heating": "Impostazioni riscaldamento",
+        "dhw": "Impostazioni ACS",
+        "emergency": "Impostazioni modo Emergenza",
+        "equitherm": "Impostazioni Equitherm",
+        "pid": "Impostazioni PID",
+        "ot": "Impostazioni OpenTherm",
+        "mqtt": "Impostazioni MQTT",
+        "extPump": "Impostazioni pompa esterna",
+        "cascadeControl": "Impostazioni controllo a cascata"
+      },
+
+      "enable": "Attiva",
+      "note": {
+        "restart": "Dopo aver cambiato queste impostazioni, il sistema sarà riavviato perchè i cambiamenti abbiano effetto.",
+        "blankNotUse": "vuoto - non usare",
+        "bleDevice": "Dispositivi BLE possono essere usati <u>solo</u> con alcune schede ESP32 che supportano il bluetooth!"
+      },
+
+      "temp": {
+        "min": "Temperatura minima",
+        "max": "Temperatura massima"
+      },
+      "maxModulation": "Max livello modulazione",
+
+      "portal": {
+        "login": "Login",
+        "password": "Password",
+        "auth": "Richiede autenticazione",
+        "mdns": "Usa mDNS"
+      },
+
+      "system": {
+        "unit": "Unità di misura",
+        "metric": "Metrico <small>(celsius, litri, bar)</small>",
+        "imperial": "Imperiale <small>(fahrenheit, galloni, psi)</small>",
+        "statusLedGpio": "LED di stato GPIO",
+        "logLevel": "Log livello",
+        "serial": {
+          "enable": "Porta seriale attivata",
+          "baud": "Porta seriale baud rate"
+        },
+        "telnet": {
+          "enable": "Telnet attivato",
+          "port": {
+            "title": "Porta Telnet",
+            "note": "Default: 23"
+          }
+        },
+        "ntp": {
+          "server": "NTP server",
+          "timezone": "Zona oraria",
+          "timezonePresets": "Seleziona preimpostato..."
+        }
+      },
+
+      "heating": {
+        "hyst": "Isteresi <small>(in gradi)</small>",
+        "turboFactor": "Turbo mode coeff."
+      },
+
+      "emergency": {
+        "desc": "Il modo emergenza è attivato automaticamente quando «PID» o «Equitherm» non possono calcolare il setpoint:<br />- se «Equitherm» è attivato e il sensore della temperatura esternare è disconnesso;<br />- se «PID» o l'opzione OT <i>«Impostazioni riscaldamento native»</i> è attiva e il sensore di temperatura interno è disconnesso.<br /><b>Nota:</b> In mancanza di rete o MQTT, sensore di tipo <i>«Manuale via MQTT/API»</i> è in stato Disconnesso.",
+        
+        "target": {
+          "title": "Temperatura impostata",
+          "note": "<b>Importante:</b> <u>Temperatura interna impostata</u> se l'opzione OT <i>«Controllo riscaldamento interno»</i> è attivato.<br />In tutti gli altri casi, la <u>target heat carrier temperature</u>."
+        },
+        "treshold": "Tempo di soglia <small>(sec)</small>"
+      },
+
+      "equitherm": {
+        "n": "Fattore N",
+        "k": "Fattore K",
+        "t": {
+          "title": "Fattore T",
+          "note": "Non usato se PID è attivato"
+        }
+      },
+
+      "pid": {
+        "p": "Fattore P",
+        "i": "Fattore I",
+        "d": "Fattore D",
+        "dt": "DT <small>in secondi</small>",
+        "limits": {
+          "title": "Limiti",
+          "note": "<b>Importante:</b> Quando usi «Equitherm» e «PID» allo stesso tempo, i limiti della temperatura min e max influenzano il risultato della temperatura «Equitherm».<br />Thus, se la temperatura minima è impostata a -15 e la massima a 15, il riscaldamento finale sarà impostato fra <code>equitherm_result - 15</code> a <code>equitherm_result + 15</code>."
+        },
+        "deadband": {
+          "title": "Zona morta (Deadband)",
+          "note": "La zona morta è un intervallo intorno alla temperatura target in cui la regolazione PID diventa meno attiva. In questo intervallo, l'algoritmo può ridurre l'intensità o interrompere gli aggiustamenti per evitare di reagire eccessivamente a piccole fluttuazioni.<br /><br />Ad esempio, con una temperatura target di 22°, una soglia inferiore di 1.0 e una soglia superiore di 0.5, la zona morta opera tra 21° e 22.5°. Se il coefficiente I è 0.0005 e il moltiplicatore I è 0.05, allora nella zona morta, il coefficiente I diventa: <code>0.0005 * 0.05 = 0.000025</code>",
+          "p_multiplier": "Moltiplicatore P",
+          "i_multiplier": "Moltiplicatore I",
+          "d_multiplier": "Moltiplicatore D",
+          "thresholdHigh": "Soglia superiore",
+          "thresholdLow": "Soglia inferiore"
+        }
+      },
+
+      "ot": {
+        "advanced": "Impostazioni avanzate",
+        "inGpio": "In GPIO",
+        "outGpio": "Out GPIO",
+        "ledGpio": "RX LED GPIO",
+        "memberId": "Master member ID",
+        "flags": "Master flags",
+        "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\"."
+        },
+        "maxPower": {
+          "title": "Potenza massima caldaia <small>(kW)</small>",
+          "note": "<b>0</b> - prova a rilevarla automaticamente. Di solito si trova nelle specifiche delle caldaia come \"potenza massima disponibile\"."
+        },
+
+        "options": {
+          "desc": "Opzioni",
+          "dhwSupport": "Supporto ACS",
+          "coolingSupport": "Supporto rafferscamento",
+          "summerWinterMode": "Modalità Estate/inverno",
+          "heatingStateToSummerWinterMode": "Stato di riscaldamento come modalità estate/inverno",
+          "ch2AlwaysEnabled": "CH2 sempre abilitato",
+          "heatingToCh2": "Riproduci riscaldamento su CH2",
+          "dhwToCh2": "Riproduci ACS su CH2",
+          "dhwBlocking": "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"
+        },
+
+        "nativeHeating": {
+          "title": "Controllo del riscaldamento nativo (caldaia)",
+          "note": "Lavora <u>SOLO</u> se la caldaia richiede la temperatura ambiente desiderata e regola autonomamente la temperatura del fluido. Non compatiblile con regolazioni PID e Equitherm del sistema."
+        }
+      },
+
+      "mqtt": {
+        "homeAssistantDiscovery": "Home Assistant Discovery",
+        "server": "Server",
+        "port": "Porta",
+        "user": "Utente",
+        "password": "Password",
+        "prefix": "Prefisso",
+        "interval": "Intervallo invio <small>(sec)</small>"
+      },
+
+      "extPump": {
+        "use": "Usa pompa/circolatore esterno",
+        "gpio": "GPIO relè",
+        "postCirculationTime": "Tempo di post circolazione <small>(min)</small>",
+        "antiStuckInterval": "Intervallo antiblocco <small>(days)</small>",
+        "antiStuckTime": "Tempo antiblocco <small>(min)</small>"
+      },
+
+      "cascadeControl": {
+        "input": {
+          "desc": "Può essere attivata la caldaia se un'altra ha fallito. Il controllo dell'altra caldaia cambia lo stato dell'ingresso del GPIO in caso di errore.",
+          "enable": "Ingresso abilitato",
+          "gpio": "GPIO",
+          "invertState": "Inverti stato GPIO",
+          "thresholdTime": "Tempo soglia di modifica dello stato <small>(sec)</small>"
+        },
+        "output": {
+          "desc": "Può essere usato per passare ad un'altra caldaia tramite <u>relè</u>.",
+          "enable": "Uscita abilitata",
+          "gpio": "GPIO",
+          "invertState": "Invert GPIO state",
+          "thresholdTime": "Tempo soglia di modifica dello stato <small>(sec)</small>",
+          "events": {
+            "desc": "Eventi",
+            "onFault": "Se lo stato di errore è attivo",
+            "onLossConnection": "Se non c'è la connessione via Opentherm",
+            "onEnabledHeating": "Se il riscaldamento è attivato"
+          }
+        }
+      }
+    },
+
+    "upgrade": {
+      "title": "Aggiornamenti - OpenTherm Gateway",
+      "name": "Aggiornamenti",
+
+      "section": {
+        "backupAndRestore": "Backup & restore",
+        "backupAndRestore.desc": "In questa sezione puoi salvare e recuperare un backup di tutte le impostazioni.",
+        "upgrade": "Aggiorna",
+        "upgrade.desc": "In questa sezione puoi aggiornare il firmware il filesystem del tuo dispositivo.<br />L'ultimo aggiornamento può essere scaricato da <a href=\"https://github.com/Laxilef/OTGateway/releases\" target=\"_blank\">Releases page</a> del progetto." 
+      },
+
+      "note": {
+        "disclaimer1": "Dopo un aggiornamento riuscito del filesystem, tutte le impostazioni sono impostate di default! Salva un backup prima di aggiornare.",
+        "disclaimer2": "Dopo un aggiornamento riuscito, il sistema viene automaticamente riavviato dopo 15 secondi."
+      },
+
+      "settingsFile": "Settings file",
+      "fw": "Firmware",
+      "fs": "Filesystem"
+    }
+  }
+}

src_data/locales/ru.json

@@ -87,6 +87,18 @@
         "turbo": "Турбо"
       },
 
+      "notify": {
+        "fault": {
+          "title": "Состояние неисправности котла активно!",
+          "note": "Рекомендуется осмотреть котел и изучить документацию котла для расшифровки кода неисправности:"
+        },
+        "diag": {
+          "title": "Состояние диагностики котла активно!",
+          "note": "Возможно, вашему котлу требуется проверка? Рекомендуется изучить документацию котла для расшифровки кода диагностики:"
+        },
+        "reset": "Сбросить"
+      },
+
       "states": {
         "mNetworkConnected": "Подключение к сети",
         "mMqttConnected": "Подключение к MQTT",
@@ -97,6 +109,7 @@
 
         "sConnected": "Подключение к OpenTherm",
         "sFlame": "Пламя",
+        "sCooling": "Охлаждение",
         "sFaultActive": "Ошибка",
         "sFaultCode": "Код ошибки",
         "sDiagActive": "Диагностика",
@@ -180,7 +193,7 @@
       "purpose": "Назначение",
       "purposes": {
         "outdoorTemp": "Внешняя температура",
-        "indoorTemp": "Внутреняя температура",
+        "indoorTemp": "Внутренняя температура",
         "heatTemp": "Отопление, температура",
         "heatRetTemp": "Отопление, температура обратки",
         "dhwTemp": "ГВС, температура",
@@ -188,6 +201,7 @@
         "dhwFlowRate": "ГВС, расход/скорость потока",
         "exhaustTemp": "Температура выхлопных газов",
         "modLevel": "Уровень модуляции (в процентах)",
+        "number": "Число (raw)",
         "powerFactor": "Мощность (в процентах)",
         "power": "Мощность (в кВт)",
         "fanSpeed": "Скорость вентилятора",
@@ -218,6 +232,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 датчик",
@@ -279,16 +301,18 @@
         "min": "Мин. температура",
         "max": "Макс. температура"
       },
+      "maxModulation": "Макс. уровень модуляции",
 
       "portal": {
         "login": "Логин",
         "password": "Пароль",
-        "auth": "Требовать аутентификацию"
+        "auth": "Требовать аутентификацию",
+        "mdns": "Использовать mDNS"
       },
 
       "system": {
         "unit": "Система единиц",
-        "metric": "Метрическая <small>(цильсии, литры, бары)</small>",
+        "metric": "Метрическая <small>(цельсии, литры, бары)</small>",
         "imperial": "Imperial <small>(фаренгейты, галлоны, psi)</small>",
         "statusLedGpio": "Статус LED GPIO",
         "logLevel": "Уровень логирования",
@@ -302,6 +326,11 @@
             "title": "Telnet порт",
             "note": "По умолчанию: 23"
           }
+        },
+        "ntp": {
+          "server": "NTP сервер",
+          "timezone": "Часовой пояс",
+          "timezonePresets": "Выберите пресет..."
         }
       },
 
@@ -334,7 +363,19 @@
         "i": "Коэффициент I",
         "d": "Коэффициент D",
         "dt": "DT <small>(сек)</small>",
-        "noteMinMaxTemp": "<b>Важно:</b> При использовании «ПЗА» и «ПИД» одновременно, мин. и макс. температура ограничивает влияние на расчётную температуру «ПЗА».<br />Таким образом, если мин. температура задана как -15, а макс. как 15, то конечная температура теплоносителя будет от <code>equitherm_result - 15</code> до <code>equitherm_result + 15</code>."
+        "limits": {
+          "title": "Лимиты",
+          "note": "<b>Важно:</b> При использовании «ПЗА» и «ПИД» одновременно, мин. и макс. температура ограничивает влияние на расчётную температуру «ПЗА».<br />Таким образом, если мин. температура задана как -15, а макс. как 15, то конечная температура теплоносителя будет от <code>equitherm_result - 15</code> до <code>equitherm_result + 15</code>."
+        },
+        "deadband": {
+          "title": "Зона нечувствительности (Deadband)",
+          "note": "Deadband - это зона нечувствительности вокруг целевой температуры, в которой PID-регулирование становится менее активным. В этом диапазоне алгоритм может снижать интенсивность или полностью прекращать корректировку температуры, чтобы избежать излишней чувствительности к небольшим колебаниям.<br /><br />Например, при целевой температуре 22°, нижнем пороге 1.0 и верхнем 0.5, deadband активен в диапазоне от 21° до 22.5°. Если коэфф. I=0.0005, а множитель I=0.05, то при включении зоны нечувствительности коэфф. I будет равен: <code>0.0005 * 0.05 = 0.000025</code>",
+          "p_multiplier": "Множитель для коэф. P",
+          "i_multiplier": "Множитель для коэф. I",
+          "d_multiplier": "Множитель для коэф. D",
+          "thresholdHigh": "Верхний порог",
+          "thresholdLow": "Нижний порог"
+        }
       },
 
       "ot": {
@@ -344,7 +385,6 @@
         "ledGpio": "RX LED GPIO",
         "memberId": "Master member ID",
         "flags": "Master flags",
-        "maxMod": "Макс. уровень модуляции",
         "minPower": {
           "title": "Мин. мощность котла <small>(кВт)</small>",
           "note": "Это значение соответствует уровню модуляции котла 0–1%. Обычно можно найти в спецификации котла как \"минимальная полезная тепловая мощность\"."
@@ -356,14 +396,20 @@
 
         "options": {
           "desc": "Опции",
-          "dhwPresent": "Контур ГВС",
+          "dhwSupport": "Поддержка ГВС",
+          "coolingSupport": "Поддержка охлаждения",
           "summerWinterMode": "Летний/зимний режим",
-          "heatingCh2Enabled": "Канал 2 отопления всегда вкл.",
-          "heatingCh1ToCh2": "Дублировать параметры отопления канала 1 в канал 2",
+          "heatingStateToSummerWinterMode": "Летний/зимний режим в качестве состояния отопления",
+          "ch2AlwaysEnabled": "Канал 2 всегда вкл.",
+          "heatingToCh2": "Дублировать параметры отопления в канал 2",
           "dhwToCh2": "Дублировать параметры ГВС в канал 2",
           "dhwBlocking": "DHW blocking",
-          "modulationSyncWithHeating": "Синхронизировать модуляцию с отоплением",
+          "maxTempSyncWithTargetTemp": "Синхронизировать макс. темп. отопления с целевой темп.",
           "getMinMaxTemp": "Получать мин. и макс. температуру от котла",
+          "ignoreDiagState": "Игнорировать состояние диагностики",
+          "autoFaultReset": "Автоматический сброс ошибок <small>(не рекомендуется!)</small>",
+          "autoDiagReset": "Автоматический сброс диагностики <small>(не рекомендуется!)</small>",
+          "setDateAndTime": "Устанавливать время и дату на котле",
           "immergasFix": "Фикс для котлов Immergas"
         },
 

src_data/pages/dashboard.html

@@ -21,6 +21,7 @@
           <li>
             <select id="lang" aria-label="Lang">
               <option value="en" selected>EN</option>
+              <option value="it">IT</option>
               <option value="ru">RU</option>
             </select>
           </li>
@@ -40,14 +41,18 @@
           <details open>
             <summary><b data-i18n>dashboard.section.control</b></summary>
             <div class="grid">
-              <div class="thermostat" id="thermostat-heating">
+              <div class="thermostat tHeat" data-purpose="heating" data-min="0" data-max="100" data-step="0.1" data-big-step="1">
                 <div class="thermostat-header" data-i18n>dashboard.thermostat.heating</div>
                 <div class="thermostat-temp">
-                  <div class="thermostat-temp-target"><span id="tHeatTargetTemp"></span> <span class="tempUnit"></span></div>
+                  <div class="thermostat-temp-target"><span class="targetTemp"></span> <span class="tempUnit"></span></div>
                   <div class="thermostat-temp-current"><span data-i18n>dashboard.thermostat.temp.current</span>: <span id="tHeatCurrentTemp"></span> <span class="tempUnit"></span></div>
                 </div>
-                <div class="thermostat-minus"><button id="tHeatActionMinus" class="outline"><i class="icons-down"></i></button></div>
-                <div class="thermostat-plus"><button id="tHeatActionPlus" class="outline"><i class="icons-up"></i></button></div>
+                <div class="thermostat-minus">
+                  <button class="tAction outline" data-action="decrement"><i class="icons-down"></i></button>
+                </div>
+                <div class="thermostat-plus">
+                  <button class="tAction outline" data-action="increment"><i class="icons-up"></i></button>
+                </div>
                 <div class="thermostat-control">
                   <input type="checkbox" role="switch" id="tHeatEnabled" value="true">
                   <label htmlFor="tHeatEnabled" data-i18n>dashboard.thermostat.enable</label>
@@ -57,20 +62,54 @@
                 </div>
               </div>
 
-              <div class="thermostat" id="thermostat-dhw">
+              <div class="thermostat tDhw" data-purpose="dhw" data-min="0" data-max="100" data-step="1" data-big-step="5">
                 <div class="thermostat-header" data-i18n>dashboard.thermostat.dhw</div>
                 <div class="thermostat-temp">
-                  <div class="thermostat-temp-target"><span id="tDhwTargetTemp"></span> <span class="tempUnit"></span></div>
+                  <div class="thermostat-temp-target"><span class="targetTemp"></span> <span class="tempUnit"></span></div>
                   <div class="thermostat-temp-current"><span data-i18n>dashboard.thermostat.temp.current</span>: <span id="tDhwCurrentTemp"></span> <span class="tempUnit"></span></div>
                 </div>
-                <div class="thermostat-minus"><button class="outline" id="tDhwActionMinus"><i class="icons-down"></i></button></div>
-                <div class="thermostat-plus"><button class="outline" id="tDhwActionPlus"><i class="icons-up"></i></button></div>
+                <div class="thermostat-minus">
+                  <button class="tAction outline" data-action="decrement"><i class="icons-down"></i></button>
+                </div>
+                <div class="thermostat-plus">
+                  <button class="tAction outline" data-action="increment"><i class="icons-up"></i></button>
+                </div>
                 <div class="thermostat-control">
                   <input type="checkbox" role="switch" id="tDhwEnabled" value="true">
                   <label htmlFor="tDhwEnabled" data-i18n>dashboard.thermostat.enable</label>
                 </div>
               </div>
             </div>
+
+            <div class="notify notify-error notify-fault hidden">
+              <div class="notify-icon">
+                <i class="icons-error"></i>
+              </div>
+              <div class="notify-content">
+                <b data-i18n>dashboard.notify.fault.title</b><br />
+                <small>
+                  <span data-i18n>dashboard.notify.fault.note</span> <b class="sFaultCode"></b>
+                </small>
+              </div>
+              <div class="notify-actions">
+                <button class="reset" data-i18n>dashboard.notify.reset</button>
+              </div>
+            </div>
+
+            <div class="notify notify-alarm notify-diag hidden">
+              <div class="notify-icon">
+                <i class="icons-alarm"></i>
+              </div>
+              <div class="notify-content">
+                <b data-i18n>dashboard.notify.diag.title</b><br />
+                <small>
+                  <span data-i18n>dashboard.notify.diag.note</span> <b class="sDiagCode"></b>
+                </small>
+              </div>
+              <div class="notify-actions">
+                <button class="reset" data-i18n>dashboard.notify.reset</button>
+              </div>
+            </div>
           </details>
 
           <hr />
@@ -113,6 +152,10 @@
                   <th scope="row" data-i18n>dashboard.states.sFlame</th>
                   <td><i class="sFlame"></i></td>
                 </tr>
+                <tr>
+                  <th scope="row" data-i18n>dashboard.states.sCooling</th>
+                  <td><i class="sCooling"></i></td>
+                </tr>
 
 
                 <tr>
@@ -218,16 +261,16 @@
 
           <details>
             <summary><b data-i18n>dashboard.section.diag</b></summary>
-            <pre><b>Vendor:</b>             <span class="sVendor"></span>
-<b>Member ID:</b>          <span class="sMemberId"></span>
-<b>Flags:</b>              <span class="sFlags"></span>
-<b>Type:</b>               <span class="sType"></span>
-<b>AppVersion:</b>         <span class="sAppVersion"></span>
-<b>OT version:</b>         <span class="sProtocolVersion"></span>
-<b>Modulation limits:</b>  <span class="sModMin"></span>...<span class="sModMax"></span> %
-<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>DHW limits:</b>         <span class="sDhwMinTemp"></span>...<span class="sDhwMaxTemp"></span> <span class="tempUnit"></span></pre>
+            <pre><b>Vendor:</b>         <span class="sVendor"></span>
+<b>Member ID:</b>      <span class="sMemberId"></span>
+<b>Flags:</b>          <span class="sFlags"></span>
+<b>Type:</b>           <span class="sType"></span>
+<b>AppVersion:</b>     <span class="sAppVersion"></span>
+<b>OT version:</b>     <span class="sProtocolVersion"></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>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>
           </details>
         </div>
       </article>
@@ -247,7 +290,6 @@
     <script src="/static/app.js?{BUILD_TIME}"></script>
     <script>
       let modifiedTime = null;
-      let noRegulators;
       let prevSettings;
       let newSettings = {
         heating: {
@@ -265,78 +307,69 @@
         const lang = new Lang(document.getElementById('lang'));
         lang.build();
 
-        document.querySelector('#tHeatActionMinus').addEventListener('click', (event) => {
-          if (!prevSettings) {
-            return;
+        let actionTimer = null;
+        let actionLongPress = false;
+        document.querySelectorAll('.tAction').forEach((item) => {
+          const action = item.dataset.action;
+          const tContainer = item.parentNode.parentNode;
+
+          for (const eName of ['pointerup', 'pointercancel']) {
+            item.addEventListener(eName, (event) => {
+              clearInterval(actionTimer);
+
+              const purpose = tContainer.dataset.purpose;
+              const minTemp = parseFloat(tContainer.dataset.min);
+              const maxTemp = parseFloat(tContainer.dataset.max);
+              const step = parseFloat(tContainer.dataset.step);
+              const bigStep = parseFloat(tContainer.dataset.bigStep);
+
+              if (!actionLongPress && prevSettings) {
+                let value = 0;
+                if (action == 'increment') {
+                  value = step;
+
+                } else if (action == 'decrement') {
+                  value = -(step);
+                }
+
+                newSettings[purpose].target = parseFloat(constrain(newSettings[purpose].target + value, minTemp, maxTemp).toFixed(2));
+                modifiedTime = Date.now();
+                setValue('.targetTemp', newSettings[purpose].target, tContainer);
+              }
+            });
           }
 
-          newSettings.heating.target -= 0.5;
-          modifiedTime = Date.now();
+          item.addEventListener('pointerdown', (event) => {
+            if (!prevSettings) {
+              return;
+            }
 
-          let minTemp;
-          if (noRegulators) {
-            minTemp = prevSettings.heating.minTemp;
-          } else {
-            minTemp = prevSettings.system.unitSystem == 0 ? 5 : 41;
-          }
+            const purpose = tContainer.dataset.purpose;
+            const minTemp = parseFloat(tContainer.dataset.min);
+            const maxTemp = parseFloat(tContainer.dataset.max);
+            const step = parseFloat(tContainer.dataset.step);
+            const bigStep = parseFloat(tContainer.dataset.bigStep);
 
-          if (prevSettings && newSettings.heating.target < minTemp) {
-            newSettings.heating.target = minTemp;
-          }
+            actionLongPress = false;
+            actionTimer = setInterval(() => {
+              if (!actionLongPress) {
+                actionLongPress = true;
+              }
 
-          setValue('#tHeatTargetTemp', newSettings.heating.target);
-        });
+              let value = 0;
+              if (action == 'increment') {
+                value = bigStep;
 
-        document.querySelector('#tHeatActionPlus').addEventListener('click', (event) => {
-          if (!prevSettings) {
-            return;
-          }
+              } else if (action == 'decrement') {
+                value = -(bigStep);
+              }
 
-          newSettings.heating.target += 0.5;
-          modifiedTime = Date.now();
+              newSettings[purpose].target = parseFloat(constrain(newSettings[purpose].target + value, minTemp, maxTemp).toFixed(2));
+              modifiedTime = Date.now();
 
-          let maxTemp;
-          if (noRegulators) {
-            maxTemp = prevSettings.heating.maxTemp;
-          } else {
-            maxTemp = prevSettings.system.unitSystem == 0 ? 30 : 86;
-          }
-
-          if (prevSettings && newSettings.heating.target > maxTemp) {
-            newSettings.heating.target = maxTemp;
-          }
-
-          setValue('#tHeatTargetTemp', newSettings.heating.target);
-        });
-
-        document.querySelector('#tDhwActionMinus').addEventListener('click', (event) => {
-          if (!prevSettings) {
-            return;
-          }
-
-          newSettings.dhw.target -= 1.0;
-          modifiedTime = Date.now();
-
-          if (newSettings.dhw.target < prevSettings.dhw.minTemp) {
-            newSettings.dhw.target = prevSettings.dhw.minTemp;
-          }
-
-          setValue('#tDhwTargetTemp', newSettings.dhw.target);
-        });
-
-        document.querySelector('#tDhwActionPlus').addEventListener('click', (event) => {
-          if (!prevSettings) {
-            return;
-          }
-
-          newSettings.dhw.target += 1.0;
-          modifiedTime = Date.now();
-
-          if (newSettings.dhw.target > prevSettings.dhw.maxTemp) {
-            newSettings.dhw.target = prevSettings.dhw.maxTemp;
-          }
-
-          setValue('#tDhwTargetTemp', newSettings.dhw.target);
+              setValue('.targetTemp', newSettings[purpose].target, tContainer);
+            }, 500);
+          });
         });
 
         document.querySelector('#tHeatEnabled').addEventListener('change', (event) => {
@@ -354,6 +387,60 @@
           newSettings.dhw.enabled = event.currentTarget.checked;
         });
 
+        document.querySelector('.notify-fault .reset').addEventListener('click', async (event) => {
+          const resetBtn = document.querySelector(".notify-fault .reset");
+          if (!resetBtn.disabled) {
+            resetBtn.disabled = true;
+          }
+
+          let response = await fetch("/api/vars", {
+            method: "POST",
+            cache: "no-cache",
+            credentials: "include",
+            headers: {
+              "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+              "actions": {
+                "resetFault": true
+              }
+            })
+          });
+
+          setTimeout(() => {
+            if (resetBtn.disabled) {
+              resetBtn.disabled = false;
+            }
+          }, 10000);
+        });
+
+        document.querySelector('.notify-diag .reset').addEventListener('click', async (event) => {
+          const resetBtn = document.querySelector(".notify-diag .reset");
+          if (!resetBtn.disabled) {
+            resetBtn.disabled = true;
+          }
+
+          let response = await fetch("/api/vars", {
+            method: "POST",
+            cache: "no-cache",
+            credentials: "include",
+            headers: {
+              "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+              "actions": {
+                "resetDiagnostic": true
+              }
+            })
+          });
+
+          setTimeout(() => {
+            if (resetBtn.disabled) {
+              resetBtn.disabled = false;
+            }
+          }, 10000);
+        });
+
         setTimeout(async function onLoadPage() {
           let unitSystem = null;
 
@@ -372,8 +459,8 @@
               (prevSettings.heating.enabled != newSettings.heating.enabled)
               || (prevSettings.heating.turbo != newSettings.heating.turbo)
               || (prevSettings.heating.target != newSettings.heating.target)
-              || (prevSettings.opentherm.dhwPresent && prevSettings.dhw.enabled != newSettings.dhw.enabled)
-              || (prevSettings.opentherm.dhwPresent && prevSettings.dhw.target != newSettings.dhw.target)
+              || (prevSettings.opentherm.options.dhwSupport && prevSettings.dhw.enabled != newSettings.dhw.enabled)
+              || (prevSettings.opentherm.options.dhwSupport && prevSettings.dhw.target != newSettings.dhw.target)
             );
 
             if (modified) {
@@ -397,7 +484,6 @@
             }
 
             const result = await response.json();
-            noRegulators = !result.opentherm.nativeHeatingControl && !result.equitherm.enabled && !result.pid.enabled;
             prevSettings = result;
             unitSystem = result.system.unitSystem;
             newSettings.heating.enabled = result.heating.enabled;
@@ -406,18 +492,18 @@
             newSettings.dhw.enabled = result.dhw.enabled;
             newSettings.dhw.target = result.dhw.target;
 
-            if (result.opentherm.dhwPresent) {
-              show('#thermostat-dhw');
+            if (result.opentherm.options.dhwSupport) {
+              show('.tDhw');
             } else {
-              hide('#thermostat-dhw');
+              hide('.tDhw');
             }
 
             setCheckboxValue('#tHeatEnabled', result.heating.enabled);
             setCheckboxValue('#tHeatTurbo', result.heating.turbo);
-            setValue('#tHeatTargetTemp', result.heating.target);
+            setValue('.tHeat .targetTemp', result.heating.target);
 
             setCheckboxValue('#tDhwEnabled', result.dhw.enabled);
-            setValue('#tDhwTargetTemp', result.dhw.target);
+            setValue('.tDhw .targetTemp', result.dhw.target);
 
             setValue('.tempUnit', temperatureUnit(unitSystem));
             setValue('.pressureUnit', pressureUnit(unitSystem));
@@ -433,20 +519,20 @@
               cache: "no-cache",
               credentials: "include"
             });
-            
+
             if (!response.ok) {
               throw new Error('Response not valid');
             }
 
             const result = await response.json();
-            
+
             // Graph
-            setValue('#tHeatCurrentTemp', result.master.heating.indoorTempControl 
-              ? result.master.heating.indoorTemp 
+            setValue('#tHeatCurrentTemp', result.master.heating.indoorTempControl
+              ? result.master.heating.indoorTemp
               : result.master.heating.currentTemp
             );
             setValue('#tDhwCurrentTemp', result.master.dhw.currentTemp);
-            
+
 
             // SLAVE
             setValue('.sMemberId', result.slave.memberId);
@@ -462,6 +548,7 @@
               result.slave.connected ? "green" : "red"
             );
             setState('.sFlame', result.slave.flame);
+            setState('.sCooling', result.slave.cooling);
 
             setValue('.sModMin', result.slave.modulation.min);
             setValue('.sModMax', result.slave.modulation.max);
@@ -489,6 +576,13 @@
                 : "-"
             );
 
+            if (result.slave.fault.active) {
+              show(".notify-fault");
+
+            } else {
+              hide('.notify-fault');
+            }
+
             setStatus(
               '.sDiagActive',
               result.slave.diag.active ? "success" : "error",
@@ -501,6 +595,13 @@
                 : "-"
             );
 
+            if (result.slave.diag.active) {
+              show(".notify-diag");
+
+            } else {
+              hide('.notify-diag');
+            }
+
 
             // MASTER
             setState('.mHeatEnabled', result.master.heating.enabled);
@@ -541,6 +642,14 @@
             setState('.mCascadeControlInput', result.master.cascadeControl.input);
             setState('.mCascadeControlOutput', result.master.cascadeControl.output);
 
+            const tHeat = document.querySelector('.tHeat');
+            tHeat.dataset.min = result.master.heating.minTemp;
+            tHeat.dataset.max = result.master.heating.maxTemp;
+
+            const tDhw = document.querySelector('.tDhw');
+            tDhw.dataset.min = result.master.dhw.minTemp;
+            tDhw.dataset.max = result.master.dhw.maxTemp;
+
             setBusy('#dashboard-busy', '#dashboard-container', false);
 
           } catch (error) {
@@ -553,7 +662,7 @@
               cache: "no-cache",
               credentials: "include"
             });
-            
+
             if (!response.ok) {
               throw new Error("Response not valid");
             }
@@ -579,7 +688,7 @@
               if (!sensorNode) {
                 continue;
               }
-              
+
               const sData = result[sensorId];
               if (!sData.enabled || sData.purpose == 255) {
                 sensorNode.classList.toggle("hidden", true);

src_data/pages/index.html

@@ -21,6 +21,7 @@
           <li>
             <select id="lang" aria-label="Lang">
               <option value="en" selected>EN</option>
+              <option value="it">IT</option>
               <option value="ru">RU</option>
             </select>
           </li>

src_data/pages/network.html

@@ -21,6 +21,7 @@
           <li>
             <select id="lang" aria-label="Lang">
               <option value="en" selected>EN</option>
+              <option value="it">IT</option>
               <option value="ru">RU</option>
             </select>
           </li>
@@ -38,37 +39,37 @@
 
           <div id="network-settings-busy" aria-busy="true"></div>
           <form action="/api/network/settings" id="network-settings" class="hidden">
-            <label for="network-hostname">
+            <label>
               <span data-i18n>network.params.hostname</span>
-              <input type="text" id="network-hostname" name="hostname" maxlength="24" pattern="[A-Za-z0-9]+[A-Za-z0-9\-]+[A-Za-z0-9]+" required>
+              <input type="text" name="hostname" maxlength="24" pattern="[A-Za-z0-9]+[A-Za-z0-9\-]+[A-Za-z0-9]+" required>
             </label>
 
-            <label for="network-use-dhcp">
-              <input type="checkbox" id="network-use-dhcp" name="useDhcp" value="true">
+            <label>
+              <input type="checkbox" name="useDhcp" value="true">
               <span data-i18n>network.params.dhcp</span>
             </label>
             <br />
             <hr />
             <h4 data-i18n>network.section.static</h4>
 
-            <label for="network-static-ip">
+            <label>
               <span data-i18n>network.params.ip</span>
-              <input type="text" id="network-static-ip" name="staticConfig[ip]" value="true" maxlength="16" pattern="\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}" required>
+              <input type="text" name="staticConfig[ip]" value="true" maxlength="16" pattern="\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}" required>
             </label>
 
-            <label for="network-static-gateway">
+            <label>
               <span data-i18n>network.params.gateway</span>
-              <input type="text" id="network-static-gateway" name="staticConfig[gateway]" maxlength="16" pattern="\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}" required>
+              <input type="text" name="staticConfig[gateway]" maxlength="16" pattern="\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}" required>
             </label>
 
-            <label for="network-static-subnet">
+            <label>
               <span data-i18n>network.params.subnet</span>
-              <input type="text" id="network-static-subnet" name="staticConfig[subnet]" maxlength="16" pattern="\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}" required>
+              <input type="text" name="staticConfig[subnet]" maxlength="16" pattern="\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}" required>
             </label>
 
-            <label for="network-static-dns">
+            <label>
               <span data-i18n>network.params.dns</span>
-              <input type="text" id="network-static-dns" name="staticConfig[dns]" maxlength="16" pattern="\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}" required>
+              <input type="text" name="staticConfig[dns]" maxlength="16" pattern="\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}" required>
             </label>
 
             <button type="submit" data-i18n>button.save</button>
@@ -109,19 +110,19 @@
 
             <div id="sta-settings-busy" aria-busy="true"></div>
             <form action="/api/network/settings" id="sta-settings" class="hidden">
-              <label for="sta-ssid">
+              <label>
                 <span data-i18n>network.wifi.ssid</span>
-                <input type="text" id="sta-ssid" name="sta[ssid]" maxlength="32" required>
+                <input type="text" name="sta[ssid]" maxlength="32" required>
               </label>
 
-              <label for="sta-password">
+              <label>
                 <span data-i18n>network.wifi.password</span>
-                <input type="password" id="sta-password" name="sta[password]" maxlength="64" required>
+                <input type="password" name="sta[password]" maxlength="64" required>
               </label>
 
-              <label for="sta-channel">
+              <label>
                 <span data-i18n>network.wifi.channel</span>
-                <input type="number" inputmode="numeric" id="sta-channel" name="sta[channel]" min="0" max="12" step="1" required>
+                <input type="number" inputmode="numeric" name="sta[channel]" min="0" max="12" step="1" required>
                 <small data-i18n>network.sta.channel.note</small>
               </label>
 
@@ -140,19 +141,19 @@
 
           <div id="ap-settings-busy" aria-busy="true"></div>
           <form action="/api/network/settings" id="ap-settings" class="hidden">
-            <label for="ap-ssid">
+            <label>
               <span data-i18n>network.wifi.ssid</span>
-              <input type="text" id="ap-ssid" name="ap[ssid]" maxlength="32" required>
+              <input type="text" name="ap[ssid]" maxlength="32" required>
             </label>
 
-            <label for="ap-password">
+            <label>
               <span data-i18n>network.wifi.password</span>
-              <input type="text" id="ap-password" name="ap[password]" maxlength="64" required>
+              <input type="text" name="ap[password]" maxlength="64" required>
             </label>
 
-            <label for="ap-channel">
+            <label>
               <span data-i18n>network.wifi.channel</span>
-              <input type="number" inputmode="numeric" id="ap-channel" name="ap[channel]" min="1" max="12" step="1" required>
+              <input type="number" inputmode="numeric" name="ap[channel]" min="1" max="12" step="1" required>
             </label>
 
             <button type="submit" data-i18n>button.save</button>
@@ -179,22 +180,22 @@
         lang.build();
 
         const fillData = (data) => {
-          setInputValue('#network-hostname', data.hostname);
-          setCheckboxValue('#network-use-dhcp', data.useDhcp);
-          setInputValue('#network-static-ip', data.staticConfig.ip);
-          setInputValue('#network-static-gateway', data.staticConfig.gateway);
-          setInputValue('#network-static-subnet', data.staticConfig.subnet);
-          setInputValue('#network-static-dns', data.staticConfig.dns);
+          setInputValue("[name='hostname']", data.hostname);
+          setCheckboxValue("[name='useDhcp']", data.useDhcp);
+          setInputValue("[name='staticConfig[ip]']", data.staticConfig.ip);
+          setInputValue("[name='staticConfig[gateway]']", data.staticConfig.gateway);
+          setInputValue("[name='staticConfig[subnet]']", data.staticConfig.subnet);
+          setInputValue("[name='staticConfig[dns]']", data.staticConfig.dns);
           setBusy('#network-settings-busy', '#network-settings', false);
 
-          setInputValue('#sta-ssid', data.sta.ssid);
-          setInputValue('#sta-password', data.sta.password);
-          setInputValue('#sta-channel', data.sta.channel);
+          setInputValue("[name='sta[ssid]']", data.sta.ssid);
+          setInputValue("[name='sta[password]']", data.sta.password);
+          setInputValue("[name='sta[channel]']", data.sta.channel);
           setBusy('#sta-settings-busy', '#sta-settings', false);
 
-          setInputValue('#ap-ssid', data.ap.ssid);
-          setInputValue('#ap-password', data.ap.password);
-          setInputValue('#ap-channel', data.ap.channel);
+          setInputValue("[name='ap[ssid]']", data.ap.ssid);
+          setInputValue("[name='ap[password]']", data.ap.password);
+          setInputValue("[name='ap[channel]']", data.ap.channel);
           setBusy('#ap-settings-busy', '#ap-settings', false);
         };
 

src_data/pages/sensors.html

@@ -21,6 +21,7 @@
           <li>
             <select id="lang" aria-label="Lang">
               <option value="en" selected>EN</option>
+              <option value="it">IT</option>
               <option value="ru">RU</option>
             </select>
           </li>
@@ -36,7 +37,7 @@
         </hgroup>
 
         <details id="template" class="sensor hidden" data-id="" data-preloaded="0">
-          <summary><b>#<span class="id"></span>: <span class="name"></span></b></summary>
+          <summary><b>#<span class="pos"></span>: <span class="name"></span></b></summary>
 
           <div>
             <div class="form-busy" aria-busy="true"></div>
@@ -68,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>
@@ -101,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>
@@ -134,12 +144,12 @@
                 <div class="grid">
                   <label>
                     <span data-i18n>sensors.correction.offset</span>
-                    <input type="number" inputmode="numeric" name="offset" min="-20" max="20" step="0.01" required>
+                    <input type="number" inputmode="decimal" name="offset" min="-20" max="20" step="0.01" required>
                   </label>
 
                   <label>
                     <span data-i18n>sensors.correction.factor</span>
-                    <input type="number" inputmode="numeric" name="factor" min="0.01" max="10" step="0.01" required>
+                    <input type="number" inputmode="decimal" name="factor" min="0.01" max="100" step="0.01" required>
                   </label>
                 </div>
               </details>
@@ -159,7 +169,7 @@
   
                   <label>
                     <span data-i18n>sensors.filtering.factor.title</span>
-                    <input type="number" inputmode="numeric" name="filteringFactor" min="0.01" max="1" step="0.01">
+                    <input type="number" inputmode="decimal" name="filteringFactor" min="0.01" max="1" step="0.01">
                     <small data-i18n>sensors.filtering.factor.note</small>
                   </label>
                 </div>
@@ -210,6 +220,7 @@
             sensorNode.classList.remove("hidden");
             sensorNode.dataset.id = sensorId;
             setValue(".id", sensorId, sensorNode);
+            setValue(".pos", parseInt(sensorId) + 1, sensorNode);
             setValue(".name", result[sensorId], sensorNode);
             
             container.appendChild(sensorNode);

src_data/pages/upgrade.html

@@ -21,6 +21,7 @@
           <li>
             <select id="lang" aria-label="Lang">
               <option value="en" selected>EN</option>
+              <option value="it">IT</option>
               <option value="ru">RU</option>
             </select>
           </li>
@@ -42,7 +43,7 @@
               <input type="file" name="settings" id="restore-file" accept=".json">
             </label>
 
-            <div class="grid">
+            <div role="group">
               <button type="submit" data-i18n>button.restore</button>
               <button type="button" class="secondary" onclick="window.location='/api/backup/save';" data-i18n>button.backup</button>
             </div>

src_data/robots.txt

@@ -0,0 +1,2 @@
+User-agent: *
+Disallow: /

src_data/scripts/utils.js

@@ -132,10 +132,14 @@ const setupNetworkScanForm = (formSelector, tableSelector) => {
       for (let i = 0; i < result.length; i++) {
         let row = tbody.insertRow(-1);
         row.classList.add("network");
-        row.setAttribute('data-ssid', result[i].hidden ? '' : result[i].ssid);
-        row.onclick = () => {
-          const input = document.querySelector('input#sta-ssid');
-          const ssid = this.getAttribute('data-ssid');
+        row.dataset.ssid = result[i].hidden ? '' : result[i].ssid;
+        row.insertCell().textContent = `#${i + 1}`;
+
+        const nameCell = row.insertCell();
+        nameCell.innerHTML = result[i].hidden ? `<i>${result[i].bssid}</i>` : result[i].ssid;
+        nameCell.onclick = (event) => {
+          const input = document.querySelector("[name='sta[ssid]']");
+          const ssid = event.target.parentNode.dataset.ssid;
           if (!input || !ssid) {
             return;
           }
@@ -144,9 +148,6 @@ const setupNetworkScanForm = (formSelector, tableSelector) => {
           input.focus();
         };
 
-        row.insertCell().textContent = `#${i + 1}`;
-        row.insertCell().innerHTML = result[i].hidden ? `<i>${result[i].bssid}</i>` : result[i].ssid;
-
         // info cell
         let infoCell = row.insertCell();
 
@@ -165,7 +166,7 @@ const setupNetworkScanForm = (formSelector, tableSelector) => {
         }
         
         let signalQualityContainer = document.createElement("span");
-        signalQualityContainer.setAttribute('data-tooltip', `${result[i].signalQuality}%`);
+        signalQualityContainer.dataset.tooltip = `${result[i].signalQuality}%`;
         signalQualityContainer.appendChild(signalQualityIcon);
         infoCell.appendChild(signalQualityContainer);
 
@@ -192,7 +193,7 @@ const setupNetworkScanForm = (formSelector, tableSelector) => {
         }
 
         let authContainer = document.createElement("span");
-        authContainer.setAttribute('data-tooltip', (result[i].auth in authList) ? authList[result[i].auth] : "unknown");
+        authContainer.dataset.tooltip = (result[i].auth in authList) ? authList[result[i].auth] : "unknown";
         authContainer.appendChild(authIcon);
         infoCell.appendChild(authContainer);
       }
@@ -848,4 +849,8 @@ function dec2hex(i) {
   }
   
   return hex.toUpperCase();
+}
+
+function constrain(amt, low, high) {
+  return ((amt) < (low) ? (low) : ((amt) > (high) ? (high) : (amt)));
 }

src_data/styles/app.css

@@ -115,6 +115,7 @@ tr.network:hover {
   font-family: var(--pico-font-family-monospace);
 }
 
+
 .thermostat {
   display: grid;
   grid-template-columns: 0.5fr 2fr 0.5fr;
@@ -193,6 +194,92 @@ tr.network:hover {
   margin: 1.25rem 0;
 }
 
+
+@media (max-width: 575px) {
+  .notify {
+    display: grid; 
+    grid-template-columns: 1fr; 
+    grid-template-rows: 1fr 0.5fr; 
+    gap: 0.5rem 0.5rem;
+    grid-template-areas: 
+      "notify-content"
+      "notify-actions"; 
+  }
+
+  .notify-icon {
+    display: none;
+  }
+
+  .notify-content {
+    justify-self: center;
+    align-self: center;
+    grid-area: notify-content; 
+  }
+
+  .notify-actions {
+    justify-self: center; 
+    align-self: center; 
+    grid-area: notify-actions; 
+  }
+}
+
+@media (min-width: 576px) {
+  .notify {
+    display: grid;
+    grid-template-columns: 5rem 1fr 10rem;
+    grid-template-rows: 1fr;
+    gap: 0rem 0.5rem;
+    grid-auto-flow: row;
+    grid-template-areas:
+      "notify-icon notify-content notify-actions";
+  }
+
+  .notify-icon {
+    justify-self: center;
+    align-self: center;
+    grid-area: notify-icon;
+  }
+
+  .notify-content {
+    justify-self: center;
+    align-self: center;
+    grid-area: notify-content;
+  }
+  
+  .notify-actions {
+    justify-self: center;
+    align-self: center;
+    grid-area: notify-actions;
+  }
+}
+
+.notify {
+  margin: 1rem;
+  padding: 0.5rem;
+  border: .25rem solid var(--pico-blockquote-border-color);
+}
+
+.notify-error {
+  border-color: var(--pico-form-element-invalid-border-color);
+}
+
+.notify-error .notify-icon {
+  color: var(--pico-form-element-invalid-border-color);
+}
+
+.notify-alarm {
+  border-color: #c89048;
+}
+
+.notify-alarm .notify-icon {
+  color: #c89048;
+}
+
+.notify-icon i {
+  font-size: 2.5rem;
+}
+
+
 [class*=" icons-"],
 [class=icons],
 [class^=icons-] {

src_data/timezones.json

@@ -0,0 +1,458 @@
+{
+  "Africa/Abidjan":"GMT0",
+  "Africa/Accra":"GMT0",
+  "Africa/Addis_Ababa":"EAT-3",
+  "Africa/Algiers":"CET-1",
+  "Africa/Asmara":"EAT-3",
+  "Africa/Bamako":"GMT0",
+  "Africa/Bangui":"WAT-1",
+  "Africa/Banjul":"GMT0",
+  "Africa/Bissau":"GMT0",
+  "Africa/Blantyre":"CAT-2",
+  "Africa/Brazzaville":"WAT-1",
+  "Africa/Bujumbura":"CAT-2",
+  "Africa/Cairo":"EET-2EEST,M4.5.5/0,M10.5.4/24",
+  "Africa/Casablanca":"<+01>-1",
+  "Africa/Ceuta":"CET-1CEST,M3.5.0,M10.5.0/3",
+  "Africa/Conakry":"GMT0",
+  "Africa/Dakar":"GMT0",
+  "Africa/Dar_es_Salaam":"EAT-3",
+  "Africa/Djibouti":"EAT-3",
+  "Africa/Douala":"WAT-1",
+  "Africa/El_Aaiun":"<+01>-1",
+  "Africa/Freetown":"GMT0",
+  "Africa/Gaborone":"CAT-2",
+  "Africa/Harare":"CAT-2",
+  "Africa/Johannesburg":"SAST-2",
+  "Africa/Juba":"CAT-2",
+  "Africa/Kampala":"EAT-3",
+  "Africa/Khartoum":"CAT-2",
+  "Africa/Kigali":"CAT-2",
+  "Africa/Kinshasa":"WAT-1",
+  "Africa/Lagos":"WAT-1",
+  "Africa/Libreville":"WAT-1",
+  "Africa/Lome":"GMT0",
+  "Africa/Luanda":"WAT-1",
+  "Africa/Lubumbashi":"CAT-2",
+  "Africa/Lusaka":"CAT-2",
+  "Africa/Malabo":"WAT-1",
+  "Africa/Maputo":"CAT-2",
+  "Africa/Maseru":"SAST-2",
+  "Africa/Mbabane":"SAST-2",
+  "Africa/Mogadishu":"EAT-3",
+  "Africa/Monrovia":"GMT0",
+  "Africa/Nairobi":"EAT-3",
+  "Africa/Ndjamena":"WAT-1",
+  "Africa/Niamey":"WAT-1",
+  "Africa/Nouakchott":"GMT0",
+  "Africa/Ouagadougou":"GMT0",
+  "Africa/Porto-Novo":"WAT-1",
+  "Africa/Sao_Tome":"GMT0",
+  "Africa/Tripoli":"EET-2",
+  "Africa/Tunis":"CET-1",
+  "Africa/Windhoek":"CAT-2",
+  "America/Adak":"HST10HDT,M3.2.0,M11.1.0",
+  "America/Anchorage":"AKST9AKDT,M3.2.0,M11.1.0",
+  "America/Anguilla":"AST4",
+  "America/Antigua":"AST4",
+  "America/Araguaina":"<-03>3",
+  "America/Argentina/Buenos_Aires":"<-03>3",
+  "America/Argentina/Catamarca":"<-03>3",
+  "America/Argentina/Cordoba":"<-03>3",
+  "America/Argentina/Jujuy":"<-03>3",
+  "America/Argentina/La_Rioja":"<-03>3",
+  "America/Argentina/Mendoza":"<-03>3",
+  "America/Argentina/Rio_Gallegos":"<-03>3",
+  "America/Argentina/Salta":"<-03>3",
+  "America/Argentina/San_Juan":"<-03>3",
+  "America/Argentina/San_Luis":"<-03>3",
+  "America/Argentina/Tucuman":"<-03>3",
+  "America/Argentina/Ushuaia":"<-03>3",
+  "America/Aruba":"AST4",
+  "America/Asuncion":"<-04>4<-03>,M10.1.0/0,M3.4.0/0",
+  "America/Atikokan":"EST5",
+  "America/Bahia":"<-03>3",
+  "America/Bahia_Banderas":"CST6",
+  "America/Barbados":"AST4",
+  "America/Belem":"<-03>3",
+  "America/Belize":"CST6",
+  "America/Blanc-Sablon":"AST4",
+  "America/Boa_Vista":"<-04>4",
+  "America/Bogota":"<-05>5",
+  "America/Boise":"MST7MDT,M3.2.0,M11.1.0",
+  "America/Cambridge_Bay":"MST7MDT,M3.2.0,M11.1.0",
+  "America/Campo_Grande":"<-04>4",
+  "America/Cancun":"EST5",
+  "America/Caracas":"<-04>4",
+  "America/Cayenne":"<-03>3",
+  "America/Cayman":"EST5",
+  "America/Chicago":"CST6CDT,M3.2.0,M11.1.0",
+  "America/Chihuahua":"CST6",
+  "America/Costa_Rica":"CST6",
+  "America/Creston":"MST7",
+  "America/Cuiaba":"<-04>4",
+  "America/Curacao":"AST4",
+  "America/Danmarkshavn":"GMT0",
+  "America/Dawson":"MST7",
+  "America/Dawson_Creek":"MST7",
+  "America/Denver":"MST7MDT,M3.2.0,M11.1.0",
+  "America/Detroit":"EST5EDT,M3.2.0,M11.1.0",
+  "America/Dominica":"AST4",
+  "America/Edmonton":"MST7MDT,M3.2.0,M11.1.0",
+  "America/Eirunepe":"<-05>5",
+  "America/El_Salvador":"CST6",
+  "America/Fort_Nelson":"MST7",
+  "America/Fortaleza":"<-03>3",
+  "America/Glace_Bay":"AST4ADT,M3.2.0,M11.1.0",
+  "America/Godthab":"<-02>2<-01>,M3.5.0/-1,M10.5.0/0",
+  "America/Goose_Bay":"AST4ADT,M3.2.0,M11.1.0",
+  "America/Grand_Turk":"EST5EDT,M3.2.0,M11.1.0",
+  "America/Grenada":"AST4",
+  "America/Guadeloupe":"AST4",
+  "America/Guatemala":"CST6",
+  "America/Guayaquil":"<-05>5",
+  "America/Guyana":"<-04>4",
+  "America/Halifax":"AST4ADT,M3.2.0,M11.1.0",
+  "America/Havana":"CST5CDT,M3.2.0/0,M11.1.0/1",
+  "America/Hermosillo":"MST7",
+  "America/Indiana/Indianapolis":"EST5EDT,M3.2.0,M11.1.0",
+  "America/Indiana/Knox":"CST6CDT,M3.2.0,M11.1.0",
+  "America/Indiana/Marengo":"EST5EDT,M3.2.0,M11.1.0",
+  "America/Indiana/Petersburg":"EST5EDT,M3.2.0,M11.1.0",
+  "America/Indiana/Tell_City":"CST6CDT,M3.2.0,M11.1.0",
+  "America/Indiana/Vevay":"EST5EDT,M3.2.0,M11.1.0",
+  "America/Indiana/Vincennes":"EST5EDT,M3.2.0,M11.1.0",
+  "America/Indiana/Winamac":"EST5EDT,M3.2.0,M11.1.0",
+  "America/Inuvik":"MST7MDT,M3.2.0,M11.1.0",
+  "America/Iqaluit":"EST5EDT,M3.2.0,M11.1.0",
+  "America/Jamaica":"EST5",
+  "America/Juneau":"AKST9AKDT,M3.2.0,M11.1.0",
+  "America/Kentucky/Louisville":"EST5EDT,M3.2.0,M11.1.0",
+  "America/Kentucky/Monticello":"EST5EDT,M3.2.0,M11.1.0",
+  "America/Kralendijk":"AST4",
+  "America/La_Paz":"<-04>4",
+  "America/Lima":"<-05>5",
+  "America/Los_Angeles":"PST8PDT,M3.2.0,M11.1.0",
+  "America/Lower_Princes":"AST4",
+  "America/Maceio":"<-03>3",
+  "America/Managua":"CST6",
+  "America/Manaus":"<-04>4",
+  "America/Marigot":"AST4",
+  "America/Martinique":"AST4",
+  "America/Matamoros":"CST6CDT,M3.2.0,M11.1.0",
+  "America/Mazatlan":"MST7",
+  "America/Menominee":"CST6CDT,M3.2.0,M11.1.0",
+  "America/Merida":"CST6",
+  "America/Metlakatla":"AKST9AKDT,M3.2.0,M11.1.0",
+  "America/Mexico_City":"CST6",
+  "America/Miquelon":"<-03>3<-02>,M3.2.0,M11.1.0",
+  "America/Moncton":"AST4ADT,M3.2.0,M11.1.0",
+  "America/Monterrey":"CST6",
+  "America/Montevideo":"<-03>3",
+  "America/Montreal":"EST5EDT,M3.2.0,M11.1.0",
+  "America/Montserrat":"AST4",
+  "America/Nassau":"EST5EDT,M3.2.0,M11.1.0",
+  "America/New_York":"EST5EDT,M3.2.0,M11.1.0",
+  "America/Nipigon":"EST5EDT,M3.2.0,M11.1.0",
+  "America/Nome":"AKST9AKDT,M3.2.0,M11.1.0",
+  "America/Noronha":"<-02>2",
+  "America/North_Dakota/Beulah":"CST6CDT,M3.2.0,M11.1.0",
+  "America/North_Dakota/Center":"CST6CDT,M3.2.0,M11.1.0",
+  "America/North_Dakota/New_Salem":"CST6CDT,M3.2.0,M11.1.0",
+  "America/Nuuk":"<-02>2<-01>,M3.5.0/-1,M10.5.0/0",
+  "America/Ojinaga":"CST6CDT,M3.2.0,M11.1.0",
+  "America/Panama":"EST5",
+  "America/Pangnirtung":"EST5EDT,M3.2.0,M11.1.0",
+  "America/Paramaribo":"<-03>3",
+  "America/Phoenix":"MST7",
+  "America/Port-au-Prince":"EST5EDT,M3.2.0,M11.1.0",
+  "America/Port_of_Spain":"AST4",
+  "America/Porto_Velho":"<-04>4",
+  "America/Puerto_Rico":"AST4",
+  "America/Punta_Arenas":"<-03>3",
+  "America/Rainy_River":"CST6CDT,M3.2.0,M11.1.0",
+  "America/Rankin_Inlet":"CST6CDT,M3.2.0,M11.1.0",
+  "America/Recife":"<-03>3",
+  "America/Regina":"CST6",
+  "America/Resolute":"CST6CDT,M3.2.0,M11.1.0",
+  "America/Rio_Branco":"<-05>5",
+  "America/Santarem":"<-03>3",
+  "America/Santiago":"<-04>4<-03>,M9.1.6/24,M4.1.6/24",
+  "America/Santo_Domingo":"AST4",
+  "America/Sao_Paulo":"<-03>3",
+  "America/Scoresbysund":"<-02>2<-01>,M3.5.0/-1,M10.5.0/0",
+  "America/Sitka":"AKST9AKDT,M3.2.0,M11.1.0",
+  "America/St_Barthelemy":"AST4",
+  "America/St_Johns":"NST3:30NDT,M3.2.0,M11.1.0",
+  "America/St_Kitts":"AST4",
+  "America/St_Lucia":"AST4",
+  "America/St_Thomas":"AST4",
+  "America/St_Vincent":"AST4",
+  "America/Swift_Current":"CST6",
+  "America/Tegucigalpa":"CST6",
+  "America/Thule":"AST4ADT,M3.2.0,M11.1.0",
+  "America/Thunder_Bay":"EST5EDT,M3.2.0,M11.1.0",
+  "America/Tijuana":"PST8PDT,M3.2.0,M11.1.0",
+  "America/Toronto":"EST5EDT,M3.2.0,M11.1.0",
+  "America/Tortola":"AST4",
+  "America/Vancouver":"PST8PDT,M3.2.0,M11.1.0",
+  "America/Whitehorse":"MST7",
+  "America/Winnipeg":"CST6CDT,M3.2.0,M11.1.0",
+  "America/Yakutat":"AKST9AKDT,M3.2.0,M11.1.0",
+  "America/Yellowknife":"MST7MDT,M3.2.0,M11.1.0",
+  "Antarctica/Casey":"<+08>-8",
+  "Antarctica/Davis":"<+07>-7",
+  "Antarctica/DumontDUrville":"<+10>-10",
+  "Antarctica/Macquarie":"AEST-10AEDT,M10.1.0,M4.1.0/3",
+  "Antarctica/Mawson":"<+05>-5",
+  "Antarctica/McMurdo":"NZST-12NZDT,M9.5.0,M4.1.0/3",
+  "Antarctica/Palmer":"<-03>3",
+  "Antarctica/Rothera":"<-03>3",
+  "Antarctica/Syowa":"<+03>-3",
+  "Antarctica/Troll":"<+00>0<+02>-2,M3.5.0/1,M10.5.0/3",
+  "Antarctica/Vostok":"<+05>-5",
+  "Arctic/Longyearbyen":"CET-1CEST,M3.5.0,M10.5.0/3",
+  "Asia/Aden":"<+03>-3",
+  "Asia/Almaty":"<+05>-5",
+  "Asia/Amman":"<+03>-3",
+  "Asia/Anadyr":"<+12>-12",
+  "Asia/Aqtau":"<+05>-5",
+  "Asia/Aqtobe":"<+05>-5",
+  "Asia/Ashgabat":"<+05>-5",
+  "Asia/Atyrau":"<+05>-5",
+  "Asia/Baghdad":"<+03>-3",
+  "Asia/Bahrain":"<+03>-3",
+  "Asia/Baku":"<+04>-4",
+  "Asia/Bangkok":"<+07>-7",
+  "Asia/Barnaul":"<+07>-7",
+  "Asia/Beirut":"EET-2EEST,M3.5.0/0,M10.5.0/0",
+  "Asia/Bishkek":"<+06>-6",
+  "Asia/Brunei":"<+08>-8",
+  "Asia/Chita":"<+09>-9",
+  "Asia/Choibalsan":"<+08>-8",
+  "Asia/Colombo":"<+0530>-5:30",
+  "Asia/Damascus":"<+03>-3",
+  "Asia/Dhaka":"<+06>-6",
+  "Asia/Dili":"<+09>-9",
+  "Asia/Dubai":"<+04>-4",
+  "Asia/Dushanbe":"<+05>-5",
+  "Asia/Famagusta":"EET-2EEST,M3.5.0/3,M10.5.0/4",
+  "Asia/Gaza":"EET-2EEST,M3.4.4/50,M10.4.4/50",
+  "Asia/Hebron":"EET-2EEST,M3.4.4/50,M10.4.4/50",
+  "Asia/Ho_Chi_Minh":"<+07>-7",
+  "Asia/Hong_Kong":"HKT-8",
+  "Asia/Hovd":"<+07>-7",
+  "Asia/Irkutsk":"<+08>-8",
+  "Asia/Jakarta":"WIB-7",
+  "Asia/Jayapura":"WIT-9",
+  "Asia/Jerusalem":"IST-2IDT,M3.4.4/26,M10.5.0",
+  "Asia/Kabul":"<+0430>-4:30",
+  "Asia/Kamchatka":"<+12>-12",
+  "Asia/Karachi":"PKT-5",
+  "Asia/Kathmandu":"<+0545>-5:45",
+  "Asia/Khandyga":"<+09>-9",
+  "Asia/Kolkata":"IST-5:30",
+  "Asia/Krasnoyarsk":"<+07>-7",
+  "Asia/Kuala_Lumpur":"<+08>-8",
+  "Asia/Kuching":"<+08>-8",
+  "Asia/Kuwait":"<+03>-3",
+  "Asia/Macau":"CST-8",
+  "Asia/Magadan":"<+11>-11",
+  "Asia/Makassar":"WITA-8",
+  "Asia/Manila":"PST-8",
+  "Asia/Muscat":"<+04>-4",
+  "Asia/Nicosia":"EET-2EEST,M3.5.0/3,M10.5.0/4",
+  "Asia/Novokuznetsk":"<+07>-7",
+  "Asia/Novosibirsk":"<+07>-7",
+  "Asia/Omsk":"<+06>-6",
+  "Asia/Oral":"<+05>-5",
+  "Asia/Phnom_Penh":"<+07>-7",
+  "Asia/Pontianak":"WIB-7",
+  "Asia/Pyongyang":"KST-9",
+  "Asia/Qatar":"<+03>-3",
+  "Asia/Qyzylorda":"<+05>-5",
+  "Asia/Riyadh":"<+03>-3",
+  "Asia/Sakhalin":"<+11>-11",
+  "Asia/Samarkand":"<+05>-5",
+  "Asia/Seoul":"KST-9",
+  "Asia/Shanghai":"CST-8",
+  "Asia/Singapore":"<+08>-8",
+  "Asia/Srednekolymsk":"<+11>-11",
+  "Asia/Taipei":"CST-8",
+  "Asia/Tashkent":"<+05>-5",
+  "Asia/Tbilisi":"<+04>-4",
+  "Asia/Tehran":"<+0330>-3:30",
+  "Asia/Thimphu":"<+06>-6",
+  "Asia/Tokyo":"JST-9",
+  "Asia/Tomsk":"<+07>-7",
+  "Asia/Ulaanbaatar":"<+08>-8",
+  "Asia/Urumqi":"<+06>-6",
+  "Asia/Ust-Nera":"<+10>-10",
+  "Asia/Vientiane":"<+07>-7",
+  "Asia/Vladivostok":"<+10>-10",
+  "Asia/Yakutsk":"<+09>-9",
+  "Asia/Yangon":"<+0630>-6:30",
+  "Asia/Yekaterinburg":"<+05>-5",
+  "Asia/Yerevan":"<+04>-4",
+  "Atlantic/Azores":"<-01>1<+00>,M3.5.0/0,M10.5.0/1",
+  "Atlantic/Bermuda":"AST4ADT,M3.2.0,M11.1.0",
+  "Atlantic/Canary":"WET0WEST,M3.5.0/1,M10.5.0",
+  "Atlantic/Cape_Verde":"<-01>1",
+  "Atlantic/Faroe":"WET0WEST,M3.5.0/1,M10.5.0",
+  "Atlantic/Madeira":"WET0WEST,M3.5.0/1,M10.5.0",
+  "Atlantic/Reykjavik":"GMT0",
+  "Atlantic/South_Georgia":"<-02>2",
+  "Atlantic/St_Helena":"GMT0",
+  "Atlantic/Stanley":"<-03>3",
+  "Australia/Adelaide":"ACST-9:30ACDT,M10.1.0,M4.1.0/3",
+  "Australia/Brisbane":"AEST-10",
+  "Australia/Broken_Hill":"ACST-9:30ACDT,M10.1.0,M4.1.0/3",
+  "Australia/Currie":"AEST-10AEDT,M10.1.0,M4.1.0/3",
+  "Australia/Darwin":"ACST-9:30",
+  "Australia/Eucla":"<+0845>-8:45",
+  "Australia/Hobart":"AEST-10AEDT,M10.1.0,M4.1.0/3",
+  "Australia/Lindeman":"AEST-10",
+  "Australia/Lord_Howe":"<+1030>-10:30<+11>-11,M10.1.0,M4.1.0",
+  "Australia/Melbourne":"AEST-10AEDT,M10.1.0,M4.1.0/3",
+  "Australia/Perth":"AWST-8",
+  "Australia/Sydney":"AEST-10AEDT,M10.1.0,M4.1.0/3",
+  "Europe/Amsterdam":"CET-1CEST,M3.5.0,M10.5.0/3",
+  "Europe/Andorra":"CET-1CEST,M3.5.0,M10.5.0/3",
+  "Europe/Astrakhan":"<+04>-4",
+  "Europe/Athens":"EET-2EEST,M3.5.0/3,M10.5.0/4",
+  "Europe/Belgrade":"CET-1CEST,M3.5.0,M10.5.0/3",
+  "Europe/Berlin":"CET-1CEST,M3.5.0,M10.5.0/3",
+  "Europe/Bratislava":"CET-1CEST,M3.5.0,M10.5.0/3",
+  "Europe/Brussels":"CET-1CEST,M3.5.0,M10.5.0/3",
+  "Europe/Bucharest":"EET-2EEST,M3.5.0/3,M10.5.0/4",
+  "Europe/Budapest":"CET-1CEST,M3.5.0,M10.5.0/3",
+  "Europe/Busingen":"CET-1CEST,M3.5.0,M10.5.0/3",
+  "Europe/Chisinau":"EET-2EEST,M3.5.0,M10.5.0/3",
+  "Europe/Copenhagen":"CET-1CEST,M3.5.0,M10.5.0/3",
+  "Europe/Dublin":"IST-1GMT0,M10.5.0,M3.5.0/1",
+  "Europe/Gibraltar":"CET-1CEST,M3.5.0,M10.5.0/3",
+  "Europe/Guernsey":"GMT0BST,M3.5.0/1,M10.5.0",
+  "Europe/Helsinki":"EET-2EEST,M3.5.0/3,M10.5.0/4",
+  "Europe/Isle_of_Man":"GMT0BST,M3.5.0/1,M10.5.0",
+  "Europe/Istanbul":"<+03>-3",
+  "Europe/Jersey":"GMT0BST,M3.5.0/1,M10.5.0",
+  "Europe/Kaliningrad":"EET-2",
+  "Europe/Kiev":"EET-2EEST,M3.5.0/3,M10.5.0/4",
+  "Europe/Kirov":"MSK-3",
+  "Europe/Lisbon":"WET0WEST,M3.5.0/1,M10.5.0",
+  "Europe/Ljubljana":"CET-1CEST,M3.5.0,M10.5.0/3",
+  "Europe/London":"GMT0BST,M3.5.0/1,M10.5.0",
+  "Europe/Luxembourg":"CET-1CEST,M3.5.0,M10.5.0/3",
+  "Europe/Madrid":"CET-1CEST,M3.5.0,M10.5.0/3",
+  "Europe/Malta":"CET-1CEST,M3.5.0,M10.5.0/3",
+  "Europe/Mariehamn":"EET-2EEST,M3.5.0/3,M10.5.0/4",
+  "Europe/Minsk":"<+03>-3",
+  "Europe/Monaco":"CET-1CEST,M3.5.0,M10.5.0/3",
+  "Europe/Moscow":"MSK-3",
+  "Europe/Oslo":"CET-1CEST,M3.5.0,M10.5.0/3",
+  "Europe/Paris":"CET-1CEST,M3.5.0,M10.5.0/3",
+  "Europe/Podgorica":"CET-1CEST,M3.5.0,M10.5.0/3",
+  "Europe/Prague":"CET-1CEST,M3.5.0,M10.5.0/3",
+  "Europe/Riga":"EET-2EEST,M3.5.0/3,M10.5.0/4",
+  "Europe/Rome":"CET-1CEST,M3.5.0,M10.5.0/3",
+  "Europe/Samara":"<+04>-4",
+  "Europe/San_Marino":"CET-1CEST,M3.5.0,M10.5.0/3",
+  "Europe/Sarajevo":"CET-1CEST,M3.5.0,M10.5.0/3",
+  "Europe/Saratov":"<+04>-4",
+  "Europe/Simferopol":"MSK-3",
+  "Europe/Skopje":"CET-1CEST,M3.5.0,M10.5.0/3",
+  "Europe/Sofia":"EET-2EEST,M3.5.0/3,M10.5.0/4",
+  "Europe/Stockholm":"CET-1CEST,M3.5.0,M10.5.0/3",
+  "Europe/Tallinn":"EET-2EEST,M3.5.0/3,M10.5.0/4",
+  "Europe/Tirane":"CET-1CEST,M3.5.0,M10.5.0/3",
+  "Europe/Ulyanovsk":"<+04>-4",
+  "Europe/Uzhgorod":"EET-2EEST,M3.5.0/3,M10.5.0/4",
+  "Europe/Vaduz":"CET-1CEST,M3.5.0,M10.5.0/3",
+  "Europe/Vatican":"CET-1CEST,M3.5.0,M10.5.0/3",
+  "Europe/Vienna":"CET-1CEST,M3.5.0,M10.5.0/3",
+  "Europe/Vilnius":"EET-2EEST,M3.5.0/3,M10.5.0/4",
+  "Europe/Volgograd":"MSK-3",
+  "Europe/Warsaw":"CET-1CEST,M3.5.0,M10.5.0/3",
+  "Europe/Zagreb":"CET-1CEST,M3.5.0,M10.5.0/3",
+  "Europe/Zaporozhye":"EET-2EEST,M3.5.0/3,M10.5.0/4",
+  "Europe/Zurich":"CET-1CEST,M3.5.0,M10.5.0/3",
+  "Indian/Antananarivo":"EAT-3",
+  "Indian/Chagos":"<+06>-6",
+  "Indian/Christmas":"<+07>-7",
+  "Indian/Cocos":"<+0630>-6:30",
+  "Indian/Comoro":"EAT-3",
+  "Indian/Kerguelen":"<+05>-5",
+  "Indian/Mahe":"<+04>-4",
+  "Indian/Maldives":"<+05>-5",
+  "Indian/Mauritius":"<+04>-4",
+  "Indian/Mayotte":"EAT-3",
+  "Indian/Reunion":"<+04>-4",
+  "Pacific/Apia":"<+13>-13",
+  "Pacific/Auckland":"NZST-12NZDT,M9.5.0,M4.1.0/3",
+  "Pacific/Bougainville":"<+11>-11",
+  "Pacific/Chatham":"<+1245>-12:45<+1345>,M9.5.0/2:45,M4.1.0/3:45",
+  "Pacific/Chuuk":"<+10>-10",
+  "Pacific/Easter":"<-06>6<-05>,M9.1.6/22,M4.1.6/22",
+  "Pacific/Efate":"<+11>-11",
+  "Pacific/Enderbury":"<+13>-13",
+  "Pacific/Fakaofo":"<+13>-13",
+  "Pacific/Fiji":"<+12>-12",
+  "Pacific/Funafuti":"<+12>-12",
+  "Pacific/Galapagos":"<-06>6",
+  "Pacific/Gambier":"<-09>9",
+  "Pacific/Guadalcanal":"<+11>-11",
+  "Pacific/Guam":"ChST-10",
+  "Pacific/Honolulu":"HST10",
+  "Pacific/Kiritimati":"<+14>-14",
+  "Pacific/Kosrae":"<+11>-11",
+  "Pacific/Kwajalein":"<+12>-12",
+  "Pacific/Majuro":"<+12>-12",
+  "Pacific/Marquesas":"<-0930>9:30",
+  "Pacific/Midway":"SST11",
+  "Pacific/Nauru":"<+12>-12",
+  "Pacific/Niue":"<-11>11",
+  "Pacific/Norfolk":"<+11>-11<+12>,M10.1.0,M4.1.0/3",
+  "Pacific/Noumea":"<+11>-11",
+  "Pacific/Pago_Pago":"SST11",
+  "Pacific/Palau":"<+09>-9",
+  "Pacific/Pitcairn":"<-08>8",
+  "Pacific/Pohnpei":"<+11>-11",
+  "Pacific/Port_Moresby":"<+10>-10",
+  "Pacific/Rarotonga":"<-10>10",
+  "Pacific/Saipan":"ChST-10",
+  "Pacific/Tahiti":"<-10>10",
+  "Pacific/Tarawa":"<+12>-12",
+  "Pacific/Tongatapu":"<+13>-13",
+  "Pacific/Wake":"<+12>-12",
+  "Pacific/Wallis":"<+12>-12",
+
+  "Etc/UTC":"UTC0",
+  "Etc/GMT":"GMT0",
+  "Etc/GMT+1":"<-01>1",
+  "Etc/GMT+2":"<-02>2",
+  "Etc/GMT+3":"<-03>3",
+  "Etc/GMT+4":"<-04>4",
+  "Etc/GMT+5":"<-05>5",
+  "Etc/GMT+6":"<-06>6",
+  "Etc/GMT+7":"<-07>7",
+  "Etc/GMT+8":"<-08>8",
+  "Etc/GMT+9":"<-09>9",
+  "Etc/GMT+10":"<-10>10",
+  "Etc/GMT+11":"<-11>11",
+  "Etc/GMT+12":"<-12>12",
+  "Etc/GMT-1":"<+01>-1",
+  "Etc/GMT-2":"<+02>-2",
+  "Etc/GMT-3":"<+03>-3",
+  "Etc/GMT-4":"<+04>-4",
+  "Etc/GMT-5":"<+05>-5",
+  "Etc/GMT-6":"<+06>-6",
+  "Etc/GMT-7":"<+07>-7",
+  "Etc/GMT-8":"<+08>-8",
+  "Etc/GMT-9":"<+09>-9",
+  "Etc/GMT-10":"<+10>-10",
+  "Etc/GMT-11":"<+11>-11",
+  "Etc/GMT-12":"<+12>-12",
+  "Etc/GMT-13":"<+13>-13",
+  "Etc/GMT-14":"<+14>-14",
+  "Etc/Zulu":"UTC0"
+}