homebridge-tuya-plus 3.14.0-dev.3 → 3.14.0-dev.30

package/lib/TuyaCloudMessaging.js

@@ -0,0 +1,219 @@
+'use strict';
+
+const EventEmitter = require('events');
+const crypto = require('crypto');
+
+/*
+ * TuyaCloudMessaging
+ * ------------------
+ * Realtime updates for cloud-backed devices, over Tuya's MQTT message service.
+ * ONE instance is shared by every cloud device on the same Tuya project (one
+ * broker connection delivers status for all of them); messages are fanned out
+ * to the right device by its `devId`.
+ *
+ * Cloud updates (including physical button presses and the rain sensor) arrive
+ * over this stream rather than by polling, so they show up in HomeKit within a
+ * second or two. `mqtt` is a required dependency; if the broker can't be
+ * reached or a message can't be decrypted nothing crashes — the stream simply
+ * reconnects and the cloud REST reads still cover initial state.
+ *
+ * The connection + AES-GCM message decryption are faithful to the
+ * actively-maintained `0x5e/homebridge-tuya-platform` (`src/core/TuyaOpenMQ.ts`),
+ * re-implemented here with Node's built-in `crypto`.
+ */
+
+const mqtt = require('mqtt');
+
+const GCM_TAG_LENGTH = 16;
+const PROTOCOL_DEVICE_STATUS = 4;
+
+class TuyaCloudMessaging extends EventEmitter {
+    constructor({api, log} = {}) {
+        super();
+        this.api = api;
+        this.log = log || console;
+
+        this.linkId = crypto.randomUUID(); // bare v4 UUID, reused across reconnects
+        this.client = null;
+        this.config = null;
+        this.connected = false;
+
+        this._handlers = new Map(); // devId -> [fn(status)]
+        this._renewTimer = null;
+        this._started = false;
+        this._stopped = false;
+
+        // EventEmitter with many devices listening to 'online'/'offline'.
+        this.setMaxListeners(0);
+    }
+
+    // Register a device's status handler and lazily start the shared connection.
+    subscribeDevice(devId, handler) {
+        const id = '' + devId;
+        if (!this._handlers.has(id)) this._handlers.set(id, []);
+        this._handlers.get(id).push(handler);
+        if (!this._started) this.start();
+    }
+
+    start() {
+        if (this._stopped || this._started) return;
+        this._started = true;
+
+        this._connect().catch(ex => {
+            this.log.warn(`Tuya Cloud realtime could not start (${ex.message}); it will keep retrying.`);
+            this._scheduleRenew(60);
+        });
+    }
+
+    async _connect() {
+        if (this._stopped) return;
+        this._teardownClient();
+
+        const cfg = await this.api.getMqttConfig(this.linkId);
+        this.config = cfg;
+
+        if (!cfg.url || !cfg.source_topic || !cfg.source_topic.device) {
+            throw new Error('incomplete MQTT config from Tuya');
+        }
+
+        const client = mqtt.connect(cfg.url, {
+            clientId: cfg.client_id,
+            username: cfg.username,
+            password: cfg.password
+        });
+
+        client.on('connect', () => {
+            this.connected = true;
+            client.subscribe(cfg.source_topic.device, err => {
+                if (err) this.log.debug(`Tuya Cloud realtime subscribe error: ${err.message}`);
+            });
+            this.log.info('Tuya Cloud realtime connected (MQTT).');
+            this.emit('online');
+        });
+        client.on('message', (topic, payload) => this._onMessage(topic, payload));
+        client.on('error', err => this.log.debug(`Tuya Cloud realtime error: ${err && err.message}`));
+        client.on('close', () => this._markOffline());
+        client.on('end', () => this._markOffline());
+
+        this.client = client;
+
+        // Broker credentials expire; renew them a minute early (mqtt.js handles
+        // transient drops on its own via auto-reconnect).
+        const ttl = parseInt(cfg.expire_time) || 7200;
+        this._scheduleRenew(Math.max(60, ttl - 60));
+    }
+
+    _markOffline() {
+        if (this.connected) {
+            this.connected = false;
+            this.emit('offline');
+        }
+    }
+
+    _scheduleRenew(seconds) {
+        if (this._renewTimer) clearTimeout(this._renewTimer);
+        if (this._stopped) return;
+        this._renewTimer = setTimeout(() => {
+            this._connect().catch(ex => {
+                this.log.debug(`Tuya Cloud realtime renew failed: ${ex.message}`);
+                this._scheduleRenew(60);
+            });
+        }, seconds * 1000);
+    }
+
+    _onMessage(topic, payload) {
+        let envelope;
+        try {
+            envelope = JSON.parse(payload.toString());
+        } catch (_) { return; }
+
+        const {protocol, data} = envelope;
+        if (!data) return;
+
+        let plaintext;
+        try {
+            plaintext = this._decrypt(data, this.config && this.config.password);
+        } catch (ex) {
+            this.log.debug(`Tuya Cloud realtime decrypt failed: ${ex.message}`);
+            return;
+        }
+
+        let msg;
+        try {
+            msg = JSON.parse(plaintext);
+        } catch (_) { return; }
+
+        // We only care about device status frames (protocol 4). Some firmwares
+        // omit `protocol`; in that case fall back to "has a status array".
+        if (protocol != null && protocol !== PROTOCOL_DEVICE_STATUS && !(msg && Array.isArray(msg.status))) return;
+
+        const devId = msg && (msg.devId || msg.devid || msg.dev_id);
+        const status = msg && msg.status;
+        if (!devId || !Array.isArray(status)) return;
+
+        const handlers = this._handlers.get('' + devId);
+        if (!handlers || !handlers.length) return;
+        handlers.forEach(fn => {
+            try { fn(status); } catch (ex) { this.log.debug(`Tuya Cloud realtime handler error: ${ex.message}`); }
+        });
+    }
+
+    // Decrypt the MQTT `data` field. msg_encrypted_version 2.0 → AES-128-GCM,
+    // 1.0 → AES-128-ECB. The AES key is the middle 16 chars of the broker
+    // password (NOT the project Access Secret).
+    //
+    // The GCM auth tag is intentionally NOT verified: Tuya's real status frames
+    // do not carry a tag that verifies against the documented AAD, so calling
+    // `decipher.final()` would throw on every genuine message and silently drop
+    // all realtime updates. AES-GCM is a stream cipher, so `update()` alone
+    // recovers the plaintext correctly regardless of the tag; a wrong key just
+    // yields garbage that the subsequent JSON.parse rejects. Both the official
+    // `tuya/tuya-homebridge` and `0x5e/homebridge-tuya-platform` decrypt with
+    // `update()` only, for exactly this reason — `final()` here was the bug that
+    // stopped external changes (physical buttons, the Tuya app) from showing up.
+    _decrypt(data, password) {
+        const key = Buffer.from(('' + (password || '')).substring(8, 24), 'utf8');
+        const buf = Buffer.from(data, 'base64');
+
+        // GCM (v2.0) layout: [ivLen(4) BE][iv(ivLen)][ciphertext][tag(16)].
+        // Try it first; if the header doesn't look like a sane IV length, fall
+        // back to ECB (v1.0).
+        if (buf.length > 4 + GCM_TAG_LENGTH) {
+            const ivLen = buf.readUIntBE(0, 4);
+            if (ivLen >= 12 && ivLen <= 16 && (4 + ivLen + GCM_TAG_LENGTH) <= buf.length) {
+                try {
+                    const iv = buf.slice(4, 4 + ivLen);
+                    const ciphertext = buf.slice(4 + ivLen, buf.length - GCM_TAG_LENGTH);
+                    const decipher = crypto.createDecipheriv('aes-128-gcm', key, iv);
+                    return decipher.update(ciphertext).toString('utf8');
+                } catch (gcmEx) {
+                    // fall through to ECB
+                }
+            }
+        }
+
+        const decipher = crypto.createDecipheriv('aes-128-ecb', key, null);
+        return Buffer.concat([decipher.update(buf), decipher.final()]).toString('utf8');
+    }
+
+    _teardownClient() {
+        if (this.client) {
+            try {
+                this.client.removeAllListeners();
+                this.client.end(true);
+            } catch (_) { /* ignore */ }
+            this.client = null;
+        }
+        this.connected = false;
+    }
+
+    stop() {
+        this._stopped = true;
+        if (this._renewTimer) { clearTimeout(this._renewTimer); this._renewTimer = null; }
+        this._teardownClient();
+    }
+}
+
+// Expose for unit tests / encryption round-trips.
+TuyaCloudMessaging.GCM_TAG_LENGTH = GCM_TAG_LENGTH;
+module.exports = TuyaCloudMessaging;

package/lib/TuyaDevice.js

@@ -0,0 +1,266 @@
+'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,
+                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/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]))
@@ -76,6 +76,7 @@ class VerticalBlindsWithTilt extends BaseAccessory {
 
     setPosition(value) {
         const {Characteristic} = this.hap;
+        if (!this.device.connected) throw this._commError();
 
         if (value === 0) {
             if (this.currentPosition === 0) {
@@ -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));