homebridge-tuya-plus 3.1.2

package/lib/SimpleFanLightAccessory.js

@@ -0,0 +1,201 @@
+const BaseAccessory = require('./BaseAccessory');
+
+class SimpleFanLightAccessory extends BaseAccessory {
+    static getCategory(Categories) {
+        return Categories.FANLIGHT;
+    }
+
+    constructor(...props) {
+        super(...props);
+    }
+
+    _registerPlatformAccessory() {
+        const {Service} = this.hap;
+        this.accessory.addService(Service.Fan, this.device.context.name);
+        this.accessory.addService(Service.Lightbulb, this.device.context.name + " Light");
+        super._registerPlatformAccessory();
+    }
+
+    _registerCharacteristics(dps) {
+        const {Service, Characteristic} = this.hap;
+        const serviceFan = this.accessory.getService(Service.Fan);
+        const serviceLightbulb = this.accessory.getService(Service.Lightbulb);
+        this._checkServiceName(serviceFan, this.device.context.name);
+        this._checkServiceName(serviceLightbulb, this.device.context.name + " Light");
+        this.dpFanOn = this._getCustomDP(this.device.context.dpFanOn) || '1';
+        this.dpRotationSpeed = this._getCustomDP(this.device.context.dpRotationSpeed) || '3';
+        this.dpLightOn = this._getCustomDP(this.device.context.dpLightOn) || '9';
+        this.dpBrightness = this._getCustomDP(this.device.context.dpBrightness) || '10';
+        this.useLight = this._coerceBoolean(this.device.context.useLight, true);
+        this.useBrightness = this._coerceBoolean(this.device.context.useBrightness, false);
+        this.maxSpeed = parseInt(this.device.context.maxSpeed) || 3;
+        // This variable is here so that we can set the fans to turn onto speed one instead of 3 on start.
+        this.fanDefaultSpeed = parseInt(this.device.context.fanDefaultSpeed) || 1;
+        // This variable is here as a workaround to allow for the on/off function to work.
+        this.fanCurrentSpeed = 0;
+        // Add setting to use .toString() on return values or not.
+        this.useStrings = this._coerceBoolean(this.device.context.useStrings, true);
+
+        const characteristicFanOn = serviceFan.getCharacteristic(Characteristic.On)
+            .updateValue(this._getFanOn(dps[this.dpFanOn]))
+            .on('get', this.getFanOn.bind(this))
+            .on('set', this.setFanOn.bind(this));
+
+        const characteristicRotationSpeed = serviceFan.getCharacteristic(Characteristic.RotationSpeed)
+            .setProps({
+                minValue: 0,
+                maxValue: 100,
+                minStep: Math.max(100 / this.maxSpeed)
+            })
+            .updateValue(this.convertRotationSpeedFromTuyaToHomeKit(dps[this.dpRotationSpeed]))
+            .on('get', this.getSpeed.bind(this))
+            .on('set', this.setSpeed.bind(this));
+
+        let characteristicLightOn;
+        let characteristicBrightness;
+        if (this.useLight) {
+            characteristicLightOn = serviceLightbulb.getCharacteristic(Characteristic.On)
+                .updateValue(this._getLightOn(dps[this.dpLightOn]))
+                .on('get', this.getLightOn.bind(this))
+                .on('set', this.setLightOn.bind(this));
+
+            if (this.useBrightness) {
+                characteristicBrightness = serviceLightbulb.getCharacteristic(Characteristic.Brightness)
+                    .setProps({
+                        minValue: 0,
+                        maxValue: 1000,
+                        minStep: 100
+                    })
+                    .updateValue(this.convertBrightnessFromTuyaToHomeKit(dps[this.dpBrightness]))
+                    .on('get', this.getBrightness.bind(this))
+                    .on('set', this.setBrightness.bind(this));
+            }
+        }
+
+        this.device.on('change', (changes, state) => {
+
+            if (changes.hasOwnProperty(this.dpFanOn) && characteristicFanOn.value !== changes[this.dpFanOn])
+                characteristicFanOn.updateValue(changes[this.dpFanOn]);
+
+            if (changes.hasOwnProperty(this.dpRotationSpeed) && this.convertRotationSpeedFromHomeKitToTuya(characteristicRotationSpeed.value) !== changes[this.dpRotationSpeed])
+                characteristicRotationSpeed.updateValue(this.convertRotationSpeedFromTuyaToHomeKit(changes[this.dpRotationSpeed]));
+
+            if (changes.hasOwnProperty(this.dpLightOn) && characteristicLightOn && characteristicLightOn.value !== changes[this.dpLightOn])
+                characteristicLightOn.updateValue(changes[this.dpLightOn]);
+
+            if (changes.hasOwnProperty(this.dpBrightness) && characteristicBrightness && characteristicBrightness.value !== changes[this.dpBrightness])
+                characteristicBrightness.updateValue(changes[this.dpBrightness]);
+
+            this.log.debug('SimpleFanLight changed: ' + JSON.stringify(state));
+        });
+    }
+
+    /*************************** FAN ***************************/
+    // Get the Current Fan State
+    getFanOn(callback) {
+        this.getState(this.dpFanOn, (err, dp) => {
+            if (err) return callback(err);
+            callback(null, this._getFanOn(dp));
+        });
+    }
+
+    _getFanOn(dp) {
+        const {Characteristic} = this.hap;
+        return dp;
+    }
+
+    setFanOn(value, callback) {
+        const {Characteristic} = this.hap;
+        // This uses the multistatelegacy set command to send the fan on and speed request in one call.
+        if (value == false ) {
+          this.fanCurrentSpeed = 0;
+          // This will turn off the fan speed if it is set to be 0.
+          return this.setState(this.dpFanOn, false, callback);
+        } else {
+          if (this.fanCurrentSpeed === 0) {
+            // The current fanDefaultSpeed Variable is there to have the fan set to a sensible default if turned on.
+            if (this.useStrings) {
+                return this.setMultiStateLegacy({[this.dpFanOn]: value, [this.dpRotationSpeed]: this.fanDefaultSpeed.toString()}, callback);
+            } else {
+                return this.setMultiStateLegacy({[this.dpFanOn]: value, [this.dpRotationSpeed]: this.fanDefaultSpeed}, callback);
+            }
+          } else {
+            // The current fanCurrentSpeed Variable is there to ensure the fan speed doesn't change if the fan is already on.
+            if (this.useStrings) {
+                return this.setMultiStateLegacy({[this.dpFanOn]: value, [this.dpRotationSpeed]: this.fanCurrentSpeed.toString()}, callback);
+            } else {
+                return this.setMultiStateLegacy({[this.dpFanOn]: value, [this.dpRotationSpeed]: this.fanCurrentSpeed}, callback);
+            }
+          }
+        }
+    }
+
+    // Get the Current Fan Speed
+    getSpeed(callback) {
+        this.getState(this.dpRotationSpeed, (err, dp) => {
+            if (err) return callback(err);
+            callback(null, this.convertRotationSpeedFromTuyaToHomeKit(this.device.state[this.dpRotationSpeed]));
+        });
+    }
+
+    // Set the new fan speed
+    setSpeed(value, callback) {
+      const {Characteristic} = this.hap;
+      if (value === 0) {
+        // This is to set the fan speed variable to be 1 when the fan is off.
+        if (this.useStrings) {
+            return this.setMultiStateLegacy({[this.dpFanOn]: false, [this.dpRotationSpeed]: this.fanDefaultSpeed.toString()}, callback);
+        } else {
+            return this.setMultiStateLegacy({[this.dpFanOn]: false, [this.dpRotationSpeed]: this.fanDefaultSpeed}, callback);
+        }
+      } else {
+        // This is to set the fan speed variable to match the current speed.
+        this.fanCurrentSpeed = this.convertRotationSpeedFromHomeKitToTuya(value);
+        // This uses the multistatelegacy set command to send the fan on and speed request in one call.
+        if (this.useStrings) {
+            return this.setMultiStateLegacy({[this.dpFanOn]: true, [this.dpRotationSpeed]: this.convertRotationSpeedFromHomeKitToTuya(value).toString()}, callback);
+        } else {
+            return this.setMultiStateLegacy({[this.dpFanOn]: true, [this.dpRotationSpeed]: this.convertRotationSpeedFromHomeKitToTuya(value)}, callback);            
+        }
+      }
+    }
+
+    /*************************** LIGHT ***************************/
+    //Lightbulb State
+    getLightOn(callback) {
+        this.getState(this.dpLightOn, (err, dp) => {
+            if (err) return callback(err);
+            callback(null, this._getLightOn(dp));
+        });
+    }
+
+    _getLightOn(dp) {
+        const {Characteristic} = this.hap;
+        return dp;
+    }
+
+    setLightOn(value, callback) {
+        const {Characteristic} = this.hap;
+        return this.setState(this.dpLightOn, value, callback);
+    }
+
+    //Lightbulb Brightness
+    getBrightness(callback) {
+        this.getState(this.dpBrightness, (err, dp) => {
+            if (err) return callback(err);
+            callback(null, this._getBrightness(dp));
+        });
+    }
+
+    _getBrightness(dp) {
+        const {Characteristic} = this.hap;
+        return dp;
+    }
+
+    setBrightness(value, callback) {
+        const {Characteristic} = this.hap;
+        return this.setState(this.dpBrightness, value, callback);
+    }
+}
+
+module.exports = SimpleFanLightAccessory;

