@homebridge-plugins/homebridge-tado 9.2.0 → 9.3.0

package/CHANGELOG.md

@@ -1,7 +1,21 @@
 # Changelog
 
+# v9.3.0 - 2026-06-18
+- Fix: Treat tado zone id `0` as a valid zone id when resolving and updating configured zones (#169)
+- Fix: Resolve missing `HOT_WATER` zone ids for temperature-controlled boiler `HeaterCooler` accessories before sending overlays (#169)
+- Fix: Prevent invalid overlay requests from being sent when a zone id cannot be resolved (#169)
+- Fix: Use a valid configured `HOT_WATER` target temperature when Apple Home turns the accessory back on without providing one (#169)
+- Fix: Clamp only `HOT_WATER` target temperatures to the configured supported range before sending overlays (#169)
+- Fix: Apply `HeaterCooler` temperature limits before restoring cached threshold values to avoid HomeKit range warnings for `HOT_WATER` zones (#169)
+- Improve: Refine update buffer handling for accessory state and temperature updates
+- Update dependencies
+
+# v9.2.1 - 2026-06-06
+- Fix: HeaterCooler temperature limits are no longer overridden by an unset or zero `minValue`/`maxValue` from config (#169)
+- Fix: `accTypeBoiler` is now hidden in the UI when `boilerTempSupport` is enabled, as temperature-controlled hot water devices are always exposed as HeaterCooler (#169)
+
 # v9.2.0 - 2026-06-05
-- Fix: Incorrect warning "CoolingThresholdTemperature exceeded maximum of 35" for HOT_WATER zones with `boilerTempSupport: true` (#169)
+- Fix: Incorrect warning "CoolingThresholdTemperature exceeded maximum of 35" for `HOT_WATER` zones with `boilerTempSupport: true` (#169)
 - Fix: Config UI: show AC-specific fields for AIR_CONDITIONING zones (#173)
 - Update dependencies
 

package/config.schema.json

@@ -682,7 +682,12 @@
                       },
                       "items": [
                         "homes[].zones[].boilerTempSupport",
-                        "homes[].zones[].accTypeBoiler"
+                        {
+                          "key": "homes[].zones[].accTypeBoiler",
+                          "condition": {
+                            "functionBody": "try { return !model.homes[arrayIndices[0]].zones[arrayIndices[1]].boilerTempSupport } catch(e){ return false }"
+                          }
+                        }
                       ]
                     },
                     {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@homebridge-plugins/homebridge-tado",
-  "version": "9.2.0",
+  "version": "9.3.0",
   "description": "Homebridge plugin for controlling tado° devices.",
   "main": "index.js",
   "scripts": {
@@ -35,15 +35,15 @@
   "dependencies": {
     "@homebridge/plugin-ui-utils": "^2.2.4",
     "fakegato-history": "^0.6.7",
-    "form-data": "^4.0.5",
+    "form-data": "^4.0.6",
     "fs-extra": "^11.3.5",
     "got": "^15.0.5",
     "moment": "^2.30.1"
   },
   "devDependencies": {
-    "eslint": "^10.4.1",
+    "eslint": "^10.5.0",
     "@eslint/js": "^10.0.1",
     "globals": "^17.6.0",
-    "prettier": "^3.8.3"
+    "prettier": "^3.8.4"
   }
 }

package/src/accessories/heatercooler.js

@@ -16,13 +16,73 @@ export default class HeaterCoolerAccessory {
 
     this.autoDelayTimeout = null;
 
-    this.updateBuffer = new TadoUpdateBuffer((target, value) => {
-      return this.deviceHandler.setStates(this.accessory, this.accessories, target, value);
-    }, preferSiriTemperature);
+    const temperatureConfig = this.getTemperatureConfig();
+    const isHotWater = this.accessory.context.config.type === 'HOT_WATER';
+    const defaultTemperature = isHotWater ? temperatureConfig.minValue : 20;
+    const clampToRange = isHotWater;
+
+    this.updateBuffer = new TadoUpdateBuffer(
+      (target, value) => {
+        return this.deviceHandler.setStates(this.accessory, this.accessories, target, value);
+      },
+      preferSiriTemperature,
+      defaultTemperature,
+      temperatureConfig.minValue,
+      temperatureConfig.maxValue,
+      clampToRange
+    );
 
     this.getService();
   }
 
+  getTemperatureConfig() {
+    let minValue =
+      this.accessory.context.config.type === 'HOT_WATER'
+        ? this.accessory.context.config.temperatureUnit === 'FAHRENHEIT'
+          ? 86
+          : 30
+        : this.accessory.context.config.temperatureUnit === 'FAHRENHEIT'
+          ? 41
+          : 5;
+
+    let maxValue =
+      this.accessory.context.config.type === 'HOT_WATER'
+        ? this.accessory.context.config.temperatureUnit === 'FAHRENHEIT'
+          ? 149
+          : 65
+        : this.accessory.context.config.temperatureUnit === 'FAHRENHEIT'
+          ? 77
+          : 25;
+
+    //only override temperature limits if config value is explicitly and correctly set
+    if (
+      this.accessory.context.config.minValue != null &&
+      this.accessory.context.config.minValue > 0 &&
+      this.accessory.context.config.minValue < maxValue
+    ) {
+      minValue = this.accessory.context.config.minValue;
+    }
+    if (
+      this.accessory.context.config.maxValue != null &&
+      this.accessory.context.config.maxValue > 0 &&
+      this.accessory.context.config.maxValue > minValue
+    ) {
+      maxValue = this.accessory.context.config.maxValue;
+    }
+
+    const minStep = parseFloat(
+      (this.accessory.context.config.minStep &&
+        !isNaN(this.accessory.context.config.minStep) &&
+        this.accessory.context.config.minStep > 0 &&
+        this.accessory.context.config.minStep <= 1
+        ? parseFloat(this.accessory.context.config.minStep)
+        : 1
+      ).toFixed(2)
+    );
+
+    return { minValue, maxValue, minStep };
+  }
+
   //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
   // Services
   //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
@@ -149,41 +209,7 @@ export default class HeaterCoolerAccessory {
         );
     }
 
-    let minValue =
-      this.accessory.context.config.type === 'HOT_WATER'
-        ? this.accessory.context.config.temperatureUnit === 'CELSIUS'
-          ? 30
-          : 86
-        : this.accessory.context.config.temperatureUnit === 'CELSIUS'
-          ? 5
-          : 41;
-
-    let maxValue =
-      this.accessory.context.config.type === 'HOT_WATER'
-        ? this.accessory.context.config.temperatureUnit === 'CELSIUS'
-          ? 65
-          : 149
-        : this.accessory.context.config.temperatureUnit === 'CELSIUS'
-          ? 25
-          : 77;
-
-    minValue = this.accessory.context.config.minValue < maxValue ? this.accessory.context.config.minValue : minValue;
-
-    maxValue = this.accessory.context.config.maxValue > minValue ? this.accessory.context.config.maxValue : maxValue;
-
-    console.log('Before MINSTEP: ' + this.accessory.context.config.minStep, this.accessory.displayName);
-
-    let minStep = parseFloat(
-      (this.accessory.context.config.minStep &&
-        !isNaN(this.accessory.context.config.minStep) &&
-        this.accessory.context.config.minStep > 0 &&
-        this.accessory.context.config.minStep <= 1
-        ? parseFloat(this.accessory.context.config.minStep)
-        : 1
-      ).toFixed(2)
-    );
-
-    console.log('After MINSTEP: ' + minStep, this.accessory.displayName);
+    const { minValue, maxValue, minStep } = this.getTemperatureConfig();
 
     let maxState = this.accessory.context.config.type === 'HOT_WATER' ? 2 : 3;
 
@@ -220,30 +246,38 @@ export default class HeaterCoolerAccessory {
       maxValue: 255,
     });
 
-    if (service.getCharacteristic(this.api.hap.Characteristic.HeatingThresholdTemperature).value < minValue)
-      service.getCharacteristic(this.api.hap.Characteristic.HeatingThresholdTemperature).updateValue(minValue);
+    const heatingThreshold = service.getCharacteristic(this.api.hap.Characteristic.HeatingThresholdTemperature);
 
-    if (service.getCharacteristic(this.api.hap.Characteristic.HeatingThresholdTemperature).value > maxValue)
-      service.getCharacteristic(this.api.hap.Characteristic.HeatingThresholdTemperature).updateValue(maxValue);
-
-    service.getCharacteristic(this.api.hap.Characteristic.HeatingThresholdTemperature).setProps({
+    heatingThreshold.setProps({
       minValue: minValue,
       maxValue: maxValue,
       minStep: minStep,
     });
 
-    if (this.accessory.context.config.type === 'HEATING') {
-      if (service.getCharacteristic(this.api.hap.Characteristic.CoolingThresholdTemperature).value < minValue)
-        service.getCharacteristic(this.api.hap.Characteristic.CoolingThresholdTemperature).updateValue(minValue);
+    let heatingThresholdValue = Number(heatingThreshold.value);
+
+    if (!Number.isFinite(heatingThresholdValue) || heatingThresholdValue < minValue)
+      heatingThreshold.updateValue(minValue);
 
-      if (service.getCharacteristic(this.api.hap.Characteristic.CoolingThresholdTemperature).value > maxValue)
-        service.getCharacteristic(this.api.hap.Characteristic.CoolingThresholdTemperature).updateValue(maxValue);
+    if (Number.isFinite(heatingThresholdValue) && heatingThresholdValue > maxValue)
+      heatingThreshold.updateValue(maxValue);
 
-      service.getCharacteristic(this.api.hap.Characteristic.CoolingThresholdTemperature).setProps({
+    if (this.accessory.context.config.type === 'HEATING') {
+      const coolingThreshold = service.getCharacteristic(this.api.hap.Characteristic.CoolingThresholdTemperature);
+
+      coolingThreshold.setProps({
         minValue: minValue,
         maxValue: maxValue,
         minStep: minStep,
       });
+
+      let coolingThresholdValue = Number(coolingThreshold.value);
+
+      if (!Number.isFinite(coolingThresholdValue) || coolingThresholdValue < minValue)
+        coolingThreshold.updateValue(minValue);
+
+      if (Number.isFinite(coolingThresholdValue) && coolingThresholdValue > maxValue)
+        coolingThreshold.updateValue(maxValue);
     }
 
     if (!service.testCharacteristic(this.api.hap.Characteristic.ValvePosition))

package/src/helper/handler.js

@@ -30,6 +30,162 @@ export default (api, accessories, config, tado, telegram) => {
     return Object.keys(helpers[config.homeId].activeSettingStateRuns).length > 0;
   }
 
+
+  function _hasZoneId(zoneId) {
+    return zoneId !== undefined && zoneId !== null;
+  }
+
+  function _getExpectedAccessoryName(zone) {
+    return config.homeName + ' ' + zone.name + (zone.type === 'HEATING' ? ' Heater' : zone.type === 'AIR_CONDITIONING' ? ' AC' : ' Boiler');
+  }
+
+  function _getAccessoryNameSuffix(zone) {
+    return zone.name + (zone.type === 'HEATING' ? ' Heater' : zone.type === 'AIR_CONDITIONING' ? ' AC' : ' Boiler');
+  }
+
+  function _isAccessoryForZone(accessory, zone) {
+    return (
+      accessory &&
+      zone &&
+      accessory.context.config.type === zone.type &&
+      (accessory.displayName === _getExpectedAccessoryName(zone) ||
+        accessory.displayName === _getAccessoryNameSuffix(zone) ||
+        accessory.displayName.endsWith(' ' + _getAccessoryNameSuffix(zone)))
+    );
+  }
+
+  function _findConfiguredZoneForAccessory(accessory) {
+    if (!config.zones || !config.zones.length) return;
+
+    return config.zones.find((zone) => _isAccessoryForZone(accessory, zone));
+  }
+
+  async function _getZoneIdForAccessory(accessory) {
+    if (_hasZoneId(accessory.context.config.zoneId)) return accessory.context.config.zoneId;
+
+    let configuredZone = _findConfiguredZoneForAccessory(accessory);
+
+    if (configuredZone && _hasZoneId(configuredZone.id)) {
+      accessory.context.config.zoneId = configuredZone.id;
+      return configuredZone.id;
+    }
+
+    const allZones = (await tado.getZones(config.homeId)) || [];
+
+    for (const [index, zone] of config.zones.entries()) {
+      const foundZone = allZones.find((zoneWithID) => zoneWithID.name === zone.name && zoneWithID.type === zone.type);
+
+      if (foundZone && _hasZoneId(foundZone.id)) {
+        config.zones[index].id = foundZone.id;
+      }
+    }
+
+    configuredZone = _findConfiguredZoneForAccessory(accessory);
+
+    if (configuredZone && _hasZoneId(configuredZone.id)) {
+      accessory.context.config.zoneId = configuredZone.id;
+      return configuredZone.id;
+    }
+
+    Logger.error(`Cannot set state for ${accessory.displayName}: missing tado zone id. Please run reconfigure or add the correct zone id to the zone config.`);
+    return null;
+  }
+
+  function _getTemperatureLimits(accessory) {
+    let min =
+      accessory.context.config.type === 'HOT_WATER'
+        ? accessory.context.config.temperatureUnit === 'FAHRENHEIT'
+          ? 86
+          : 30
+        : accessory.context.config.temperatureUnit === 'FAHRENHEIT'
+          ? 41
+          : 5;
+
+    let max =
+      accessory.context.config.type === 'HOT_WATER'
+        ? accessory.context.config.temperatureUnit === 'FAHRENHEIT'
+          ? 149
+          : 65
+        : accessory.context.config.temperatureUnit === 'FAHRENHEIT'
+          ? 77
+          : 25;
+
+    if (
+      accessory.context.config.minValue != null &&
+      accessory.context.config.minValue > 0 &&
+      accessory.context.config.minValue < max
+    ) {
+      min = accessory.context.config.minValue;
+    }
+
+    if (
+      accessory.context.config.maxValue != null &&
+      accessory.context.config.maxValue > 0 &&
+      accessory.context.config.maxValue > min
+    ) {
+      max = accessory.context.config.maxValue;
+    }
+
+    return { min, max };
+  }
+
+  function _normalizeTemperatureForAccessory(accessory, temp) {
+    if (temp === null || temp === undefined) return temp;
+
+    const numericTemp = Number(temp);
+    if (!Number.isFinite(numericTemp)) return temp;
+
+    if (accessory.context.config.type !== 'HOT_WATER') return parseFloat(numericTemp.toFixed(2));
+
+    const { min, max } = _getTemperatureLimits(accessory);
+
+    return parseFloat(Math.min(Math.max(numericTemp, min), max).toFixed(2));
+  }
+
+  async function _setZoneOverlay(accessory, power, temp, mode) {
+    const zoneId = await _getZoneIdForAccessory(accessory);
+    if (!_hasZoneId(zoneId)) return false;
+
+    await tado.setZoneOverlay(
+      config.homeId,
+      zoneId,
+      power,
+      _normalizeTemperatureForAccessory(accessory, temp),
+      mode,
+      accessory.context.config.temperatureUnit
+    );
+
+    return true;
+  }
+
+  async function _setACZoneOverlay(accessory, power, acMode, temp, fanSpeed, swing, mode) {
+    const zoneId = await _getZoneIdForAccessory(accessory);
+    if (!_hasZoneId(zoneId)) return false;
+
+    await tado.setACZoneOverlay(
+      config.homeId,
+      zoneId,
+      power,
+      acMode,
+      _normalizeTemperatureForAccessory(accessory, temp),
+      fanSpeed,
+      swing,
+      mode,
+      accessory.context.config.temperatureUnit
+    );
+
+    return true;
+  }
+
+  async function _clearZoneOverlay(accessory) {
+    const zoneId = await _getZoneIdForAccessory(accessory);
+    if (!_hasZoneId(zoneId)) return false;
+
+    await tado.clearZoneOverlay(config.homeId, zoneId);
+
+    return true;
+  }
+
   async function setStates(accessory, accs, target, value) {
     let zoneUpdated = false;
     accessories = accs.filter((acc) => acc && acc.context.config.homeName === config.homeName);
@@ -80,27 +236,18 @@ export default (api, accessories, config, tado, telegram) => {
               // Use AC-specific overlay for AIR_CONDITIONING zones
               if (accessory.context.config.type === 'AIR_CONDITIONING') {
                 zoneUpdated = true;
-                await tado.setACZoneOverlay(
-                  config.homeId,
-                  accessory.context.config.zoneId,
+                await _setACZoneOverlay(
+                  accessory,
                   power,
                   'COOL', // Default AC mode for OFF state
                   temp,
                   null, // No fan speed for AC units
                   'OFF', // Default swing
-                  mode,
-                  accessory.context.config.temperatureUnit
+                  mode
                 );
               } else {
                 zoneUpdated = true;
-                await tado.setZoneOverlay(
-                  config.homeId,
-                  accessory.context.config.zoneId,
-                  power,
-                  temp,
-                  mode,
-                  accessory.context.config.temperatureUnit
-                );
+                await _setZoneOverlay(accessory, power, temp, mode);
               }
             } else {
               let mode =
@@ -133,7 +280,7 @@ export default (api, accessories, config, tado, telegram) => {
                     accessory.context.config.subtype.includes('heatercooler'))
                 ) {
                   zoneUpdated = true;
-                  await tado.clearZoneOverlay(config.homeId, accessory.context.config.zoneId);
+                  await _clearZoneOverlay(accessory);
                   return;
                 }
 
@@ -149,27 +296,18 @@ export default (api, accessories, config, tado, telegram) => {
                   let acMode = value === 1 ? 'HEAT' : value === 2 ? 'COOL' : 'COOL';
 
                   zoneUpdated = true;
-                  await tado.setACZoneOverlay(
-                    config.homeId,
-                    accessory.context.config.zoneId,
+                  await _setACZoneOverlay(
+                    accessory,
                     power,
                     acMode,
                     temp,
                     null, // No fan speed for AC units
                     'OFF', // Default swing
-                    mode,
-                    accessory.context.config.temperatureUnit
+                    mode
                   );
                 } else {
                   zoneUpdated = true;
-                  await tado.setZoneOverlay(
-                    config.homeId,
-                    accessory.context.config.zoneId,
-                    power,
-                    temp,
-                    mode,
-                    accessory.context.config.temperatureUnit
-                  );
+                  await _setZoneOverlay(accessory, power, temp, mode);
                 }
 
                 helpers[config.homeId].delayTimer[accessory.displayName] = null;
@@ -196,7 +334,7 @@ export default (api, accessories, config, tado, telegram) => {
                   accessory.context.config.subtype.includes('heatercooler'))
               ) {
                 zoneUpdated = true;
-                await tado.clearZoneOverlay(config.homeId, accessory.context.config.zoneId);
+                await _clearZoneOverlay(accessory);
                 return;
               }
 
@@ -259,27 +397,18 @@ export default (api, accessories, config, tado, telegram) => {
               }
 
               zoneUpdated = true;
-              await tado.setACZoneOverlay(
-                config.homeId,
-                accessory.context.config.zoneId,
+              await _setACZoneOverlay(
+                accessory,
                 power,
                 acMode,
                 temp,
                 null, // No fan speed for AC units
                 'OFF', // Default swing
-                mode,
-                accessory.context.config.temperatureUnit
+                mode
               );
             } else {
               zoneUpdated = true;
-              await tado.setZoneOverlay(
-                config.homeId,
-                accessory.context.config.zoneId,
-                power,
-                temp,
-                mode,
-                accessory.context.config.temperatureUnit
-              );
+              await _setZoneOverlay(accessory, power, temp, mode);
             }
           }
 
@@ -293,7 +422,7 @@ export default (api, accessories, config, tado, telegram) => {
           let temp = null;
           let power = value ? 'ON' : 'OFF';
 
-          if (faucetService) faucetService.getCharacteristic(this.api.hap.Characteristic.InUse).updateValue(value);
+          if (faucetService) faucetService.getCharacteristic(api.hap.Characteristic.InUse).updateValue(value);
 
           let mode =
             accessory.context.config.mode === 'TIMER'
@@ -303,27 +432,18 @@ export default (api, accessories, config, tado, telegram) => {
           // Use AC-specific overlay for AIR_CONDITIONING zones
           if (accessory.context.config.type === 'AIR_CONDITIONING') {
             zoneUpdated = true;
-            await tado.setACZoneOverlay(
-              config.homeId,
-              accessory.context.config.zoneId,
+            await _setACZoneOverlay(
+              accessory,
               power,
               'COOL', // Default AC mode for switch/faucet
               temp,
               null, // No fan speed for AC units
               'OFF', // Default swing
-              mode,
-              accessory.context.config.temperatureUnit
+              mode
             );
           } else {
             zoneUpdated = true;
-            await tado.setZoneOverlay(
-              config.homeId,
-              accessory.context.config.zoneId,
-              power,
-              temp,
-              mode,
-              accessory.context.config.temperatureUnit
-            );
+            await _setZoneOverlay(accessory, power, temp, mode);
           }
 
           break;
@@ -899,7 +1019,7 @@ export default (api, accessories, config, tado, telegram) => {
     let inOffMode = 0;
     let inAutoMode = 0;
 
-    let zonesWithoutID = config.zones.filter((zone) => zone && !zone.id);
+    let zonesWithoutID = config.zones.filter((zone) => zone && !_hasZoneId(zone.id));
 
     if (zonesWithoutID.length) {
       const allZones = (await tado.getZones(config.homeId)) || [];
@@ -917,11 +1037,11 @@ export default (api, accessories, config, tado, telegram) => {
     for (const [index, zone] of config.zones.entries()) {
       allZones.forEach((zoneWithID) => {
         if (zoneWithID.name === zone.name && zoneWithID.type === zone.type) {
-          const heatAccessory = accessories.filter(
-            (acc) => acc && acc.displayName === config.homeName + ' ' + zone.name + ' Heater'
-          );
+          const zoneAccessories = accessories.filter((acc) => _isAccessoryForZone(acc, zone));
 
-          if (heatAccessory.length) heatAccessory[0].context.config.zoneId = zoneWithID.id;
+          zoneAccessories.forEach((acc) => {
+            acc.context.config.zoneId = zoneWithID.id;
+          });
 
           config.zones[index].id = zoneWithID.id;
           config.zones[index].battery = !config.zones[index].noBattery
@@ -949,9 +1069,19 @@ export default (api, accessories, config, tado, telegram) => {
     }
 
     for (const zone of config.zones) {
+      if (!_hasZoneId(zone.id)) {
+        Logger.warn(`Skipping zone ${zone.name}: missing tado zone id.`);
+        continue;
+      }
+
       const zoneState = zoneStates[zone.id.toString()];
       Logger.debug(`Update state of zone ${zone.id} to:`, zoneState);
 
+      if (!zoneState || !zoneState.setting) {
+        Logger.warn(`Skipping zone ${zone.name}: missing tado zone state.`);
+        continue;
+      }
+
       let currentState, targetState, currentTemp, targetTemp, humidity, active, battery, tempEqual;
 
       if (zoneState.setting.type === 'HEATING') {

package/src/helper/update-buffer.js

@@ -2,7 +2,7 @@ import { hrtime } from "process";
 import Logger from '../helper/logger.js';
 
 export class TadoUpdateBuffer {
-  constructor(sendUpdateFn, preferSiriTemperature = false) {
+  constructor(sendUpdateFn, preferSiriTemperature = false, defaultTemperature = 20, minTemperature = 5, maxTemperature = null, clampToRange = false) {
     this.preferSiriTemperature = !!preferSiriTemperature;
     this.sendUpdateFn = sendUpdateFn;
     this.delay = 400;
@@ -10,7 +10,12 @@ export class TadoUpdateBuffer {
     this.pendingState = null;
     this.pendingTemperature = null;
     this.lastUpdateTime = null;
-    this.lastTemperature = 20;
+    this.minTemperature = Number.isFinite(Number(minTemperature)) ? Number(minTemperature) : 5;
+    this.maxTemperature = Number.isFinite(Number(maxTemperature)) ? Number(maxTemperature) : null;
+    this.clampToRange = !!clampToRange;
+
+    const normalizedDefaultTemperature = this._normalizeTemperature(defaultTemperature);
+    this.lastTemperature = normalizedDefaultTemperature ?? (this.clampToRange ? this.minTemperature : 20);
   }
 
   setState(value) {
@@ -25,6 +30,16 @@ export class TadoUpdateBuffer {
     Logger.debug("[TadoUpdateBuffer] setTemperature", value, hrtime.bigint());
   }
 
+  _normalizeTemperature(value) {
+    const temp = Number(value);
+    if (!Number.isFinite(temp)) return null;
+
+    if (temp < this.minTemperature) return this.clampToRange ? this.minTemperature : null;
+    if (this.maxTemperature !== null && temp > this.maxTemperature) return this.clampToRange ? this.maxTemperature : temp;
+
+    return parseFloat(temp.toFixed(2));
+  }
+
   _schedule() {
     if (this.timer) clearTimeout(this.timer);
     this.timer = setTimeout(() => this._apply(), this.delay);
@@ -33,15 +48,17 @@ export class TadoUpdateBuffer {
   _apply() {
     this.timer = null;
     const state = this.pendingState;
-    const temp = this.pendingTemperature;
-    const tempSet = temp !== null && temp !== undefined && temp >= 5;
+    const rawTemp = this.pendingTemperature;
+    const siriAutoTemperature = Number(rawTemp) === 5;
+    const temp = siriAutoTemperature ? 5 : this._normalizeTemperature(rawTemp);
+    const tempSet = temp !== null;
     this.pendingState = null;
     this.pendingTemperature = null;
-    if (tempSet) this.lastTemperature = temp;
+    if (tempSet && !siriAutoTemperature) this.lastTemperature = temp;
 
     //Siri temperature heuristic
     if (this.preferSiriTemperature && state === 3 && tempSet) {
-      if (temp === 5) {
+      if (siriAutoTemperature) {
         //set auto mode on
         Logger.debug("[TadoUpdateBuffer] preferSiriTemperature active but temp=5 -> treat as auto mode");
         return this.sendUpdateFn("State", 3);

package/src/tado/tado-config.js

@@ -15,6 +15,8 @@ const hashCode = (s) =>
 const devices = new Map();
 const deviceHandler = new Map();
 
+const hasZoneId = (zoneId) => zoneId !== undefined && zoneId !== null;
+
 let telegram;
 
 export default {
@@ -554,6 +556,13 @@ export default {
                   zone.type = 'HEATING';
                 }
 
+                if (!hasZoneId(zone.id)) {
+                  Logger.warn(
+                    'There is no tado zone id configured for this zone. The plugin will try to resolve it from the tado API at runtime. Run reconfigure to persist it in the config.',
+                    zone.name
+                  );
+                }
+
                 if (!error) {
                   activeZones += 1;
 
@@ -582,6 +591,7 @@ export default {
                             ? 'zone-faucet'
                             : 'zone-switch';
 
+                    // boilerTempSupport always takes precedence over accTypeBoiler
                     config.subtype = zone.boilerTempSupport ? 'zone-heatercooler-boiler' : config.subtype;
 
                     config.zoneId = zone.id;
@@ -878,7 +888,7 @@ export default {
                   config.name = name;
                   config.subtype = 'extra-cntrlswitch';
                   config.runningInformation = home.extras.runningInformation;
-                  config.rooms = home.zones.filter((zne) => zne && zne.id);
+                  config.rooms = home.zones.filter((zne) => zne && hasZoneId(zne.id));
                   config.switches = validSwitches;
                   config.model = 'Central Switch';
                   config.serialNumber = hashCode(name);