homebridge-tuya-plus 4.0.0 → 4.1.0-dev.64

package/Changelog.md

@@ -4,6 +4,7 @@ All notable changes to this project will be documented in this file. This projec
 
 ## Unreleased
 
+* [+] **Garage door: support DASPI "Passage" openers.** Set `"manufacturer": "Daspi"` on a `GarageDoor` device to select its data-points (`dpAction` `1`, `dpStatus` `7`, still overridable). DASPI reports state as strings on DP `7` (`full_opened`/`opening`/`open_softstop`/`full_closed`/`closing`/`close_softstop`) and takes capitalized `Open`/`Close` commands on DP `1`; the soft-stop phases map to HomeKit's Opening/Closing so the tile animates correctly mid-travel.
 * [+] **Tuya Cloud is now a transparent, global fallback for every device.** What started as an experiment to reach battery-powered "sleepy" irrigation timers (which never appear on the LAN) is now a general, optional fallback: add a top-level `cloud` credentials block once and the plugin keeps a single Tuya Cloud/MQTT session alive in the background, falling back to it whenever a device can't be reached on the LAN — a flaky moment, or hardware that's never local. The plugin stays **LAN-first** (local is always tried first and preferred) and cloud remains **strictly opt-in** (nothing runs unless credentials are present).
   * **No per-device configuration.** There is one global session and no per-device cloud settings. Every device automatically uses the LAN first and the cloud as a fallback; a device with no local `key` is reached over the cloud only. Existing LAN configs (numeric data-points) keep working over the cloud — the data-point id↔code map is learned from Tuya's device shadow (`/v2.0/cloud/thing/{id}/shadow/properties`) — and if both transports fail, HomeKit shows "No Response" as before. This mirrors the official Tuya/Smart Life app (LAN when possible, cloud as a backup).
   * Realtime updates arrive over Tuya's **MQTT** message service (via the optional `mqtt` dependency, installed automatically); initial state and control use the Tuya OpenAPI. There is no polling.

package/config.schema.json

@@ -538,6 +538,23 @@
                 "functionBody": "return model.devices && model.devices[arrayIndices] && ['Fan', 'FanLight'].includes(model.devices[arrayIndices].type);"
               }
             },
