homebridge-tuya-plus 3.14.0-dev.5 → 3.14.0-dev.52

package/lib/RGBTWLightAccessory.js

@@ -134,8 +134,8 @@ class RGBTWLightAccessory extends BaseAccessory {
     }
 
     getBrightness() {
-        if (this.device.state[this.dpMode] === this.cmdWhite) return this.convertBrightnessFromTuyaToHomeKit(this.device.state[this.dpBrightness]);
-        return this.convertColorFromTuyaToHomeKit(this.device.state[this.dpColor]).b;
+        if (this.getStateAsync(this.dpMode) === this.cmdWhite) return this.convertBrightnessFromTuyaToHomeKit(this.getStateAsync(this.dpBrightness));
+        return this.convertColorFromTuyaToHomeKit(this.getStateAsync(this.dpColor)).b;
     }
 
     setBrightness(value) {
@@ -145,8 +145,8 @@ class RGBTWLightAccessory extends BaseAccessory {
 
     getColorTemperature() {
         this.log.debug(`getColorTemperature`);
-        if (this.device.state[this.dpMode] !== this.cmdWhite) return this.minWhiteColor;
-        return this.convertColorTemperatureFromTuyaToHomeKit(this.device.state[this.dpColorTemperature]);
+        if (this.getStateAsync(this.dpMode) !== this.cmdWhite) return this.minWhiteColor;
+        return this.convertColorTemperatureFromTuyaToHomeKit(this.getStateAsync(this.dpColorTemperature));
     }
 
     setColorTemperature(value) {
@@ -165,10 +165,10 @@ class RGBTWLightAccessory extends BaseAccessory {
     }
 
     getHue() {
-        if (this.device.state[this.dpMode] === this.cmdWhite) {
-            return this.convertHomeKitColorTemperatureToHomeKitColor(this.convertColorTemperatureFromTuyaToHomeKit(this.device.state[this.dpColorTemperature])).h;
+        if (this.getStateAsync(this.dpMode) === this.cmdWhite) {
+            return this.convertHomeKitColorTemperatureToHomeKitColor(this.convertColorTemperatureFromTuyaToHomeKit(this.getStateAsync(this.dpColorTemperature))).h;
         }
-        return this.convertColorFromTuyaToHomeKit(this.device.state[this.dpColor]).h;
+        return this.convertColorFromTuyaToHomeKit(this.getStateAsync(this.dpColor)).h;
     }
 
     setHue(value) {
@@ -176,10 +176,10 @@ class RGBTWLightAccessory extends BaseAccessory {
     }
 
     getSaturation() {
-        if (this.device.state[this.dpMode] === this.cmdWhite) {
-            return this.convertHomeKitColorTemperatureToHomeKitColor(this.convertColorTemperatureFromTuyaToHomeKit(this.device.state[this.dpColorTemperature])).s;
+        if (this.getStateAsync(this.dpMode) === this.cmdWhite) {
+            return this.convertHomeKitColorTemperatureToHomeKitColor(this.convertColorTemperatureFromTuyaToHomeKit(this.getStateAsync(this.dpColorTemperature))).s;
         }
-        return this.convertColorFromTuyaToHomeKit(this.device.state[this.dpColor]).s;
+        return this.convertColorFromTuyaToHomeKit(this.getStateAsync(this.dpColor)).s;
     }
 
     setSaturation(value) {
@@ -187,6 +187,8 @@ class RGBTWLightAccessory extends BaseAccessory {
     }
 
     _setHueSaturation(prop) {
+        if (!this.device.connected) throw this._commError();
+
         if (!this._pendingHueSaturation) {
             this._pendingHueSaturation = {props: {}, resolvers: []};
         }
@@ -208,7 +210,7 @@ class RGBTWLightAccessory extends BaseAccessory {
                 const newValue = this.convertColorFromHomeKitToTuya(props);
 
                 if (!(this.device.state[this.dpMode] === this.cmdWhite && isSham)) {
-                    this.setMultiStateAsync({[this.dpMode]: this.cmdColor, [this.dpColor]: newValue});
+                    this.setMultiStateInBackground({[this.dpMode]: this.cmdColor, [this.dpColor]: newValue});
                 }
                 this.characteristicColorTemperature.updateValue(this.minWhiteColor);
 

package/lib/RGBTWOutletAccessory.js

@@ -196,8 +196,8 @@ class RGBTWOutletAccessory extends BaseAccessory {
     }
 
     getBrightness() {
-        if (this.device.state[this.dpMode] === this.cmdWhite) return this.convertBrightnessFromTuyaToHomeKit(this.device.state[this.dpBrightness]);
-        return this.convertColorFromTuyaToHomeKit(this.device.state[this.dpColor]).b;
+        if (this.getStateAsync(this.dpMode) === this.cmdWhite) return this.convertBrightnessFromTuyaToHomeKit(this.getStateAsync(this.dpBrightness));
+        return this.convertColorFromTuyaToHomeKit(this.getStateAsync(this.dpColor)).b;
     }
 
     setBrightness(value) {
@@ -206,8 +206,8 @@ class RGBTWOutletAccessory extends BaseAccessory {
     }
 
     getColorTemperature() {
-        if (this.device.state[this.dpMode] !== this.cmdWhite) return 0;
-        return this.convertColorTemperatureFromTuyaToHomeKit(this.device.state[this.dpColorTemperature]);
+        if (this.getStateAsync(this.dpMode) !== this.cmdWhite) return 0;
+        return this.convertColorTemperatureFromTuyaToHomeKit(this.getStateAsync(this.dpColorTemperature));
     }
 
     setColorTemperature(value) {
@@ -221,8 +221,8 @@ class RGBTWOutletAccessory extends BaseAccessory {
     }
 
     getHue() {
-        if (this.device.state[this.dpMode] === this.cmdWhite) return 0;
-        return this.convertColorFromTuyaToHomeKit(this.device.state[this.dpColor]).h;
+        if (this.getStateAsync(this.dpMode) === this.cmdWhite) return 0;
+        return this.convertColorFromTuyaToHomeKit(this.getStateAsync(this.dpColor)).h;
     }
 
     setHue(value) {
@@ -230,8 +230,8 @@ class RGBTWOutletAccessory extends BaseAccessory {
     }
 
     getSaturation() {
-        if (this.device.state[this.dpMode] === this.cmdWhite) return 0;
-        return this.convertColorFromTuyaToHomeKit(this.device.state[this.dpColor]).s;
+        if (this.getStateAsync(this.dpMode) === this.cmdWhite) return 0;
+        return this.convertColorFromTuyaToHomeKit(this.getStateAsync(this.dpColor)).s;
     }
 
     setSaturation(value) {
@@ -239,6 +239,8 @@ class RGBTWOutletAccessory extends BaseAccessory {
     }
 
     _setHueSaturation(prop) {
+        if (!this.device.connected) throw this._commError();
+
         if (!this._pendingHueSaturation) {
             this._pendingHueSaturation = {props: {}, resolvers: []};
         }
@@ -257,7 +259,7 @@ class RGBTWOutletAccessory extends BaseAccessory {
                 const newValue = this.convertColorFromHomeKitToTuya(props);
 
                 if (!(this.device.state[this.dpMode] === this.cmdWhite && isSham)) {
-                    this.setMultiStateAsync({[this.dpMode]: this.cmdColor, [this.dpColor]: newValue});
+                    this.setMultiStateInBackground({[this.dpMode]: this.cmdColor, [this.dpColor]: newValue});
                 }
                 this.characteristicColorTemperature.updateValue(0);
 

package/lib/SimpleBlindsAccessory.js

@@ -92,7 +92,7 @@ class SimpleBlindsAccessory extends BaseAccessory {
 
         const characteristicPositionState = service.getCharacteristic(Characteristic.PositionState)
             .updateValue(this._getPositionState())
-            .onGet(() => this._getPositionState());
+            .onGet(() => { if (!this.device.connected) throw this._commError(); return this._getPositionState(); });
 
         this.device.on('change', changes => {
             this.log.debug('[TuyaAccessory] Blinds saw change to ' + changes[this.dpAction]);
@@ -176,7 +176,7 @@ class SimpleBlindsAccessory extends BaseAccessory {
     }
 
     getCurrentPosition() {
-        return this._getCurrentPosition(this.device.state[this.dpAction]);
+        return this._getCurrentPosition(this.getStateAsync(this.dpAction));
     }
 
     _getCurrentPosition(dp) {
@@ -191,7 +191,7 @@ class SimpleBlindsAccessory extends BaseAccessory {
     }
 
     getTargetPosition() {
-        return this._getTargetPosition(this.device.state[this.dpAction]);
+        return this._getTargetPosition(this.getStateAsync(this.dpAction));
     }
 
     _getTargetPosition(dp) {
@@ -234,7 +234,7 @@ class SimpleBlindsAccessory extends BaseAccessory {
                 this.log.debug('[TuyaAccessory] Blinds will stop in ' + duration + 'ms');
                 this.changeTimeout = setTimeout(() => {
                     this.log.debug('[TuyaAccessory] Blinds asked to stop');
-                    this.setStateAsync(this.dpAction, this.cmdStop);
+                    this.setStateInBackground(this.dpAction, this.cmdStop);
                 }, duration);
             }
             return result;
@@ -246,7 +246,7 @@ class SimpleBlindsAccessory extends BaseAccessory {
                 this.log.debug('[TuyaAccessory] Blinds will stop in ' + duration + 'ms');
                 this.changeTimeout = setTimeout(() => {
                     this.log.debug('[TuyaAccessory] Blinds asked to stop');
-                    this.setStateAsync(this.dpAction, this.cmdStop);
+                    this.setStateInBackground(this.dpAction, this.cmdStop);
                 }, duration);
             }
             return result;

package/lib/SimpleDimmer2Accessory.js

@@ -43,7 +43,7 @@ class SimpleDimmer2Accessory extends BaseAccessory {
     }
 
     getBrightness() {
-        return this.convertBrightnessFromTuyaToHomeKit(this.device.state[this.dpBrightness]);
+        return this.convertBrightnessFromTuyaToHomeKit(this.getStateAsync(this.dpBrightness));
     }
 
     setBrightness(value) {

package/lib/SimpleDimmerAccessory.js

@@ -25,25 +25,29 @@ class SimpleDimmerAccessory extends BaseAccessory {
         this.dpPower = this._getCustomDP(this.device.context.dpPower) || '1';
         this.dpBrightness = this._getCustomDP(this.device.context.dpBrightness) || this._getCustomDP(this.device.context.dp) || '2';
 
-        const characteristicOn = service.getCharacteristic(Characteristic.On)
+        this._characteristicOn = service.getCharacteristic(Characteristic.On)
             .updateValue(dps[this.dpPower])
             .onGet(() => this.getStateAsync(this.dpPower))
             .onSet(value => this.setStateAsync(this.dpPower, value));
 
-        const characteristicBrightness = service.getCharacteristic(Characteristic.Brightness)
+        this._characteristicBrightness = service.getCharacteristic(Characteristic.Brightness)
             .updateValue(this.convertBrightnessFromTuyaToHomeKit(dps[this.dpBrightness]))
             .onGet(() => this.getBrightness())
             .onSet(value => this.setBrightness(value));
 
+        this._registerChangeListener();
+    }
+
+    _registerChangeListener() {
         this.device.on('change', changes => {
-            if (changes.hasOwnProperty(this.dpPower) && characteristicOn.value !== changes[this.dpPower]) characteristicOn.updateValue(changes[this.dpPower]);
-            if (changes.hasOwnProperty(this.dpBrightness) && this.convertBrightnessFromHomeKitToTuya(characteristicBrightness.value) !== changes[this.dpBrightness])
-                characteristicBrightness.updateValue(this.convertBrightnessFromTuyaToHomeKit(changes[this.dpBrightness]));
+            if (changes.hasOwnProperty(this.dpPower) && this._characteristicOn.value !== changes[this.dpPower]) this._characteristicOn.updateValue(changes[this.dpPower]);
+            if (changes.hasOwnProperty(this.dpBrightness) && this.convertBrightnessFromHomeKitToTuya(this._characteristicBrightness.value) !== changes[this.dpBrightness])
+                this._characteristicBrightness.updateValue(this.convertBrightnessFromTuyaToHomeKit(changes[this.dpBrightness]));
         });
     }
 
     getBrightness() {
-        return this.convertBrightnessFromTuyaToHomeKit(this.device.state[this.dpBrightness]);
+        return this.convertBrightnessFromTuyaToHomeKit(this.getStateAsync(this.dpBrightness));
     }
 
     setBrightness(value) {

package/lib/SimpleGarageDoorAccessory.js

@@ -98,6 +98,12 @@ class SimpleGarageDoorAccessory extends BaseAccessory {
         // and the close that trails a stop in the stop-before-close path.
         this.partialStopTimer = null;
         this.pendingCloseTimer = null;
+        // A partial open that has fired its open but is still waiting for the
+        // controller to report it's moving before arming the auto-stop.
+        this.partialPending = false;
+        // Bumped whenever a partial open starts or is superseded/cancelled, so a
+        // stale auto-stop (and its re-sends) from an earlier flow bails out.
+        this.partialGeneration = 0;
 
         // Seed the initial state from whatever the device has already reported.
         // If it hasn't reported yet, fall back to the persisted target, then to
@@ -114,28 +120,33 @@ class SimpleGarageDoorAccessory extends BaseAccessory {
             ? Characteristic.TargetDoorState.OPEN
             : Characteristic.TargetDoorState.CLOSED;
         this.accessory.context.cachedTargetDoorState = initialTarget;
+        // The level-triggered dispatch baseline (see setTargetDoorState). Held
+        // separately from cachedTargetDoorState because that one mirrors every
+        // reported value for HomeKit's benefit — including the transient "stopped"
+        // our own stop-before-close produces — which must not move this baseline.
+        this._committedTarget = initialTarget;
 
         this.characteristicTargetDoorState = service.getCharacteristic(Characteristic.TargetDoorState)
             .updateValue(initialTarget)
-            .onGet(() => this.accessory.context.cachedTargetDoorState)
+            .onGet(() => this._reportDoorState(this.accessory.context.cachedTargetDoorState))
             .onSet(value => this.setTargetDoorState(value));
 
         this.characteristicCurrentDoorState = service.getCharacteristic(Characteristic.CurrentDoorState)
             .updateValue(this.currentDoorState)
-            .onGet(() => this.currentDoorState);
+            .onGet(() => this._reportDoorState(this.currentDoorState));
 
         // The controller exposes limit switches (l_open/l_close) but they don't
         // work in practice, and there's no obstruction sensor wired up, so this
         // is always reported clear.
         service.getCharacteristic(Characteristic.ObstructionDetected)
             .updateValue(false)
-            .onGet(() => false);
+            .onGet(() => this._reportDoorState(false));
 
         const partialSwitch = this.accessory.getServiceById(Service.Switch, 'partialOpen');
         if (partialSwitch) {
             const onChar = partialSwitch.getCharacteristic(Characteristic.On)
                 .updateValue(isOpen)
-                .onGet(() => this.currentDoorState === Characteristic.CurrentDoorState.OPEN)
+                .onGet(() => this._reportDoorState(this.currentDoorState === Characteristic.CurrentDoorState.OPEN))
                 .onSet(value => {
                     // Stateful: the switch mirrors CurrentDoorState (ON while
                     // the gate is open in HomeKit's view — see
@@ -195,11 +206,24 @@ class SimpleGarageDoorAccessory extends BaseAccessory {
         // (=OPEN), which would fight the close we're about to send. Ignore
         // status reports until the close has gone out.
         if (this.pendingCloseTimer) return;
-        const isOpen = this._mapDpState(changes[this.dpState]);
+        const raw = typeof changes[this.dpState] === 'string' ? parseInt(changes[this.dpState], 10) : changes[this.dpState];
+        const isOpen = this._mapDpState(raw);
         if (isOpen === null) {
-            this.log.info(`[SimpleGarageDoor] ${this.device.context.name}: ignoring unknown state DP value ${JSON.stringify(changes[this.dpState])}`);
+            this.log.debug(`[SimpleGarageDoor] ${this.device.context.name}: ignoring unknown state DP value ${JSON.stringify(changes[this.dpState])}`);
             return;
         }
+        // Keep the level-triggered dispatch baseline honest with the gate's real
+        // position, but only from a DEFINITIVE report — 12 (opening/open) or 13
+        // (closing/closed). A bare 11 (stopped) is skipped: it is exactly what our
+        // own stop-before-close pulse makes the controller report, and over the LAN
+        // that report can land just after the stop→close window. Letting it flip
+        // the committed target back to OPEN is what let HomeKit's repeat close fire
+        // a second stop-before-close into the already-closing gate. A genuine
+        // external open always passes through 12 first, so nothing is missed.
+        if (raw === STATE_OPENING_OR_OPEN || raw === STATE_CLOSING_OR_CLOSED) {
+            const {Characteristic} = this.hap;
+            this._committedTarget = isOpen ? Characteristic.TargetDoorState.OPEN : Characteristic.TargetDoorState.CLOSED;
+        }
         this._applyReportedState(isOpen);
     }
 
@@ -227,13 +251,53 @@ class SimpleGarageDoorAccessory extends BaseAccessory {
         if (this.characteristicPartialOpen) {
             this.characteristicPartialOpen.updateValue(isOpen);
         }
+
+        // A partial open fires its open and then waits for the controller to
+        // confirm the gate is actually moving before starting the auto-stop
+        // countdown — see _handlePartialOpen.
+        if (this.partialPending && isOpen) this._armPartialStop();
+    }
+
+    // onGet helper: a cached/optimistic door value is fine to report while the
+    // gate is reachable, but when it's offline HomeKit must show "No Response"
+    // instead of a stale state that makes the gate look online and accept taps.
+    _reportDoorState(value) {
+        if (!this.device.connected) throw this._commError();
+        return value;
     }
 
     setTargetDoorState(value) {
+        // Surface "No Response" for a tap on an unreachable gate instead of
+        // silently dropping the command (the write helpers would otherwise just
+        // log and skip, leaving HomeKit to believe the open/close succeeded).
+        if (!this.device.connected) throw this._commError();
+
+        // The opener is level-triggered: act only when the requested target
+        // differs from the one we've already committed to. HomeKit re-sends the
+        // same target after a tap — a second controller echoing it, or its own
+        // retry a few seconds later — and acting on that repeat would fire another
+        // open/close. For a close that means a second stop-before-close into the
+        // already-closing gate, halting it mid-travel and restarting it (the
+        // reported stutter). A genuine request always flips the target (the Home
+        // app toggles to the opposite state). The committed target is reconciled
+        // with the gate's real position in _onDeviceChange so external operation
+        // still works — but only from a definitive report, never from the
+        // "stopped" transient our own stop produces, so the repeat stays caught.
+        if (value === this._committedTarget) {
+            this.log.debug(`[SimpleGarageDoor] ${this.device.context.name}: target unchanged — ignoring repeat request`);
+            return;
+        }
+
         // A direct open/close (the GarageDoorOpener target, a Force switch, or
         // the partial switch tapped OFF) is manual control: cancel any pending
-        // partial-open auto-stop so it can't halt this movement part-way.
+        // partial-open auto-stop so it can't halt this movement part-way. This
+        // must run only for a genuine target change, AFTER the repeat check
+        // above: a partial open drives the committed target to OPEN itself, so
+        // HomeKit's repeat of that OPEN re-enters here, and cancelling on that
+        // swallowed repeat would tear down the auto-stop the partial just armed —
+        // letting the gate run all the way open instead of parking part-way.
         this._cancelPartialStop();
+
         this._applyTarget(value);
     }
 
@@ -244,6 +308,7 @@ class SimpleGarageDoorAccessory extends BaseAccessory {
     _applyTarget(value) {
         const {Characteristic} = this.hap;
         const open = value === Characteristic.TargetDoorState.OPEN;
+        this._committedTarget = value;
         this.accessory.context.cachedTargetDoorState = value;
         if (this.characteristicTargetDoorState) this.characteristicTargetDoorState.updateValue(value);
         if (open) this._sendOpen();
@@ -254,8 +319,8 @@ class SimpleGarageDoorAccessory extends BaseAccessory {
     // own, even mid-close. Abandon any pending stop-before-close.
     _sendOpen() {
         this._cancelPendingClose();
-        this.log.info(`[SimpleGarageDoor] ${this.device.context.name}: open (dp${this.dpOpen})`);
-        this.setMultiStateLegacyAsync({[this.dpOpen]: true});
+        this.log.debug(`[SimpleGarageDoor] ${this.device.context.name}: open (dp${this.dpOpen})`);
+        this.setMultiStateLegacyInBackground({[this.dpOpen]: true});
     }
 
     // Close is ignored while the gate is actively moving, so fire it directly
@@ -266,20 +331,20 @@ class SimpleGarageDoorAccessory extends BaseAccessory {
         if (this.pendingCloseTimer) {
             // A stop-before-close is already running — don't restart it (and
             // push the close out) on a duplicate or retransmitted request.
-            this.log.info(`[SimpleGarageDoor] ${name}: close ignored — a stop-before-close is already running`);
+            this.log.debug(`[SimpleGarageDoor] ${name}: close ignored — a stop-before-close is already running`);
             return;
         }
         if (this._isStopped()) {
-            this.log.info(`[SimpleGarageDoor] ${name}: close (dp${this.dpClose}) — gate already stopped`);
-            this.setMultiStateLegacyAsync({[this.dpClose]: true});
+            this.log.debug(`[SimpleGarageDoor] ${name}: close (dp${this.dpClose}) — gate already stopped`);
+            this.setMultiStateLegacyInBackground({[this.dpClose]: true});
             return;
         }
-        this.log.info(`[SimpleGarageDoor] ${name}: stop-before-close — stop (dp${this.dpStop}) now, close (dp${this.dpClose}) in ${this.stopBeforeCloseMs}ms`);
-        this.setMultiStateLegacyAsync({[this.dpStop]: true});
+        this.log.debug(`[SimpleGarageDoor] ${name}: stop-before-close — stop (dp${this.dpStop}) now, close (dp${this.dpClose}) in ${this.stopBeforeCloseMs}ms`);
+        this.setMultiStateLegacyInBackground({[this.dpStop]: true});
         this.pendingCloseTimer = setTimeout(() => {
             this.pendingCloseTimer = null;
-            this.log.info(`[SimpleGarageDoor] ${name}: stop-before-close — firing close (dp${this.dpClose})`);
-            this.setMultiStateLegacyAsync({[this.dpClose]: true});
+            this.log.debug(`[SimpleGarageDoor] ${name}: stop-before-close — firing close (dp${this.dpClose})`);
+            this.setMultiStateLegacyInBackground({[this.dpClose]: true});
         }, this.stopBeforeCloseMs);
     }
 
@@ -298,32 +363,63 @@ class SimpleGarageDoorAccessory extends BaseAccessory {
         }
     }
 
-    // Partial open: fire the open action, then after partialOpenMs fire a stop
-    // so the gate ends up parked part-way. Anchored to the button press (the
-    // controller starts moving and reports state within ~1s), which is all the
-    // user asked for.
+    // Partial open: fire the open action, wait partialOpenMs, then fire a stop
+    // so the gate ends up parked part-way.
+    //
+    // The auto-stop is anchored to the controller *reporting the gate is moving*
+    // (the status DP flipping to OPEN), not to the button press: the open
+    // command takes time to reach the gate, and a stop fired before the gate is
+    // actually moving lands as a no-op the controller drops — letting the gate
+    // run all the way open. If the gate already reads open/opening, no fresh
+    // report is coming, so we arm straight away.
     _handlePartialOpen() {
         const {Characteristic} = this.hap;
         const name = this.device.context.name;
+        if (!this.device.connected) throw this._commError();
         if (!this.partialOpenMs) return;
-        if (this.partialStopTimer) {
-            // Re-entrant press while a partial is already armed (e.g. a
+        if (this.partialPending || this.partialStopTimer) {
+            // Re-entrant press while a partial is already in progress (e.g. a
             // HomeKit/iOS WRITE retransmit) — ignore so the stop isn't pushed
             // out, which would let the gate run further than intended.
-            this.log.info(`[SimpleGarageDoor] ${name}: partial press ignored — a partial open is already running`);
+            this.log.debug(`[SimpleGarageDoor] ${name}: partial press ignored — a partial open is already running`);
             return;
         }
 
-        this.log.info(`[SimpleGarageDoor] ${name}: partial open — opening, will stop in ${this.partialOpenMs}ms`);
+        this.log.debug(`[SimpleGarageDoor] ${name}: partial open — opening, will stop ${this.partialOpenMs}ms after the gate starts moving`);
+        this.partialGeneration++;
+        this.partialPending = true;
         this._applyTarget(Characteristic.TargetDoorState.OPEN);
+
+        const reported = this.device.state ? this.device.state[this.dpState] : undefined;
+        if (this._mapDpState(reported) === true) this._armPartialStop();
+    }
+
+    _armPartialStop() {
+        if (!this.partialPending || this.partialStopTimer) return;
+        this.partialPending = false;
+        const name = this.device.context.name;
+        const generation = this.partialGeneration;
         this.partialStopTimer = setTimeout(() => {
             this.partialStopTimer = null;
-            this.log.info(`[SimpleGarageDoor] ${name}: partial open — firing stop (dp${this.dpStop})`);
-            this.setMultiStateLegacyAsync({[this.dpStop]: true});
+            this.log.debug(`[SimpleGarageDoor] ${name}: partial open — firing stop (dp${this.dpStop})`);
+            this._sendPartialStop(generation, 1);
         }, this.partialOpenMs);
     }
 
+    // The controller occasionally drops a lone write (its command queue can
+    // coalesce back-to-back writes, and brief Wi-Fi blips lose individual
+    // packets), and a dropped stop here is exactly what lets a partial open run
+    // all the way. Re-send it a few times; a stop on an already-parked gate is a
+    // harmless no-op. Bails out if the flow was superseded mid-way.
+    _sendPartialStop(generation, attempt) {
+        if (generation !== this.partialGeneration) return;
+        this.setMultiStateLegacyInBackground({[this.dpStop]: true});
+        if (attempt < 3) setTimeout(() => this._sendPartialStop(generation, attempt + 1), 300);
+    }
+
     _cancelPartialStop() {
+        this.partialPending = false;
+        this.partialGeneration++;
         if (this.partialStopTimer) {
             clearTimeout(this.partialStopTimer);
             this.partialStopTimer = null;

package/lib/SimpleHeaterAccessory.js

@@ -45,7 +45,7 @@ class SimpleHeaterAccessory extends BaseAccessory {
 
         const characteristicCurrentHeaterCoolerState = service.getCharacteristic(Characteristic.CurrentHeaterCoolerState)
             .updateValue(this._getCurrentHeaterCoolerState(dps))
-            .onGet(() => this.currentHeaterCoolerState);
+            .onGet(() => { if (!this.device.connected) throw this._commError(); return this.currentHeaterCoolerState; });
 
         service.getCharacteristic(Characteristic.TargetHeaterCoolerState)
             .setProps({
@@ -54,7 +54,7 @@ class SimpleHeaterAccessory extends BaseAccessory {
                 validValues: [Characteristic.TargetHeaterCoolerState.HEAT]
             })
             .updateValue(this._getTargetHeaterCoolerState())
-            .onGet(() => this._getTargetHeaterCoolerState())
+            .onGet(() => { if (!this.device.connected) throw this._commError(); return this._getTargetHeaterCoolerState(); })
             .onSet(() => this.setStateAsync(this.dpActive, true));
 
         const characteristicCurrentTemperature = service.getCharacteristic(Characteristic.CurrentTemperature)
@@ -90,7 +90,7 @@ class SimpleHeaterAccessory extends BaseAccessory {
                 characteristicCurrentTemperature.updateValue(this._getDividedState(changes[this.dpCurrentTemperature], this.temperatureDivisor, this.currentTemperatureOffset));
 
             characteristicCurrentHeaterCoolerState.updateValue(this._getCurrentHeaterCoolerState(state));
-            this.log.info('SimpleHeater changed: ' + JSON.stringify(state));
+            this.log.debug('SimpleHeater changed: ' + JSON.stringify(state));
         });
     }
 
@@ -147,7 +147,7 @@ class SimpleHeaterAccessory extends BaseAccessory {
 
     _getCurrentTempAsync() {
         const data = this.getStateAsync(this.dpCurrentTemperature);
-        if (!isFinite(data)) throw new Error('Invalid state');
+        if (!isFinite(data)) throw this._commError();
         return this._getDividedState(data, this.temperatureDivisor, this.currentTemperatureOffset);
     }
 }

package/lib/SimpleLightAccessory.js

@@ -31,7 +31,7 @@ class SimpleLightAccessory extends BaseAccessory {
 
         this.device.on('change', (changes, state) => {
             if (changes.hasOwnProperty(this.dpPower) && characteristicOn.value !== changes[this.dpPower]) characteristicOn.updateValue(changes[this.dpPower]);
-            this.log.info('SimpleLight changed: ' + JSON.stringify(state));
+            this.log.debug('SimpleLight changed: ' + JSON.stringify(state));
         });
     }
 }

package/lib/SwitchAccessory.js

@@ -34,7 +34,7 @@ class SwitchAccessory extends BaseAccessory {
         this.accessory.services
             .filter(service => service.UUID === Service.Switch.UUID && !_validServices.includes(service))
             .forEach(service => {
-                this.log.info('Removing', service.displayName);
+                this.log.debug('Removing', service.displayName);
                 this.accessory.removeService(service);
             });
     }
@@ -69,6 +69,7 @@ class SwitchAccessory extends BaseAccessory {
     }
 
     setPower(dp, value) {
+        if (!this.device.connected) throw this._commError();
         if (!this._pendingPower) {
             this._pendingPower = {props: {}, resolvers: []};
         }
@@ -82,7 +83,7 @@ class SwitchAccessory extends BaseAccessory {
             this._pendingPower.timer = setTimeout(() => {
                 const {props, resolvers} = this._pendingPower;
                 this._pendingPower = null;
-                this.setMultiStateAsync(props);
+                this.setMultiStateInBackground(props);
                 resolvers.forEach(r => r());
             }, 500);
         });

package/lib/TWLightAccessory.js

@@ -72,7 +72,7 @@ class TWLightAccessory extends BaseAccessory {
     }
 
     getBrightness() {
-        return this.convertBrightnessFromTuyaToHomeKit(this.device.state[this.dpBrightness]);
+        return this.convertBrightnessFromTuyaToHomeKit(this.getStateAsync(this.dpBrightness));
     }
 
     setBrightness(value) {
@@ -80,7 +80,7 @@ class TWLightAccessory extends BaseAccessory {
     }
 
     getColorTemperature() {
-        return this.convertColorTemperatureFromTuyaToHomeKit(this.device.state[this.dpColorTemperature]);
+        return this.convertColorTemperatureFromTuyaToHomeKit(this.getStateAsync(this.dpColorTemperature));
     }
 
     setColorTemperature(value) {