Merge branch 'unit-system'

data/index.html

@@ -180,23 +180,31 @@
               </tr>
               <tr>
                 <th scope="row">Indoor temp:</th>
-                <td><b class="indoor-temp"></b> C</td>
+                <td><b class="indoor-temp"></b> <span class="unit-system"></span></td>
               </tr>
               <tr>
                 <th scope="row">Outdoor temp:</th>
-                <td><b class="outdoor-temp"></b> C</td>
+                <td><b class="outdoor-temp"></b> <span class="unit-system"></span></td>
               </tr>
               <tr>
                 <th scope="row">Heating temp:</th>
-                <td><b class="heating-temp"></b> C</td>
+                <td><b class="heating-temp"></b> <span class="unit-system"></span></td>
               </tr>
               <tr>
                 <th scope="row">Heating setpoint temp:</th>
-                <td><b class="heating-setpoint-temp"></b> C</td>
+                <td><b class="heating-setpoint-temp"></b> <span class="unit-system"></span></td>
+              </tr>
+              <tr>
+                <th scope="row">Heating return temp:</th>
+                <td><b class="heating-return-temp"></b> <span class="unit-system"></span></td>
               </tr>
               <tr>
                 <th scope="row">DHW temp:</th>
-                <td><b class="dhw-temp"></b> C</td>
+                <td><b class="dhw-temp"></b> <span class="unit-system"></span></td>
+              </tr>
+              <tr>
+                <th scope="row">Exhaust temp:</th>
+                <td><b class="exhaust-temp"></b> <span class="unit-system"></span></td>
               </tr>
             </tbody>
           </table>

data/settings.html

@@ -62,6 +62,18 @@
 
         <div id="opentherm-settings-busy" aria-busy="true"></div>
         <form action="/api/settings" id="opentherm-settings" class="hidden">
+          <fieldset>
+            <legend>Unit system</legend>
+            <label>
+              <input type="radio" class="opentherm-unit-system" name="opentherm[unitSystem]" value="0" />
+              Metric (celsius)
+            </label>
+            <label>
+              <input type="radio" class="opentherm-unit-system" name="opentherm[unitSystem]" value="1" />
+              Imperial (fahrenheit)
+            </label>
+          </fieldset>
+
           <div class="grid">
             <label for="opentherm-in-gpio">
               In GPIO
@@ -302,6 +314,18 @@
 
         <div id="system-settings-busy" aria-busy="true"></div>
         <form action="/api/settings" id="system-settings" class="hidden">
+          <fieldset>
+            <legend>Unit system</legend>
+            <label>
+              <input type="radio" class="system-unit-system" name="system[unitSystem]" value="0" />
+              Metric (celsius)
+            </label>
+            <label>
+              <input type="radio" class="system-unit-system" name="system[unitSystem]" value="1" />
+              Imperial (fahrenheit)
+            </label>
+          </fieldset>
+
           <fieldset>
             <label for="system-debug">
               <input type="checkbox" class="system-debug" name="system[debug]" value="true">

lib/HomeAssistantHelper/strings.h

@@ -33,6 +33,8 @@ const char HA_AVAILABILITY_MODE[]               PROGMEM = "availability_mode";
 const char HA_TOPIC[]                           PROGMEM = "topic";
 const char HA_DEVICE_CLASS[]                    PROGMEM = "device_class";
 const char HA_UNIT_OF_MEASUREMENT[]             PROGMEM = "unit_of_measurement";
+const char HA_UNIT_OF_MEASUREMENT_C[]           PROGMEM = "°C";
+const char HA_UNIT_OF_MEASUREMENT_F[]           PROGMEM = "°F";
 const char HA_ICON[]                            PROGMEM = "icon";
 const char HA_MIN[]                             PROGMEM = "min";
 const char HA_MAX[]                             PROGMEM = "max";
@@ -50,6 +52,7 @@ const char HA_TEMPERATURE_COMMAND_TOPIC[]       PROGMEM = "temperature_command_t
 const char HA_TEMPERATURE_COMMAND_TEMPLATE[]    PROGMEM = "temperature_command_template";
 const char HA_TEMPERATURE_STATE_TOPIC[]         PROGMEM = "temperature_state_topic";
 const char HA_TEMPERATURE_STATE_TEMPLATE[]      PROGMEM = "temperature_state_template";
+const char HA_TEMPERATURE_UNIT[]                PROGMEM = "temperature_unit";
 const char HA_MODE_COMMAND_TOPIC[]              PROGMEM = "mode_command_topic";
 const char HA_MODE_COMMAND_TEMPLATE[]           PROGMEM = "mode_command_template";
 const char HA_MODE_STATE_TOPIC[]                PROGMEM = "mode_state_topic";

src/HaHelper.h

@@ -27,22 +27,31 @@ public:
     return this->publish(this->getTopic(FPSTR(HA_ENTITY_SWITCH), F("emergency")).c_str(), doc);
   }
 
