fix: decimation for Equitherm chart fixed; chartjs updated

README.md

@@ -72,7 +72,7 @@ All available information and instructions can be found in the wiki:
       * [Leds on board](https://github.com/Laxilef/OTGateway/wiki/OT-adapters#leds-on-board)
 
 ## Gratitude
-* To the developers of the libraries used: [OpenTherm Library](https://github.com/ihormelnyk/opentherm_library), [ESP8266Scheduler](https://github.com/nrwiersma/ESP8266Scheduler), [ArduinoJson](https://github.com/bblanchon/ArduinoJson), [NimBLE-Arduino](https://github.com/h2zero/NimBLE-Arduino), [ArduinoMqttClient](https://github.com/arduino-libraries/ArduinoMqttClient), [ESPTelnet](https://github.com/LennartHennigs/ESPTelnet), [FileData](https://github.com/GyverLibs/FileData), [GyverPID](https://github.com/GyverLibs/GyverPID), [GyverBlinker](https://github.com/GyverLibs/GyverBlinker), [OneWireNg](https://github.com/pstolarz/OneWireNg) & [OneWire](https://github.com/PaulStoffregen/OneWire)
+* To the developers of the libraries used: [OpenTherm Library](https://github.com/ihormelnyk/opentherm_library), [ESP8266Scheduler](https://github.com/nrwiersma/ESP8266Scheduler), [ArduinoJson](https://github.com/bblanchon/ArduinoJson), [NimBLE-Arduino](https://github.com/h2zero/NimBLE-Arduino), [ArduinoMqttClient](https://github.com/arduino-libraries/ArduinoMqttClient), [ESPTelnet](https://github.com/LennartHennigs/ESPTelnet), [FileData](https://github.com/GyverLibs/FileData), [GyverPID](https://github.com/GyverLibs/GyverPID), [GyverBlinker](https://github.com/GyverLibs/GyverBlinker), [FileData](https://github.com/GyverLibs/FileData), [OneWireNg](https://github.com/pstolarz/OneWireNg) & [OneWire](https://github.com/PaulStoffregen/OneWire)
 * To the [PlatformIO](https://platformio.org/) Team
 * To the team and contributors of the [pioarduino](https://github.com/pioarduino/platform-espressif32) project
 * To the [BrowserStack](https://www.browserstack.com/) team. This project is tested with BrowserStack.

gulpfile.js

@@ -27,6 +27,9 @@ let paths = {
         'src_data/scripts/i18n.min.js',
         'src_data/scripts/lang.js',
         'src_data/scripts/utils.js'
+      ],
+      'chart.js': [
+        'src_data/scripts/chart.js'
       ]
     }
   },

lib/CustomOpenTherm/CustomOpenTherm.h

@@ -4,8 +4,8 @@
 class CustomOpenTherm : public OpenTherm {
 public:
   typedef std::function<void(unsigned int)> DelayCallback;
-  typedef std::function<void(unsigned long, uint8_t)> BeforeSendRequestCallback;
+  typedef std::function<void(unsigned long, byte)> BeforeSendRequestCallback;
-  typedef std::function<void(unsigned long, unsigned long, OpenThermResponseStatus, uint8_t)> AfterSendRequestCallback;
+  typedef std::function<void(unsigned long, unsigned long, OpenThermResponseStatus, byte)> AfterSendRequestCallback;
 
   CustomOpenTherm(int inPin = 4, int outPin = 5, bool isSlave = false, bool alwaysReceive = false) : OpenTherm(inPin, outPin, isSlave, alwaysReceive) {}
   ~CustomOpenTherm() {}
@@ -106,14 +106,15 @@ public:
     return isValidResponse(response) && isValidResponseId(response, OpenThermMessageID::RemoteRequest);
   }
 
-  static bool isCh2Active(unsigned long response) {
+  static bool isCh2Active(unsigned long response)
+  {
       return response & 0x20;
   }
 
   static bool isValidResponseId(unsigned long response, OpenThermMessageID id) {
-    uint8_t responseId = (response >> 16) & 0xFF;
+    byte responseId = (response >> 16) & 0xFF;
 
-    return (uint8_t)id == responseId;
+    return (byte)id == responseId;
   }
 
   static uint8_t getResponseMessageTypeId(unsigned long response) {

lib/Equitherm/Equitherm.h

@@ -1,63 +0,0 @@
-#include <Arduino.h>
-
-#if defined(EQUITHERM_INTEGER)
-// расчёты с целыми числами
-typedef int datatype;
-#else
-// расчёты с float числами
-typedef float datatype;
-#endif
-
-class Equitherm {
-public:
-  datatype targetTemp = 0;
-  datatype indoorTemp = 0;
-  datatype outdoorTemp = 0;
-  float Kn = 0.0;
-  float Kk = 0.0;
-  float Kt = 0.0;
-
-  Equitherm() = default;
-
-  // kn, kk, kt
-  Equitherm(float new_kn, float new_kk, float new_kt) {
-    Kn = new_kn;
-    Kk = new_kk;
-    Kt = new_kt;
-  }
-
-  // лимит выходной величины
-  void setLimits(unsigned short min_output, unsigned short max_output) {
-    _minOut = min_output;
-    _maxOut = max_output;
-  }
-
-  // возвращает новое значение при вызове
-  datatype getResult() {
-    datatype output = getResultN() + getResultK() + getResultT();
-    output = constrain(output, _minOut, _maxOut);		// ограничиваем выход
-    return output;
-  }
-
-private:
-  unsigned short _minOut = 20, _maxOut = 90;
-
-  // температура контура отопления в зависимости от наружной температуры
-  datatype getResultN() {
-    float a = (-0.21 * Kn) - 0.06;     // a = -0,21k — 0,06
-    float b = (6.04 * Kn) + 1.98;      // b = 6,04k + 1,98
-    float c = (-5.06 * Kn) + 18.06;    // с = -5,06k + 18,06
-    float x = (-0.2 * outdoorTemp) + 5; // x = -0.2*t1 + 5
-    return (a * x * x) + (b * x) + c;       // Tn = ax2 + bx + c
-  }
-
-  // поправка на желаемую комнатную температуру
-  datatype getResultK() {
-    return (targetTemp - 20) * Kk;
-  }
-
-  // Расчет поправки (ошибки) термостата
-  datatype getResultT() {
-    return constrain((targetTemp - indoorTemp), -3, 3) * Kt;
-  }
-};

lib/HomeAssistantHelper/HomeAssistantHelper.h

@@ -147,19 +147,8 @@ public:
     return topic;
   }
 
-  template <class DT, class VT> 
-  String getEntityIdWithPrefix(DT domain, VT value, char separator = '_') {
-    String topic = "";
-    topic.concat(domain);
-    topic.concat('.');
-    topic.concat(this->devicePrefix);
-    topic.concat(separator);
-    topic.concat(value);
-    return topic;
-  }
-
   template <class T> 
-  String getUniqueIdWithPrefix(T value, char separator = '_') {
+  String getObjectIdWithPrefix(T value, char separator = '_') {
     String topic = "";
     topic.concat(this->devicePrefix);
     topic.concat(separator);

lib/HomeAssistantHelper/strings.h

@@ -12,67 +12,66 @@ const char HA_ENTITY_SELECT[]                   PROGMEM = "select";
 const char HA_ENTITY_SENSOR[]                   PROGMEM = "sensor";
 const char HA_ENTITY_SWITCH[]                   PROGMEM = "switch";
 
-// https://www.home-assistant.io/integrations/mqtt/#supported-abbreviations-in-mqtt-discovery-messages
+const char HA_DEVICE[]                          PROGMEM = "device";
-const char HA_DEFAULT_ENTITY_ID[]               PROGMEM = "def_ent_id";               // "default_entity_id "
+const char HA_IDENTIFIERS[]                     PROGMEM = "identifiers";
-const char HA_DEVICE[]                          PROGMEM = "dev";                      // "device"
+const char HA_SW_VERSION[]                      PROGMEM = "sw_version";
-const char HA_IDENTIFIERS[]                     PROGMEM = "ids";                      // "identifiers"
+const char HA_MANUFACTURER[]                    PROGMEM = "manufacturer";
-const char HA_SW_VERSION[]                      PROGMEM = "sw";                       // "sw_version"
+const char HA_MODEL[]                           PROGMEM = "model";
-const char HA_MANUFACTURER[]                    PROGMEM = "mf";                       // "manufacturer"
-const char HA_MODEL[]                           PROGMEM = "mdl";                      // "model"
 const char HA_NAME[]                            PROGMEM = "name";
-const char HA_CONF_URL[]                        PROGMEM = "cu";                       // "configuration_url"
+const char HA_CONF_URL[]                        PROGMEM = "configuration_url";
-const char HA_COMMAND_TOPIC[]                   PROGMEM = "cmd_t";                    // "command_topic"
+const char HA_COMMAND_TOPIC[]                   PROGMEM = "command_topic";
-const char HA_COMMAND_TEMPLATE[]                PROGMEM = "cmd_tpl";                  // "command_template"
+const char HA_COMMAND_TEMPLATE[]                PROGMEM = "command_template";
-const char HA_ENABLED_BY_DEFAULT[]              PROGMEM = "en";                       // "enabled_by_default"
+const char HA_ENABLED_BY_DEFAULT[]              PROGMEM = "enabled_by_default";
-const char HA_UNIQUE_ID[]                       PROGMEM = "uniq_id";                  // "unique_id"
+const char HA_UNIQUE_ID[]                       PROGMEM = "unique_id";
-const char HA_ENTITY_CATEGORY[]                 PROGMEM = "ent_cat";                  // "entity_category"
+const char HA_OBJECT_ID[]                       PROGMEM = "object_id";
+const char HA_ENTITY_CATEGORY[]                 PROGMEM = "entity_category";
 const char HA_ENTITY_CATEGORY_DIAGNOSTIC[]      PROGMEM = "diagnostic";
 const char HA_ENTITY_CATEGORY_CONFIG[]          PROGMEM = "config";
-const char HA_STATE_TOPIC[]                     PROGMEM = "stat_t";                   // "state_topic"
+const char HA_STATE_TOPIC[]                     PROGMEM = "state_topic";
-const char HA_VALUE_TEMPLATE[]                  PROGMEM = "val_tpl";                  // "value_template"
+const char HA_VALUE_TEMPLATE[]                  PROGMEM = "value_template";
-const char HA_OPTIONS[]                         PROGMEM = "ops";                      // "options"
+const char HA_OPTIONS[]                         PROGMEM = "options";
-const char HA_AVAILABILITY[]                    PROGMEM = "avty";                     // "availability"
+const char HA_AVAILABILITY[]                    PROGMEM = "availability";
-const char HA_AVAILABILITY_MODE[]               PROGMEM = "avty_mode";                // "availability_mode"
+const char HA_AVAILABILITY_MODE[]               PROGMEM = "availability_mode";
-const char HA_TOPIC[]                           PROGMEM = "t";                        // "topic"
+const char HA_TOPIC[]                           PROGMEM = "topic";
-const char HA_DEVICE_CLASS[]                    PROGMEM = "dev_cla";                  // "device_class"
+const char HA_DEVICE_CLASS[]                    PROGMEM = "device_class";
-const char HA_UNIT_OF_MEASUREMENT[]             PROGMEM = "unit_of_meas";             // "unit_of_measurement"
+const char HA_UNIT_OF_MEASUREMENT[]             PROGMEM = "unit_of_measurement";
 const char HA_UNIT_OF_MEASUREMENT_C[]           PROGMEM = "°C";
 const char HA_UNIT_OF_MEASUREMENT_F[]           PROGMEM = "°F";
 const char HA_UNIT_OF_MEASUREMENT_PERCENT[]     PROGMEM = "%";
 const char HA_UNIT_OF_MEASUREMENT_L_MIN[]       PROGMEM = "L/min";
 const char HA_UNIT_OF_MEASUREMENT_GAL_MIN[]     PROGMEM = "gal/min";
-const char HA_ICON[]                            PROGMEM = "ic";                       // "icon"
+const char HA_ICON[]                            PROGMEM = "icon";
 const char HA_MIN[]                             PROGMEM = "min";
 const char HA_MAX[]                             PROGMEM = "max";
 const char HA_STEP[]                            PROGMEM = "step";
 const char HA_MODE[]                            PROGMEM = "mode";
 const char HA_MODE_BOX[]                        PROGMEM = "box";
-const char HA_STATE_ON[]                        PROGMEM = "stat_on";                  // "state_on"
+const char HA_STATE_ON[]                        PROGMEM = "state_on";
-const char HA_STATE_OFF[]                       PROGMEM = "stat_off";                 // "state_off"
+const char HA_STATE_OFF[]                       PROGMEM = "state_off";
-const char HA_PAYLOAD_ON[]                      PROGMEM = "pl_on";                    // "payload_on"
+const char HA_PAYLOAD_ON[]                      PROGMEM = "payload_on";
-const char HA_PAYLOAD_OFF[]                     PROGMEM = "pl_off";                   // "payload_off"
+const char HA_PAYLOAD_OFF[]                     PROGMEM = "payload_off";
-const char HA_STATE_CLASS[]                     PROGMEM = "stat_cla";                 // "state_class"
+const char HA_STATE_CLASS[]                     PROGMEM = "state_class";
 const char HA_STATE_CLASS_MEASUREMENT[]         PROGMEM = "measurement";
-const char HA_EXPIRE_AFTER[]                    PROGMEM = "exp_aft";                  // "expire_after"
+const char HA_EXPIRE_AFTER[]                    PROGMEM = "expire_after";
-const char HA_CURRENT_TEMPERATURE_TOPIC[]       PROGMEM = "curr_temp_t";              // "current_temperature_topic"
+const char HA_CURRENT_TEMPERATURE_TOPIC[]       PROGMEM = "current_temperature_topic";
-const char HA_CURRENT_TEMPERATURE_TEMPLATE[]    PROGMEM = "curr_temp_tpl";            // "current_temperature_template"
+const char HA_CURRENT_TEMPERATURE_TEMPLATE[]    PROGMEM = "current_temperature_template";
-const char HA_TEMPERATURE_COMMAND_TOPIC[]       PROGMEM = "temp_cmd_t";               // "temperature_command_topic"
+const char HA_TEMPERATURE_COMMAND_TOPIC[]       PROGMEM = "temperature_command_topic";
-const char HA_TEMPERATURE_COMMAND_TEMPLATE[]    PROGMEM = "temp_cmd_tpl";             // "temperature_command_template"
+const char HA_TEMPERATURE_COMMAND_TEMPLATE[]    PROGMEM = "temperature_command_template";
-const char HA_TEMPERATURE_STATE_TOPIC[]         PROGMEM = "temp_stat_t";              // "temperature_state_topic"
+const char HA_TEMPERATURE_STATE_TOPIC[]         PROGMEM = "temperature_state_topic";
-const char HA_TEMPERATURE_STATE_TEMPLATE[]      PROGMEM = "temp_stat_tpl";            // "temperature_state_template"
+const char HA_TEMPERATURE_STATE_TEMPLATE[]      PROGMEM = "temperature_state_template";
-const char HA_TEMPERATURE_UNIT[]                PROGMEM = "temp_unit";                // "temperature_unit"
+const char HA_TEMPERATURE_UNIT[]                PROGMEM = "temperature_unit";
-const char HA_MODE_COMMAND_TOPIC[]              PROGMEM = "mode_cmd_t";               // "mode_command_topic"
+const char HA_MODE_COMMAND_TOPIC[]              PROGMEM = "mode_command_topic";
-const char HA_MODE_COMMAND_TEMPLATE[]           PROGMEM = "mode_cmd_tpl";             // "mode_command_template"
+const char HA_MODE_COMMAND_TEMPLATE[]           PROGMEM = "mode_command_template";
-const char HA_MODE_STATE_TOPIC[]                PROGMEM = "mode_stat_t";              // "mode_state_topic"
+const char HA_MODE_STATE_TOPIC[]                PROGMEM = "mode_state_topic";
-const char HA_MODE_STATE_TEMPLATE[]             PROGMEM = "mode_stat_tpl";            // "mode_state_template"
+const char HA_MODE_STATE_TEMPLATE[]             PROGMEM = "mode_state_template";
 const char HA_MODES[]                           PROGMEM = "modes";
-const char HA_ACTION_TOPIC[]                    PROGMEM = "act_t";                    // "action_topic"
+const char HA_ACTION_TOPIC[]                    PROGMEM = "action_topic";
-const char HA_ACTION_TEMPLATE[]                 PROGMEM = "act_tpl";                  // "action_template"
+const char HA_ACTION_TEMPLATE[]                 PROGMEM = "action_template";
 const char HA_MIN_TEMP[]                        PROGMEM = "min_temp";
 const char HA_MAX_TEMP[]                        PROGMEM = "max_temp";
 const char HA_TEMP_STEP[]                       PROGMEM = "temp_step";
-const char HA_PRESET_MODE_COMMAND_TOPIC[]       PROGMEM = "pr_mode_cmd_t";            // "preset_mode_command_topic"
+const char HA_PRESET_MODE_COMMAND_TOPIC[]       PROGMEM = "preset_mode_command_topic";
-const char HA_PRESET_MODE_COMMAND_TEMPLATE[]    PROGMEM = "pr_mode_cmd_tpl";          // "preset_mode_command_template"
+const char HA_PRESET_MODE_COMMAND_TEMPLATE[]    PROGMEM = "preset_mode_command_template";
-const char HA_PRESET_MODE_STATE_TOPIC[]         PROGMEM = "pr_mode_stat_t";           // "preset_mode_state_topic"
+const char HA_PRESET_MODE_STATE_TOPIC[]         PROGMEM = "preset_mode_state_topic";
-const char HA_PRESET_MODE_VALUE_TEMPLATE[]      PROGMEM = "pr_mode_val_tpl";          // "preset_mode_value_template"
+const char HA_PRESET_MODE_VALUE_TEMPLATE[]      PROGMEM = "preset_mode_value_template";
-const char HA_PRESET_MODES[]                    PROGMEM = "pr_modes";                 // "preset_modes"
+const char HA_PRESET_MODES[]                    PROGMEM = "preset_modes";

lib/NetworkUtils/NetworkMgr.h

@@ -35,7 +35,7 @@ namespace NetworkUtils {
       return this;
     }
 
-    NetworkMgr* setApCredentials(const char* ssid, const char* password = nullptr, uint8_t channel = 0) {
+    NetworkMgr* setApCredentials(const char* ssid, const char* password = nullptr, byte channel = 0) {
       this->apName = ssid;
       this->apPassword = password;
       this->apChannel = channel;
@@ -43,7 +43,7 @@ namespace NetworkUtils {
       return this;
     }
 
-    NetworkMgr* setStaCredentials(const char* ssid = nullptr, const char* password = nullptr, uint8_t channel = 0) {
+    NetworkMgr* setStaCredentials(const char* ssid = nullptr, const char* password = nullptr, byte channel = 0) {
       this->staSsid = ssid;
       this->staPassword = password;
       this->staChannel = channel;
@@ -140,7 +140,7 @@ namespace NetworkUtils {
       return this->staPassword;
     }
 
-    uint8_t getStaChannel() {
+    byte getStaChannel() {
       return this->staChannel;
     }
 
@@ -377,7 +377,7 @@ namespace NetworkUtils {
       }
     }
 
-    static uint8_t rssiToSignalQuality(short int rssi) {
+    static byte rssiToSignalQuality(short int rssi) {
       return constrain(map(rssi, -100, -50, 0, 100), 0, 100);
     }
 
@@ -397,11 +397,11 @@ namespace NetworkUtils {
     const char* hostname = "esp";
     const char* apName = "ESP";
     const char* apPassword = nullptr;
-    uint8_t apChannel = 1;
+    byte apChannel = 1;
 
     const char* staSsid = nullptr;
     const char* staPassword = nullptr;
-    uint8_t staChannel = 0;
+    byte staChannel = 0;
 
     bool useDhcp = true;
     IPAddress staticIp;

lib/WebServerHandlers/UpgradeHandler.h

@@ -1,6 +1,6 @@
 #include <Arduino.h>
 
-class UpgradeHandler : public AsyncWebHandler {
+class UpgradeHandler : public RequestHandler {
 public:
   enum class UpgradeType {
     FIRMWARE = 0,
@@ -12,7 +12,7 @@ public:
     NO_FILE,
     SUCCESS,
     PROHIBITED,
-    SIZE_MISMATCH,
+    ABORTED,
     ERROR_ON_START,
     ERROR_ON_WRITE,
     ERROR_ON_FINISH
@@ -22,21 +22,27 @@ public:
     UpgradeType type;
     UpgradeStatus status;
     String error;
-    size_t progress = 0;
-    size_t size = 0;
   } UpgradeResult;
 
-  typedef std::function<bool(AsyncWebServerRequest *request, UpgradeType)> BeforeUpgradeCallback;
+  typedef std::function<bool(HTTPMethod, const String&)> CanHandleCallback;
-  typedef std::function<void(AsyncWebServerRequest *request, const UpgradeResult&, const UpgradeResult&)> AfterUpgradeCallback;
+  typedef std::function<bool(const String&)> CanUploadCallback;
+  typedef std::function<bool(UpgradeType)> BeforeUpgradeCallback;
+  typedef std::function<void(const UpgradeResult&, const UpgradeResult&)> AfterUpgradeCallback;
   
-  UpgradeHandler(AsyncURIMatcher uri) : uri(uri) {}
+  UpgradeHandler(const char* uri) {
+    this->uri = uri;
+  }
 
-  bool canHandle(AsyncWebServerRequest *request) const override final {
+  UpgradeHandler* setCanHandleCallback(CanHandleCallback callback = nullptr) {
-    if (!request->isHTTP()) {
+    this->canHandleCallback = callback;
-      return false;
+
-    }
+    return this;
-    
+  }
-    return this->uri.matches(request);
+
+  UpgradeHandler* setCanUploadCallback(CanUploadCallback callback = nullptr) {
+    this->canUploadCallback = callback;
+
+    return this;
   }
 
   UpgradeHandler* setBeforeUpgradeCallback(BeforeUpgradeCallback callback = nullptr) {
@@ -51,9 +57,29 @@ public:
     return this;
   }
 
-  void handleRequest(AsyncWebServerRequest *request) override final {
+  #if defined(ARDUINO_ARCH_ESP32)
+  bool canHandle(WebServer &server, HTTPMethod method, const String &uri) override {
+    return this->canHandle(method, uri);
+  }
+  #endif
+
+  bool canHandle(HTTPMethod method, const String& uri) override {
+    return method == HTTP_POST && uri.equals(this->uri) && (!this->canHandleCallback || this->canHandleCallback(method, uri));
+  }
+
+  #if defined(ARDUINO_ARCH_ESP32)
+  bool canUpload(WebServer &server, const String &uri) override {
+    return this->canUpload(uri);
+  }
+  #endif
+
+  bool canUpload(const String& uri) override {
+    return uri.equals(this->uri) && (!this->canUploadCallback || this->canUploadCallback(uri));
+  }
+
+  bool handle(WebServer& server, HTTPMethod method, const String& uri) override {
     if (this->afterUpgradeCallback) {
-      this->afterUpgradeCallback(request, this->firmwareResult, this->filesystemResult);
+      this->afterUpgradeCallback(this->firmwareResult, this->filesystemResult);
     }
 
     this->firmwareResult.status = UpgradeStatus::NONE;
@@ -61,147 +87,129 @@ public:
 
     this->filesystemResult.status = UpgradeStatus::NONE;
     this->filesystemResult.error.clear();
+
+    return true;
   }
 
-  void handleUpload(AsyncWebServerRequest *request, const String &fileName, size_t index, uint8_t *data, size_t dataLength, bool isFinal) override final {
+  void upload(WebServer& server, const String& uri, HTTPUpload& upload) override {
-    UpgradeResult* result = nullptr;
+    UpgradeResult* result;
-
+    if (upload.name.equals(F("firmware"))) {
-    if (!request->hasParam(asyncsrv::T_name, true, true)) {
-      // Missing content-disposition 'name' parameter
-      return;
-    }
-
-    const auto& pName = request->getParam(asyncsrv::T_name, true, true)->value();
-    if (pName.equals("fw")) {
       result = &this->firmwareResult;
 
-      if (!index) {
+    } else if (upload.name.equals(F("filesystem"))) {
-        result->progress = 0;
-        result->size = request->hasParam("fw_size", true)
-          ? request->getParam("fw_size", true)->value().toInt()
-          : 0;
-      }
-
-    } else if (pName.equals("fs")) {
       result = &this->filesystemResult;
-
+      
-      if (!index) {
-        result->progress = 0;
-        result->size = request->hasParam("fs_size", true)
-          ? request->getParam("fs_size", true)->value().toInt()
-          : 0;
-      }
-
     } else {
-      // Unknown parameter name
       return;
     }
 
-    // check result status
     if (result->status != UpgradeStatus::NONE) {
       return;
     }
 
-    if (this->beforeUpgradeCallback && !this->beforeUpgradeCallback(request, result->type)) {
+    if (this->beforeUpgradeCallback && !this->beforeUpgradeCallback(result->type)) {
       result->status = UpgradeStatus::PROHIBITED;
       return;
     }
 
-    if (!fileName.length()) {
+    if (!upload.filename.length()) {
       result->status = UpgradeStatus::NO_FILE;
       return;
     }
 
-    if (!index) {
+    if (upload.status == UPLOAD_FILE_START) {
       // reset
       if (Update.isRunning()) {
         Update.end(false);
         Update.clearError();
       }
 
-      // try begin
       bool begin = false;
+      #ifdef ARDUINO_ARCH_ESP8266
+      Update.runAsync(true);
+      
+      if (result->type == UpgradeType::FIRMWARE) {
+        begin = Update.begin((ESP.getFreeSketchSpace() - 0x1000) & 0xFFFFF000, U_FLASH);
+        
+      } else if (result->type == UpgradeType::FILESYSTEM) {
+        close_all_fs();
+        begin = Update.begin((size_t)FS_end - (size_t)FS_start, U_FS);
+      }
+      #elif defined(ARDUINO_ARCH_ESP32)
       if (result->type == UpgradeType::FIRMWARE) {
         begin = Update.begin(UPDATE_SIZE_UNKNOWN, U_FLASH);
         
       } else if (result->type == UpgradeType::FILESYSTEM) {
         begin = Update.begin(UPDATE_SIZE_UNKNOWN, U_SPIFFS);
       }
+      #endif
 
       if (!begin || Update.hasError()) {
         result->status = UpgradeStatus::ERROR_ON_START;
+        #ifdef ARDUINO_ARCH_ESP8266
+        result->error = Update.getErrorString();
+        #else
         result->error = Update.errorString();
+        #endif
 
-        Log.serrorln(FPSTR(L_PORTAL_OTA), "File '%s', on start: %s", fileName.c_str(), result->error.c_str());
+        Log.serrorln(FPSTR(L_PORTAL_OTA), F("File '%s', on start: %s"), upload.filename.c_str(), result->error.c_str());
         return;
       }
       
-      Log.sinfoln(FPSTR(L_PORTAL_OTA), "File '%s', started", fileName.c_str());
+      Log.sinfoln(FPSTR(L_PORTAL_OTA), F("File '%s', started"), upload.filename.c_str());
-    }
+
-    
+    } else if (upload.status == UPLOAD_FILE_WRITE) {
-    if (dataLength) {
+      if (Update.write(upload.buf, upload.currentSize) != upload.currentSize) {
-      if (Update.write(data, dataLength) != dataLength) {
         Update.end(false);
+
         result->status = UpgradeStatus::ERROR_ON_WRITE;
+        #ifdef ARDUINO_ARCH_ESP8266
+        result->error = Update.getErrorString();
+        #else
         result->error = Update.errorString();
+        #endif
 
         Log.serrorln(
-          FPSTR(L_PORTAL_OTA), "File '%s', on write %d bytes, %d of %d bytes",
+          FPSTR(L_PORTAL_OTA),
-          fileName.c_str(),
+          F("File '%s', on writing %d bytes: %s"),
-          dataLength,
+          upload.filename.c_str(), upload.totalSize, result->error.c_str()
-          result->progress + dataLength,
-          result->size
         );
-        return;
-      }
-      
-      result->progress += dataLength;
-      Log.sinfoln(
-        FPSTR(L_PORTAL_OTA), "File '%s', write %d bytes, %d of %d bytes",
-        fileName.c_str(),
-        dataLength,
-        result->progress,
-        result->size
-      );
-    }
 
-    if (result->size > 0) {
+      } else {
-      if (result->progress > result->size || (isFinal && result->progress < result->size)) {
+        Log.sinfoln(FPSTR(L_PORTAL_OTA), F("File '%s', writed %d bytes"), upload.filename.c_str(), upload.totalSize);
-        Update.end(false);
-        result->status = UpgradeStatus::SIZE_MISMATCH;
-
-        Log.serrorln(
-          FPSTR(L_PORTAL_OTA), "File '%s', size mismatch: %d of %d bytes",
-          fileName.c_str(),
-          result->progress,
-          result->size
-        );
-        return;
       }
-    }
+
-    
+    } else if (upload.status == UPLOAD_FILE_END) {
-    if (isFinal) {
+      if (Update.end(true)) {
-      if (!Update.end(true)) {
+        result->status = UpgradeStatus::SUCCESS;
+
+        Log.sinfoln(FPSTR(L_PORTAL_OTA), F("File '%s': finish"), upload.filename.c_str());
+
+      } else {
         result->status = UpgradeStatus::ERROR_ON_FINISH;
+        #ifdef ARDUINO_ARCH_ESP8266
+        result->error = Update.getErrorString();
+        #else
         result->error = Update.errorString();
+        #endif
 
-        Log.serrorln(FPSTR(L_PORTAL_OTA), "File '%s', on finish: %s", fileName.c_str(), result->error);
+        Log.serrorln(FPSTR(L_PORTAL_OTA), F("File '%s', on finish: %s"), upload.filename.c_str(), result->error);
-        return;
       }
 
-      result->status = UpgradeStatus::SUCCESS;
+    } else if (upload.status == UPLOAD_FILE_ABORTED) {
-      Log.sinfoln(FPSTR(L_PORTAL_OTA), "File '%s': finish", fileName.c_str());
+      Update.end(false);
-    }
+      result->status = UpgradeStatus::ABORTED;
-  }
 
-  bool isRequestHandlerTrivial() const override final {
+      Log.serrorln(FPSTR(L_PORTAL_OTA), F("File '%s': aborted"), upload.filename.c_str());
-    return false;
+    }
   }
 
 protected:
+  CanHandleCallback canHandleCallback;
+  CanUploadCallback canUploadCallback;
   BeforeUpgradeCallback beforeUpgradeCallback;
   AfterUpgradeCallback afterUpgradeCallback;
-  AsyncURIMatcher uri;
+  const char* uri = nullptr;
 
   UpgradeResult firmwareResult{UpgradeType::FIRMWARE, UpgradeStatus::NONE};
   UpgradeResult filesystemResult{UpgradeType::FILESYSTEM, UpgradeStatus::NONE};

platformio.ini

@@ -1,275 +1,375 @@
+; PlatformIO Project Configuration File
+;
+;   Build options: build flags, source filter
+;   Upload options: custom upload port, speed and extra flags
+;   Library options: dependencies, extra library storages
+;   Advanced options: extra scripting
+;
+; Please visit documentation for the other options and examples
+; https://docs.platformio.org/page/projectconf.html
+
 [platformio]
-;extra_configs          = secrets.ini
+;extra_configs = secrets.ini
-extra_configs           = secrets.default.ini
+extra_configs = secrets.default.ini
-core_dir                = .pio
+core_dir = .pio
 
 [env]
-version                 = 1.5.7-passiveble
+version = 1.5.6
-framework               = arduino
+framework = arduino
-lib_deps                = ESP32Async/AsyncTCP
+lib_deps = 
-                          ;ESP32Async/ESPAsyncWebServer
+	bblanchon/ArduinoJson@^7.3.0
-                          https://github.com/ESP32Async/ESPAsyncWebServer
+	;ihormelnyk/OpenTherm Library@^1.1.5
-                          bblanchon/ArduinoJson@^7.4.2
+	https://github.com/Laxilef/opentherm_library#esp32_timer
-                          ;ihormelnyk/OpenTherm Library@^1.1.5
+	arduino-libraries/ArduinoMqttClient@^0.1.8
-                          https://github.com/Laxilef/opentherm_library#esp32_timer
+	lennarthennigs/ESP Telnet@^2.2
-                          arduino-libraries/ArduinoMqttClient@^0.1.8
+	gyverlibs/FileData@^1.0.2
-                          lennarthennigs/ESP Telnet@^2.2.3
+	gyverlibs/GyverPID@^3.3.2
-                          gyverlibs/FileData@^1.0.3
+	gyverlibs/GyverBlinker@^1.1.1
-                          gyverlibs/GyverPID@^3.3.2
+	https://github.com/pstolarz/Arduino-Temperature-Control-Library.git#OneWireNg
-                          gyverlibs/GyverBlinker@^1.1.1
+	laxilef/TinyLogger@^1.1.1
-                          https://github.com/pstolarz/Arduino-Temperature-Control-Library.git#OneWireNg
+build_type = ${secrets.build_type}
-                          laxilef/TinyLogger@^1.1.1
+build_flags = 
-build_type              = ${secrets.build_type}
+	-mtext-section-literals
-build_flags             = -mtext-section-literals
+	-D MQTT_CLIENT_STD_FUNCTION_CALLBACK=1
-                          -Wno-deprecated-declarations
+	;-D DEBUG_ESP_CORE -D DEBUG_ESP_WIFI -D DEBUG_ESP_HTTP_SERVER -D DEBUG_ESP_PORT=Serial
-                          -D MQTT_CLIENT_STD_FUNCTION_CALLBACK=1
+	-D BUILD_VERSION='"${this.version}"'
-                          ;-D DEBUG_ESP_CORE -D DEBUG_ESP_WIFI -D DEBUG_ESP_HTTP_SERVER -D DEBUG_ESP_PORT=Serial
+	-D BUILD_ENV='"$PIOENV"'
-                          -D BUILD_VERSION='"${this.version}"'
+	-D DEFAULT_SERIAL_ENABLED=${secrets.serial_enabled}
-                          -D BUILD_ENV='"$PIOENV"'
+	-D DEFAULT_SERIAL_BAUD=${secrets.serial_baud}
-                          -D CONFIG_ASYNC_TCP_STACK_SIZE=4096
+	-D DEFAULT_TELNET_ENABLED=${secrets.telnet_enabled}
-                          -D ARDUINOJSON_USE_DOUBLE=0
+	-D DEFAULT_TELNET_PORT=${secrets.telnet_port}
-                          -D ARDUINOJSON_USE_LONG_LONG=0
+	-D DEFAULT_LOG_LEVEL=${secrets.log_level}
-                          -D DEFAULT_SERIAL_ENABLED=${secrets.serial_enabled}
+	-D DEFAULT_HOSTNAME='"${secrets.hostname}"'
-                          -D DEFAULT_SERIAL_BAUD=${secrets.serial_baud}
+	-D DEFAULT_AP_SSID='"${secrets.ap_ssid}"'
-                          -D DEFAULT_TELNET_ENABLED=${secrets.telnet_enabled}
+	-D DEFAULT_AP_PASSWORD='"${secrets.ap_password}"'
-                          -D DEFAULT_TELNET_PORT=${secrets.telnet_port}
+	-D DEFAULT_STA_SSID='"${secrets.sta_ssid}"'
-                          -D DEFAULT_LOG_LEVEL=${secrets.log_level}
+	-D DEFAULT_STA_PASSWORD='"${secrets.sta_password}"'
-                          -D DEFAULT_HOSTNAME='"${secrets.hostname}"'
+	-D DEFAULT_PORTAL_LOGIN='"${secrets.portal_login}"'
-                          -D DEFAULT_AP_SSID='"${secrets.ap_ssid}"'
+	-D DEFAULT_PORTAL_PASSWORD='"${secrets.portal_password}"'
-                          -D DEFAULT_AP_PASSWORD='"${secrets.ap_password}"'
+	-D DEFAULT_MQTT_ENABLED=${secrets.mqtt_enabled}
-                          -D DEFAULT_STA_SSID='"${secrets.sta_ssid}"'
+	-D DEFAULT_MQTT_SERVER='"${secrets.mqtt_server}"'
-                          -D DEFAULT_STA_PASSWORD='"${secrets.sta_password}"'
+	-D DEFAULT_MQTT_PORT=${secrets.mqtt_port}
-                          -D DEFAULT_PORTAL_LOGIN='"${secrets.portal_login}"'
+	-D DEFAULT_MQTT_USER='"${secrets.mqtt_user}"'
-                          -D DEFAULT_PORTAL_PASSWORD='"${secrets.portal_password}"'
+	-D DEFAULT_MQTT_PASSWORD='"${secrets.mqtt_password}"'
-                          -D DEFAULT_MQTT_ENABLED=${secrets.mqtt_enabled}
+	-D DEFAULT_MQTT_PREFIX='"${secrets.mqtt_prefix}"'
-                          -D DEFAULT_MQTT_SERVER='"${secrets.mqtt_server}"'
+upload_speed = 921600
-                          -D DEFAULT_MQTT_PORT=${secrets.mqtt_port}
+monitor_speed = 115200
-                          -D DEFAULT_MQTT_USER='"${secrets.mqtt_user}"'
+;monitor_filters = direct
-                          -D DEFAULT_MQTT_PASSWORD='"${secrets.mqtt_password}"'
+monitor_filters = 
-                          -D DEFAULT_MQTT_PREFIX='"${secrets.mqtt_prefix}"'
+	esp32_exception_decoder
-upload_speed            = 921600
+	esp8266_exception_decoder
-monitor_speed           = 115200
+board_build.flash_mode = dio
-;monitor_filters        = direct
+board_build.filesystem = littlefs
-monitor_filters         = esp32_exception_decoder
+check_tool = ; pvs-studio
-                          esp8266_exception_decoder
+check_flags =
-board_build.flash_mode  = dio
+;  pvs-studio:
-board_build.filesystem  = littlefs
+;    --analysis-mode=4
-check_tool              = ;pvs-studio
+;    --exclude-path=./.pio/libdeps
-check_flags             = ;pvs-studio: --analysis-mode=4 --exclude-path=./.pio/libdeps
 
 ; Defaults
 [esp8266_defaults]
-platform                = espressif8266@^4.2.1
+platform = espressif8266@^4.2.1
-platform_packages       = ${env.platform_packages}
+platform_packages = ${env.platform_packages}
-lib_deps                = ${env.lib_deps}
+lib_deps = 
-                          nrwiersma/ESP8266Scheduler@^1.2
+	${env.lib_deps}
-lib_ignore              = 
+	nrwiersma/ESP8266Scheduler@^1.2
-extra_scripts           = post:tools/build.py
+lib_ignore = 
-build_type              = ${env.build_type}
+extra_scripts = 
-build_flags             = ${env.build_flags}
+	post:tools/build.py
-                          -D PIO_FRAMEWORK_ARDUINO_LWIP2_LOW_MEMORY
+build_type = ${env.build_type}
-                          ;-D PIO_FRAMEWORK_ARDUINO_LWIP2_HIGHER_BANDWIDTH_LOW_FLASH
+build_flags = 
-                          -D PIO_FRAMEWORK_ARDUINO_ESPRESSIF_SDK305
+	${env.build_flags}
-board_build.ldscript    = eagle.flash.4m1m.ld
+	-D PIO_FRAMEWORK_ARDUINO_LWIP2_LOW_MEMORY
-check_tool              = ${env.check_tool}
+	;-D PIO_FRAMEWORK_ARDUINO_LWIP2_HIGHER_BANDWIDTH_LOW_FLASH
-check_flags             = ${env.check_flags}
+	-D PIO_FRAMEWORK_ARDUINO_ESPRESSIF_SDK305
+board_build.ldscript = eagle.flash.4m1m.ld
+check_tool = ${env.check_tool}
+check_flags = ${env.check_flags}
 
 [esp32_defaults]
-platform                = https://github.com/pioarduino/platform-espressif32/releases/download/55.03.34/platform-espressif32.zip
+;platform = espressif32@^6.7
-platform_packages       = ${env.platform_packages}
+;platform = https://github.com/platformio/platform-espressif32.git
-board_build.partitions  = esp32_partitions.csv
+;platform_packages = 
-lib_deps                = ${env.lib_deps}
+;  framework-arduinoespressif32 @ https://github.com/espressif/arduino-esp32.git#3.0.5
-                          laxilef/ESP32Scheduler@^1.0.1
+;  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
-nimble_lib              = https://github.com/h2zero/NimBLE-Arduino
+platform = https://github.com/pioarduino/platform-espressif32/releases/download/55.03.30-2/platform-espressif32.zip
-lib_ignore              = BluetoothSerial
+platform_packages = ${env.platform_packages}
-                          SimpleBLE
+board_build.partitions = esp32_partitions.csv
-                          ESP RainMaker
+lib_deps =
-                          RainMaker
+	${env.lib_deps}
-                          ESP Insights
+	laxilef/ESP32Scheduler@^1.0.1
-                          Insights
+nimble_lib = h2zero/NimBLE-Arduino@^2.1.0
-                          Zigbee
+lib_ignore = 
-                          Matter
+extra_scripts = 
-                          OpenThread
+	post:tools/esp32.py
-                          dsp
+	post:tools/build.py
-custom_component_remove = espressif/esp_hosted
+build_type = ${env.build_type}
-                          espressif/esp_wifi_remote
+build_flags = 
-                          espressif/esp-dsp
+	${env.build_flags}
-                          espressif/esp_modem
+	-D CORE_DEBUG_LEVEL=0
-                          espressif/esp_rainmaker
+	-Wl,--wrap=esp_panic_handler
-                          espressif/rmaker_common
+check_tool = ${env.check_tool}
-                          espressif/esp_insights
+check_flags = ${env.check_flags}
-                          espressif/esp_diag_data_store
-                          espressif/esp_diagnostics
-                          espressif/libsodium
-                          espressif/esp-modbus
-                          espressif/esp-cbor
-                          espressif/esp-sr
-                          espressif/esp32-camera
-                          espressif/qrcode
-                          espressif/esp-zboss-lib
-                          espressif/esp-zigbee-lib
-                          chmorgan/esp-libhelix-mp3
-extra_scripts           = post:tools/esp32.py
-                          post:tools/build.py
-build_type              = ${env.build_type}
-build_flags             = ${env.build_flags}
-                          -D CORE_DEBUG_LEVEL=0
-                          -Wl,--wrap=esp_panic_handler
-check_tool              = ${env.check_tool}
-check_flags             = ${env.check_flags}
 
 
 ; Boards
 [env:d1_mini]
-extends                 = esp8266_defaults
+platform = ${esp8266_defaults.platform}
-board                   = d1_mini
+platform_packages = ${esp8266_defaults.platform_packages}
-build_flags             = ${esp8266_defaults.build_flags}
+board = d1_mini
-                          -D DEFAULT_OT_IN_GPIO=4
+lib_deps = ${esp8266_defaults.lib_deps}
-                          -D DEFAULT_OT_OUT_GPIO=5
+lib_ignore = ${esp8266_defaults.lib_ignore}
-                          -D DEFAULT_SENSOR_OUTDOOR_GPIO=12
+extra_scripts = ${esp8266_defaults.extra_scripts}
-                          -D DEFAULT_SENSOR_INDOOR_GPIO=14
+board_build.ldscript = ${esp8266_defaults.board_build.ldscript}
-                          -D DEFAULT_STATUS_LED_GPIO=13
+build_type = ${esp8266_defaults.build_type}
-                          -D DEFAULT_OT_RX_LED_GPIO=15
+build_flags = 
+	${esp8266_defaults.build_flags}
+	-D DEFAULT_OT_IN_GPIO=4
+	-D DEFAULT_OT_OUT_GPIO=5
+	-D DEFAULT_SENSOR_OUTDOOR_GPIO=12
+	-D DEFAULT_SENSOR_INDOOR_GPIO=14
+	-D DEFAULT_STATUS_LED_GPIO=13
+	-D DEFAULT_OT_RX_LED_GPIO=15
+check_tool = ${esp8266_defaults.check_tool}
+check_flags = ${esp8266_defaults.check_flags}
 
 [env:d1_mini_lite]
-extends                 = esp8266_defaults
+platform = ${esp8266_defaults.platform}
-board                   = d1_mini_lite
+platform_packages = ${esp8266_defaults.platform_packages}
-build_flags             = ${esp8266_defaults.build_flags}
+board = d1_mini_lite
-                          -D DEFAULT_OT_IN_GPIO=4
+lib_deps = ${esp8266_defaults.lib_deps}
-                          -D DEFAULT_OT_OUT_GPIO=5
+lib_ignore = ${esp8266_defaults.lib_ignore}
-                          -D DEFAULT_SENSOR_OUTDOOR_GPIO=12
+extra_scripts = ${esp8266_defaults.extra_scripts}
-                          -D DEFAULT_SENSOR_INDOOR_GPIO=14
+board_build.ldscript = ${esp8266_defaults.board_build.ldscript}
-                          -D DEFAULT_STATUS_LED_GPIO=13
+build_type = ${esp8266_defaults.build_type}
-                          -D DEFAULT_OT_RX_LED_GPIO=15
+build_flags = 
+	${esp8266_defaults.build_flags}
+	-D DEFAULT_OT_IN_GPIO=4
+	-D DEFAULT_OT_OUT_GPIO=5
+	-D DEFAULT_SENSOR_OUTDOOR_GPIO=12
+	-D DEFAULT_SENSOR_INDOOR_GPIO=14
+	-D DEFAULT_STATUS_LED_GPIO=13
+	-D DEFAULT_OT_RX_LED_GPIO=15
+check_tool = ${esp8266_defaults.check_tool}
+check_flags = ${esp8266_defaults.check_flags}
 
 [env:d1_mini_pro]
-extends                 = esp8266_defaults
+platform = ${esp8266_defaults.platform}
-board                   = d1_mini_pro
+platform_packages = ${esp8266_defaults.platform_packages}
-build_flags             = ${esp8266_defaults.build_flags}
+board = d1_mini_pro
-                          -D DEFAULT_OT_IN_GPIO=4
+lib_deps = ${esp8266_defaults.lib_deps}
-                          -D DEFAULT_OT_OUT_GPIO=5
+lib_ignore = ${esp8266_defaults.lib_ignore}
-                          -D DEFAULT_SENSOR_OUTDOOR_GPIO=12
+extra_scripts = ${esp8266_defaults.extra_scripts}
-                          -D DEFAULT_SENSOR_INDOOR_GPIO=14
+board_build.ldscript = ${esp8266_defaults.board_build.ldscript}
-                          -D DEFAULT_STATUS_LED_GPIO=13
+build_type = ${esp8266_defaults.build_type}
-                          -D DEFAULT_OT_RX_LED_GPIO=15
+build_flags = 
+	${esp8266_defaults.build_flags}
+	-D DEFAULT_OT_IN_GPIO=4
+	-D DEFAULT_OT_OUT_GPIO=5
+	-D DEFAULT_SENSOR_OUTDOOR_GPIO=12
+	-D DEFAULT_SENSOR_INDOOR_GPIO=14
+	-D DEFAULT_STATUS_LED_GPIO=13
+	-D DEFAULT_OT_RX_LED_GPIO=15
+check_tool = ${esp8266_defaults.check_tool}
+check_flags = ${esp8266_defaults.check_flags}
 
 [env:nodemcu_8266]
-extends                 = esp8266_defaults
+platform = ${esp8266_defaults.platform}
-board                   = nodemcuv2
+platform_packages = ${esp8266_defaults.platform_packages}
-build_flags             = ${esp8266_defaults.build_flags}
+board = nodemcuv2
-                          -D DEFAULT_OT_IN_GPIO=13
+lib_deps = ${esp8266_defaults.lib_deps}
-                          -D DEFAULT_OT_OUT_GPIO=15
+lib_ignore = ${esp8266_defaults.lib_ignore}
-                          -D DEFAULT_SENSOR_OUTDOOR_GPIO=12
+extra_scripts = ${esp8266_defaults.extra_scripts}
-                          -D DEFAULT_SENSOR_INDOOR_GPIO=4
+board_build.ldscript = ${esp8266_defaults.board_build.ldscript}
-                          -D DEFAULT_STATUS_LED_GPIO=2
+build_type = ${esp8266_defaults.build_type}
-                          -D DEFAULT_OT_RX_LED_GPIO=16
+build_flags = 
+	${esp8266_defaults.build_flags}
+	-D DEFAULT_OT_IN_GPIO=13
+	-D DEFAULT_OT_OUT_GPIO=15
+	-D DEFAULT_SENSOR_OUTDOOR_GPIO=12
+	-D DEFAULT_SENSOR_INDOOR_GPIO=4
+	-D DEFAULT_STATUS_LED_GPIO=2
+	-D DEFAULT_OT_RX_LED_GPIO=16
+check_tool = ${esp8266_defaults.check_tool}
+check_flags = ${esp8266_defaults.check_flags}
 
 [env:s2_mini]
-extends                 = esp32_defaults
+platform = ${esp32_defaults.platform}
-board                   = lolin_s2_mini
+platform_packages = ${esp32_defaults.platform_packages}
-build_unflags           = -DARDUINO_USB_MODE=1
+board = lolin_s2_mini
-build_flags             = ${esp32_defaults.build_flags}
+board_build.partitions = ${esp32_defaults.board_build.partitions}
-                          -D ARDUINO_USB_MODE=0
+lib_deps = ${esp32_defaults.lib_deps}
-                          -D ARDUINO_USB_CDC_ON_BOOT=1
+lib_ignore = ${esp32_defaults.lib_ignore}
-                          -D DEFAULT_OT_IN_GPIO=33
+extra_scripts = ${esp32_defaults.extra_scripts}
-                          -D DEFAULT_OT_OUT_GPIO=35
+build_unflags =
-                          -D DEFAULT_SENSOR_OUTDOOR_GPIO=9
+	-DARDUINO_USB_MODE=1
-                          -D DEFAULT_SENSOR_INDOOR_GPIO=7
+build_type = ${esp32_defaults.build_type}
-                          -D DEFAULT_STATUS_LED_GPIO=11
+build_flags = 
-                          -D DEFAULT_OT_RX_LED_GPIO=12
+	${esp32_defaults.build_flags}
+	-D ARDUINO_USB_MODE=0
+	-D ARDUINO_USB_CDC_ON_BOOT=1
+	-D DEFAULT_OT_IN_GPIO=33
+	-D DEFAULT_OT_OUT_GPIO=35
+	-D DEFAULT_SENSOR_OUTDOOR_GPIO=9
+	-D DEFAULT_SENSOR_INDOOR_GPIO=7
+	-D DEFAULT_STATUS_LED_GPIO=11
+	-D DEFAULT_OT_RX_LED_GPIO=12
+check_tool = ${esp32_defaults.check_tool}
+check_flags = ${esp32_defaults.check_flags}
 
-[env:s3_mini]
+[env:s3_mini] 
-extends                 = esp32_defaults
+platform = ${esp32_defaults.platform}
-board                   = lolin_s3_mini
+platform_packages = ${esp32_defaults.platform_packages}
-lib_deps                = ${esp32_defaults.lib_deps}
+board = lolin_s3_mini
-                          ${esp32_defaults.nimble_lib}
+board_build.partitions = ${esp32_defaults.board_build.partitions}
-build_unflags           = -DARDUINO_USB_MODE=1
+lib_deps = 
-build_flags             = ${esp32_defaults.build_flags}
+	${esp32_defaults.lib_deps}
-                          -D ARDUINO_USB_MODE=0
+	${esp32_defaults.nimble_lib}
-                          -D ARDUINO_USB_CDC_ON_BOOT=1
+lib_ignore = ${esp32_defaults.lib_ignore}
-                          -D USE_BLE=1
+extra_scripts = ${esp32_defaults.extra_scripts}
-                          -D MYNEWT_VAL_BLE_EXT_ADV=1
+build_unflags =
-                          -D DEFAULT_OT_IN_GPIO=35
+	-DARDUINO_USB_MODE=1
-                          -D DEFAULT_OT_OUT_GPIO=36
+build_type = ${esp32_defaults.build_type}
-                          -D DEFAULT_SENSOR_OUTDOOR_GPIO=13
+build_flags = 
-                          -D DEFAULT_SENSOR_INDOOR_GPIO=12
+	${esp32_defaults.build_flags}
-                          -D DEFAULT_STATUS_LED_GPIO=11
+	-D ARDUINO_USB_MODE=0
-                          -D DEFAULT_OT_RX_LED_GPIO=10
+	-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
+	-D DEFAULT_SENSOR_OUTDOOR_GPIO=13
+	-D DEFAULT_SENSOR_INDOOR_GPIO=12
+	-D DEFAULT_STATUS_LED_GPIO=11
+	-D DEFAULT_OT_RX_LED_GPIO=10
+check_tool = ${esp32_defaults.check_tool}
+check_flags = ${esp32_defaults.check_flags}
 
-[env:c3_mini]
+[env:c3_mini] 
-extends                 = esp32_defaults
+platform = ${esp32_defaults.platform}
-board                   = lolin_c3_mini
+platform_packages = ${esp32_defaults.platform_packages}
-lib_deps                = ${esp32_defaults.lib_deps}
+board = lolin_c3_mini
-                          ${esp32_defaults.nimble_lib}
+board_build.partitions = ${esp32_defaults.board_build.partitions}
-build_unflags           = -mtext-section-literals
+lib_deps = 
-build_flags             = ${esp32_defaults.build_flags}
+	${esp32_defaults.lib_deps}
-                          -D USE_BLE=1
+	${esp32_defaults.nimble_lib}
-                          -D DEFAULT_OT_IN_GPIO=8
+lib_ignore = ${esp32_defaults.lib_ignore}
-                          -D DEFAULT_OT_OUT_GPIO=10
+extra_scripts = ${esp32_defaults.extra_scripts}
-                          -D DEFAULT_SENSOR_OUTDOOR_GPIO=0
+build_unflags = 
-                          -D DEFAULT_SENSOR_INDOOR_GPIO=1
+	-mtext-section-literals
-                          -D DEFAULT_STATUS_LED_GPIO=4
+build_type = ${esp32_defaults.build_type}
-                          -D DEFAULT_OT_RX_LED_GPIO=5
+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
+	-D DEFAULT_SENSOR_OUTDOOR_GPIO=0
+	-D DEFAULT_SENSOR_INDOOR_GPIO=1
+	-D DEFAULT_STATUS_LED_GPIO=4
+	-D DEFAULT_OT_RX_LED_GPIO=5
+check_tool = ${esp32_defaults.check_tool}
+check_flags = ${esp32_defaults.check_flags}
 
 [env:nodemcu_32]
-extends                 = esp32_defaults
+platform = ${esp32_defaults.platform}
-board                   = nodemcu-32s
+platform_packages = ${esp32_defaults.platform_packages}
-lib_deps                = ${esp32_defaults.lib_deps}
+board = nodemcu-32s
-                          ${esp32_defaults.nimble_lib}
+board_build.partitions = ${esp32_defaults.board_build.partitions}
-build_flags             = ${esp32_defaults.build_flags}
+lib_deps = 
-                          -D USE_BLE=1
+	${esp32_defaults.lib_deps}
-                          -D DEFAULT_OT_IN_GPIO=16
+	${esp32_defaults.nimble_lib}
-                          -D DEFAULT_OT_OUT_GPIO=4
+lib_ignore = ${esp32_defaults.lib_ignore}
-                          -D DEFAULT_SENSOR_OUTDOOR_GPIO=15
+extra_scripts = ${esp32_defaults.extra_scripts}
-                          -D DEFAULT_SENSOR_INDOOR_GPIO=26
+build_type = ${esp32_defaults.build_type}
-                          -D DEFAULT_STATUS_LED_GPIO=2
+build_flags = 
-                          -D DEFAULT_OT_RX_LED_GPIO=19
+	${esp32_defaults.build_flags}
-
+	-D USE_BLE=1
-[env:nodemcu_32_160mhz]
+	-D DEFAULT_OT_IN_GPIO=16
-extends                 = env:nodemcu_32 
+	-D DEFAULT_OT_OUT_GPIO=4
-board_build.f_cpu       = 160000000L ; set frequency to 160MHz
+	-D DEFAULT_SENSOR_OUTDOOR_GPIO=15
+	-D DEFAULT_SENSOR_INDOOR_GPIO=26
+	-D DEFAULT_STATUS_LED_GPIO=2
+	-D DEFAULT_OT_RX_LED_GPIO=19
+check_tool = ${esp32_defaults.check_tool}
+check_flags = ${esp32_defaults.check_flags}
 
 [env:d1_mini32]
-extends                 = esp32_defaults
+platform = ${esp32_defaults.platform}
-board                   = wemos_d1_mini32
+platform_packages = ${esp32_defaults.platform_packages}
-lib_deps                = ${esp32_defaults.lib_deps}
+board = wemos_d1_mini32
-                          ${esp32_defaults.nimble_lib}
+board_build.partitions = ${esp32_defaults.board_build.partitions}
-build_flags             = ${esp32_defaults.build_flags}
+lib_deps = 
-                          -D USE_BLE=1
+	${esp32_defaults.lib_deps}
-                          -D DEFAULT_OT_IN_GPIO=21
+	${esp32_defaults.nimble_lib}
-                          -D DEFAULT_OT_OUT_GPIO=22
+lib_ignore = ${esp32_defaults.lib_ignore}
-                          -D DEFAULT_SENSOR_OUTDOOR_GPIO=12
+extra_scripts = ${esp32_defaults.extra_scripts}
-                          -D DEFAULT_SENSOR_INDOOR_GPIO=18
+build_type = ${esp32_defaults.build_type}
-                          -D DEFAULT_STATUS_LED_GPIO=2
+build_flags = 
-                          -D DEFAULT_OT_RX_LED_GPIO=19
+	${esp32_defaults.build_flags}
+	-D USE_BLE=1
+	-D DEFAULT_OT_IN_GPIO=21
+	-D DEFAULT_OT_OUT_GPIO=22
+	-D DEFAULT_SENSOR_OUTDOOR_GPIO=12
+	-D DEFAULT_SENSOR_INDOOR_GPIO=18
+	-D DEFAULT_STATUS_LED_GPIO=2
+	-D DEFAULT_OT_RX_LED_GPIO=19
+check_tool = ${esp32_defaults.check_tool}
+check_flags = ${esp32_defaults.check_flags}
 
 [env:esp32_c6]
-extends                 = esp32_defaults
+platform = ${esp32_defaults.platform}
-board                   = esp32-c6-devkitc-1
+framework = arduino, espidf
-lib_deps                = ${esp32_defaults.lib_deps}
+platform_packages = ${esp32_defaults.platform_packages}
-                          ${esp32_defaults.nimble_lib}
+board = esp32-c6-devkitm-1
-build_unflags           = -mtext-section-literals
+board_build.partitions = ${esp32_defaults.board_build.partitions}
-build_flags             = ${esp32_defaults.build_flags}
+board_build.embed_txtfiles = 
-                          -D USE_BLE=1
+	managed_components/espressif__esp_insights/server_certs/https_server.crt
-                          -D DEFAULT_OT_IN_GPIO=15
+	managed_components/espressif__esp_rainmaker/server_certs/rmaker_mqtt_server.crt
-                          -D DEFAULT_OT_OUT_GPIO=23
+	managed_components/espressif__esp_rainmaker/server_certs/rmaker_claim_service_server.crt
-                          -D DEFAULT_SENSOR_OUTDOOR_GPIO=0
+	managed_components/espressif__esp_rainmaker/server_certs/rmaker_ota_server.crt
-                          -D DEFAULT_SENSOR_INDOOR_GPIO=0
+lib_deps = ${esp32_defaults.lib_deps}
-                          -D DEFAULT_STATUS_LED_GPIO=11
+lib_ignore = 
-                          -D DEFAULT_OT_RX_LED_GPIO=10
+	${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
+check_tool = ${esp32_defaults.check_tool}
+check_flags = ${esp32_defaults.check_flags}
 
-[env:otthing]
+[env:otthing] 
-extends                 = esp32_defaults
+platform = ${esp32_defaults.platform}
-board                   = lolin_c3_mini
+platform_packages = ${esp32_defaults.platform_packages}
-lib_deps                = ${esp32_defaults.lib_deps}
+board = lolin_c3_mini
-                          ${esp32_defaults.nimble_lib}
+board_build.partitions = ${esp32_defaults.board_build.partitions}
-build_unflags           = -mtext-section-literals
+lib_deps = 
-build_flags             = ${esp32_defaults.build_flags}
+	${esp32_defaults.lib_deps}
-                          -D USE_BLE=1
+	${esp32_defaults.nimble_lib}
-                          -D DEFAULT_OT_IN_GPIO=3
+lib_ignore = ${esp32_defaults.lib_ignore}
-                          -D DEFAULT_OT_OUT_GPIO=1
+extra_scripts = ${esp32_defaults.extra_scripts}
-                          ;-D DEFAULT_SENSOR_OUTDOOR_GPIO=0
+build_unflags = 
-                          ;-D DEFAULT_SENSOR_INDOOR_GPIO=1
+	-mtext-section-literals
-                          -D DEFAULT_STATUS_LED_GPIO=8
+build_type = ${esp32_defaults.build_type}
-                          -D DEFAULT_OT_RX_LED_GPIO=2
+build_flags = 
-                          -D OT_BYPASS_RELAY_GPIO=20
+	${esp32_defaults.build_flags}
+	-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
+check_tool = ${esp32_defaults.check_tool}
+check_flags = ${esp32_defaults.check_flags}

src/HaHelper.h

@@ -3,8 +3,8 @@
 
 class HaHelper : public HomeAssistantHelper {
 public:
-  static const uint8_t TEMP_SOURCE_HEATING = 0;
+  static const byte TEMP_SOURCE_HEATING = 0;
-  static const uint8_t TEMP_SOURCE_INDOOR = 1;
+  static const byte TEMP_SOURCE_INDOOR = 1;
   static const char AVAILABILITY_OT_CONN[];
   static const char AVAILABILITY_SENSOR_CONN[];
 
@@ -261,13 +261,8 @@ public:
     }
 
     // object id's
-    doc[FPSTR(HA_UNIQUE_ID)] = this->getUniqueIdWithPrefix(objId.c_str());
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectIdWithPrefix(objId.c_str());
-    doc[FPSTR(HA_DEFAULT_ENTITY_ID)] = this->getEntityIdWithPrefix(
+    doc[FPSTR(HA_OBJECT_ID)] = doc[FPSTR(HA_UNIQUE_ID)];
-      sSensor.type == Sensors::Type::MANUAL 
-        ? FPSTR(HA_ENTITY_NUMBER) 
-        : FPSTR(HA_ENTITY_SENSOR),
-      objId.c_str()
-    );
 
     const String& configTopic = this->makeConfigTopic(
       sSensor.type == Sensors::Type::MANUAL ? FPSTR(HA_ENTITY_NUMBER) : FPSTR(HA_ENTITY_SENSOR),
@@ -328,8 +323,8 @@ public:
     String objId = Sensors::makeObjectIdWithSuffix(sSensor.name, F("connected"));
 
     // object id's
-    doc[FPSTR(HA_UNIQUE_ID)] = this->getUniqueIdWithPrefix(objId.c_str());
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectIdWithPrefix(objId.c_str());
-    doc[FPSTR(HA_DEFAULT_ENTITY_ID)] = this->getEntityIdWithPrefix(FPSTR(HA_ENTITY_BINARY_SENSOR), objId.c_str());
+    doc[FPSTR(HA_OBJECT_ID)] = doc[FPSTR(HA_UNIQUE_ID)];
 
     // state topic
     doc[FPSTR(HA_STATE_TOPIC)] = this->getDeviceTopic(
@@ -375,8 +370,8 @@ public:
     String objId = Sensors::makeObjectIdWithSuffix(sSensor.name, F("signal_quality"));
 
     // object id's
-    doc[FPSTR(HA_UNIQUE_ID)] = this->getUniqueIdWithPrefix(objId.c_str());
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectIdWithPrefix(objId.c_str());
-    doc[FPSTR(HA_DEFAULT_ENTITY_ID)] = this->getEntityIdWithPrefix(FPSTR(HA_ENTITY_SENSOR), objId.c_str());
+    doc[FPSTR(HA_OBJECT_ID)] = doc[FPSTR(HA_UNIQUE_ID)];
 
     // state topic
     doc[FPSTR(HA_STATE_TOPIC)] = this->getDeviceTopic(
@@ -412,6 +407,7 @@ public:
   }
 
   bool deleteSignalQualityDynamicSensor(Sensors::Settings& sSensor) {
+    JsonDocument doc;
     const String& configTopic = this->makeConfigTopic(
       FPSTR(HA_ENTITY_SENSOR),
       Sensors::makeObjectIdWithSuffix(sSensor.name, F("signal_quality")).c_str()
@@ -425,8 +421,8 @@ public:
     JsonDocument doc;
     doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->statusTopic.c_str();
     doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
-    doc[FPSTR(HA_UNIQUE_ID)] = this->getUniqueIdWithPrefix(F("heating_turbo"));
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectIdWithPrefix(F("heating_turbo"));
-    doc[FPSTR(HA_DEFAULT_ENTITY_ID)] = this->getEntityIdWithPrefix(FPSTR(HA_ENTITY_SWITCH), F("heating_turbo"));
+    doc[FPSTR(HA_OBJECT_ID)] = doc[FPSTR(HA_UNIQUE_ID)];
     doc[FPSTR(HA_ENTITY_CATEGORY)] = FPSTR(HA_ENTITY_CATEGORY_CONFIG);
     doc[FPSTR(HA_NAME)] = F("Turbo heating");
     doc[FPSTR(HA_ICON)] = F("mdi:rocket-launch-outline");
@@ -447,8 +443,8 @@ public:
     JsonDocument doc;
     doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->statusTopic.c_str();
     doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
-    doc[FPSTR(HA_UNIQUE_ID)] = this->getUniqueIdWithPrefix(F("heating_hysteresis"));
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectIdWithPrefix(F("heating_hysteresis"));
-    doc[FPSTR(HA_DEFAULT_ENTITY_ID)] = this->getEntityIdWithPrefix(FPSTR(HA_ENTITY_NUMBER), F("heating_hysteresis"));
+    doc[FPSTR(HA_OBJECT_ID)] = doc[FPSTR(HA_UNIQUE_ID)];
     doc[FPSTR(HA_ENTITY_CATEGORY)] = FPSTR(HA_ENTITY_CATEGORY_CONFIG);
     doc[FPSTR(HA_DEVICE_CLASS)] = FPSTR(S_TEMPERATURE);
 
@@ -479,8 +475,8 @@ public:
     JsonDocument doc;
     doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->statusTopic.c_str();
     doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
-    doc[FPSTR(HA_UNIQUE_ID)] = this->getUniqueIdWithPrefix(F("heating_turbo_factor"));
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectIdWithPrefix(F("heating_turbo_factor"));
-    doc[FPSTR(HA_DEFAULT_ENTITY_ID)] = this->getEntityIdWithPrefix(FPSTR(HA_ENTITY_NUMBER), F("heating_turbo_factor"));
+    doc[FPSTR(HA_OBJECT_ID)] = doc[FPSTR(HA_UNIQUE_ID)];
     doc[FPSTR(HA_ENTITY_CATEGORY)] = FPSTR(HA_ENTITY_CATEGORY_CONFIG);
     doc[FPSTR(HA_DEVICE_CLASS)] = F("power_factor");
     doc[FPSTR(HA_NAME)] = F("Heating turbo factor");
@@ -503,8 +499,8 @@ public:
     JsonDocument doc;
     doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->statusTopic.c_str();
     doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
-    doc[FPSTR(HA_UNIQUE_ID)] = this->getUniqueIdWithPrefix(F("heating_min_temp"));
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectIdWithPrefix(F("heating_min_temp"));
-    doc[FPSTR(HA_DEFAULT_ENTITY_ID)] = this->getEntityIdWithPrefix(FPSTR(HA_ENTITY_NUMBER), F("heating_min_temp"));
+    doc[FPSTR(HA_OBJECT_ID)] = doc[FPSTR(HA_UNIQUE_ID)];
     doc[FPSTR(HA_ENTITY_CATEGORY)] = FPSTR(HA_ENTITY_CATEGORY_CONFIG);
     doc[FPSTR(HA_DEVICE_CLASS)] = FPSTR(S_TEMPERATURE);
 
@@ -537,8 +533,8 @@ public:
     JsonDocument doc;
     doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->statusTopic.c_str();
     doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
-    doc[FPSTR(HA_UNIQUE_ID)] = this->getUniqueIdWithPrefix(F("heating_max_temp"));
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectIdWithPrefix(F("heating_max_temp"));
-    doc[FPSTR(HA_DEFAULT_ENTITY_ID)] = this->getEntityIdWithPrefix(FPSTR(HA_ENTITY_NUMBER), F("heating_max_temp"));
+    doc[FPSTR(HA_OBJECT_ID)] = doc[FPSTR(HA_UNIQUE_ID)];
     doc[FPSTR(HA_ENTITY_CATEGORY)] = FPSTR(HA_ENTITY_CATEGORY_CONFIG);
     doc[FPSTR(HA_DEVICE_CLASS)] = FPSTR(S_TEMPERATURE);
 
@@ -572,8 +568,8 @@ public:
     JsonDocument doc;
     doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->statusTopic.c_str();
     doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
-    doc[FPSTR(HA_UNIQUE_ID)] = this->getUniqueIdWithPrefix(F("dhw_min_temp"));
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectIdWithPrefix(F("dhw_min_temp"));
-    doc[FPSTR(HA_DEFAULT_ENTITY_ID)] = this->getEntityIdWithPrefix(FPSTR(HA_ENTITY_NUMBER), F("dhw_min_temp"));
+    doc[FPSTR(HA_OBJECT_ID)] = doc[FPSTR(HA_UNIQUE_ID)];
     doc[FPSTR(HA_ENTITY_CATEGORY)] = FPSTR(HA_ENTITY_CATEGORY_CONFIG);
     doc[FPSTR(HA_DEVICE_CLASS)] = FPSTR(S_TEMPERATURE);
 
@@ -606,8 +602,8 @@ public:
     JsonDocument doc;
     doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->statusTopic.c_str();
     doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
-    doc[FPSTR(HA_UNIQUE_ID)] = this->getUniqueIdWithPrefix(F("dhw_max_temp"));
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectIdWithPrefix(F("dhw_max_temp"));
-    doc[FPSTR(HA_DEFAULT_ENTITY_ID)] = this->getEntityIdWithPrefix(FPSTR(HA_ENTITY_NUMBER), F("dhw_max_temp"));
+    doc[FPSTR(HA_OBJECT_ID)] = doc[FPSTR(HA_UNIQUE_ID)];
     doc[FPSTR(HA_ENTITY_CATEGORY)] = FPSTR(HA_ENTITY_CATEGORY_CONFIG);
     doc[FPSTR(HA_DEVICE_CLASS)] = FPSTR(S_TEMPERATURE);
 
@@ -641,8 +637,8 @@ public:
     JsonDocument doc;
     doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->statusTopic.c_str();
     doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
-    doc[FPSTR(HA_UNIQUE_ID)] = this->getUniqueIdWithPrefix(F("pid"));
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectIdWithPrefix(F("pid"));
-    doc[FPSTR(HA_DEFAULT_ENTITY_ID)] = this->getEntityIdWithPrefix(FPSTR(HA_ENTITY_SWITCH), F("pid"));
+    doc[FPSTR(HA_OBJECT_ID)] = doc[FPSTR(HA_UNIQUE_ID)];
     doc[FPSTR(HA_ENTITY_CATEGORY)] = FPSTR(HA_ENTITY_CATEGORY_CONFIG);
     doc[FPSTR(HA_NAME)] = F("PID");
     doc[FPSTR(HA_ICON)] = F("mdi:chart-bar-stacked");
@@ -663,8 +659,8 @@ public:
     JsonDocument doc;
     doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->statusTopic.c_str();
     doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
-    doc[FPSTR(HA_UNIQUE_ID)] = this->getUniqueIdWithPrefix(F("pid_p"));
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectIdWithPrefix(F("pid_p"));
-    doc[FPSTR(HA_DEFAULT_ENTITY_ID)] = this->getEntityIdWithPrefix(FPSTR(HA_ENTITY_NUMBER), F("pid_p"));
+    doc[FPSTR(HA_OBJECT_ID)] = doc[FPSTR(HA_UNIQUE_ID)];
     doc[FPSTR(HA_ENTITY_CATEGORY)] = FPSTR(HA_ENTITY_CATEGORY_CONFIG);
     doc[FPSTR(HA_NAME)] = F("PID factor P");
     doc[FPSTR(HA_ICON)] = F("mdi:alpha-p-circle-outline");
@@ -686,8 +682,8 @@ public:
     JsonDocument doc;
     doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->statusTopic.c_str();
     doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
-    doc[FPSTR(HA_UNIQUE_ID)] = this->getUniqueIdWithPrefix(F("pid_i"));
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectIdWithPrefix(F("pid_i"));
-    doc[FPSTR(HA_DEFAULT_ENTITY_ID)] = this->getEntityIdWithPrefix(FPSTR(HA_ENTITY_NUMBER), F("pid_i"));
+    doc[FPSTR(HA_OBJECT_ID)] = doc[FPSTR(HA_UNIQUE_ID)];
     doc[FPSTR(HA_ENTITY_CATEGORY)] = FPSTR(HA_ENTITY_CATEGORY_CONFIG);
     doc[FPSTR(HA_NAME)] = F("PID factor I");
     doc[FPSTR(HA_ICON)] = F("mdi:alpha-i-circle-outline");
@@ -709,8 +705,8 @@ public:
     JsonDocument doc;
     doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->statusTopic.c_str();
     doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
-    doc[FPSTR(HA_UNIQUE_ID)] = this->getUniqueIdWithPrefix(F("pid_d"));
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectIdWithPrefix(F("pid_d"));
-    doc[FPSTR(HA_DEFAULT_ENTITY_ID)] = this->getEntityIdWithPrefix(FPSTR(HA_ENTITY_NUMBER), F("pid_d"));
+    doc[FPSTR(HA_OBJECT_ID)] = doc[FPSTR(HA_UNIQUE_ID)];
     doc[FPSTR(HA_ENTITY_CATEGORY)] = FPSTR(HA_ENTITY_CATEGORY_CONFIG);
     doc[FPSTR(HA_NAME)] = F("PID factor D");
     doc[FPSTR(HA_ICON)] = F("mdi:alpha-d-circle-outline");
@@ -732,8 +728,8 @@ public:
     JsonDocument doc;
     doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->statusTopic.c_str();
     doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
-    doc[FPSTR(HA_UNIQUE_ID)] = this->getUniqueIdWithPrefix(F("pid_dt"));
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectIdWithPrefix(F("pid_dt"));
-    doc[FPSTR(HA_DEFAULT_ENTITY_ID)] = this->getEntityIdWithPrefix(FPSTR(HA_ENTITY_NUMBER), F("pid_dt"));
+    doc[FPSTR(HA_OBJECT_ID)] = doc[FPSTR(HA_UNIQUE_ID)];
     doc[FPSTR(HA_ENTITY_CATEGORY)] = FPSTR(HA_ENTITY_CATEGORY_CONFIG);
     doc[FPSTR(HA_DEVICE_CLASS)] = F("duration");
     doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = F("s");
@@ -757,8 +753,8 @@ public:
     JsonDocument doc;
     doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->statusTopic.c_str();
     doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
-    doc[FPSTR(HA_UNIQUE_ID)] = this->getUniqueIdWithPrefix(F("pid_min_temp"));
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectIdWithPrefix(F("pid_min_temp"));
-    doc[FPSTR(HA_DEFAULT_ENTITY_ID)] = this->getEntityIdWithPrefix(FPSTR(HA_ENTITY_NUMBER), F("pid_min_temp"));
+    doc[FPSTR(HA_OBJECT_ID)] = doc[FPSTR(HA_UNIQUE_ID)];
     doc[FPSTR(HA_ENTITY_CATEGORY)] = FPSTR(HA_ENTITY_CATEGORY_CONFIG);
     doc[FPSTR(HA_DEVICE_CLASS)] = FPSTR(S_TEMPERATURE);
 
@@ -791,8 +787,8 @@ public:
     JsonDocument doc;
     doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->statusTopic.c_str();
     doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
-    doc[FPSTR(HA_UNIQUE_ID)] = this->getUniqueIdWithPrefix(F("pid_max_temp"));
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectIdWithPrefix(F("pid_max_temp"));
-    doc[FPSTR(HA_DEFAULT_ENTITY_ID)] = this->getEntityIdWithPrefix(FPSTR(HA_ENTITY_NUMBER), F("pid_max_temp"));
+    doc[FPSTR(HA_OBJECT_ID)] = doc[FPSTR(HA_UNIQUE_ID)];
     doc[FPSTR(HA_ENTITY_CATEGORY)] = FPSTR(HA_ENTITY_CATEGORY_CONFIG);
     doc[FPSTR(HA_DEVICE_CLASS)] = FPSTR(S_TEMPERATURE);
 
@@ -826,8 +822,8 @@ public:
     JsonDocument doc;
     doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->statusTopic.c_str();
     doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
-    doc[FPSTR(HA_UNIQUE_ID)] = this->getUniqueIdWithPrefix(F("equitherm"));
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectIdWithPrefix(F("equitherm"));
-    doc[FPSTR(HA_DEFAULT_ENTITY_ID)] = this->getEntityIdWithPrefix(FPSTR(HA_ENTITY_SWITCH), F("equitherm"));
+    doc[FPSTR(HA_OBJECT_ID)] = doc[FPSTR(HA_UNIQUE_ID)];
     doc[FPSTR(HA_ENTITY_CATEGORY)] = FPSTR(HA_ENTITY_CATEGORY_CONFIG);
     doc[FPSTR(HA_NAME)] = F("Equitherm");
     doc[FPSTR(HA_ICON)] = F("mdi:sun-snowflake-variant");
@@ -844,19 +840,19 @@ public:
     return this->publish(this->makeConfigTopic(FPSTR(HA_ENTITY_SWITCH), F("equitherm")).c_str(), doc);
   }
 
-  bool publishInputEquithermFactorN(bool enabledByDefault = true) {
+  bool publishInputEquithermSlope(bool enabledByDefault = true) {
     JsonDocument doc;
     doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->statusTopic.c_str();
     doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
-    doc[FPSTR(HA_UNIQUE_ID)] = this->getUniqueIdWithPrefix(F("equitherm_n"));
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectIdWithPrefix(F("equitherm_slope"));
-    doc[FPSTR(HA_DEFAULT_ENTITY_ID)] = this->getEntityIdWithPrefix(FPSTR(HA_ENTITY_NUMBER), F("equitherm_n"));
+    doc[FPSTR(HA_OBJECT_ID)] = doc[FPSTR(HA_UNIQUE_ID)];
     doc[FPSTR(HA_ENTITY_CATEGORY)] = FPSTR(HA_ENTITY_CATEGORY_CONFIG);
-    doc[FPSTR(HA_NAME)] = F("Equitherm factor N");
+    doc[FPSTR(HA_NAME)] = F("Equitherm slope");
-    doc[FPSTR(HA_ICON)] = F("mdi:alpha-n-circle-outline");
+    doc[FPSTR(HA_ICON)] = F("mdi:slope-uphill");
     doc[FPSTR(HA_STATE_TOPIC)] = this->settingsTopic.c_str();
-    doc[FPSTR(HA_VALUE_TEMPLATE)] = F("{{ value_json.equitherm.n_factor|float(0)|round(3) }}");
+    doc[FPSTR(HA_VALUE_TEMPLATE)] = F("{{ value_json.equitherm.slope|float(0)|round(3) }}");
     doc[FPSTR(HA_COMMAND_TOPIC)] = this->setSettingsTopic.c_str();
-    doc[FPSTR(HA_COMMAND_TEMPLATE)] = F("{\"equitherm\": {\"n_factor\" : {{ value }}}}");
+    doc[FPSTR(HA_COMMAND_TEMPLATE)] = F("{\"equitherm\": {\"slope\" : {{ value }}}}");
     doc[FPSTR(HA_MIN)] = 0.001f;
     doc[FPSTR(HA_MAX)] = 10;
     doc[FPSTR(HA_STEP)] = 0.001f;
@@ -864,64 +860,88 @@ public:
     doc[FPSTR(HA_EXPIRE_AFTER)] = this->expireAfter;
     doc.shrinkToFit();
 
-    return this->publish(this->makeConfigTopic(FPSTR(HA_ENTITY_NUMBER), F("equitherm_n_factor")).c_str(), doc);
+    return this->publish(this->makeConfigTopic(FPSTR(HA_ENTITY_NUMBER), F("equitherm_slope")).c_str(), doc);
   }
 
-  bool publishInputEquithermFactorK(bool enabledByDefault = true) {
+  bool publishInputEquithermExponent(bool enabledByDefault = true) {
     JsonDocument doc;
     doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->statusTopic.c_str();
     doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
-    doc[FPSTR(HA_UNIQUE_ID)] = this->getUniqueIdWithPrefix(F("equitherm_k"));
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectIdWithPrefix(F("equitherm_exponent"));
-    doc[FPSTR(HA_DEFAULT_ENTITY_ID)] = this->getEntityIdWithPrefix(FPSTR(HA_ENTITY_NUMBER), F("equitherm_k"));
+    doc[FPSTR(HA_OBJECT_ID)] = doc[FPSTR(HA_UNIQUE_ID)];
     doc[FPSTR(HA_ENTITY_CATEGORY)] = FPSTR(HA_ENTITY_CATEGORY_CONFIG);
-    doc[FPSTR(HA_NAME)] = F("Equitherm factor K");
+    doc[FPSTR(HA_NAME)] = F("Equitherm exponent");
-    doc[FPSTR(HA_ICON)] = F("mdi:alpha-k-circle-outline");
+    doc[FPSTR(HA_ICON)] = F("mdi:exponent");
     doc[FPSTR(HA_STATE_TOPIC)] = this->settingsTopic.c_str();
-    doc[FPSTR(HA_VALUE_TEMPLATE)] = F("{{ value_json.equitherm.k_factor|float(0)|round(2) }}");
+    doc[FPSTR(HA_VALUE_TEMPLATE)] = F("{{ value_json.equitherm.exponent|float(0)|round(3) }}");
     doc[FPSTR(HA_COMMAND_TOPIC)] = this->setSettingsTopic.c_str();
-    doc[FPSTR(HA_COMMAND_TEMPLATE)] = F("{\"equitherm\": {\"k_factor\" : {{ value }}}}");
+    doc[FPSTR(HA_COMMAND_TEMPLATE)] = F("{\"equitherm\": {\"exponent\" : {{ value }}}}");
-    doc[FPSTR(HA_MIN)] = 0;
+    doc[FPSTR(HA_MIN)] = 0.1;
-    doc[FPSTR(HA_MAX)] = 10;
+    doc[FPSTR(HA_MAX)] = 2;
+    doc[FPSTR(HA_STEP)] = 0.001f;
+    doc[FPSTR(HA_MODE)] = FPSTR(HA_MODE_BOX);
+    doc[FPSTR(HA_EXPIRE_AFTER)] = this->expireAfter;
+    doc.shrinkToFit();
+
+    return this->publish(this->makeConfigTopic(FPSTR(HA_ENTITY_NUMBER), F("equitherm_exponent")).c_str(), doc);
+  }
+
+  bool publishInputEquithermShift(bool enabledByDefault = true) {
+    JsonDocument doc;
+    doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->statusTopic.c_str();
+    doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectIdWithPrefix(F("equitherm_shift"));
+    doc[FPSTR(HA_OBJECT_ID)] = doc[FPSTR(HA_UNIQUE_ID)];
+    doc[FPSTR(HA_ENTITY_CATEGORY)] = FPSTR(HA_ENTITY_CATEGORY_CONFIG);
+    doc[FPSTR(HA_DEVICE_CLASS)] = FPSTR(S_TEMPERATURE);
+    doc[FPSTR(HA_NAME)] = F("Equitherm shift");
+    doc[FPSTR(HA_ICON)] = F("mdi:chart-areaspline");
+    doc[FPSTR(HA_STATE_TOPIC)] = this->settingsTopic.c_str();
+    doc[FPSTR(HA_VALUE_TEMPLATE)] = F("{{ value_json.equitherm.shift|float(0)|round(2) }}");
+    doc[FPSTR(HA_COMMAND_TOPIC)] = this->setSettingsTopic.c_str();
+    doc[FPSTR(HA_COMMAND_TEMPLATE)] = F("{\"equitherm\": {\"shift\" : {{ value }}}}");
+    doc[FPSTR(HA_MIN)] = -15;
+    doc[FPSTR(HA_MAX)] = 15;
     doc[FPSTR(HA_STEP)] = 0.01f;
     doc[FPSTR(HA_MODE)] = FPSTR(HA_MODE_BOX);
     doc[FPSTR(HA_EXPIRE_AFTER)] = this->expireAfter;
     doc.shrinkToFit();
 
-    return this->publish(this->makeConfigTopic(FPSTR(HA_ENTITY_NUMBER), F("equitherm_k_factor")).c_str(), doc);
+    return this->publish(this->makeConfigTopic(FPSTR(HA_ENTITY_NUMBER), F("equitherm_shift")).c_str(), doc);
   }
 
-  bool publishInputEquithermFactorT(bool enabledByDefault = true) {
+  bool publishInputEquithermTargetDiffFactor(bool enabledByDefault = true) {
     JsonDocument doc;
     doc[FPSTR(HA_AVAILABILITY)][0][FPSTR(HA_TOPIC)] = this->statusTopic.c_str();
     doc[FPSTR(HA_AVAILABILITY)][1][FPSTR(HA_TOPIC)] = this->settingsTopic.c_str();
     doc[FPSTR(HA_AVAILABILITY)][1][FPSTR(HA_VALUE_TEMPLATE)] = F("{{ iif(value_json.pid.enabled, 'offline', 'online') }}");
     doc[FPSTR(HA_AVAILABILITY_MODE)] = F("all");
     doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
-    doc[FPSTR(HA_UNIQUE_ID)] = this->getUniqueIdWithPrefix(F("equitherm_t"));
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectIdWithPrefix(F("equitherm_target_diff_factor"));
-    doc[FPSTR(HA_DEFAULT_ENTITY_ID)] = this->getEntityIdWithPrefix(FPSTR(HA_ENTITY_NUMBER), F("equitherm_t"));
+    doc[FPSTR(HA_OBJECT_ID)] = doc[FPSTR(HA_UNIQUE_ID)];
     doc[FPSTR(HA_ENTITY_CATEGORY)] = FPSTR(HA_ENTITY_CATEGORY_CONFIG);
-    doc[FPSTR(HA_NAME)] = F("Equitherm factor T");
+    doc[FPSTR(HA_NAME)] = F("Equitherm target diff factor");
-    doc[FPSTR(HA_ICON)] = F("mdi:alpha-t-circle-outline");
+    doc[FPSTR(HA_ICON)] = F("mdi:chart-timeline-variant-shimmer");
     doc[FPSTR(HA_STATE_TOPIC)] = this->settingsTopic.c_str();
-    doc[FPSTR(HA_VALUE_TEMPLATE)] = F("{{ value_json.equitherm.t_factor|float(0)|round(2) }}");
+    doc[FPSTR(HA_VALUE_TEMPLATE)] = F("{{ value_json.equitherm.targetDiffFactor|float(0)|round(3) }}");
     doc[FPSTR(HA_COMMAND_TOPIC)] = this->setSettingsTopic.c_str();
-    doc[FPSTR(HA_COMMAND_TEMPLATE)] = F("{\"equitherm\": {\"t_factor\" : {{ value }}}}");
+    doc[FPSTR(HA_COMMAND_TEMPLATE)] = F("{\"equitherm\": {\"targetDiffFactor\" : {{ value }}}}");
     doc[FPSTR(HA_MIN)] = 0;
     doc[FPSTR(HA_MAX)] = 10;
-    doc[FPSTR(HA_STEP)] = 0.01f;
+    doc[FPSTR(HA_STEP)] = 0.001f;
     doc[FPSTR(HA_MODE)] = FPSTR(HA_MODE_BOX);
     doc[FPSTR(HA_EXPIRE_AFTER)] = this->expireAfter;
     doc.shrinkToFit();
 
-    return this->publish(this->makeConfigTopic(FPSTR(HA_ENTITY_NUMBER), F("equitherm_t_factor")).c_str(), doc);
+    return this->publish(this->makeConfigTopic(FPSTR(HA_ENTITY_NUMBER), F("equitherm_target_diff_factor")).c_str(), doc);
   }
 
 
   bool publishStatusState(bool enabledByDefault = true) {
     JsonDocument doc;
     doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
-    doc[FPSTR(HA_UNIQUE_ID)] = this->getUniqueIdWithPrefix(F("status"));
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectIdWithPrefix(F("status"));
-    doc[FPSTR(HA_DEFAULT_ENTITY_ID)] = this->getEntityIdWithPrefix(FPSTR(HA_ENTITY_BINARY_SENSOR), F("status"));
+    doc[FPSTR(HA_OBJECT_ID)] = doc[FPSTR(HA_UNIQUE_ID)];
     doc[FPSTR(HA_ENTITY_CATEGORY)] = FPSTR(HA_ENTITY_CATEGORY_DIAGNOSTIC);
     doc[FPSTR(HA_DEVICE_CLASS)] = F("problem");
     doc[FPSTR(HA_NAME)] = F("Status");
@@ -938,8 +958,8 @@ public:
     JsonDocument doc;
     doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->statusTopic.c_str();
     doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
-    doc[FPSTR(HA_UNIQUE_ID)] = this->getUniqueIdWithPrefix(F("emergency"));
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectIdWithPrefix(F("emergency"));
-    doc[FPSTR(HA_DEFAULT_ENTITY_ID)] = this->getEntityIdWithPrefix(FPSTR(HA_ENTITY_BINARY_SENSOR), F("emergency"));
+    doc[FPSTR(HA_OBJECT_ID)] = doc[FPSTR(HA_UNIQUE_ID)];
     doc[FPSTR(HA_ENTITY_CATEGORY)] = FPSTR(HA_ENTITY_CATEGORY_DIAGNOSTIC);
     doc[FPSTR(HA_DEVICE_CLASS)] = F("problem");
     doc[FPSTR(HA_NAME)] = F("Emergency");
@@ -956,8 +976,8 @@ public:
     JsonDocument doc;
     doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->statusTopic.c_str();
     doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
-    doc[FPSTR(HA_UNIQUE_ID)] = this->getUniqueIdWithPrefix(F("ot_status"));
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectIdWithPrefix(F("ot_status"));
-    doc[FPSTR(HA_DEFAULT_ENTITY_ID)] = this->getEntityIdWithPrefix(FPSTR(HA_ENTITY_BINARY_SENSOR), F("ot_status"));
+    doc[FPSTR(HA_OBJECT_ID)] = doc[FPSTR(HA_UNIQUE_ID)];
     doc[FPSTR(HA_ENTITY_CATEGORY)] = FPSTR(HA_ENTITY_CATEGORY_DIAGNOSTIC);
     doc[FPSTR(HA_DEVICE_CLASS)] = F("connectivity");
     doc[FPSTR(HA_NAME)] = F("Opentherm status");
@@ -977,8 +997,9 @@ public:
     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->getUniqueIdWithPrefix(F("heating"));
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectIdWithPrefix(F("heating"));
-    doc[FPSTR(HA_DEFAULT_ENTITY_ID)] = this->getEntityIdWithPrefix(FPSTR(HA_ENTITY_BINARY_SENSOR), F("heating"));
+    doc[FPSTR(HA_OBJECT_ID)] = doc[FPSTR(HA_UNIQUE_ID)];
+    //doc[FPSTR(HA_ENTITY_CATEGORY)] = FPSTR(HA_ENTITY_CATEGORY_DIAGNOSTIC);
     doc[FPSTR(HA_DEVICE_CLASS)] = F("running");
     doc[FPSTR(HA_NAME)] = F("Heating");
     doc[FPSTR(HA_ICON)] = F("mdi:radiator");
@@ -997,8 +1018,9 @@ public:
     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->getUniqueIdWithPrefix(F("dhw"));
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectIdWithPrefix(F("dhw"));
-    doc[FPSTR(HA_DEFAULT_ENTITY_ID)] = this->getEntityIdWithPrefix(FPSTR(HA_ENTITY_BINARY_SENSOR), F("dhw"));
+    doc[FPSTR(HA_OBJECT_ID)] = doc[FPSTR(HA_UNIQUE_ID)];
+    //doc[FPSTR(HA_ENTITY_CATEGORY)] = FPSTR(HA_ENTITY_CATEGORY_DIAGNOSTIC);
     doc[FPSTR(HA_DEVICE_CLASS)] = F("running");
     doc[FPSTR(HA_NAME)] = F("DHW");
     doc[FPSTR(HA_ICON)] = F("mdi:faucet");
@@ -1017,8 +1039,9 @@ public:
     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->getUniqueIdWithPrefix(F("flame"));
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectIdWithPrefix(F("flame"));
-    doc[FPSTR(HA_DEFAULT_ENTITY_ID)] = this->getEntityIdWithPrefix(FPSTR(HA_ENTITY_BINARY_SENSOR), F("flame"));
+    doc[FPSTR(HA_OBJECT_ID)] = doc[FPSTR(HA_UNIQUE_ID)];
+    //doc[FPSTR(HA_ENTITY_CATEGORY)] = FPSTR(HA_ENTITY_CATEGORY_DIAGNOSTIC);
     doc[FPSTR(HA_DEVICE_CLASS)] = F("running");
     doc[FPSTR(HA_NAME)] = F("Flame");
     doc[FPSTR(HA_ICON)] = F("mdi:gas-burner");
@@ -1037,8 +1060,8 @@ public:
     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->getUniqueIdWithPrefix(F("fault"));
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectIdWithPrefix(F("fault"));
-    doc[FPSTR(HA_DEFAULT_ENTITY_ID)] = this->getEntityIdWithPrefix(FPSTR(HA_ENTITY_BINARY_SENSOR), F("fault"));
+    doc[FPSTR(HA_OBJECT_ID)] = doc[FPSTR(HA_UNIQUE_ID)];
     doc[FPSTR(HA_ENTITY_CATEGORY)] = FPSTR(HA_ENTITY_CATEGORY_DIAGNOSTIC);
     doc[FPSTR(HA_DEVICE_CLASS)] = F("problem");
     doc[FPSTR(HA_NAME)] = F("Fault");
@@ -1058,8 +1081,8 @@ public:
     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->getUniqueIdWithPrefix(FPSTR(HA_ENTITY_CATEGORY_DIAGNOSTIC));
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectIdWithPrefix(FPSTR(HA_ENTITY_CATEGORY_DIAGNOSTIC));
-    doc[FPSTR(HA_DEFAULT_ENTITY_ID)] = this->getEntityIdWithPrefix(FPSTR(HA_ENTITY_BINARY_SENSOR), FPSTR(HA_ENTITY_CATEGORY_DIAGNOSTIC));
+    doc[FPSTR(HA_OBJECT_ID)] = doc[FPSTR(HA_UNIQUE_ID)];
     doc[FPSTR(HA_ENTITY_CATEGORY)] = FPSTR(HA_ENTITY_CATEGORY_DIAGNOSTIC);
     doc[FPSTR(HA_DEVICE_CLASS)] = F("problem");
     doc[FPSTR(HA_NAME)] = F("Diagnostic");
@@ -1076,8 +1099,8 @@ public:
     JsonDocument doc;
     doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->statusTopic.c_str();
     doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
-    doc[FPSTR(HA_UNIQUE_ID)] = this->getUniqueIdWithPrefix(F("ext_pump"));
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectIdWithPrefix(F("ext_pump"));
-    doc[FPSTR(HA_DEFAULT_ENTITY_ID)] = this->getEntityIdWithPrefix(FPSTR(HA_ENTITY_BINARY_SENSOR), F("ext_pump"));
+    doc[FPSTR(HA_OBJECT_ID)] = doc[FPSTR(HA_UNIQUE_ID)];
     doc[FPSTR(HA_ENTITY_CATEGORY)] = FPSTR(HA_ENTITY_CATEGORY_DIAGNOSTIC);
     doc[FPSTR(HA_DEVICE_CLASS)] = F("running");
     doc[FPSTR(HA_NAME)] = F("External pump");
@@ -1097,8 +1120,8 @@ public:
     doc[FPSTR(HA_AVAILABILITY)][1][FPSTR(HA_VALUE_TEMPLATE)] = F("{{ iif(value_json.slave.connected and value_json.slave.fault.active, 'online', 'offline') }}");
     doc[FPSTR(HA_AVAILABILITY_MODE)] = F("all");
     doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
-    doc[FPSTR(HA_UNIQUE_ID)] = this->getUniqueIdWithPrefix(F("fault_code"));
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectIdWithPrefix(F("fault_code"));
-    doc[FPSTR(HA_DEFAULT_ENTITY_ID)] = this->getEntityIdWithPrefix(FPSTR(HA_ENTITY_SENSOR), F("fault_code"));
+    doc[FPSTR(HA_OBJECT_ID)] = doc[FPSTR(HA_UNIQUE_ID)];
     doc[FPSTR(HA_ENTITY_CATEGORY)] = FPSTR(HA_ENTITY_CATEGORY_DIAGNOSTIC);
     doc[FPSTR(HA_NAME)] = F("Fault code");
     doc[FPSTR(HA_ICON)] = F("mdi:cog-box");
@@ -1117,8 +1140,8 @@ public:
     doc[FPSTR(HA_AVAILABILITY)][1][FPSTR(HA_VALUE_TEMPLATE)] = F("{{ iif(value_json.slave.connected and value_json.slave.fault.active or value_json.slave.diag.active, 'online', 'offline') }}");
     doc[FPSTR(HA_AVAILABILITY_MODE)] = F("all");
     doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
-    doc[FPSTR(HA_UNIQUE_ID)] = this->getUniqueIdWithPrefix(F("diagnostic_code"));
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectIdWithPrefix(F("diagnostic_code"));
-    doc[FPSTR(HA_DEFAULT_ENTITY_ID)] = this->getEntityIdWithPrefix(FPSTR(HA_ENTITY_SENSOR), F("diagnostic_code"));
+    doc[FPSTR(HA_OBJECT_ID)] = doc[FPSTR(HA_UNIQUE_ID)];
     doc[FPSTR(HA_ENTITY_CATEGORY)] = FPSTR(HA_ENTITY_CATEGORY_DIAGNOSTIC);
     doc[FPSTR(HA_NAME)] = F("Diagnostic code");
     doc[FPSTR(HA_ICON)] = F("mdi:information-box");
@@ -1134,8 +1157,8 @@ public:
     JsonDocument doc;
     doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->statusTopic.c_str();
     doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
-    doc[FPSTR(HA_UNIQUE_ID)] = this->getUniqueIdWithPrefix(FPSTR(S_RSSI));
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectIdWithPrefix(FPSTR(S_RSSI));
-    doc[FPSTR(HA_DEFAULT_ENTITY_ID)] = this->getEntityIdWithPrefix(FPSTR(HA_ENTITY_SENSOR), FPSTR(S_RSSI));
+    doc[FPSTR(HA_OBJECT_ID)] = doc[FPSTR(HA_UNIQUE_ID)];
     doc[FPSTR(HA_ENTITY_CATEGORY)] = FPSTR(HA_ENTITY_CATEGORY_DIAGNOSTIC);
     doc[FPSTR(HA_DEVICE_CLASS)] = F("signal_strength");
     doc[FPSTR(HA_STATE_CLASS)] = FPSTR(HA_STATE_CLASS_MEASUREMENT);
@@ -1154,8 +1177,8 @@ public:
     JsonDocument doc;
     doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->statusTopic.c_str();
     doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
-    doc[FPSTR(HA_UNIQUE_ID)] = this->getUniqueIdWithPrefix(F("uptime"));
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectIdWithPrefix(F("uptime"));
-    doc[FPSTR(HA_DEFAULT_ENTITY_ID)] = this->getEntityIdWithPrefix(FPSTR(HA_ENTITY_SENSOR), F("uptime"));
+    doc[FPSTR(HA_OBJECT_ID)] = doc[FPSTR(HA_UNIQUE_ID)];
     doc[FPSTR(HA_ENTITY_CATEGORY)] = FPSTR(HA_ENTITY_CATEGORY_DIAGNOSTIC);
     doc[FPSTR(HA_DEVICE_CLASS)] = F("duration");
     doc[FPSTR(HA_STATE_CLASS)] = F("total_increasing");
@@ -1171,12 +1194,12 @@ public:
   }
 
 
-  bool publishClimateHeating(UnitSystem unit = UnitSystem::METRIC, uint8_t minTemp = 20, uint8_t maxTemp = 90, bool enabledByDefault = true) {
+  bool publishClimateHeating(UnitSystem unit = UnitSystem::METRIC, byte minTemp = 20, byte maxTemp = 90, bool enabledByDefault = true) {
     JsonDocument doc;
     doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->statusTopic.c_str();
     doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
-    doc[FPSTR(HA_UNIQUE_ID)] = this->getUniqueIdWithPrefix(F("heating"));
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectIdWithPrefix(F("heating"));
-    doc[FPSTR(HA_DEFAULT_ENTITY_ID)] = this->getEntityIdWithPrefix(FPSTR(HA_ENTITY_CLIMATE), F("heating"));
+    doc[FPSTR(HA_OBJECT_ID)] = doc[FPSTR(HA_UNIQUE_ID)];
     doc[FPSTR(HA_NAME)] = F("Heating");
     doc[FPSTR(HA_ICON)] = F("mdi:radiator");
 
@@ -1223,12 +1246,12 @@ public:
     return this->publish(this->makeConfigTopic(FPSTR(HA_ENTITY_CLIMATE), F("heating"), '_').c_str(), doc);
   }
 
-  bool publishClimateDhw(UnitSystem unit = UnitSystem::METRIC, uint8_t minTemp = 40, uint8_t maxTemp = 60, bool enabledByDefault = true) {
+  bool publishClimateDhw(UnitSystem unit = UnitSystem::METRIC, byte minTemp = 40, byte maxTemp = 60, bool enabledByDefault = true) {
     JsonDocument doc;
     doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->statusTopic.c_str();
     doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
-    doc[FPSTR(HA_UNIQUE_ID)] = this->getUniqueIdWithPrefix(F("dhw"));
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectIdWithPrefix(F("dhw"));
-    doc[FPSTR(HA_DEFAULT_ENTITY_ID)] = this->getEntityIdWithPrefix(FPSTR(HA_ENTITY_CLIMATE), F("dhw"));
+    doc[FPSTR(HA_OBJECT_ID)] = doc[FPSTR(HA_UNIQUE_ID)];
     doc[FPSTR(HA_NAME)] = F("DHW");
     doc[FPSTR(HA_ICON)] = F("mdi:faucet");
 
@@ -1272,8 +1295,8 @@ public:
     JsonDocument doc;
     doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->statusTopic.c_str();
     doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
-    doc[FPSTR(HA_UNIQUE_ID)] = this->getUniqueIdWithPrefix(FPSTR(S_RESTART));
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectIdWithPrefix(FPSTR(S_RESTART));
-    doc[FPSTR(HA_DEFAULT_ENTITY_ID)] = this->getEntityIdWithPrefix(FPSTR(HA_ENTITY_BUTTON), FPSTR(S_RESTART));
+    doc[FPSTR(HA_OBJECT_ID)] = doc[FPSTR(HA_UNIQUE_ID)];
     doc[FPSTR(HA_ENTITY_CATEGORY)] = FPSTR(HA_ENTITY_CATEGORY_CONFIG);
     doc[FPSTR(HA_DEVICE_CLASS)] = FPSTR(S_RESTART);
     doc[FPSTR(HA_NAME)] = F("Restart");
@@ -1292,8 +1315,8 @@ public:
     doc[FPSTR(HA_AVAILABILITY)][1][FPSTR(HA_VALUE_TEMPLATE)] = F("{{ iif(value_json.slave.fault.active, 'online', 'offline') }}");
     doc[FPSTR(HA_AVAILABILITY_MODE)] = F("all");
     doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
-    doc[FPSTR(HA_UNIQUE_ID)] = this->getUniqueIdWithPrefix(F("reset_fault"));
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectIdWithPrefix(F("reset_fault"));
-    doc[FPSTR(HA_DEFAULT_ENTITY_ID)] = this->getEntityIdWithPrefix(FPSTR(HA_ENTITY_BUTTON), F("reset_fault"));
+    doc[FPSTR(HA_OBJECT_ID)] = doc[FPSTR(HA_UNIQUE_ID)];
     doc[FPSTR(HA_ENTITY_CATEGORY)] = FPSTR(HA_ENTITY_CATEGORY_CONFIG);
     doc[FPSTR(HA_DEVICE_CLASS)] = FPSTR(S_RESTART);
     doc[FPSTR(HA_NAME)] = F("Reset fault");
@@ -1312,8 +1335,8 @@ public:
     doc[FPSTR(HA_AVAILABILITY)][1][FPSTR(HA_VALUE_TEMPLATE)] = F("{{ iif(value_json.slave.diag.active, 'online', 'offline') }}");
     doc[FPSTR(HA_AVAILABILITY_MODE)] = F("all");
     doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
-    doc[FPSTR(HA_UNIQUE_ID)] = this->getUniqueIdWithPrefix(F("reset_diagnostic"));
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectIdWithPrefix(F("reset_diagnostic"));
-    doc[FPSTR(HA_DEFAULT_ENTITY_ID)] = this->getEntityIdWithPrefix(FPSTR(HA_ENTITY_BUTTON), F("reset_diagnostic"));
+    doc[FPSTR(HA_OBJECT_ID)] = doc[FPSTR(HA_UNIQUE_ID)];
     doc[FPSTR(HA_ENTITY_CATEGORY)] = FPSTR(HA_ENTITY_CATEGORY_CONFIG);
     doc[FPSTR(HA_DEVICE_CLASS)] = FPSTR(S_RESTART);
     doc[FPSTR(HA_NAME)] = F("Reset diagnostic");

src/MainTask.h

@@ -51,10 +51,6 @@ protected:
     return "Main";
   }
 
-  uint32_t getTaskStackSize() override {
-    return 6000;
-  }
-
   /*BaseType_t getTaskCore() override {
     return 1;
   }*/
@@ -613,12 +609,7 @@ protected:
       if (GPIO_IS_VALID(settings.externalPump.gpio)) {
         configuredGpio = settings.externalPump.gpio;
         pinMode(configuredGpio, OUTPUT);
-        digitalWrite(
+        digitalWrite(configuredGpio, LOW);
-          configuredGpio,
-          settings.externalPump.invertState
-            ? HIGH 
-            : LOW
-        );
 
       } else if (configuredGpio != GPIO_IS_NOT_CONFIGURED) {
         configuredGpio = GPIO_IS_NOT_CONFIGURED;
@@ -646,12 +637,7 @@ protected:
     
     if (!settings.externalPump.use) {
       if (vars.externalPump.state) {
-        digitalWrite(
+        digitalWrite(configuredGpio, LOW);
-          configuredGpio,
-          settings.externalPump.invertState
-            ? HIGH 
-            : LOW
-        );
 
         vars.externalPump.state = false;
         vars.externalPump.lastEnabledTime = millis();
@@ -664,12 +650,7 @@ protected:
 
     if (vars.externalPump.state && !this->heatingEnabled) {
       if (this->extPumpStartReason == MainTask::PumpStartReason::HEATING && millis() - this->heatingDisabledTime > (settings.externalPump.postCirculationTime * 1000u)) {
-        digitalWrite(
+        digitalWrite(configuredGpio, LOW);
-          configuredGpio,
-          settings.externalPump.invertState
-            ? HIGH 
-            : LOW
-        );
 
         vars.externalPump.state = false;
         vars.externalPump.lastEnabledTime = millis();
@@ -677,12 +658,7 @@ protected:
         Log.sinfoln(FPSTR(L_EXTPUMP), F("Disabled: expired post circulation time"));
 
       } else if (this->extPumpStartReason == MainTask::PumpStartReason::ANTISTUCK && millis() - this->externalPumpStartTime >= (settings.externalPump.antiStuckTime * 1000u)) {
-        digitalWrite(
+        digitalWrite(configuredGpio, LOW);
-          configuredGpio,
-          settings.externalPump.invertState
-            ? HIGH 
-            : LOW
-        );
 
         vars.externalPump.state = false;
         vars.externalPump.lastEnabledTime = millis();
@@ -698,12 +674,7 @@ protected:
       this->externalPumpStartTime = millis();
       this->extPumpStartReason = MainTask::PumpStartReason::HEATING;
 
-      digitalWrite(
+      digitalWrite(configuredGpio, HIGH);
-        configuredGpio,
-        settings.externalPump.invertState
-          ? LOW 
-          : HIGH
-      );
 
       Log.sinfoln(FPSTR(L_EXTPUMP), F("Enabled: heating on"));
 
@@ -712,12 +683,7 @@ protected:
       this->externalPumpStartTime = millis();
       this->extPumpStartReason = MainTask::PumpStartReason::ANTISTUCK;
 
-      digitalWrite(
+      digitalWrite(configuredGpio, HIGH);
-        configuredGpio,
-        settings.externalPump.invertState
-          ? LOW 
-          : HIGH
-      );
 
       Log.sinfoln(FPSTR(L_EXTPUMP), F("Enabled: anti stuck"));
     }

src/MqttTask.h

@@ -502,9 +502,10 @@ protected:
 
     // equitherm
     this->haHelper->publishSwitchEquitherm();
-    this->haHelper->publishInputEquithermFactorN(false);
+    this->haHelper->publishInputEquithermSlope(false);
-    this->haHelper->publishInputEquithermFactorK(false);
+    this->haHelper->publishInputEquithermExponent(false);
-    this->haHelper->publishInputEquithermFactorT(false);
+    this->haHelper->publishInputEquithermShift(false);
+    this->haHelper->publishInputEquithermTargetDiffFactor(false);
 
     // states
     this->haHelper->publishStatusState();
@@ -557,7 +558,7 @@ protected:
   }
 
   bool publishNonStaticHaEntities(bool force = false) {
-    static uint8_t _heatingMinTemp, _heatingMaxTemp, _dhwMinTemp, _dhwMaxTemp = 0;
+    static byte _heatingMinTemp, _heatingMaxTemp, _dhwMinTemp, _dhwMaxTemp = 0;
     static bool _indoorTempControl, _dhwSupport = false;
 
     bool published = false;

src/OpenThermTask.h

@@ -19,8 +19,8 @@ protected:
 
   CustomOpenTherm* instance = nullptr;
   unsigned long instanceCreatedTime = 0;
-  uint8_t instanceInGpio = 0;
+  byte instanceInGpio = 0;
-  uint8_t instanceOutGpio = 0;
+  byte instanceOutGpio = 0;
   bool initialized = false;
   unsigned long connectedTime = 0;
   unsigned long disconnectedTime = 0;
@@ -31,16 +31,12 @@ protected:
   unsigned long heatingSetTempTime = 0;
   unsigned long dhwSetTempTime = 0;
   unsigned long ch2SetTempTime = 0;
-  uint8_t configuredRxLedGpio = GPIO_IS_NOT_CONFIGURED;
+  byte configuredRxLedGpio = GPIO_IS_NOT_CONFIGURED;
 
   #if defined(ARDUINO_ARCH_ESP32)
   const char* getTaskName() override {
     return "OpenTherm";
   }
-
-  uint32_t getTaskStackSize() override {
-    return 7500;
-  }
   
   BaseType_t getTaskCore() override {
     return 1;
@@ -94,7 +90,7 @@ protected:
 
     Log.sinfoln(FPSTR(L_OT), F("Started. GPIO IN: %hhu, GPIO OUT: %hhu"), settings.opentherm.inGpio, settings.opentherm.outGpio);
 
-    this->instance->setAfterSendRequestCallback([this](unsigned long request, unsigned long response, OpenThermResponseStatus status, uint8_t attempt) {
+    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   Msg type: %s   Attempt: %2d   Status: %s"),
@@ -240,7 +236,7 @@ protected:
       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.active = CustomOpenTherm::isCoolingActive(response);
+      vars.slave.cooling = CustomOpenTherm::isCoolingActive(response);
       vars.slave.ch2.active = CustomOpenTherm::isCh2Active(response);
       vars.slave.fault.active = CustomOpenTherm::isFault(response);
 
@@ -254,7 +250,7 @@ protected:
       Log.snoticeln(
         FPSTR(L_OT), F("Received boiler status. Heating: %hhu; DHW: %hhu; flame: %hhu; cooling: %hhu; channel 2: %hhu; fault: %hhu; diag: %hhu"),
         vars.slave.heating.active, vars.slave.dhw.active,
-        vars.slave.flame, vars.slave.cooling.active, vars.slave.ch2.active, vars.slave.fault.active, vars.slave.diag.active
+        vars.slave.flame, vars.slave.cooling, vars.slave.ch2.active, vars.slave.fault.active, vars.slave.diag.active
       );
     }
 
@@ -322,8 +318,6 @@ protected:
       vars.slave.dhw.enabled = false;
       vars.slave.dhw.active = false;
       vars.slave.flame = false;
-      vars.slave.cooling.active = false;
-      vars.slave.cooling.setpoint = 0;
       vars.slave.fault.active = false;
       vars.slave.fault.code = 0;
       vars.slave.diag.active = false;
@@ -694,22 +688,6 @@ protected:
       this->prevUpdateNonEssentialVars = millis();
     }
 
-    // Set cooling setpoint = heating max modulation
-    if (settings.opentherm.options.coolingSupport) {
-      if (this->setCoolingSetpoint(settings.heating.maxModulation)) {
-        Log.snoticeln(
-          FPSTR(L_OT), F("Set cooling setpoint: %hhu%% (response: %hhu%%)"),
-          settings.heating.maxModulation, vars.slave.cooling.setpoint
-        );
-
-      } else {
-        Log.swarningln(
-          FPSTR(L_OT), F("Failed set cooling setpoint: %hhu%% (response: %hhu%%)"),
-          settings.heating.maxModulation, vars.slave.cooling.setpoint
-        );
-      }
-    }
-
     // Set max modulation level
     uint8_t targetMaxModulation = vars.slave.modulation.max;
     if (vars.slave.heating.active) {
@@ -1590,26 +1568,6 @@ protected:
     return CustomOpenTherm::getUInt(response) == request;
   }
 
-  bool setCoolingSetpoint(const uint8_t value) {
-    const unsigned int request = CustomOpenTherm::toFloat(value);
-    const unsigned long response = this->instance->sendRequest(CustomOpenTherm::buildRequest(
-      OpenThermRequestType::WRITE_DATA,
-      OpenThermMessageID::CoolingControl,
-      request
-    ));
-
-    if (!CustomOpenTherm::isValidResponse(response)) {
-      return false;
-
-    } else if (!CustomOpenTherm::isValidResponseId(response, OpenThermMessageID::CoolingControl)) {
-      return false;
-    }
-
-    vars.slave.cooling.setpoint = CustomOpenTherm::getFloat(response);
-
-    return CustomOpenTherm::getUInt(response) == request;
-  }
-
   bool setMaxModulationLevel(const uint8_t value) {
     const unsigned int request = CustomOpenTherm::toFloat(value);
     const unsigned long response = this->instance->sendRequest(CustomOpenTherm::buildRequest(

src/RegulatorTask.h

@@ -1,7 +1,5 @@
-#include <Equitherm.h>
 #include <GyverPID.h>
 
-Equitherm etRegulator;
 GyverPID pidRegulator(0, 0, 0);
 
 
@@ -21,10 +19,6 @@ protected:
   const char* getTaskName() override {
     return "Regulator";
   }
-
-  uint32_t getTaskStackSize() override {
-    return 5000;
-  }
   
   /*BaseType_t getTaskCore() override {
     return 1;
@@ -150,39 +144,32 @@ protected:
 
     // if use equitherm
     if (settings.equitherm.enabled) {
-      unsigned short minTemp = settings.heating.minTemp;
+      float tempDelta = settings.heating.target - vars.master.heating.outdoorTemp;
-      unsigned short maxTemp = settings.heating.maxTemp;
+      float maxPoint = settings.heating.target - (
-      float targetTemp = settings.heating.target;
+        settings.heating.maxTemp - settings.heating.target
-      float indoorTemp = vars.master.heating.indoorTemp;
+      ) / settings.equitherm.slope;
-      float outdoorTemp = vars.master.heating.outdoorTemp;
 
-      if (settings.system.unitSystem == UnitSystem::IMPERIAL) {
+      float sf = (settings.heating.maxTemp - settings.heating.target) / pow(
-        minTemp = f2c(minTemp);
+        settings.heating.target - maxPoint,
-        maxTemp = f2c(maxTemp);
+        1.0f / settings.equitherm.exponent
-        targetTemp = f2c(targetTemp);
+      );
-        indoorTemp = f2c(indoorTemp);
+      float etResult = settings.heating.target + settings.equitherm.shift + sf * (
-        outdoorTemp = f2c(outdoorTemp);
+        tempDelta >= 0 
+          ? pow(tempDelta, 1.0f / settings.equitherm.exponent) 
+          : -(pow(-(tempDelta), 1.0f / settings.equitherm.exponent))
+      );
+
+      // add diff
+      if (this->indoorSensorsConnected && !settings.pid.enabled && !settings.heating.turbo) {
+        etResult += constrain(
+          settings.heating.target - vars.master.heating.indoorTemp,
+          -3.0f,
+          3.0f
+        ) * settings.equitherm.targetDiffFactor;
       }
 
-      if (!this->indoorSensorsConnected || settings.pid.enabled) {
+      // limit
-        etRegulator.Kt = 0.0f;
+      etResult = constrain(etResult, settings.heating.minTemp, settings.heating.maxTemp);
-        etRegulator.indoorTemp = 0.0f;
-
-      } else {
-        etRegulator.Kt = settings.heating.turbo ? 0.0f : settings.equitherm.t_factor;
-        etRegulator.indoorTemp = indoorTemp;
-      }
-
-      etRegulator.setLimits(minTemp, maxTemp);
-      etRegulator.Kn = settings.equitherm.n_factor;
-      etRegulator.Kk = settings.equitherm.k_factor;
-      etRegulator.targetTemp = targetTemp;
-      etRegulator.outdoorTemp = outdoorTemp;
-      float etResult = etRegulator.getResult();
-
-      if (settings.system.unitSystem == UnitSystem::IMPERIAL) {
-        etResult = c2f(etResult);
-      }
 
       if (fabsf(prevEtResult - etResult) > 0.09f) {
         prevEtResult = etResult;
@@ -217,8 +204,7 @@ protected:
         }*/
 
         float error = pidRegulator.setpoint - pidRegulator.input;
-        bool hasDeadband = settings.pid.deadband.enabled 
+        bool hasDeadband = (error > -(settings.pid.deadband.thresholdHigh))
-          && (error > -(settings.pid.deadband.thresholdHigh))
           && (error < settings.pid.deadband.thresholdLow);
 
         if (hasDeadband) {

src/Sensors.h

@@ -149,7 +149,7 @@ public:
 
   static int16_t getIdByName(const char* name) {
     if (settings == nullptr) {
-      return -1;
+      return 0;
     }
 
     for (uint8_t id = 0; id <= getMaxSensorId(); id++) {
@@ -163,7 +163,7 @@ public:
 
   static int16_t getIdByObjectId(const char* objectId) {
     if (settings == nullptr) {
-      return -1;
+      return 0;
     }
 
     String refObjectId;
@@ -334,7 +334,7 @@ public:
 
     uint8_t valueId = (uint8_t) valueType;
     if (!isValidValueId(valueId)) {
-      return 0;
+      return false;
     }
     
     float value = 0.0f;

src/SensorsTask.h

@@ -8,140 +8,6 @@
 
 extern FileData fsSensorsSettings;
 
-#if USE_BLE
-class BluetoothScanCallbacks : public NimBLEScanCallbacks {
-public:
-  void onDiscovered(const NimBLEAdvertisedDevice* device) override {
-    auto& deviceAddress = device->getAddress();
-
-    bool found = false;
-    uint8_t sensorId;
-    for (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;
-      }
-
-      const auto sensorAddress = NimBLEAddress(sSensor.address, deviceAddress.getType());
-      if (sensorAddress.isNull() || sensorAddress != deviceAddress) {
-        continue;
-      }
-
-      found = true;
-      break;
-    }
-
-    if (!found) {
-      return;
-    }
-
-    auto& sSensor = Sensors::settings[sensorId];
-    auto& rSensor = Sensors::results[sensorId];
-    auto deviceName = device->getName();
-    auto deviceRssi = device->getRSSI();
-
-    Log.straceln(
-      FPSTR(L_SENSORS_BLE), F("Sensor #%hhu '%s': discovered device %s, name: %s, RSSI: %hhd"),
-      sensorId, sSensor.name,
-      deviceAddress.toString().c_str(), deviceName.c_str(), deviceRssi
-    );
-
-    if (!device->haveServiceData()) {
-      Log.straceln(
-        FPSTR(L_SENSORS_BLE), F("Sensor #%hhu '%s': not found service data"),
-        sensorId, sSensor.name
-      );
-      return;
-    }
-
-    auto serviceDataCount = device->getServiceDataCount();
-    Log.straceln(
-      FPSTR(L_SENSORS_BLE), F("Sensor #%hhu '%s': found %hhu service data"),
-      sensorId, sSensor.name, serviceDataCount
-    );
-
-    NimBLEUUID serviceUuid((uint16_t) 0x181A);
-    auto serviceData = device->getServiceData(serviceUuid);
-    if (!serviceData.size()) {
-      Log.straceln(
-        FPSTR(L_SENSORS_BLE), F("Sensor #%hhu '%s': NOT found %s env service data"),
-        sensorId, sSensor.name, serviceUuid.toString().c_str()
-      );
-      return;
-    }
-  
-    Log.straceln(
-      FPSTR(L_SENSORS_BLE), F("Sensor #%hhu '%s': found %s env service data"),
-      sensorId, sSensor.name, serviceUuid.toString().c_str()
-    );
-
-    float temperature, humidity;
-    uint16_t batteryMv;
-    uint8_t batteryLevel;
-
-    if (serviceData.size() == 13) {
-      // atc1441 format
-
-      // Temperature (2 bytes, big-endian)
-      temperature = (
-        (static_cast<uint8_t>(serviceData[6]) << 8) | static_cast<uint8_t>(serviceData[7])
-      ) * 0.1f;
-
-      // Humidity (1 byte)
-      humidity = static_cast<uint8_t>(serviceData[8]);
-
-      // Battery mV (2 bytes, big-endian)
-      batteryMv = (static_cast<uint8_t>(serviceData[10]) << 8) | static_cast<uint8_t>(serviceData[11]);
-
-      // Battery level (1 byte)
-      batteryLevel = static_cast<uint8_t>(serviceData[9]);
-
-    } else if (serviceData.size() == 15) {
-      // custom pvvx format
-
-      // Temperature (2 bytes, little-endian)
-      temperature = (
-        (static_cast<uint8_t>(serviceData[7]) << 8) | static_cast<uint8_t>(serviceData[6])
-      ) * 0.01f;
-
-      // Humidity (2 bytes, little-endian)
-      humidity = (
-        (static_cast<uint8_t>(serviceData[9]) << 8) | static_cast<uint8_t>(serviceData[8])
-      ) * 0.01f;
-
-      // Battery mV (2 bytes, little-endian)
-      batteryMv = (static_cast<uint8_t>(serviceData[11]) << 8) | static_cast<uint8_t>(serviceData[10]);
-
-      // Battery level (1 byte)
-      batteryLevel = static_cast<uint8_t>(serviceData[12]);
-
-    } else {
-      // unknown format
-      Log.straceln(
-        FPSTR(L_SENSORS_BLE), F("Sensor #%hhu '%s': unknown data format (size: %i)"),
-        sensorId, sSensor.name, serviceData.size()
-      );
-      return;
-    }
-
-    Log.straceln(
-      FPSTR(L_SENSORS_BLE),
-      F("Sensor #%hhu '%s', received temp: %.2f; humidity: %.2f, battery voltage: %hu, battery level: %hhu"),
-      sensorId, sSensor.name,
-      temperature, humidity, batteryMv, batteryLevel
-    );
-
-    // update data
-    Sensors::setValueById(sensorId, temperature, Sensors::ValueType::TEMPERATURE, true, true);
-    Sensors::setValueById(sensorId, humidity, Sensors::ValueType::HUMIDITY, true, true);
-    Sensors::setValueById(sensorId, batteryLevel, Sensors::ValueType::BATTERY, true, true);
-
-    // update rssi
-    Sensors::setValueById(sensorId, deviceRssi, Sensors::ValueType::RSSI, false, false);
-  }
-};
-#endif
-
 class SensorsTask : public LeanTask {
 public:
   SensorsTask(bool _enabled = false, unsigned long _interval = 0) : LeanTask(_enabled, _interval) {
@@ -150,10 +16,6 @@ public:
     this->dallasSearchTime.reserve(2);
     this->dallasPolling.reserve(2);
     this->dallasLastPollingTime.reserve(2);
-
-    #if USE_BLE
-    this->pBLEScanCallbacks = new BluetoothScanCallbacks();
-    #endif
   }
 
   ~SensorsTask() {
@@ -162,17 +24,16 @@ public:
     this->dallasSearchTime.clear();
     this->dallasPolling.clear();
     this->dallasLastPollingTime.clear();
-
-    #if USE_BLE
-    delete this->pBLEScanCallbacks;
-    #endif
   }
 
 protected:
-  const unsigned int disconnectedTimeout = 180000u;
+  const unsigned int disconnectedTimeout = 120000;
-  const unsigned short dallasSearchInterval = 60000u;
+  const unsigned short dallasSearchInterval = 60000;
-  const unsigned short dallasPollingInterval = 10000u;
+  const unsigned short dallasPollingInterval = 10000;
-  const unsigned short globalPollingInterval = 15000u;
+  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;
@@ -180,9 +41,8 @@ protected:
   std::unordered_map<uint8_t, bool> dallasPolling;
   std::unordered_map<uint8_t, unsigned long> dallasLastPollingTime;
   #if USE_BLE
-  NimBLEScan* pBLEScan = nullptr;
+  std::unordered_map<uint8_t, bool> bleSubscribed;
-  BluetoothScanCallbacks* pBLEScanCallbacks = nullptr;
+  std::unordered_map<uint8_t, unsigned long> bleLastSetDtTime;
-  bool activeScanBle = false;
   #endif
   unsigned long globalLastPollingTime = 0;
 
@@ -191,10 +51,6 @@ protected:
     return "Sensors";
   }
 
-  uint32_t getTaskStackSize() override {
-    return 7500;
-  }
-
   BaseType_t getTaskCore() override {
     // https://github.com/h2zero/NimBLE-Arduino/issues/676
     #if USE_BLE && defined(CONFIG_BT_NIMBLE_PINNED_TO_CORE)
@@ -235,7 +91,8 @@ protected:
       this->yield();
 
       #if USE_BLE
-      scanBleSensors();
+      cleanBleInstances();
+      pollingBleSensors();
       this->yield();
       #endif
 
@@ -528,7 +385,7 @@ protected:
         continue;
       }
 
-      const float sensorResistance = value > 1
+      const float sensorResistance = value > 0.001f
         ? DEFAULT_NTC_REF_RESISTANCE / (DEFAULT_NTC_VREF / (float) value - 1.0f)
         : 0.0f;
       const float rawTemp = 1.0f / (
@@ -547,71 +404,572 @@ protected:
   }
 
   #if USE_BLE
-  void scanBleSensors() {
+  void cleanBleInstances() {
-    if (!Sensors::getAmountByType(Sensors::Type::BLUETOOTH, true)) {
+    #if USE_BLE
-      if (NimBLEDevice::isInitialized()) {
+    if (!NimBLEDevice::isInitialized()) {
-        if (this->pBLEScan != nullptr) {
-          if (this->pBLEScan->isScanning()) {
-            this->pBLEScan->stop();
-
-          } else {
-            this->pBLEScan = nullptr;
-          }
-        }
-
-        if (this->pBLEScan == nullptr) {
-          if (NimBLEDevice::deinit(true)) {
-            Log.sinfoln(FPSTR(L_SENSORS_BLE), F("Deinitialized"));
-
-          } else {
-            Log.swarningln(FPSTR(L_SENSORS_BLE), F("Unable to deinitialize!"));
-          }
-        }
-      }
-
       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"));
-      NimBLEDevice::init("");
+      BLEDevice::init("");
-
+      NimBLEDevice::setPower(9);
-      #ifdef ESP_PWR_LVL_P20
-      NimBLEDevice::setPower(ESP_PWR_LVL_P20);
-      #elifdef ESP_PWR_LVL_P9
-      NimBLEDevice::setPower(ESP_PWR_LVL_P9);
-      #endif
     }
 
-    if (this->pBLEScan == nullptr) {
+    for (uint8_t sensorId = 0; sensorId <= Sensors::getMaxSensorId(); sensorId++) {
-      this->pBLEScan = NimBLEDevice::getScan();
+      auto& sSensor = Sensors::settings[sensorId];
-      this->pBLEScan->setScanCallbacks(this->pBLEScanCallbacks);
+      auto& rSensor = Sensors::results[sensorId];
-      #if MYNEWT_VAL(BLE_EXT_ADV)
+      
-      this->pBLEScan->setPhy(NimBLEScan::Phy::SCAN_ALL);
+      if (!sSensor.enabled || sSensor.type != Sensors::Type::BLUETOOTH || sSensor.purpose == Sensors::Purpose::NOT_CONFIGURED) {
-      #endif
+        continue;
-      this->pBLEScan->setDuplicateFilter(false);
+      }
-      this->pBLEScan->setMaxResults(0);
-      this->pBLEScan->setInterval(10000);
-      this->pBLEScan->setWindow(10000);
 
-      Log.sinfoln(FPSTR(L_SENSORS_BLE), F("Scanning initialized"));
+      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;
     }
 
-    if (!this->pBLEScan->isScanning()) {
+    auto& sSensor = Sensors::settings[sensorId];
-      this->activeScanBle = !this->activeScanBle;
+    auto& rSensor = Sensors::results[sensorId];
-      this->pBLEScan->setActiveScan(this->activeScanBle);
 
-      if (this->pBLEScan->start(30000, false, false)) {
+    if (!sSensor.enabled || sSensor.type != Sensors::Type::BLUETOOTH || sSensor.purpose == Sensors::Purpose::NOT_CONFIGURED) {
-        Log.sinfoln(
+      return nullptr;
-          FPSTR(L_SENSORS_BLE),
+    }
-          F("%s scanning started"),
+    
-          this->activeScanBle ? "Active" : "Passive"
+    uint8_t addr[6] = {
+      sSensor.address[0], sSensor.address[1], sSensor.address[2],
+      sSensor.address[3], sSensor.address[4], sSensor.address[5]
+    };
+    const auto address = NimBLEAddress(addr, 0);
+    
+    NimBLEClient* pClient = NimBLEDevice::getClientByPeerAddress(address);
+    if (pClient == nullptr) {
+      pClient = NimBLEDevice::getDisconnectedClient();
+    }
+
+    if (pClient == nullptr) {
+      if (NimBLEDevice::getCreatedClientCount() >= NIMBLE_MAX_CONNECTIONS) {
+        return nullptr;
+      }
+
+      pClient = NimBLEDevice::createClient();
+      if (pClient == nullptr) {
+        return nullptr;
+      }
+
+      /**
+       *  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->isConnected()) {
+      pClient->setPeerAddress(address);
+    }
+
+    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;
+
+    // ENV Service (0x181A)
+    NimBLEUUID serviceUuid((uint16_t) 0x181AU);
+    pService = pClient->getService(serviceUuid);
+    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(), 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(), pAddress
+      );
+
+      // 0x2A6E - Notify temperature x0.01C (pvvx)
+      bool tempNotifyCreated = false;
+      if (!tempNotifyCreated) {
+        NimBLEUUID charUuid((uint16_t) 0x2A6E);
+        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.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(), 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(), 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(), pAddress
+              );
+            }
+          }
+        }
+
+        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, pAddress
+          );
+        }
+      }
+    }
+
+
+    // Battery Service (0x180F)
+    {
+      NimBLEUUID serviceUuid((uint16_t) 0x180F);
+      pService = pClient->getService(serviceUuid);
+      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(), pAddress
         );
 
       } else {
-        Log.sinfoln(FPSTR(L_SENSORS_BLE), F("Unable to start scanning"));
+        Log.straceln(
+          FPSTR(L_SENSORS_BLE), F("Sensor #%hhu '%s': found battery service (%s) on device %s"),
+          sensorId, sSensor.name, serviceUuid.toString().c_str(), pAddress
+        );
+
+        // 0x2A19 - Notify the battery charge level 0..99% (pvvx)
+        bool batteryNotifyCreated = false;
+        if (!batteryNotifyCreated) {
+          NimBLEUUID charUuid((uint16_t) 0x2A19);
+          pChar = pService->getCharacteristic(charUuid);
+
+          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(), pAddress
+            );
+
+            pChar->unsubscribe();
+            batteryNotifyCreated = 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 != 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': received battery: %hhu"),
+                  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(), 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(), pAddress
+              );
+            }
+          }
+        }
+
+        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, pAddress
+          );
+        }
       }
     }
+
+    return true;
+  }
+
+  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
 

src/Settings.h

@@ -12,13 +12,13 @@ struct NetworkSettings {
   struct {
     char ssid[33] = DEFAULT_AP_SSID;
     char password[65] = DEFAULT_AP_PASSWORD;
-    uint8_t channel = 6;
+    byte channel = 6;
   } ap;
 
   struct {
     char ssid[33] = DEFAULT_STA_SSID;
     char password[65] = DEFAULT_STA_PASSWORD;
-    uint8_t channel = 0;
+    byte channel = 0;
   } sta;
 } networkSettings;
 
@@ -42,7 +42,7 @@ struct Settings {
     } ntp;
 
     UnitSystem unitSystem = UnitSystem::METRIC;
-    uint8_t statusLedGpio = DEFAULT_STATUS_LED_GPIO;
+    byte statusLedGpio = DEFAULT_STATUS_LED_GPIO;
   } system;
 
   struct {
@@ -54,9 +54,9 @@ struct Settings {
 
   struct {
     UnitSystem unitSystem = UnitSystem::METRIC;
-    uint8_t inGpio = DEFAULT_OT_IN_GPIO;
+    byte inGpio = DEFAULT_OT_IN_GPIO;
-    uint8_t outGpio = DEFAULT_OT_OUT_GPIO;
+    byte outGpio = DEFAULT_OT_OUT_GPIO;
-    uint8_t rxLedGpio = DEFAULT_OT_RX_LED_GPIO;
+    byte rxLedGpio = DEFAULT_OT_RX_LED_GPIO;
     uint8_t memberId = 0;
     uint8_t flags = 0;
     float minPower = 0.0f;
@@ -105,8 +105,8 @@ struct Settings {
     float target = DEFAULT_HEATING_TARGET_TEMP;
     float hysteresis = 0.5f;
     float turboFactor = 7.5f;
-    uint8_t minTemp = DEFAULT_HEATING_MIN_TEMP;
+    byte minTemp = DEFAULT_HEATING_MIN_TEMP;
-    uint8_t maxTemp = DEFAULT_HEATING_MAX_TEMP;
+    byte maxTemp = DEFAULT_HEATING_MAX_TEMP;
     uint8_t maxModulation = 100;
 
     struct {
@@ -123,8 +123,8 @@ struct Settings {
   struct {
     bool enabled = true;
     float target = DEFAULT_DHW_TARGET_TEMP;
-    uint8_t minTemp = DEFAULT_DHW_MIN_TEMP;
+    byte minTemp = DEFAULT_DHW_MIN_TEMP;
-    uint8_t maxTemp = DEFAULT_DHW_MAX_TEMP;
+    byte maxTemp = DEFAULT_DHW_MAX_TEMP;
     uint8_t maxModulation = 100;
     
     struct {
@@ -154,15 +154,15 @@ struct Settings {
 
   struct {
     bool enabled = false;
-    float n_factor = 0.7f;
+    float slope = 0.7f;
-    float k_factor = 3.0f;
+    float exponent = 1.3f;
-    float t_factor = 2.0f;
+    float shift = 0.0f;
+    float targetDiffFactor = 2.0f;
   } equitherm;
 
   struct {
     bool use = false;
-    uint8_t gpio = DEFAULT_EXT_PUMP_GPIO;
+    byte gpio = DEFAULT_EXT_PUMP_GPIO;
-    bool invertState = false;
     unsigned short postCirculationTime = 600;
     unsigned int antiStuckInterval = 2592000;
     unsigned short antiStuckTime = 300;
@@ -171,15 +171,15 @@ struct Settings {
   struct {
     struct {
       bool enabled = false;
-      uint8_t gpio = GPIO_IS_NOT_CONFIGURED;
+      byte gpio = GPIO_IS_NOT_CONFIGURED;
-      bool invertState = false;
+      byte invertState = false;
       unsigned short thresholdTime = 60;
     } input;
 
     struct {
       bool enabled = false;
-      uint8_t gpio = GPIO_IS_NOT_CONFIGURED;
+      byte gpio = GPIO_IS_NOT_CONFIGURED;
-      bool invertState = false;
+      byte invertState = false;
       unsigned short thresholdTime = 60;
       bool onFault = true;
       bool onLossConnection = true;
@@ -330,14 +330,10 @@ struct Variables {
 
     bool connected = false;
     bool flame = false;
+    bool cooling = false;
     float pressure = 0.0f;
     float heatExchangerTemp = 0.0f;
 
-    struct {
-      bool active = false;
-      uint8_t setpoint = 0;
-    } cooling;
-
     struct {
       bool active = false;
       uint8_t code = 0;

src/main.cpp

@@ -1,3 +1,6 @@
+#define ARDUINOJSON_USE_DOUBLE 0
+#define ARDUINOJSON_USE_LONG_LONG 0
+
 #include <Arduino.h>
 #include <ArduinoJson.h>
 #include <FileData.h>
@@ -213,7 +216,7 @@ void setup() {
   tRegulator = new RegulatorTask(true, 10000);
   Scheduler.start(tRegulator);
 
-  tPortal = new PortalTask(true, 10);
+  tPortal = new PortalTask(true, 0);
   Scheduler.start(tPortal);
 
   tMain = new MainTask(true, 100);

src/strings.h

@@ -81,6 +81,7 @@ 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_EXPONENT[]                             PROGMEM = "exponent";
 const char S_EXTERNAL_PUMP[]                        PROGMEM = "externalPump";
 const char S_FACTOR[]                               PROGMEM = "factor";
 const char S_FAULT[]                                PROGMEM = "fault";
@@ -117,7 +118,6 @@ 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_LOW_TEMP[]                             PROGMEM = "lowTemp";
@@ -143,7 +143,6 @@ 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";
@@ -164,7 +163,6 @@ 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_PSRAM[]                                PROGMEM = "psram";
 const char S_P_FACTOR[]                             PROGMEM = "p_factor";
 const char S_P_MULTIPLIER[]                         PROGMEM = "p_multiplier";
 const char S_REAL_SIZE[]                            PROGMEM = "realSize";
@@ -183,20 +181,22 @@ 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_SHIFT[]                                PROGMEM = "shift";
 const char S_SIGNAL_QUALITY[]                       PROGMEM = "signalQuality";
 const char S_SIZE[]                                 PROGMEM = "size";
 const char S_SLAVE[]                                PROGMEM = "slave";
+const char S_SLOPE[]                                PROGMEM = "slope";
 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[]                             PROGMEM = "setpoint";
 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_DIFF_FACTOR[]                   PROGMEM = "targetDiffFactor";
 const char S_TARGET_TEMP[]                          PROGMEM = "targetTemp";
 const char S_TELNET[]                               PROGMEM = "telnet";
 const char S_TEMPERATURE[]                          PROGMEM = "temperature";
@@ -209,7 +209,6 @@ 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";

src/utils.h

@@ -72,7 +72,7 @@ time_t mkgmtime(const struct tm *ptm) {
 
 inline bool isDigit(const char* ptr) {
   char* endPtr;
-  auto tmp = strtol(ptr, &endPtr, 10);
+  strtol(ptr, &endPtr, 10);
   return *endPtr == 0;
 }
 
@@ -517,9 +517,10 @@ void settingsToJson(const Settings& src, JsonVariant dst, bool safe = false) {
 
   auto equitherm = dst[FPSTR(S_EQUITHERM)].to<JsonObject>();
   equitherm[FPSTR(S_ENABLED)] = src.equitherm.enabled;
-  equitherm[FPSTR(S_N_FACTOR)] = roundf(src.equitherm.n_factor, 3);
+  equitherm[FPSTR(S_SLOPE)] = roundf(src.equitherm.slope, 3);
-  equitherm[FPSTR(S_K_FACTOR)] = roundf(src.equitherm.k_factor, 3);
+  equitherm[FPSTR(S_EXPONENT)] = roundf(src.equitherm.exponent, 3);
-  equitherm[FPSTR(S_T_FACTOR)] = roundf(src.equitherm.t_factor, 3);
+  equitherm[FPSTR(S_SHIFT)] = roundf(src.equitherm.shift, 2);
+  equitherm[FPSTR(S_TARGET_DIFF_FACTOR)] = roundf(src.equitherm.targetDiffFactor, 3);
 
   auto pid = dst[FPSTR(S_PID)].to<JsonObject>();
   pid[FPSTR(S_ENABLED)] = src.pid.enabled;
@@ -542,7 +543,6 @@ void settingsToJson(const Settings& src, JsonVariant dst, bool safe = false) {
     auto externalPump = dst[FPSTR(S_EXTERNAL_PUMP)].to<JsonObject>();
     externalPump[FPSTR(S_USE)] = src.externalPump.use;
     externalPump[FPSTR(S_GPIO)] = src.externalPump.gpio;
-    externalPump[FPSTR(S_INVERT_STATE)] = src.externalPump.invertState;
     externalPump[FPSTR(S_POST_CIRCULATION_TIME)] = roundf(src.externalPump.postCirculationTime / 60, 0);
     externalPump[FPSTR(S_ANTI_STUCK_INTERVAL)] = roundf(src.externalPump.antiStuckInterval / 86400, 0);
     externalPump[FPSTR(S_ANTI_STUCK_TIME)] = roundf(src.externalPump.antiStuckTime / 60, 0);
@@ -1127,29 +1127,38 @@ bool jsonToSettings(const JsonVariantConst src, Settings& dst, bool safe = false
     }
   }
 
-  if (!src[FPSTR(S_EQUITHERM)][FPSTR(S_N_FACTOR)].isNull()) {
+  if (!src[FPSTR(S_EQUITHERM)][FPSTR(S_SLOPE)].isNull()) {
-    float value = src[FPSTR(S_EQUITHERM)][FPSTR(S_N_FACTOR)].as<float>();
+    float value = src[FPSTR(S_EQUITHERM)][FPSTR(S_SLOPE)].as<float>();
 
-    if (value > 0 && value <= 10 && fabsf(value - dst.equitherm.n_factor) > 0.0001f) {
+    if (value > 0.0f && value <= 10.0f && fabsf(value - dst.equitherm.slope) > 0.0001f) {
-      dst.equitherm.n_factor = roundf(value, 3);
+      dst.equitherm.slope = roundf(value, 3);
       changed = true;
     }
   }
 
-  if (!src[FPSTR(S_EQUITHERM)][FPSTR(S_K_FACTOR)].isNull()) {
+  if (!src[FPSTR(S_EQUITHERM)][FPSTR(S_EXPONENT)].isNull()) {
-    float value = src[FPSTR(S_EQUITHERM)][FPSTR(S_K_FACTOR)].as<float>();
+    float value = src[FPSTR(S_EQUITHERM)][FPSTR(S_EXPONENT)].as<float>();
 
-    if (value >= 0 && value <= 10 && fabsf(value - dst.equitherm.k_factor) > 0.0001f) {
+    if (value > 0.0f && value <= 2.0f && fabsf(value - dst.equitherm.exponent) > 0.0001f) {
-      dst.equitherm.k_factor = roundf(value, 3);
+      dst.equitherm.exponent = roundf(value, 3);
       changed = true;
     }
   }
 
-  if (!src[FPSTR(S_EQUITHERM)][FPSTR(S_T_FACTOR)].isNull()) {
+  if (!src[FPSTR(S_EQUITHERM)][FPSTR(S_SHIFT)].isNull()) {
-    float value = src[FPSTR(S_EQUITHERM)][FPSTR(S_T_FACTOR)].as<float>();
+    float value = src[FPSTR(S_EQUITHERM)][FPSTR(S_SHIFT)].as<float>();
 
-    if (value >= 0 && value <= 10 && fabsf(value - dst.equitherm.t_factor) > 0.0001f) {
+    if (value >= -15.0f && value <= 15.0f && fabsf(value - dst.equitherm.shift) > 0.0001f) {
-      dst.equitherm.t_factor = roundf(value, 3);
+      dst.equitherm.shift = roundf(value, 2);
+      changed = true;
+    }
+  }
+
+  if (!src[FPSTR(S_EQUITHERM)][FPSTR(S_TARGET_DIFF_FACTOR)].isNull()) {
+    float value = src[FPSTR(S_EQUITHERM)][FPSTR(S_TARGET_DIFF_FACTOR)].as<float>();
+
+    if (value >= 0.0f && value <= 10.0f && fabsf(value - dst.equitherm.targetDiffFactor) > 0.0001f) {
+      dst.equitherm.targetDiffFactor = roundf(value, 3);
       changed = true;
     }
   }
@@ -1325,7 +1334,7 @@ bool jsonToSettings(const JsonVariantConst src, Settings& dst, bool safe = false
   if (!src[FPSTR(S_HEATING)][FPSTR(S_MIN_TEMP)].isNull()) {
     unsigned char value = src[FPSTR(S_HEATING)][FPSTR(S_MIN_TEMP)].as<unsigned char>();
 
-    if (value != dst.heating.minTemp && value >= vars.slave.heating.minTemp && value < vars.slave.heating.maxTemp && value != dst.heating.maxTemp) {
+    if (value != dst.heating.minTemp && value >= vars.slave.heating.minTemp && value < vars.slave.heating.maxTemp && value != dst.heating.minTemp) {
       dst.heating.minTemp = value;
       changed = true;
     }
@@ -1334,7 +1343,7 @@ bool jsonToSettings(const JsonVariantConst src, Settings& dst, bool safe = false
   if (!src[FPSTR(S_HEATING)][FPSTR(S_MAX_TEMP)].isNull()) {
     unsigned char value = src[FPSTR(S_HEATING)][FPSTR(S_MAX_TEMP)].as<unsigned char>();
 
-    if (value != dst.heating.maxTemp && value > vars.slave.heating.minTemp && value <= vars.slave.heating.maxTemp && value != dst.heating.minTemp) {
+    if (value != dst.heating.maxTemp && value > vars.slave.heating.minTemp && value <= vars.slave.heating.maxTemp && value != dst.heating.maxTemp) {
       dst.heating.maxTemp = value;
       changed = true;
     }
@@ -1493,15 +1502,6 @@ bool jsonToSettings(const JsonVariantConst src, Settings& dst, bool safe = false
       }
     }
 
-    if (src[FPSTR(S_EXTERNAL_PUMP)][FPSTR(S_INVERT_STATE)].is<bool>()) {
-      bool value = src[FPSTR(S_EXTERNAL_PUMP)][FPSTR(S_INVERT_STATE)].as<bool>();
-
-      if (value != dst.externalPump.invertState) {
-        dst.externalPump.invertState = value;
-        changed = true;
-      }
-    }
-
     if (!src[FPSTR(S_EXTERNAL_PUMP)][FPSTR(S_POST_CIRCULATION_TIME)].isNull()) {
       unsigned short value = src[FPSTR(S_EXTERNAL_PUMP)][FPSTR(S_POST_CIRCULATION_TIME)].as<unsigned short>();
 
@@ -1904,7 +1904,7 @@ bool jsonToSensorSettings(const uint8_t sensorId, const JsonVariantConst src, Se
 
   // gpio
   if (!src[FPSTR(S_GPIO)].isNull()) {
-    if (dst.type != Sensors::Type::DALLAS_TEMP && dst.type != Sensors::Type::NTC_10K_TEMP) {
+    if (dst.type != Sensors::Type::DALLAS_TEMP && dst.type == Sensors::Type::BLUETOOTH && dst.type == Sensors::Type::NTC_10K_TEMP) {
       if (dst.gpio != GPIO_IS_NOT_CONFIGURED) {
         dst.gpio = GPIO_IS_NOT_CONFIGURED;
         changed = true;
@@ -1940,20 +1940,12 @@ bool jsonToSensorSettings(const uint8_t sensorId, const JsonVariantConst src, Se
       );
 
       if (parsed == 8) {
-        for (uint8_t i = 0; i < parsed; i++) {
+        for (uint8_t i = 0; i < 8; i++) {
           if (dst.address[i] != tmp[i]) {
             dst.address[i] = tmp[i];
             changed = true;
           }
         }
-
-      } else {
-        // reset
-        for (uint8_t i = 0; i < sizeof(dst.address); i++) {
-          dst.address[i] = 0x00;
-        }
-
-        changed = true;
       }
 
     } else if (dst.type == Sensors::Type::BLUETOOTH) {
@@ -1966,20 +1958,12 @@ bool jsonToSensorSettings(const uint8_t sensorId, const JsonVariantConst src, Se
       );
 
       if (parsed == 6) {
-        for (uint8_t i = 0; i < parsed; i++) {
+        for (uint8_t i = 0; i < 6; i++) {
           if (dst.address[i] != tmp[i]) {
             dst.address[i] = tmp[i];
             changed = true;
           }
         }
-
-      } else {
-        // reset
-        for (uint8_t i = 0; i < sizeof(dst.address); i++) {
-          dst.address[i] = 0x00;
-        }
-        
-        changed = true;
       }
     }
   }
@@ -2086,10 +2070,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 sCooling = slave[FPSTR(S_COOLING)].to<JsonObject>();
-  sCooling[FPSTR(S_ACTIVE)] = src.slave.cooling.active;
-  sCooling[FPSTR(S_SETPOINT)] = src.slave.cooling.setpoint;
 
   auto sModulation = slave[FPSTR(S_MODULATION)].to<JsonObject>();
   sModulation[FPSTR(S_MIN)] = src.slave.modulation.min;

src_data/locales/cn.json

@@ -109,8 +109,7 @@
 
         "sConnected": "OpenTherm 通讯状态",
         "sFlame": "火焰",
-        "sCoolingActive": "制冷",
+        "sCooling": "制冷",
-        "sCoolingSetpoint": "冷却设定点",
         "sFaultActive": "报警状态",
         "sFaultCode": "报警代码",
         "sDiagActive": "诊断状态",
@@ -455,7 +454,6 @@
       "extPump": {
         "use": "使用外置循环泵",
         "gpio": "继电器 GPIO引脚",
-        "invertState": "切换 GPIO 状态",
         "postCirculationTime": "后循环时间 <small>(分钟)</small>",
         "antiStuckInterval": "防卡死间隔时间<small>(天)</small>",
         "antiStuckTime": "防卡死运行时长<small>(分钟)</small>"

src_data/locales/en.json

@@ -109,8 +109,7 @@
 
         "sConnected": "OpenTherm connection",
         "sFlame": "Flame",
-        "sCoolingActive": "Cooling",
+        "sCooling": "Cooling",
-        "sCoolingSetpoint": "Cooling setpoint",
         "sFaultActive": "Fault",
         "sFaultCode": "Fault code",
         "sDiagActive": "Diagnostic",
@@ -371,11 +370,26 @@
       },
 
       "equitherm": {
-        "n": "N factor",
+        "slope": {
-        "k": "K factor",
+          "title": "Slope",
-        "t": {
+          "note": "Heat loss compensation. Main tuning parameter."
+        },
+        "exponent": {
+          "title": "Exponent",
+          "note": "Radiator efficiency.  Typical values: 1.1 - Floor heating, 1.2 - Cast iron, 1.3 - Panel radiators, 1.4 - Convectors."
+        },
+        "shift": {
+          "title": "Shift",
+          "note": "Compensates for additional heat losses (e.g., in pipes) or extra heat sources."
+        },
+        "targetDiffFactor": {
           "title": "T factor",
           "note": "Not used if PID is enabled"
+        },
+        "chart": {
+          "targetTemp": "Target indoor temperature",
+          "setpointTemp": "Heat carrier temperature",
+          "outdoorTemp": "Outdoor temperature"
         }
       },
 
@@ -455,7 +469,6 @@
       "extPump": {
         "use": "Use external pump",
         "gpio": "Relay GPIO",
-        "invertState": "Invert GPIO state",
         "postCirculationTime": "Post circulation time <small>(min)</small>",
         "antiStuckInterval": "Anti stuck interval <small>(days)</small>",
         "antiStuckTime": "Anti stuck time <small>(min)</small>"

src_data/locales/it.json

@@ -109,8 +109,7 @@
 
         "sConnected": "Connessione OpenTherm",
         "sFlame": "Fiamma",
-        "sCoolingActive": "Raffrescamento",
+        "sCooling": "Raffrescamento",
-        "sCoolingSetpoint": "Raffrescamento setpoint",
         "sFaultActive": "Anomalia",
         "sFaultCode": "Codice anomalia",
         "sDiagActive": "Diagnostica",
@@ -371,11 +370,26 @@
       },
 
       "equitherm": {
-        "n": "Fattore N",
+        "slope": {
-        "k": "Fattore K",
+          "title": "Pendenza",
-        "t": {
+          "note": "Compensazione delle perdite di calore. Principale parametro di regolazione."
+        },
+        "exponent": {
+          "title": "Esponente",
+          "note": "Efficienza del radiatore. Valori tipici: 1.1 - Riscaldamento a pavimento, 1.2 - Radiatori in ghisa, 1.3 - Radiatori a pannelli, 1.4 - Convetttori."
+        },
+        "shift": {
+          "title": "Spostare",
+          "note": "Compensa le perdite di calore aggiuntive (ad esempio, nelle tubature) o fonti di calore extra."
+        },
+        "targetDiffFactor": {
           "title": "Fattore T",
           "note": "Non usato se PID è attivato"
+        },
+        "chart": {
+          "targetTemp": "Temperatura interna target",
+          "setpointTemp": "Temperatura del portatore di calore",
+          "outdoorTemp": "Temperatura esterna"
         }
       },
 
@@ -455,7 +469,6 @@
       "extPump": {
         "use": "Usa pompa/circolatore esterno",
         "gpio": "GPIO relè",
-        "invertState": "Inverti stato GPIO",
         "postCirculationTime": "Tempo di post circolazione <small>(min)</small>",
         "antiStuckInterval": "Intervallo antiblocco <small>(days)</small>",
         "antiStuckTime": "Tempo antiblocco <small>(min)</small>"

src_data/locales/nl.json

@@ -1,466 +0,0 @@
-{
-  "values": {
-    "logo": "OpenTherm Gateway",
-    "nav": {
-      "license": "Licentie",
-      "source": "Broncode",
-      "help": "Help",
-      "issues": "Problemen & vragen",
-      "releases": "Releases"
-    },
-    "dbm": "dBm",
-    "kw": "kW",
-    "time": {
-      "days": "d.",
-      "hours": "u.",
-      "min": "min.",
-      "sec": "sec."
-    },
-    "button": {
-      "upgrade": "Upgraden",
-      "restart": "Herstarten",
-      "save": "Opslaan",
-      "saved": "Opgeslagen",
-      "refresh": "Vernieuwen",
-      "restore": "Herstellen",
-      "restored": "Hersteld",
-      "backup": "Back-up",
-      "wait": "Even wachten...",
-      "uploading": "Uploaden...",
-      "success": "Succes",
-      "error": "Fout"
-    },
-    "index": {
-      "title": "OpenTherm Gateway",
-      "section": {
-        "network": "Netwerk",
-        "system": "Systeem"
-      },
-      "system": {
-        "build": {
-          "title": "Build",
-          "version": "Versie",
-          "date": "Datum",
-          "core": "Core",
-          "sdk": "SDK"
-        },
-        "uptime": "Uptime",
-        "memory": {
-          "title": "Vrij geheugen",
-          "maxFreeBlock": "max. vrij blok",
-          "min": "min"
-        },
-        "board": "Board",
-        "chip": {
-          "model": "Chip",
-          "cores": "Kernen",
-          "freq": "frequentie"
-        },
-        "flash": {
-          "size": "Flash-grootte",
-          "realSize": "werkelijke grootte"
-        },
-        "lastResetReason": "Reden laatste herstart"
-      }
-    },
-    "dashboard": {
-      "name": "Dashboard",
-      "title": "Dashboard - OpenTherm Gateway",
-      "section": {
-        "control": "Bediening",
-        "states": "Statussen",
-        "sensors": "Sensoren",
-        "diag": "OpenTherm diagnose"
-      },
-      "thermostat": {
-        "heating": "Verwarming",
-        "dhw": "Warm water",
-        "temp.current": "Huidig",
-        "enable": "Inschakelen",
-        "turbo": "Turbomodus"
-      },
-      "notify": {
-        "fault": {
-          "title": "Ketelstoring is actief!",
-          "note": "Het wordt aanbevolen de ketel te inspecteren en de documentatie te raadplegen om de storingscode te interpreteren:"
-        },
-        "diag": {
-          "title": "Keteldiagnose is actief!",
-          "note": "Heeft uw ketel misschien een inspectie nodig? Het wordt aanbevolen de documentatie te raadplegen om de diagnosecode te interpreteren:"
-        },
-        "reset": "Probeer te resetten"
-      },
-      "states": {
-        "mNetworkConnected": "Netwerkverbinding",
-        "mMqttConnected": "MQTT-verbinding",
-        "mEmergencyState": "Noodmodus",
-        "mExtPumpState": "Externe pomp",
-        "mCascadeControlInput": "Cascaderegeling (ingang)",
-        "mCascadeControlOutput": "Cascaderegeling (uitgang)",
-        "sConnected": "OpenTherm-verbinding",
-        "sFlame": "Vlam",
-        "sCoolingActive": "Koeling",
-        "sCoolingSetpoint": "Koelinstelpunt",
-        "sFaultActive": "Storing",
-        "sFaultCode": "Storingscode",
-        "sDiagActive": "Diagnose",
-        "sDiagCode": "Diagnosecode",
-        "mHeatEnabled": "Verwarming ingeschakeld",
-        "mHeatBlocking": "Verwarming geblokkeerd",
-        "mHeatOverheat": "Verwarming oververhit",
-        "sHeatActive": "Verwarming actief",
-        "mHeatSetpointTemp": "Insteltemperatuur verwarming",
-        "mHeatTargetTemp": "Doeltemperatuur verwarming",
-        "mHeatCurrTemp": "Huidige temperatuur verwarming",
-        "mHeatRetTemp": "Retourtemperatuur verwarming",
-        "mHeatIndoorTemp": "Verwarming, binnentemperatuur",
-        "mHeatOutdoorTemp": "Verwarming, buitentemperatuur",
-        "mDhwEnabled": "Warm water ingeschakeld",
-        "mDhwOverheat": "Warm water oververhit",
-        "sDhwActive": "Warm water actief",
-        "mDhwTargetTemp": "Doeltemperatuur warm water",
-        "mDhwCurrTemp": "Huidige temperatuur warm water",
-        "mDhwRetTemp": "Retourtemperatuur warm water"
-      },
-      "sensors": {
-        "values": {
-          "temp": "Temperatuur",
-          "humidity": "Luchtvochtigheid",
-          "battery": "Batterij",
-          "rssi": "RSSI"
-        }
-      }
-    },
-    "network": {
-      "title": "Netwerk - OpenTherm Gateway",
-      "name": "Netwerkinstellingen",
-      "section": {
-        "static": "Statische instellingen",
-        "availableNetworks": "Beschikbare netwerken",
-        "staSettings": "WiFi-instellingen",
-        "apSettings": "AP-instellingen"
-      },
-      "scan": {
-        "pos": "#",
-        "info": "Info"
-      },
-      "wifi": {
-        "ssid": "SSID",
-        "password": "Wachtwoord",
-        "channel": "Kanaal",
-        "signal": "Signaal",
-        "connected": "Verbonden"
-      },
-      "params": {
-        "hostname": "Hostnaam",
-        "dhcp": "Gebruik DHCP",
-        "mac": "MAC",
-        "ip": "IP",
-        "subnet": "Subnet",
-        "gateway": "Gateway",
-        "dns": "DNS"
-      },
-      "sta": {
-        "channel.note": "zet op 0 voor automatische selectie"
-      }
-    },
-    "sensors": {
-      "title": "Sensorinstellingen - OpenTherm Gateway",
-      "name": "Sensorinstellingen",
-      "enabled": "Ingeschakeld",
-      "sensorName": {
-        "title": "Sensornaam",
-        "note": "Mag alleen bevatten: a-z, A-Z, 0-9, _ en spatie"
-      },
-      "purpose": "Doel",
-      "purposes": {
-        "outdoorTemp": "Buitentemperatuur",
-        "indoorTemp": "Binnentemperatuur",
-        "heatTemp": "Verwarming, temperatuur",
-        "heatRetTemp": "Verwarming, retourtemperatuur",
-        "dhwTemp": "Warm water, temperatuur",
-        "dhwRetTemp": "Warm water, retourtemperatuur",
-        "dhwFlowRate": "Warm water, doorstroomsnelheid",
-        "exhaustTemp": "Rookgastemperatuur",
-        "modLevel": "Modulatieniveau (in procenten)",
-        "number": "Getal (ruw)",
-        "powerFactor": "Vermogen (in procent)",
-        "power": "Vermogen (in kWt)",
-        "fanSpeed": "Ventilatorsnelheid",
-        "co2": "CO2",
-        "pressure": "Druk",
-        "humidity": "Luchtvochtigheid",
-        "temperature": "Temperatuur",
-        "notConfigured": "Niet geconfigureerd"
-      },
-      "type": "Type/bron",
-      "types": {
-        "otOutdoorTemp": "OpenTherm, buitentemp.",
-        "otHeatTemp": "OpenTherm, verwarming, temp.",
-        "otHeatRetTemp": "OpenTherm, verwarming, retourtemp.",
-        "otDhwTemp": "OpenTherm, warm water, temperatuur",
-        "otDhwTemp2": "OpenTherm, warm water, temperatuur 2",
-        "otDhwFlowRate": "OpenTherm, warm water, doorstroomsnelheid",
-        "otCh2Temp": "OpenTherm, kanaal 2, temp.",
-        "otExhaustTemp": "OpenTherm, rookgastemp.",
-        "otHeatExchangerTemp": "OpenTherm, warmtewisselaar temp.",
-        "otPressure": "OpenTherm, druk",
-        "otModLevel": "OpenTherm, modulatieniveau",
-        "otCurrentPower": "OpenTherm, huidig vermogen",
-        "otExhaustCo2": "OpenTherm, rookgas CO2",
-        "otExhaustFanSpeed": "OpenTherm, rookgasventilator snelheid",
-        "otSupplyFanSpeed": "OpenTherm, toevoerventilator snelheid",
-        "otSolarStorageTemp": "OpenTherm, zonneboiler opslagtemp.",
-        "otSolarCollectorTemp": "OpenTherm, zonnecollector temp.",
-        "otFanSpeedSetpoint": "OpenTherm, instelpunt ventilatorsnelheid",
-        "otFanSpeedCurrent": "OpenTherm, huidige ventilatorsnelheid",
-        "otBurnerStarts": "OpenTherm, aantal branderstarts",
-        "otDhwBurnerStarts": "OpenTherm, aantal branderstarts (warm water)",
-        "otHeatingPumpStarts": "OpenTherm, aantal pompstarts (verwarming)",
-        "otDhwPumpStarts": "OpenTherm, aantal pompstarts (warm water)",
-        "otBurnerHours": "OpenTherm, aantal branderuren",
-        "otDhwBurnerHours": "OpenTherm, aantal branderuren (warm water)",
-        "otHeatingPumpHours": "OpenTherm, aantal pompuren (verwarming)",
-        "otDhwPumpHours": "OpenTherm, aantal pompuren (warm water)",
-        "ntcTemp": "NTC-sensor",
-        "dallasTemp": "DALLAS-sensor",
-        "bluetooth": "BLE-sensor",
-        "heatSetpointTemp": "Verwarming, insteltemperatuur",
-        "manual": "Handmatig via MQTT/API",
-        "notConfigured": "Niet geconfigureerd"
-      },
-      "gpio": "GPIO",
-      "address": {
-        "title": "Sensoradres",
-        "note": "Laat leeg voor automatische detectie van DALLAS-sensoren. Voor BLE-apparaten is een MAC-adres vereist."
-      },
-      "correction": {
-        "desc": "Correctie van waarden",
-        "offset": "Compensatie (offset)",
-        "factor": "Vermenigvuldiger"
-      },
-      "filtering": {
-        "desc": "Filteren van waarden",
-        "enabled": {
-          "title": "Filteren ingeschakeld",
-          "note": "Kan handig zijn bij veel scherpe ruis in de grafieken. Het gebruikte filter is \"Voortschrijdend gemiddelde\"."
-        },
-        "factor": {
-          "title": "Filterfactor",
-          "note": "Hoe lager de waarde, hoe vloeiender en <u>langer</u> de verandering in numerieke waarden."
-        }
-      }
-    },
-    "settings": {
-      "title": "Instellingen - OpenTherm Gateway",
-      "name": "Instellingen",
-      "section": {
-        "portal": "Portaalinstellingen",
-        "system": "Systeeminstellingen",
-        "diag": "Diagnose",
-        "heating": "Verwarmingsinstellingen",
-        "dhw": "Warmwaterinstellingen",
-        "emergency": "Instellingen noodmodus",
-        "equitherm": "Equitherm-instellingen",
-        "pid": "PID-instellingen",
-        "ot": "OpenTherm-instellingen",
-        "mqtt": "MQTT-instellingen",
-        "extPump": "Instellingen externe pomp",
-        "cascadeControl": "Instellingen cascaderegeling"
-      },
-      "enable": "Inschakelen",
-      "note": {
-        "restart": "Na het wijzigen van deze instellingen moet het apparaat opnieuw worden opgestart om de wijzigingen door te voeren.",
-        "blankNotUse": "leeg - niet gebruiken",
-        "bleDevice": "BLE-apparaat kan <u>alleen</u> worden gebruikt met sommige ESP32-boards met BLE-ondersteuning!"
-      },
-      "temp": {
-        "min": "Minimumtemperatuur",
-        "max": "Maximumtemperatuur"
-      },
-      "maxModulation": "Max. modulatieniveau",
-      "ohProtection": {
-        "title": "Oververhittingsbeveiliging",
-        "desc": "<b>Let op:</b> Deze functie kan handig zijn als de ingebouwde oververhittingsbeveiliging van de ketel niet of niet correct werkt en de warmtedrager kookt. Om uit te schakelen, stel 0 in als <b>hoge</b> en <b>lage</b> temperatuur.",
-        "highTemp": {
-          "title": "Drempelwaarde hoge temperatuur",
-          "note": "Drempelwaarde waarbij de brander geforceerd wordt uitgeschakeld"
-        },
-        "lowTemp": {
-          "title": "Drempelwaarde lage temperatuur",
-          "note": "Drempelwaarde waarbij de brander weer ingeschakeld kan worden"
-        }
-      },
-      "freezeProtection": {
-        "title": "Vorstbeveiliging",
-        "desc": "De verwarming wordt geforceerd ingeschakeld als de temperatuur van de warmtedrager of de binnentemperatuur onder de <b>Lage temperatuur</b> daalt gedurende de <b>Wachttijd</b>.",
-        "lowTemp": "Drempelwaarde lage temperatuur",
-        "thresholdTime": "Wachttijd <small>(sec)</small>"
-      },
-      "portal": {
-        "login": "Gebruikersnaam",
-        "password": "Wachtwoord",
-        "auth": "Authenticatie vereisen",
-        "mdns": "Gebruik mDNS"
-      },
-      "system": {
-        "unit": "Eenheidssysteem",
-        "metric": "Metrisch <small>(celsius, liters, bar)</small>",
-        "imperial": "Imperiaal <small>(fahrenheit, gallons, psi)</small>",
-        "statusLedGpio": "Status LED GPIO",
-        "logLevel": "Logniveau",
-        "serial": {
-          "enable": "Seriële poort ingeschakeld",
-          "baud": "Baudrate seriële poort"
-        },
-        "telnet": {
-          "enable": "Telnet ingeschakeld",
-          "port": {
-            "title": "Telnet-poort",
-            "note": "Standaard: 23"
-          }
-        },
-        "ntp": {
-          "server": "NTP-server",
-          "timezone": "Tijdzone",
-          "timezonePresets": "Selecteer voorinstelling..."
-        }
-      },
-      "heating": {
-        "hyst": "Hysterese <small>(in graden)</small>",
-        "turboFactor": "Turbomodus coëff."
-      },
-      "emergency": {
-        "desc": "Noodmodus wordt automatisch geactiveerd wanneer «PID» of «Equitherm» het instelpunt van de warmtedrager niet kan berekenen:<br />- als «Equitherm» is ingeschakeld en de buitentemperatuursensor is losgekoppeld;<br />- als «PID» of OT-optie <i>«Natuurlijke verwarmingsregeling»</i> is ingeschakeld en de binnentemperatuursensor is losgekoppeld.<br /><b>Let op:</b> Bij een netwerk- of MQTT-storing krijgen sensoren van het type <i>«Handmatig via MQTT/API»</i> de status ONVERBONDEN.",
-        "target": {
-          "title": "Doeltemperatuur",
-          "note": "<b>Belangrijk:</b> <u>Doel binnentemperatuur</u> als OT-optie <i>«Natuurlijke verwarmingsregeling»</i> is ingeschakeld.<br />In alle andere gevallen, de <u>doel warmtedragertemperatuur</u>."
-        },
-        "treshold": "Drempeltijd <small>(sec)</small>"
-      },
-      "equitherm": {
-        "n": "N-factor",
-        "k": "K-factor",
-        "t": {
-          "title": "T-factor",
-          "note": "Niet gebruikt als PID is ingeschakeld"
-        }
-      },
-      "pid": {
-        "p": "P-factor",
-        "i": "I-factor",
-        "d": "D-factor",
-        "dt": "DT <small>in seconden</small>",
-        "limits": {
-          "title": "Limieten",
-          "note": "<b>Belangrijk:</b> Bij gelijktijdig gebruik van «Equitherm» en «PID» beperken de min- en maxtemperaturen de invloed op de resulterende «Equitherm»-temperatuur.<br />Dus, als de min-temperatuur is ingesteld op -15 en de max-temperatuur op 15, zal het uiteindelijke instelpunt van de warmtedrager liggen tussen <code>equitherm_resultaat - 15</code> en <code>equitherm_resultaat + 15</code>."
-        },
-        "deadband": {
-          "title": "Deadband",
-          "note": "Deadband is een bereik rond de doeltemperatuur waarbinnen de PID-regeling minder actief wordt. Binnen dit bereik kan het algoritme de intensiteit verminderen of aanpassingen pauzeren om overreactie op kleine schommelingen te voorkomen.<br /><br />Bijvoorbeeld, met een doeltemperatuur van 22°, een onderdrempel van 1.0 en een bovendrempel van 0.5, werkt de deadband tussen 21° en 22.5°. Als de I-coëfficiënt 0.0005 is en de I-vermenigvuldiger 0.05, dan wordt de I-coëfficiënt binnen de deadband: <code>0.0005 * 0.05 = 0.000025</code>",
-          "p_multiplier": "Vermenigvuldiger voor P-factor",
-          "i_multiplier": "Vermenigvuldiger voor I-factor",
-          "d_multiplier": "Vermenigvuldiger voor D-factor",
-          "thresholdHigh": "Bovendrempel",
-          "thresholdLow": "Onderdrempel"
-        }
-      },
-      "ot": {
-        "advanced": "Geavanceerde instellingen",
-        "inGpio": "In GPIO",
-        "outGpio": "Uit GPIO",
-        "ledGpio": "RX LED GPIO",
-        "memberId": "Master member ID",
-        "flags": "Master flags",
-        "minPower": {
-          "title": "Min. ketelvermogen <small>(kW)</small>",
-          "note": "Deze waarde is bij 0-1% modulatieniveau van de ketel. Typisch te vinden in de ketelspecificatie als \"minimum nuttig warmtevermogen\"."
-        },
-        "maxPower": {
-          "title": "Max. ketelvermogen <small>(kW)</small>",
-          "note": "<b>0</b> - probeer automatisch te detecteren. Typisch te vinden in de ketelspecificatie als \"maximum nuttig warmtevermogen\"."
-        },
-        "options": {
-          "title": "Opties (aanvullende instellingen)",
-          "desc": "Opties kunnen de logica van de ketel veranderen. Niet alle opties zijn gedocumenteerd in het protocol, dus dezelfde optie kan verschillende effecten hebben op verschillende ketels.<br /><b>Let op:</b> Het is niet nodig om iets te veranderen als alles goed werkt.",
-          "dhwSupport": "Warm water ondersteuning",
-          "coolingSupport": "Koeling ondersteuning",
-          "summerWinterMode": "Zomer/wintermodus",
-          "heatingStateToSummerWinterMode": "Verwarmingsstatus als zomer/wintermodus",
-          "ch2AlwaysEnabled": "CH2 altijd ingeschakeld",
-          "heatingToCh2": "Dupliceer verwarming naar CH2",
-          "dhwToCh2": "Dupliceer warm water naar CH2",
-          "dhwBlocking": "Blokkering warm water",
-          "dhwStateAsDhwBlocking": "Status warm water als blokkering warm water",
-          "maxTempSyncWithTargetTemp": "Synchroniseer max. verwarmingstemp. met doeltemp.",
-          "getMinMaxTemp": "Haal min/max temp. op van ketel",
-          "ignoreDiagState": "Negeer diagnosestatus",
-          "autoFaultReset": "Automatische storingsreset <small>(niet aanbevolen!)</small>",
-          "autoDiagReset": "Automatische diagnosereset <small>(niet aanbevolen!)</small>",
-          "setDateAndTime": "Stel datum & tijd in op ketel",
-          "immergasFix": "Fix voor Immergas-ketels"
-        },
-        "nativeHeating": {
-          "title": "Natuurlijke verwarmingsregeling (ketel)",
-          "note": "Werkt <u>ALLEEN</u> als de ketel de gewenste kamertemperatuur vereist en zelf de temperatuur van de warmtedrager regelt. Niet compatibel met PID- en Equitherm-regelaars in de firmware."
-        }
-      },
-      "mqtt": {
-        "homeAssistantDiscovery": "Home Assistant Discovery",
-        "server": "Server",
-        "port": "Poort",
-        "user": "Gebruiker",
-        "password": "Wachtwoord",
-        "prefix": "Prefix",
-        "interval": "Publicatie-interval <small>(sec)</small>"
-      },
-      "extPump": {
-        "use": "Gebruik externe pomp",
-        "gpio": "Relais GPIO",
-        "invertState": "Inverteer GPIO-status",
-        "postCirculationTime": "Nacirculatietijd <small>(min)</small>",
-        "antiStuckInterval": "Anti-vastloopinterval <small>(dagen)</small>",
-        "antiStuckTime": "Anti-vastlooptijd <small>(min)</small>"
-      },
-      "cascadeControl": {
-        "input": {
-          "desc": "Kan worden gebruikt om de verwarming alleen in te schakelen als een andere ketel defect is. De besturing van de andere ketel moet de status van de GPIO-ingang wijzigen in geval van een storing.",
-          "enable": "Ingang ingeschakeld",
-          "gpio": "GPIO",
-          "invertState": "Inverteer GPIO-status",
-          "thresholdTime": "Drempeltijd statuswijziging <small>(sec)</small>"
-        },
-        "output": {
-          "desc": "Kan worden gebruikt om een andere ketel in te schakelen <u>via een relais</u>.",
-          "enable": "Uitgang ingeschakeld",
-          "gpio": "GPIO",
-          "invertState": "Inverteer GPIO-status",
-          "thresholdTime": "Drempeltijd statuswijziging <small>(sec)</small>",
-          "events": {
-            "desc": "Gebeurtenissen",
-            "onFault": "Als de storingsstatus actief is",
-            "onLossConnection": "Als de verbinding via Opentherm is verbroken",
-            "onEnabledHeating": "Als de verwarming is ingeschakeld"
-          }
-        }
-      }
-    },
-    "upgrade": {
-      "title": "Upgrade - OpenTherm Gateway",
-      "name": "Upgrade",
-      "section": {
-        "backupAndRestore": "Back-up & herstel",
-        "backupAndRestore.desc": "In deze sectie kunt u een back-up van ALLE instellingen opslaan en herstellen.",
-        "upgrade": "Upgrade",
-        "upgrade.desc": "In deze sectie kunt u de firmware en het bestandssysteem van uw apparaat upgraden.<br />De nieuwste releases kunnen worden gedownload van de <a href=\"https://github.com/Laxilef/OTGateway/releases\" target=\"_blank\">Releases-pagina</a> van de projectrepository."
-      },
-      "note": {
-        "disclaimer1": "Na een succesvolle upgrade van het bestandssysteem worden ALLE instellingen teruggezet naar de standaardwaarden! Sla een back-up op voordat u gaat upgraden.",
-        "disclaimer2": "Na een succesvolle upgrade zal het apparaat automatisch herstarten na 15 seconden."
-      },
-      "settingsFile": "Instellingenbestand",
-      "fw": "Firmware",
-      "fs": "Bestandssysteem"
-    }
-  }
-}

src_data/locales/ru.json

@@ -109,8 +109,7 @@
 
         "sConnected": "Подключение к OpenTherm",
         "sFlame": "Пламя",
-        "sCoolingActive": "Охлаждение",
+        "sCooling": "Охлаждение",
-        "sCoolingSetpoint": "Охлаждение, уставка",
         "sFaultActive": "Ошибка",
         "sFaultCode": "Код ошибки",
         "sDiagActive": "Диагностика",
@@ -371,11 +370,26 @@
       },
 
       "equitherm": {
-        "n": "Коэффициент N",
+        "slope": {
-        "k": "Коэффициент K",
+          "title": "Наклон",
-        "t": {
+          "note": "Компенсация теплопотерь. Основной параметр настройки."
+        },
+        "exponent": {
+          "title": "Экспонента",
+          "note": "Эффективность радиатора. Типичные значения: 1.1 - Тёплый пол, 1.2 - Чугунные радиаторы, 1.3 - Панельные радиаторы, 1.4 - Конвекторы."
+        },
+        "shift": {
+          "title": "Смещение",
+          "note": "Компенсирует дополнительные теплопотери (например, в трубах) или дополнительные источники тепла."
+        },
+        "targetDiffFactor": {
           "title": "Коэффициент T",
           "note": "Не используется, если ПИД включен"
+        },
+        "chart": {
+          "targetTemp": "Целевая внутренняя температура",
+          "setpointTemp": "Температура теплоносителя",
+          "outdoorTemp": "Наружная температура"
         }
       },
 
@@ -455,7 +469,6 @@
       "extPump": {
         "use": "Использовать доп. насос",
         "gpio": "GPIO реле",
-        "invertState": "Инвертировать состояние GPIO",
         "postCirculationTime": "Время постциркуляции <small>(в минутах)</small>",
         "antiStuckInterval": "Интервал защиты от блокировки <small>(в днях)</small>",
         "antiStuckTime": "Время работы насоса <small>(в минутах)</small>"

src_data/pages/dashboard.html

@@ -23,7 +23,6 @@
               <option value="en" selected>EN</option>
               <option value="cn">CN</option>
               <option value="it">IT</option>
-              <option value="nl">NL</option>
               <option value="ru">RU</option>
             </select>
           </li>
@@ -154,14 +153,9 @@
                   <th scope="row" data-i18n>dashboard.states.sFlame</th>
                   <td><i class="sFlame"></i></td>
                 </tr>
-
                 <tr>
-                  <th scope="row" data-i18n>dashboard.states.sCoolingActive</th>
+                  <th scope="row" data-i18n>dashboard.states.sCooling</th>
-                  <td><i class="sCoolingActive"></i></td>
+                  <td><i class="sCooling"></i></td>
-                </tr>
-                <tr>
-                  <th scope="row" data-i18n>dashboard.states.sCoolingSetpoint</th>
-                  <td><b class="sCoolingSetpoint"></b> %</td>
                 </tr>
 
 
@@ -563,9 +557,7 @@
               result.slave.connected ? "green" : "red"
             );
             setState('.sFlame', result.slave.flame);
-
+            setState('.sCooling', result.slave.cooling);
-            setState('.sCoolingActive', result.slave.cooling.active);
-            setValue('.sCoolingSetpoint', result.slave.cooling.setpoint);
 
             setValue('.sModMin', result.slave.modulation.min);
             setValue('.sModMax', result.slave.modulation.max);

src_data/pages/index.html

@@ -23,7 +23,6 @@
               <option value="en" selected>EN</option>
               <option value="cn">CN</option>
               <option value="it">IT</option>
-              <option value="nl">NL</option>
               <option value="ru">RU</option>
             </select>
           </li>

src_data/pages/network.html

@@ -23,7 +23,6 @@
               <option value="en" selected>EN</option>
               <option value="cn">CN</option>
               <option value="it">IT</option>
-              <option value="nl">NL</option>
               <option value="ru">RU</option>
             </select>
           </li>

src_data/pages/sensors.html

@@ -23,7 +23,6 @@
               <option value="en" selected>EN</option>
               <option value="cn">CN</option>
               <option value="it">IT</option>
-              <option value="nl">NL</option>
               <option value="ru">RU</option>
             </select>
           </li>
@@ -241,7 +240,9 @@
               setCheckboxValue("[name='filtering']", data.filtering, sensorForm);
               setInputValue("[name='filteringFactor']", data.filteringFactor, {}, sensorForm);
 
-              sensorForm.querySelector("[name='type']").dispatchEvent(new Event("change"));
+              setTimeout(() => {
+                sensorForm.querySelector("[name='type']").dispatchEvent(new Event("change"));
+              }, 10);
 
               setBusy(".form-busy", "form", false, sensorNode);
             };

src_data/pages/settings.html

@@ -23,7 +23,6 @@
               <option value="en" selected>EN</option>
               <option value="cn">CN</option>
               <option value="it">IT</option>
-              <option value="nl">NL</option>
               <option value="ru">RU</option>
             </select>
           </li>
@@ -341,7 +340,7 @@
         </details>
 
         <hr />
-
+        
         <details>
           <summary><b data-i18n>settings.section.equitherm</b></summary>
           <div>
@@ -354,21 +353,44 @@
                 </label>
               </fieldset>
 
+              <div>
+                <div>
+                  <canvas id="etChart"></canvas>
+                </div>
+
+                <label>
+                  <div>
+                    <span data-i18n>settings.equitherm.chart.targetTemp</span>: <b class="etChartTargetTempValue"></b>°
+                  </div>
+                  <input class="etChartTargetTemp" type="range" value="0" min="0" max="0" step="0.5">
+                </label>
+              </div>
+              
               <div class="grid">
                 <label>
-                  <span data-i18n>settings.equitherm.n</span>
+                  <span data-i18n>settings.equitherm.slope.title</span>
-                  <input type="number" inputmode="decimal" name="equitherm[n_factor]" min="0.001" max="10" step="0.001" required>
+                  <input type="number" inputmode="decimal" name="equitherm[slope]" min="0.001" max="10" step="0.001" required>
+                  <small data-i18n>settings.equitherm.slope.note</small>
                 </label>
 
                 <label>
-                  <span data-i18n>settings.equitherm.k</span>
+                  <span data-i18n>settings.equitherm.exponent.title</span>
-                  <input type="number" inputmode="decimal" name="equitherm[k_factor]" min="0" max="10" step="0.01" required>
+                  <input type="number" inputmode="decimal" name="equitherm[exponent]" min="0.1" max="2" step="0.001" required>
+                  <small data-i18n>settings.equitherm.exponent.note</small>
+                </label>
+              </div>
+
+              <div class="grid">
+                <label>
+                  <span data-i18n>settings.equitherm.shift.title</span>
+                  <input type="number" inputmode="decimal" name="equitherm[shift]" min="-15" max="15" step="0.01" required>
+                  <small data-i18n>settings.equitherm.shift.note</small>
                 </label>
 
                 <label>
-                  <span data-i18n>settings.equitherm.t.title</span>
+                  <span data-i18n>settings.equitherm.targetDiffFactor.title</span>
-                  <input type="number" inputmode="decimal" name="equitherm[t_factor]" min="0" max="10" step="0.01" required>
+                  <input type="number" inputmode="decimal" name="equitherm[targetDiffFactor]" min="0" max="10" step="0.01" required>
-                  <small data-i18n>settings.equitherm.t.note</small>
+                  <small data-i18n>settings.equitherm.targetDiffFactor.note</small>
                 </label>
               </div>
 
@@ -378,7 +400,7 @@
         </details>
 
         <hr />
-
+        
         <details>
           <summary><b data-i18n>settings.section.pid</b></summary>
           <div>
@@ -731,11 +753,6 @@
                   <input type="checkbox" name="externalPump[use]" value="true">
                   <span data-i18n>settings.extPump.use</span>
                 </label>
-
-                <label>
-                  <input type="checkbox" name="externalPump[invertState]" value="true">
-                  <span data-i18n>settings.externalPump.invertState</span>
-                </label>
               </fieldset>
 
               <div class="grid">
@@ -866,11 +883,163 @@
     </footer>
 
     <script src="/static/app.js?{BUILD_TIME}"></script>
+    <script src="/static/chart.js?{BUILD_TIME}"></script>
     <script>
       document.addEventListener('DOMContentLoaded', async () => {
         const lang = new Lang(document.getElementById('lang'));
         lang.build();
 
+        let etChart = null;
+        let etChartConfig = {
+          slope: null,
+          exponent: null,
+          shift: null,
+          unitSystem: null,
+          targetTemp: null,
+          minTemp: null,
+          maxTemp: null,
+          decimated: false
+        };
+
+        const hasNeedDecimationChart = () => {
+          return window.innerWidth <= 800;
+        }
+
+        const makeEquithermChart = () => {
+          if (etChart == null) {
+            const ctx = document.getElementById('etChart').getContext('2d');
+
+            try {
+              etChart = new Chart(ctx, {
+                type: 'line',
+                data: {
+                  datasets: [{
+                    borderColor: (context) => {
+                      const chart = context.chart;
+                      const {ctx, chartArea} = chart;
+
+                      if (!chartArea) {
+                        return;
+                      }
+
+                      const gradient = ctx.createLinearGradient(0, chartArea.bottom, 0, chartArea.top);
+                      gradient.addColorStop(0, 'rgba(1, 114, 173, 1)');
+                      gradient.addColorStop(0.5, 'rgba(255, 99, 132, 1)');
+
+                      return gradient;
+                    },
+                    borderWidth: 3,
+                    fill: false,
+                    tension: 0.1,
+                    pointRadius: 2,
+                    pointHoverRadius: 4,
+                    indexAxis: "x",
+                    data: []
+                  }]
+                },
+                options: {
+                  responsive: true,
+                  resizeDelay: 500,
+                  parsing: false,
+                  interaction: {
+                    mode: 'nearest',
+                    intersect: false
+                  },
+                  plugins: {
+                    tooltip: {
+                      enabled: true,
+                      position: 'nearest',
+                      displayColors: false,
+                      callbacks: {
+                        title: (items) => {
+                          return `${i18n("settings.equitherm.chart.outdoorTemp")}: ${items[0].label}`;
+                        }
+                      }
+                    },
+                    legend: {
+                      display: false
+                    }
+                  },
+                  scales: {
+                    x: {
+                      display: true,
+                      type: "linear",
+                      reverse: true,
+                      title: {
+                        display: true
+                      },
+                      ticks: {
+                        stepSize: 1,
+                        format: {
+                          style: "unit",
+                          unit: "degree",
+                          unitDisplay: "narrow"
+                        }
+                      }
+                    },
+                    y: {
+                      display: true,
+                      title: {
+                        display: true
+                      },
+                      ticks: {
+                        format: {
+                          style: "unit",
+                          unit: "degree",
+                          unitDisplay: "narrow"
+                        }
+                      }
+                    }
+                  }
+                }
+              });
+
+            } catch (error) {
+              console.log(error);
+            }
+          }
+
+          if (!etChart) {
+            return;
+          }
+
+          let data = [];
+          etChartConfig.decimated = hasNeedDecimationChart();
+          for (let value = 30; value >= -30; value -= etChartConfig.decimated ? 2 : 1) {
+            const outdoorTemp = etChartConfig.unitSystem == 0 ? value : c2f(value);
+
+            data.push({
+              x: parseFloat(outdoorTemp.toFixed(1)),
+              y: parseFloat(calculateEquithermTemp(outdoorTemp).toFixed(1))
+            });
+          }
+
+          etChart.data.datasets[0].data = data;
+          etChart.data.datasets[0].label = i18n("settings.equitherm.chart.setpointTemp");
+          etChart.options.scales.x.title.text = i18n("settings.equitherm.chart.outdoorTemp");
+          etChart.options.scales.y.title.text = i18n("settings.equitherm.chart.setpointTemp");
+          etChart.update();
+        }
+
+        const calculateEquithermTemp = (outdoorTemp) => {
+          const tempDelta = etChartConfig.targetTemp - outdoorTemp;
+          const maxPoint = etChartConfig.targetTemp - (
+            etChartConfig.maxTemp - etChartConfig.targetTemp
+          ) / etChartConfig.slope;
+
+          const sf = (etChartConfig.maxTemp - etChartConfig.targetTemp) / Math.pow(
+            etChartConfig.targetTemp - maxPoint,
+            1 / etChartConfig.exponent
+          );
+          const result = etChartConfig.targetTemp + etChartConfig.shift + sf * (
+            tempDelta >= 0 
+              ? Math.pow(tempDelta, 1 / etChartConfig.exponent) 
+              : -(Math.pow(-(tempDelta), 1 / etChartConfig.exponent))
+          );
+
+          return Math.max(Math.min(result, etChartConfig.maxTemp), etChartConfig.minTemp);
+        }
+
         const fillData = (data) => {
           // System
           setSelectValue("[name='system[logLevel]']", data.system.logLevel);
@@ -933,7 +1102,6 @@
           // Extpump
           setCheckboxValue("[name='externalPump[use]']", data.externalPump.use);
           setInputValue("[name='externalPump[gpio]']", data.externalPump.gpio < 255 ? data.externalPump.gpio : '');
-          setCheckboxValue("[name='externalPump[invertState]']", data.externalPump.invertState);
           setInputValue("[name='externalPump[postCirculationTime]']", data.externalPump.postCirculationTime);
           setInputValue("[name='externalPump[antiStuckInterval]']", data.externalPump.antiStuckInterval);
           setInputValue("[name='externalPump[antiStuckTime]']", data.externalPump.antiStuckTime);
@@ -1019,9 +1187,10 @@
 
           // Equitherm
           setCheckboxValue("[name='equitherm[enabled]']", data.equitherm.enabled);
-          setInputValue("[name='equitherm[n_factor]']", data.equitherm.n_factor);
+          setInputValue("[name='equitherm[slope]']", data.equitherm.slope);
-          setInputValue("[name='equitherm[k_factor]']", data.equitherm.k_factor);
+          setInputValue("[name='equitherm[exponent]']", data.equitherm.exponent);
-          setInputValue("[name='equitherm[t_factor]']", data.equitherm.t_factor);
+          setInputValue("[name='equitherm[shift]']", data.equitherm.shift);
+          setInputValue("[name='equitherm[targetDiffFactor]']", data.equitherm.targetDiffFactor);
           setBusy('#equitherm-settings-busy', '#equitherm-settings', false);
 
           // PID
@@ -1045,6 +1214,24 @@
           setInputValue("[name='pid[deadband][thresholdHigh]']", data.pid.deadband.thresholdHigh);
           setInputValue("[name='pid[deadband][thresholdLow]']", data.pid.deadband.thresholdLow);
           setBusy('#pid-settings-busy', '#pid-settings', false);
+
+          const etMinTemp = parseInt(data.system.unitSystem == 0 ? 5 : 41);
+          const etMaxTemp = parseInt(data.system.unitSystem == 0 ? 30 : 86);
+          const etTargetTemp = constrain(parseFloat(data.heating.target), etMinTemp, etMaxTemp);
+          
+          setInputValue(".etChartTargetTemp", etTargetTemp.toFixed(1), {
+            "min": etMinTemp,
+            "max": etMaxTemp
+          });
+
+          etChartConfig.slope = data.equitherm.slope;
+          etChartConfig.exponent = data.equitherm.exponent;
+          etChartConfig.shift = data.equitherm.shift;
+          etChartConfig.unitSystem = data.system.unitSystem;
+          etChartConfig.minTemp = data.heating.minTemp;
+          etChartConfig.maxTemp = data.heating.maxTemp;
+
+          makeEquithermChart();
         };
 
         try {
@@ -1097,6 +1284,57 @@
         } catch (error) {
           console.log(error);
         }
+
+        document.querySelector(".etChartTargetTemp").addEventListener("input", async (event) => {
+          setValue('.etChartTargetTempValue', parseFloat(event.target.value).toFixed(1));
+        });
+
+        document.querySelector(".etChartTargetTemp").addEventListener("change", async (event) => {
+          if (!event.target.checkValidity()) {
+            return;
+          }
+
+          etChartConfig.targetTemp = parseFloat(event.target.value);
+          setValue('.etChartTargetTempValue', etChartConfig.targetTemp.toFixed(1));
+          makeEquithermChart();
+        });
+
+        document.querySelector("[name='equitherm[slope]']").addEventListener("change", async (event) => {
+          if (!event.target.checkValidity()) {
+            return;
+          }
+
+          etChartConfig.slope = parseFloat(event.target.value);
+          makeEquithermChart();
+        });
+
+        document.querySelector("[name='equitherm[exponent]']").addEventListener("change", async (event) => {
+          if (!event.target.checkValidity()) {
+            return;
+          }
+
+          etChartConfig.exponent = parseFloat(event.target.value);
+          makeEquithermChart();
+        });
+
+        document.querySelector("[name='equitherm[shift]']").addEventListener("change", async (event) => {
+          if (!event.target.checkValidity()) {
+            return;
+          }
+
+          etChartConfig.shift = parseFloat(event.target.value);
+          makeEquithermChart();
+        });
+
+        window.addEventListener('resize', async (event) => {
+          if (etChart) {
+            etChart.resize();
+            
+            if (etChartConfig.decimated != hasNeedDecimationChart()) {
+              makeEquithermChart();
+            }
+          }
+        });
       });
     </script>
   </body>

src_data/pages/upgrade.html

@@ -23,7 +23,6 @@
               <option value="en" selected>EN</option>
               <option value="cn">CN</option>
               <option value="it">IT</option>
-              <option value="nl">NL</option>
               <option value="ru">RU</option>
             </select>
           </li>
@@ -62,19 +61,19 @@
 
           <form action="/api/upgrade" id="upgrade">
             <fieldset class="primary">
-              <label>
+              <label for="firmware-file">
                 <span data-i18n>upgrade.fw</span>:
                 <div class="grid">
-                  <input type="file" name="fw" accept=".bin">
+                  <input type="file" name="firmware" id="firmware-file" accept=".bin">
-                  <button type="button" class="fwResult hidden" disabled></button>
+                  <button type="button" class="upgrade-firmware-result hidden" disabled></button>
                 </div>
               </label>
 
-              <label>
+              <label for="filesystem-file">
                 <span data-i18n>upgrade.fs</span>:
                 <div class="grid">
-                  <input type="file" name="fs" accept=".bin">
+                  <input type="file" name="filesystem" id="filesystem-file" accept=".bin">
-                  <button type="button" class="fsResult hidden" disabled></button>
+                  <button type="button" class="upgrade-filesystem-result hidden" disabled></button>
                 </div>
               </label>
             </fieldset>
@@ -108,123 +107,7 @@
         lang.build();
 
         setupRestoreBackupForm('#restore');
-
+        setupUpgradeForm('#upgrade');
-        const upgradeForm = document.querySelector('#upgrade');
-        if (upgradeForm) {
-          upgradeForm.reset();
-          const statusToText = (status) => {
-            switch (status) {
-              case 0:
-                return "None";
-              case 1:
-                return "No file";
-              case 2:
-                return "Success";
-              case 3:
-                return "Prohibited";
-              case 4:
-                return "Size mismatch";
-              case 5:
-                return "Error on start";
-              case 6:
-                return "Error on write";
-              case 7:
-                return "Error on finish";
-              default:
-                return "Unknown";
-            }
-          };
-
-          upgradeForm.addEventListener('submit', async (event) => {
-            event.preventDefault();
-
-            hide('.fwResult');
-            hide('.fsResult');
-
-            let button = upgradeForm.querySelector('button[type="submit"]');
-            button.textContent = i18n('button.uploading');
-            button.setAttribute('disabled', true);
-            button.setAttribute('aria-busy', true);
-
-            try {
-              let fd = new FormData();
-
-              const fw = upgradeForm.querySelector("[name='fw']").files;
-              if (fw.length > 0) {
-                fd.append("fw_size", fw[0].size);
-                fd.append("fw", fw[0]);
-              }
-
-              const fs = upgradeForm.querySelector("[name='fs']").files;
-              if (fs.length > 0) {
-                fd.append("fs_size", fs[0].size);
-                fd.append("fs", fs[0]);
-              }
-
-              let response = await fetch(upgradeForm.action, {
-                method: "POST",
-                cache: "no-cache",
-                credentials: "include",
-                body: fd
-              });
-              
-              if (response.status != 202 && response.status != 406) {
-                throw new Error('Response not valid');
-              }
-
-              const result = await response.json();
-              let resItem = upgradeForm.querySelector('.fwResult');
-              if (resItem && result.firmware.status > 1) {
-                resItem.textContent = statusToText(result.firmware.status);
-                resItem.classList.remove('hidden');
-
-                if (result.firmware.status == 2) {
-                  resItem.classList.remove('failed');
-                  resItem.classList.add('success');
-                } else {
-                  resItem.classList.remove('success');
-                  resItem.classList.add('failed');
-
-                  if (result.firmware.error != "") {
-                    resItem.textContent += `: ${result.firmware.error}`;
-                  }
-                }
-              }
-
-              resItem = upgradeForm.querySelector('.fsResult');
-              if (resItem && result.filesystem.status > 1) {
-                resItem.textContent = statusToText(result.filesystem.status);
-                resItem.classList.remove('hidden');
-
-                if (result.filesystem.status == 2) {
-                  resItem.classList.remove('failed');
-                  resItem.classList.add('success');
-                } else {
-                  resItem.classList.remove('success');
-                  resItem.classList.add('failed');
-
-                  if (result.filesystem.error != "") {
-                    resItem.textContent += `: ${result.filesystem.error}`;
-                  }
-                }
-              }
-
-            } catch (err) {
-              console.log(err);
-              button.textContent = i18n('button.error');
-              button.classList.add('failed');
-
-            } finally {
-              setTimeout(() => {
-                button.removeAttribute('aria-busy');
-                button.removeAttribute('disabled');
-                button.classList.remove('success', 'failed');
-                button.textContent = i18n(button.dataset.i18n);
-                upgradeForm.reset();
-              }, 10000);
-            }
-          });
-        }
       });
     </script>
   </body>

src_data/scripts/utils.js

@@ -5,8 +5,13 @@ const setupForm = (formSelector, onResultCallback = null, noCastItems = []) => {
   }
 
   form.querySelectorAll('input').forEach(item => {
-    item.addEventListener('change', (e) => {
+    item.addEventListener('change', (event) => {
-      e.target.setAttribute('aria-invalid', !e.target.checkValidity());
+      if (!event.target.checkValidity()) {
+        event.target.setAttribute('aria-invalid', true);
+
+      } else if (event.target.hasAttribute('aria-invalid')) {
+        event.target.removeAttribute('aria-invalid');
+      }
     })
   });
 
@@ -630,6 +635,10 @@ const setCheckboxValue = (selector, value, parent = undefined) => {
   }
 
   item.checked = value;
+
+  setTimeout(() => {
+    item.dispatchEvent(new Event("change"));
+  }, 10);
 }
 
 const setRadioValue = (selector, value, parent = undefined) => {
@@ -643,7 +652,14 @@ const setRadioValue = (selector, value, parent = undefined) => {
   }
 
   for (let item of items) {
-    item.checked = item.value == value;
+    const checked = item.value == value;
+    if (item.checked != checked) {
+      item.checked = checked;
+
+      setTimeout(() => {
+        item.dispatchEvent(new Event("change"));
+      }, 10);
+    }
   }
 }
 
@@ -658,13 +674,17 @@ const setInputValue = (selector, value, attrs = {}, parent = undefined) => {
   }
 
   for (let item of items) {
-    item.value = value;
-
     if (attrs instanceof Object) {
       for (let attrKey of Object.keys(attrs)) {
         item.setAttribute(attrKey, attrs[attrKey]);
       }
     }
+
+    item.value = value;
+
+    setTimeout(() => {
+      item.dispatchEvent(new Event("change"));
+    }, 10);
   }
 }
 
@@ -853,4 +873,12 @@ function dec2hex(i) {
 
 function constrain(amt, low, high) {
   return ((amt) < (low) ? (low) : ((amt) > (high) ? (high) : (amt)));
+}
+
+function c2f(value) {
+  return (9 / 5) * value + 32;
+}
+
+function f2c(value) {
+  return (value - 32) * (5 / 9);
 }