+            "dpSwing": {
+              "title": "Swing/oscillation DP",
+              "description": "Data point of the fan's oscillation switch (a boolean DP). When set, a Swing (oscillation) control is shown in the Home app. Leave empty if the fan has no oscillation.",
+              "type": "integer",
+              "condition": {
+                "functionBody": "return model.devices && model.devices[arrayIndices] && ['Fan'].includes(model.devices[arrayIndices].type);"
+              }
+            },
+            "noDirection": {
+              "title": "Hide the rotation direction control",
+              "description": "Enable if the fan has no forward/reverse direction, or if the direction data point is actually a mode enum. Prevents writing forward/reverse into that data point.",
+              "type": "boolean",
+              "placeholder": false,
+              "condition": {
+                "functionBody": "return model.devices && model.devices[arrayIndices] && ['Fan'].includes(model.devices[arrayIndices].type);"
+              }
+            },
             "maxSpeed": {
               "type": "integer",
               "placeholder": "3",

package/lib/GarageDoorAccessory.js

@@ -12,8 +12,16 @@ const GARAGE_DOOR_OPENNING = 'openning';
 const GARAGE_DOOR_OPENING = 'opening';
 const GARAGE_DOOR_CLOSING = 'closing';
 
+// For Daspi garage door
+const GARAGE_DOOR_FULL_OPENED = 'full_opened';
+const GARAGE_DOOR_FULL_CLOSED = 'full_closed';
+const GARAGE_DOOR_OPEN_SOFTSTOP = 'open_softstop';
+const GARAGE_DOOR_CLOSE_SOFTSTOP = 'close_softstop';
+// Daspi garage door appears to have no stopped status
+
 const GARAGE_DOOR_MANUFACTURER_KOGAN = 'Kogan';
 const GARAGE_DOOR_MANUFACTURER_WOFEA = 'Wofea';
+const GARAGE_DOOR_MANUFACTURER_DASPI = 'Daspi';
 
 class GarageDoorAccessory extends BaseAccessory {
     static getCategory(Categories) {
@@ -50,6 +58,10 @@ class GarageDoorAccessory extends BaseAccessory {
         return this.manufacturer === GARAGE_DOOR_MANUFACTURER_WOFEA.trim();
     }
 
+    _isDaspi() {
+        return this.manufacturer === GARAGE_DOOR_MANUFACTURER_DASPI.trim();
+    }
+
     _registerCharacteristics(dps) {
         const {Service, Characteristic} = this.hap;
         const service = this.accessory.getService(Service.GarageDoorOpener);
@@ -59,6 +71,8 @@ class GarageDoorAccessory extends BaseAccessory {
             this.manufacturer = GARAGE_DOOR_MANUFACTURER_KOGAN.trim();
         } else if (this.device.context.manufacturer.trim().toLowerCase() === GARAGE_DOOR_MANUFACTURER_WOFEA.trim().toLowerCase()) {
             this.manufacturer = this.device.context.manufacturer.trim();
+        } else if (this.device.context.manufacturer.trim().toLowerCase() === GARAGE_DOOR_MANUFACTURER_DASPI.trim().toLowerCase()) {
+            this.manufacturer = GARAGE_DOOR_MANUFACTURER_DASPI.trim();
         } else if (this.device.context.manufacturer) {
             this.manufacturer = this.device.context.manufacturer.trim();
         } else {
@@ -73,6 +87,10 @@ class GarageDoorAccessory extends BaseAccessory {
             this._debugLog('_registerCharacteristics setting dpAction and dpStatus for ' + GARAGE_DOOR_MANUFACTURER_WOFEA + ' garage door');
             this.dpAction = this._getCustomDP(this.device.context.dpAction) || '1';
             this.dpStatus = this._getCustomDP(this.device.context.dpStatus) || '101';
+        } else if (this._isDaspi()) {
+            this._debugLog('_registerCharacteristics setting dpAction and dpStatus for ' + GARAGE_DOOR_MANUFACTURER_DASPI + ' garage door');
+            this.dpAction = this._getCustomDP(this.device.context.dpAction) || '1';
+            this.dpStatus = this._getCustomDP(this.device.context.dpStatus) || '7';
         } else {
             this._debugLog('_registerCharacteristics setting dpAction and dpStatus for generic door');
             this.dpAction = this._getCustomDP(this.device.context.dpAction) || '1';
@@ -143,6 +161,23 @@ class GarageDoorAccessory extends BaseAccessory {
                 case GARAGE_DOOR_CLOSING:
                     return this.targetClosed;
 
+                default:
+                    this._alwaysLog('_getTargetDoorState UNKNOWN STATE ' + JSON.stringify(dp));
+            }
+        } else if (this._isDaspi()) {
+            switch (dp.toLowerCase()) {
+                case GARAGE_DOOR_OPEN:
+                case GARAGE_DOOR_OPENING:
+                case GARAGE_DOOR_OPEN_SOFTSTOP:
+                case GARAGE_DOOR_FULL_OPENED:
+                    return this.targetOpen;
+
+                case GARAGE_DOOR_CLOSE:
+                case GARAGE_DOOR_CLOSING:
+                case GARAGE_DOOR_CLOSE_SOFTSTOP:
+                case GARAGE_DOOR_FULL_CLOSED:
+                    return this.targetClosed;
+
                 default:
                     this._alwaysLog('_getTargetDoorState UNKNOWN STATE ' + JSON.stringify(dp));
             }
@@ -161,13 +196,14 @@ class GarageDoorAccessory extends BaseAccessory {
         this._debugLog('setTargetDoorState value ' + value + ' targetOpen ' + this.targetOpen + ' targetClosed ' + this.targetClosed);
         let newValue = GARAGE_DOOR_CLOSE;
 
-        if (this._isKogan()) {
+        if (this._isKogan() || this._isDaspi()) {
+            // Daspi expects capitalized command strings ('Open'/'Close'); Kogan uses lowercase.
             switch (value) {
                 case this.targetOpen:
-                    newValue = GARAGE_DOOR_OPEN;
+                    newValue = this._isDaspi() ? 'Open' : GARAGE_DOOR_OPEN;
                     break;
                 case this.targetClosed:
-                    newValue = GARAGE_DOOR_CLOSE;
+                    newValue = this._isDaspi() ? 'Close' : GARAGE_DOOR_CLOSE;
                     break;
                 default:
                     this._alwaysLog('setTargetDoorState UNKNOWN STATE ' + JSON.stringify(value));
@@ -210,6 +246,25 @@ class GarageDoorAccessory extends BaseAccessory {
                 default:
                     this._alwaysLog('_getCurrentDoorState UNKNOWN STATUS ' + JSON.stringify(dpStatusValue));
             }
+        } else if (this._isDaspi()) {
+            switch (dpStatusValue.toLowerCase()) {
+                case GARAGE_DOOR_FULL_OPENED:
+                    return this.currentOpen;
+
+                case GARAGE_DOOR_OPEN_SOFTSTOP:
+                case GARAGE_DOOR_OPENING:
+                    return this.currentOpening;
+
+                case GARAGE_DOOR_CLOSE_SOFTSTOP:
+                case GARAGE_DOOR_CLOSING:
+                    return this.currentClosing;
+
+                case GARAGE_DOOR_FULL_CLOSED:
+                    return this.currentClosed;
+
+                default:
+                    this._alwaysLog('_getCurrentDoorState UNKNOWN STATUS ' + JSON.stringify(dpStatusValue));
+            }
         } else {
             if (dpStatusValue === true) {
                 return this.currentOpen;

package/lib/SimpleFanAccessory.js

@@ -22,6 +22,13 @@ class SimpleFanAccessory extends BaseAccessory {
         this.dpFanOn = this._getCustomDP(this.device.context.dpFanOn) || '1';
         this.dpRotationSpeed = this._getCustomDP(this.device.context.dpRotationSpeed) || '3';
         this.dpFanDirection = this._getCustomDP(this.device.context.dpFanDirection) || '2';
+        // Oscillation is opt-in: SwingMode is only exposed when the fan's boolean
+        // swing DP is configured, so existing setups are unchanged (issue #96).
+        this.dpSwing = this._getCustomDP(this.device.context.dpSwing);
+        // Some fans use DP 2 for a mode enum (nature/sleep/…) rather than a
+        // rotation direction; RotationDirection would then write forward/reverse
+        // into that enum. noDirection drops the characteristic for those fans.
+        this.noDirection = this._coerceBoolean(this.device.context.noDirection, false);
 
         this.maxSpeed = parseInt(this.device.context.maxSpeed) || 3;
         this.fanDefaultSpeed = parseInt(this.device.context.fanDefaultSpeed) || 1;
@@ -44,10 +51,21 @@ class SimpleFanAccessory extends BaseAccessory {
             .onGet(() => this.getSpeed())
             .onSet(value => this.setSpeed(value));
 
-        const characteristicFanDirection = serviceFan.getCharacteristic(Characteristic.RotationDirection)
-            .updateValue(this._getFanDirection(dps[this.dpFanDirection]))
-            .onGet(() => this.getFanDirection())
-            .onSet(value => this.setFanDirection(value));
+        let characteristicFanDirection;
+        if (!this.noDirection) {
+            characteristicFanDirection = serviceFan.getCharacteristic(Characteristic.RotationDirection)
+                .updateValue(this._getFanDirection(dps[this.dpFanDirection]))
+                .onGet(() => this.getFanDirection())
+                .onSet(value => this.setFanDirection(value));
+        } else this._removeCharacteristic(serviceFan, Characteristic.RotationDirection);
+
+        let characteristicSwingMode;
+        if (this.dpSwing) {
+            characteristicSwingMode = serviceFan.getCharacteristic(Characteristic.SwingMode)
+                .updateValue(this._getSwingMode(dps[this.dpSwing]))
+                .onGet(() => this.getSwingMode())
+                .onSet(value => this.setSwingMode(value));
+        } else this._removeCharacteristic(serviceFan, Characteristic.SwingMode);
 
         this.device.on('change', (changes, state) => {
             if (changes.hasOwnProperty(this.dpFanOn) && characteristicFanOn.value !== changes[this.dpFanOn])
@@ -61,6 +79,11 @@ class SimpleFanAccessory extends BaseAccessory {
                 if (characteristicFanDirection.value !== dir) characteristicFanDirection.updateValue(dir);
             }
 
+            if (characteristicSwingMode && changes.hasOwnProperty(this.dpSwing)) {
+                const swing = this._getSwingMode(changes[this.dpSwing]);
+                if (characteristicSwingMode.value !== swing) characteristicSwingMode.updateValue(swing);
+            }
+
             this.log.debug('SimpleFan changed: ' + JSON.stringify(state));
         });
     }
@@ -134,6 +157,20 @@ class SimpleFanAccessory extends BaseAccessory {
         return this.setStateAsync(this.dpFanDirection, tuyaVal);
     }
 
+    getSwingMode() {
+        return this._getSwingMode(this.getStateAsync(this.dpSwing));
+    }
+
+    _getSwingMode(dp) {
+        const {Characteristic} = this.hap;
+        return dp ? Characteristic.SwingMode.SWING_ENABLED : Characteristic.SwingMode.SWING_DISABLED;
+    }
+
+    setSwingMode(value) {
+        const {Characteristic} = this.hap;
+        return this.setStateAsync(this.dpSwing, value === Characteristic.SwingMode.SWING_ENABLED);
+    }
+
     convertRotationSpeedFromTuyaToHomeKit(value) {
         const v = parseInt(value) || 0;
         if (v <= 0) return 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "homebridge-tuya-plus",
-  "version": "4.0.0",
+  "version": "4.1.0-dev.64",
   "description": "A community-maintained Homebridge plugin for controlling Tuya devices locally over LAN, with an optional Tuya Cloud fallback for whatever the LAN can't reach. Includes new features, fixes, and updated device support. PRs welcome: if it runs, it ships (almost).",
   "main": "index.js",
   "scripts": {

package/test/GarageDoorAccessory.test.js

@@ -52,6 +52,21 @@ describe('GarageDoorAccessory._getTargetDoorState — Kogan (string)', () => {
     test('"closing" → targetClosed', () => expect(instance._getTargetDoorState('closing')).toBe(TDS.CLOSED));
 });
 
+describe('GarageDoorAccessory._getTargetDoorState — Daspi (string)', () => {
+    let instance;
+    beforeEach(() => ({ instance } = makeGarage('Daspi')));
+
+    test('"open" → targetOpen', () => expect(instance._getTargetDoorState('open')).toBe(TDS.OPEN));
+    test('"opening" → targetOpen', () => expect(instance._getTargetDoorState('opening')).toBe(TDS.OPEN));
+    test('"open_softstop" → targetOpen', () => expect(instance._getTargetDoorState('open_softstop')).toBe(TDS.OPEN));
+    test('"full_opened" → targetOpen', () => expect(instance._getTargetDoorState('full_opened')).toBe(TDS.OPEN));
+    test('"close" → targetClosed', () => expect(instance._getTargetDoorState('close')).toBe(TDS.CLOSED));
+    test('"closing" → targetClosed', () => expect(instance._getTargetDoorState('closing')).toBe(TDS.CLOSED));
+    test('"close_softstop" → targetClosed', () => expect(instance._getTargetDoorState('close_softstop')).toBe(TDS.CLOSED));
+    test('"full_closed" → targetClosed', () => expect(instance._getTargetDoorState('full_closed')).toBe(TDS.CLOSED));
+    test('mixed case "FULL_OPENED" → targetOpen', () => expect(instance._getTargetDoorState('FULL_OPENED')).toBe(TDS.OPEN));
+});
+
 // ---------------------------------------------------------------------------
 // _getCurrentDoorState
 // ---------------------------------------------------------------------------
@@ -78,6 +93,19 @@ describe('GarageDoorAccessory._getCurrentDoorState — Kogan (string)', () => {
     test('"closed" → CLOSED',    () => expect(instance._getCurrentDoorState('closed')).toBe(CDS.CLOSED));
 });
 
+describe('GarageDoorAccessory._getCurrentDoorState — Daspi (string)', () => {
+    let instance;
+    beforeEach(() => ({ instance } = makeGarage('Daspi')));
+
+    test('"full_opened" → OPEN',         () => expect(instance._getCurrentDoorState('full_opened')).toBe(CDS.OPEN));
+    test('"open_softstop" → OPENING',    () => expect(instance._getCurrentDoorState('open_softstop')).toBe(CDS.OPENING));
+    test('"opening" → OPENING',          () => expect(instance._getCurrentDoorState('opening')).toBe(CDS.OPENING));
+    test('"close_softstop" → CLOSING',   () => expect(instance._getCurrentDoorState('close_softstop')).toBe(CDS.CLOSING));
+    test('"closing" → CLOSING',          () => expect(instance._getCurrentDoorState('closing')).toBe(CDS.CLOSING));
+    test('"full_closed" → CLOSED',       () => expect(instance._getCurrentDoorState('full_closed')).toBe(CDS.CLOSED));
+    test('mixed case "FULL_CLOSED" → CLOSED', () => expect(instance._getCurrentDoorState('FULL_CLOSED')).toBe(CDS.CLOSED));
+});
+
 // ---------------------------------------------------------------------------
 // setTargetDoorState — device command
 // ---------------------------------------------------------------------------
@@ -113,6 +141,23 @@ describe('GarageDoorAccessory.setTargetDoorState — Kogan', () => {
     });
 });
 
+describe('GarageDoorAccessory.setTargetDoorState — Daspi', () => {
+    // Daspi expects capitalized command strings, unlike Kogan's lowercase.
+    test('OPEN sends "Open" to dpAction (1)', () => {
+        const { instance, device } = makeGarage('Daspi');
+        device.state['1'] = 'full_closed';
+        instance.setTargetDoorState(TDS.OPEN);
+        expect(device.update).toHaveBeenCalledWith({ '1': 'Open' });
+    });
+
+    test('CLOSED sends "Close" to dpAction (1)', () => {
+        const { instance, device } = makeGarage('Daspi');
+        device.state['1'] = 'full_opened';
+        instance.setTargetDoorState(TDS.CLOSED);
+        expect(device.update).toHaveBeenCalledWith({ '1': 'Close' });
+    });
+});
+
 // ---------------------------------------------------------------------------
 // flipState
 // ---------------------------------------------------------------------------

package/test/SimpleFanAccessory.test.js

@@ -0,0 +1,101 @@
+'use strict';
+
+const SimpleFanAccessory = require('../lib/SimpleFanAccessory');
+const { makeInstance, HAP } = require('./support/mocks');
+
+const { SwingMode, RotationDirection } = HAP.Characteristic;
+
+// The mock Fan service shares a single characteristic, so the write-path tests
+// wire the DP fields manually (mirroring what _registerCharacteristics would do)
+// and assert on the conversion helpers and the DP packets that go out. The
+// registration tests below drive _registerCharacteristics itself.
+function makeFan(state = {}, context = {}) {
+    const result = makeInstance(SimpleFanAccessory, state, { type: 'Fan', ...context });
+    const { instance } = result;
+
+    instance.dpFanOn = '1';
+    instance.dpRotationSpeed = '3';
+    instance.dpFanDirection = '2';
+    instance.dpSwing = instance._getCustomDP(context.dpSwing);
+    return result;
+}
+
+// ---------------------------------------------------------------------------
+// _getSwingMode — boolean DP maps to HomeKit SwingMode
+// ---------------------------------------------------------------------------
+describe('SimpleFanAccessory._getSwingMode', () => {
+    test('truthy DP enables swing', () => {
+        const { instance } = makeFan();
+        expect(instance._getSwingMode(true)).toBe(SwingMode.SWING_ENABLED);
+        expect(instance._getSwingMode(1)).toBe(SwingMode.SWING_ENABLED);
+    });
+
+    test('falsy DP disables swing', () => {
+        const { instance } = makeFan();
+        expect(instance._getSwingMode(false)).toBe(SwingMode.SWING_DISABLED);
+        expect(instance._getSwingMode(0)).toBe(SwingMode.SWING_DISABLED);
+        expect(instance._getSwingMode(undefined)).toBe(SwingMode.SWING_DISABLED);
+    });
+});
+
+// ---------------------------------------------------------------------------
+// getSwingMode / setSwingMode — read and write the configured swing DP
+// ---------------------------------------------------------------------------
+describe('SimpleFanAccessory.getSwingMode / setSwingMode', () => {
+    test('getSwingMode reads and converts the swing DP', () => {
+        const { instance } = makeFan({ '4': true }, { dpSwing: 4 });
+        expect(instance.getSwingMode()).toBe(SwingMode.SWING_ENABLED);
+    });
+
+    test('setSwingMode writes a boolean true to the swing DP', () => {
+        const { instance, device } = makeFan({ '4': false }, { dpSwing: 4 });
+        instance.setSwingMode(SwingMode.SWING_ENABLED);
+        expect(device.update).toHaveBeenCalledWith({ '4': true });
+    });
+
+    test('setSwingMode writes a boolean false to the swing DP', () => {
+        const { instance, device } = makeFan({ '4': true }, { dpSwing: 4 });
+        instance.setSwingMode(SwingMode.SWING_DISABLED);
+        expect(device.update).toHaveBeenCalledWith({ '4': false });
+    });
+
+    test('setSwingMode rejects (No Response) and writes nothing when disconnected', async () => {
+        const { instance, device } = makeFan({ '4': false }, { dpSwing: 4 });
+        device.connected = false;
+        await expect(instance.setSwingMode(SwingMode.SWING_ENABLED)).rejects.toBeInstanceOf(HAP.HapStatusError);
+        expect(device.update).not.toHaveBeenCalled();
+    });
+});
+
+// ---------------------------------------------------------------------------
+// Registration — SwingMode is opt-in and RotationDirection is opt-out
+// ---------------------------------------------------------------------------
+describe('SimpleFanAccessory._registerCharacteristics', () => {
+    const register = context => {
+        const { instance, accessory } = makeInstance(SimpleFanAccessory, {}, { type: 'Fan', ...context });
+        const service = accessory._mockService;
+        service.getCharacteristic.mockClear();
+        instance._registerCharacteristics(instance.device.state);
+        return service;
+    };
+
+    test('registers SwingMode when dpSwing is configured', () => {
+        const service = register({ dpSwing: 4 });
+        expect(service.getCharacteristic).toHaveBeenCalledWith(SwingMode);
+    });
+
+    test('does not register SwingMode when dpSwing is absent (backwards compatible)', () => {
+        const service = register({});
+        expect(service.getCharacteristic).not.toHaveBeenCalledWith(SwingMode);
+    });
+
+    test('registers RotationDirection by default', () => {
+        const service = register({});
+        expect(service.getCharacteristic).toHaveBeenCalledWith(RotationDirection);
+    });
+
+    test('drops RotationDirection when noDirection is set', () => {
+        const service = register({ noDirection: true });
+        expect(service.getCharacteristic).not.toHaveBeenCalledWith(RotationDirection);
+    });
+});

package/wiki/Supported-Device-Types.md

@@ -466,6 +466,15 @@ While still in early testing, you can use this to open and close the garage door
 }
 ```
 
+**Manufacturer-specific defaults.** Most openers report a plain boolean state on a numeric data-point. Some report string states and use different action/status data-points; set `manufacturer` and the plugin picks sensible defaults for you (each still overridable with `dpAction`/`dpStatus`):
+
+| `manufacturer` | `dpAction` | `dpStatus` | State values |
+|---|---|---|---|
+| _(any other)_ | `1` | `2` | boolean (`true`/`false`) |
+| `Kogan` | `101` | `102` | strings (`opened` / `openning` / `opening` / `closing` / `closed`) |
+| `Wofea` | `1` | `101` | boolean (`true`/`false`) |
+| `Daspi` | `1` | `7` | strings (`full_opened` / `opening` / `open_softstop` / `full_closed` / `closing` / `close_softstop`); commands are capitalized `Open` / `Close` |
+
 ### Simple Garage Doors
 For sliding gate openers and garage door controllers that expose momentary
 open/stop/close action DPs plus a single status DP that reports the gate's
@@ -723,7 +732,16 @@ These are accessories that may act as a regulator switch or an inbuilt regulator
     "dpRotationSpeed": "2",
 
     /* Override the default datapoint identifier of direction control (forward/reverse) */
-    "dpRotationDirection": 63
+    "dpRotationDirection": 63,
+
+    /* Datapoint of the oscillation switch (a boolean DP). When set, a Swing
+       (oscillation) control is shown in the Home app. Omit if the fan has none. */
+    "dpSwing": 4,
+
+    /* Hide the rotation direction control. Enable for fans that have no
+       forward/reverse, or whose direction datapoint is actually a mode enum,
+       so forward/reverse is never written into it. */
+    "noDirection": true
 }
 ```