chore: bump version to 1.4.6

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

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_MAX)] = 15;
-    doc[FPSTR(HA_STEP)] = 0.1f;
+    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)][0][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
-    doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_VALUE_TEMPLATE)] = F("{{ iif(value_json.pid.enable, 'offline', 'online') }}");
+    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 publishOutdoorSensorConnected(bool enabledByDefault = true) {
-  bool publishSensorModulation(bool enabledByDefault = true) {
     JsonDocument doc;
-    doc[FPSTR(HA_AVAILABILITY)][0][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
+    doc[FPSTR(HA_AVAILABILITY)][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_UNIQUE_ID)] = this->getObjectId(F("outdoor_sensor_connected"));
-    doc[FPSTR(HA_OBJECT_ID)] = this->getObjectId(F("modulation_level"));
+    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_DEVICE_CLASS)] = F("connectivity");
-    doc[FPSTR(HA_STATE_CLASS)] = F("measurement");
+    doc[FPSTR(HA_NAME)] = F("Outdoor sensor connected");
-    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_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)][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_UNIQUE_ID)] = this->getObjectId(F("outdoor_sensor_rssi"));
-    doc[FPSTR(HA_OBJECT_ID)] = this->getObjectId(F("pressure"));
+    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");
-
+    doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = F("dBm");
-    if (unit == UnitSystem::METRIC) {
+    doc[FPSTR(HA_NAME)] = F("Outdoor sensor RSSI");
-      doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = F("bar");
+    doc[FPSTR(HA_ICON)] = F("mdi:signal");
-
-    } 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_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)][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_UNIQUE_ID)] = this->getObjectId(F("outdoor_sensor_battery"));
-    doc[FPSTR(HA_OBJECT_ID)] = this->getObjectId(F("dhw_flow_rate"));
+    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");
-
+    doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = FPSTR("%");
-    if (unit == UnitSystem::METRIC) {
+    doc[FPSTR(HA_NAME)] = F("Outdoor sensor battery");
-      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_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)][0][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
-    doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_VALUE_TEMPLATE)] = F("{{ iif(value_json.states.fault, 'online', 'offline') }}");
+    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)][0][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
-    doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_VALUE_TEMPLATE)] = F("{{ iif(value_json.states.diagnostic, 'online', 'offline') }}");
+    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());
   }
 

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"));
         }

src/MqttTask.h

@@ -322,48 +322,58 @@ protected:
   void publishHaEntities() {
     // heating
     this->haHelper->publishSwitchHeating(false);
-    this->haHelper->publishSwitchHeatingTurbo();
+    this->haHelper->publishSwitchHeatingTurbo(false);
-    this->haHelper->publishNumberHeatingHysteresis(settings.system.unitSystem);
+    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->publishInputPidFactorP(false);
-    this->haHelper->publishNumberPidFactorI();
+    this->haHelper->publishInputPidFactorI(false);
-    this->haHelper->publishNumberPidFactorD();
+    this->haHelper->publishInputPidFactorD(false);
-    this->haHelper->publishNumberPidDt(false);
+    this->haHelper->publishInputPidDt(false);
-    this->haHelper->publishNumberPidMinTemp(settings.system.unitSystem, false);
+    this->haHelper->publishInputPidMinTemp(settings.system.unitSystem, false);
-    this->haHelper->publishNumberPidMaxTemp(settings.system.unitSystem, false);
+    this->haHelper->publishInputPidMaxTemp(settings.system.unitSystem, false);
 
     // equitherm
     this->haHelper->publishSwitchEquitherm();
-    this->haHelper->publishNumberEquithermFactorN();
+    this->haHelper->publishInputEquithermFactorN(false);
-    this->haHelper->publishNumberEquithermFactorK();
+    this->haHelper->publishInputEquithermFactorK(false);
-    this->haHelper->publishNumberEquithermFactorT();
+    this->haHelper->publishInputEquithermFactorT(false);
 
     // states
-    this->haHelper->publishBinSensorStatus();
+    this->haHelper->publishStateStatus();
-    this->haHelper->publishBinSensorOtStatus();
+    this->haHelper->publishStateEmergency();
-    this->haHelper->publishBinSensorHeating();
+    this->haHelper->publishStateOtStatus();
-    this->haHelper->publishBinSensorFlame();
+    this->haHelper->publishStateHeating();
-    this->haHelper->publishBinSensorFault();
+    this->haHelper->publishStateFlame();
-    this->haHelper->publishBinSensorDiagnostic();
+    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->publishInputDhwMinTemp(settings.system.unitSystem);
-        this->haHelper->publishNumberDhwMaxTemp(settings.system.unitSystem, false);
+        this->haHelper->publishInputDhwMaxTemp(settings.system.unitSystem);
-        this->haHelper->publishBinSensorDhw();
+        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->deleteInputDhwMinTemp();
-        this->haHelper->deleteNumberDhwMaxTemp();
+        this->haHelper->deleteInputDhwMaxTemp();
-        this->haHelper->deleteBinSensorDhw();
+        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);
       }
 

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

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;

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,
+  BOILER_OUTDOOR  = 0,
-  MANUAL,
+  BOILER_RETURN   = 4,
-  DS18B20,
+  MANUAL          = 1,
-  BLUETOOTH
+  DS18B20         = 2,
+  BLUETOOTH       = 3
 };
 
 enum class UnitSystem : byte {

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):
+      case static_cast<byte>(SensorType::BOILER_OUTDOOR):
-        if (dst.sensors.outdoor.type != SensorType::BOILER) {
+        if (dst.sensors.outdoor.type != SensorType::BOILER_OUTDOOR) {
-          dst.sensors.outdoor.type = SensorType::BOILER;
+          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;
     }

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"

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 устройство"

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>