@homebridge-plugins/homebridge-tado 8.6.0-beta.2 → 8.6.0-beta.4

package/CHANGELOG.md

@@ -1,11 +1,17 @@
 # Changelog
 
-## v8.6.0 - 2025-10-30
-- BREAKING CHANGE: If you use tadoApiUrl or skipAuth, you must now define them under each corresponding home in your configuration (#176)
-- Refactor configuration: moved tadoApiUrl and skipAuth into individual home configs to support multiple API URLs (#176)
-- Persist tado zone states after every zone states update
+## v8.6.0 - 2025-10-31
+- BREAKING CHANGE: If you use tadoApiUrl or skipAuth, they must now be defined under each corresponding home in your configuration (#176)
+- Refactor configuration: Moved tadoApiUrl and skipAuth into individual home configs to support multiple API URLs (#176)
+- Persist Tado zone states after zone state updates
 - Improved zone update logic: when setting a state, all zones are now updated immediately if the next scheduled update is more than 10 seconds away
+- Advanced queue handling for update and persistence tasks
+- Prevent updates during active setStates
+- Tado API counter now tracks and persists for each authenticated user
+- Fix: Polling and tasks for multiple homes (#178)
 - Fix: Corrected zone update handling that could previously cause unintended heating changes (#178)
+- Added additional debug log messages for zone updates
+- Note: This update will reset your tado api counter for the current day to zero.
 
 ## v8.5.0 - 2025-10-27
 - Change minimum polling interval to 30s due to improvements made in v8.2.0

package/config.schema.json

@@ -568,6 +568,11 @@
         "title": "Disable History Service",
         "type": "boolean",
         "description": "Optional: Skip creation of history service."
+      },
+      "preferSiriTemperature": {
+        "title": "Prefer Siri temperature changes",
+        "type": "boolean",
+        "description": "Prefers temperature changes when the Auto (state=3) mode is sent simultaneously. Default: false."
       }
     }
   },
@@ -575,6 +580,7 @@
     "name",
     "debug",
     "disableHistoryService",
+    "preferSiriTemperature",
     {
       "key": "homes",
       "type": "array",

package/homebridge-ui/public/js/main.js

@@ -133,6 +133,7 @@ async function createCustomSchema(home) {
     name: pluginConfig[0].name,
     debug: pluginConfig[0].debug,
     disableHistoryService: pluginConfig[0].disableHistoryService,
+    preferSiriTemperature: pluginConfig[0].preferSiriTemperature,
     homes: home
   });
 
@@ -141,6 +142,7 @@ async function createCustomSchema(home) {
     pluginConfig[0].name = config.name;
     pluginConfig[0].debug = config.debug;
     pluginConfig[0].disableHistoryService = config.disableHistoryService;
+    pluginConfig[0].preferSiriTemperature = config.preferSiriTemperature;
     pluginConfig[0].homes = pluginConfig[0].homes.map(myHome => {
       if (myHome.name === config.homes.name) {
         myHome = config.homes;
@@ -284,6 +286,7 @@ async function removeDeviceFromConfig(name) {
       if (!pluginConfig[0].homes.length) {
         delete pluginConfig[0].debug;
         delete pluginConfig[0].disableHistoryService;
+        delete pluginConfig[0].preferSiriTemperature;
       }
 
       await homebridge.updatePluginConfig(pluginConfig);

package/homebridge-ui/public/js/schema.js

@@ -560,12 +560,18 @@ const schema = {
       'title': 'Disable History Service',
       'type': 'boolean',
       'description': 'Optional: Skip creation of history service.'
+    },
+    'preferSiriTemperature': {
+      'title': 'Prefer Siri temperature changes',
+      'type': 'boolean',
+      'description': 'Prefers temperature changes when the Auto (state=3) mode is sent simultaneously. Default: false.'
     }
   },
   'layout': [
     'name',
     'debug',
     'disableHistoryService',
+    'preferSiriTemperature',
     'homes.name',
     'homes.polling',
     'homes.temperatureUnit',

package/homebridge-ui/server.js

@@ -21,7 +21,7 @@ class UiServer extends HomebridgePluginUiServer {
       username: config.username,
       tadoApiUrl: config.tadoApiUrl,
       skipAuth: config.skipAuth
-    }, this.homebridgeStoragePath);
+    }, this.homebridgeStoragePath, false);
 
     return;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@homebridge-plugins/homebridge-tado",
-  "version": "8.6.0-beta.2",
+  "version": "8.6.0-beta.4",
   "description": "Homebridge plugin for controlling tado° devices.",
   "main": "index.js",
   "scripts": {
@@ -43,12 +43,12 @@
     "@babel/core": "7.28.5",
     "@babel/eslint-parser": "7.28.5",
     "@babel/eslint-plugin": "7.27.1",
-    "@eslint/js": "^9.38.0",
-    "eslint": "^9.38.0",
+    "@eslint/js": "^9.39.0",
+    "eslint": "^9.39.0",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-import": "^2.32.0",
     "eslint-plugin-prettier": "^5.5.4",
-    "globals": "^16.4.0",
+    "globals": "^16.5.0",
     "prettier": "^3.6.2"
   }
 }

package/src/accessories/heatercooler.js

@@ -1,10 +1,11 @@
 import Logger from '../helper/logger.js';
 import moment from 'moment';
+import { TadoUpdateBuffer } from '../helper/update-buffer.js'
 
 const timeout = (ms) => new Promise((res) => setTimeout(res, ms));
 
 export default class HeaterCoolerAccessory {
-  constructor(api, accessory, accessories, tado, deviceHandler, FakeGatoHistoryService) {
+  constructor(api, accessory, accessories, tado, deviceHandler, preferSiriTemperature, FakeGatoHistoryService) {
     this.api = api;
     this.accessory = accessory;
     this.accessories = accessories;
@@ -15,6 +16,10 @@ export default class HeaterCoolerAccessory {
 
     this.autoDelayTimeout = null;
 
+    this.updateBuffer = new TadoUpdateBuffer((target, value) => {
+      return this.deviceHandler.setStates(this.accessory, this.accessories, target, value);
+    }, preferSiriTemperature);
+
     this.getService();
   }
 
@@ -258,16 +263,7 @@ export default class HeaterCoolerAccessory {
 
     service
       .getCharacteristic(this.api.hap.Characteristic.Active)
-      .onSet((value) => {
-        if (this.waitForEndValue) {
-          clearTimeout(this.waitForEndValue);
-          this.waitForEndValue = null;
-        }
-
-        this.waitForEndValue = setTimeout(() => {
-          this.deviceHandler.setStates(this.accessory, this.accessories, 'State', value);
-        }, 500);
-      })
+      .onSet(value => this.updateBuffer.setState(value))
       .on(
         'change',
         this.deviceHandler.changedStates.bind(this, this.accessory, this.historyService, this.accessory.displayName)
@@ -282,16 +278,7 @@ export default class HeaterCoolerAccessory {
 
     service
       .getCharacteristic(this.api.hap.Characteristic.HeatingThresholdTemperature)
-      .onSet((value) => {
-        if (this.waitForEndValue) {
-          clearTimeout(this.waitForEndValue);
-          this.waitForEndValue = null;
-        }
-
-        this.waitForEndValue = setTimeout(() => {
-          this.deviceHandler.setStates(this.accessory, this.accessories, 'Temperature', value);
-        }, 250);
-      })
+      .onSet(value => this.updateBuffer.setTemperature(value))
       .on(
         'change',
         this.deviceHandler.changedStates.bind(this, this.accessory, this.historyService, this.accessory.displayName)
@@ -301,16 +288,7 @@ export default class HeaterCoolerAccessory {
     if (this.accessory.context.config.type === 'AIR_CONDITIONING') {
       service
         .getCharacteristic(this.api.hap.Characteristic.CoolingThresholdTemperature)
-        .onSet((value) => {
-          if (this.waitForEndValue) {
-            clearTimeout(this.waitForEndValue);
-            this.waitForEndValue = null;
-          }
-
-          this.waitForEndValue = setTimeout(() => {
-            this.deviceHandler.setStates(this.accessory, this.accessories, 'Temperature', value);
-          }, 250);
-        })
+        .onSet(value => this.updateBuffer.setTemperature(value))
         .on(
           'change',
           this.deviceHandler.changedStates.bind(this, this.accessory, this.historyService, this.accessory.displayName)

package/src/accessories/thermostat.js

@@ -1,11 +1,12 @@
 import Logger from '../helper/logger.js';
 import moment from 'moment';
 import fs from 'fs-extra';
+import { TadoUpdateBuffer } from '../helper/update-buffer.js'
 
 const timeout = (ms) => new Promise((res) => setTimeout(res, ms));
 
 export default class ThermostatAccessory {
-  constructor(api, accessory, accessories, tado, deviceHandler, FakeGatoHistoryService) {
+  constructor(api, accessory, accessories, tado, deviceHandler, preferSiriTemperature, FakeGatoHistoryService) {
     this.api = api;
     this.accessory = accessory;
     this.accessories = accessories;
@@ -16,6 +17,10 @@ export default class ThermostatAccessory {
 
     this.autoDelayTimeout = null;
 
+    this.updateBuffer = new TadoUpdateBuffer((target, value) => {
+      return this.deviceHandler.setStates(this.accessory, this.accessories, target, value);
+    }, preferSiriTemperature);
+
     this.getService();
   }
 
@@ -192,20 +197,8 @@ export default class ThermostatAccessory {
       .getCharacteristic(this.api.hap.Characteristic.TemperatureDisplayUnits)
       .onSet(this.changeUnit.bind(this, service));
 
-    service.getCharacteristic(this.api.hap.Characteristic.TargetHeatingCoolingState).onSet((value) => {
-      if (this.waitForEndValue) {
-        clearTimeout(this.waitForEndValue);
-        this.waitForEndValue = null;
-      }
-
-      this.waitForEndValue = setTimeout(() => {
-        if (this.settingTemperature) {
-          this.settingTemperature = false;
-          return;
-        }
-        this.deviceHandler.setStates(this.accessory, this.accessories, 'State', value);
-      }, 500);
-    });
+    service.getCharacteristic(this.api.hap.Characteristic.TargetHeatingCoolingState)
+      .onSet(value => this.updateBuffer.setState(value));
 
     service
       .getCharacteristic(this.api.hap.Characteristic.CurrentTemperature)
@@ -216,12 +209,7 @@ export default class ThermostatAccessory {
 
     service
       .getCharacteristic(this.api.hap.Characteristic.TargetTemperature)
-      .onSet((value) => {
-        this.settingTemperature = true;
-        const targetState = service.getCharacteristic(this.api.hap.Characteristic.TargetHeatingCoolingState).value;
-        if (targetState) this.deviceHandler.setStates(this.accessory, this.accessories, 'Temperature', value);
-        setTimeout(() => this.settingTemperature = false, 1000);
-      })
+      .onSet(value => this.updateBuffer.setTemperature(value))
       .on(
         'change',
         this.deviceHandler.changedStates.bind(this, this.accessory, this.historyService, this.accessory.displayName)

package/src/helper/handler.js

@@ -1,42 +1,41 @@
 import Logger from '../helper/logger.js';
 import moment from 'moment';
-import { writeFile, access, readFile } from 'fs/promises';
+import { writeFile } from 'fs/promises';
 import { join } from "path";
-
-let settingState = false;
-let tasksInitialized = false;
-let lastGetStates = 0;
-const delayTimer = {};
+import { randomUUID } from 'crypto';
 
 const timeout = (ms) => new Promise((res) => setTimeout(res, ms));
-const aRefreshHistoryHandlers = [];
-
-export async function getPersistedStates(storagePath) {
-  try {
-    const sFilePath = join(storagePath, "tado-states.json");
-    await access(sFilePath);
-    const sData = (await readFile(sFilePath, "utf-8"));
-    if (sData) return JSON.parse(sData);
-  } catch (error) {
-    //no states data => ignore
-    Logger.debug(`Failed to read tado states file: ${error.message || error}`);
-  }
-}
+const helpers = {};
 
 export default (api, accessories, config, tado, telegram) => {
-  const statesIntervalTime = Math.max(config.polling, 30) * 1000;
-  const storagePath = api.user.storagePath();
+  //init helper variables for current home scope
+  if (!helpers[config.homeId]) {
+    helpers[config.homeId] = {
+      activeSettingStateRuns: {},
+      tasksInitialized: false,
+      lastGetStates: 0,
+      lastPersistZoneStates: 0,
+      persistPromise: Promise.resolve(),
+      updateZonesRunning: false,
+      updateZonesNextQueued: false,
+      delayTimer: {},
+      refreshHistoryHandlers: [],
+      statesIntervalTime: Math.max(config.polling, 30) * 1000,
+      storagePath: api.user.storagePath(),
+    }
+  }
+
+  function settingStates() {
+    return Object.keys(helpers[config.homeId].activeSettingStateRuns).length > 0;
+  }
 
   async function setStates(accessory, accs, target, value) {
     let zoneUpdated = false;
-
     accessories = accs.filter((acc) => acc && acc.context.config.homeName === config.homeName);
-
+    const runId = randomUUID();
     try {
-      settingState = true;
-
+      helpers[config.homeId].activeSettingStateRuns[runId] = true;
       value = typeof value === 'number' ? parseFloat(value.toFixed(2)) : value;
-
       Logger.info(target + ': ' + value, accessory.displayName);
 
       switch (accessory.context.config.subtype) {
@@ -63,10 +62,10 @@ export default (api, accessories, config, tado, telegram) => {
             value < 5
           ) {
             if (value === 0) {
-              if (delayTimer[accessory.displayName]) {
+              if (helpers[config.homeId].delayTimer[accessory.displayName]) {
                 Logger.info('Resetting delay timer', accessory.displayName);
-                clearTimeout(delayTimer[accessory.displayName]);
-                delayTimer[accessory.displayName] = null;
+                clearTimeout(helpers[config.homeId].delayTimer[accessory.displayName]);
+                helpers[config.homeId].delayTimer[accessory.displayName] = null;
               }
 
               power = 'OFF';
@@ -111,14 +110,14 @@ export default (api, accessories, config, tado, telegram) => {
               let timer = accessory.context.delayTimer;
               let tarState = value === 1 ? 'HEAT' : 'AUTO';
 
-              if (delayTimer[accessory.displayName]) {
-                clearTimeout(delayTimer[accessory.displayName]);
-                delayTimer[accessory.displayName] = null;
+              if (helpers[config.homeId].delayTimer[accessory.displayName]) {
+                clearTimeout(helpers[config.homeId].delayTimer[accessory.displayName]);
+                helpers[config.homeId].delayTimer[accessory.displayName] = null;
               }
 
               Logger.info('Wait ' + timer + ' seconds before switching state', accessory.displayName);
 
-              delayTimer[accessory.displayName] = setTimeout(async () => {
+              helpers[config.homeId].delayTimer[accessory.displayName] = setTimeout(async () => {
                 Logger.info('Delay timer finished, switching state to ' + tarState, accessory.displayName);
 
                 //targetState
@@ -172,7 +171,7 @@ export default (api, accessories, config, tado, telegram) => {
                   );
                 }
 
-                delayTimer[accessory.displayName] = null;
+                helpers[config.homeId].delayTimer[accessory.displayName] = null;
               }, timer * 1000);
             }
           } else {
@@ -565,13 +564,14 @@ export default (api, accessories, config, tado, telegram) => {
           break;
       }
     } catch (err) {
+      console.log("error at setStates", err);
       errorHandler(err);
     } finally {
-      settingState = false;
+      delete helpers[config.homeId].activeSettingStateRuns[runId];
       //update zones to ensure correct state in Apple Home
-      const timeSinceLastGetStates = Date.now() - lastGetStates;
-      const statesIntervalTimeLeft = statesIntervalTime - timeSinceLastGetStates;
-      if (zoneUpdated && statesIntervalTimeLeft > 10_000) await updateZones();
+      const timeSinceLastGetStates = helpers[config.homeId].lastGetStates === 0 ? 0 : (Date.now() - helpers[config.homeId].lastGetStates);
+      const statesIntervalTimeLeft = helpers[config.homeId].statesIntervalTime - timeSinceLastGetStates;
+      if (!settingStates() && zoneUpdated && statesIntervalTimeLeft > (10 * 1000)) await updateZones();
     }
   }
 
@@ -729,61 +729,49 @@ export default (api, accessories, config, tado, telegram) => {
     }
   }
 
-  async function persistZoneStates(homeId, zoneStates) {
+  function persistZoneStates(homeId, zoneStates) {
+    helpers[config.homeId].persistPromise = helpers[config.homeId].persistPromise.then(() => _persistZoneStates(homeId, zoneStates));
+  }
+
+  async function _persistZoneStates(homeId, zoneStates) {
+    if ((Date.now() - helpers[config.homeId].lastPersistZoneStates) < (10 * 1000)) return;
     try {
       if (zoneStates && Object.keys(zoneStates).length) {
         const homeData = {};
         homeData.zoneStates = zoneStates;
-        await writeFile(join(storagePath, `tado-states-${homeId}.json`), JSON.stringify(homeData, null, 2), "utf-8");
+        await writeFile(join(helpers[config.homeId].storagePath, `tado-states-${homeId}.json`), JSON.stringify(homeData, null, 2), "utf-8");
+        helpers[config.homeId].lastPersistZoneStates = Date.now();
       } else {
-        Logger.info(`Skipping persistence of tado states for home ${homeId}: zone states are empty.`);
+        Logger.warn(`Skipping persistence of tado states file for home ${homeId}: zone states are empty.`);
       }
     } catch (error) {
       Logger.error(`Error while updating the tado states file for home ${homeId}: ${error.message || error}`);
     }
   }
 
-  async function persistStates() {
-    try {
-      const data = {};
-      data.counterData = await tado.getCounterData();
-      await writeFile(join(storagePath, "tado-states.json"), JSON.stringify(data, null, 2), "utf-8");
-    } catch (error) {
-      Logger.error(`Error while updating the tado states file: ${error.message || error}`);
-    }
+  async function refreshHistoryServices() {
+    if (!helpers[config.homeId].refreshHistoryHandlers.length) return;
     try {
       //wait for fakegato history services to be loaded
       await timeout(4000);
-      for (const refreshHistory of aRefreshHistoryHandlers) {
+      for (const refreshHistory of helpers[config.homeId].refreshHistoryHandlers) {
         refreshHistory();
       }
     } catch (error) {
-      Logger.error(`Error while refreshing history: ${error.message || error}`);
-    }
-  }
-
-  async function logCounter() {
-    try {
-      const iCounter = (await tado.getCounterData()).counter;
-      Logger.info(`Tado API counter: ${iCounter.toLocaleString('en-US')}`);
-    } catch (error) {
-      Logger.warn(`Failed to get Tado API counter: ${error.message || error}`);
+      Logger.error(`Error while refreshing history services: ${error.message || error}`);
     }
   }
 
   function initTasks() {
-    if (tasksInitialized) return;
-    tasksInitialized = true;
+    if (helpers[config.homeId].tasksInitialized) return;
+    helpers[config.homeId].tasksInitialized = true;
 
     void getStates();
-    setInterval(() => getStates(), statesIntervalTime);
-
-    void logCounter();
-    setInterval(() => logCounter(), 60 * 60 * 1000);
+    setInterval(() => void getStates(), helpers[config.homeId].statesIntervalTime);
   }
 
   async function getStates() {
-    lastGetStates = Date.now();
+    helpers[config.homeId].lastGetStates = Date.now();
     try {
       //ME
       if (!config.homeId) await updateMe();
@@ -811,12 +799,12 @@ export default (api, accessories, config, tado, telegram) => {
     } catch (err) {
       errorHandler(err);
     } finally {
-      void persistStates();
+      void refreshHistoryServices();
     }
   }
 
   async function updateMe() {
-    if (settingState) return;
+    if (settingStates()) return;
 
     Logger.debug('Polling User Info...', config.homeName);
 
@@ -828,7 +816,7 @@ export default (api, accessories, config, tado, telegram) => {
   }
 
   async function updateHome() {
-    if (settingState) return;
+    if (settingStates()) return;
 
     Logger.debug('Polling Home Info...', config.homeName);
 
@@ -853,7 +841,32 @@ export default (api, accessories, config, tado, telegram) => {
   }
 
   async function updateZones() {
-    if (settingState) return;
+    if (helpers[config.homeId].updateZonesRunning) {
+      helpers[config.homeId].updateZonesNextQueued = true;
+      return;
+    }
+    helpers[config.homeId].updateZonesRunning = true;
+    try {
+      while (true) {
+        try {
+          await _updateZones();
+        } catch (error) {
+          Logger.error(`Failed to update zones: ${error.message || error}`);
+        }
+        if (helpers[config.homeId].updateZonesNextQueued) {
+          helpers[config.homeId].updateZonesNextQueued = false;
+          //continue with loop
+        } else {
+          break;
+        }
+      }
+    } finally {
+      helpers[config.homeId].updateZonesRunning = false;
+    }
+  }
+
+  async function _updateZones() {
+    if (settingStates()) return;
 
     Logger.debug('Polling Zones...', config.homeName);
 
@@ -904,8 +917,11 @@ export default (api, accessories, config, tado, telegram) => {
       });
     }
 
-    const zoneStates = (await tado.getZoneStates(config.homeId))["zoneStates"] ?? {};
-    void persistZoneStates(config.homeId, zoneStates);
+    let zoneStates = {};
+    if (config.zones?.length) {
+      zoneStates = (await tado.getZoneStates(config.homeId))["zoneStates"] ?? {};
+      void persistZoneStates(config.homeId, zoneStates);
+    }
 
     for (const zone of config.zones) {
       const zoneState = zoneStates[zone.id.toString()];
@@ -1316,7 +1332,7 @@ export default (api, accessories, config, tado, telegram) => {
   }
 
   async function updateMobileDevices() {
-    if (settingState) return;
+    if (settingStates()) return;
 
     Logger.debug('Polling MobileDevices...', config.homeName);
 
@@ -1370,7 +1386,7 @@ export default (api, accessories, config, tado, telegram) => {
   }
 
   async function updateWeather() {
-    if (settingState) return;
+    if (settingStates()) return;
 
     const weatherTemperatureAccessory = accessories.filter(
       (acc) => acc && acc.displayName === acc.context.config.homeName + ' Weather'
@@ -1425,7 +1441,7 @@ export default (api, accessories, config, tado, telegram) => {
   }
 
   async function updatePresence() {
-    if (settingState) return;
+    if (settingStates()) return;
 
     const presenceLockAccessory = accessories.filter(
       (acc) => acc && acc.displayName === acc.context.config.homeName + ' Presence Lock'
@@ -1470,7 +1486,7 @@ export default (api, accessories, config, tado, telegram) => {
   }
 
   async function updateRunningTime() {
-    if (settingState) return;
+    if (settingStates()) return;
 
     const centralSwitchAccessory = accessories.filter(
       (acc) => acc && acc.displayName === acc.context.config.homeName + ' Central Switch'
@@ -1515,7 +1531,7 @@ export default (api, accessories, config, tado, telegram) => {
   }
 
   async function updateDevices() {
-    if (settingState) return;
+    if (settingStates()) return;
 
     Logger.debug('Polling Devices...', config.homeName);
 
@@ -1586,6 +1602,6 @@ export default (api, accessories, config, tado, telegram) => {
     getStates: getStates,
     setStates: setStates,
     changedStates: changedStates,
-    refreshHistoryHandlers: aRefreshHistoryHandlers
+    refreshHistoryHandlers: helpers[config.homeId].refreshHistoryHandlers
   };
-};
+};

package/src/helper/update-buffer.js

@@ -0,0 +1,69 @@
+import { hrtime } from "process";
+import Logger from '../helper/logger.js';
+
+export class TadoUpdateBuffer {
+  constructor(sendUpdateFn, preferSiriTemperature = false) {
+    this.preferSiriTemperature = !!preferSiriTemperature;
+    this.sendUpdateFn = sendUpdateFn;
+    this.delay = 400;
+    this.timer = null;
+    this.pendingState = null;
+    this.pendingTemperature = null;
+    this.lastUpdateTime = null;
+    this.lastTemperature = 20;
+  }
+
+  setState(value) {
+    this.pendingState = value;
+    this._schedule();
+    Logger.debug("[TadoUpdateBuffer] setState", value, hrtime.bigint());
+  }
+
+  setTemperature(value) {
+    this.pendingTemperature = value;
+    this._schedule();
+    Logger.debug("[TadoUpdateBuffer] setTemperature", value, hrtime.bigint());
+  }
+
+  _schedule() {
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = setTimeout(() => this._apply(), this.delay);
+  }
+
+  _apply() {
+    this.timer = null;
+    const state = this.pendingState;
+    const temp = this.pendingTemperature;
+    const tempSet = temp !== null && temp !== undefined && temp >= 5;
+    this.pendingState = null;
+    this.pendingTemperature = null;
+    if (tempSet) this.lastTemperature = temp;
+
+    //Siri temperature heuristic
+    if (this.preferSiriTemperature && state === 3 && tempSet) {
+      if (temp === 5) {
+        //set auto mode on
+        Logger.debug("[TadoUpdateBuffer] preferSiriTemperature active but temp=5 -> treat as auto mode");
+        return this.sendUpdateFn("State", 3);
+      }
+      //set temperature
+      Logger.debug("[TadoUpdateBuffer] Siri temperature change detected -> ignore state 3, apply temperature only");
+      return this.sendUpdateFn("Temperature", temp);
+    }
+
+    //default behaviour
+    if (state === 0) {
+      //set heating off
+      return this.sendUpdateFn("State", 0);
+    } else if (state === 3) {
+      //set auto mode on
+      return this.sendUpdateFn("State", 3);
+    } else if (tempSet) {
+      //set heating on with temperature provided
+      return this.sendUpdateFn("Temperature", temp);
+    } else if (state === 1) {
+      //heating on without temperature provided
+      return this.sendUpdateFn("Temperature", this.lastTemperature);
+    }
+  }
+}

package/src/platform.js

@@ -237,12 +237,12 @@ class TadoPlatform {
 
     switch (device.subtype) {
       case 'zone-thermostat':
-        new ThermostatAccessory(this.api, accessory, this.accessories, tado, deviceHandler, FakeGatoHistoryService);
+        new ThermostatAccessory(this.api, accessory, this.accessories, tado, deviceHandler, this.config.preferSiriTemperature, FakeGatoHistoryService);
         break;
       case 'zone-heatercooler':
       case 'zone-heatercooler-boiler':
       case 'zone-heatercooler-ac':
-        new HeaterCoolerAccessory(this.api, accessory, this.accessories, tado, deviceHandler, FakeGatoHistoryService);
+        new HeaterCoolerAccessory(this.api, accessory, this.accessories, tado, deviceHandler, this.config.preferSiriTemperature, FakeGatoHistoryService);
         break;
       case 'zone-switch':
       case 'zone-window-switch':

package/src/tado/tado-api.js

@@ -1,5 +1,4 @@
 import Logger from '../helper/logger.js';
-import { getPersistedStates } from '../helper/handler.js';
 import got from 'got';
 import { join } from 'path';
 import { access, readFile, writeFile } from 'fs/promises';
@@ -8,8 +7,17 @@ const tado_url = "https://my.tado.com";
 const tado_auth_url = "https://login.tado.com/oauth2";
 const tado_client_id = "1bb50063-6b0c-4d11-bd99-387f4a91cc46";
 
+function _getSimpleHash(str) {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+  }
+  return (hash >>> 0).toString(36).padStart(7, '0');
+}
+
 export default class Tado {
-  constructor(name, auth, storagePath) {
+  constructor(name, auth, storagePath, counterActivated) {
     this.tadoApiUrl = auth.tadoApiUrl || tado_url;
     this.customTadoApiUrlActive = !!auth.tadoApiUrl;
     this.skipAuth = auth.skipAuth?.toString() === "true";
@@ -17,28 +25,42 @@ export default class Tado {
     this.name = name;
     const usesExternalTokenFile = auth.username?.toLowerCase().endsWith(".json");
     this._tadoExternalTokenFilePath = usesExternalTokenFile ? auth.username : undefined;
-    const fnSimpleHash = (str) => {
-      let hash = 0;
-      for (let i = 0; i < str.length; i++) {
-        const char = str.charCodeAt(i);
-        hash = (hash << 5) - hash + char;
-      }
-      return (hash >>> 0).toString(36).padStart(7, '0');
-    };
+    this.hashedUsername = _getSimpleHash(auth.username);
     this.username = usesExternalTokenFile ? undefined : auth.username;
-    this._tadoInternalTokenFilePath = usesExternalTokenFile ? undefined : join(this.storagePath, `.tado-token-${fnSimpleHash(auth.username)}.json`);
+    this._tadoInternalTokenFilePath = usesExternalTokenFile ? undefined : join(this.storagePath, `.tado-token-${this.hashedUsername}.json`);
     this._tadoApiClientId = tado_client_id;
     this._tadoTokenPromise = undefined;
     this._tadoAuthenticationCallback = undefined;
+    this._counterActivated = counterActivated?.toString() === "true";
     this._counterInitPromise = this._initCounter();
     Logger.debug("API successfull initialized", this.name);
   }
 
   async _initCounter() {
-    const persistedCounterData = (await getPersistedStates(this.storagePath))?.counterData;
+    if (!this._counterActivated) return;
+    const persistedCounterData = (await this._getPersistedCounter())?.counterData;
     this._counter = persistedCounterData?.counter ?? 0;
     this._counterTimestamp = persistedCounterData?.counterTimestamp ?? new Date().toISOString();
     this._checkCounterMidnightReset();
+    //wait some seconds to catch recent api calls
+    setTimeout(() => {
+      void this._logCounter();
+      setInterval(() => void this._logCounter(), 60 * 60 * 1000);
+      void this._persistCounterData();
+      setInterval(() => void this._persistCounterData(), 5 * 60 * 1000);
+    }, 4 * 1000);
+  }
+
+  async _getPersistedCounter() {
+    try {
+      const filePath = join(this.storagePath, `tado-api-${this.hashedUsername}.json`);
+      await access(filePath);
+      const data = (await readFile(filePath, "utf-8"));
+      if (data) return JSON.parse(data);
+    } catch (error) {
+      //no persisted counter data => ignore
+      Logger.debug(`Failed to read tado api file for user ${this.hashedUsername}: ${error.message || error}`);
+    }
   }
 
   _checkCounterMidnightReset() {
@@ -53,6 +75,7 @@ export default class Tado {
   }
 
   async _increaseCounter() {
+    if (!this._counterActivated) return;
     try {
       await this._counterInitPromise;
       this._checkCounterMidnightReset();
@@ -63,7 +86,7 @@ export default class Tado {
     }
   }
 
-  async getCounterData() {
+  async _getCounterData() {
     await this._counterInitPromise;
     return {
       counter: this._counter,
@@ -71,6 +94,25 @@ export default class Tado {
     };
   }
 
+  async _persistCounterData() {
+    try {
+      const data = {};
+      data.counterData = await this._getCounterData();
+      await writeFile(join(this.storagePath, `tado-api-${this.hashedUsername}.json`), JSON.stringify(data, null, 2), "utf-8");
+    } catch (error) {
+      Logger.error(`Error while updating the tado api file for user ${this.hashedUsername}: ${error.message || error}`);
+    }
+  }
+
+  async _logCounter() {
+    try {
+      const counter = (await this._getCounterData()).counter;
+      Logger.info(`Tado API counter: ${counter.toLocaleString('en-US')}`);
+    } catch (error) {
+      Logger.warn(`Failed to get Tado API counter: ${error.message || error}`);
+    }
+  }
+
   async getToken() {
     Logger.debug('Get access token...', this.name);
     if (!this._tadoTokenPromise) {

package/src/tado/tado-config.js

@@ -23,7 +23,7 @@ export default {
 
     for (const auth of auths) {
 
-      const tado = new TadoApi('Configuration', auth, storagePath);
+      const tado = new TadoApi('Configuration', auth, storagePath, false);
 
       const me = await tado.getMe();
 
@@ -160,7 +160,7 @@ export default {
         username: auth.username,
         tadoApiUrl: auth.tadoApiUrl,
         skipAuth: auth.skipAuth
-      }, storagePath);
+      }, storagePath, false);
 
       const me = await tado.getMe();
 
@@ -208,7 +208,7 @@ export default {
 
   refresh: async function (currentHome, config, auth, storagePath) {
 
-    const tado = new TadoApi('Configuration', auth, storagePath);
+    const tado = new TadoApi('Configuration', auth, storagePath, false);
 
     //Home Informations
     let home = config.homes.find((home) => home && home.name === currentHome);
@@ -505,7 +505,7 @@ export default {
             username: home.username,
             tadoApiUrl: home.tadoApiUrl,
             skipAuth: home.skipAuth
-          }, storagePath);
+          }, storagePath, true);
 
           const accessoryConfig = {
             homeId: home.id,