homebridge-tuya-plus 3.14.0-dev.4 → 3.14.0-dev.40

package/lib/TuyaDevice.js

@@ -0,0 +1,269 @@
+'use strict';
+
+const EventEmitter = require('events');
+const TuyaAccessory = require('./TuyaAccessory');
+const TuyaCloudDevice = require('./TuyaCloudDevice');
+
+/*
+ * TuyaDevice
+ * ----------
+ * The single `device` object every accessory now talks to. It presents the exact
+ * same minimal contract the accessories already rely on —
+ *
+ *   - `context`            device config (name, id, type, …)
+ *   - `state`              current data-points
+ *   - `connected`          boolean
+ *   - `_connect()`         start talking to the device
+ *   - `update(dps)`        write data-points
+ *   - 'connect' / 'change' events  (change → (changes, state))
+ *
+ * — but underneath it transparently spans BOTH transports:
+ *
+ *   - a LAN backend  (TuyaAccessory)   — the fast, private, local path
+ *   - a cloud backend (TuyaCloudDevice)— Tuya's internet path, used as a fallback
+ *
+ * Behaviour mirrors the official Tuya app: control goes over the LAN whenever the
+ * device is reachable there; if the LAN is down (or the device never appears on it
+ * — e.g. battery-powered "sleepy" units) it falls back to the cloud. Only when
+ * BOTH are unreachable does the device report disconnected, so the accessory shows
+ * "No Response". Accessories don't know or care which path is live.
+ *
+ * The one thing that differs between the transports is how a data-point is
+ * addressed: the LAN speaks numeric ids (1, 2, …), the cloud speaks string codes
+ * (switch_led, …). The cloud backend learns the id<->code map from the device's
+ * thing-shadow and keeps `state` keyed BOTH ways, so a configuration written for
+ * either transport resolves over the other. Writes are translated to whatever the
+ * live backend needs. The net effect: existing LAN configs gain a cloud fallback,
+ * and existing cloud configs gain LAN, with no config change.
+ */
+
+// When a LAN-primary device's cloud backend connects first but can't offer the
+// numeric data-point map (the device-shadow API isn't available), give the LAN a
+// short head start before letting the cloud drive the one-time characteristic
+// registration — so a numeric-DP config still registers against numeric keys.
+const LAN_REGISTRATION_GRACE_MS = 15000;
+
+class TuyaDevice extends EventEmitter {
+    constructor(props = {}) {
+        super();
+        // Several accessories attach their own 'change' listener on top of the one
+        // BaseAccessory uses; keep the default-listener guard from ever warning.
+        this.setMaxListeners(0);
+
+        this.log = props.log || console;
+
+        // A plain config object on `context`, mirroring the transport classes but
+        // without the live helper objects we were handed.
+        this.context = {...props};
+        delete this.context.log;
+        delete this.context.cloudApi;
+        delete this.context.messaging;
+
+        this.state = {};
+        this._stopped = false;
+        this._registered = false;       // has the first 'change' (registration) gone out?
+        this._connectEmitted = false;
+        this._lanGraceElapsed = false;
+
+        // LAN backend — created later, once an IP is known (see attachLan). A
+        // device with no local key can't speak the LAN protocol at all, so it is
+        // cloud-only and this stays null.
+        this.lan = null;
+
+        // Cloud backend — present whenever the platform handed us a shared cloud
+        // session and this device isn't opted out of it.
+        this.cloud = null;
+        if (props.cloudApi) {
+            this.cloud = new TuyaCloudDevice({
+                ...props,
+                cloudApi: props.cloudApi,
+                messaging: props.messaging,
+                log: this.log,
+                // Let the cloud backend tell a harmless fallback failure (the device
+                // is reachable over the LAN) apart from one that matters (it isn't).
+                isLanConnected: () => !!(this.lan && this.lan.connected),
+                connect: false
+            });
+        }
+
+        if (props.connect !== false) this._connect();
+    }
+
+    // Reachable over either transport.
+    get connected() {
+        return !!((this.lan && this.lan.connected) || (this.cloud && this.cloud.connected));
+    }
+
+    /* ------------------------------------------------------------------ *
+     *  Lifecycle
+     * ------------------------------------------------------------------ */
+
+    _connect() {
+        if (this.cloud) {
+            this._wire(this.cloud, 'cloud');
+            this.cloud._connect();
+
+            // Safety net for the LAN-without-map registration guard above.
+            if (this.context.key) {
+                setTimeout(() => {
+                    this._lanGraceElapsed = true;
+                    if (!this._registered) this._onBackendChange();
+                }, LAN_REGISTRATION_GRACE_MS).unref?.();
+            }
+        }
+        // The LAN backend is attached by the platform via attachLan() once the
+        // device's IP is known (from discovery, or a configured `ip`), preserving
+        // the existing discovery timing.
+    }
+
+    // Bring up (or update) the LAN transport for a device whose IP is now known.
+    // `target` carries the {ip, version} learned from discovery; a configured
+    // version/forceVersion still take precedence as they always have.
+    attachLan(target = {}) {
+        if (this._stopped || this.lan) return;
+        if (!this.context.key) {
+            this.log.debug(`${this.context.name}: no local key; staying on the cloud only.`);
+            return;
+        }
+        if (!target.ip && !this.context.ip) return;
+
+        let version = this.context.version;
+        if (target.version) version = target.version;          // the device's broadcast wins…
+        if (this.context.forceVersion) version = this.context.forceVersion; // …but forceVersion wins all
+
+        this.lan = new TuyaAccessory({
+            ...this.context,
+            ip: target.ip || this.context.ip,
+            version,
+            log: this.log,
+            connect: false
+        });
+        this._wire(this.lan, 'lan');
+        this.lan._connect();
+    }
+
+    _wire(backend, which) {
+        backend.on('connect', () => this._onBackendConnect(which));
+        backend.on('change', () => this._onBackendChange(which));
+    }
+
+    _onBackendConnect(which) {
+        this.log.debug(`${this.context.name}: ${which} backend connected.`);
+        if (!this._connectEmitted) {
+            this._connectEmitted = true;
+            this.emit('connect');
+        }
+    }
+
+    /* ------------------------------------------------------------------ *
+     *  State merge — LAN wins while it's up, cloud fills the rest / takes over
+     * ------------------------------------------------------------------ */
+
+    _merge() {
+        const merged = {};
+        if (this.cloud && this.cloud.connected) Object.assign(merged, this.cloud.state);
+        // LAN overlays the cloud while it's connected: it's the authoritative,
+        // freshest view for a device that's actually reachable locally.
+        if (this.lan && this.lan.connected) Object.assign(merged, this._lanStateDualKeyed());
+        return merged;
+    }
+
+    // LAN state is keyed by numeric dp id; mirror each value under its cloud code
+    // too (using the map the cloud backend learned), so a code-style config still
+    // resolves while the device is on the LAN.
+    _lanStateDualKeyed() {
+        const lanState = this.lan.state;
+        if (!this.cloud) return lanState;
+        const codeByDpId = this.cloud.codeByDpId;
+        const out = {...lanState};
+        for (const dp in lanState) {
+            const code = codeByDpId[dp];
+            if (code != null) out[code] = lanState[dp];
+        }
+        return out;
+    }
+
+    _onBackendChange(which) {
+        if (this._stopped) return;
+        if (!this._registered && !this._mayRegisterFrom(which)) return;
+
+        const merged = this._merge();
+        const changes = {};
+        Object.keys(merged).forEach(key => {
+            if (merged[key] !== this.state[key]) changes[key] = merged[key];
+        });
+
+        const first = !this._registered;
+        if (first || Object.keys(changes).length) {
+            this.state = {...this.state, ...merged};
+            this._registered = true;
+            // The first emit drives BaseAccessory's one-time characteristic
+            // registration; later emits carry only what actually changed.
+            this.emit('change', changes, this.state);
+        }
+    }
+
+    // Decide whether `which` backend may drive the one-time characteristic
+    // registration. LAN is always safe (numeric signature). The cloud is safe when
+    // the device is cloud-only (no local key), or once it has the numeric map (state
+    // is dual-keyed and so resolves a numeric-DP config), or once the LAN has been
+    // given its head start and didn't show up.
+    _mayRegisterFrom(which) {
+        if (which === 'lan') return true;
+        if (!this.context.key) return true;
+        if (this.cloud && Object.keys(this.cloud.codeByDpId).length) return true;
+        return this._lanGraceElapsed;
+    }
+
+    /* ------------------------------------------------------------------ *
+     *  Writes — LAN first, cloud as a fallback
+     * ------------------------------------------------------------------ */
+
+    update(dps) {
+        // Pure LAN (no cloud configured): byte-for-byte the legacy behaviour — a
+        // synchronous boolean, so the sync write helpers keep detecting failures.
+        if (!this.cloud) {
+            return this.lan ? this.lan.update(this._toLanDps(dps)) : false;
+        }
+        return this._updateWithFallback(dps);
+    }
+
+    async _updateWithFallback(dps) {
+        // Prefer the LAN while it's connected.
+        if (this.lan && this.lan.connected) {
+            if (this.lan.update(this._toLanDps(dps)) !== false) return true;
+            this.log.debug(`${this.context.name}: LAN write didn't go through; trying the cloud.`);
+        }
+        if (this.cloud && this.cloud.connected) {
+            return (await this.cloud.update(dps)) !== false;
+        }
+        // Cloud is down too — a last LAN attempt (it may have just dropped, and a
+        // buffered write is better than a guaranteed failure).
+        if (this.lan) return this.lan.update(this._toLanDps(dps)) !== false;
+        return false;
+    }
+
+    // Translate a write keyed by codes and/or numeric ids into the numeric ids the
+    // LAN protocol needs. Numeric ids pass straight through; a code with a known id
+    // is translated; an unmapped code is left as-is (TuyaAccessory.update will then
+    // simply ignore it, which is the safe degradation when no map is available).
+    _toLanDps(dps) {
+        if (!this.cloud || !dps || typeof dps !== 'object') return dps;
+        const dpIdByCode = this.cloud.dpIdByCode;
+        const out = {};
+        for (const key in dps) out[dpIdByCode[key] || key] = dps[key];
+        return out;
+    }
+
+    /* ------------------------------------------------------------------ *
+     *  Teardown (tidy; Homebridge doesn't strictly require it)
+     * ------------------------------------------------------------------ */
+
+    stop() {
+        this._stopped = true;
+        if (this.cloud && typeof this.cloud.stop === 'function') this.cloud.stop();
+        if (this.lan && typeof this.lan.stop === 'function') this.lan.stop();
+    }
+}
+
+module.exports = TuyaDevice;

