homebridge-tuya-plus 3.9.0 → 3.11.0

package/config.schema.json

@@ -82,6 +82,10 @@
                   "title": "Garage Door",
                   "enum": ["GarageDoor"]
                 },
+                {
+                  "title": "Simple Garage Door (Open/Stop/Close)",
+                  "enum": ["SimpleGarageDoor"]
+                },
                 {
                   "title": "Simple Blinds",
                   "enum": ["SimpleBlinds"]
@@ -493,6 +497,27 @@
                 "functionBody": "return model.devices && model.devices[arrayIndices] && ['GarageDoor'].includes(model.devices[arrayIndices].type);"
               }
             },
+            "dpOpen": {
+              "type": "integer",
+              "placeholder": "1",
+              "condition": {
+                "functionBody": "return model.devices && model.devices[arrayIndices] && ['SimpleGarageDoor'].includes(model.devices[arrayIndices].type);"
+              }
+            },
+            "dpStop": {
+              "type": "integer",
+              "placeholder": "2",
+              "condition": {
+                "functionBody": "return model.devices && model.devices[arrayIndices] && ['SimpleGarageDoor'].includes(model.devices[arrayIndices].type);"
+              }
+            },
+            "dpClose": {
+              "type": "integer",
+              "placeholder": "3",
+              "condition": {
+                "functionBody": "return model.devices && model.devices[arrayIndices] && ['SimpleGarageDoor'].includes(model.devices[arrayIndices].type);"
+              }
+            },
             "flipState": {
               "type": "boolean",
               "condition": {

package/index.js

@@ -13,6 +13,7 @@ const AirPurifierAccessory = require('./lib/AirPurifierAccessory');
 const DehumidifierAccessory = require('./lib/DehumidifierAccessory');
 const ConvectorAccessory = require('./lib/ConvectorAccessory');
 const GarageDoorAccessory = require('./lib/GarageDoorAccessory');
+const SimpleGarageDoorAccessory = require('./lib/SimpleGarageDoorAccessory');
 const SimpleDimmerAccessory = require('./lib/SimpleDimmerAccessory');
 const SimpleDimmer2Accessory = require('./lib/SimpleDimmer2Accessory');
 const SimpleBlindsAccessory = require('./lib/SimpleBlindsAccessory');
@@ -47,6 +48,7 @@ const CLASS_DEF = {
     dehumidifier: DehumidifierAccessory,
     convector: ConvectorAccessory,
     garagedoor: GarageDoorAccessory,
+    simplegaragedoor: SimpleGarageDoorAccessory,
     simpledimmer: SimpleDimmerAccessory,
     simpledimmer2: SimpleDimmer2Accessory,
     simpleblinds: SimpleBlindsAccessory,

package/lib/AirConditionerAccessory.js

@@ -1,7 +1,5 @@
 const BaseAccessory = require('./BaseAccessory');
 
-const STATE_OTHER = 9;
-
 class AirConditionerAccessory extends BaseAccessory {
     static getCategory(Categories) {
         return Categories.AIR_CONDITIONER;
@@ -28,8 +26,6 @@ class AirConditionerAccessory extends BaseAccessory {
             else throw new Error('The cmdAuto doesn\'t appear to be valid: ' + this.device.context.cmdAuto);
         }
 
-        this.device.context.noAuto = true;
-
         if (!this.device.context.noRotationSpeed) {
             const fanSpeedSteps = (this.device.context.fanSpeedSteps && isFinite(this.device.context.fanSpeedSteps) && this.device.context.fanSpeedSteps > 0 && this.device.context.fanSpeedSteps < 100) ? this.device.context.fanSpeedSteps : 100;
             this._rotationSteps = [0];
@@ -65,7 +61,7 @@ class AirConditionerAccessory extends BaseAccessory {
         this.dpSwingMode = this._getCustomDP(this.device.context.dpSwingMode) || '104';
 
         const characteristicActive = service.getCharacteristic(Characteristic.Active)
-            .updateValue(this._getActive(this.dpActive))
+            .updateValue(this._getActive(dps[this.dpActive]))
             .onGet(() => this.getActive())
             .onSet(value => this.setActive(value));
 
@@ -73,13 +69,13 @@ class AirConditionerAccessory extends BaseAccessory {
             .updateValue(this._getCurrentHeaterCoolerState(dps))
             .onGet(() => this.getCurrentHeaterCoolerState());
 
-        const _validTargetHeaterCoolerStateValues = [STATE_OTHER];
-        if (!this.device.context.noCool) _validTargetHeaterCoolerStateValues.unshift(Characteristic.TargetHeaterCoolerState.COOL);
-        if (!this.device.context.noHeat) _validTargetHeaterCoolerStateValues.unshift(Characteristic.TargetHeaterCoolerState.HEAT);
-        if (!this.device.context.noAuto) _validTargetHeaterCoolerStateValues.unshift(Characteristic.TargetHeaterCoolerState.AUTO);
+        const _validTargetHeaterCoolerStateValues = [];
+        if (!this.device.context.noAuto) _validTargetHeaterCoolerStateValues.push(Characteristic.TargetHeaterCoolerState.AUTO);
+        if (!this.device.context.noHeat) _validTargetHeaterCoolerStateValues.push(Characteristic.TargetHeaterCoolerState.HEAT);
+        if (!this.device.context.noCool) _validTargetHeaterCoolerStateValues.push(Characteristic.TargetHeaterCoolerState.COOL);
 
         const characteristicTargetHeaterCoolerState = service.getCharacteristic(Characteristic.TargetHeaterCoolerState)
-            .setProps({ maxValue: 9, validValues: _validTargetHeaterCoolerStateValues })
+            .setProps({ validValues: _validTargetHeaterCoolerStateValues })
             .updateValue(this._getTargetHeaterCoolerState(dps[this.dpMode]))
             .onGet(() => this.getTargetHeaterCoolerState())
             .onSet(value => this.setTargetHeaterCoolerState(value));
@@ -112,7 +108,7 @@ class AirConditionerAccessory extends BaseAccessory {
                     maxValue: this.device.context.maxTemperature || 35,
                     minStep: this.device.context.minTemperatureSteps || 1
                 })
-                .updateValue(this.dpThreshold)
+                .updateValue(dps[this.dpThreshold])
                 .onGet(() => this.getStateAsync(this.dpThreshold))
                 .onSet(value => this.setTargetThresholdTemperature('cool', value));
         } else this._removeCharacteristic(service, Characteristic.CoolingThresholdTemperature);
@@ -256,17 +252,20 @@ class AirConditionerAccessory extends BaseAccessory {
         const {Characteristic} = this.hap;
         switch (dp) {
             case this.cmdCool:
-                if (this.device.context.noCool) return STATE_OTHER;
-                return Characteristic.TargetHeaterCoolerState.COOL;
+                if (!this.device.context.noCool) return Characteristic.TargetHeaterCoolerState.COOL;
+                break;
             case this.cmdHeat:
-                if (this.device.context.noHeat) return STATE_OTHER;
-                return Characteristic.TargetHeaterCoolerState.HEAT;
+                if (!this.device.context.noHeat) return Characteristic.TargetHeaterCoolerState.HEAT;
+                break;
             case this.cmdAuto:
-                if (this.device.context.noAuto) return STATE_OTHER;
-                return Characteristic.TargetHeaterCoolerState.AUTO;
-            default:
-                return STATE_OTHER;
+                if (!this.device.context.noAuto) return Characteristic.TargetHeaterCoolerState.AUTO;
+                break;
         }
+        // Fall back to the first allowed mode rather than publishing a value
+        // that isn't in validValues — HomeKit would reject it otherwise.
+        if (!this.device.context.noCool) return Characteristic.TargetHeaterCoolerState.COOL;
+        if (!this.device.context.noHeat) return Characteristic.TargetHeaterCoolerState.HEAT;
+        return Characteristic.TargetHeaterCoolerState.AUTO;
     }
 
     setTargetHeaterCoolerState(value) {
@@ -274,13 +273,13 @@ class AirConditionerAccessory extends BaseAccessory {
         switch (value) {
             case Characteristic.TargetHeaterCoolerState.COOL:
                 if (this.device.context.noCool) return;
-                return this.setStateAsync(this.dpMode, this.cmdCool);
+                return this.setMultiStateLegacyAsync({[this.dpActive]: true, [this.dpMode]: this.cmdCool});
             case Characteristic.TargetHeaterCoolerState.HEAT:
                 if (this.device.context.noHeat) return;
-                return this.setStateAsync(this.dpMode, this.cmdHeat);
+                return this.setMultiStateLegacyAsync({[this.dpActive]: true, [this.dpMode]: this.cmdHeat});
             case Characteristic.TargetHeaterCoolerState.AUTO:
                 if (this.device.context.noAuto) return;
-                return this.setStateAsync(this.dpMode, this.cmdAuto);
+                return this.setMultiStateLegacyAsync({[this.dpActive]: true, [this.dpMode]: this.cmdAuto});
         }
     }
 
@@ -305,7 +304,7 @@ class AirConditionerAccessory extends BaseAccessory {
     }
 
     async setTargetThresholdTemperature(mode, value) {
-        await this.setStateAsync(this.dpThreshold, value);
+        await this.setMultiStateLegacyAsync({[this.dpActive]: true, [this.dpThreshold]: value});
         if (mode === 'cool' && !this.device.context.noHeat && this.characteristicHeatingThresholdTemperature) {
             this.characteristicHeatingThresholdTemperature.updateValue(value);
         } else if (mode === 'heat' && !this.device.context.noCool && this.characteristicCoolingThresholdTemperature) {

package/lib/SimpleGarageDoorAccessory.js

@@ -0,0 +1,84 @@
+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.
+const CURRENT_STATE_DELAY_MS = 1000;
+
+class SimpleGarageDoorAccessory extends BaseAccessory {
+    static getCategory(Categories) {
+        return Categories.GARAGE_DOOR_OPENER;
+    }
+
+    constructor(...props) {
+        super(...props);
+    }
+
+    _registerPlatformAccessory() {
+        const {Service} = this.hap;
+
+        this.accessory.addService(Service.GarageDoorOpener, this.device.context.name);
+
+        super._registerPlatformAccessory();
+    }
+
+    _registerCharacteristics() {
+        const {Service, Characteristic} = this.hap;
+        const service = this.accessory.getService(Service.GarageDoorOpener);
+        this._checkServiceName(service, this.device.context.name);
+
+        this.dpOpen = this._getCustomDP(this.device.context.dpOpen) || '1';
+        this.dpStop = this._getCustomDP(this.device.context.dpStop) || '2';
+        this.dpClose = this._getCustomDP(this.device.context.dpClose) || '3';
+
+        // 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 &&
+            this.accessory.context.cachedTargetDoorState !== Characteristic.TargetDoorState.CLOSED) {
+            this.accessory.context.cachedTargetDoorState = Characteristic.TargetDoorState.OPEN;
+        }
+        const initialTarget = this.accessory.context.cachedTargetDoorState;
+        this.currentDoorState = initialTarget === Characteristic.TargetDoorState.OPEN
+            ? Characteristic.CurrentDoorState.OPEN
+            : Characteristic.CurrentDoorState.CLOSED;
+
+        this.characteristicTargetDoorState = service.getCharacteristic(Characteristic.TargetDoorState)
+            .updateValue(initialTarget)
+            .onGet(() => this.accessory.context.cachedTargetDoorState)
+            .onSet(value => this.setTargetDoorState(value));
+
+        this.characteristicCurrentDoorState = service.getCharacteristic(Characteristic.CurrentDoorState)
+            .updateValue(this.currentDoorState)
+            .onGet(() => this.currentDoorState);
+
+        service.getCharacteristic(Characteristic.ObstructionDetected)
+            .updateValue(false)
+            .onGet(() => false);
+    }
+
+    setTargetDoorState(value) {
+        const {Characteristic} = this.hap;
+
+        this.accessory.context.cachedTargetDoorState = value;
+
+        // 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});
+        if (value === Characteristic.TargetDoorState.OPEN) {
+            this.setMultiStateLegacyAsync({[this.dpOpen]: true});
+        } else {
+            this.setMultiStateLegacyAsync({[this.dpClose]: true});
+        }
+
+        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);
+    }
+}
+
+module.exports = SimpleGarageDoorAccessory;

package/lib/SimpleHeaterAccessory.js

@@ -29,6 +29,14 @@ class SimpleHeaterAccessory extends BaseAccessory {
         this.temperatureDivisor = parseInt(this.device.context.temperatureDivisor) || 1;
         this.thresholdTemperatureDivisor = parseInt(this.device.context.thresholdTemperatureDivisor) || 1;
         this.temperatureOffset = parseInt(this.device.context.temperatureOffset) || 0;
+        // currentTemperatureOffset shifts only the displayed current temperature
+        // (not the threshold/setpoint). Use for devices whose onboard sensor
+        // reads systematically off from real ambient (e.g. wall-mounted patio
+        // heaters with sensor against the housing/wall). Defaults to
+        // temperatureOffset for backwards compatibility.
+        this.currentTemperatureOffset = this.device.context.currentTemperatureOffset !== undefined
+            ? parseInt(this.device.context.currentTemperatureOffset)
+            : this.temperatureOffset;
 
         const characteristicActive = service.getCharacteristic(Characteristic.Active)
             .updateValue(this._getActive(dps[this.dpActive]))
@@ -50,8 +58,8 @@ class SimpleHeaterAccessory extends BaseAccessory {
             .onSet(() => this.setStateAsync(this.dpActive, true));
 
         const characteristicCurrentTemperature = service.getCharacteristic(Characteristic.CurrentTemperature)
-            .updateValue(this._getDividedState(dps[this.dpCurrentTemperature], this.temperatureDivisor))
-            .onGet(() => this.getDividedStateAsync(this.dpCurrentTemperature, this.temperatureDivisor));
+            .updateValue(this._getDividedState(dps[this.dpCurrentTemperature], this.temperatureDivisor, this.currentTemperatureOffset))
+            .onGet(() => this._getCurrentTempAsync());
 
         const characteristicHeatingThresholdTemperature = service.getCharacteristic(Characteristic.HeatingThresholdTemperature)
             .setProps({
@@ -79,7 +87,7 @@ class SimpleHeaterAccessory extends BaseAccessory {
             }
 
             if (changes.hasOwnProperty(this.dpCurrentTemperature) && characteristicCurrentTemperature.value !== changes[this.dpCurrentTemperature])
-                characteristicCurrentTemperature.updateValue(this._getDividedState(changes[this.dpCurrentTemperature], this.temperatureDivisor));
+                characteristicCurrentTemperature.updateValue(this._getDividedState(changes[this.dpCurrentTemperature], this.temperatureDivisor, this.currentTemperatureOffset));
 
             characteristicCurrentHeaterCoolerState.updateValue(this._getCurrentHeaterCoolerState(state));
             this.log.info('SimpleHeater changed: ' + JSON.stringify(state));
@@ -132,8 +140,15 @@ class SimpleHeaterAccessory extends BaseAccessory {
         }
     }
 
-    _getDividedState(dp, divisor) {
-        return ((parseFloat(dp) / divisor) + this.temperatureOffset) || 0;
+    _getDividedState(dp, divisor, offsetOverride) {
+        const offset = offsetOverride !== undefined ? offsetOverride : this.temperatureOffset;
+        return ((parseFloat(dp) / divisor) + offset) || 0;
+    }
+
+    _getCurrentTempAsync() {
+        const data = this.getStateAsync(this.dpCurrentTemperature);
+        if (!isFinite(data)) throw new Error('Invalid state');
+        return this._getDividedState(data, this.temperatureDivisor, this.currentTemperatureOffset);
     }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "homebridge-tuya-plus",
-  "version": "3.9.0",
+  "version": "3.11.0",
   "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

@@ -0,0 +1,129 @@
+'use strict';
+
+const SimpleGarageDoorAccessory = require('../lib/SimpleGarageDoorAccessory');
+const { HAP, makeInstance } = require('./support/mocks');
+
+const { CurrentDoorState: CDS, TargetDoorState: TDS } = HAP.Characteristic;
+
+function makeSimpleGarage(contextOverrides = {}) {
+    const { instance, device, accessory, platform } = makeInstance(
+        SimpleGarageDoorAccessory,
+        {},
+        { manufacturer: 'Generic', ...contextOverrides }
+    );
+
+    // Replicate what _registerCharacteristics would set up.
+    instance.dpOpen = '1';
+    instance.dpStop = '2';
+    instance.dpClose = '3';
+    instance.currentDoorState = CDS.OPEN;
+    instance.characteristicCurrentDoorState = {
+        value: CDS.OPEN,
+        updateValue: jest.fn().mockImplementation(function(v) { this.value = v; return this; }),
+    };
+
+    return { instance, device, accessory, platform };
+}
+
+// ---------------------------------------------------------------------------
+// setTargetDoorState — device commands
+// ---------------------------------------------------------------------------
+describe('SimpleGarageDoorAccessory.setTargetDoorState — device commands', () => {
+    test('OPEN sends stop=true then open=true', () => {
+        const { instance, device } = makeSimpleGarage();
+        instance.setTargetDoorState(TDS.OPEN);
+        expect(device.update).toHaveBeenNthCalledWith(1, { '2': true });
+        expect(device.update).toHaveBeenNthCalledWith(2, { '1': true });
+    });
+
+    test('CLOSED sends stop=true then close=true', () => {
+        const { instance, device } = makeSimpleGarage();
+        instance.setTargetDoorState(TDS.CLOSED);
+        expect(device.update).toHaveBeenNthCalledWith(1, { '2': true });
+        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();
+    });
+
+    test('Custom DPs are respected', () => {
+        const { instance, device } = makeSimpleGarage();
+        instance.dpOpen = '101';
+        instance.dpStop = '102';
+        instance.dpClose = '103';
+        instance.setTargetDoorState(TDS.OPEN);
+        expect(device.update).toHaveBeenNthCalledWith(1, { '102': true });
+        expect(device.update).toHaveBeenNthCalledWith(2, { '101': true });
+    });
+});
+
+// ---------------------------------------------------------------------------
+// CurrentDoorState transition
+// ---------------------------------------------------------------------------
+describe('SimpleGarageDoorAccessory.setTargetDoorState — CurrentDoorState transition', () => {
+    beforeEach(() => jest.useFakeTimers());
+    afterEach(() => jest.useRealTimers());
+
+    test('CurrentDoorState lags the target by 1s when opening', () => {
+        const { instance } = makeSimpleGarage();
+        instance.currentDoorState = CDS.CLOSED;
+        instance.characteristicCurrentDoorState.value = CDS.CLOSED;
+
+        instance.setTargetDoorState(TDS.OPEN);
+        expect(instance.characteristicCurrentDoorState.value).toBe(CDS.CLOSED);
+
+        jest.advanceTimersByTime(999);
+        expect(instance.characteristicCurrentDoorState.value).toBe(CDS.CLOSED);
+
+        jest.advanceTimersByTime(1);
+        expect(instance.currentDoorState).toBe(CDS.OPEN);
+        expect(instance.characteristicCurrentDoorState.value).toBe(CDS.OPEN);
+    });
+
+    test('CurrentDoorState lags the target by 1s when closing', () => {
+        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);
+        expect(instance.currentDoorState).toBe(CDS.CLOSED);
+        expect(instance.characteristicCurrentDoorState.value).toBe(CDS.CLOSED);
+    });
+
+    test('Reversing direction within the 1s window resets the timer', () => {
+        const { instance } = makeSimpleGarage();
+        instance.currentDoorState = CDS.OPEN;
+        instance.characteristicCurrentDoorState.value = CDS.OPEN;
+
+        instance.setTargetDoorState(TDS.CLOSED);
+        jest.advanceTimersByTime(500);
+        instance.setTargetDoorState(TDS.OPEN);
+
+        jest.advanceTimersByTime(500);
+        expect(instance.characteristicCurrentDoorState.value).toBe(CDS.OPEN);
+
+        jest.advanceTimersByTime(500);
+        expect(instance.currentDoorState).toBe(CDS.OPEN);
+        expect(instance.characteristicCurrentDoorState.value).toBe(CDS.OPEN);
+    });
+});
+
+// ---------------------------------------------------------------------------
+// Persistence
+// ---------------------------------------------------------------------------
+describe('SimpleGarageDoorAccessory persistence', () => {
+    test('Stores the latest target on the accessory context', () => {
+        const { instance, accessory } = makeSimpleGarage();
+        instance.setTargetDoorState(TDS.CLOSED);
+        expect(accessory.context.cachedTargetDoorState).toBe(TDS.CLOSED);
+        instance.setTargetDoorState(TDS.OPEN);
+        expect(accessory.context.cachedTargetDoorState).toBe(TDS.OPEN);
+    });
+});