homebridge-tasmota-control 1.4.1-beta.5 → 1.4.1-beta.6

package/package.json

@@ -1,7 +1,7 @@
 {
   "displayName": "Tasmota Control",
   "name": "homebridge-tasmota-control",
-  "version": "1.4.1-beta.5",
+  "version": "1.4.1-beta.6",
   "description": "Homebridge plugin to control Tasmota flashed devices.",
   "license": "MIT",
   "author": "grzegorz914",

package/src/switches.js

@@ -22,6 +22,7 @@ class Switches extends EventEmitter {
         //other config
         this.relaysDisplayType = config.relaysDisplayType || 0;
         this.relaysNamePrefix = config.relaysNamePrefix || false;
+        this.sensorsNamePrefix = config.sensorsNamePrefix || false;
         this.enableDebugMode = config.enableDebugMode || false;
         this.disableLogInfo = config.disableLogInfo || false;
         this.disableLogDeviceInfo = config.disableLogDeviceInfo || false;
@@ -64,6 +65,13 @@ class Switches extends EventEmitter {
             const powerStatus = powerStatusData.data ?? {};
             const debug = this.enableDebugMode ? this.emit('debug', `Power status: ${JSON.stringify(powerStatus, null, 2)}`) : false;
 
+            //sensor status keys
+            const sensorStatusKeys = Object.keys(sensorStatus);
+
+            //status SNS
+            const statusSnsSupported = sensorStatusKeys.includes('StatusSNS');
+            const statusSns = statusSnsSupported ? sensorStatus.StatusSNS : {};
+
             //relays
             const relaysCount = this.info.relaysCount;
             if (relaysCount > 0) {
@@ -94,6 +102,160 @@ class Switches extends EventEmitter {
                 }
             }
 
+            //status SNS
+            if (statusSnsSupported) {
+                this.sensorsName = [];
+                this.sensorsTemperature = [];
+                this.sensorsReferenceTemperature = [];
+                this.sensorsObjTemperature = [];
+                this.sensorsAmbTemperature = [];
+                this.sensorsDewPointTemperature = [];
+                this.sensorsHumidity = [];
+                this.sensorsPressure = [];
+                this.sensorsGas = [];
+                this.sensorsCarbonDioxyde = [];
+                this.sensorsAmbientLight = [];
+                this.sensorsMotion = [];
+
+                const sensor = Object.entries(statusSns)
+                    .filter(([key]) => SensorKeys.some(type => key.includes(type)))
+                    .reduce((obj, [key, value]) => {
+                        obj[key] = value;
+                        return obj;
+                    }, {});
+
+                for (const [key, value] of Object.entries(sensor)) {
+                    const sensorName = key ?? `Sensor`;
+                    const sensorData = value;
+
+                    //sensors
+                    const temperature = sensorData.Temperature ?? false;
+                    const referenceTemperature = sensorData.ReferenceTemperature ?? false;
+                    const objTemperature = sensorData.OBJTMP ?? false;
+                    const ambTemperature = sensorData.AMBTMP ?? false;
+                    const dewPointTemperature = sensorData.DewPoint ?? false;
+                    const humidity = sensorData.Humidity ?? false;
+                    const pressure = sensorData.Pressure ?? false;
+                    const gas = sensorData.Gas ?? false;
+                    const carbonDioxyde = sensorData.CarbonDioxyde ?? false;
+                    const ambientLight = sensorData.Ambient ?? false;
+                    const motion = sensorData === 'ON';
+
+                    //energy
+                    const energyTotalStartTime = sensorData.TotalStartTime ?? '';
+                    const energyTotal = sensorData.Total ?? 0;
+                    const energyPeriod = sensorData.Period ?? 0;
+                    const energyYesterday = sensorData.Yesterday ?? 0;
+                    const energyToday = sensorData.Today ?? 0;
+                    const power = sensorData.Power ?? 0;
+                    const apparentPower = sensorData.ApparentPower ?? 0;
+                    const reactivePower = sensorData.ReactivePower ?? 0;
+                    const factor = sensorData.Factor ?? 0;
+                    const voltage = sensorData.Voltage ?? 0;
+                    const current = sensorData.Current ?? 0;
+                    const load = sensorData.Load ?? 0;
+
+                    //push to array
+                    this.sensorsName.push(sensorName);
+                    const push1 = temperature ? this.sensorsTemperature.push(temperature) : false;
+                    const push2 = referenceTemperature ? this.sensorsReferenceTemperature.push(referenceTemperature) : false;
+                    const push3 = objTemperature ? this.sensorsAmbTemperature.push(objTemperature) : false;
+                    const push4 = ambTemperature ? this.sensorsAmbTemperature.push(ambTemperature) : false;
+                    const push5 = dewPointTemperature ? this.sensorsDewPointTemperature.push(dewPointTemperature) : false;
+                    const push6 = humidity ? this.sensorsHumidity.push(humidity) : false;
+                    const push7 = pressure ? this.sensorsPressure.push(pressure) : false;
+                    const push8 = gas ? this.sensorsGas.push(gas) : false;
+                    const push9 = carbonDioxyde ? this.sensorsCarbonDioxyde.push(carbonDioxyde) : false;
+                    const push10 = ambientLight ? this.sensorsAmbientLight.push(ambientLight) : false;
+                    const push11 = motion ? this.sensorsMotion.push(motion) : false;
+                }
+
+                this.time = sensorStatus.Time ?? '';
+                this.tempUnit = sensorStatus.TempUnit === 'C' ? '°C' : 'F';
+                this.pressureUnit = sensorStatus.PressureUnit ?? 'hPa';
+                this.sensorsTemperatureCount = this.sensorsTemperature.length;
+                this.sensorsReferenceTemperatureCount = this.sensorsReferenceTemperature.length;
+                this.sensorsObjTemperatureCount = this.sensorsObjTemperature.length;
+                this.sensorsAmbTemperatureCount = this.sensorsAmbTemperature.length;
+                this.sensorsDewPointTemperatureCount = this.sensorsDewPointTemperature.length;
+                this.sensorsHumidityCount = this.sensorsHumidity.length;
+                this.sensorsPressureCount = this.sensorsPressure.length;
+                this.sensorsGasCount = this.sensorsGas.length;
+                this.sensorsCarbonDioxydeCount = this.sensorsCarbonDioxyde.length;
+                this.sensorsAmbientLightCount = this.sensorsAmbientLight.length;
+                this.sensorsMotionCount = this.sensorsMotion.length;
+                this.sensorsCount = this.sensorsName.length;
+
+
+                //update characteristics
+                if (this.sensorTemperatureServices) {
+                    for (let i = 0; i < this.sensorsTemperatureCount; i++) {
+                        const value = this.sensorsTemperature[i];
+                        this.sensorTemperatureServices[i].updateCharacteristic(Characteristic.CurrentTemperature, value);
+                    }
+                }
+
+                if (this.sensorReferenceTemperatureServices) {
+                    for (let i = 0; i < this.sensorsReferenceTemperatureCount; i++) {
+                        const value = this.sensorsReferenceTemperature[i];
+                        this.sensorReferenceTemperatureServices[i].updateCharacteristic(Characteristic.CurrentTemperature, value);
+                    }
+                }
+
+                if (this.sensorObjTemperatureServices) {
+                    for (let i = 0; i < this.sensorsObjTemperatureCount; i++) {
+                        const value = this.sensorsObjTemperature[i];
+                        this.sensorObjTemperatureServices[i].updateCharacteristic(Characteristic.CurrentTemperature, value);
+                    }
+                }
+
+                if (this.sensorAmbTemperatureServices) {
+                    for (let i = 0; i < this.sensorsAmbTemperatureCount; i++) {
+                        const value = this.sensorsAmbTemperature[i];
+                        this.sensorAmbTemperatureServices[i].updateCharacteristic(Characteristic.CurrentTemperature, value);
+                    }
+                }
+
+                if (this.sensorDewPointTemperatureServices) {
+                    for (let i = 0; i < this.sensorsDewPointTemperatureCount; i++) {
+                        const value = this.sensorsDewPointTemperature[i];
+                        this.sensorDewPointTemperatureServices[i].updateCharacteristic(Characteristic.CurrentTemperature, value);
+                    }
+                }
+
+                if (this.sensorHumidityServices) {
+                    for (let i = 0; i < this.sensorsHumidityCount; i++) {
+                        const value = this.sensorsHumidity[i];
+                        this.sensorHumidityServices[i].updateCharacteristic(Characteristic.CurrentRelativeHumidity, value);
+                    }
+                }
+
+                if (this.sensorCarbonDioxydeServices) {
+                    for (let i = 0; i < this.sensorsCarbonDioxydeCount; i++) {
+                        const state = this.sensorsCarbonDioxyde[i] > 1000;
+                        const value = this.sensorsCarbonDioxyde[i];
+                        this.sensorCarbonDioxydeServices[i]
+                            .updateCharacteristic(Characteristic.CarbonDioxideDetected, state)
+                            .updateCharacteristic(Characteristic.CarbonDioxideLevel, value)
+                            .updateCharacteristic(Characteristic.CarbonDioxidePeakLevel, value);
+                    }
+                }
+
+                if (this.sensorAmbientLightServices) {
+                    for (let i = 0; i < this.sensorsAmbientLightCount; i++) {
+                        const value = this.sensorsAmbientLight[i];
+                        this.sensorAmbientLightServices[i].updateCharacteristic(Characteristic.CurrentAmbientLightLevel, value);
+                    }
+                }
+
+                if (this.sensorMotionServices) {
+                    for (let i = 0; i < this.sensorsMotionCount; i++) {
+                        const state = this.sensorsMotion[i];
+                        this.sensorMotionServices[i].updateCharacteristic(Characteristic.MotionDetected, state);
+                    }
+                }
+            }
+
             return true;
         } catch (error) {
             throw new Error(`Check state error: ${error}`);
@@ -198,6 +360,216 @@ class Switches extends EventEmitter {
                 }
             };
 
+            //Prepare services 
+            if (this.sensorsCount > 0) {
+                const debug = this.enableDebugMode ? this.emit('debug', `Prepare Sensor Services`) : false;
+
+                //temperature
+                const sensorsTemperatureCount = this.sensorsTemperatureCount;
+                if (sensorsTemperatureCount > 0) {
+                    const debug = this.enableDebugMode ? this.emit('debug', `Prepare Temperature Sensor Services`) : false;
+                    this.sensorTemperatureServices = [];
+                    for (let i = 0; i < sensorsTemperatureCount; i++) {
+                        const sensorName = this.sensorsName[i];
+                        const serviceName = this.sensorsNamePrefix ? `${accessoryName} ${sensorName} Temperature` : `${sensorName} Temperature`;
+                        const sensorTemperatureService = accessory.addService(Service.TemperatureSensor, serviceName, `Temperature Sensor ${i}`);
+                        sensorTemperatureService.addOptionalCharacteristic(Characteristic.ConfiguredName);
+                        sensorTemperatureService.setCharacteristic(Characteristic.ConfiguredName, serviceName);
+                        sensorTemperatureService.getCharacteristic(Characteristic.CurrentTemperature)
+                            .onGet(async () => {
+                                const value = this.sensorsTemperature[i];
+                                const logInfo = this.disableLogInfo ? false : this.emit('info', `sensor: ${sensorName} temperature: ${value} °${this.tempUnit}`);
+                                return value;
+                            });
+                        this.sensorTemperatureServices.push(sensorTemperatureService);
+                    }
+                }
+
+                //reference temperature
+                const sensorsReferenceTemperatureCount = this.sensorsReferenceTemperatureCount;
+                if (sensorsReferenceTemperatureCount > 0) {
+                    const debug = this.enableDebugMode ? this.emit('debug', `Prepare Reference Temperature Sensor Services`) : false;
+                    this.sensorReferenceTemperatureServices = [];
+                    for (let i = 0; i < sensorsReferenceTemperatureCount; i++) {
+                        const sensorName = this.sensorsName[i];
+                        const serviceName = this.sensorsNamePrefix ? `${accessoryName} ${sensorName} Reference Temperature` : `${sensorName} Reference Temperature`;
+                        const sensorReferenceTemperatureService = accessory.addService(Service.TemperatureSensor, serviceName, `Reference Temperature Sensor ${i}`);
+                        sensorReferenceTemperatureService.addOptionalCharacteristic(Characteristic.ConfiguredName);
+                        sensorReferenceTemperatureService.setCharacteristic(Characteristic.ConfiguredName, serviceName);
+                        sensorReferenceTemperatureService.getCharacteristic(Characteristic.CurrentTemperature)
+                            .onGet(async () => {
+                                const value = this.sensorsReferenceTemperature[i];
+                                const logInfo = this.disableLogInfo ? false : this.emit('info', `sensor: ${sensorName} reference temperature: ${value} °${this.tempUnit}`);
+                                return value;
+                            });
+                        this.sensorReferenceTemperatureServices.push(sensorReferenceTemperatureService);
+                    }
+                }
+
+                //object temperature
+                const sensorsObjTemperatureCount = this.sensorsObjTemperatureCount;
+                if (sensorsObjTemperatureCount > 0) {
+                    const debug = this.enableDebugMode ? this.emit('debug', `Prepare Obj Temperature Sensor Services`) : false;
+                    this.sensorObjTemperatureServices = [];
+                    for (let i = 0; i < sensorsObjTemperatureCount; i++) {
+                        const sensorName = this.sensorsName[i];
+                        const serviceName = this.sensorsNamePrefix ? `${accessoryName} ${sensorName} Obj Temperature` : `${sensorName} Obj Temperature`;
+                        const sensorObjTemperatureService = accessory.addService(Service.TemperatureSensor, serviceName, `Obj Temperature Sensor ${i}`);
+                        sensorObjTemperatureService.addOptionalCharacteristic(Characteristic.ConfiguredName);
+                        sensorObjTemperatureService.setCharacteristic(Characteristic.ConfiguredName, serviceName);
+                        sensorObjTemperatureService.getCharacteristic(Characteristic.CurrentTemperature)
+                            .onGet(async () => {
+                                const value = this.sensorsObjTemperature[i];
+                                const logInfo = this.disableLogInfo ? false : this.emit('info', `sensor: ${sensorName} obj temperature: ${value} °${this.tempUnit}`);
+                                return value;
+                            });
+                        this.sensorObjTemperatureServices.push(sensorObjTemperatureService);
+                    }
+                }
+
+                //ambient temperature
+                const sensorsAmbTemperatureCount = this.sensorsAmbTemperatureCount;
+                if (sensorsAmbTemperatureCount > 0) {
+                    const debug = this.enableDebugMode ? this.emit('debug', `Prepare Amb Temperature Sensor Services`) : false;
+                    this.sensorAmbTemperatureServices = [];
+                    for (let i = 0; i < sensorsAmbTemperatureCount; i++) {
+                        const sensorName = this.sensorsName[i];
+                        const serviceName = this.sensorsNamePrefix ? `${accessoryName} ${sensorName} Amb Temperature` : `${sensorName} Amb Temperature`;
+                        const sensorAmbTemperatureService = accessory.addService(Service.TemperatureSensor, serviceName, `Amb Temperature Sensor ${i}`);
+                        sensorAmbTemperatureService.addOptionalCharacteristic(Characteristic.ConfiguredName);
+                        sensorAmbTemperatureService.setCharacteristic(Characteristic.ConfiguredName, serviceName);
+                        sensorAmbTemperatureService.getCharacteristic(Characteristic.CurrentTemperature)
+                            .onGet(async () => {
+                                const value = this.sensorsAmbTemperature[i];
+                                const logInfo = this.disableLogInfo ? false : this.emit('info', `sensor: ${sensorName} amb temperature: ${value} °${this.tempUnit}`);
+                                return value;
+                            });
+                        this.sensorAmbTemperatureServices.push(sensorAmbTemperatureService);
+                    }
+                }
+
+                //dew point temperature
+                const sensorsDewPointTemperatureCount = this.sensorsDewPointTemperatureCount;
+                if (sensorsDewPointTemperatureCount > 0) {
+                    const debug = this.enableDebugMode ? this.emit('debug', `Prepare Dew Point Temperature Sensor Services`) : false;
+                    this.sensorDewPointTemperatureServices = [];
+                    for (let i = 0; i < sensorsDewPointTemperatureCount; i++) {
+                        const sensorName = this.sensorsName[i];
+                        const serviceName = this.sensorsNamePrefix ? `${accessoryName} ${sensorName} Dew Point` : `${sensorName} Dew Point`;
+                        const sensorDewPointTemperatureService = accessory.addService(Service.TemperatureSensor, serviceName, `Dew Point Temperature Sensor ${i}`);
+                        sensorDewPointTemperatureService.addOptionalCharacteristic(Characteristic.ConfiguredName);
+                        sensorDewPointTemperatureService.setCharacteristic(Characteristic.ConfiguredName, serviceName);
+                        sensorDewPointTemperatureService.getCharacteristic(Characteristic.CurrentTemperature)
+                            .onGet(async () => {
+                                const value = this.sensorsDewPointTemperature[i];
+                                const logInfo = this.disableLogInfo ? false : this.emit('info', `sensor: ${sensorName} dew point: ${value} °${this.tempUnit}`);
+                                return value;
+                            });
+                        this.sensorDewPointTemperatureServices.push(sensorDewPointTemperatureService);
+                    }
+                }
+
+                //humidity
+                const sensorsHumidityCount = this.sensorsHumidityCount;
+                if (sensorsHumidityCount > 0) {
+                    const debug = this.enableDebugMode ? this.emit('debug', `Prepare Humidity Sensor Services`) : false;
+                    this.sensorHumidityServices = [];
+                    for (let i = 0; i < sensorsHumidityCount; i++) {
+                        const sensorName = this.sensorsName[i];
+                        const serviceName = this.sensorsNamePrefix ? `${accessoryName} ${sensorName} Humidity` : `${sensorName} Humidity`;
+                        const sensorHumidityService = accessory.addService(Service.HumiditySensor, serviceName, `Humidity Sensor ${i}`);
+                        sensorHumidityService.addOptionalCharacteristic(Characteristic.ConfiguredName);
+                        sensorHumidityService.setCharacteristic(Characteristic.ConfiguredName, serviceName);
+                        sensorHumidityService.getCharacteristic(Characteristic.CurrentRelativeHumidity)
+                            .onGet(async () => {
+                                const value = this.sensorsHumidity[i];
+                                const logInfo = this.disableLogInfo ? false : this.emit('info', `sensor: ${sensorName} humidity: ${value} %`);
+                                return value;
+                            });
+                        this.sensorHumidityServices.push(sensorHumidityService);
+                    }
+                }
+
+                //pressure
+
+                //gas
+
+                //carbon dioxyde
+                const sensorsCarbonDioxydeCount = this.sensorsCarbonDioxydeCount;
+                if (sensorsCarbonDioxydeCount > 0) {
+                    const debug = this.enableDebugMode ? this.emit('debug', `Prepare Carbon Dioxyde Sensor Services`) : false;
+                    this.sensorCarbonDioxydeServices = [];
+                    for (let i = 0; i < sensorsCarbonDioxydeCount; i++) {
+                        const sensorName = this.sensorsName[i];
+                        const serviceName = this.sensorsNamePrefix ? `${accessoryName} ${sensorName} Carbon Dioxyde` : `${sensorName} Carbon Dioxyde`;
+                        const sensorCarbonDioxydeService = accessory.addService(Service.CarbonDioxideSensor, serviceName, `Carbon Dioxyde Sensor ${i}`);
+                        sensorCarbonDioxydeService.addOptionalCharacteristic(Characteristic.ConfiguredName);
+                        sensorCarbonDioxydeService.setCharacteristic(Characteristic.ConfiguredName, serviceName);
+                        sensorCarbonDioxydeService.getCharacteristic(Characteristic.CarbonDioxideDetected)
+                            .onGet(async () => {
+                                const state = this.sensorsCarbonDioxyde[i] > 1000;
+                                const logInfo = this.disableLogInfo ? false : this.emit('info', `sensor: ${sensorName} carbon dioxyde detected: ${state ? 'Yes' : 'No'}`);
+                                return state;
+                            });
+                        sensorCarbonDioxydeService.getCharacteristic(Characteristic.CarbonDioxideLevel)
+                            .onGet(async () => {
+                                const value = this.sensorsCarbonDioxyde[i];
+                                const logInfo = this.disableLogInfo ? false : this.emit('info', `sensor: ${sensorName} carbon dioxyde level: ${value} ppm`);
+                                return value;
+                            });
+                        sensorCarbonDioxydeService.getCharacteristic(Characteristic.CarbonDioxidePeakLevel)
+                            .onGet(async () => {
+                                const value = this.sensorsCarbonDioxyde[i];
+                                const logInfo = this.disableLogInfo ? false : this.emit('info', `sensor: ${sensorName} carbon dioxyde peak level: ${value} ppm`);
+                                return value;
+                            });
+                        this.sensorCarbonDioxydeServices.push(sensorCarbonDioxydeService);
+                    }
+                }
+
+                //ambient light
+                const sensorsAmbientLightCount = this.sensorsAmbientLightCount;
+                if (sensorsAmbientLightCount > 0) {
+                    const debug = this.enableDebugMode ? this.emit('debug', `Prepare Ambient Light Sensor Services`) : false;
+                    this.sensorAmbientLightServices = [];
+                    for (let i = 0; i < sensorsAmbientLightCount; i++) {
+                        const sensorName = this.sensorsName[i];
+                        const serviceName = this.sensorsNamePrefix ? `${accessoryName} ${sensorName} Ambient Light` : `${sensorName} Ambient Light`;
+                        const sensorAmbientLightService = accessory.addService(Service.LightSensor, serviceName, `Ambient Light Sensor ${i}`);
+                        sensorAmbientLightService.addOptionalCharacteristic(Characteristic.ConfiguredName);
+                        sensorAmbientLightService.setCharacteristic(Characteristic.ConfiguredName, serviceName);
+                        sensorAmbientLightService.getCharacteristic(Characteristic.CurrentAmbientLightLevel)
+                            .onGet(async () => {
+                                const value = this.sensorsAmbientLight[i];
+                                const logInfo = this.disableLogInfo ? false : this.emit('info', `sensor: ${sensorName} ambient light: ${value} lx`);
+                                return value;
+                            });
+                        this.sensorAmbientLightServices.push(sensorAmbientLightService);
+                    }
+                }
+
+                //motion
+                const sensorsMotionCount = this.sensorsMotionCount;
+                if (sensorsMotionCount > 0) {
+                    const debug = this.enableDebugMode ? this.emit('debug', `Prepare Motion Sensor Services`) : false;
+                    this.sensorMotionServices = [];
+                    for (let i = 0; i < sensorsMotionCount; i++) {
+                        const sensorName = this.sensorsName[i];
+                        const serviceName = this.sensorsNamePrefix ? `${accessoryName} ${sensorName} Motion` : `${sensorName} Motion`;
+                        const sensorMotionService = accessory.addService(Service.MotionSensor, serviceName, `Motion Sensor ${i}`);
+                        sensorMotionService.addOptionalCharacteristic(Characteristic.ConfiguredName);
+                        sensorMotionService.setCharacteristic(Characteristic.ConfiguredName, serviceName);
+                        sensorMotionService.getCharacteristic(Characteristic.MotionDetected)
+                            .onGet(async () => {
+                                const state = this.sensorsMotion[i];
+                                const logInfo = this.disableLogInfo ? false : this.emit('info', `sensor: ${sensorName} motion: ${state ? 'ON' : 'OFF'}`);
+                                return state;
+                            });
+                        this.sensorMotionServices.push(sensorMotionService);
+                    }
+                }
+            }
+
             return accessory;
         } catch (error) {
             throw new Error(`Prepare accessory error: ${error}`)