package/lib/SimpleHeaterAccessory.js

@@ -0,0 +1,154 @@
+const BaseAccessory = require('./BaseAccessory');
+
+class SimpleHeaterAccessory extends BaseAccessory {
+    static getCategory(Categories) {
+        return Categories.AIR_HEATER;
+    }
+
+    constructor(...props) {
+        super(...props);
+    }
+
+    _registerPlatformAccessory() {
+        const {Service} = this.hap;
+
+        this.accessory.addService(Service.HeaterCooler, this.device.context.name);
+
+        super._registerPlatformAccessory();
+    }
+
+    _registerCharacteristics(dps) {
+        const {Service, Characteristic} = this.hap;
+        const service = this.accessory.getService(Service.HeaterCooler);
+        this._checkServiceName(service, this.device.context.name);
+
+        this.dpActive = this._getCustomDP(this.device.context.dpActive) || '1';
+        this.dpDesiredTemperature = this._getCustomDP(this.device.context.dpDesiredTemperature) || '2';
+        this.dpCurrentTemperature = this._getCustomDP(this.device.context.dpCurrentTemperature) || '3';
+        this.temperatureDivisor = parseInt(this.device.context.temperatureDivisor) || 1;
+        this.thresholdTemperatureDivisor = parseInt(this.device.context.thresholdTemperatureDivisor) || 1;
+        this.targetTemperatureDivisor = parseInt(this.device.context.targetTemperatureDivisor) || 1;
+
+        const characteristicActive = service.getCharacteristic(Characteristic.Active)
+            .updateValue(this._getActive(dps[this.dpActive]))
+            .on('get', this.getActive.bind(this))
+            .on('set', this.setActive.bind(this));
+
+        service.getCharacteristic(Characteristic.CurrentHeaterCoolerState)
+            .updateValue(this._getCurrentHeaterCoolerState(dps))
+            .on('get', this.getCurrentHeaterCoolerState.bind(this));
+
+        service.getCharacteristic(Characteristic.TargetHeaterCoolerState)
+            .setProps({
+                minValue: 1,
+                maxValue: 1,
+                validValues: [Characteristic.TargetHeaterCoolerState.HEAT]
+            })
+            .updateValue(this._getTargetHeaterCoolerState())
+            .on('get', this.getTargetHeaterCoolerState.bind(this))
+            .on('set', this.setTargetHeaterCoolerState.bind(this));
+
+        const characteristicCurrentTemperature = service.getCharacteristic(Characteristic.CurrentTemperature)
+            .updateValue(this._getDividedState(dps[this.dpCurrentTemperature], this.temperatureDivisor))
+            .on('get', this.getDividedState.bind(this, this.dpCurrentTemperature, this.temperatureDivisor));
+
+
+        const characteristicHeatingThresholdTemperature = service.getCharacteristic(Characteristic.HeatingThresholdTemperature)
+            .setProps({
+                minValue: this.device.context.minTemperature || 15,
+                maxValue: this.device.context.maxTemperature || 35,
+                minStep: this.device.context.minTemperatureSteps || 1
+            })
+            .updateValue(this._getDividedState(dps[this.dpDesiredTemperature], this.thresholdTemperatureDivisor))
+            .on('get', this.getDividedState.bind(this, this.dpDesiredTemperature, this.thresholdTemperatureDivisor))
+            .on('set', this.setTargetThresholdTemperature.bind(this));
+
+        this.characteristicHeatingThresholdTemperature = characteristicHeatingThresholdTemperature;
+
+        this.device.on('change', (changes, state) => {
+            if (changes.hasOwnProperty(this.dpActive)) {
+                const newActive = this._getActive(changes[this.dpActive]);
+                if (characteristicActive.value !== newActive) {
+                    characteristicActive.updateValue(newActive);
+                }
+            }
+
+            if (changes.hasOwnProperty(this.dpDesiredTemperature)) {
+                if (characteristicHeatingThresholdTemperature.value !== changes[this.dpDesiredTemperature])
+                    characteristicHeatingThresholdTemperature.updateValue(changes[this.dpDesiredTemperature * this.targetTemperatureDivisor]);
+            }
+
+            if (changes.hasOwnProperty(this.dpCurrentTemperature) && characteristicCurrentTemperature.value !== changes[this.dpCurrentTemperature]) characteristicCurrentTemperature.updateValue(this._getDividedState(changes[this.dpCurrentTemperature], this.temperatureDivisor));
+
+            this.log.info('SimpleHeater changed: ' + JSON.stringify(state));
+        });
+    }
+
+    getActive(callback) {
+        this.getState(this.dpActive, (err, dp) => {
+            if (err) return callback(err);
+
+            callback(null, this._getActive(dp));
+        });
+    }
+
+    _getActive(dp) {
+        const {Characteristic} = this.hap;
+
+        return dp ? Characteristic.Active.ACTIVE : Characteristic.Active.INACTIVE;
+    }
+
+    setActive(value, callback) {
+        const {Characteristic} = this.hap;
+
+        switch (value) {
+            case Characteristic.Active.ACTIVE:
+                return this.setState(this.dpActive, true, callback);
+
+            case Characteristic.Active.INACTIVE:
+                return this.setState(this.dpActive, false, callback);
+        }
+
+        callback();
+    }
+
+    getCurrentHeaterCoolerState(callback) {
+        this.getState([this.dpActive], (err, dps) => {
+            if (err) return callback(err);
+
+            callback(null, this._getCurrentHeaterCoolerState(dps));
+        });
+    }
+
+    _getCurrentHeaterCoolerState(dps) {
+        const {Characteristic} = this.hap;
+        return dps[this.dpActive] ? Characteristic.CurrentHeaterCoolerState.HEATING : Characteristic.CurrentHeaterCoolerState.INACTIVE;
+    }
+
+    getTargetHeaterCoolerState(callback) {
+        callback(null, this._getTargetHeaterCoolerState());
+    }
+
+    _getTargetHeaterCoolerState() {
+        const {Characteristic} = this.hap;
+        return Characteristic.TargetHeaterCoolerState.HEAT;
+    }
+
+    setTargetHeaterCoolerState(value, callback) {
+        this.setState(this.dpActive, true, callback);
+    }
+
+    setTargetThresholdTemperature(value, callback) {
+        this.setState(this.dpDesiredTemperature, value * this.thresholdTemperatureDivisor, err => {
+            if (err) return callback(err);
+
+            if (this.characteristicHeatingThresholdTemperature) {
+                this.characteristicHeatingThresholdTemperature.updateValue(value);
+            }
+
+            callback();
+        });
+    }
+}
+
+module.exports = SimpleHeaterAccessory;

