chore: bump version to 1.4.6

fix; fix typo
fix: hysteresis with native heating control has been fixed
2025-12-26 18:13:36 +05:00 · 2024-11-16 14:19:40 +03:00 · 2024-11-01 12:49:35 +03:00 · 2024-11-01 12:47:32 +03:00 · 2024-11-01 04:16:50 +03:00 · 2024-11-01 04:10:56 +03:00
11 changed files with 515 additions and 233 deletions
--- a/platformio.ini
+++ b/platformio.ini
@@ -14,7 +14,7 @@ extra_configs = secrets.default.ini
 core_dir = .pio

 [env]
-version = 1.4.5
+version = 1.4.6
 framework = arduino
 lib_deps = 
 	bblanchon/ArduinoJson@^7.1.0
--- a/src/HaHelper.h
+++ b/src/HaHelper.h
@@ -50,7 +50,7 @@ public:
    return this->publish(this->getTopic(FPSTR(HA_ENTITY_SWITCH), F("heating_turbo")).c_str(), doc);
  }

-  bool publishNumberHeatingTarget(UnitSystem unit = UnitSystem::METRIC, byte minTemp = 20, byte maxTemp = 90, bool enabledByDefault = true) {
+  bool publishInputHeatingTarget(UnitSystem unit = UnitSystem::METRIC, byte minTemp = 20, byte maxTemp = 90, bool enabledByDefault = true) {
    JsonDocument doc;
    doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
    doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
@@ -82,8 +82,9 @@ public:
    return this->publish(this->getTopic(FPSTR(HA_ENTITY_NUMBER), F("heating_target")).c_str(), doc);
  }

-  bool publishNumberHeatingHysteresis(UnitSystem unit = UnitSystem::METRIC, bool enabledByDefault = true) {
+  bool publishInputHeatingHysteresis(UnitSystem unit = UnitSystem::METRIC, bool enabledByDefault = true) {
    JsonDocument doc;
+    doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
    doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectId(F("heating_hysteresis"));
    doc[FPSTR(HA_OBJECT_ID)] = this->getObjectId(F("heating_hysteresis"));
@@ -100,12 +101,12 @@ public:
    doc[FPSTR(HA_NAME)] = F("Heating hysteresis");
    doc[FPSTR(HA_ICON)] = F("mdi:altimeter");
    doc[FPSTR(HA_STATE_TOPIC)] = this->getDeviceTopic(F("settings"));
-    doc[FPSTR(HA_VALUE_TEMPLATE)] = F("{{ value_json.heating.hysteresis|float(0)|round(1) }}");
+    doc[FPSTR(HA_VALUE_TEMPLATE)] = F("{{ value_json.heating.hysteresis|float(0)|round(2) }}");
    doc[FPSTR(HA_COMMAND_TOPIC)] = this->getDeviceTopic(F("settings/set"));
    doc[FPSTR(HA_COMMAND_TEMPLATE)] = F("{\"heating\": {\"hysteresis\" : {{ value }}}}");
    doc[FPSTR(HA_MIN)] = 0;
-    doc[FPSTR(HA_MAX)] = 5;
-    doc[FPSTR(HA_STEP)] = 0.1f;
+    doc[FPSTR(HA_MAX)] = 15;
+    doc[FPSTR(HA_STEP)] = 0.01f;
    doc[FPSTR(HA_MODE)] = "box";
    doc[FPSTR(HA_EXPIRE_AFTER)] = 120;
    doc.shrinkToFit();
@@ -113,6 +114,98 @@ public:
    return this->publish(this->getTopic(FPSTR(HA_ENTITY_NUMBER), F("heating_hysteresis")).c_str(), doc);
  }

+  bool publishInputHeatingTurboFactor(bool enabledByDefault = true) {
+    JsonDocument doc;
+    doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
+    doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectId(F("heating_turbo_factor"));
+    doc[FPSTR(HA_OBJECT_ID)] = this->getObjectId(F("heating_turbo_factor"));
+    doc[FPSTR(HA_ENTITY_CATEGORY)] = F("config");
+    doc[FPSTR(HA_DEVICE_CLASS)] = F("power_factor");
+    doc[FPSTR(HA_NAME)] = F("Heating turbo factor");
+    doc[FPSTR(HA_ICON)] = F("mdi:multiplication-box");
+    doc[FPSTR(HA_STATE_TOPIC)] = this->getDeviceTopic(F("settings"));
+    doc[FPSTR(HA_VALUE_TEMPLATE)] = F("{{ value_json.heating.turboFactor|float(0)|round(2) }}");
+    doc[FPSTR(HA_COMMAND_TOPIC)] = this->getDeviceTopic(F("settings/set"));
+    doc[FPSTR(HA_COMMAND_TEMPLATE)] = F("{\"heating\": {\"turboFactor\" : {{ value }}}}");
+    doc[FPSTR(HA_MIN)] = 1.5;
+    doc[FPSTR(HA_MAX)] = 10;
+    doc[FPSTR(HA_STEP)] = 0.01f;
+    doc[FPSTR(HA_MODE)] = "box";
+    doc[FPSTR(HA_EXPIRE_AFTER)] = 120;
+    doc.shrinkToFit();
+
+    return this->publish(this->getTopic(FPSTR(HA_ENTITY_NUMBER), F("heating_turbo_factor")).c_str(), doc);
+  }
+  bool publishInputHeatingMinTemp(UnitSystem unit = UnitSystem::METRIC, bool enabledByDefault = true) {
+    JsonDocument doc;
+    doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
+    doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectId(F("heating_min_temp"));
+    doc[FPSTR(HA_OBJECT_ID)] = this->getObjectId(F("heating_min_temp"));
+    doc[FPSTR(HA_ENTITY_CATEGORY)] = F("config");
+    doc[FPSTR(HA_DEVICE_CLASS)] = F("temperature");
+
+    if (unit == UnitSystem::METRIC) {
+      doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = FPSTR(HA_UNIT_OF_MEASUREMENT_C);
+      doc[FPSTR(HA_MIN)] = 0;
+      doc[FPSTR(HA_MAX)] = 99;
+      
+    } else if (unit == UnitSystem::IMPERIAL) {
+      doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = FPSTR(HA_UNIT_OF_MEASUREMENT_F);
+      doc[FPSTR(HA_MIN)] = 32;
+      doc[FPSTR(HA_MAX)] = 211;
+    }
+
+    doc[FPSTR(HA_NAME)] = F("Heating min temp");
+    doc[FPSTR(HA_ICON)] = F("mdi:thermometer-chevron-down");
+    doc[FPSTR(HA_STATE_TOPIC)] = this->getDeviceTopic(F("settings"));
+    doc[FPSTR(HA_VALUE_TEMPLATE)] = F("{{ value_json.heating.minTemp|float(0)|round(1) }}");
+    doc[FPSTR(HA_COMMAND_TOPIC)] = this->getDeviceTopic(F("settings/set"));
+    doc[FPSTR(HA_COMMAND_TEMPLATE)] = F("{\"heating\": {\"minTemp\" : {{ value }}}}");
+    doc[FPSTR(HA_STEP)] = 1;
+    doc[FPSTR(HA_MODE)] = "box";
+    doc[FPSTR(HA_EXPIRE_AFTER)] = 120;
+    doc.shrinkToFit();
+
+    return this->publish(this->getTopic(FPSTR(HA_ENTITY_NUMBER), F("heating_min_temp")).c_str(), doc);
+  }
+
+  bool publishInputHeatingMaxTemp(UnitSystem unit = UnitSystem::METRIC, bool enabledByDefault = true) {
+    JsonDocument doc;
+    doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
+    doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectId(F("heating_max_temp"));
+    doc[FPSTR(HA_OBJECT_ID)] = this->getObjectId(F("heating_max_temp"));
+    doc[FPSTR(HA_ENTITY_CATEGORY)] = F("config");
+    doc[FPSTR(HA_DEVICE_CLASS)] = F("temperature");
+
+    if (unit == UnitSystem::METRIC) {
+      doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = FPSTR(HA_UNIT_OF_MEASUREMENT_C);
+      doc[FPSTR(HA_MIN)] = 1;
+      doc[FPSTR(HA_MAX)] = 100;
+      
+    } else if (unit == UnitSystem::IMPERIAL) {
+      doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = FPSTR(HA_UNIT_OF_MEASUREMENT_F);
+      doc[FPSTR(HA_MIN)] = 33;
+      doc[FPSTR(HA_MAX)] = 212;
+    }
+
+    doc[FPSTR(HA_NAME)] = F("Heating max temp");
+    doc[FPSTR(HA_ICON)] = F("mdi:thermometer-chevron-up");
+    doc[FPSTR(HA_STATE_TOPIC)] = this->getDeviceTopic(F("settings"));
+    doc[FPSTR(HA_VALUE_TEMPLATE)] = F("{{ value_json.heating.maxTemp|float(0)|round(1) }}");
+    doc[FPSTR(HA_COMMAND_TOPIC)] = this->getDeviceTopic(F("settings/set"));
+    doc[FPSTR(HA_COMMAND_TEMPLATE)] = F("{\"heating\": {\"maxTemp\" : {{ value }}}}");
+    doc[FPSTR(HA_STEP)] = 1;
+    doc[FPSTR(HA_MODE)] = "box";
+    doc[FPSTR(HA_EXPIRE_AFTER)] = 120;
+    doc.shrinkToFit();
+
+    return this->publish(this->getTopic(FPSTR(HA_ENTITY_NUMBER), F("heating_max_temp")).c_str(), doc);
+  }
+
+
  bool publishSensorHeatingSetpoint(UnitSystem unit = UnitSystem::METRIC, bool enabledByDefault = true) {
    JsonDocument doc;
    doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
@@ -200,72 +293,6 @@ public:
    return this->publish(this->getTopic(FPSTR(HA_ENTITY_SENSOR), F("boiler_heating_max_temp")).c_str(), doc);
  }

-  bool publishNumberHeatingMinTemp(UnitSystem unit = UnitSystem::METRIC, bool enabledByDefault = true) {
-    JsonDocument doc;
-    doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
-    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectId(F("heating_min_temp"));
-    doc[FPSTR(HA_OBJECT_ID)] = this->getObjectId(F("heating_min_temp"));
-    doc[FPSTR(HA_ENTITY_CATEGORY)] = F("config");
-    doc[FPSTR(HA_DEVICE_CLASS)] = F("temperature");
-
-    if (unit == UnitSystem::METRIC) {
-      doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = FPSTR(HA_UNIT_OF_MEASUREMENT_C);
-      doc[FPSTR(HA_MIN)] = 0;
-      doc[FPSTR(HA_MAX)] = 99;
-      
-    } else if (unit == UnitSystem::IMPERIAL) {
-      doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = FPSTR(HA_UNIT_OF_MEASUREMENT_F);
-      doc[FPSTR(HA_MIN)] = 32;
-      doc[FPSTR(HA_MAX)] = 211;
-    }
-
-    doc[FPSTR(HA_NAME)] = F("Heating min temp");
-    doc[FPSTR(HA_ICON)] = F("mdi:thermometer-chevron-down");
-    doc[FPSTR(HA_STATE_TOPIC)] = this->getDeviceTopic(F("settings"));
-    doc[FPSTR(HA_VALUE_TEMPLATE)] = F("{{ value_json.heating.minTemp|float(0)|round(1) }}");
-    doc[FPSTR(HA_COMMAND_TOPIC)] = this->getDeviceTopic(F("settings/set"));
-    doc[FPSTR(HA_COMMAND_TEMPLATE)] = F("{\"heating\": {\"minTemp\" : {{ value }}}}");
-    doc[FPSTR(HA_STEP)] = 1;
-    doc[FPSTR(HA_MODE)] = "box";
-    doc[FPSTR(HA_EXPIRE_AFTER)] = 120;
-    doc.shrinkToFit();
-
-    return this->publish(this->getTopic(FPSTR(HA_ENTITY_NUMBER), F("heating_min_temp")).c_str(), doc);
-  }
-
-  bool publishNumberHeatingMaxTemp(UnitSystem unit = UnitSystem::METRIC, bool enabledByDefault = true) {
-    JsonDocument doc;
-    doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
-    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectId(F("heating_max_temp"));
-    doc[FPSTR(HA_OBJECT_ID)] = this->getObjectId(F("heating_max_temp"));
-    doc[FPSTR(HA_ENTITY_CATEGORY)] = F("config");
-    doc[FPSTR(HA_DEVICE_CLASS)] = F("temperature");
-
-    if (unit == UnitSystem::METRIC) {
-      doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = FPSTR(HA_UNIT_OF_MEASUREMENT_C);
-      doc[FPSTR(HA_MIN)] = 1;
-      doc[FPSTR(HA_MAX)] = 100;
-      
-    } else if (unit == UnitSystem::IMPERIAL) {
-      doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = FPSTR(HA_UNIT_OF_MEASUREMENT_F);
-      doc[FPSTR(HA_MIN)] = 33;
-      doc[FPSTR(HA_MAX)] = 212;
-    }
-
-    doc[FPSTR(HA_NAME)] = F("Heating max temp");
-    doc[FPSTR(HA_ICON)] = F("mdi:thermometer-chevron-up");
-    doc[FPSTR(HA_STATE_TOPIC)] = this->getDeviceTopic(F("settings"));
-    doc[FPSTR(HA_VALUE_TEMPLATE)] = F("{{ value_json.heating.maxTemp|float(0)|round(1) }}");
-    doc[FPSTR(HA_COMMAND_TOPIC)] = this->getDeviceTopic(F("settings/set"));
-    doc[FPSTR(HA_COMMAND_TEMPLATE)] = F("{\"heating\": {\"maxTemp\" : {{ value }}}}");
-    doc[FPSTR(HA_STEP)] = 1;
-    doc[FPSTR(HA_MODE)] = "box";
-    doc[FPSTR(HA_EXPIRE_AFTER)] = 120;
-    doc.shrinkToFit();
-
-    return this->publish(this->getTopic(FPSTR(HA_ENTITY_NUMBER), F("heating_max_temp")).c_str(), doc);
-  }
-

  bool publishSwitchDhw(bool enabledByDefault = true) {
    JsonDocument doc;
@@ -289,7 +316,7 @@ public:
    return this->publish(this->getTopic(FPSTR(HA_ENTITY_SWITCH), F("dhw")).c_str(), doc);
  }

-  bool publishNumberDhwTarget(UnitSystem unit = UnitSystem::METRIC, byte minTemp = 40, byte maxTemp = 60, bool enabledByDefault = true) {
+  bool publishInputDhwTarget(UnitSystem unit = UnitSystem::METRIC, byte minTemp = 40, byte maxTemp = 60, bool enabledByDefault = true) {
    JsonDocument doc;
    doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
    doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
@@ -381,8 +408,9 @@ public:
    return this->publish(this->getTopic(FPSTR(HA_ENTITY_SENSOR), F("boiler_dhw_max_temp")).c_str(), doc);
  }

-  bool publishNumberDhwMinTemp(UnitSystem unit = UnitSystem::METRIC, bool enabledByDefault = true) {
+  bool publishInputDhwMinTemp(UnitSystem unit = UnitSystem::METRIC, bool enabledByDefault = true) {
    JsonDocument doc;
+    doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
    doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectId(F("dhw_min_temp"));
    doc[FPSTR(HA_OBJECT_ID)] = this->getObjectId(F("dhw_min_temp"));
@@ -414,8 +442,9 @@ public:
    return this->publish(this->getTopic(FPSTR(HA_ENTITY_NUMBER), F("dhw_min_temp")).c_str(), doc);
  }

-  bool publishNumberDhwMaxTemp(UnitSystem unit = UnitSystem::METRIC, bool enabledByDefault = true) {
+  bool publishInputDhwMaxTemp(UnitSystem unit = UnitSystem::METRIC, bool enabledByDefault = true) {
    JsonDocument doc;
+    doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
    doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectId(F("dhw_max_temp"));
    doc[FPSTR(HA_OBJECT_ID)] = this->getObjectId(F("dhw_max_temp"));
@@ -450,6 +479,7 @@ public:

  bool publishSwitchPid(bool enabledByDefault = true) {
    JsonDocument doc;
+    doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
    doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectId(F("pid"));
    doc[FPSTR(HA_OBJECT_ID)] = this->getObjectId(F("pid"));
@@ -469,8 +499,10 @@ public:
    return this->publish(this->getTopic(FPSTR(HA_ENTITY_SWITCH), F("pid")).c_str(), doc);
  }

-  bool publishNumberPidFactorP(bool enabledByDefault = true) {
+  bool publishInputPidFactorP(bool enabledByDefault = true) {
    JsonDocument doc;
+    doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
+    doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectId(F("pid_p"));
    doc[FPSTR(HA_OBJECT_ID)] = this->getObjectId(F("pid_p"));
    doc[FPSTR(HA_ENTITY_CATEGORY)] = F("config");
@@ -490,8 +522,10 @@ public:
    return this->publish(this->getTopic(FPSTR(HA_ENTITY_NUMBER), F("pid_p_factor")).c_str(), doc);
  }

-  bool publishNumberPidFactorI(bool enabledByDefault = true) {
+  bool publishInputPidFactorI(bool enabledByDefault = true) {
    JsonDocument doc;
+    doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
+    doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectId(F("pid_i"));
    doc[FPSTR(HA_OBJECT_ID)] = this->getObjectId(F("pid_i"));
    doc[FPSTR(HA_ENTITY_CATEGORY)] = F("config");
@@ -511,8 +545,10 @@ public:
    return this->publish(this->getTopic(FPSTR(HA_ENTITY_NUMBER), F("pid_i_factor")).c_str(), doc);
  }

-  bool publishNumberPidFactorD(bool enabledByDefault = true) {
+  bool publishInputPidFactorD(bool enabledByDefault = true) {
    JsonDocument doc;
+    doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
+    doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectId(F("pid_d"));
    doc[FPSTR(HA_OBJECT_ID)] = this->getObjectId(F("pid_d"));
    doc[FPSTR(HA_ENTITY_CATEGORY)] = F("config");
@@ -532,8 +568,10 @@ public:
    return this->publish(this->getTopic(FPSTR(HA_ENTITY_NUMBER), F("pid_d_factor")).c_str(), doc);
  }

-  bool publishNumberPidDt(bool enabledByDefault = true) {
+  bool publishInputPidDt(bool enabledByDefault = true) {
    JsonDocument doc;
+    doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
+    doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectId(F("pid_dt"));
    doc[FPSTR(HA_OBJECT_ID)] = this->getObjectId(F("pid_dt"));
    doc[FPSTR(HA_ENTITY_CATEGORY)] = F("config");
@@ -555,8 +593,9 @@ public:
    return this->publish(this->getTopic(FPSTR(HA_ENTITY_NUMBER), F("pid_dt")).c_str(), doc);
  }

-  bool publishNumberPidMinTemp(UnitSystem unit = UnitSystem::METRIC, bool enabledByDefault = true) {
+  bool publishInputPidMinTemp(UnitSystem unit = UnitSystem::METRIC, bool enabledByDefault = true) {
    JsonDocument doc;
+    doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
    doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectId(F("pid_min_temp"));
    doc[FPSTR(HA_OBJECT_ID)] = this->getObjectId(F("pid_min_temp"));
@@ -588,8 +627,9 @@ public:
    return this->publish(this->getTopic(FPSTR(HA_ENTITY_NUMBER), F("pid_min_temp")).c_str(), doc);
  }

-  bool publishNumberPidMaxTemp(UnitSystem unit = UnitSystem::METRIC, bool enabledByDefault = true) {
+  bool publishInputPidMaxTemp(UnitSystem unit = UnitSystem::METRIC, bool enabledByDefault = true) {
    JsonDocument doc;
+    doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
    doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectId(F("pid_max_temp"));
    doc[FPSTR(HA_OBJECT_ID)] = this->getObjectId(F("pid_max_temp"));
@@ -624,6 +664,7 @@ public:

  bool publishSwitchEquitherm(bool enabledByDefault = true) {
    JsonDocument doc;
+    doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
    doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectId(F("equitherm"));
    doc[FPSTR(HA_OBJECT_ID)] = this->getObjectId(F("equitherm"));
@@ -643,8 +684,10 @@ public:
    return this->publish(this->getTopic(FPSTR(HA_ENTITY_SWITCH), F("equitherm")).c_str(), doc);
  }

-  bool publishNumberEquithermFactorN(bool enabledByDefault = true) {
+  bool publishInputEquithermFactorN(bool enabledByDefault = true) {
    JsonDocument doc;
+    doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
+    doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectId(F("equitherm_n"));
    doc[FPSTR(HA_OBJECT_ID)] = this->getObjectId(F("equitherm_n"));
    doc[FPSTR(HA_ENTITY_CATEGORY)] = F("config");
@@ -664,8 +707,10 @@ public:
    return this->publish(this->getTopic(FPSTR(HA_ENTITY_NUMBER), F("equitherm_n_factor")).c_str(), doc);
  }

-  bool publishNumberEquithermFactorK(bool enabledByDefault = true) {
+  bool publishInputEquithermFactorK(bool enabledByDefault = true) {
    JsonDocument doc;
+    doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
+    doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectId(F("equitherm_k"));
    doc[FPSTR(HA_OBJECT_ID)] = this->getObjectId(F("equitherm_k"));
    doc[FPSTR(HA_ENTITY_CATEGORY)] = F("config");
@@ -685,10 +730,13 @@ public:
    return this->publish(this->getTopic(FPSTR(HA_ENTITY_NUMBER), F("equitherm_k_factor")).c_str(), doc);
  }

-  bool publishNumberEquithermFactorT(bool enabledByDefault = true) {
+  bool publishInputEquithermFactorT(bool enabledByDefault = true) {
    JsonDocument doc;
-    doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("settings"));
-    doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_VALUE_TEMPLATE)] = F("{{ iif(value_json.pid.enable, 'offline', 'online') }}");
+    doc[FPSTR(HA_AVAILABILITY)][0][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
+    doc[FPSTR(HA_AVAILABILITY)][1][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("settings"));
+    doc[FPSTR(HA_AVAILABILITY)][1][FPSTR(HA_VALUE_TEMPLATE)] = F("{{ iif(value_json.pid.enable, 'offline', 'online') }}");
+    doc[FPSTR(HA_AVAILABILITY_MODE)] = F("all");
+    doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectId(F("equitherm_t"));
    doc[FPSTR(HA_OBJECT_ID)] = this->getObjectId(F("equitherm_t"));
    doc[FPSTR(HA_ENTITY_CATEGORY)] = F("config");
@@ -709,7 +757,7 @@ public:
  }


-  bool publishBinSensorStatus(bool enabledByDefault = true) {
+  bool publishStateStatus(bool enabledByDefault = true) {
    JsonDocument doc;
    doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectId(F("status"));
@@ -726,24 +774,43 @@ public:
    return this->publish(this->getTopic(FPSTR(HA_ENTITY_BINARY_SENSOR), F("status")).c_str(), doc);
  }

-  bool publishBinSensorOtStatus(bool enabledByDefault = true) {
+  bool publishStateEmergency(bool enabledByDefault = true) {
    JsonDocument doc;
+    doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
+    doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectId(F("emergency"));
+    doc[FPSTR(HA_OBJECT_ID)] = this->getObjectId(F("emergency"));
+    doc[FPSTR(HA_ENTITY_CATEGORY)] = F("diagnostic");
+    doc[FPSTR(HA_DEVICE_CLASS)] = F("problem");
+    doc[FPSTR(HA_NAME)] = F("Emergency mode");
+    doc[FPSTR(HA_ICON)] = F("mdi:alert-rhombus-outline");
+    doc[FPSTR(HA_STATE_TOPIC)] = this->getDeviceTopic(F("state"));
+    doc[FPSTR(HA_VALUE_TEMPLATE)] = F("{{ iif(value_json.states.emergency, 'ON', 'OFF') }}");
+    doc[FPSTR(HA_EXPIRE_AFTER)] = 120;
+    doc.shrinkToFit();
+
+    return this->publish(this->getTopic(FPSTR(HA_ENTITY_BINARY_SENSOR), F("emergency")).c_str(), doc);
+  }
+
+  bool publishStateOtStatus(bool enabledByDefault = true) {
+    JsonDocument doc;
+    doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
    doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectId(F("ot_status"));
    doc[FPSTR(HA_OBJECT_ID)] = this->getObjectId(F("ot_status"));
    doc[FPSTR(HA_ENTITY_CATEGORY)] = F("diagnostic");
-    doc[FPSTR(HA_DEVICE_CLASS)] = F("problem");
+    doc[FPSTR(HA_DEVICE_CLASS)] = F("connectivity");
    doc[FPSTR(HA_NAME)] = F("Opentherm status");
    doc[FPSTR(HA_ICON)] = F("mdi:list-status");
    doc[FPSTR(HA_STATE_TOPIC)] = this->getDeviceTopic(F("state"));
-    doc[FPSTR(HA_VALUE_TEMPLATE)] = F("{{ iif(value_json.states.otStatus, 'OFF', 'ON') }}");
+    doc[FPSTR(HA_VALUE_TEMPLATE)] = F("{{ iif(value_json.states.otStatus, 'ON', 'OFF') }}");
    doc[FPSTR(HA_EXPIRE_AFTER)] = 120;
    doc.shrinkToFit();

    return this->publish(this->getTopic(FPSTR(HA_ENTITY_BINARY_SENSOR), F("ot_status")).c_str(), doc);
  }

-  bool publishBinSensorHeating(bool enabledByDefault = true) {
+  bool publishStateHeating(bool enabledByDefault = true) {
    JsonDocument doc;
    doc[FPSTR(HA_AVAILABILITY)][0][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
    doc[FPSTR(HA_AVAILABILITY)][1][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("state"));
@@ -764,7 +831,7 @@ public:
    return this->publish(this->getTopic(FPSTR(HA_ENTITY_BINARY_SENSOR), F("heating")).c_str(), doc);
  }

-  bool publishBinSensorDhw(bool enabledByDefault = true) {
+  bool publishStateDhw(bool enabledByDefault = true) {
    JsonDocument doc;
    doc[FPSTR(HA_AVAILABILITY)][0][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
    doc[FPSTR(HA_AVAILABILITY)][1][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("state"));
@@ -785,7 +852,7 @@ public:
    return this->publish(this->getTopic(FPSTR(HA_ENTITY_BINARY_SENSOR), F("dhw")).c_str(), doc);
  }

-  bool publishBinSensorFlame(bool enabledByDefault = true) {
+  bool publishStateFlame(bool enabledByDefault = true) {
    JsonDocument doc;
    doc[FPSTR(HA_AVAILABILITY)][0][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
    doc[FPSTR(HA_AVAILABILITY)][1][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("state"));
@@ -806,7 +873,7 @@ public:
    return this->publish(this->getTopic(FPSTR(HA_ENTITY_BINARY_SENSOR), F("flame")).c_str(), doc);
  }

-  bool publishBinSensorFault(bool enabledByDefault = true) {
+  bool publishStateFault(bool enabledByDefault = true) {
    JsonDocument doc;
    doc[FPSTR(HA_AVAILABILITY)][0][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
    doc[FPSTR(HA_AVAILABILITY)][1][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("state"));
@@ -827,7 +894,7 @@ public:
    return this->publish(this->getTopic(FPSTR(HA_ENTITY_BINARY_SENSOR), F("fault")).c_str(), doc);
  }

-  bool publishBinSensorDiagnostic(bool enabledByDefault = true) {
+  bool publishStateDiagnostic(bool enabledByDefault = true) {
    JsonDocument doc;
    doc[FPSTR(HA_AVAILABILITY)][0][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
    doc[FPSTR(HA_AVAILABILITY)][1][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("state"));
@@ -848,6 +915,108 @@ public:
    return this->publish(this->getTopic(FPSTR(HA_ENTITY_BINARY_SENSOR), F("diagnostic")).c_str(), doc);
  }

+  bool publishStateExtPump(bool enabledByDefault = true) {
+    JsonDocument doc;
+    doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
+    doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectId(F("ext_pump"));
+    doc[FPSTR(HA_OBJECT_ID)] = this->getObjectId(F("ext_pump"));
+    doc[FPSTR(HA_ENTITY_CATEGORY)] = F("diagnostic");
+    doc[FPSTR(HA_DEVICE_CLASS)] = F("running");
+    doc[FPSTR(HA_NAME)] = F("External pump");
+    doc[FPSTR(HA_ICON)] = F("mdi:pump");
+    doc[FPSTR(HA_STATE_TOPIC)] = this->getDeviceTopic(F("state"));
+    doc[FPSTR(HA_VALUE_TEMPLATE)] = F("{{ iif(value_json.states.externalPump, 'ON', 'OFF') }}");
+    doc[FPSTR(HA_EXPIRE_AFTER)] = 120;
+    doc.shrinkToFit();
+
+    return this->publish(this->getTopic(FPSTR(HA_ENTITY_BINARY_SENSOR), F("ext_pump")).c_str(), doc);
+  }
+
+
+  bool publishSensorModulation(bool enabledByDefault = true) {
+    JsonDocument doc;
+    doc[FPSTR(HA_AVAILABILITY)][0][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
+    doc[FPSTR(HA_AVAILABILITY)][1][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("state"));
+    doc[FPSTR(HA_AVAILABILITY)][1][FPSTR(HA_VALUE_TEMPLATE)] = F("{{ iif(value_json.states.otStatus, 'online', 'offline') }}");
+    doc[FPSTR(HA_AVAILABILITY_MODE)] = F("all");
+    doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectId(F("modulation_level"));
+    doc[FPSTR(HA_OBJECT_ID)] = this->getObjectId(F("modulation_level"));
+    doc[FPSTR(HA_ENTITY_CATEGORY)] = F("diagnostic");
+    doc[FPSTR(HA_DEVICE_CLASS)] = F("power_factor");
+    doc[FPSTR(HA_STATE_CLASS)] = F("measurement");
+    doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = F("%");
+    doc[FPSTR(HA_NAME)] = F("Modulation level");
+    doc[FPSTR(HA_ICON)] = F("mdi:fire-circle");
+    doc[FPSTR(HA_STATE_TOPIC)] = this->getDeviceTopic(F("state"));
+    doc[FPSTR(HA_VALUE_TEMPLATE)] = F("{{ value_json.sensors.modulation|float(0)|round(0) }}");
+    doc[FPSTR(HA_EXPIRE_AFTER)] = 120;
+    doc.shrinkToFit();
+
+    return this->publish(this->getTopic(FPSTR(HA_ENTITY_SENSOR), F("modulation")).c_str(), doc);
+  }
+
+  bool publishSensorPressure(UnitSystem unit = UnitSystem::METRIC, bool enabledByDefault = true) {
+    JsonDocument doc;
+    doc[FPSTR(HA_AVAILABILITY)][0][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
+    doc[FPSTR(HA_AVAILABILITY)][1][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("state"));
+    doc[FPSTR(HA_AVAILABILITY)][1][FPSTR(HA_VALUE_TEMPLATE)] = F("{{ iif(value_json.states.otStatus, 'online', 'offline') }}");
+    doc[FPSTR(HA_AVAILABILITY_MODE)] = F("all");
+    doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectId(F("pressure"));
+    doc[FPSTR(HA_OBJECT_ID)] = this->getObjectId(F("pressure"));
+    doc[FPSTR(HA_ENTITY_CATEGORY)] = F("diagnostic");
+    doc[FPSTR(HA_DEVICE_CLASS)] = F("pressure");
+    doc[FPSTR(HA_STATE_CLASS)] = F("measurement");
+
+    if (unit == UnitSystem::METRIC) {
+      doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = F("bar");
+
+    } else if (unit == UnitSystem::IMPERIAL) {
+      doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = F("psi");
+    }
+
+    doc[FPSTR(HA_NAME)] = F("Pressure");
+    doc[FPSTR(HA_ICON)] = F("mdi:gauge");
+    doc[FPSTR(HA_STATE_TOPIC)] = this->getDeviceTopic(F("state"));
+    doc[FPSTR(HA_VALUE_TEMPLATE)] = F("{{ value_json.sensors.pressure|float(0)|round(2) }}");
+    doc[FPSTR(HA_EXPIRE_AFTER)] = 120;
+    doc.shrinkToFit();
+
+    return this->publish(this->getTopic(FPSTR(HA_ENTITY_SENSOR), F("pressure")).c_str(), doc);
+  }
+
+  bool publishSensorDhwFlowRate(UnitSystem unit = UnitSystem::METRIC, bool enabledByDefault = true) {
+    JsonDocument doc;
+    doc[FPSTR(HA_AVAILABILITY)][0][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
+    doc[FPSTR(HA_AVAILABILITY)][1][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("state"));
+    doc[FPSTR(HA_AVAILABILITY)][1][FPSTR(HA_VALUE_TEMPLATE)] = F("{{ iif(value_json.states.otStatus, 'online', 'offline') }}");
+    doc[FPSTR(HA_AVAILABILITY_MODE)] = F("all");
+    doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectId(F("dhw_flow_rate"));
+    doc[FPSTR(HA_OBJECT_ID)] = this->getObjectId(F("dhw_flow_rate"));
+    doc[FPSTR(HA_ENTITY_CATEGORY)] = F("diagnostic");
+    doc[FPSTR(HA_DEVICE_CLASS)] = F("volume_flow_rate");
+    doc[FPSTR(HA_STATE_CLASS)] = F("measurement");
+
+    if (unit == UnitSystem::METRIC) {
+      doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = F("L/min");
+
+    } else if (unit == UnitSystem::IMPERIAL) {
+      doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = F("gal/min");
+    }
+
+    doc[FPSTR(HA_NAME)] = F("DHW flow rate");
+    doc[FPSTR(HA_ICON)] = F("mdi:water-pump");
+    doc[FPSTR(HA_STATE_TOPIC)] = this->getDeviceTopic(F("state"));
+    doc[FPSTR(HA_VALUE_TEMPLATE)] = F("{{ value_json.sensors.dhwFlowRate|float(0)|round(2) }}");
+    doc[FPSTR(HA_EXPIRE_AFTER)] = 120;
+    doc.shrinkToFit();
+
+    return this->publish(this->getTopic(FPSTR(HA_ENTITY_SENSOR), F("dhw_flow_rate")).c_str(), doc);
+  }
+
  bool publishSensorPower(bool enabledByDefault = true) {
    JsonDocument doc;
    doc[FPSTR(HA_AVAILABILITY)][0][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
@@ -951,93 +1120,160 @@ public:
    return this->publish(this->getTopic(FPSTR(HA_ENTITY_SENSOR), F("uptime")).c_str(), doc);
  }

-
-  bool publishSensorModulation(bool enabledByDefault = true) {
+  bool publishOutdoorSensorConnected(bool enabledByDefault = true) {
    JsonDocument doc;
-    doc[FPSTR(HA_AVAILABILITY)][0][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
-    doc[FPSTR(HA_AVAILABILITY)][1][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("state"));
-    doc[FPSTR(HA_AVAILABILITY)][1][FPSTR(HA_VALUE_TEMPLATE)] = F("{{ iif(value_json.states.otStatus, 'online', 'offline') }}");
-    doc[FPSTR(HA_AVAILABILITY_MODE)] = F("all");
+    doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
    doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
-    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectId(F("modulation_level"));
-    doc[FPSTR(HA_OBJECT_ID)] = this->getObjectId(F("modulation_level"));
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectId(F("outdoor_sensor_connected"));
+    doc[FPSTR(HA_OBJECT_ID)] = this->getObjectId(F("outdoor_sensor_connected"));
    doc[FPSTR(HA_ENTITY_CATEGORY)] = F("diagnostic");
-    doc[FPSTR(HA_DEVICE_CLASS)] = F("power_factor");
-    doc[FPSTR(HA_STATE_CLASS)] = F("measurement");
-    doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = F("%");
-    doc[FPSTR(HA_NAME)] = F("Modulation level");
-    doc[FPSTR(HA_ICON)] = F("mdi:fire-circle");
+    doc[FPSTR(HA_DEVICE_CLASS)] = F("connectivity");
+    doc[FPSTR(HA_NAME)] = F("Outdoor sensor connected");
    doc[FPSTR(HA_STATE_TOPIC)] = this->getDeviceTopic(F("state"));
-    doc[FPSTR(HA_VALUE_TEMPLATE)] = F("{{ value_json.sensors.modulation|float(0)|round(0) }}");
+    doc[FPSTR(HA_VALUE_TEMPLATE)] = F("{{ iif(value_json.sensors.outdoor.connected, 'ON', 'OFF') }}");
    doc[FPSTR(HA_EXPIRE_AFTER)] = 120;
    doc.shrinkToFit();

-    return this->publish(this->getTopic(FPSTR(HA_ENTITY_SENSOR), F("modulation")).c_str(), doc);
+    return this->publish(this->getTopic(FPSTR(HA_ENTITY_BINARY_SENSOR), F("outdoor_sensor_connected")).c_str(), doc);
  }

-  bool publishSensorPressure(UnitSystem unit = UnitSystem::METRIC, bool enabledByDefault = true) {
+  bool publishOutdoorSensorRssi(bool enabledByDefault = true) {
    JsonDocument doc;
-    doc[FPSTR(HA_AVAILABILITY)][0][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
-    doc[FPSTR(HA_AVAILABILITY)][1][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("state"));
-    doc[FPSTR(HA_AVAILABILITY)][1][FPSTR(HA_VALUE_TEMPLATE)] = F("{{ iif(value_json.states.otStatus, 'online', 'offline') }}");
-    doc[FPSTR(HA_AVAILABILITY_MODE)] = F("all");
+    doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
    doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
-    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectId(F("pressure"));
-    doc[FPSTR(HA_OBJECT_ID)] = this->getObjectId(F("pressure"));
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectId(F("outdoor_sensor_rssi"));
+    doc[FPSTR(HA_OBJECT_ID)] = this->getObjectId(F("outdoor_sensor_rssi"));
    doc[FPSTR(HA_ENTITY_CATEGORY)] = F("diagnostic");
-    doc[FPSTR(HA_DEVICE_CLASS)] = F("pressure");
+    doc[FPSTR(HA_DEVICE_CLASS)] = F("signal_strength");
    doc[FPSTR(HA_STATE_CLASS)] = F("measurement");
-
-    if (unit == UnitSystem::METRIC) {
-      doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = F("bar");
-
-    } else if (unit == UnitSystem::IMPERIAL) {
-      doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = F("psi");
-    }
-
-    doc[FPSTR(HA_NAME)] = F("Pressure");
-    doc[FPSTR(HA_ICON)] = F("mdi:gauge");
+    doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = F("dBm");
+    doc[FPSTR(HA_NAME)] = F("Outdoor sensor RSSI");
+    doc[FPSTR(HA_ICON)] = F("mdi:signal");
    doc[FPSTR(HA_STATE_TOPIC)] = this->getDeviceTopic(F("state"));
-    doc[FPSTR(HA_VALUE_TEMPLATE)] = F("{{ value_json.sensors.pressure|float(0)|round(2) }}");
+    doc[FPSTR(HA_VALUE_TEMPLATE)] = F("{{ value_json.sensors.outdoor.rssi|float(0)|round(1) }}");
    doc[FPSTR(HA_EXPIRE_AFTER)] = 120;
    doc.shrinkToFit();

-    return this->publish(this->getTopic(FPSTR(HA_ENTITY_SENSOR), F("pressure")).c_str(), doc);
+    return this->publish(this->getTopic(FPSTR(HA_ENTITY_SENSOR), F("outdoor_sensor_rssi")).c_str(), doc);
  }

-  bool publishSensorDhwFlowRate(UnitSystem unit = UnitSystem::METRIC, bool enabledByDefault = true) {
+  bool publishOutdoorSensorBattery(bool enabledByDefault = true) {
    JsonDocument doc;
-    doc[FPSTR(HA_AVAILABILITY)][0][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
-    doc[FPSTR(HA_AVAILABILITY)][1][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("state"));
-    doc[FPSTR(HA_AVAILABILITY)][1][FPSTR(HA_VALUE_TEMPLATE)] = F("{{ iif(value_json.states.otStatus, 'online', 'offline') }}");
-    doc[FPSTR(HA_AVAILABILITY_MODE)] = F("all");
+    doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
    doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
-    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectId(F("dhw_flow_rate"));
-    doc[FPSTR(HA_OBJECT_ID)] = this->getObjectId(F("dhw_flow_rate"));
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectId(F("outdoor_sensor_battery"));
+    doc[FPSTR(HA_OBJECT_ID)] = this->getObjectId(F("outdoor_sensor_battery"));
    doc[FPSTR(HA_ENTITY_CATEGORY)] = F("diagnostic");
-    doc[FPSTR(HA_DEVICE_CLASS)] = F("volume_flow_rate");
+    doc[FPSTR(HA_DEVICE_CLASS)] = F("battery");
    doc[FPSTR(HA_STATE_CLASS)] = F("measurement");
-
-    if (unit == UnitSystem::METRIC) {
-      doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = F("L/min");
-
-    } else if (unit == UnitSystem::IMPERIAL) {
-      doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = F("gal/min");
-    }
-
-    doc[FPSTR(HA_NAME)] = F("DHW flow rate");
-    doc[FPSTR(HA_ICON)] = F("mdi:water-pump");
+    doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = FPSTR("%");
+    doc[FPSTR(HA_NAME)] = F("Outdoor sensor battery");
    doc[FPSTR(HA_STATE_TOPIC)] = this->getDeviceTopic(F("state"));
-    doc[FPSTR(HA_VALUE_TEMPLATE)] = F("{{ value_json.sensors.dhwFlowRate|float(0)|round(2) }}");
+    doc[FPSTR(HA_VALUE_TEMPLATE)] = F("{{ value_json.sensors.outdoor.battery|float(0)|round(1) }}");
    doc[FPSTR(HA_EXPIRE_AFTER)] = 120;
    doc.shrinkToFit();

-    return this->publish(this->getTopic(FPSTR(HA_ENTITY_SENSOR), F("dhw_flow_rate")).c_str(), doc);
+    return this->publish(this->getTopic(FPSTR(HA_ENTITY_SENSOR), F("outdoor_sensor_battery")).c_str(), doc);
+  }
+
+  bool publishOutdoorSensorHumidity(bool enabledByDefault = true) {
+    JsonDocument doc;
+    doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
+    doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectId(F("outdoor_sensor_humidity"));
+    doc[FPSTR(HA_OBJECT_ID)] = this->getObjectId(F("outdoor_sensor_humidity"));
+    doc[FPSTR(HA_ENTITY_CATEGORY)] = F("diagnostic");
+    doc[FPSTR(HA_DEVICE_CLASS)] = F("humidity");
+    doc[FPSTR(HA_STATE_CLASS)] = F("measurement");
+    doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = FPSTR("%");
+    doc[FPSTR(HA_NAME)] = F("Outdoor sensor humidity");
+    doc[FPSTR(HA_STATE_TOPIC)] = this->getDeviceTopic(F("state"));
+    doc[FPSTR(HA_VALUE_TEMPLATE)] = F("{{ value_json.sensors.outdoor.humidity|float(0)|round(1) }}");
+    doc[FPSTR(HA_EXPIRE_AFTER)] = 120;
+    doc.shrinkToFit();
+
+    return this->publish(this->getTopic(FPSTR(HA_ENTITY_SENSOR), F("outdoor_sensor_humidity")).c_str(), doc);
+  }
+
+  bool publishIndoorSensorConnected(bool enabledByDefault = true) {
+    JsonDocument doc;
+    doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
+    doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectId(F("indoor_sensor_connected"));
+    doc[FPSTR(HA_OBJECT_ID)] = this->getObjectId(F("indoor_sensor_connected"));
+    doc[FPSTR(HA_ENTITY_CATEGORY)] = F("diagnostic");
+    doc[FPSTR(HA_DEVICE_CLASS)] = F("connectivity");
+    doc[FPSTR(HA_NAME)] = F("Indoor sensor connected");
+    doc[FPSTR(HA_STATE_TOPIC)] = this->getDeviceTopic(F("state"));
+    doc[FPSTR(HA_VALUE_TEMPLATE)] = F("{{ iif(value_json.sensors.indoor.connected, 'ON', 'OFF') }}");
+    doc[FPSTR(HA_EXPIRE_AFTER)] = 120;
+    doc.shrinkToFit();
+
+    return this->publish(this->getTopic(FPSTR(HA_ENTITY_BINARY_SENSOR), F("indoor_sensor_connected")).c_str(), doc);
+  }
+
+  bool publishIndoorSensorRssi(bool enabledByDefault = true) {
+    JsonDocument doc;
+    doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
+    doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectId(F("indoor_sensor_rssi"));
+    doc[FPSTR(HA_OBJECT_ID)] = this->getObjectId(F("indoor_sensor_rssi"));
+    doc[FPSTR(HA_ENTITY_CATEGORY)] = F("diagnostic");
+    doc[FPSTR(HA_DEVICE_CLASS)] = F("signal_strength");
+    doc[FPSTR(HA_STATE_CLASS)] = F("measurement");
+    doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = F("dBm");
+    doc[FPSTR(HA_NAME)] = F("Indoor sensor RSSI");
+    doc[FPSTR(HA_ICON)] = F("mdi:signal");
+    doc[FPSTR(HA_STATE_TOPIC)] = this->getDeviceTopic(F("state"));
+    doc[FPSTR(HA_VALUE_TEMPLATE)] = F("{{ value_json.sensors.indoor.rssi|float(0)|round(1) }}");
+    doc[FPSTR(HA_EXPIRE_AFTER)] = 120;
+    doc.shrinkToFit();
+
+    return this->publish(this->getTopic(FPSTR(HA_ENTITY_SENSOR), F("indoor_sensor_rssi")).c_str(), doc);
+  }
+
+  bool publishIndoorSensorBattery(bool enabledByDefault = true) {
+    JsonDocument doc;
+    doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
+    doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectId(F("indoor_sensor_battery"));
+    doc[FPSTR(HA_OBJECT_ID)] = this->getObjectId(F("indoor_sensor_battery"));
+    doc[FPSTR(HA_ENTITY_CATEGORY)] = F("diagnostic");
+    doc[FPSTR(HA_DEVICE_CLASS)] = F("battery");
+    doc[FPSTR(HA_STATE_CLASS)] = F("measurement");
+    doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = FPSTR("%");
+    doc[FPSTR(HA_NAME)] = F("Indoor sensor battery");
+    doc[FPSTR(HA_STATE_TOPIC)] = this->getDeviceTopic(F("state"));
+    doc[FPSTR(HA_VALUE_TEMPLATE)] = F("{{ value_json.sensors.indoor.battery|float(0)|round(1) }}");
+    doc[FPSTR(HA_EXPIRE_AFTER)] = 120;
+    doc.shrinkToFit();
+
+    return this->publish(this->getTopic(FPSTR(HA_ENTITY_SENSOR), F("indoor_sensor_battery")).c_str(), doc);
+  }
+
+  bool publishIndoorSensorHumidity(bool enabledByDefault = true) {
+    JsonDocument doc;
+    doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
+    doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
+    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectId(F("indoor_sensor_humidity"));
+    doc[FPSTR(HA_OBJECT_ID)] = this->getObjectId(F("indoor_sensor_humidity"));
+    doc[FPSTR(HA_ENTITY_CATEGORY)] = F("diagnostic");
+    doc[FPSTR(HA_DEVICE_CLASS)] = F("humidity");
+    doc[FPSTR(HA_STATE_CLASS)] = F("measurement");
+    doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = FPSTR("%");
+    doc[FPSTR(HA_NAME)] = F("Indoor sensor humidity");
+    doc[FPSTR(HA_STATE_TOPIC)] = this->getDeviceTopic(F("state"));
+    doc[FPSTR(HA_VALUE_TEMPLATE)] = F("{{ value_json.sensors.indoor.humidity|float(0)|round(1) }}");
+    doc[FPSTR(HA_EXPIRE_AFTER)] = 120;
+    doc.shrinkToFit();
+
+    return this->publish(this->getTopic(FPSTR(HA_ENTITY_SENSOR), F("indoor_sensor_humidity")).c_str(), doc);
  }


-  bool publishNumberIndoorTemp(UnitSystem unit = UnitSystem::METRIC, bool enabledByDefault = true) {
+  bool publishInputIndoorTemp(UnitSystem unit = UnitSystem::METRIC, bool enabledByDefault = true) {
    JsonDocument doc;
+    doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
    doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectId(F("indoor_temp"));
    doc[FPSTR(HA_OBJECT_ID)] = this->getObjectId(F("indoor_temp"));
@@ -1095,8 +1331,9 @@ public:
    return this->publish(this->getTopic(FPSTR(HA_ENTITY_SENSOR), F("indoor_temp")).c_str(), doc);
  }

-  bool publishNumberOutdoorTemp(UnitSystem unit = UnitSystem::METRIC, bool enabledByDefault = true) {
+  bool publishInputOutdoorTemp(UnitSystem unit = UnitSystem::METRIC, bool enabledByDefault = true) {
    JsonDocument doc;
+    doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
    doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectId(F("outdoor_temp"));
    doc[FPSTR(HA_OBJECT_ID)] = this->getObjectId(F("outdoor_temp"));
@@ -1382,6 +1619,7 @@ public:

  bool publishButtonRestart(bool enabledByDefault = true) {
    JsonDocument doc;
+    doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
    doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectId(F("restart"));
    doc[FPSTR(HA_OBJECT_ID)] = this->getObjectId(F("restart"));
@@ -1398,8 +1636,10 @@ public:

  bool publishButtonResetFault(bool enabledByDefault = true) {
    JsonDocument doc;
-    doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("state"));
-    doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_VALUE_TEMPLATE)] = F("{{ iif(value_json.states.fault, 'online', 'offline') }}");
+    doc[FPSTR(HA_AVAILABILITY)][0][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
+    doc[FPSTR(HA_AVAILABILITY)][1][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("state"));
+    doc[FPSTR(HA_AVAILABILITY)][1][FPSTR(HA_VALUE_TEMPLATE)] = F("{{ iif(value_json.states.fault, 'online', 'offline') }}");
+    doc[FPSTR(HA_AVAILABILITY_MODE)] = F("all");
    doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectId(F("reset_fault"));
    doc[FPSTR(HA_OBJECT_ID)] = this->getObjectId(F("reset_fault"));
@@ -1416,8 +1656,10 @@ public:

  bool publishButtonResetDiagnostic(bool enabledByDefault = true) {
    JsonDocument doc;
-    doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("state"));
-    doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_VALUE_TEMPLATE)] = F("{{ iif(value_json.states.diagnostic, 'online', 'offline') }}");
+    doc[FPSTR(HA_AVAILABILITY)][0][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
+    doc[FPSTR(HA_AVAILABILITY)][1][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("state"));
+    doc[FPSTR(HA_AVAILABILITY)][1][FPSTR(HA_VALUE_TEMPLATE)] = F("{{ iif(value_json.states.diagnostic, 'online', 'offline') }}");
+    doc[FPSTR(HA_AVAILABILITY_MODE)] = F("all");
    doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
    doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectId(F("reset_diagnostic"));
    doc[FPSTR(HA_OBJECT_ID)] = this->getObjectId(F("reset_diagnostic"));
@@ -1433,7 +1675,7 @@ public:
  }


-  bool deleteNumberOutdoorTemp() {
+  bool deleteInputOutdoorTemp() {
    return this->publish(this->getTopic(FPSTR(HA_ENTITY_NUMBER), F("outdoor_temp")).c_str());
  }

@@ -1441,7 +1683,7 @@ public:
    return this->publish(this->getTopic(FPSTR(HA_ENTITY_SENSOR), F("outdoor_temp")).c_str());
  }

-  bool deleteNumberIndoorTemp() {
+  bool deleteInputIndoorTemp() {
    return this->publish(this->getTopic(FPSTR(HA_ENTITY_NUMBER), F("indoor_temp")).c_str());
  }

@@ -1461,15 +1703,15 @@ public:
    return this->publish(this->getTopic(FPSTR(HA_ENTITY_SENSOR), F("boiler_dhw_max_temp")).c_str());
  }

-  bool deleteNumberDhwMinTemp() {
+  bool deleteInputDhwMinTemp() {
    return this->publish(this->getTopic(FPSTR(HA_ENTITY_NUMBER), F("dhw_min_temp")).c_str());
  }

-  bool deleteNumberDhwMaxTemp() {
+  bool deleteInputDhwMaxTemp() {
    return this->publish(this->getTopic(FPSTR(HA_ENTITY_NUMBER), F("dhw_max_temp")).c_str());
  }

-  bool deleteBinSensorDhw() {
+  bool deleteStateDhw() {
    return this->publish(this->getTopic(FPSTR(HA_ENTITY_BINARY_SENSOR), F("dhw")).c_str());
  }

@@ -1477,7 +1719,7 @@ public:
    return this->publish(this->getTopic(FPSTR(HA_ENTITY_SENSOR), F("dhw_temp")).c_str());
  }

-  bool deleteNumberDhwTarget() {
+  bool deleteInputDhwTarget() {
    return this->publish(this->getTopic(FPSTR(HA_ENTITY_NUMBER), F("dhw_target")).c_str());
  }

--- a/src/MainTask.h
+++ b/src/MainTask.h
@@ -246,7 +246,7 @@ protected:

      } else if (!this->emergencyDetected && vars.states.emergency) {
        // disable emergency
-        if (millis() - this->emergencyFlipTime > 30000) {
+        if (millis() - this->emergencyFlipTime > (settings.emergency.tresholdTime * 1000)) {
          vars.states.emergency = false;
          Log.sinfoln(FPSTR(L_MAIN), F("Emergency mode disabled"));
        }
--- a/src/MqttTask.h
+++ b/src/MqttTask.h
@@ -322,48 +322,58 @@ protected:
  void publishHaEntities() {
    // heating
    this->haHelper->publishSwitchHeating(false);
-    this->haHelper->publishSwitchHeatingTurbo();
-    this->haHelper->publishNumberHeatingHysteresis(settings.system.unitSystem);
+    this->haHelper->publishSwitchHeatingTurbo(false);
+    this->haHelper->publishInputHeatingHysteresis(settings.system.unitSystem);
+    this->haHelper->publishInputHeatingTurboFactor(false);
+    this->haHelper->publishInputHeatingMinTemp(settings.system.unitSystem);
+    this->haHelper->publishInputHeatingMaxTemp(settings.system.unitSystem);
    this->haHelper->publishSensorHeatingSetpoint(settings.system.unitSystem, false);
    this->haHelper->publishSensorBoilerHeatingMinTemp(settings.system.unitSystem, false);
    this->haHelper->publishSensorBoilerHeatingMaxTemp(settings.system.unitSystem, false);
-    this->haHelper->publishNumberHeatingMinTemp(settings.system.unitSystem, false);
-    this->haHelper->publishNumberHeatingMaxTemp(settings.system.unitSystem, false);

    // pid
    this->haHelper->publishSwitchPid();
-    this->haHelper->publishNumberPidFactorP();
-    this->haHelper->publishNumberPidFactorI();
-    this->haHelper->publishNumberPidFactorD();
-    this->haHelper->publishNumberPidDt(false);
-    this->haHelper->publishNumberPidMinTemp(settings.system.unitSystem, false);
-    this->haHelper->publishNumberPidMaxTemp(settings.system.unitSystem, false);
+    this->haHelper->publishInputPidFactorP(false);
+    this->haHelper->publishInputPidFactorI(false);
+    this->haHelper->publishInputPidFactorD(false);
+    this->haHelper->publishInputPidDt(false);
+    this->haHelper->publishInputPidMinTemp(settings.system.unitSystem, false);
+    this->haHelper->publishInputPidMaxTemp(settings.system.unitSystem, false);

    // equitherm
    this->haHelper->publishSwitchEquitherm();
-    this->haHelper->publishNumberEquithermFactorN();
-    this->haHelper->publishNumberEquithermFactorK();
-    this->haHelper->publishNumberEquithermFactorT();
+    this->haHelper->publishInputEquithermFactorN(false);
+    this->haHelper->publishInputEquithermFactorK(false);
+    this->haHelper->publishInputEquithermFactorT(false);

    // states
-    this->haHelper->publishBinSensorStatus();
-    this->haHelper->publishBinSensorOtStatus();
-    this->haHelper->publishBinSensorHeating();
-    this->haHelper->publishBinSensorFlame();
-    this->haHelper->publishBinSensorFault();
-    this->haHelper->publishBinSensorDiagnostic();
+    this->haHelper->publishStateStatus();
+    this->haHelper->publishStateEmergency();
+    this->haHelper->publishStateOtStatus();
+    this->haHelper->publishStateHeating();
+    this->haHelper->publishStateFlame();
+    this->haHelper->publishStateFault();
+    this->haHelper->publishStateDiagnostic();
+    this->haHelper->publishStateExtPump(false);

    // sensors
-    this->haHelper->publishSensorModulation(false);
+    this->haHelper->publishSensorModulation();
    this->haHelper->publishSensorPressure(settings.system.unitSystem, false);
    this->haHelper->publishSensorPower();
    this->haHelper->publishSensorFaultCode();
    this->haHelper->publishSensorDiagnosticCode();
    this->haHelper->publishSensorRssi(false);
    this->haHelper->publishSensorUptime(false);
+    this->haHelper->publishOutdoorSensorConnected();
+    this->haHelper->publishOutdoorSensorRssi(false);
+    this->haHelper->publishOutdoorSensorBattery(false);
+    this->haHelper->publishOutdoorSensorHumidity(false);
+    this->haHelper->publishIndoorSensorConnected();
+    this->haHelper->publishIndoorSensorRssi(false);
+    this->haHelper->publishIndoorSensorBattery(false);
+    this->haHelper->publishIndoorSensorHumidity(false);

    // temperatures
-    this->haHelper->publishNumberIndoorTemp(settings.system.unitSystem);
    this->haHelper->publishSensorHeatingTemp(settings.system.unitSystem);
    this->haHelper->publishSensorHeatingReturnTemp(settings.system.unitSystem, false);
    this->haHelper->publishSensorExhaustTemp(settings.system.unitSystem, false);
@@ -401,21 +411,21 @@ protected:
        this->haHelper->publishSwitchDhw(false);
        this->haHelper->publishSensorBoilerDhwMinTemp(settings.system.unitSystem, false);
        this->haHelper->publishSensorBoilerDhwMaxTemp(settings.system.unitSystem, false);
-        this->haHelper->publishNumberDhwMinTemp(settings.system.unitSystem, false);
-        this->haHelper->publishNumberDhwMaxTemp(settings.system.unitSystem, false);
-        this->haHelper->publishBinSensorDhw();
+        this->haHelper->publishInputDhwMinTemp(settings.system.unitSystem);
+        this->haHelper->publishInputDhwMaxTemp(settings.system.unitSystem);
+        this->haHelper->publishStateDhw();
        this->haHelper->publishSensorDhwTemp(settings.system.unitSystem);
-        this->haHelper->publishSensorDhwFlowRate(settings.system.unitSystem, false);
+        this->haHelper->publishSensorDhwFlowRate(settings.system.unitSystem);

      } else {
        this->haHelper->deleteSwitchDhw();
        this->haHelper->deleteSensorBoilerDhwMinTemp();
        this->haHelper->deleteSensorBoilerDhwMaxTemp();
-        this->haHelper->deleteNumberDhwMinTemp();
-        this->haHelper->deleteNumberDhwMaxTemp();
-        this->haHelper->deleteBinSensorDhw();
+        this->haHelper->deleteInputDhwMinTemp();
+        this->haHelper->deleteInputDhwMaxTemp();
+        this->haHelper->deleteStateDhw();
        this->haHelper->deleteSensorDhwTemp();
-        this->haHelper->deleteNumberDhwTarget();
+        this->haHelper->deleteInputDhwTarget();
        this->haHelper->deleteClimateDhw();
        this->haHelper->deleteSensorDhwFlowRate();
      }
@@ -428,7 +438,7 @@ protected:
      _heatingMaxTemp = heatingMaxTemp;
      _noRegulators = noRegulators;

-      this->haHelper->publishNumberHeatingTarget(settings.system.unitSystem, heatingMinTemp, heatingMaxTemp, false);
+      this->haHelper->publishInputHeatingTarget(settings.system.unitSystem, heatingMinTemp, heatingMaxTemp, false);
      this->haHelper->publishClimateHeating(
        settings.system.unitSystem,
        heatingMinTemp,
@@ -443,7 +453,7 @@ protected:
      _dhwMinTemp = settings.dhw.minTemp;
      _dhwMaxTemp = settings.dhw.maxTemp;

-      this->haHelper->publishNumberDhwTarget(settings.system.unitSystem, settings.dhw.minTemp, settings.dhw.maxTemp, false);
+      this->haHelper->publishInputDhwTarget(settings.system.unitSystem, settings.dhw.minTemp, settings.dhw.maxTemp, false);
      this->haHelper->publishClimateDhw(settings.system.unitSystem, settings.dhw.minTemp, settings.dhw.maxTemp);

      published = true;
@@ -454,9 +464,9 @@ protected:

      if (editableOutdoorTemp) {
        this->haHelper->deleteSensorOutdoorTemp();
-        this->haHelper->publishNumberOutdoorTemp(settings.system.unitSystem);
+        this->haHelper->publishInputOutdoorTemp(settings.system.unitSystem);
      } else {
-        this->haHelper->deleteNumberOutdoorTemp();
+        this->haHelper->deleteInputOutdoorTemp();
        this->haHelper->publishSensorOutdoorTemp(settings.system.unitSystem);
      }

@@ -468,9 +478,9 @@ protected:

      if (editableIndoorTemp) {
        this->haHelper->deleteSensorIndoorTemp();
-        this->haHelper->publishNumberIndoorTemp(settings.system.unitSystem);
+        this->haHelper->publishInputIndoorTemp(settings.system.unitSystem);
      } else {
-        this->haHelper->deleteNumberIndoorTemp();
+        this->haHelper->deleteInputIndoorTemp();
        this->haHelper->publishSensorIndoorTemp(settings.system.unitSystem);
      }

--- a/src/OpenThermTask.h
+++ b/src/OpenThermTask.h
@@ -185,10 +185,14 @@ protected:
    } else if (vars.states.otStatus && millis() - this->lastSuccessResponse > 1150) {
      Log.swarningln(FPSTR(L_OT), F("Disconnected"));

-      if (settings.sensors.outdoor.type == SensorType::BOILER) {
+      if (settings.sensors.outdoor.type == SensorType::BOILER_OUTDOOR) {
        vars.sensors.outdoor.connected = false;
      }

+      if (settings.sensors.indoor.type == SensorType::BOILER_RETURN) {
+        vars.sensors.indoor.connected = false;
+      }
+
      vars.states.otStatus = false;
      this->isInitialized = false;
    }
@@ -396,7 +400,7 @@ protected:
      // update these parameters once a minute
      if (!settings.opentherm.filterNumValues.enable) {
        // Get outdoor temp (if necessary)
-        if (settings.sensors.outdoor.type == SensorType::BOILER) {
+        if (settings.sensors.outdoor.type == SensorType::BOILER_OUTDOOR) {
          if (this->updateOutdoorTemp()) {
            if (!vars.sensors.outdoor.connected) {
              vars.sensors.outdoor.connected = true;
@@ -486,9 +490,21 @@ protected:

    // Get heating return temp
    if (this->updateHeatingReturnTemp()) {
+      if (settings.sensors.indoor.type == SensorType::BOILER_RETURN) {
+        vars.temperatures.indoor = settings.sensors.outdoor.offset + vars.temperatures.heatingReturn;
+
+        if (!vars.sensors.outdoor.connected) {
+          vars.sensors.indoor.connected = true;
+        }
+      }
+
      Log.snoticeln(FPSTR(L_OT_HEATING), F("Received return temp: %.2f"), vars.temperatures.heatingReturn);

    } else {
+      if (settings.sensors.indoor.type == SensorType::BOILER_RETURN && vars.sensors.outdoor.connected) {
+        vars.sensors.indoor.connected = false;
+      }
+
      Log.swarningln(FPSTR(L_OT_HEATING), F("Failed receive return temp"));
    }

@@ -504,7 +520,7 @@ protected:
    // must be updated every time.
    if (settings.opentherm.filterNumValues.enable) {
      // Get outdoor temp (if necessary)
-      if (settings.sensors.outdoor.type == SensorType::BOILER) {
+      if (settings.sensors.outdoor.type == SensorType::BOILER_OUTDOOR) {
        if (this->updateOutdoorTemp()) {
          if (!vars.sensors.outdoor.connected) {
            vars.sensors.outdoor.connected = true;
@@ -589,7 +605,7 @@ protected:
      float indoorTemp = 0.0f;
      float convertedTemp = 0.0f;

-      if (!vars.sensors.indoor.connected) {
+      if (vars.sensors.indoor.connected) {
        indoorTemp = vars.temperatures.indoor;
        convertedTemp = convertTemp(indoorTemp, settings.system.unitSystem, settings.opentherm.unitSystem);
      }
@@ -651,26 +667,25 @@ protected:
          }
        }
      }
+    }

+    // Hysteresis
+    // Only if enabled PID or/and Equitherm or Native heating control via OT
+    bool useHyst = false;
+    if (settings.heating.hysteresis > 0.01f && vars.sensors.indoor.connected) {
+      useHyst = settings.equitherm.enable || settings.pid.enable || settings.opentherm.nativeHeatingControl;
+    }

-      // Hysteresis
-      // Only if enabled PID or/and Equitherm or Native heating control via OT
-      bool useHyst = false;
-      if (settings.heating.hysteresis > 0.01f && vars.sensors.indoor.connected) {
-        useHyst = settings.equitherm.enable || settings.pid.enable || settings.opentherm.nativeHeatingControl;
-      }
+    if (useHyst) {
+      if (!this->heatingBlocking && vars.temperatures.indoor - settings.heating.target + 0.0001f >= settings.heating.hysteresis) {
+        this->heatingBlocking = true;

-      if (useHyst) {
-        if (!this->heatingBlocking && vars.temperatures.indoor - settings.heating.target + 0.0001f >= settings.heating.hysteresis) {
-          this->heatingBlocking = true;
-
-        } else if (this->heatingBlocking && vars.temperatures.indoor - settings.heating.target - 0.0001f <= -(settings.heating.hysteresis)) {
-          this->heatingBlocking = false;
-        }
-
-      } else if (this->heatingBlocking) {
+      } else if (this->heatingBlocking && vars.temperatures.indoor - settings.heating.target - 0.0001f <= -(settings.heating.hysteresis)) {
        this->heatingBlocking = false;
      }
+
+    } else if (this->heatingBlocking) {
+      this->heatingBlocking = false;
    }
  }

--- a/src/Settings.h
+++ b/src/Settings.h
@@ -126,7 +126,7 @@ struct Settings {

  struct {
    struct {
-      SensorType type = SensorType::BOILER;
+      SensorType type = SensorType::BOILER_OUTDOOR;
      byte gpio = DEFAULT_SENSOR_OUTDOOR_GPIO;
      uint8_t bleAddress[6] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
      float offset = 0.0f;
--- a/src/defines.h
+++ b/src/defines.h
@@ -147,10 +147,11 @@
 #define GPIO_IS_VALID(gpioNum) (gpioNum != GPIO_IS_NOT_CONFIGURED && GPIO_IS_VALID_GPIO(gpioNum))

 enum class SensorType : byte {
-  BOILER,
-  MANUAL,
-  DS18B20,
-  BLUETOOTH
+  BOILER_OUTDOOR  = 0,
+  BOILER_RETURN   = 4,
+  MANUAL          = 1,
+  DS18B20         = 2,
+  BLUETOOTH       = 3
 };

 enum class UnitSystem : byte {
--- a/src/utils.h
+++ b/src/utils.h
@@ -1101,7 +1101,7 @@ bool jsonToSettings(const JsonVariantConst src, Settings& dst, bool safe = false
  if (!src["heating"]["hysteresis"].isNull()) {
    float value = src["heating"]["hysteresis"].as<float>();

-    if (value >= 0 && value <= 5 && fabs(value - dst.heating.hysteresis) > 0.0001f) {
+    if (value >= 0.0f && value <= 15.0f && fabs(value - dst.heating.hysteresis) > 0.0001f) {
      dst.heating.hysteresis = roundd(value, 2);
      changed = true;
    }
@@ -1178,9 +1178,9 @@ bool jsonToSettings(const JsonVariantConst src, Settings& dst, bool safe = false
    byte value = src["sensors"]["outdoor"]["type"].as<unsigned char>();

    switch (value) {
-      case static_cast<byte>(SensorType::BOILER):
-        if (dst.sensors.outdoor.type != SensorType::BOILER) {
-          dst.sensors.outdoor.type = SensorType::BOILER;
+      case static_cast<byte>(SensorType::BOILER_OUTDOOR):
+        if (dst.sensors.outdoor.type != SensorType::BOILER_OUTDOOR) {
+          dst.sensors.outdoor.type = SensorType::BOILER_OUTDOOR;
          changed = true;
        }
        break;
@@ -1248,7 +1248,7 @@ bool jsonToSettings(const JsonVariantConst src, Settings& dst, bool safe = false
  if (!src["sensors"]["outdoor"]["offset"].isNull()) {
    float value = src["sensors"]["outdoor"]["offset"].as<float>();

-    if (value >= -10 && value <= 10 && fabs(value - dst.sensors.outdoor.offset) > 0.0001f) {
+    if (value >= -20.0f && value <= 20.0f && fabs(value - dst.sensors.outdoor.offset) > 0.0001f) {
      dst.sensors.outdoor.offset = roundd(value, 2);
      changed = true;
    }
@@ -1258,6 +1258,13 @@ bool jsonToSettings(const JsonVariantConst src, Settings& dst, bool safe = false
    byte value = src["sensors"]["indoor"]["type"].as<unsigned char>();

    switch (value) {
+      case static_cast<byte>(SensorType::BOILER_RETURN):
+        if (dst.sensors.indoor.type != SensorType::BOILER_RETURN) {
+          dst.sensors.indoor.type = SensorType::BOILER_RETURN;
+          changed = true;
+        }
+        break;
+
      case static_cast<byte>(SensorType::MANUAL):
        if (dst.sensors.indoor.type != SensorType::MANUAL) {
          dst.sensors.indoor.type = SensorType::MANUAL;
@@ -1321,7 +1328,7 @@ bool jsonToSettings(const JsonVariantConst src, Settings& dst, bool safe = false
  if (!src["sensors"]["indoor"]["offset"].isNull()) {
    float value = src["sensors"]["indoor"]["offset"].as<float>();

-    if (value >= -10 && value <= 10 && fabs(value - dst.sensors.indoor.offset) > 0.0001f) {
+    if (value >= -20.0f && value <= 20.0f && fabs(value - dst.sensors.indoor.offset) > 0.0001f) {
      dst.sensors.indoor.offset = roundd(value, 2);
      changed = true;
    }
--- a/src_data/locales/en.json
+++ b/src_data/locales/en.json
@@ -318,7 +318,8 @@
      "tempSensor": {
        "source": {
          "type": "Source type",
-          "boiler": "From boiler via OpenTherm",
+          "boilerOutdoor": "From boiler via OpenTherm",
+          "boilerReturn": "Return heat carrier temp via OpenTherm",
          "manual": "Manual via MQTT/API",
          "ext": "External (DS18B20)",
          "ble": "BLE device"
--- a/src_data/locales/ru.json
+++ b/src_data/locales/ru.json
@@ -332,7 +332,8 @@
      "tempSensor": {
        "source": {
          "type": "Источник данных",
-          "boiler": "От котла через OpenTherm",
+          "boilerOutdoor": "От котла через OpenTherm",
+          "boilerReturn": "Температура обратки через OpenTherm",
          "manual": "Вручную через MQTT/API",
          "ext": "Внешний датчик (DS18B20)",
          "ble": "BLE устройство"
--- a/src_data/pages/settings.html
+++ b/src_data/pages/settings.html
@@ -566,7 +566,7 @@

                <label>
                  <input type="radio" class="outdoor-sensor-type" name="sensors[outdoor][type]" value="0" />
-                  <span data-i18n>settings.tempSensor.source.boiler</span>
+                  <span data-i18n>settings.tempSensor.source.boilerOutdoor</span>
                </label>

                <label>
@@ -599,7 +599,7 @@

              <label for="outdoor-sensor-offset">
                <span data-i18n>settings.tempSensor.offset</span>
-                <input type="number" inputmode="numeric" id="outdoor-sensor-offset" name="sensors[outdoor][offset]" min="-10" max="10" step="0.01" required>
+                <input type="number" inputmode="numeric" id="outdoor-sensor-offset" name="sensors[outdoor][offset]" min="-20" max="20" step="0.01" required>
              </label>
              
              <fieldset>
@@ -621,6 +621,11 @@
              <fieldset>
                <legend data-i18n>settings.tempSensor.source.type</legend>

+                <label>
+                  <input type="radio" class="indoor-sensor-type" name="sensors[indoor][type]" value="4" />
+                  <span data-i18n>settings.tempSensor.source.boilerReturn</span>
+                </label>
+
                <label>
                  <input type="radio" class="indoor-sensor-type" name="sensors[indoor][type]" value="1" />
                  <span data-i18n>settings.tempSensor.source.manual</span>
@@ -651,7 +656,7 @@

              <label for="indoor-sensor-offset">
                <span data-i18n>settings.tempSensor.offset</span>
-                <input type="number" inputmode="numeric" id="indoor-sensor-offset" name="sensors[indoor][offset]" min="-10" max="10" step="0.01" required>
+                <input type="number" inputmode="numeric" id="indoor-sensor-offset" name="sensors[indoor][offset]" min="-20" max="20" step="0.01" required>
              </label>

              <fieldset>
Author	SHA1	Message	Date
Yurii	f4af237472	chore: bump version to 1.4.6	2024-11-16 14:19:40 +03:00
Yurii	c3d0d94806	fix; fix typo	2024-11-01 12:49:35 +03:00
Yurii	e4211c872c	fix: hysteresis with native heating control has been fixed	2024-11-01 12:47:32 +03:00
Yurii	467cfea449	feat: ability to use return heat carrier temp as indoor temp	2024-11-01 04:16:50 +03:00
Yurii	0e3473e065	fix: fix typo	2024-11-01 04:10:56 +03:00
Yurii	8780e5245a	fix: for some HA entities added missing parameter enabled_by_default	2024-11-01 03:33:35 +03:00
Yurii	94e8288d76	feat: added entities to HA: connected, rssi, battery, humidity for indoor and outdoor sensors; some entities are disabled by default	2024-11-01 02:36:45 +03:00