-  bool publishNumberEmergencyTarget(bool enabledByDefault = true) {
+  bool publishNumberEmergencyTarget(UnitSystem unit = UnitSystem::METRIC, bool enabledByDefault = true) {
     JsonDocument doc;
     doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
     doc[FPSTR(HA_UNIQUE_ID)] = this->getObjectId(F("emergency_target"));
     doc[FPSTR(HA_OBJECT_ID)] = this->getObjectId(F("emergency_target"));
     doc[FPSTR(HA_ENTITY_CATEGORY)] = F("config");
     doc[FPSTR(HA_DEVICE_CLASS)] = F("temperature");
-    doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = F("°C");
+
+    if (unit == UnitSystem::METRIC) {
+      doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = FPSTR(HA_UNIT_OF_MEASUREMENT_C);
+      doc[FPSTR(HA_MIN)] = 5;
+      doc[FPSTR(HA_MAX)] = 50;
+
+    } else if (unit == UnitSystem::IMPERIAL) {
+      doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = FPSTR(HA_UNIT_OF_MEASUREMENT_F);
+      doc[FPSTR(HA_MIN)] = 41;
+      doc[FPSTR(HA_MAX)] = 122;
+    }
+    
     doc[FPSTR(HA_NAME)] = F("Emergency target temp");
     doc[FPSTR(HA_ICON)] = F("mdi:thermometer-alert");
     doc[FPSTR(HA_STATE_TOPIC)] = this->getDeviceTopic(F("settings"));
     doc[FPSTR(HA_VALUE_TEMPLATE)] = F("{{ value_json.emergency.target|float(0)|round(1) }}");
     doc[FPSTR(HA_COMMAND_TOPIC)] = this->getDeviceTopic(F("settings/set"));
     doc[FPSTR(HA_COMMAND_TEMPLATE)] = F("{\"emergency\": {\"target\" : {{ value }}}}");
-    doc[FPSTR(HA_MIN)] = 5;
-    doc[FPSTR(HA_MAX)] = 50;
     doc[FPSTR(HA_STEP)] = 0.5;
     doc[FPSTR(HA_MODE)] = "box";
     doc[FPSTR(HA_EXPIRE_AFTER)] = 120;
@@ -142,7 +151,7 @@ public:
     return this->publish(this->getTopic(FPSTR(HA_ENTITY_SWITCH), F("heating_turbo")).c_str(), doc);
   }
 
-  bool publishNumberHeatingTarget(byte minTemp = 20, byte maxTemp = 90, bool enabledByDefault = true) {
+  bool publishNumberHeatingTarget(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;
@@ -150,7 +159,14 @@ public:
     doc[FPSTR(HA_OBJECT_ID)] = this->getObjectId(F("heating_target"));
     doc[FPSTR(HA_ENTITY_CATEGORY)] = F("config");
     doc[FPSTR(HA_DEVICE_CLASS)] = F("temperature");
-    doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = F("°C");
+
+    if (unit == UnitSystem::METRIC) {
+      doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = FPSTR(HA_UNIT_OF_MEASUREMENT_C);
+      
+    } else if (unit == UnitSystem::IMPERIAL) {
+      doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = FPSTR(HA_UNIT_OF_MEASUREMENT_F);
+    }
+
     doc[FPSTR(HA_NAME)] = F("Heating target");
     doc[FPSTR(HA_ICON)] = F("mdi:radiator");
     doc[FPSTR(HA_STATE_TOPIC)] = this->getDeviceTopic(F("settings"));
@@ -167,14 +183,21 @@ public:
     return this->publish(this->getTopic(FPSTR(HA_ENTITY_NUMBER), F("heating_target")).c_str(), doc);
   }
 
-  bool publishNumberHeatingHysteresis(bool enabledByDefault = true) {
+  bool publishNumberHeatingHysteresis(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_hysteresis"));
     doc[FPSTR(HA_OBJECT_ID)] = this->getObjectId(F("heating_hysteresis"));
     doc[FPSTR(HA_ENTITY_CATEGORY)] = F("config");
     doc[FPSTR(HA_DEVICE_CLASS)] = F("temperature");
-    doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = F("°C");
+
+    if (unit == UnitSystem::METRIC) {
+      doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = FPSTR(HA_UNIT_OF_MEASUREMENT_C);
+      
+    } else if (unit == UnitSystem::IMPERIAL) {
+      doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = FPSTR(HA_UNIT_OF_MEASUREMENT_F);
+    }
+
     doc[FPSTR(HA_NAME)] = F("Heating hysteresis");
     doc[FPSTR(HA_ICON)] = F("mdi:altimeter");
     doc[FPSTR(HA_STATE_TOPIC)] = this->getDeviceTopic(F("settings"));
@@ -191,7 +214,7 @@ public:
     return this->publish(this->getTopic(FPSTR(HA_ENTITY_NUMBER), F("heating_hysteresis")).c_str(), doc);
   }
 
-  bool publishSensorHeatingSetpoint(bool enabledByDefault = true) {
+  bool publishSensorHeatingSetpoint(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;
@@ -200,7 +223,14 @@ public:
     doc[FPSTR(HA_ENTITY_CATEGORY)] = F("diagnostic");
     doc[FPSTR(HA_DEVICE_CLASS)] = F("temperature");
     doc[FPSTR(HA_STATE_CLASS)] = F("measurement");
-    doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = F("°C");
+
+    if (unit == UnitSystem::METRIC) {
+      doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = FPSTR(HA_UNIT_OF_MEASUREMENT_C);
+      
+    } else if (unit == UnitSystem::IMPERIAL) {
+      doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = FPSTR(HA_UNIT_OF_MEASUREMENT_F);
+    }
+
     doc[FPSTR(HA_NAME)] = F("Heating setpoint");
     doc[FPSTR(HA_ICON)] = F("mdi:coolant-temperature");
     doc[FPSTR(HA_STATE_TOPIC)] = this->getDeviceTopic(F("state"));
@@ -211,7 +241,7 @@ public:
     return this->publish(this->getTopic(FPSTR(HA_ENTITY_SENSOR), F("heating_setpoint")).c_str(), doc);
   }
 
-  bool publishSensorBoilerHeatingMinTemp(bool enabledByDefault = true) {
+  bool publishSensorBoilerHeatingMinTemp(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"));
@@ -223,7 +253,14 @@ public:
     doc[FPSTR(HA_ENTITY_CATEGORY)] = F("diagnostic");
     doc[FPSTR(HA_DEVICE_CLASS)] = F("temperature");
     doc[FPSTR(HA_STATE_CLASS)] = F("measurement");
-    doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = F("°C");
+
+    if (unit == UnitSystem::METRIC) {
+      doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = FPSTR(HA_UNIT_OF_MEASUREMENT_C);
+      
+    } else if (unit == UnitSystem::IMPERIAL) {
+      doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = FPSTR(HA_UNIT_OF_MEASUREMENT_F);
+    }
+
     doc[FPSTR(HA_NAME)] = F("Boiler heating min temp");
     doc[FPSTR(HA_ICON)] = F("mdi:thermometer-chevron-down");
     doc[FPSTR(HA_STATE_TOPIC)] = this->getDeviceTopic(F("state"));
@@ -234,7 +271,7 @@ public:
     return this->publish(this->getTopic(FPSTR(HA_ENTITY_SENSOR), F("boiler_heating_min_temp")).c_str(), doc);
   }
 
-  bool publishSensorBoilerHeatingMaxTemp(bool enabledByDefault = true) {
+  bool publishSensorBoilerHeatingMaxTemp(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"));
@@ -246,7 +283,14 @@ public:
     doc[FPSTR(HA_ENTITY_CATEGORY)] = F("diagnostic");
     doc[FPSTR(HA_DEVICE_CLASS)] = F("temperature");
     doc[FPSTR(HA_STATE_CLASS)] = F("measurement");
-    doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = F("°C");
+
+    if (unit == UnitSystem::METRIC) {
+      doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = FPSTR(HA_UNIT_OF_MEASUREMENT_C);
+      
+    } else if (unit == UnitSystem::IMPERIAL) {
+      doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = FPSTR(HA_UNIT_OF_MEASUREMENT_F);
+    }
+
     doc[FPSTR(HA_NAME)] = F("Boiler heating max temp");
     doc[FPSTR(HA_ICON)] = F("mdi:thermometer-chevron-up");
     doc[FPSTR(HA_STATE_TOPIC)] = this->getDeviceTopic(F("state"));
@@ -257,22 +301,31 @@ public:
     return this->publish(this->getTopic(FPSTR(HA_ENTITY_SENSOR), F("boiler_heating_max_temp")).c_str(), doc);
   }
 
-  bool publishNumberHeatingMinTemp(bool enabledByDefault = true) {
+  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");
-    doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = F("°C");
+
+    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_MIN)] = 0;
-    doc[FPSTR(HA_MAX)] = 99;
     doc[FPSTR(HA_STEP)] = 1;
     doc[FPSTR(HA_MODE)] = "box";
     doc[FPSTR(HA_EXPIRE_AFTER)] = 120;
@@ -281,22 +334,31 @@ public:
     return this->publish(this->getTopic(FPSTR(HA_ENTITY_NUMBER), F("heating_min_temp")).c_str(), doc);
   }
 
-  bool publishNumberHeatingMaxTemp(bool enabledByDefault = true) {
+  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");
-    doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = F("°C");
+
+    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_MIN)] = 1;
-    doc[FPSTR(HA_MAX)] = 100;
     doc[FPSTR(HA_STEP)] = 1;
     doc[FPSTR(HA_MODE)] = "box";
     doc[FPSTR(HA_EXPIRE_AFTER)] = 120;
@@ -352,7 +414,7 @@ public:
     return this->publish(this->getTopic(FPSTR(HA_ENTITY_SWITCH), F("dhw")).c_str(), doc);
   }
 
-  bool publishNumberDhwTarget(byte minTemp = 40, byte maxTemp = 60, bool enabledByDefault = true) {
+  bool publishNumberDhwTarget(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;
@@ -360,7 +422,14 @@ public:
     doc[FPSTR(HA_OBJECT_ID)] = this->getObjectId(F("dhw_target"));
     doc[FPSTR(HA_ENTITY_CATEGORY)] = F("config");
     doc[FPSTR(HA_DEVICE_CLASS)] = F("temperature");
-    doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = F("°C");
+
+    if (unit == UnitSystem::METRIC) {
+      doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = FPSTR(HA_UNIT_OF_MEASUREMENT_C);
+      
+    } else if (unit == UnitSystem::IMPERIAL) {
+      doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = FPSTR(HA_UNIT_OF_MEASUREMENT_F);
+    }
+
     doc[FPSTR(HA_NAME)] = F("DHW target");
     doc[FPSTR(HA_ICON)] = F("mdi:water-pump");
     doc[FPSTR(HA_STATE_TOPIC)] = this->getDeviceTopic(F("settings"));
@@ -377,7 +446,7 @@ public:
     return this->publish(this->getTopic(FPSTR(HA_ENTITY_NUMBER), F("dhw_target")).c_str(), doc);
   }
 
-  bool publishSensorBoilerDhwMinTemp(bool enabledByDefault = true) {
+  bool publishSensorBoilerDhwMinTemp(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"));
@@ -389,7 +458,14 @@ public:
     doc[FPSTR(HA_ENTITY_CATEGORY)] = F("diagnostic");
     doc[FPSTR(HA_DEVICE_CLASS)] = F("temperature");
     doc[FPSTR(HA_STATE_CLASS)] = F("measurement");
-    doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = F("°C");
+
+    if (unit == UnitSystem::METRIC) {
+      doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = FPSTR(HA_UNIT_OF_MEASUREMENT_C);
+      
+    } else if (unit == UnitSystem::IMPERIAL) {
+      doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = FPSTR(HA_UNIT_OF_MEASUREMENT_F);
+    }
+
     doc[FPSTR(HA_NAME)] = F("Boiler DHW min temp");
     doc[FPSTR(HA_ICON)] = F("mdi:thermometer-chevron-down");
     doc[FPSTR(HA_STATE_TOPIC)] = this->getDeviceTopic(F("state"));
@@ -400,7 +476,7 @@ public:
     return this->publish(this->getTopic(FPSTR(HA_ENTITY_SENSOR), F("boiler_dhw_min_temp")).c_str(), doc);
   }
 
-  bool publishSensorBoilerDhwMaxTemp(bool enabledByDefault = true) {
+  bool publishSensorBoilerDhwMaxTemp(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"));
@@ -412,7 +488,14 @@ public:
     doc[FPSTR(HA_ENTITY_CATEGORY)] = F("diagnostic");
     doc[FPSTR(HA_DEVICE_CLASS)] = F("temperature");
     doc[FPSTR(HA_STATE_CLASS)] = F("measurement");
-    doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = F("°C");
+
+    if (unit == UnitSystem::METRIC) {
+      doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = FPSTR(HA_UNIT_OF_MEASUREMENT_C);
+      
+    } else if (unit == UnitSystem::IMPERIAL) {
+      doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = FPSTR(HA_UNIT_OF_MEASUREMENT_F);
+    }
+
     doc[FPSTR(HA_NAME)] = F("Boiler DHW max temp");
     doc[FPSTR(HA_ICON)] = F("mdi:thermometer-chevron-up");
     doc[FPSTR(HA_STATE_TOPIC)] = this->getDeviceTopic(F("state"));
@@ -423,22 +506,31 @@ public:
     return this->publish(this->getTopic(FPSTR(HA_ENTITY_SENSOR), F("boiler_dhw_max_temp")).c_str(), doc);
   }
 
-  bool publishNumberDhwMinTemp(bool enabledByDefault = true) {
+  bool publishNumberDhwMinTemp(UnitSystem unit = UnitSystem::METRIC, bool enabledByDefault = true) {
     JsonDocument doc;
     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"));
     doc[FPSTR(HA_ENTITY_CATEGORY)] = F("config");
     doc[FPSTR(HA_DEVICE_CLASS)] = F("temperature");
-    doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = F("°C");
+
+    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("DHW 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.dhw.minTemp|float(0)|round(1) }}");
     doc[FPSTR(HA_COMMAND_TOPIC)] = this->getDeviceTopic(F("settings/set"));
     doc[FPSTR(HA_COMMAND_TEMPLATE)] = F("{\"dhw\": {\"minTemp\" : {{ value }}}}");
-    doc[FPSTR(HA_MIN)] = 0;
-    doc[FPSTR(HA_MAX)] = 99;
     doc[FPSTR(HA_STEP)] = 1;
     doc[FPSTR(HA_MODE)] = "box";
     doc[FPSTR(HA_EXPIRE_AFTER)] = 120;
@@ -447,22 +539,31 @@ public:
     return this->publish(this->getTopic(FPSTR(HA_ENTITY_NUMBER), F("dhw_min_temp")).c_str(), doc);
   }
 
-  bool publishNumberDhwMaxTemp(bool enabledByDefault = true) {
+  bool publishNumberDhwMaxTemp(UnitSystem unit = UnitSystem::METRIC, bool enabledByDefault = true) {
     JsonDocument doc;
     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"));
     doc[FPSTR(HA_ENTITY_CATEGORY)] = F("config");
     doc[FPSTR(HA_DEVICE_CLASS)] = F("temperature");
-    doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = F("°C");
+
+    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("DHW 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.dhw.maxTemp|float(0)|round(1) }}");
     doc[FPSTR(HA_COMMAND_TOPIC)] = this->getDeviceTopic(F("settings/set"));
     doc[FPSTR(HA_COMMAND_TEMPLATE)] = F("{\"dhw\": {\"maxTemp\" : {{ value }}}}");
-    doc[FPSTR(HA_MIN)] = 1;
-    doc[FPSTR(HA_MAX)] = 100;
     doc[FPSTR(HA_STEP)] = 1;
     doc[FPSTR(HA_MODE)] = "box";
     doc[FPSTR(HA_EXPIRE_AFTER)] = 120;
@@ -579,22 +680,31 @@ public:
     return this->publish(this->getTopic(FPSTR(HA_ENTITY_NUMBER), F("pid_dt")).c_str(), doc);
   }
 
-  bool publishNumberPidMinTemp(bool enabledByDefault = true) {
+  bool publishNumberPidMinTemp(UnitSystem unit = UnitSystem::METRIC, bool enabledByDefault = true) {
     JsonDocument doc;
     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"));
     doc[FPSTR(HA_ENTITY_CATEGORY)] = F("config");
     doc[FPSTR(HA_DEVICE_CLASS)] = F("temperature");
-    doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = F("°C");
+
+    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)] = 0;
+      doc[FPSTR(HA_MAX)] = 211;
+    }
+
     doc[FPSTR(HA_NAME)] = F("PID 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.pid.minTemp|float(0)|round(1) }}");
     doc[FPSTR(HA_COMMAND_TOPIC)] = this->getDeviceTopic(F("settings/set"));
     doc[FPSTR(HA_COMMAND_TEMPLATE)] = F("{\"pid\": {\"minTemp\" : {{ value }}}}");
-    doc[FPSTR(HA_MIN)] = 0;
-    doc[FPSTR(HA_MAX)] = 99;
     doc[FPSTR(HA_STEP)] = 1;
     doc[FPSTR(HA_MODE)] = "box";
     doc[FPSTR(HA_EXPIRE_AFTER)] = 120;
@@ -603,22 +713,31 @@ public:
     return this->publish(this->getTopic(FPSTR(HA_ENTITY_NUMBER), F("pid_min_temp")).c_str(), doc);
   }
 
-  bool publishNumberPidMaxTemp(bool enabledByDefault = true) {
+  bool publishNumberPidMaxTemp(UnitSystem unit = UnitSystem::METRIC, bool enabledByDefault = true) {
     JsonDocument doc;
     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"));
     doc[FPSTR(HA_ENTITY_CATEGORY)] = F("config");
     doc[FPSTR(HA_DEVICE_CLASS)] = F("temperature");
-    doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = F("°C");
+
+    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)] = 1;
+      doc[FPSTR(HA_MAX)] = 212;
+    }
+
     doc[FPSTR(HA_NAME)] = F("PID 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.pid.maxTemp|float(0)|round(1) }}");
     doc[FPSTR(HA_COMMAND_TOPIC)] = this->getDeviceTopic(F("settings/set"));
     doc[FPSTR(HA_COMMAND_TEMPLATE)] = F("{\"pid\": {\"maxTemp\" : {{ value }}}}");
-    doc[FPSTR(HA_MIN)] = 1;
-    doc[FPSTR(HA_MAX)] = 100;
     doc[FPSTR(HA_STEP)] = 1;
     doc[FPSTR(HA_MODE)] = "box";
     doc[FPSTR(HA_EXPIRE_AFTER)] = 120;
@@ -1027,21 +1146,30 @@ public:
   }
 
 
-  bool publishNumberIndoorTemp(bool enabledByDefault = true) {
+  bool publishNumberIndoorTemp(UnitSystem unit = UnitSystem::METRIC, bool enabledByDefault = true) {
     JsonDocument doc;
     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"));
     doc[FPSTR(HA_ENTITY_CATEGORY)] = F("config");
-    doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = F("°C");
+
+    if (unit == UnitSystem::METRIC) {
+      doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = FPSTR(HA_UNIT_OF_MEASUREMENT_C);
+      doc[FPSTR(HA_MIN)] = -99;
+      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)] = -147;
+      doc[FPSTR(HA_MAX)] = 211;
+    }
+
     doc[FPSTR(HA_NAME)] = F("Indoor temperature");
     doc[FPSTR(HA_ICON)] = F("mdi:home-thermometer");
     doc[FPSTR(HA_STATE_TOPIC)] = this->getDeviceTopic(F("state"));
     doc[FPSTR(HA_VALUE_TEMPLATE)] = F("{{ value_json.temperatures.indoor|float(0)|round(1) }}");
     doc[FPSTR(HA_COMMAND_TOPIC)] = this->getDeviceTopic(F("state/set"));
     doc[FPSTR(HA_COMMAND_TEMPLATE)] = F("{\"temperatures\": {\"indoor\":{{ value }}}}");
-    doc[FPSTR(HA_MIN)] = -99;
-    doc[FPSTR(HA_MAX)] = 99;
     doc[FPSTR(HA_STEP)] = 0.01;
     doc[FPSTR(HA_MODE)] = "box";
     doc[FPSTR(HA_EXPIRE_AFTER)] = 120;
@@ -1050,7 +1178,7 @@ public:
     return this->publish(this->getTopic(FPSTR(HA_ENTITY_NUMBER), F("indoor_temp")).c_str(), doc);
   }
 
-  bool publishSensorIndoorTemp(bool enabledByDefault = true) {
+  bool publishSensorIndoorTemp(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;
@@ -1059,7 +1187,14 @@ public:
     doc[FPSTR(HA_ENTITY_CATEGORY)] = F("diagnostic");
     doc[FPSTR(HA_DEVICE_CLASS)] = F("temperature");
     doc[FPSTR(HA_STATE_CLASS)] = F("measurement");
-    doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = F("°C");
+
+    if (unit == UnitSystem::METRIC) {
+      doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = FPSTR(HA_UNIT_OF_MEASUREMENT_C);
+      
+    } else if (unit == UnitSystem::IMPERIAL) {
+      doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = FPSTR(HA_UNIT_OF_MEASUREMENT_F);
+    }
+
     doc[FPSTR(HA_NAME)] = F("Indoor temperature");
     doc[FPSTR(HA_ICON)] = F("mdi:home-thermometer");
     doc[FPSTR(HA_STATE_TOPIC)] = this->getDeviceTopic(F("state"));
@@ -1070,21 +1205,30 @@ public:
     return this->publish(this->getTopic(FPSTR(HA_ENTITY_SENSOR), F("indoor_temp")).c_str(), doc);
   }
 
-  bool publishNumberOutdoorTemp(bool enabledByDefault = true) {
+  bool publishNumberOutdoorTemp(UnitSystem unit = UnitSystem::METRIC, bool enabledByDefault = true) {
     JsonDocument doc;
     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"));
     doc[FPSTR(HA_ENTITY_CATEGORY)] = F("config");
-    doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = F("°C");
+
+    if (unit == UnitSystem::METRIC) {
+      doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = FPSTR(HA_UNIT_OF_MEASUREMENT_C);
+      doc[FPSTR(HA_MIN)] = -99;
+      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)] = -147;
+      doc[FPSTR(HA_MAX)] = 211;
+    }
+
     doc[FPSTR(HA_NAME)] = F("Outdoor temperature");
     doc[FPSTR(HA_ICON)] = F("mdi:home-thermometer-outline");
     doc[FPSTR(HA_STATE_TOPIC)] = this->getDeviceTopic(F("state"));
     doc[FPSTR(HA_VALUE_TEMPLATE)] = F("{{ value_json.temperatures.outdoor|float(0)|round(1) }}");
     doc[FPSTR(HA_COMMAND_TOPIC)] = this->getDeviceTopic(F("state/set"));
     doc[FPSTR(HA_COMMAND_TEMPLATE)] = F("{\"temperatures\": {\"outdoor\":{{ value }}}}");
-    doc[FPSTR(HA_MIN)] = -99;
-    doc[FPSTR(HA_MAX)] = 99;
     doc[FPSTR(HA_STEP)] = 0.01;
     doc[FPSTR(HA_MODE)] = "box";
     doc[FPSTR(HA_EXPIRE_AFTER)] = 120;
@@ -1093,7 +1237,7 @@ public:
     return this->publish(this->getTopic(FPSTR(HA_ENTITY_NUMBER), F("outdoor_temp")).c_str(), doc);
   }
 
-  bool publishSensorOutdoorTemp(bool enabledByDefault = true) {
+  bool publishSensorOutdoorTemp(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;
@@ -1102,7 +1246,14 @@ public:
     doc[FPSTR(HA_ENTITY_CATEGORY)] = F("diagnostic");
     doc[FPSTR(HA_DEVICE_CLASS)] = F("temperature");
     doc[FPSTR(HA_STATE_CLASS)] = F("measurement");
-    doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = F("°C");
+
+    if (unit == UnitSystem::METRIC) {
+      doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = FPSTR(HA_UNIT_OF_MEASUREMENT_C);
+      
+    } else if (unit == UnitSystem::IMPERIAL) {
+      doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = FPSTR(HA_UNIT_OF_MEASUREMENT_F);
+    }
+
     doc[FPSTR(HA_NAME)] = F("Outdoor temperature");
     doc[FPSTR(HA_ICON)] = F("mdi:home-thermometer-outline");
     doc[FPSTR(HA_STATE_TOPIC)] = this->getDeviceTopic(F("state"));
@@ -1113,7 +1264,7 @@ public:
     return this->publish(this->getTopic(FPSTR(HA_ENTITY_SENSOR), F("outdoor_temp")).c_str(), doc);
   }
 
-  bool publishSensorHeatingTemp(bool enabledByDefault = true) {
+  bool publishSensorHeatingTemp(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"));
@@ -1125,7 +1276,14 @@ public:
     doc[FPSTR(HA_ENTITY_CATEGORY)] = F("diagnostic");
     doc[FPSTR(HA_DEVICE_CLASS)] = F("temperature");
     doc[FPSTR(HA_STATE_CLASS)] = F("measurement");
-    doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = F("°C");
+
+    if (unit == UnitSystem::METRIC) {
+      doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = FPSTR(HA_UNIT_OF_MEASUREMENT_C);
+      
+    } else if (unit == UnitSystem::IMPERIAL) {
+      doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = FPSTR(HA_UNIT_OF_MEASUREMENT_F);
+    }
+
     doc[FPSTR(HA_NAME)] = F("Heating temperature");
     doc[FPSTR(HA_ICON)] = F("mdi:radiator");
     doc[FPSTR(HA_STATE_TOPIC)] = this->getDeviceTopic(F("state"));
@@ -1136,7 +1294,7 @@ public:
     return this->publish(this->getTopic(FPSTR(HA_ENTITY_SENSOR), F("heating_temp")).c_str(), doc);
   }
 
-  bool publishSensorHeatingReturnTemp(bool enabledByDefault = true) {
+  bool publishSensorHeatingReturnTemp(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"));
@@ -1148,7 +1306,14 @@ public:
     doc[FPSTR(HA_ENTITY_CATEGORY)] = F("diagnostic");
     doc[FPSTR(HA_DEVICE_CLASS)] = F("temperature");
     doc[FPSTR(HA_STATE_CLASS)] = F("measurement");
-    doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = F("°C");
+
+    if (unit == UnitSystem::METRIC) {
+      doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = FPSTR(HA_UNIT_OF_MEASUREMENT_C);
+      
+    } else if (unit == UnitSystem::IMPERIAL) {
+      doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = FPSTR(HA_UNIT_OF_MEASUREMENT_F);
+    }
+
     doc[FPSTR(HA_NAME)] = F("Heating return temperature");
     doc[FPSTR(HA_ICON)] = F("mdi:radiator");
     doc[FPSTR(HA_STATE_TOPIC)] = this->getDeviceTopic(F("state"));
@@ -1159,7 +1324,7 @@ public:
     return this->publish(this->getTopic(FPSTR(HA_ENTITY_SENSOR), F("heating_return_temp")).c_str(), doc);
   }
 
-  bool publishSensorDhwTemp(bool enabledByDefault = true) {
+  bool publishSensorDhwTemp(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"));
@@ -1171,7 +1336,14 @@ public:
     doc[FPSTR(HA_ENTITY_CATEGORY)] = F("diagnostic");
     doc[FPSTR(HA_DEVICE_CLASS)] = F("temperature");
     doc[FPSTR(HA_STATE_CLASS)] = F("measurement");
-    doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = F("°C");
+
+    if (unit == UnitSystem::METRIC) {
+      doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = FPSTR(HA_UNIT_OF_MEASUREMENT_C);
+      
+    } else if (unit == UnitSystem::IMPERIAL) {
+      doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = FPSTR(HA_UNIT_OF_MEASUREMENT_F);
+    }
+
     doc[FPSTR(HA_NAME)] = F("DHW temperature");
     doc[FPSTR(HA_ICON)] = F("mdi:water-pump");
     doc[FPSTR(HA_STATE_TOPIC)] = this->getDeviceTopic(F("state"));
@@ -1182,7 +1354,7 @@ public:
     return this->publish(this->getTopic(FPSTR(HA_ENTITY_SENSOR), F("dhw_temp")).c_str(), doc);
   }
 
-  bool publishSensorExhaustTemp(bool enabledByDefault = true) {
+  bool publishSensorExhaustTemp(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"));
@@ -1194,7 +1366,14 @@ public:
     doc[FPSTR(HA_ENTITY_CATEGORY)] = F("diagnostic");
     doc[FPSTR(HA_DEVICE_CLASS)] = F("temperature");
     doc[FPSTR(HA_STATE_CLASS)] = F("measurement");
-    doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = F("°C");
+
+    if (unit == UnitSystem::METRIC) {
+      doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = FPSTR(HA_UNIT_OF_MEASUREMENT_C);
+      
+    } else if (unit == UnitSystem::IMPERIAL) {
+      doc[FPSTR(HA_UNIT_OF_MEASUREMENT)] = FPSTR(HA_UNIT_OF_MEASUREMENT_F);
+    }
+
     doc[FPSTR(HA_NAME)] = F("Exhaust temperature");
     doc[FPSTR(HA_ICON)] = F("mdi:smoke");
     doc[FPSTR(HA_STATE_TOPIC)] = this->getDeviceTopic(F("state"));
@@ -1206,7 +1385,7 @@ public:
   }
 
 
-  bool publishClimateHeating(byte minTemp = 20, byte maxTemp = 90, byte currentTempSource = HaHelper::TEMP_SOURCE_HEATING, bool enabledByDefault = true) {
+  bool publishClimateHeating(UnitSystem unit = UnitSystem::METRIC, byte minTemp = 20, byte maxTemp = 90, byte currentTempSource = HaHelper::TEMP_SOURCE_HEATING, bool enabledByDefault = true) {
     JsonDocument doc;
     doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
     doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
@@ -1232,6 +1411,13 @@ public:
     doc[FPSTR(HA_TEMPERATURE_STATE_TOPIC)] = this->getDeviceTopic(F("settings"));
     doc[FPSTR(HA_TEMPERATURE_STATE_TEMPLATE)] = F("{{ value_json.heating.target|float(0)|round(1) }}");
 
+    if (unit == UnitSystem::METRIC) {
+      doc[FPSTR(HA_TEMPERATURE_UNIT)] = "C";
+      
+    } else if (unit == UnitSystem::IMPERIAL) {
+      doc[FPSTR(HA_TEMPERATURE_UNIT)] = "F";
+    }
+
     doc[FPSTR(HA_MODE_COMMAND_TOPIC)] = this->getDeviceTopic(F("settings/set"));
     doc[FPSTR(HA_MODE_COMMAND_TEMPLATE)] = F("{% if value == 'heat' %}{\"heating\": {\"enable\" : true}}"
       "{% elif value == 'off' %}{\"heating\": {\"enable\" : false}}{% endif %}");
@@ -1259,7 +1445,7 @@ public:
     return this->publish(this->getTopic(FPSTR(HA_ENTITY_CLIMATE), F("heating"), '_').c_str(), doc);
   }
 
-  bool publishClimateDhw(byte minTemp = 40, byte maxTemp = 60, bool enabledByDefault = true) {
+  bool publishClimateDhw(UnitSystem unit = UnitSystem::METRIC, byte minTemp = 40, byte maxTemp = 60, bool enabledByDefault = true) {
     JsonDocument doc;
     doc[FPSTR(HA_AVAILABILITY)][FPSTR(HA_TOPIC)] = this->getDeviceTopic(F("status"));
     doc[FPSTR(HA_ENABLED_BY_DEFAULT)] = enabledByDefault;
@@ -1277,6 +1463,13 @@ public:
     doc[FPSTR(HA_TEMPERATURE_STATE_TOPIC)] = this->getDeviceTopic(F("settings"));
     doc[FPSTR(HA_TEMPERATURE_STATE_TEMPLATE)] = F("{{ value_json.dhw.target|int(0) }}");
 
+    if (unit == UnitSystem::METRIC) {
+      doc[FPSTR(HA_TEMPERATURE_UNIT)] = "C";
+      
+    } else if (unit == UnitSystem::IMPERIAL) {
+      doc[FPSTR(HA_TEMPERATURE_UNIT)] = "F";
+    }
+
     doc[FPSTR(HA_MODE_COMMAND_TOPIC)] = this->getDeviceTopic(F("settings/set"));
     doc[FPSTR(HA_MODE_COMMAND_TEMPLATE)] = F("{% if value == 'heat' %}{\"dhw\": {\"enable\" : true}}"
       "{% elif value == 'off' %}{\"dhw\": {\"enable\" : false}}{% endif %}");

src/MqttTask.h

@@ -51,6 +51,7 @@ protected:
   MqttClient* client = nullptr;
   HaHelper* haHelper = nullptr;
   MqttWriter* writer = nullptr;
+  UnitSystem currentUnitSystem = UnitSystem::METRIC;
   unsigned short readyForSendTime = 15000;
   unsigned long lastReconnectTime = 0;
   unsigned long connectedTime = 0;
@@ -213,10 +214,11 @@ protected:
     }
 
     // publish ha entities if not published
-    if (this->newConnection) {
+    if (this->newConnection || this->currentUnitSystem != settings.system.unitSystem) {
       this->publishHaEntities();
       this->publishNonStaticHaEntities(true);
       this->newConnection = false;
+      this->currentUnitSystem = settings.system.unitSystem;
 
     } else {
       // publish non static ha entities
@@ -318,19 +320,19 @@ protected:
   void publishHaEntities() {
     // emergency
     this->haHelper->publishSwitchEmergency();
-    this->haHelper->publishNumberEmergencyTarget();
+    this->haHelper->publishNumberEmergencyTarget(settings.system.unitSystem);
     this->haHelper->publishSwitchEmergencyUseEquitherm();
     this->haHelper->publishSwitchEmergencyUsePid();
 
     // heating
     this->haHelper->publishSwitchHeating(false);
     this->haHelper->publishSwitchHeatingTurbo();
-    this->haHelper->publishNumberHeatingHysteresis();
+    this->haHelper->publishNumberHeatingHysteresis(settings.system.unitSystem);
-    this->haHelper->publishSensorHeatingSetpoint(false);
+    this->haHelper->publishSensorHeatingSetpoint(settings.system.unitSystem, false);
-    this->haHelper->publishSensorBoilerHeatingMinTemp(false);
+    this->haHelper->publishSensorBoilerHeatingMinTemp(settings.system.unitSystem, false);
-    this->haHelper->publishSensorBoilerHeatingMaxTemp(false);
+    this->haHelper->publishSensorBoilerHeatingMaxTemp(settings.system.unitSystem, false);
-    this->haHelper->publishNumberHeatingMinTemp(false);
+    this->haHelper->publishNumberHeatingMinTemp(settings.system.unitSystem, false);
-    this->haHelper->publishNumberHeatingMaxTemp(false);
+    this->haHelper->publishNumberHeatingMaxTemp(settings.system.unitSystem, false);
     this->haHelper->publishNumberHeatingMaxModulation(false);
 
     // pid
@@ -339,8 +341,8 @@ protected:
     this->haHelper->publishNumberPidFactorI();
     this->haHelper->publishNumberPidFactorD();
     this->haHelper->publishNumberPidDt(false);
-    this->haHelper->publishNumberPidMinTemp(false);
+    this->haHelper->publishNumberPidMinTemp(settings.system.unitSystem, false);
-    this->haHelper->publishNumberPidMaxTemp(false);
+    this->haHelper->publishNumberPidMaxTemp(settings.system.unitSystem, false);
 
     // equitherm
     this->haHelper->publishSwitchEquitherm();
@@ -368,10 +370,10 @@ protected:
     this->haHelper->publishSensorUptime(false);
 
     // temperatures
-    this->haHelper->publishNumberIndoorTemp();
+    this->haHelper->publishNumberIndoorTemp(settings.system.unitSystem);
-    this->haHelper->publishSensorHeatingTemp();
+    this->haHelper->publishSensorHeatingTemp(settings.system.unitSystem);
-    this->haHelper->publishSensorHeatingReturnTemp(false);
+    this->haHelper->publishSensorHeatingReturnTemp(settings.system.unitSystem, false);
-    this->haHelper->publishSensorExhaustTemp(false);
+    this->haHelper->publishSensorExhaustTemp(settings.system.unitSystem, false);
 
     // buttons
     this->haHelper->publishButtonRestart(false);
@@ -385,22 +387,35 @@ protected:
 
     bool published = false;
     bool isStupidMode = !settings.pid.enable && !settings.equitherm.enable;
-    byte heatingMinTemp = isStupidMode ? settings.heating.minTemp : 10;
+    byte heatingMinTemp = 0;
-    byte heatingMaxTemp = isStupidMode ? settings.heating.maxTemp : 30;
+    byte heatingMaxTemp = 0;
     bool editableOutdoorTemp = settings.sensors.outdoor.type == SensorType::MANUAL;
     bool editableIndoorTemp = settings.sensors.indoor.type == SensorType::MANUAL;
 
+    if (isStupidMode) {
+      heatingMinTemp = settings.heating.minTemp;
+      heatingMaxTemp = settings.heating.maxTemp;
+
+    } else if (settings.system.unitSystem == UnitSystem::METRIC) {
+      heatingMinTemp = 5;
+      heatingMaxTemp = 30;
+
+    } else if (settings.system.unitSystem == UnitSystem::IMPERIAL) {
+      heatingMinTemp = 41;
+      heatingMaxTemp = 86;
+    }
+
     if (force || _dhwPresent != settings.opentherm.dhwPresent) {
       _dhwPresent = settings.opentherm.dhwPresent;
 
       if (_dhwPresent) {
         this->haHelper->publishSwitchDhw(false);
-        this->haHelper->publishSensorBoilerDhwMinTemp(false);
+        this->haHelper->publishSensorBoilerDhwMinTemp(settings.system.unitSystem, false);
-        this->haHelper->publishSensorBoilerDhwMaxTemp(false);
+        this->haHelper->publishSensorBoilerDhwMaxTemp(settings.system.unitSystem, false);
-        this->haHelper->publishNumberDhwMinTemp(false);
+        this->haHelper->publishNumberDhwMinTemp(settings.system.unitSystem, false);
-        this->haHelper->publishNumberDhwMaxTemp(false);
+        this->haHelper->publishNumberDhwMaxTemp(settings.system.unitSystem, false);
         this->haHelper->publishBinSensorDhw();
-        this->haHelper->publishSensorDhwTemp();
+        this->haHelper->publishSensorDhwTemp(settings.system.unitSystem);
         this->haHelper->publishSensorDhwFlowRate(false);
 
       } else {
@@ -428,8 +443,9 @@ protected:
       _heatingMaxTemp = heatingMaxTemp;
       _isStupidMode = isStupidMode;
 
-      this->haHelper->publishNumberHeatingTarget(heatingMinTemp, heatingMaxTemp, false);
+      this->haHelper->publishNumberHeatingTarget(settings.system.unitSystem, heatingMinTemp, heatingMaxTemp, false);
       this->haHelper->publishClimateHeating(
+        settings.system.unitSystem,
         heatingMinTemp,
         heatingMaxTemp,
         isStupidMode ? HaHelper::TEMP_SOURCE_HEATING : HaHelper::TEMP_SOURCE_INDOOR
@@ -440,6 +456,7 @@ protected:
     } else if (_isStupidMode != isStupidMode) {
       _isStupidMode = isStupidMode;
       this->haHelper->publishClimateHeating(
+        settings.system.unitSystem,
         heatingMinTemp,
         heatingMaxTemp,
         isStupidMode ? HaHelper::TEMP_SOURCE_HEATING : HaHelper::TEMP_SOURCE_INDOOR
@@ -452,8 +469,8 @@ protected:
       _dhwMinTemp = settings.dhw.minTemp;
       _dhwMaxTemp = settings.dhw.maxTemp;
 
-      this->haHelper->publishNumberDhwTarget(settings.dhw.minTemp, settings.dhw.maxTemp, false);
+      this->haHelper->publishNumberDhwTarget(settings.system.unitSystem, settings.dhw.minTemp, settings.dhw.maxTemp, false);
-      this->haHelper->publishClimateDhw(settings.dhw.minTemp, settings.dhw.maxTemp);
+      this->haHelper->publishClimateDhw(settings.system.unitSystem, settings.dhw.minTemp, settings.dhw.maxTemp);
 
       published = true;
     }
@@ -463,10 +480,10 @@ protected:
 
       if (editableOutdoorTemp) {
         this->haHelper->deleteSensorOutdoorTemp();
-        this->haHelper->publishNumberOutdoorTemp();
+        this->haHelper->publishNumberOutdoorTemp(settings.system.unitSystem);
       } else {
         this->haHelper->deleteNumberOutdoorTemp();
-        this->haHelper->publishSensorOutdoorTemp();
+        this->haHelper->publishSensorOutdoorTemp(settings.system.unitSystem);
       }
 
       published = true;
@@ -477,10 +494,10 @@ protected:
 
       if (editableIndoorTemp) {
         this->haHelper->deleteSensorIndoorTemp();
-        this->haHelper->publishNumberIndoorTemp();
+        this->haHelper->publishNumberIndoorTemp(settings.system.unitSystem);
       } else {
         this->haHelper->deleteNumberIndoorTemp();
-        this->haHelper->publishSensorIndoorTemp();
+        this->haHelper->publishSensorIndoorTemp(settings.system.unitSystem);
       }
 
       published = true;

src/OpenThermTask.h

@@ -44,6 +44,13 @@ protected:
   }
 
   void setup() {
+    if (settings.system.unitSystem != UnitSystem::METRIC) {
+      vars.parameters.heatingMinTemp = convertTemp(vars.parameters.heatingMinTemp, UnitSystem::METRIC, settings.system.unitSystem);
+      vars.parameters.heatingMaxTemp = convertTemp(vars.parameters.heatingMaxTemp, UnitSystem::METRIC, settings.system.unitSystem);
+      vars.parameters.dhwMinTemp = convertTemp(vars.parameters.dhwMinTemp, UnitSystem::METRIC, settings.system.unitSystem);
+      vars.parameters.dhwMaxTemp = convertTemp(vars.parameters.dhwMaxTemp, UnitSystem::METRIC, settings.system.unitSystem);
+    }
+    
     #ifdef LED_OT_RX_GPIO
       pinMode(LED_OT_RX_GPIO, OUTPUT);
       digitalWrite(LED_OT_RX_GPIO, LOW);
@@ -218,12 +225,15 @@ protected:
           }
 
         } else {
+          vars.parameters.dhwMinTemp = convertTemp(DEFAULT_DHW_MIN_TEMP, UnitSystem::METRIC, settings.system.unitSystem);
+          vars.parameters.dhwMaxTemp = convertTemp(DEFAULT_DHW_MAX_TEMP, UnitSystem::METRIC, settings.system.unitSystem);
+
           Log.swarningln(FPSTR(L_OT_DHW), F("Failed get min/max temp"));
         }
 
         if (settings.dhw.minTemp >= settings.dhw.maxTemp) {
-          settings.dhw.minTemp = 30;
+          settings.dhw.minTemp = vars.parameters.dhwMinTemp;
-          settings.dhw.maxTemp = 60;
+          settings.dhw.maxTemp = vars.parameters.dhwMaxTemp;
           fsSettings.update();
         }
       }
@@ -244,15 +254,17 @@ protected:
             Log.snoticeln(FPSTR(L_OT_HEATING), F("Updated max temp: %hhu"), settings.heating.maxTemp);
           }
 
-        } else {
+      } else {
-          Log.swarningln(FPSTR(L_OT_HEATING), F("Failed get min/max temp"));
+        vars.parameters.heatingMinTemp = convertTemp(DEFAULT_HEATING_MIN_TEMP, UnitSystem::METRIC, settings.system.unitSystem);
-        }
+        vars.parameters.heatingMaxTemp = convertTemp(DEFAULT_HEATING_MAX_TEMP, UnitSystem::METRIC, settings.system.unitSystem);
 
-        if (settings.heating.minTemp >= settings.heating.maxTemp) {
+        Log.swarningln(FPSTR(L_OT_HEATING), F("Failed get min/max temp"));
-          settings.heating.minTemp = 20;
+      }
-          settings.heating.maxTemp = 90;
+
-          fsSettings.update();
+      if (settings.heating.minTemp >= settings.heating.maxTemp) {
-        }
+        settings.heating.minTemp = vars.parameters.heatingMinTemp;
+        settings.heating.maxTemp = vars.parameters.heatingMaxTemp;
+        fsSettings.update();
       }
 
       // Get outdoor temp (if necessary)
@@ -330,15 +342,16 @@ protected:
 
     // Update DHW temp
     byte newDhwTemp = settings.dhw.target;
-    if (settings.opentherm.dhwPresent && settings.dhw.enable && (needSetDhwTemp() || newDhwTemp != currentDhwTemp)) {
+    if (settings.opentherm.dhwPresent && settings.dhw.enable && (this->needSetDhwTemp() || newDhwTemp != currentDhwTemp)) {
       if (newDhwTemp < settings.dhw.minTemp || newDhwTemp > settings.dhw.maxTemp) {
         newDhwTemp = constrain(newDhwTemp, settings.dhw.minTemp, settings.dhw.maxTemp);
       }
 
-      Log.sinfoln(FPSTR(L_OT_DHW), F("Set temp = %u"), newDhwTemp);
+      float convertedTemp = convertTemp(newDhwTemp, settings.system.unitSystem, settings.opentherm.unitSystem);
+      Log.sinfoln(FPSTR(L_OT_DHW), F("Set temp: %u (converted: %.2f)"), newDhwTemp, convertedTemp);
 
       // Set DHW temp
-      if (this->instance->setDhwTemp(newDhwTemp)) {
+      if (this->instance->setDhwTemp(convertedTemp)) {
         currentDhwTemp = newDhwTemp;
         this->dhwSetTempTime = millis();
 
@@ -348,7 +361,7 @@ protected:
 
       // Set DHW temp to CH2
       if (settings.opentherm.dhwToCh2) {
-        if (!this->instance->setHeatingCh2Temp(newDhwTemp)) {
+        if (!this->instance->setHeatingCh2Temp(convertedTemp)) {
           Log.swarningln(FPSTR(L_OT_DHW), F("Failed set ch2 temp"));
         }
       }
@@ -356,11 +369,12 @@ protected:
 
 
     // Update heating temp
-    if (heatingEnabled && (needSetHeatingTemp() || fabs(vars.parameters.heatingSetpoint - currentHeatingTemp) > 0.0001)) {
+    if (heatingEnabled && (this->needSetHeatingTemp() || fabs(vars.parameters.heatingSetpoint - currentHeatingTemp) > 0.0001)) {
-      Log.sinfoln(FPSTR(L_OT_HEATING), F("Set temp = %u"), vars.parameters.heatingSetpoint);
+      float convertedTemp = convertTemp(vars.parameters.heatingSetpoint, settings.system.unitSystem, settings.opentherm.unitSystem);
+      Log.sinfoln(FPSTR(L_OT_HEATING), F("Set temp: %u (converted: %.2f)"), vars.parameters.heatingSetpoint, convertedTemp);
 
       // Set heating temp
-      if (this->instance->setHeatingCh1Temp(vars.parameters.heatingSetpoint) || this->setMaxHeatingTemp(vars.parameters.heatingSetpoint)) {
+      if (this->instance->setHeatingCh1Temp(convertedTemp) || this->setMaxHeatingTemp(convertedTemp)) {
         currentHeatingTemp = vars.parameters.heatingSetpoint;
         this->heatingSetTempTime = millis();
 
@@ -370,7 +384,7 @@ protected:
 
       // Set heating temp to CH2
       if (settings.opentherm.heatingCh1ToCh2) {
-        if (!this->instance->setHeatingCh2Temp(vars.parameters.heatingSetpoint)) {
+        if (!this->instance->setHeatingCh2Temp(convertedTemp)) {
           Log.swarningln(FPSTR(L_OT_HEATING), F("Failed set ch2 temp"));
         }
       }
@@ -395,7 +409,7 @@ protected:
 
   void initialize() {
     // Not all boilers support these, only try once when the boiler becomes connected
-    if (updateSlaveVersion()) {
+    if (this->updateSlaveVersion()) {
       Log.straceln(FPSTR(L_OT), F("Slave version: %u, type: %u"), vars.parameters.slaveVersion, vars.parameters.slaveType);
 
     } else {
@@ -403,21 +417,21 @@ protected:
     }
 
     // 0x013F
-    if (setMasterVersion(0x3F, 0x01)) {
+    if (this->setMasterVersion(0x3F, 0x01)) {
       Log.straceln(FPSTR(L_OT), F("Master version: %u, type: %u"), vars.parameters.masterVersion, vars.parameters.masterType);
       
     } else {
       Log.swarningln(FPSTR(L_OT), F("Set master version failed"));
     }
 
-    if (updateSlaveConfig()) {
+    if (this->updateSlaveConfig()) {
       Log.straceln(FPSTR(L_OT), F("Slave member id: %u, flags: %u"), vars.parameters.slaveMemberId, vars.parameters.slaveFlags);
 
     } else {
       Log.swarningln(FPSTR(L_OT), F("Get slave config failed"));
     }
 
-    if (setMasterConfig(settings.opentherm.memberIdCode & 0xFF, (settings.opentherm.memberIdCode & 0xFFFF) >> 8)) {
+    if (this->setMasterConfig(settings.opentherm.memberIdCode & 0xFF, (settings.opentherm.memberIdCode & 0xFFFF) >> 8)) {
       Log.straceln(FPSTR(L_OT), F("Master member id: %u, flags: %u"), vars.parameters.masterMemberId, vars.parameters.masterFlags);
       
     } else {
@@ -603,8 +617,8 @@ protected:
     byte maxTemp = (response & 0xFFFF) >> 8;
 
     if (minTemp >= 0 && maxTemp > 0 && maxTemp > minTemp) {
-      vars.parameters.dhwMinTemp = minTemp;
+      vars.parameters.dhwMinTemp = convertTemp(minTemp, settings.opentherm.unitSystem, settings.system.unitSystem);
-      vars.parameters.dhwMaxTemp = maxTemp;
+      vars.parameters.dhwMaxTemp = convertTemp(maxTemp, settings.opentherm.unitSystem, settings.system.unitSystem);
 
       return true;
     }
@@ -627,8 +641,8 @@ protected:
     byte maxTemp = (response & 0xFFFF) >> 8;
 
     if (minTemp >= 0 && maxTemp > 0 && maxTemp > minTemp) {
-      vars.parameters.heatingMinTemp = minTemp;
+      vars.parameters.heatingMinTemp = convertTemp(minTemp, settings.opentherm.unitSystem, settings.system.unitSystem);
-      vars.parameters.heatingMaxTemp = maxTemp;
+      vars.parameters.heatingMaxTemp = convertTemp(maxTemp, settings.opentherm.unitSystem, settings.system.unitSystem);
       return true;
     }
 
@@ -655,8 +669,13 @@ protected:
     if (!CustomOpenTherm::isValidResponse(response)) {
       return false;
     }
+    
+    vars.temperatures.outdoor = settings.sensors.outdoor.offset + convertTemp(
+      CustomOpenTherm::getFloat(response),
+      settings.opentherm.unitSystem,
+      settings.system.unitSystem
+    );
 
-    vars.temperatures.outdoor = CustomOpenTherm::getFloat(response) + settings.sensors.outdoor.offset;
     return true;
   }
 
@@ -671,8 +690,16 @@ protected:
       return false;
     }
 
-    short value = CustomOpenTherm::getInt(response);
+    float value = (float) CustomOpenTherm::getInt(response);
-    vars.temperatures.exhaust = (value >= -40 && value <= 500) ? (float)value : 0.0f;
+    if (!isValidTemp(value, settings.opentherm.unitSystem, -40, 500)) {
+      return false;
+    }
+
+    vars.temperatures.exhaust = convertTemp(
+      value,
+      settings.opentherm.unitSystem,
+      settings.system.unitSystem
+    );
 
     return true;
   }
@@ -693,7 +720,12 @@ protected:
       return false;
     }
 
-    vars.temperatures.heating = value;
+    vars.temperatures.heating = convertTemp(
+      value,
+      settings.opentherm.unitSystem,
+      settings.system.unitSystem
+    );
+
     return true;
   }
 
@@ -708,7 +740,12 @@ protected:
       return false;
     }
 
-    vars.temperatures.heatingReturn = CustomOpenTherm::getFloat(response);
+    vars.temperatures.heatingReturn = convertTemp(
+      CustomOpenTherm::getFloat(response),
+      settings.opentherm.unitSystem,
+      settings.system.unitSystem
+    );
+
     return true;
   }
 
@@ -729,7 +766,12 @@ protected:
       return false;
     }
 
-    vars.temperatures.dhw = value;
+    vars.temperatures.dhw = convertTemp(
+      value,
+      settings.opentherm.unitSystem,
+      settings.system.unitSystem
+    );
+
     return true;
   }
 

src/PortalTask.h

@@ -434,6 +434,7 @@ protected:
       JsonDocument doc;
       varsToJson(vars, doc);
 
+      doc["system"]["unitSystem"] = static_cast<byte>(settings.system.unitSystem);
       doc["system"]["version"] = PROJECT_VERSION;
       doc["system"]["buildDate"] = __DATE__ " " __TIME__;
       doc["system"]["uptime"] = millis() / 1000ul;

src/RegulatorTask.h

@@ -69,7 +69,7 @@ protected:
       }
     }
 
-    // Ограничиваем, если до этого не ограничило
+    // Limits
     if (newTemp < settings.heating.minTemp || newTemp > settings.heating.maxTemp) {
       newTemp = constrain(newTemp, settings.heating.minTemp, settings.heating.maxTemp);
     }
@@ -182,7 +182,6 @@ protected:
     }
 
     newTemp = round(newTemp);
-    newTemp = constrain(newTemp, 0, 100);
     return newTemp;
   }
 
@@ -273,16 +272,36 @@ protected:
     }
   }
 
+  /**
+   * @brief Get the Equitherm Temp
+   * Calculations in degrees C, conversion occurs when using F
+   * 
+   * @param minTemp 
+   * @param maxTemp 
+   * @return float 
+   */
   float getEquithermTemp(int minTemp, int maxTemp) {
+    float targetTemp = vars.states.emergency ? settings.emergency.target : settings.heating.target;
+    float indoorTemp = vars.temperatures.indoor;
+    float outdoorTemp = vars.temperatures.outdoor;
+
+    if (settings.system.unitSystem == UnitSystem::IMPERIAL) {
+      minTemp = f2c(minTemp);
+      maxTemp = f2c(maxTemp);
+      targetTemp = f2c(targetTemp);
+      indoorTemp = f2c(indoorTemp);
+      outdoorTemp = f2c(outdoorTemp);
+    }
+
     if (vars.states.emergency) {
       etRegulator.Kt = 0;
       etRegulator.indoorTemp = 0;
-      etRegulator.outdoorTemp = vars.temperatures.outdoor;
+      etRegulator.outdoorTemp = outdoorTemp;
 
     } else if (settings.pid.enable) {
       etRegulator.Kt = 0;
-      etRegulator.indoorTemp = round(vars.temperatures.indoor);
+      etRegulator.indoorTemp = round(indoorTemp);
-      etRegulator.outdoorTemp = round(vars.temperatures.outdoor);
+      etRegulator.outdoorTemp = round(outdoorTemp);
 
     } else {
       if (settings.heating.turbo) {
@@ -290,17 +309,21 @@ protected:
       } else {
         etRegulator.Kt = settings.equitherm.t_factor;
       }
-      etRegulator.indoorTemp = vars.temperatures.indoor;
+      etRegulator.indoorTemp = indoorTemp;
-      etRegulator.outdoorTemp = vars.temperatures.outdoor;
+      etRegulator.outdoorTemp = outdoorTemp;
     }
 
     etRegulator.setLimits(minTemp, maxTemp);
     etRegulator.Kn = settings.equitherm.n_factor;
-    // etRegulator.Kn = tuneEquithermN(etRegulator.Kn, vars.temperatures.indoor, settings.heating.target, 300, 1800, 0.01, 1);
     etRegulator.Kk = settings.equitherm.k_factor;
-    etRegulator.targetTemp = vars.states.emergency ? settings.emergency.target : settings.heating.target;
+    etRegulator.targetTemp = targetTemp;
+    float result = etRegulator.getResult();
 
-    return etRegulator.getResult();
+    if (settings.system.unitSystem == UnitSystem::IMPERIAL) {
+      result = c2f(result);
+    }
+
+    return result;
   }
 
   float getPidTemp(int minTemp, int maxTemp) {

src/SensorsTask.h

@@ -79,14 +79,34 @@ protected:
     }
     #endif
 
-    if (outdoorTempUpdated && fabs(vars.temperatures.outdoor - this->filteredOutdoorTemp) > 0.099) {
+    if (outdoorTempUpdated) {
-      vars.temperatures.outdoor = this->filteredOutdoorTemp + settings.sensors.outdoor.offset;
+      float newTemp = settings.sensors.outdoor.offset;
-      Log.sinfoln(FPSTR(L_SENSORS_OUTDOOR), F("New temp: %f"), vars.temperatures.outdoor);
+      if (settings.system.unitSystem == UnitSystem::METRIC) {
+        newTemp += this->filteredOutdoorTemp;
+
+      } else if (settings.system.unitSystem == UnitSystem::IMPERIAL) {
+        newTemp += c2f(this->filteredOutdoorTemp);
+      }
+
+      if (fabs(vars.temperatures.outdoor - newTemp) > 0.099) {
+        vars.temperatures.outdoor = newTemp;
+        Log.sinfoln(FPSTR(L_SENSORS_OUTDOOR), F("New temp: %f"), vars.temperatures.outdoor);
+      }
     }
 
-    if (indoorTempUpdated && fabs(vars.temperatures.indoor - this->filteredIndoorTemp) > 0.099) {
+    if (indoorTempUpdated) {
-      vars.temperatures.indoor = this->filteredIndoorTemp + settings.sensors.indoor.offset;
+      float newTemp = settings.sensors.indoor.offset;
-      Log.sinfoln(FPSTR(L_SENSORS_INDOOR), F("New temp: %f"), vars.temperatures.indoor);
+      if (settings.system.unitSystem == UnitSystem::METRIC) {
+        newTemp += this->filteredIndoorTemp;
+
+      } else if (settings.system.unitSystem == UnitSystem::IMPERIAL) {
+        newTemp += c2f(this->filteredIndoorTemp);
+      }
+
+      if (fabs(vars.temperatures.indoor - newTemp) > 0.099) {
+        vars.temperatures.indoor = newTemp;
+        Log.sinfoln(FPSTR(L_SENSORS_INDOOR), F("New temp: %f"), vars.temperatures.indoor);
+      }
     }
   }
 

src/Settings.h

@@ -27,6 +27,7 @@ struct Settings {
     bool debug = DEBUG_BY_DEFAULT;
     bool useSerial = USE_SERIAL;
     bool useTelnet = USE_TELNET;
+    UnitSystem unitSystem = UnitSystem::METRIC;
   } system;
 
   struct {
@@ -36,6 +37,7 @@ struct Settings {
   } portal;
 
   struct {
+    UnitSystem unitSystem = UnitSystem::METRIC;
     byte inGpio = DEFAULT_OT_IN_GPIO;
     byte outGpio = DEFAULT_OT_OUT_GPIO;
     unsigned int memberIdCode = 0;

src/defines.h

@@ -118,4 +118,9 @@ enum class SensorType : byte {
   BLUETOOTH
 };
 
+enum class UnitSystem : byte {
+  METRIC,
+  IMPERIAL
+};
+
 char buffer[255];

src/utils.h

@@ -1,5 +1,36 @@
 #include <Arduino.h>
 
+inline float c2f(float value) {
+  return (9.0f / 5.0f) * value + 32.0f;
+}
+
+inline float f2c(float value) {
+  return (value - 32.0f) * (5.0f / 9.0f);
+}
+
+float convertTemp(float value, const UnitSystem unitFrom, const UnitSystem unitTo) {
+  if (unitFrom == UnitSystem::METRIC && unitTo == UnitSystem::IMPERIAL) {
+    value = c2f(value);
+    
+  } else if (unitFrom == UnitSystem::IMPERIAL && unitTo == UnitSystem::METRIC) {
+    value = f2c(value);
+  }
+
+  return value;
+}
+
+bool isValidTemp(const float value, UnitSystem unit, const float min = 0.1f, const float max = 99.9f) {
+  if (unit == UnitSystem::METRIC) {
+    return value >= min && value <= max;
+
+  } else if (unit == UnitSystem::IMPERIAL) {
+    return value >= c2f(min) && value <= c2f(max);
+
+  } else {
+    return false;
+  }
+}
+
 double roundd(double value, uint8_t decimals = 2) {
   if (decimals == 0) {
     return (int)(value + 0.5);
@@ -13,7 +44,7 @@ double roundd(double value, uint8_t decimals = 2) {
   return (int)(value * multiplier) / multiplier;
 }
 
-size_t getTotalHeap() {
+inline size_t getTotalHeap() {
   #if defined(ARDUINO_ARCH_ESP32)
   return ESP.getHeapSize();
   #elif defined(ARDUINO_ARCH_ESP8266)
@@ -63,7 +94,7 @@ size_t getMaxFreeBlockHeap(bool getMinValue = false) {
   return getMinValue ? minValue : value;
 }
 
-uint8_t getHeapFrag() {
+inline uint8_t getHeapFrag() {
   return 100 - getMaxFreeBlockHeap() * 100.0 / getFreeHeap();
 }
 
@@ -268,11 +299,13 @@ void settingsToJson(const Settings& src, JsonVariant dst, bool safe = false) {
     dst["system"]["debug"] = src.system.debug;
     dst["system"]["useSerial"] = src.system.useSerial;
     dst["system"]["useTelnet"] = src.system.useTelnet;
+    dst["system"]["unitSystem"] = static_cast<byte>(src.system.unitSystem);
 
     dst["portal"]["useAuth"] = src.portal.useAuth;
     dst["portal"]["login"] = src.portal.login;
     dst["portal"]["password"] = src.portal.password;
 
+    dst["opentherm"]["unitSystem"] = static_cast<byte>(src.opentherm.unitSystem);
     dst["opentherm"]["inGpio"] = src.opentherm.inGpio;
     dst["opentherm"]["outGpio"] = src.opentherm.outGpio;
     dst["opentherm"]["memberIdCode"] = src.opentherm.memberIdCode;
@@ -378,6 +411,39 @@ bool jsonToSettings(const JsonVariantConst src, Settings& dst, bool safe = false
       changed = true;
     }
 
+    if (!src["system"]["unitSystem"].isNull()) {
+      byte value = src["system"]["unitSystem"].as<unsigned char>();
+      UnitSystem prevUnitSystem = dst.system.unitSystem;
+
+      switch (value) {
+        case static_cast<byte>(UnitSystem::METRIC):
+          dst.system.unitSystem = UnitSystem::METRIC;
+          changed = true;
+          break;
+
+        case static_cast<byte>(UnitSystem::IMPERIAL):
+          dst.system.unitSystem = UnitSystem::IMPERIAL;
+          changed = true;
+          break;
+
+        default:
+          break;
+      }
+
+      // convert temps
+      if (dst.system.unitSystem != prevUnitSystem) {
+        dst.emergency.target = convertTemp(dst.emergency.target, prevUnitSystem, dst.system.unitSystem);
+        dst.heating.target = convertTemp(dst.heating.target, prevUnitSystem, dst.system.unitSystem);
+        dst.heating.minTemp = convertTemp(dst.heating.minTemp, prevUnitSystem, dst.system.unitSystem);
+        dst.heating.maxTemp = convertTemp(dst.heating.maxTemp, prevUnitSystem, dst.system.unitSystem);
+        dst.dhw.target = convertTemp(dst.dhw.target, prevUnitSystem, dst.system.unitSystem);
+        dst.dhw.minTemp = convertTemp(dst.dhw.minTemp, prevUnitSystem, dst.system.unitSystem);
+        dst.dhw.maxTemp = convertTemp(dst.dhw.maxTemp, prevUnitSystem, dst.system.unitSystem);
+        dst.pid.minTemp = convertTemp(dst.pid.minTemp, prevUnitSystem, dst.system.unitSystem);
+        dst.pid.maxTemp = convertTemp(dst.pid.maxTemp, prevUnitSystem, dst.system.unitSystem);
+      }
+    }
+
 
     // portal
     if (src["portal"]["useAuth"].is<bool>()) {
@@ -405,6 +471,25 @@ bool jsonToSettings(const JsonVariantConst src, Settings& dst, bool safe = false
 
 
     // opentherm
+    if (!src["opentherm"]["unitSystem"].isNull()) {
+      byte value = src["opentherm"]["unitSystem"].as<unsigned char>();
+
+      switch (value) {
+        case static_cast<byte>(UnitSystem::METRIC):
+          dst.opentherm.unitSystem = UnitSystem::METRIC;
+          changed = true;
+          break;
+
+        case static_cast<byte>(UnitSystem::IMPERIAL):
+          dst.opentherm.unitSystem = UnitSystem::IMPERIAL;
+          changed = true;
+          break;
+
+        default:
+          break;
+      }
+    }
+
     if (!src["opentherm"]["inGpio"].isNull()) {
       if (src["opentherm"]["inGpio"].is<JsonString>() && src["opentherm"]["inGpio"].as<JsonString>().size() == 0) {
         if (dst.opentherm.inGpio != GPIO_IS_NOT_CONFIGURED) {
@@ -573,7 +658,7 @@ bool jsonToSettings(const JsonVariantConst src, Settings& dst, bool safe = false
   if (!src["emergency"]["target"].isNull()) {
     double value = src["emergency"]["target"].as<double>();
 
-    if (value > 0 && value < 100) {
+    if (isValidTemp(value, dst.system.unitSystem)) {
       dst.emergency.target = roundd(value, 2);
       changed = true;
     }
@@ -624,7 +709,7 @@ bool jsonToSettings(const JsonVariantConst src, Settings& dst, bool safe = false
   if (!src["heating"]["target"].isNull()) {
     double value = src["heating"]["target"].as<double>();
 
-    if (value > 0 && value < 100) {
+    if (isValidTemp(value, dst.system.unitSystem)) {
       dst.heating.target = roundd(value, 2);
       changed = true;
     }
@@ -676,7 +761,7 @@ bool jsonToSettings(const JsonVariantConst src, Settings& dst, bool safe = false
   if (!src["dhw"]["target"].isNull()) {
     unsigned char value = src["dhw"]["target"].as<unsigned char>();
 
-    if (value >= 0 && value < 100) {
+    if (isValidTemp(value, dst.system.unitSystem)) {
       dst.dhw.target = value;
       changed = true;
     }
@@ -746,7 +831,7 @@ bool jsonToSettings(const JsonVariantConst src, Settings& dst, bool safe = false
   if (!src["pid"]["maxTemp"].isNull()) {
     unsigned char value = src["pid"]["maxTemp"].as<unsigned char>();
 
-    if (value > 0 && value <= 100 && value > dst.pid.minTemp) {
+    if (isValidTemp(value, dst.system.unitSystem) && value > dst.pid.minTemp) {
       dst.pid.maxTemp = value;
       changed = true;
     }
@@ -755,7 +840,7 @@ bool jsonToSettings(const JsonVariantConst src, Settings& dst, bool safe = false
   if (!src["pid"]["minTemp"].isNull()) {
     unsigned char value = src["pid"]["minTemp"].as<unsigned char>();
 
-    if (value >= 0 && value < 100 && value < dst.pid.maxTemp) {
+    if (isValidTemp(value, dst.system.unitSystem) && value < dst.pid.maxTemp) {
       dst.pid.minTemp = value;
       changed = true;
     }
@@ -1039,7 +1124,7 @@ bool jsonToVars(const JsonVariantConst src, Variables& dst) {
   if (!src["temperatures"]["indoor"].isNull()) {
     double value = src["temperatures"]["indoor"].as<double>();
 
-    if (settings.sensors.indoor.type == SensorType::MANUAL && value > -100 && value < 100) {
+    if (settings.sensors.indoor.type == SensorType::MANUAL && isValidTemp(value, settings.system.unitSystem, -99.9f, 99.9f)) {
       dst.temperatures.indoor = roundd(value, 2);
       changed = true;
     }
@@ -1048,7 +1133,7 @@ bool jsonToVars(const JsonVariantConst src, Variables& dst) {
   if (!src["temperatures"]["outdoor"].isNull()) {
     double value = src["temperatures"]["outdoor"].as<double>();
 
-    if (settings.sensors.outdoor.type == SensorType::MANUAL && value > -100 && value < 100) {
+    if (settings.sensors.outdoor.type == SensorType::MANUAL && isValidTemp(value, settings.system.unitSystem, -99.9f, 99.9f)) {
       dst.temperatures.outdoor = roundd(value, 2);
       changed = true;
     }

src_data/static/app.js

@@ -484,6 +484,7 @@ async function loadSettings() {
   setCheckboxValue('.system-debug', result.system.debug);
   setCheckboxValue('.system-use-serial', result.system.useSerial);
   setCheckboxValue('.system-use-telnet', result.system.useTelnet);
+  setRadioValue('.system-unit-system', result.system.unitSystem);
   setBusy('#system-settings-busy', '#system-settings', false);
 
   setCheckboxValue('.portal-use-auth', result.portal.useAuth);
@@ -491,6 +492,7 @@ async function loadSettings() {
   setInputValue('.portal-password', result.portal.password);
   setBusy('#portal-settings-busy', '#portal-settings', false);
 
+  setRadioValue('.opentherm-unit-system', result.opentherm.unitSystem);
   setInputValue('.opentherm-in-gpio', result.opentherm.inGpio < 255 ? result.opentherm.inGpio : '');
   setInputValue('.opentherm-out-gpio', result.opentherm.outGpio < 255 ? result.opentherm.outGpio : '');
   setInputValue('.opentherm-member-id-code', result.opentherm.memberIdCode);
@@ -535,6 +537,21 @@ async function loadVars() {
   let response = await fetch('/api/vars');
   let result = await response.json();
 
+  let unitSystemStr;
+  switch (result.system.unitSystem) {
+    case 0:
+      unitSystemStr = 'C';
+      break;
+
+    case 1:
+      unitSystemStr = 'F';
+      break;
+
+    default:
+      unitSystemStr = '?';
+      break;
+  }
+
   setState('.ot-connected', result.states.otStatus);
   setState('.ot-emergency', result.states.emergency);
   setState('.ot-heating', result.states.heating);
@@ -553,10 +570,13 @@ async function loadVars() {
   setValue('.outdoor-temp', result.temperatures.outdoor);
   setValue('.heating-temp', result.temperatures.heating);
   setValue('.heating-setpoint-temp', result.parameters.heatingSetpoint);
+  setValue('.heating-return-temp', result.temperatures.heatingReturn);
   setValue('.dhw-temp', result.temperatures.dhw);
+  setValue('.exhaust-temp', result.temperatures.exhaust);
 
   setBusy('.ot-busy', '.ot-table', false);
 
+  setValue('.unit-system', unitSystemStr);
   setValue('.version', result.system.version);
   setValue('.build-date', result.system.buildDate);
   setValue('.uptime', result.system.uptime);
@@ -602,12 +622,14 @@ function setState(selector, value) {
 }
 
 function setValue(selector, value) {
-  let item = document.querySelector(selector);
+  let items = document.querySelectorAll(selector);
-  if (!item) {
+  if (!items.length) {
     return;
   }
 
-  item.innerHTML = value;
+  for (let item of items) {
+    item.innerHTML = value;
+  }
 }
 
 function setCheckboxValue(selector, value) {