homebridge-tuya-plus 3.11.0 → 3.11.1-beta.2

package/config.schema.json

@@ -518,6 +518,14 @@
                 "functionBody": "return model.devices && model.devices[arrayIndices] && ['SimpleGarageDoor'].includes(model.devices[arrayIndices].type);"
               }
             },
+            "commandDelay": {
+              "type": "integer",
+              "placeholder": "2000",
+              "description": "Milliseconds to wait between the stop command and the open/close command. Increase if your controller drops the direction command after a stop.",
+              "condition": {
+                "functionBody": "return model.devices && model.devices[arrayIndices] && ['SimpleGarageDoor'].includes(model.devices[arrayIndices].type);"
+              }
+            },
             "flipState": {
               "type": "boolean",
               "condition": {

package/lib/SimpleGarageDoorAccessory.js

@@ -1,10 +1,17 @@
 const BaseAccessory = require('./BaseAccessory');
 
-// Window during which CurrentDoorState lags TargetDoorState so HomeKit's
-// "Opening..."/"Closing..." caption is visible after a toggle. The device
-// has no position feedback, so this is purely cosmetic.
+// Delay between the stop command and the open/close command. Some controllers
+// drop the direction command when it arrives while they are still processing
+// the stop, so we wait this long before sending the direction.
+const DEFAULT_COMMAND_DELAY_MS = 2000;
+
+// Delay between the direction command and flipping CurrentDoorState. The
+// device has no position feedback so this is purely cosmetic — it keeps
+// HomeKit's "Opening..."/"Closing..." caption visible for at least this long.
 const CURRENT_STATE_DELAY_MS = 1000;
 
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+
 class SimpleGarageDoorAccessory extends BaseAccessory {
     static getCategory(Categories) {
         return Categories.GARAGE_DOOR_OPENER;
@@ -31,6 +38,11 @@ class SimpleGarageDoorAccessory extends BaseAccessory {
         this.dpStop = this._getCustomDP(this.device.context.dpStop) || '2';
         this.dpClose = this._getCustomDP(this.device.context.dpClose) || '3';
 
+        const configuredDelay = parseInt(this.device.context.commandDelay, 10);
+        this.commandDelayMs = Number.isFinite(configuredDelay) && configuredDelay >= 0
+            ? configuredDelay
+            : DEFAULT_COMMAND_DELAY_MS;
+
         // The device only exposes momentary action DPs, so the target state is
         // tracked locally and persisted via the homebridge accessory context.
         if (this.accessory.context.cachedTargetDoorState !== Characteristic.TargetDoorState.OPEN &&
@@ -42,6 +54,10 @@ class SimpleGarageDoorAccessory extends BaseAccessory {
             ? Characteristic.CurrentDoorState.OPEN
             : Characteristic.CurrentDoorState.CLOSED;
 
+        // Each setTargetDoorState invocation bumps this token; an older
+        // in-flight chain bails out at its next await when the token changes.
+        this.opToken = 0;
+
         this.characteristicTargetDoorState = service.getCharacteristic(Characteristic.TargetDoorState)
             .updateValue(initialTarget)
             .onGet(() => this.accessory.context.cachedTargetDoorState)
@@ -56,28 +72,43 @@ class SimpleGarageDoorAccessory extends BaseAccessory {
             .onGet(() => false);
     }
 
-    setTargetDoorState(value) {
+    // Wraps the synchronous Tuya write so the caller can await it. The Tuya
+    // transport is fire-and-forget at the JS level — the data has been handed
+    // to the kernel by the time setMultiStateLegacyAsync returns — but using
+    // an awaited call keeps the command sequence in one readable async chain.
+    async _sendDps(dps) {
+        this.setMultiStateLegacyAsync(dps);
+    }
+
+    async setTargetDoorState(value) {
         const {Characteristic} = this.hap;
 
         this.accessory.context.cachedTargetDoorState = value;
 
+        const opToken = ++this.opToken;
+
         // Send stop first so reversing direction mid-motion works; if the gate
         // is already idle, the stop is a no-op on the device side.
-        this.setMultiStateLegacyAsync({[this.dpStop]: true});
+        await this._sendDps({[this.dpStop]: true});
+        if (opToken !== this.opToken) return;
+
+        await sleep(this.commandDelayMs);
+        if (opToken !== this.opToken) return;
+
         if (value === Characteristic.TargetDoorState.OPEN) {
-            this.setMultiStateLegacyAsync({[this.dpOpen]: true});
+            await this._sendDps({[this.dpOpen]: true});
         } else {
-            this.setMultiStateLegacyAsync({[this.dpClose]: true});
+            await this._sendDps({[this.dpClose]: true});
         }
+        if (opToken !== this.opToken) return;
+
+        await sleep(CURRENT_STATE_DELAY_MS);
+        if (opToken !== this.opToken) return;
 
-        if (this.currentStateTimeout) clearTimeout(this.currentStateTimeout);
-        this.currentStateTimeout = setTimeout(() => {
-            this.currentStateTimeout = null;
-            this.currentDoorState = value === Characteristic.TargetDoorState.OPEN
-                ? Characteristic.CurrentDoorState.OPEN
-                : Characteristic.CurrentDoorState.CLOSED;
-            this.characteristicCurrentDoorState.updateValue(this.currentDoorState);
-        }, CURRENT_STATE_DELAY_MS);
+        this.currentDoorState = value === Characteristic.TargetDoorState.OPEN
+            ? Characteristic.CurrentDoorState.OPEN
+            : Characteristic.CurrentDoorState.CLOSED;
+        this.characteristicCurrentDoorState.updateValue(this.currentDoorState);
     }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "homebridge-tuya-plus",
-  "version": "3.11.0",
+  "version": "3.11.1-beta.2",
   "description": "A community-maintained Homebridge plugin for controlling Tuya devices locally over LAN. Includes new features, fixes, and updated device support.",
   "main": "index.js",
   "scripts": {

package/test/SimpleGarageDoorAccessory.test.js

@@ -5,6 +5,10 @@ const { HAP, makeInstance } = require('./support/mocks');
 
 const { CurrentDoorState: CDS, TargetDoorState: TDS } = HAP.Characteristic;
 
+const DEFAULT_COMMAND_DELAY_MS = 500;
+const CURRENT_STATE_DELAY_MS = 1000;
+const TOTAL_DELAY_MS = DEFAULT_COMMAND_DELAY_MS + CURRENT_STATE_DELAY_MS;
+
 function makeSimpleGarage(contextOverrides = {}) {
     const { instance, device, accessory, platform } = makeInstance(
         SimpleGarageDoorAccessory,
@@ -16,6 +20,8 @@ function makeSimpleGarage(contextOverrides = {}) {
     instance.dpOpen = '1';
     instance.dpStop = '2';
     instance.dpClose = '3';
+    instance.commandDelayMs = DEFAULT_COMMAND_DELAY_MS;
+    instance.opToken = 0;
     instance.currentDoorState = CDS.OPEN;
     instance.characteristicCurrentDoorState = {
         value: CDS.OPEN,
@@ -29,35 +35,108 @@ function makeSimpleGarage(contextOverrides = {}) {
 // setTargetDoorState — device commands
 // ---------------------------------------------------------------------------
 describe('SimpleGarageDoorAccessory.setTargetDoorState — device commands', () => {
-    test('OPEN sends stop=true then open=true', () => {
+    beforeEach(() => jest.useFakeTimers());
+    afterEach(() => jest.useRealTimers());
+
+    test('OPEN sends stop=true, then open=true after commandDelay', async () => {
         const { instance, device } = makeSimpleGarage();
-        instance.setTargetDoorState(TDS.OPEN);
+        const op = instance.setTargetDoorState(TDS.OPEN);
+
+        await jest.advanceTimersByTimeAsync(0);
+        expect(device.update).toHaveBeenCalledTimes(1);
         expect(device.update).toHaveBeenNthCalledWith(1, { '2': true });
+
+        await jest.advanceTimersByTimeAsync(DEFAULT_COMMAND_DELAY_MS - 1);
+        expect(device.update).toHaveBeenCalledTimes(1);
+
+        await jest.advanceTimersByTimeAsync(1);
+        expect(device.update).toHaveBeenCalledTimes(2);
         expect(device.update).toHaveBeenNthCalledWith(2, { '1': true });
+
+        await jest.advanceTimersByTimeAsync(CURRENT_STATE_DELAY_MS);
+        await op;
     });
 
-    test('CLOSED sends stop=true then close=true', () => {
+    test('CLOSED sends stop=true, then close=true after commandDelay', async () => {
         const { instance, device } = makeSimpleGarage();
-        instance.setTargetDoorState(TDS.CLOSED);
+        const op = instance.setTargetDoorState(TDS.CLOSED);
+
+        await jest.advanceTimersByTimeAsync(0);
         expect(device.update).toHaveBeenNthCalledWith(1, { '2': true });
+
+        await jest.advanceTimersByTimeAsync(DEFAULT_COMMAND_DELAY_MS);
         expect(device.update).toHaveBeenNthCalledWith(2, { '3': true });
-    });
 
-    test('Skips writes when the device is disconnected', () => {
-        const { instance, device } = makeSimpleGarage();
-        device.connected = false;
-        instance.setTargetDoorState(TDS.OPEN);
-        expect(device.update).not.toHaveBeenCalled();
+        await jest.advanceTimersByTimeAsync(CURRENT_STATE_DELAY_MS);
+        await op;
     });
 
-    test('Custom DPs are respected', () => {
+    test('Custom DPs are respected', async () => {
         const { instance, device } = makeSimpleGarage();
         instance.dpOpen = '101';
         instance.dpStop = '102';
         instance.dpClose = '103';
-        instance.setTargetDoorState(TDS.OPEN);
+        const op = instance.setTargetDoorState(TDS.OPEN);
+
+        await jest.advanceTimersByTimeAsync(0);
         expect(device.update).toHaveBeenNthCalledWith(1, { '102': true });
+
+        await jest.advanceTimersByTimeAsync(DEFAULT_COMMAND_DELAY_MS);
         expect(device.update).toHaveBeenNthCalledWith(2, { '101': true });
+
+        await jest.advanceTimersByTimeAsync(CURRENT_STATE_DELAY_MS);
+        await op;
+    });
+
+    test('Skips writes when the device is disconnected', async () => {
+        const { instance, device } = makeSimpleGarage();
+        device.connected = false;
+        const op = instance.setTargetDoorState(TDS.OPEN);
+        await jest.advanceTimersByTimeAsync(TOTAL_DELAY_MS);
+        await op;
+        expect(device.update).not.toHaveBeenCalled();
+    });
+
+    test('Configured commandDelay is used between stop and direction', async () => {
+        const { instance, device } = makeSimpleGarage();
+        instance.commandDelayMs = 5000;
+        const op = instance.setTargetDoorState(TDS.OPEN);
+
+        await jest.advanceTimersByTimeAsync(0);
+        expect(device.update).toHaveBeenCalledTimes(1);
+
+        await jest.advanceTimersByTimeAsync(4999);
+        expect(device.update).toHaveBeenCalledTimes(1);
+
+        await jest.advanceTimersByTimeAsync(1);
+        expect(device.update).toHaveBeenCalledTimes(2);
+        expect(device.update).toHaveBeenNthCalledWith(2, { '1': true });
+
+        await jest.advanceTimersByTimeAsync(CURRENT_STATE_DELAY_MS);
+        await op;
+    });
+
+    test('Reversing during the stop->direction window cancels the pending direction command', async () => {
+        const { instance, device } = makeSimpleGarage();
+        const op1 = instance.setTargetDoorState(TDS.OPEN);
+        await jest.advanceTimersByTimeAsync(0);
+        expect(device.update).toHaveBeenNthCalledWith(1, { '2': true });
+
+        await jest.advanceTimersByTimeAsync(500);
+        const op2 = instance.setTargetDoorState(TDS.CLOSED);
+        await jest.advanceTimersByTimeAsync(0);
+
+        // A second stop is sent, but the originally-pending open must not fire.
+        expect(device.update).toHaveBeenCalledTimes(2);
+        expect(device.update).toHaveBeenNthCalledWith(2, { '2': true });
+
+        await jest.advanceTimersByTimeAsync(DEFAULT_COMMAND_DELAY_MS);
+        expect(device.update).toHaveBeenCalledTimes(3);
+        expect(device.update).toHaveBeenNthCalledWith(3, { '3': true });
+
+        await jest.advanceTimersByTimeAsync(CURRENT_STATE_DELAY_MS);
+        await op1;
+        await op2;
     });
 });
 
@@ -68,48 +147,51 @@ describe('SimpleGarageDoorAccessory.setTargetDoorState — CurrentDoorState tran
     beforeEach(() => jest.useFakeTimers());
     afterEach(() => jest.useRealTimers());
 
-    test('CurrentDoorState lags the target by 1s when opening', () => {
+    test('CurrentDoorState updates to OPEN after commandDelay + currentStateDelay', async () => {
         const { instance } = makeSimpleGarage();
         instance.currentDoorState = CDS.CLOSED;
         instance.characteristicCurrentDoorState.value = CDS.CLOSED;
 
-        instance.setTargetDoorState(TDS.OPEN);
+        const op = instance.setTargetDoorState(TDS.OPEN);
+        await jest.advanceTimersByTimeAsync(0);
         expect(instance.characteristicCurrentDoorState.value).toBe(CDS.CLOSED);
 
-        jest.advanceTimersByTime(999);
+        await jest.advanceTimersByTimeAsync(TOTAL_DELAY_MS - 1);
         expect(instance.characteristicCurrentDoorState.value).toBe(CDS.CLOSED);
 
-        jest.advanceTimersByTime(1);
+        await jest.advanceTimersByTimeAsync(1);
+        await op;
         expect(instance.currentDoorState).toBe(CDS.OPEN);
         expect(instance.characteristicCurrentDoorState.value).toBe(CDS.OPEN);
     });
 
-    test('CurrentDoorState lags the target by 1s when closing', () => {
+    test('CurrentDoorState updates to CLOSED after commandDelay + currentStateDelay', async () => {
         const { instance } = makeSimpleGarage();
         instance.currentDoorState = CDS.OPEN;
         instance.characteristicCurrentDoorState.value = CDS.OPEN;
 
-        instance.setTargetDoorState(TDS.CLOSED);
-        expect(instance.characteristicCurrentDoorState.value).toBe(CDS.OPEN);
-
-        jest.advanceTimersByTime(1000);
+        const op = instance.setTargetDoorState(TDS.CLOSED);
+        await jest.advanceTimersByTimeAsync(TOTAL_DELAY_MS);
+        await op;
         expect(instance.currentDoorState).toBe(CDS.CLOSED);
         expect(instance.characteristicCurrentDoorState.value).toBe(CDS.CLOSED);
     });
 
-    test('Reversing direction within the 1s window resets the timer', () => {
+    test('Reversing direction mid-transition cancels the stale CurrentDoorState update', async () => {
         const { instance } = makeSimpleGarage();
         instance.currentDoorState = CDS.OPEN;
         instance.characteristicCurrentDoorState.value = CDS.OPEN;
 
-        instance.setTargetDoorState(TDS.CLOSED);
-        jest.advanceTimersByTime(500);
-        instance.setTargetDoorState(TDS.OPEN);
+        const op1 = instance.setTargetDoorState(TDS.CLOSED);
+        await jest.advanceTimersByTimeAsync(DEFAULT_COMMAND_DELAY_MS + 500);
+        const op2 = instance.setTargetDoorState(TDS.OPEN);
 
-        jest.advanceTimersByTime(500);
+        await jest.advanceTimersByTimeAsync(500);
         expect(instance.characteristicCurrentDoorState.value).toBe(CDS.OPEN);
 
-        jest.advanceTimersByTime(500);
+        await jest.advanceTimersByTimeAsync(TOTAL_DELAY_MS);
+        await op1;
+        await op2;
         expect(instance.currentDoorState).toBe(CDS.OPEN);
         expect(instance.characteristicCurrentDoorState.value).toBe(CDS.OPEN);
     });
@@ -119,11 +201,18 @@ describe('SimpleGarageDoorAccessory.setTargetDoorState — CurrentDoorState tran
 // Persistence
 // ---------------------------------------------------------------------------
 describe('SimpleGarageDoorAccessory persistence', () => {
-    test('Stores the latest target on the accessory context', () => {
+    beforeEach(() => jest.useFakeTimers());
+    afterEach(() => jest.useRealTimers());
+
+    test('Stores the latest target on the accessory context', async () => {
         const { instance, accessory } = makeSimpleGarage();
-        instance.setTargetDoorState(TDS.CLOSED);
+        const op1 = instance.setTargetDoorState(TDS.CLOSED);
         expect(accessory.context.cachedTargetDoorState).toBe(TDS.CLOSED);
-        instance.setTargetDoorState(TDS.OPEN);
+        const op2 = instance.setTargetDoorState(TDS.OPEN);
         expect(accessory.context.cachedTargetDoorState).toBe(TDS.OPEN);
+
+        await jest.advanceTimersByTimeAsync(TOTAL_DELAY_MS);
+        await op1;
+        await op2;
     });
 });

package/wiki/Supported-Device-Types.md

@@ -18,6 +18,7 @@ If you are looking for verified configurations for your specific device, please
 |Simple Dimmer|`SimpleDimmer`<sup>[8](#simple-dimmers)</sup>|Dimmer switches with power control <small>([instructions](#simple-dimmers))</small>|
 |Simple Heater|`SimpleHeater`<sup>[9](#simple-heaters)</sup>|Heating solutions with only temperature control <small>([instructions](#simple-heaters))</small>|
 |Garage Door|`GarageDoor`<sup>[10](#garage-doors)</sup>|Smart garage doors or garage door openers <small>([instructions](#garage-doors))</small>|
+|Simple Garage Door|`SimpleGarageDoor`<sup>[10](#simple-garage-doors)</sup>|Garage doors and sliding gate openers that expose only three momentary action DPs: open, stop, close <small>([instructions](#simple-garage-doors))</small>|
 |Simple Blinds|`SimpleBlinds`<sup>[11](#simple-blinds)</sup>|Smart blinds and smart switches that control blinds <small>([instructions](#simple-blinds))</small>|
 |Simple Blinds2|`SimpleBlinds2`<sup>[11](#simple-blinds)</sup>|Smart blinds and smart switches that control blinds(Use if simple Blinds (1) doesn't work for you. <small>([instructions](#simple-blinds))</small>|
 |Vertical Blinds with Tilt|`VerticalBlindsWithTilt`<sup>[11](#vertical-blinds-with-tilt)</sup>|Smart vertical blinds with open/close and panel rotation <small>([instructions](#vertical-blinds-with-tilt))</small>|
@@ -402,6 +403,38 @@ While still in early testing, you can use this to open and close the garage door
 }
 ```
 
+### Simple Garage Doors
+For very basic garage door openers and sliding gate controllers that expose only three momentary action DPs — one to open, one to stop, one to close — with no position or status feedback. The plugin tracks the target state locally and persists it across restarts, so HomeKit always reflects whatever was last requested. Triggering a change sends the stop command first (so reversing direction mid-motion works; it is a no-op when the gate is idle), waits `commandDelay` milliseconds, and then sends the open or close command. There is no obstruction detection.
+
+If your controller stops the gate but does not start moving in the requested direction afterwards, increase `commandDelay` — some devices drop the direction command if it arrives too soon after the stop.
+
+```json5
+{
+    "name": "My Sliding Gate",
+    "type": "SimpleGarageDoor",
+    "manufacturer": "Generic",
+    "model": "Generic Sliding Gate Controller",
+    "id": "032000123456789abcde",
+    "key": "0123456789abcdef",
+
+    /* Additional parameters to override defaults only if needed */
+
+    /* Override the default datapoint identifier for the open action */
+    "dpOpen": 1,
+
+    /* Override the default datapoint identifier for the stop action */
+    "dpStop": 2,
+
+    /* Override the default datapoint identifier for the close action */
+    "dpClose": 3,
+
+    /* Milliseconds to wait between the stop and the open/close command.
+       Default is 2000. Raise it if your controller ignores the direction
+       command when it arrives too quickly after the stop. */
+    "commandDelay": 2000
+}
+```
+
 ### Simple Blinds
 Normally the blinds don't report their position. This plugin attempts to time the movements to guesstimate the positions. You can adjust a few parameters to make it really close for you.