package/lib/SimpleLightAccessory.js

@@ -0,0 +1,39 @@
+const BaseAccessory = require('./BaseAccessory');
+
+class SimpleLightAccessory extends BaseAccessory {
+    static getCategory(Categories) {
+        return Categories.LIGHTBULB;
+    }
+
+    constructor(...props) {
+        super(...props);
+    }
+
+    _registerPlatformAccessory() {
+        const {Service} = this.hap;
+
+        this.accessory.addService(Service.Lightbulb, this.device.context.name);
+
+        super._registerPlatformAccessory();
+    }
+
+    _registerCharacteristics(dps) {
+        const {Service, Characteristic} = this.hap;
+        const service = this.accessory.getService(Service.Lightbulb);
+        this._checkServiceName(service, this.device.context.name);
+
+        this.dpPower = this._getCustomDP(this.device.context.dpPower) || '1';
+
+        const characteristicOn = service.getCharacteristic(Characteristic.On)
+            .updateValue(dps[this.dpPower])
+            .on('get', this.getState.bind(this, this.dpPower))
+            .on('set', this.setState.bind(this, this.dpPower));
+
+        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));
+        });
+    }
+}
+
+module.exports = SimpleLightAccessory;

package/lib/SwitchAccessory.js

@@ -0,0 +1,106 @@
+const BaseAccessory = require('./BaseAccessory');
+const async = require('async');
+
+class SwitchAccessory extends BaseAccessory {
+    static getCategory(Categories) {
+        return Categories.SWITCH;
+    }
+
+    constructor(...props) {
+        super(...props);
+    }
+
+    _registerPlatformAccessory() {
+        this._verifyCachedPlatformAccessory();
+        this._justRegistered = true;
+
+        super._registerPlatformAccessory();
+    }
+
+    _verifyCachedPlatformAccessory() {
+        if (this._justRegistered) return;
+
+        const {Service} = this.hap;
+
+        const switchCount = parseInt(this.device.context.switchCount) || 1;
+        const _validServices = [];
+        for (let i = 0; i++ < switchCount;) {
+            let service = this.accessory.getServiceByUUIDAndSubType(Service.Switch, 'switch ' + i);
+            if (service) this._checkServiceName(service, this.device.context.name + ' ' + i);
+            else service = this.accessory.addService(Service.Switch, this.device.context.name + ' ' + i, 'switch ' + i);
+
+            _validServices.push(service);
+        }
+
+        this.accessory.services
+            .filter(service => service.UUID === Service.Switch.UUID && !_validServices.includes(service))
+            .forEach(service => {
+                this.log.info('Removing', service.displayName);
+                this.accessory.removeService(service);
+            });
+    }
+
+    _registerCharacteristics(dps) {
+        this._verifyCachedPlatformAccessory();
+
+        const {Service, Characteristic} = this.hap;
+
+        const characteristics = {};
+        this.accessory.services.forEach(service => {
+            if (service.UUID !== Service.Switch.UUID || !service.subtype) return false;
+
+            let match;
+            if ((match = service.subtype.match(/^switch (\d+)$/)) === null) return;
+
+            characteristics[match[1]] = service.getCharacteristic(Characteristic.On)
+                .updateValue(dps[match[1]])
+                .on('get', this.getPower.bind(this, match[1]))
+                .on('set', this.setPower.bind(this, match[1]));
+        });
+
+        this.device.on('change', (changes, state) => {
+            Object.keys(changes).forEach(key => {
+                if (characteristics[key] && characteristics[key].value !== changes[key]) characteristics[key].updateValue(changes[key]);
+            });
+        });
+    }
+
+    getPower(dp, callback) {
+        callback(null, this.device.state[dp]);
+    }
+
+    setPower(dp, value, callback) {
+        if (!this._pendingPower) {
+            this._pendingPower = {props: {}, callbacks: []};
+        }
+
+        if (dp) {
+            if (this._pendingPower.timer) clearTimeout(this._pendingPower.timer);
+
+            this._pendingPower.props = {...this._pendingPower.props, ...{[dp]: value}};
+            this._pendingPower.callbacks.push(callback);
+
+            this._pendingPower.timer = setTimeout(() => {
+                this.setPower();
+            }, 500);
+            return;
+        }
+
+        const callbacks = this._pendingPower.callbacks;
+        const callEachBack = err => {
+            async.eachSeries(callbacks, (callback, next) => {
+                try {
+                    callback(err);
+                } catch (ex) {}
+                next();
+            });
+        };
+
+        const newValue = this._pendingPower.props;
+        this._pendingPower = null;
+
+        this.setMultiState(newValue, callEachBack);
+    }
+}
+
+module.exports = SwitchAccessory;

