iobroker.zigbee2mqtt 3.1.1 → 3.2.0

package/lib/statesController.js

@@ -1,16 +1,20 @@
+'use strict';
+
 const utils = require('./utils');
 
 /**
- *
+ * Verwaltet das Schreiben von Zigbee2MQTT-Gerätedaten in ioBroker-States.
+ * Puffert eingehende Nachrichten für noch nicht erstellte Geräte in einer Queue.
  */
 class StatesController {
     /**
+     * Erstellt eine neue StatesController-Instanz.
      *
-     * @param adapter
-     * @param deviceCache
-     * @param groupCache
-     * @param logCustomizations
-     * @param createCache
+     * @param {object}  adapter            Die ioBroker-Adapter-Instanz
+     * @param {Array}   deviceCache        Gemeinsamer Cache aller bekannten Geräte
+     * @param {Array}   groupCache         Gemeinsamer Cache aller bekannten Gruppen
+     * @param {object}  logCustomizations  Debug/Filter-Einstellungen (debugDevices, logfilter)
+     * @param {object}  createCache        Cache bereits erstellter ioBroker-Objekte
      */
     constructor(adapter, deviceCache, groupCache, logCustomizations, createCache) {
         this.adapter = adapter;
@@ -20,11 +24,18 @@ class StatesController {
         this.createCache = createCache;
         this.incStatsQueue = [];
         this.timeOutCache = {};
+        // Einmalig berechnen – wird nur bei Konfigurationsänderung ungültig
+        this._debugDeviceList = logCustomizations.debugDevices
+            ? String(logCustomizations.debugDevices).split(',').map((s) => s.trim()).filter(Boolean)
+            : [];
     }
 
     /**
+     * Verarbeitet eine eingehende Gerätenachricht von Zigbee2MQTT.
+     * Ist das Gerät noch nicht im Cache bekannt, wird die Nachricht in der incStatsQueue
+     * gepuffert und später über processQueue() erneut versucht.
      *
-     * @param messageObj
+     * @param {{ topic: string, payload: any }} messageObj Die zu verarbeitende Nachricht
      */
     async processDeviceMessage(messageObj) {
         if (!messageObj || typeof messageObj !== 'object') {
@@ -42,9 +53,21 @@ class StatesController {
                 this.adapter.log.error(`setDeviceStateSafely error for ${messageObj.topic}: ${error}`);
             }
         } else {
-            if (!this.incStatsQueue.some((x) => x && x.topic === messageObj.topic)) {
+            // Wenn das Gerät (noch) nicht bekannt ist: Message in Queue stellen.
+            // Existiert für dieses Topic bereits ein Eintrag, wird er mit den aktuellen
+            // Payload-Daten überschrieben, damit wir stets den neuesten Stand verarbeiten.
+            const existingIdx = this.incStatsQueue.findIndex((x) => x && x.topic === messageObj.topic);
+            if (existingIdx !== -1) {
+                const ttl = (this.incStatsQueue[existingIdx]._ttl || 0) + 1;
+                if (ttl > 10) {
+                    this.adapter.log.warn(`incStatsQueue: dropping message for unknown device ${messageObj.topic} after ${ttl} retries`);
+                    this.incStatsQueue.splice(existingIdx, 1);
+                    return;
+                }
+                this.incStatsQueue[existingIdx] = { ...messageObj, _ttl: ttl };
+            } else {
                 if (this.incStatsQueue.length < 500) {
-                    this.incStatsQueue.push(messageObj);
+                    this.incStatsQueue.push({ ...messageObj, _ttl: 1 });
                 } else {
                     this.adapter.log.warn(`incStatsQueue is full (500), dropping message for ${messageObj.topic}`);
                 }
@@ -54,12 +77,14 @@ class StatesController {
     }
 
     /**
+     * Schreibt alle State-Werte einer Nachricht in die zugehörigen ioBroker-States.
+     * Action-States werden gesammelt und am Ende gesondert behandelt.
      *
-     * @param messageObj
-     * @param device
+     * @param {{ topic: string, payload: object }} messageObj Die zu verarbeitende Nachricht
+     * @param {object} device                                 Das zugehörige Geräteobjekt aus dem Cache
      */
     async setDeviceStateSafely(messageObj, device) {
-        if (this.logCustomizations.debugDevices.includes(device.ieee_address)) {
+        if (this._debugDeviceList.includes(device.ieee_address)) {
             this.adapter.log.warn(`--->>> fromZ2M -> ${device.ieee_address} states: ${JSON.stringify(messageObj)}`);
         }
 
@@ -69,13 +94,28 @@ class StatesController {
         let queuedThisRound = false;
 
         const pushToQueue = (msg) => {
-            if (!queuedThisRound && this.incStatsQueue.length < 500
-                && !this.incStatsQueue.some((x) => x && x.topic === msg.topic)) {
-                this.incStatsQueue.push(msg);
-                queuedThisRound = true;
+            if (queuedThisRound) {return;}
+            const existingIdx = this.incStatsQueue.findIndex((x) => x && x.topic === msg.topic);
+            if (existingIdx !== -1) {
+                const ttl = (this.incStatsQueue[existingIdx]._ttl || 0) + 1;
+                if (ttl > 10) {
+                    this.adapter.log.warn(`incStatsQueue: dropping message for ${msg.topic} after ${ttl} retries (state not yet created)`);
+                    this.incStatsQueue.splice(existingIdx, 1);
+                    return;
+                }
+                this.incStatsQueue[existingIdx] = { ...msg, _ttl: ttl };
+            } else if (this.incStatsQueue.length < 500) {
+                this.incStatsQueue.push({ ...msg, _ttl: 1 });
+            } else {
+                this.adapter.log.warn(`incStatsQueue is full, dropping message for ${msg.topic}`);
             }
+            queuedThisRound = true;
         };
 
+        if (!messageObj.payload || typeof messageObj.payload !== 'object' || Array.isArray(messageObj.payload)) {
+            return;
+        }
+
         for (let [key, value] of Object.entries(messageObj.payload)) {
             if (value === undefined || value === null) {
                 continue;
@@ -154,13 +194,12 @@ class StatesController {
                         }
                     }
                 } catch (err) {
-                    // Fix 2: Größenlimit auch hier
-                    pushToQueue(messageObj);
-                    this.adapter.log.debug(`Can not set ${stateName}, queue state in incStatsQueue!`);
+                    this.adapter.log.warn(`Cannot set state ${stateName}: ${err}`);
                 }
             }
         }
 
+
         for (const state of actionStates) {
             const stateName = `${device.ieee_address}.${state.id}`;
 
@@ -178,29 +217,31 @@ class StatesController {
                     }
                 }
             } catch (err) {
-                // Fix 2: Größenlimit auch hier
-                pushToQueue(messageObj);
-                this.adapter.log.debug(`Can not set ${stateName}, queue state in incStatsQueue!`);
+                this.adapter.log.warn(`Cannot set action state ${stateName}: ${err}`);
             }
         }
     }
 
     /**
+     * Setzt einen ioBroker-State (immer, ohne Changed-Prüfung).
+     * Ignoriert null/undefined-Werte sicher.
      *
-     * @param stateName
-     * @param value
+     * @param {string} stateName Vollständiger State-Pfad (z.B. "0xAABB.state")
+     * @param {*}      value     Der zu setzende Wert
      */
     async setStateSafelyAsync(stateName, value) {
         if (value === undefined || value === null) {
             return;
         }
-        await this.adapter.setStateAsync(stateName, value, true);
+        this.adapter.setState(stateName, value, true);
     }
 
     /**
+     * Setzt einen ioBroker-State nur wenn sich der Wert geändert hat.
+     * Ignoriert null/undefined-Werte sicher.
      *
-     * @param stateName
-     * @param value
+     * @param {string} stateName Vollständiger State-Pfad (z.B. "0xAABB.brightness")
+     * @param {*}      value     Der zu setzende Wert
      */
     async setStateChangedSafelyAsync(stateName, value) {
         if (value === undefined || value === null) {
@@ -210,29 +251,41 @@ class StatesController {
     }
 
     /**
+     * Setzt einen State sofort auf den angegebenen Wert und – nur bei value=true –
+     * nach Ablauf des Timeouts automatisch zurück auf false (Button/Event-Reset).
+     * Bei value=false wird kein Auto-Reset ausgelöst (z.B. brightness_stop-Signal).
      *
-     * @param stateName
-     * @param value
-     * @param timeout
+     * @param {string}  stateName Vollständiger State-Pfad
+     * @param {boolean} value     Der sofort zu setzende Wert
+     * @param {number}  timeout   Millisekunden bis zum Auto-Reset (nur bei value=true)
      */
     async setStateWithTimeoutAsync(stateName, value, timeout) {
         if (value === undefined || value === null) {
             return;
         }
 
-        await this.adapter.setStateAsync(stateName, value, true);
+        this.adapter.setState(stateName, value, true);
+
+        // Auto-Reset (false → nichts tun, true → nach timeout zurücksetzen)
+        // Wenn value=false (z.B. Stop-Aktion im simpleMoveStopState-Modus),
+        // soll der State dauerhaft false bleiben und NICHT nach timeout auf true springen.
         if (this.timeOutCache[stateName]) {
-            clearTimeout(this.timeOutCache[stateName]);
+            this.adapter.clearTimeout(this.timeOutCache[stateName]);
+            delete this.timeOutCache[stateName];
+        }
+        if (value === true) {
+            this.timeOutCache[stateName] = this.adapter.setTimeout(() => {
+                delete this.timeOutCache[stateName];
+                this.adapter.setState(stateName, false, true).catch((err) => {
+                    this.adapter.log.debug(`setStateWithTimeout reset error for ${stateName}: ${err}`);
+                });
+            }, timeout);
         }
-        this.timeOutCache[stateName] = setTimeout(() => {
-            this.adapter.setStateAsync(stateName, !value, true).catch((err) => {
-                this.adapter.log.debug(`setStateWithTimeout reset error for ${stateName}: ${err}`);
-            });
-        }, timeout);
     }
 
     /**
-     *
+     * Verarbeitet alle in der incStatsQueue gepufferten Nachrichten erneut.
+     * Wird nach dem Aufbau des Geräte-/Gruppen-Caches aufgerufen.
      */
     async processQueue() {
         const oldIncStatsQueue = [];
@@ -244,9 +297,10 @@ class StatesController {
     }
 
     /**
-     *
+     * Meldet alle bisherigen State-Subscriptions ab und subscribt neu
+     * nur auf beschreibbare States aller bekannten Geräte und Gruppen.
      */
-    async subscribeWritableStates() {
+    subscribeWritableStates() {
         // Alle bestehenden State-Subscriptions zuerst abmelden
         this.adapter.unsubscribeStates('*');
         for (const device of this.groupCache.concat(this.deviceCache)) {
@@ -265,22 +319,26 @@ class StatesController {
     }
 
     /**
-     *
+     * Setzt alle "*.available"-States im Adapter auf false.
+     * Wird beim Verbindungsverlust zu Zigbee2MQTT aufgerufen.
      */
     async setAllAvailableToFalse() {
         const availableStates = await this.adapter.getStatesAsync('*.available');
-        // Fix: Object.keys() statt for...in verhindert ungewollte Prototype-Properties
+        if (!availableStates) {
+            return;
+        }
         for (const availableState of Object.keys(availableStates)) {
             await this.adapter.setStateChangedAsync(availableState, false, true);
         }
     }
 
     /**
-     *
+     * Bricht alle laufenden Auto-Reset-Timer ab und leert den Timer-Cache.
+     * Wird beim Adapter-Stop aufgerufen.
      */
-    async allTimerClear() {
+    allTimerClear() {
         for (const timer of Object.keys(this.timeOutCache)) {
-            clearTimeout(this.timeOutCache[timer]);
+            this.adapter.clearTimeout(this.timeOutCache[timer]);
         }
         this.timeOutCache = {};
     }

package/lib/utils.js

@@ -1,57 +1,43 @@
 /**
- * Converts a bulb level of range [0...254] to an adapter level of range [0...100]
+ * Konvertiert einen Lampen-Helligkeitswert [0..254] in einen Adapter-Prozentwert [0..100].
  *
- * @param bulbLevel
+ * @param {number} bulbLevel Helligkeitswert der Lampe (0–254)
+ * @returns {number}         Prozentwert (0–100)
  */
 function bulbLevelToAdapterLevel(bulbLevel) {
-    // Convert from bulb levels [0...254] to adapter levels [0...100]:
-    // - Bulb level 0 is a forbidden value according to the ZigBee spec "ZigBee Cluster Library
-    //   (for ZigBee 3.0) User Guide", but some bulbs (HUE) accept this value and interpret this
-    //   value as "switch the bulb off".
-    // - A bulb level of "1" is the "minimum possible level" which should mean "bulb off",
-    //   but there are bulbs that do not switch off (they need "0", some IKEA bulbs are affected).
-    // - No visible difference was seen between bulb level 1 and 2 on HUE LCT012 bulbs.
-    //
-    // Conclusion:
-    // - We map adapter level "0" to the (forbidden) bulb level "0" that seems to switch all
-    //   known bulbs.
-    // - Bulb level "1" is not used, but if received nevertheless, it is converted to
-    //   adapter level "0" (off).
-    // - Bulb level range [2...254] is linearly mapped to adapter level range [1...100].
     if (bulbLevel >= 2) {
         // Perform linear mapping of range [2...254] to [1...100]
         return Math.round(((bulbLevel - 2) * 99) / 252) + 1;
-    } 
-        // The bulb is considered off. Even a bulb level of "1" is considered as off.
-        return 0;
-     // else
+    }
+    // The bulb is considered off. Even a bulb level of "1" is considered as off.
+    return 0;
 }
 
 /**
- * Converts an adapter level of range [0...100] to a bulb level of range [0...254]
+ * Konvertiert einen Adapter-Prozentwert [0..100] in einen Lampen-Helligkeitswert [0..254].
  *
- * @param adapterLevel
+ * @param {number} adapterLevel Prozentwert (0–100)
+ * @returns {number}            Helligkeitswert der Lampe (0–254)
  */
 function adapterLevelToBulbLevel(adapterLevel) {
-    // Convert from adapter levels [0...100] to bulb levels [0...254].
-    // This is the inverse of function bulbLevelToAdapterLevel().
-    // Please read the comments there regarding the rules applied here for mapping the values.
-    if (adapterLevel) {
+    if (adapterLevel != null && adapterLevel > 0) {
         // Perform linear mapping of range [1...100] to [2...254]
         return Math.round(((adapterLevel - 1) * 252) / 99) + 2;
-    } 
-        // Switch the bulb off. Some bulbs need "0" (IKEA), others "1" (HUE), and according to the
-        // ZigBee docs "1" is the "minimum possible level"... we choose "0" here which seems to work.
-        return 0;
-     // else
+    }
+    // Switch the bulb off. Some bulbs need "0" (IKEA), others "1" (HUE), and according to the
+    // ZigBee docs "1" is the "minimum possible level"... we choose "0" here which seems to work.
+    return 0;
 }
 
 
 // If the value is greater than 1000, kelvin is assumed.
 // If smaller, it is assumed to be mired.
 /**
+ * Konvertiert einen Kelvin- oder Mired-Wert immer in Mired.
+ * Werte > 1000 werden als Kelvin interpretiert und umgerechnet.
  *
- * @param t
+ * @param {number} t Farbtemperatur in Kelvin (>1000) oder Mired (≤1000)
+ * @returns {number} Farbtemperatur in Mired
  */
 function toMired(t) {
     let miredValue = t;
@@ -62,18 +48,21 @@ function toMired(t) {
 }
 
 /**
+ * Konvertiert zwischen Mired und Kelvin (die Formel ist in beide Richtungen gleich: 1.000.000 / t).
  *
- * @param t
+ * @param {number} t Farbtemperatur in Mired oder Kelvin
+ * @returns {number} Umgerechneter Wert (gerundet)
  */
 function miredKelvinConversion(t) {
     return Math.round(1000000 / t);
 }
 
 /**
- * Converts a decimal number to a hex string with zero-padding
+ * Konvertiert eine Dezimalzahl in einen hex-String mit führenden Nullen.
  *
- * @param decimal
- * @param padding
+ * @param {number} decimal  Die umzuwandelnde Zahl
+ * @param {number} [padding] Mindestlänge des hex-Strings (wird mit '0' aufgefüllt)
+ * @returns {string}        Hex-String in Kleinbuchstaben
  */
 function decimalToHex(decimal, padding) {
     let hex = Number(decimal).toString(16);
@@ -86,31 +75,31 @@ function decimalToHex(decimal, padding) {
     return hex;
 }
 
-
 /**
+ * Leert ein Array in-place (O(1)).
  *
- * @param array
+ * @param {Array} array Das zu leerende Array
  */
 function clearArray(array) {
-    while (array.length > 0) {
-        array.pop();
-    }
+    array.length = 0;
 }
 
 /**
+ * Verschiebt alle Einträge von source nach target und leert source dabei.
  *
- * @param source
- * @param target
+ * @param {Array} source Quell-Array (wird nach dem Aufruf leer sein)
+ * @param {Array} target Ziel-Array (bekommt alle Einträge aus source angehängt)
  */
 function moveArray(source, target) {
-    while (source.length > 0) {
-        target.push(source.shift());
-    }
+    target.push(...source);
+    source.length = 0;
 }
 
 /**
+ * Prüft ob ein Wert ein einfaches Objekt ist (kein Array, kein null).
  *
- * @param item
+ * @param {*} item Der zu prüfende Wert
+ * @returns {boolean} true wenn item ein Objekt ist, sonst false
  */
 function isObject(item) {
     return typeof item === 'object' && !Array.isArray(item) && item !== null;

package/lib/websocketController.js

@@ -3,13 +3,18 @@
 const WebSocket = require('ws');
 const wsHeartbeatIntervall = 5000;
 const restartTimeout = 1000;
+/** Maximum reconnect delay in milliseconds (caps exponential backoff) */
+const MAX_RESTART_TIMEOUT = 30000;
 
 /**
- *
+ * Verwaltet die WebSocket-Verbindung zu Zigbee2MQTT inklusive
+ * Heartbeat-Überwachung und exponentiellem Reconnect-Backoff.
  */
 class WebsocketController {
     /**
-     * @param adapter
+     * Erstellt eine neue WebsocketController-Instanz.
+     *
+     * @param {object} adapter Die ioBroker-Adapter-Instanz
      */
     constructor(adapter) {
         this.adapter = adapter;
@@ -19,6 +24,8 @@ class WebsocketController {
         this.autoRestartTimeout = null;
         // Flag: wird bei closeConnection() gesetzt damit autoRestart() nicht feuert
         this._intentionalClose = false;
+        /** Aktueller Reconnect-Delay (exponentielles Backoff) */
+        this._reconnectDelay = restartTimeout;
     }
 
     /**
@@ -35,9 +42,9 @@ class WebsocketController {
         this._intentionalClose = false;
 
         // Vorherige Timer stoppen
-        clearTimeout(this.ping);
-        clearTimeout(this.pingTimeout);
-        clearTimeout(this.autoRestartTimeout);
+        this.adapter.clearTimeout(this.ping);
+        this.adapter.clearTimeout(this.pingTimeout);
+        this.adapter.clearTimeout(this.autoRestartTimeout);
 
         // Vorherige Verbindung sicher schließen und null setzen
         if (this.wsClient) {
@@ -55,14 +62,18 @@ class WebsocketController {
 
         try {
             let wsURL = `${this.adapter.config.wsScheme}://${this.adapter.config.wsServerIP}:${this.adapter.config.wsServerPort}/api`;
+            // Für Logging: URL ohne Token (Sicherheit)
+            const wsURLSafe = wsURL;
 
             if (this.adapter.config.wsTokenEnabled === true) {
                 wsURL += `?token=${this.adapter.config.wsToken}`;
             }
 
+            this.adapter.log.debug(`WebSocket connecting to ${wsURLSafe}`);
             this.wsClient = new WebSocket(wsURL, { rejectUnauthorized: false });
 
             this.wsClient.on('open', () => {
+                this._reconnectDelay = restartTimeout; // Backoff zurücksetzen bei Erfolg
                 this.adapter.log.info('Connect to Zigbee2MQTT over websocket connection.');
                 this.sendPingToServer();
                 this.wsHeartbeat();
@@ -87,32 +98,10 @@ class WebsocketController {
                 });
             });
 
-            this.wsClient.on('close', async (code, reason) => {
-                clearTimeout(this.pingTimeout);
-                clearTimeout(this.ping);
-
-                this.adapter.log.debug(`WebSocket closed – code: ${code}, reason: ${reason ? reason.toString() : 'none'}`);
-
-                try {
-                    if (this.adapter.statesController) {
-                        this.adapter.setStateChanged('info.connection', false, true);
-                        await this.adapter.statesController.setAllAvailableToFalse();
-                    }
-                } catch (err) {
-                    this.adapter.log.error(`close handler setAllAvailableToFalse error: ${err}`);
-                }
-
-                // Caches leeren
-                this.adapter.deviceCache.length = 0;
-                this.adapter.groupCache.length = 0;
-                for (const key of Object.keys(this.adapter.createCache)) {
-                    delete this.adapter.createCache[key];
-                }
-
-                // Nur reconnecten wenn kein intentionales Shutdown
-                if (!this._intentionalClose) {
-                    this.autoRestart();
-                }
+            this.wsClient.on('close', (code, reason) => {
+                this._onWsClose(code, reason).catch((err) => {
+                    this.adapter.log.error(`WebSocket close handler error: ${err}`);
+                });
             });
 
             this.wsClient.on('error', (err) => {
@@ -132,9 +121,43 @@ class WebsocketController {
     }
 
     /**
-     * Sendet eine Nachricht an Z2M.
+     * Interner async Handler für den WebSocket-close-Event.
+     *
+     * @param {number} code   WebSocket-Close-Code (z.B. 1000 = normal, 1006 = abnormal)
+     * @param {Buffer} reason Optionaler Grund-Text des Close-Events
+     */
+    async _onWsClose(code, reason) {
+        this.adapter.clearTimeout(this.pingTimeout);
+        this.adapter.clearTimeout(this.ping);
+
+        this.adapter.log.debug(`WebSocket closed – code: ${code}, reason: ${reason ? reason.toString() : 'none'}`);
+
+        try {
+            await this.adapter.setStateChangedAsync('info.connection', false, true);
+            if (this.adapter.statesController) {
+                await this.adapter.statesController.setAllAvailableToFalse();
+            }
+        } catch (err) {
+            this.adapter.log.error(`close handler setAllAvailableToFalse error: ${err}`);
+        }
+
+        // Caches leeren
+        this.adapter.deviceCache.length = 0;
+        this.adapter.groupCache.length = 0;
+        for (const key of Object.keys(this.adapter.createCache)) {
+            delete this.adapter.createCache[key];
+        }
+
+        // Nur reconnecten wenn kein intentionales Shutdown
+        if (!this._intentionalClose) {
+            this.autoRestart();
+        }
+    }
+
+    /**
+     * Sendet eine serialisierte Nachricht an Zigbee2MQTT über den WebSocket.
      *
-     * @param {string} message
+     * @param {string} message JSON-String der zu sendenden Nachricht
      */
     send(message) {
         if (!this.wsClient || this.wsClient.readyState !== WebSocket.OPEN) {
@@ -149,7 +172,8 @@ class WebsocketController {
     }
 
     /**
-     * Sendet regelmäßig Pings an den Server.
+     * Sendet regelmäßig WebSocket-Pings an den Z2M-Server
+     * und plant den nächsten Ping nach wsHeartbeatIntervall Millisekunden.
      */
     sendPingToServer() {
         if (!this.wsClient || this.wsClient.readyState !== WebSocket.OPEN) {
@@ -161,17 +185,19 @@ class WebsocketController {
             this.adapter.log.debug(`WebSocket ping error: ${err && err.message ? err.message : String(err)}`);
             return;
         }
-        this.ping = setTimeout(() => {
+        this.ping = this.adapter.setTimeout(() => {
             this.sendPingToServer();
         }, wsHeartbeatIntervall);
     }
 
     /**
-     * Überwacht den Heartbeat. Wenn kein Pong innerhalb des Timeouts kommt, wird die Verbindung getrennt.
+     * Startet oder erneuert den Heartbeat-Timeout.
+     * Wenn innerhalb von wsHeartbeatIntervall + 3000 ms kein Pong eintrifft,
+     * wird die Verbindung terminiert und autoRestart() ausgelöst.
      */
     wsHeartbeat() {
-        clearTimeout(this.pingTimeout);
-        this.pingTimeout = setTimeout(() => {
+        this.adapter.clearTimeout(this.pingTimeout);
+        this.pingTimeout = this.adapter.setTimeout(() => {
             this.adapter.log.warn('WebSocket connection timed out – terminating.');
             try {
                 if (this.wsClient) {
@@ -185,28 +211,33 @@ class WebsocketController {
     }
 
     /**
-     * Wartet kurz und baut dann die Verbindung neu auf.
+     * Plant einen Reconnect-Versuch mit exponentiellem Backoff.
+     * Der Delay verdoppelt sich mit jedem Versuch bis maximal MAX_RESTART_TIMEOUT ms.
      */
     autoRestart() {
-        this.adapter.log.warn(`WebSocket disconnected – reconnecting in ${restartTimeout / 1000} second(s)...`);
-        clearTimeout(this.autoRestartTimeout);
-        this.autoRestartTimeout = setTimeout(() => {
+        const delay = this._reconnectDelay;
+        this._reconnectDelay = Math.min(this._reconnectDelay * 2, MAX_RESTART_TIMEOUT);
+        this.adapter.log.warn(`WebSocket disconnected – reconnecting in ${delay / 1000} second(s)...`);
+        this.adapter.clearTimeout(this.autoRestartTimeout);
+        this.autoRestartTimeout = this.adapter.setTimeout(() => {
             try {
                 this.initWsClient();
             } catch (err) {
                 this.adapter.log.error(`autoRestart initWsClient error: ${err}`);
             }
-        }, restartTimeout);
+        }, delay);
     }
 
     /**
-     * Schließt die Verbindung intentional (kein autoRestart).
+     * Schließt die WebSocket-Verbindung intentional (kein autoRestart).
+     * Wird beim Adapter-Stop aufgerufen.
      */
     closeConnection() {
         this._intentionalClose = true;
-        clearTimeout(this.ping);
-        clearTimeout(this.pingTimeout);
-        clearTimeout(this.autoRestartTimeout);
+        this._reconnectDelay = restartTimeout; // Backoff zurücksetzen
+        this.adapter.clearTimeout(this.ping);
+        this.adapter.clearTimeout(this.pingTimeout);
+        this.adapter.clearTimeout(this.autoRestartTimeout);
         if (this.wsClient) {
             this.wsClient.removeAllListeners();
             try {
@@ -222,12 +253,13 @@ class WebsocketController {
     }
 
     /**
-     * Stoppt alle Timer (z.B. beim Adapter-Stop).
+     * Stoppt alle laufenden Timer (ping, pingTimeout, autoRestartTimeout).
+     * Wird beim Adapter-Stop aufgerufen.
      */
-    async allTimerClear() {
-        clearTimeout(this.pingTimeout);
-        clearTimeout(this.ping);
-        clearTimeout(this.autoRestartTimeout);
+    allTimerClear() {
+        this.adapter.clearTimeout(this.pingTimeout);
+        this.adapter.clearTimeout(this.ping);
+        this.adapter.clearTimeout(this.autoRestartTimeout);
     }
 }