package/lib/TuyaDiscovery.js

@@ -19,6 +19,7 @@ class TuyaDiscovery extends EventEmitter {
         this.limitedIds = [];
         this._servers = {};
         this._running = false;
+        this._portInUseWarned = {}; // ports already warned as in-use, so repeats stay at debug
     }
 
     start(props) {
@@ -85,7 +86,8 @@ class TuyaDiscovery extends EventEmitter {
         server.on('message', this._onDgramMessage.bind(this, port));
 
         server.bind(port, () => {
-            this.log.info(`Discovery - Discovery started on port ${port}.`);
+            this._portInUseWarned[port] = false; // a successful bind re-arms the in-use warning
+            this.log.debug(`Discovery started on port ${port}.`);
         });
     }
 
@@ -101,20 +103,30 @@ class TuyaDiscovery extends EventEmitter {
         this._stop(port);
 
         if (err && err.code === 'EADDRINUSE') {
-            this.log.warn(`Discovery - Port ${port} is in use. Will retry in 15 seconds.`);
+            // The retry runs every 15s for as long as the port stays taken (usually
+            // another Tuya plugin or a second instance). Warn once so it's
+            // actionable, then drop to debug so a persistent conflict doesn't flood
+            // the log; a later successful bind re-arms the warning.
+            const message = `Port ${port} is in use (is another Tuya plugin or instance running?). Will retry in 15 seconds.`;
+            if (this._portInUseWarned[port]) {
+                this.log.debug(`Discovery - ${message}`);
+            } else {
+                this.log.warn(`Discovery - ${message}`);
+                this._portInUseWarned[port] = true;
+            }
 
             setTimeout(() => {
                 this._start(port);
             }, 15000);
         } else {
-            this.log.error(`Discovery - Port ${port} failed:\n${err.stack}`);
+            this.log.error(`Discovery - Port ${port} failed:\n${err && err.stack || err}`);
         }
     }
 
     _onDgramClose(port) {
         this._stop(port);
 
-        this.log.info(`Discovery - Port ${port} closed.${this._running ? ' Restarting...' : ''}`);
+        this.log.debug(`Discovery - Port ${port} closed.${this._running ? ' Restarting...' : ''}`);
         if (this._running)
             setTimeout(() => {
                 this._start(port);
@@ -152,7 +164,7 @@ class TuyaDiscovery extends EventEmitter {
         const size = pkt.readUInt32BE(12);
 
         if (len - size < 8) {
-            this.log.error(`Discovery - UDP from ${info.address}:${port} size ${len - size}`);
+            this.log.debug(`Discovery - undersized UDP packet from ${info.address}:${port} (ignored).`);
             return;
         }
 
@@ -174,11 +186,14 @@ class TuyaDiscovery extends EventEmitter {
             if (result && result.gwId && result.ip) {
                 this._onDiscover(result);
             } else {
-                this.log.error(`Discovery - UDP from ${info.address}:${port} decrypted`, cleanMsg.toString('hex'));
+                this.log.debug(`Discovery - unrecognised UDP payload from ${info.address}:${port} (ignored):`, cleanMsg.toString('hex'));
             }
         } catch (ex) {
-            this.log.error(`Discovery - Failed to parse discovery response on port ${port}: ${decryptedMsg}`);
-            this.log.error(`Discovery - Failed to parse discovery raw message on port ${port}: ${pkt.toString('hex')}`);
+            // Not every Tuya-framed packet on these ports is a discovery reply we
+            // can parse (other broadcast types, foreign accounts, partial packets);
+            // none of it is an error worth surfacing.
+            this.log.debug(`Discovery - could not parse discovery response on port ${port}: ${decryptedMsg}`);
+            this.log.debug(`Discovery - raw unparsed message on port ${port}: ${pkt.toString('hex')}`);
         }
     }
 
@@ -230,7 +245,8 @@ class TuyaDiscovery extends EventEmitter {
                 this._onDiscover(payload);
             }
         } catch (ex) {
-            this.log.error(
+            // Foreign or partial packets on the v3.5 reply port are expected noise.
+            this.log.debug(
                 `Discovery v3.5 – failed to decrypt packet from ${info.address}:${srcPort}:`,
                 ex.message
             );

package/lib/ValveAccessory.js

@@ -49,13 +49,13 @@ class ValveAccessory extends BaseAccessory {
             .onSet(value => this.setStateAsync(this.dpPower, value));
 
         const characteristicInUse = service.getCharacteristic(Characteristic.InUse)
-            .onGet(() => characteristicActive.value);
+            .onGet(() => { if (!this.device.connected) throw this._commError(); return characteristicActive.value; });
 
         if (!this.noTimer) {
             service.getCharacteristic(Characteristic.SetDuration)
-                .onGet(() => this.setDuration)
+                .onGet(() => { if (!this.device.connected) throw this._commError(); return this.setDuration; })
                 .on('change', (data) => {
-                    this.log.info('Water Valve Time Duration Set to: ' + data.newValue / 60 + ' Minutes');
+                    this.log.debug('Water Valve Time Duration Set to: ' + data.newValue / 60 + ' Minutes');
                     this.setDuration = data.newValue;
 
                     if (service.getCharacteristic(Characteristic.InUse).value) {
@@ -65,8 +65,9 @@ class ValveAccessory extends BaseAccessory {
 
                         clearTimeout(this.timer);
                         this.timer = setTimeout(() => {
-                            this.log.info('Water Valve Timer Expired. Shutting OFF Valve');
-                            service.getCharacteristic(Characteristic.Active).setValue(0);
+                            this.log.debug('Water Valve Timer Expired. Shutting OFF Valve');
+                            this.setStateInBackground(this.dpPower, 0);
+                            service.getCharacteristic(Characteristic.Active).updateValue(0);
                             service.getCharacteristic(Characteristic.InUse).updateValue(0);
                             this.lastActivationTime = null;
                         }, (data.newValue * 1000));
@@ -75,6 +76,7 @@ class ValveAccessory extends BaseAccessory {
 
             service.getCharacteristic(Characteristic.RemainingDuration)
                 .onGet(() => {
+                    if (!this.device.connected) throw this._commError();
                     let remainingTime = this.setDuration - Math.floor(((new Date()).getTime() - this.lastActivationTime) / 1000);
                     return (remainingTime && remainingTime > 0) ? remainingTime : 0;
                 });
@@ -87,17 +89,18 @@ class ValveAccessory extends BaseAccessory {
                             service.getCharacteristic(Characteristic.RemainingDuration).updateValue(0);
                             service.getCharacteristic(Characteristic.Active).updateValue(0);
                             clearTimeout(this.timer);
-                            this.log.info('Water Valve is OFF!');
+                            this.log.debug('Water Valve is OFF!');
                             break;
                         case 1:
                             this.lastActivationTime = (new Date()).getTime();
                             service.getCharacteristic(Characteristic.RemainingDuration).updateValue(this.setDuration);
                             service.getCharacteristic(Characteristic.Active).updateValue(1);
-                            this.log.info('Water Valve Turning ON with Timer Set to: ' + this.setDuration / 60 + ' Minutes');
+                            this.log.debug('Water Valve Turning ON with Timer Set to: ' + this.setDuration / 60 + ' Minutes');
                             clearTimeout(this.timer);
                             this.timer = setTimeout(() => {
-                                this.log.info('Water Valve Timer Expired. Shutting OFF Valve');
-                                service.getCharacteristic(Characteristic.Active).setValue(0);
+                                this.log.debug('Water Valve Timer Expired. Shutting OFF Valve');
+                                this.setStateInBackground(this.dpPower, 0);
+                                service.getCharacteristic(Characteristic.Active).updateValue(0);
                                 service.getCharacteristic(Characteristic.InUse).updateValue(0);
                                 this.lastActivationTime = null;
                             }, (this.setDuration * 1000));
@@ -110,11 +113,12 @@ class ValveAccessory extends BaseAccessory {
                 service.getCharacteristic(Characteristic.RemainingDuration).updateValue(this.setDuration);
                 service.getCharacteristic(Characteristic.Active).updateValue(1);
                 service.getCharacteristic(Characteristic.InUse).updateValue(1);
-                this.log.info('Water Valve is ON After Restart. Setting Timer to: ' + this.setDuration / 60 + ' Minutes');
+                this.log.debug('Water Valve is ON After Restart. Setting Timer to: ' + this.setDuration / 60 + ' Minutes');
                 clearTimeout(this.timer);
                 this.timer = setTimeout(() => {
-                    this.log.info('Water Valve Timer Expired. Shutting OFF Valve');
-                    service.getCharacteristic(Characteristic.Active).setValue(0);
+                    this.log.debug('Water Valve Timer Expired. Shutting OFF Valve');
+                    this.setStateInBackground(this.dpPower, 0);
+                    service.getCharacteristic(Characteristic.Active).updateValue(0);
                     this.lastActivationTime = null;
                 }, (this.setDuration * 1000));
             }

package/lib/VerticalBlindsWithTilt.js

@@ -38,16 +38,16 @@ class VerticalBlindsWithTilt extends BaseAccessory {
 
         const characteristicCurrentPosition = service.getCharacteristic(Characteristic.CurrentPosition)
             .updateValue(this.currentPosition)
-            .onGet(() => this.currentPosition);
+            .onGet(() => { if (!this.device.connected) throw this._commError(); return this.currentPosition; });
 
         const characteristicTargetPosition = service.getCharacteristic(Characteristic.TargetPosition)
             .updateValue(this.currentPosition)
-            .onGet(() => this.currentPosition)
+            .onGet(() => { if (!this.device.connected) throw this._commError(); return this.currentPosition; })
             .onSet(value => this.setPosition(value));
 
         const characteristicPositionState = service.getCharacteristic(Characteristic.PositionState)
             .updateValue(Characteristic.PositionState.STOPPED)
-            .onGet(() => Characteristic.PositionState.STOPPED);
+            .onGet(() => { if (!this.device.connected) throw this._commError(); return Characteristic.PositionState.STOPPED; });
 
         const characteristicCurrentHorizontalTilt = service.getCharacteristic(Characteristic.CurrentHorizontalTiltAngle)
             .updateValue(this._getTiltAngle(dps[this.dpTiltState] || dps[this.dpTilt]))
@@ -67,33 +67,34 @@ class VerticalBlindsWithTilt extends BaseAccessory {
 
     _getInitialPosition(dps) {
         if (this.accessory.context.cachedPosition !== undefined) {
-            this.log('[TuyaAccessory] Restored position from cache:', this.accessory.context.cachedPosition + '%');
+            this.log.debug('[TuyaAccessory] Restored position from cache:', this.accessory.context.cachedPosition + '%');
             return this.accessory.context.cachedPosition;
         }
-        this.log('[TuyaAccessory] Initial position unknown (first time setup), defaulting to open (100%)');
+        this.log.debug('[TuyaAccessory] Initial position unknown (first time setup), defaulting to open (100%)');
         return 100;
     }
 
     setPosition(value) {
         const {Characteristic} = this.hap;
+        if (!this.device.connected) throw this._commError();
 
         if (value === 0) {
             if (this.currentPosition === 0) {
-                this.log('[TuyaAccessory] Blinds already closed, skipping close command');
+                this.log.debug('[TuyaAccessory] Blinds already closed, skipping close command');
                 return;
             }
 
-            this.log('[TuyaAccessory] Closing blinds');
+            this.log.debug('[TuyaAccessory] Closing blinds');
             this.lastCloseTime = Date.now();
             this.isMoving = true;
 
             if (this.lastTiltCommand && (Date.now() - this.lastTiltCommand.time < this.timeToClose * 1000)) {
-                this.log('[TuyaAccessory] Close command received while tilt was pending - rescheduling tilt delay');
+                this.log.debug('[TuyaAccessory] Close command received while tilt was pending - rescheduling tilt delay');
                 if (this.tiltBufferTimeout) { clearTimeout(this.tiltBufferTimeout); this.tiltBufferTimeout = null; }
                 if (this.tiltDelayTimeout) clearTimeout(this.tiltDelayTimeout);
                 const delayMs = this.timeToClose * 1000;
                 this.tiltDelayTimeout = setTimeout(() => {
-                    this.log('[TuyaAccessory] Executing delayed tilt angle:', this.lastTiltCommand.angle, '-> Tuya percent_control:', this.lastTiltCommand.value);
+                    this.log.debug('[TuyaAccessory] Executing delayed tilt angle:', this.lastTiltCommand.angle, '-> Tuya percent_control:', this.lastTiltCommand.value);
                     this._executeTilt(this.lastTiltCommand.value);
                     this.tiltDelayTimeout = null;
                     this.lastTiltCommand = null;
@@ -105,7 +106,7 @@ class VerticalBlindsWithTilt extends BaseAccessory {
 
             if (this.positionStateTimeout) clearTimeout(this.positionStateTimeout);
             this.positionStateTimeout = setTimeout(() => {
-                this.log('[TuyaAccessory] Blinds finished closing');
+                this.log.debug('[TuyaAccessory] Blinds finished closing');
                 this.currentPosition = 0;
                 this.accessory.context.cachedPosition = 0;
                 this.characteristicCurrentPosition.updateValue(0);
@@ -119,19 +120,19 @@ class VerticalBlindsWithTilt extends BaseAccessory {
 
         } else if (value === 100) {
             if (this.currentPosition === 100) {
-                this.log('[TuyaAccessory] Blinds already open, skipping open command');
+                this.log.debug('[TuyaAccessory] Blinds already open, skipping open command');
                 return;
             }
 
-            this.log('[TuyaAccessory] Opening blinds');
+            this.log.debug('[TuyaAccessory] Opening blinds');
 
             if (this.lastTiltCommand && (Date.now() - this.lastTiltCommand.time < this.timeToClose * 1000)) {
-                this.log('[TuyaAccessory] Open command received while tilt was pending - rescheduling tilt delay');
+                this.log.debug('[TuyaAccessory] Open command received while tilt was pending - rescheduling tilt delay');
                 if (this.tiltBufferTimeout) { clearTimeout(this.tiltBufferTimeout); this.tiltBufferTimeout = null; }
                 if (this.tiltDelayTimeout) clearTimeout(this.tiltDelayTimeout);
                 const delayMs = this.timeToClose * 1000;
                 this.tiltDelayTimeout = setTimeout(() => {
-                    this.log('[TuyaAccessory] Executing delayed tilt angle:', this.lastTiltCommand.angle, '-> Tuya percent_control:', this.lastTiltCommand.value);
+                    this.log.debug('[TuyaAccessory] Executing delayed tilt angle:', this.lastTiltCommand.angle, '-> Tuya percent_control:', this.lastTiltCommand.value);
                     this._executeTilt(this.lastTiltCommand.value);
                     this.tiltDelayTimeout = null;
                     this.lastTiltCommand = null;
@@ -148,7 +149,7 @@ class VerticalBlindsWithTilt extends BaseAccessory {
 
             if (this.positionStateTimeout) clearTimeout(this.positionStateTimeout);
             this.positionStateTimeout = setTimeout(() => {
-                this.log('[TuyaAccessory] Blinds finished opening');
+                this.log.debug('[TuyaAccessory] Blinds finished opening');
                 this.currentPosition = 100;
                 this.accessory.context.cachedPosition = 100;
                 this.characteristicCurrentPosition.updateValue(100);
@@ -160,15 +161,15 @@ class VerticalBlindsWithTilt extends BaseAccessory {
             return this.setStateAsync(this.dpAction, 'open');
 
         } else {
-            this.log('[TuyaAccessory] Partial position requested, opening fully');
+            this.log.debug('[TuyaAccessory] Partial position requested, opening fully');
 
             if (this.lastTiltCommand && (Date.now() - this.lastTiltCommand.time < this.timeToClose * 1000)) {
-                this.log('[TuyaAccessory] Partial open command received while tilt was pending - rescheduling tilt delay');
+                this.log.debug('[TuyaAccessory] Partial open command received while tilt was pending - rescheduling tilt delay');
                 if (this.tiltBufferTimeout) { clearTimeout(this.tiltBufferTimeout); this.tiltBufferTimeout = null; }
                 if (this.tiltDelayTimeout) clearTimeout(this.tiltDelayTimeout);
                 const delayMs = this.timeToClose * 1000;
                 this.tiltDelayTimeout = setTimeout(() => {
-                    this.log('[TuyaAccessory] Executing delayed tilt angle:', this.lastTiltCommand.angle, '-> Tuya percent_control:', this.lastTiltCommand.value);
+                    this.log.debug('[TuyaAccessory] Executing delayed tilt angle:', this.lastTiltCommand.angle, '-> Tuya percent_control:', this.lastTiltCommand.value);
                     this._executeTilt(this.lastTiltCommand.value);
                     this.tiltDelayTimeout = null;
                     this.lastTiltCommand = null;
@@ -185,7 +186,7 @@ class VerticalBlindsWithTilt extends BaseAccessory {
 
             if (this.positionStateTimeout) clearTimeout(this.positionStateTimeout);
             this.positionStateTimeout = setTimeout(() => {
-                this.log('[TuyaAccessory] Blinds finished opening');
+                this.log.debug('[TuyaAccessory] Blinds finished opening');
                 this.currentPosition = 100;
                 this.accessory.context.cachedPosition = 100;
                 this.characteristicCurrentPosition.updateValue(100);
@@ -205,6 +206,7 @@ class VerticalBlindsWithTilt extends BaseAccessory {
     }
 
     setTiltAngle(value) {
+        if (!this.device.connected) throw this._commError();
         const tuyaValue = Math.round((value / 1.8) + 50);
         const clampedValue = Math.max(0, Math.min(100, tuyaValue));
 
@@ -221,12 +223,12 @@ class VerticalBlindsWithTilt extends BaseAccessory {
                 ? (this.timeToClose * 1000) - timeSinceClose
                 : (this.timeToClose * 1000) - timeSinceOpen;
             const action = shouldDelayForClose ? 'close' : 'open';
-            this.log('[TuyaAccessory] Tilt command received during', action, '- delaying by', Math.round(delayMs / 1000), 'seconds');
+            this.log.debug('[TuyaAccessory] Tilt command received during', action, '- delaying by', Math.round(delayMs / 1000), 'seconds');
 
             this._cancelPendingTilts();
 
             this.tiltDelayTimeout = setTimeout(() => {
-                this.log('[TuyaAccessory] Executing delayed tilt angle:', value, '-> Tuya percent_control:', clampedValue);
+                this.log.debug('[TuyaAccessory] Executing delayed tilt angle:', value, '-> Tuya percent_control:', clampedValue);
                 this._executeTilt(clampedValue);
                 this.tiltDelayTimeout = null;
                 this.lastCloseTime = 0;
@@ -235,7 +237,7 @@ class VerticalBlindsWithTilt extends BaseAccessory {
             }, delayMs);
 
         } else {
-            this.log('[TuyaAccessory] Setting tilt angle:', value, '-> Tuya percent_control:', clampedValue);
+            this.log.debug('[TuyaAccessory] Setting tilt angle:', value, '-> Tuya percent_control:', clampedValue);
 
             if (this.tiltBufferTimeout) clearTimeout(this.tiltBufferTimeout);
 
@@ -256,7 +258,7 @@ class VerticalBlindsWithTilt extends BaseAccessory {
 
     _executeTilt(value) {
         if (!this.device.connected) {
-            this.log('[TuyaAccessory] Cannot execute tilt - device not connected');
+            this.log.debug('[TuyaAccessory] Cannot execute tilt - device not connected');
             return;
         }
         this.device.update({[this.dpTilt]: value});
@@ -266,12 +268,12 @@ class VerticalBlindsWithTilt extends BaseAccessory {
         if (this.tiltBufferTimeout) {
             clearTimeout(this.tiltBufferTimeout);
             this.tiltBufferTimeout = null;
-            this.log('[TuyaAccessory] Cleared pending tilt buffer');
+            this.log.debug('[TuyaAccessory] Cleared pending tilt buffer');
         }
         if (this.tiltDelayTimeout) {
             clearTimeout(this.tiltDelayTimeout);
             this.tiltDelayTimeout = null;
-            this.log('[TuyaAccessory] Cleared pending tilt delay');
+            this.log.debug('[TuyaAccessory] Cleared pending tilt delay');
         }
     }