package/lib/TWLightAccessory.js

@@ -0,0 +1,91 @@
+const BaseAccessory = require('./BaseAccessory');
+const async = require('async');
+
+class TWLightAccessory extends BaseAccessory {
+    static getCategory(Categories) {
+        return Categories.LIGHTBULB;
+    }
+
+    constructor(...props) {
+        super(...props);
+    }
+
+    _registerPlatformAccessory() {
+        const {Service} = this.hap;
+
+        this.accessory.addService(Service.Lightbulb, this.device.context.name);
+
+        super._registerPlatformAccessory();
+    }
+
+    _registerCharacteristics(dps) {
+        const {Service, Characteristic, AdaptiveLightingController} = this.hap;
+        const service = this.accessory.getService(Service.Lightbulb);
+        this._checkServiceName(service, this.device.context.name);
+
+        this.dpPower = this._getCustomDP(this.device.context.dpPower) || '1';
+        this.dpBrightness = this._getCustomDP(this.device.context.dpBrightness) || '2';
+        this.dpColorTemperature = this._getCustomDP(this.device.context.dpColorTemperature) || '3';
+
+        const characteristicOn = service.getCharacteristic(Characteristic.On)
+            .updateValue(dps[this.dpPower])
+            .on('get', this.getState.bind(this, this.dpPower))
+            .on('set', this.setState.bind(this, this.dpPower));
+
+        const characteristicBrightness = service.getCharacteristic(Characteristic.Brightness)
+            .updateValue(this.convertBrightnessFromTuyaToHomeKit(dps[this.dpBrightness]))
+            .on('get', this.getBrightness.bind(this))
+            .on('set', this.setBrightness.bind(this));
+
+        const characteristicColorTemperature = service.getCharacteristic(Characteristic.ColorTemperature)
+            .setProps({
+                minValue: 0,
+                maxValue: 600
+            })
+            .updateValue(this.convertColorTemperatureFromTuyaToHomeKit(dps[this.dpColorTemperature]))
+            .on('get', this.getColorTemperature.bind(this))
+            .on('set', this.setColorTemperature.bind(this));
+
+        this.characteristicColorTemperature = characteristicColorTemperature;
+
+        if (this.adaptiveLightingSupport()) {
+            this.adaptiveLightingController = new AdaptiveLightingController(service);
+            this.accessory.configureController(this.adaptiveLightingController);
+            this.accessory.adaptiveLightingController = this.adaptiveLightingController;
+        }
+
+        this.device.on('change', (changes, state) => {
+            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.dpColorTemperature)) {
+                if (this.convertColorTemperatureFromHomeKitToTuya(characteristicColorTemperature.value) !== changes[this.dpColorTemperature])
+                    characteristicColorTemperature.updateValue(this.convertColorTemperatureFromTuyaToHomeKit(changes[this.dpColorTemperature]));
+            } else if (changes[this.dpBrightness]) {
+                characteristicColorTemperature.updateValue(this.convertColorTemperatureFromTuyaToHomeKit(state[this.dpColorTemperature]));
+            }
+        });
+    }
+
+    getBrightness(callback) {
+        return callback(null, this.convertBrightnessFromTuyaToHomeKit(this.device.state[this.dpBrightness]));
+    }
+
+    setBrightness(value, callback) {
+        return this.setState(this.dpBrightness, this.convertBrightnessFromHomeKitToTuya(value), callback);
+    }
+
+    getColorTemperature(callback) {
+        callback(null, this.convertColorTemperatureFromTuyaToHomeKit(this.device.state[this.dpColorTemperature]));
+    }
+
+    setColorTemperature(value, callback) {
+        if (value === 0) return callback(null, true);
+
+        this.setState(this.dpColorTemperature, this.convertColorTemperatureFromHomeKitToTuya(value), callback);
+    }
+}
+
+module.exports = TWLightAccessory;