homebridge-tasmota-control 1.5.1-beta.17 → 1.5.1-beta.19

package/index.js

@@ -8,6 +8,7 @@ import Fans from './src/fans.js';
 import Sensors from './src/sensors.js';
 import ImpulseGenerator from './src/impulsegenerator.js';
 import { PluginName, PlatformName } from './src/constants.js';
+import CustomCharacteristics from './src/customcharacteristics.js';
 
 class tasmotaPlatform {
   constructor(log, config, api) {
@@ -89,9 +90,6 @@ class tasmotaPlatform {
           let i = 0;
           for (const type of info.deviceTypes) {
             const serialNumber = i === 0 ? info.serialNumber : `${info.serialNumber}${i}`;
-            if (type === 4 && info.sensorName === 'ENERGY') {
-              continue;
-            }
 
             let deviceType;
             switch (type) {
@@ -192,5 +190,6 @@ class tasmotaPlatform {
 }
 
 export default (api) => {
+  CustomCharacteristics(api);
   api.registerPlatform(PluginName, PlatformName, tasmotaPlatform);
 }

package/package.json

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

package/src/customcharacteristics.js

@@ -0,0 +1,198 @@
+export default (api) => {
+    const { Service, Characteristic, Units, Formats, Perms } = api.hap;
+
+    //Envoy production/consumption characteristics
+    class Power extends Characteristic {
+        constructor() {
+            super('Power', '00000071-000B-1000-8000-0026BB765291');
+            this.setProps({
+                format: Formats.FLOAT,
+                unit: 'W',
+                maxValue: 10000,
+                minValue: -10000,
+                minStep: 0.001,
+                perms: [Perms.PAIRED_READ, Perms.NOTIFY]
+            });
+            this.value = this.getDefaultValue();
+        }
+    }
+    Characteristic.Power = Power;
+
+    class ApparentPower extends Characteristic {
+        constructor() {
+            super('Apparent power', '00000072-000B-1000-8000-0026BB765291');
+            this.setProps({
+                format: Formats.FLOAT,
+                unit: 'VA',
+                maxValue: 10000,
+                minValue: -10000,
+                minStep: 0.001,
+                perms: [Perms.PAIRED_READ, Perms.NOTIFY]
+            });
+            this.value = this.getDefaultValue();
+        }
+    }
+    Characteristic.ApparentPower = ApparentPower;
+
+    class ReactivePower extends Characteristic {
+        constructor() {
+            super('Reactive power', '00000073-000B-1000-8000-0026BB765291');
+            this.setProps({
+                format: Formats.FLOAT,
+                unit: 'VAr',
+                maxValue: 10000,
+                minValue: -10000,
+                minStep: 0.001,
+                perms: [Perms.PAIRED_READ, Perms.NOTIFY]
+            });
+            this.value = this.getDefaultValue();
+        }
+    }
+    Characteristic.ReactivePower = ReactivePower;
+
+    class EnergyToday extends Characteristic {
+        constructor() {
+            super('Energy today', '00000074-000B-1000-8000-0026BB765291');
+            this.setProps({
+                format: Formats.FLOAT,
+                unit: 'kWh',
+                maxValue: 1000,
+                minValue: -1000,
+                minStep: 0.001,
+                perms: [Perms.PAIRED_READ, Perms.NOTIFY]
+            });
+            this.value = this.getDefaultValue();
+        }
+    }
+    Characteristic.EnergyToday = EnergyToday;
+
+    class EnergyLastDay extends Characteristic {
+        constructor() {
+            super('Energy last day', '00000075-000B-1000-8000-0026BB765291');
+            this.setProps({
+                format: Formats.FLOAT,
+                unit: 'kWh',
+                maxValue: 1000,
+                minValue: -1000,
+                minStep: 0.001,
+                perms: [Perms.PAIRED_READ, Perms.NOTIFY]
+            });
+            this.value = this.getDefaultValue();
+        }
+    }
+    Characteristic.EnergyLastDay = EnergyLastDay;
+
+    class EnergyLifetime extends Characteristic {
+        constructor() {
+            super('Energy lifetime', '00000076-000B-1000-8000-0026BB765291');
+            this.setProps({
+                format: Formats.FLOAT,
+                unit: 'kWh',
+                maxValue: 100000000,
+                minValue: -100000000,
+                minStep: 0.001,
+                perms: [Perms.PAIRED_READ, Perms.NOTIFY]
+            });
+            this.value = this.getDefaultValue();
+        }
+    }
+    Characteristic.EnergyLifetime = EnergyLifetime;
+
+    class Current extends Characteristic {
+        constructor() {
+            super('Current', '00000077-000B-1000-8000-0026BB765291');
+            this.setProps({
+                format: Formats.FLOAT,
+                unit: 'A',
+                maxValue: 1000,
+                minValue: -1000,
+                minStep: 0.001,
+                perms: [Perms.PAIRED_READ, Perms.NOTIFY]
+            });
+            this.value = this.getDefaultValue();
+        }
+    }
+    Characteristic.Current = Current;
+
+    class Voltage extends Characteristic {
+        constructor() {
+            super('Voltage', '00000078-000B-1000-8000-0026BB765291');
+            this.setProps({
+                format: Formats.FLOAT,
+                unit: 'V',
+                maxValue: 1000,
+                minValue: 0,
+                minStep: 0.1,
+                perms: [Perms.PAIRED_READ, Perms.NOTIFY]
+            });
+            this.value = this.getDefaultValue();
+        }
+    }
+    Characteristic.Voltage = Voltage;
+
+    class Factor extends Characteristic {
+        constructor() {
+            super('Power factor', '00000079-000B-1000-8000-0026BB765291');
+            this.setProps({
+                format: Formats.FLOAT,
+                unit: 'cos φ',
+                maxValue: 1,
+                minValue: -1,
+                minStep: 0.01,
+                perms: [Perms.PAIRED_READ, Perms.NOTIFY]
+            });
+            this.value = this.getDefaultValue();
+        }
+    }
+    Characteristic.Factor = Factor;
+
+    class Freqency extends Characteristic {
+        constructor() {
+            super('Frequency', '00000080-000B-1000-8000-0026BB765291');
+            this.setProps({
+                format: Formats.FLOAT,
+                unit: 'Hz',
+                maxValue: 100,
+                minValue: 0,
+                minStep: 0.01,
+                perms: [Perms.PAIRED_READ, Perms.NOTIFY]
+            });
+            this.value = this.getDefaultValue();
+        }
+    }
+    Characteristic.Freqency = Freqency;
+
+    class ReadingTime extends Characteristic {
+        constructor() {
+            super('Reading time', '00000081-000B-1000-8000-0026BB765291');
+            this.setProps({
+                format: Formats.STRING,
+                perms: [Perms.PAIRED_READ, Perms.NOTIFY]
+            });
+            this.value = this.getDefaultValue();
+        }
+    }
+    Characteristic.ReadingTime = ReadingTime;
+
+    //power production service
+    class PowerAndEnergyService extends Service {
+        constructor(displayName, subtype) {
+            super(displayName, '00000004-000A-1000-8000-0026BB765291', subtype);
+            // Mandatory Characteristics
+            this.addCharacteristic(Characteristic.Power)
+            // Optional Characteristics
+            this.addOptionalCharacteristic(Characteristic.ApparentPower);
+            this.addOptionalCharacteristic(Characteristic.ReactivePower);
+            this.addOptionalCharacteristic(Characteristic.EnergyToday);
+            this.addOptionalCharacteristic(Characteristic.EnergyLastDay);
+            this.addOptionalCharacteristic(Characteristic.EnergyLifetime);
+            this.addOptionalCharacteristic(Characteristic.Current);
+            this.addOptionalCharacteristic(Characteristic.Voltage);
+            this.addOptionalCharacteristic(Characteristic.Factor);
+            this.addOptionalCharacteristic(Characteristic.Freqency);
+            this.addOptionalCharacteristic(Characteristic.ReadingTime);
+            this.addOptionalCharacteristic(Characteristic.ConfiguredName);
+        }
+    }
+    Service.PowerAndEnergyService = PowerAndEnergyService;
+};

package/src/sensors.js

@@ -121,17 +121,18 @@ class Sensors extends EventEmitter {
 
                     //energy
                     const obj1 = {
-                        energyTotalStartTime: sensorData.TotalStartTime,
-                        energyTotal: sensorData.Total,
-                        energyPeriod: sensorData.Period,
-                        energyYesterday: sensorData.Yesterday,
-                        energyToday: sensorData.Today,
                         power: sensorData.Power,
                         apparentPower: sensorData.ApparentPower,
                         reactivePower: sensorData.ReactivePower,
-                        factor: sensorData.Factor,
-                        voltage: sensorData.Voltage,
+                        energyToday: sensorData.Today,
+                        energyLastDay: sensorData.Yesterday,
+                        energyLifetime: sensorData.Total,
+                        energyLifeTimeStartTime: sensorData.TotalStartTime,
+                        energyPeriod: sensorData.Period,
                         current: sensorData.Current,
+                        voltage: sensorData.Voltage,
+                        factor: sensorData.Factor,
+                        frequency: sensorData.Frequency,
                         load: sensorData.Load,
                     }
                     const sensor = key === 'ENERGY' ? { ...obj, ...obj1 } : obj;
@@ -146,18 +147,33 @@ class Sensors extends EventEmitter {
                 if (this.sensorsCount > 0) {
                     for (let i = 0; i < this.sensorsCount; i++) {
                         const sensor = this.sensors[i];
+
                         this.sensorTemperatureServices?.[i]?.updateCharacteristic(Characteristic.CurrentTemperature, sensor.temperature);
                         this.sensorReferenceTemperatureServices?.[i]?.updateCharacteristic(Characteristic.CurrentTemperature, sensor.referenceTemperature);
                         this.sensorObjTemperatureServices?.[i]?.updateCharacteristic(Characteristic.CurrentTemperature, sensor.objTemperature);
                         this.sensorAmbTemperatureServices?.[i]?.updateCharacteristic(Characteristic.CurrentTemperature, sensor.ambTemperature);
                         this.sensorDewPointTemperatureServices?.[i]?.updateCharacteristic(Characteristic.CurrentTemperature, sensor.dewPointTemperature);
                         this.sensorHumidityServices?.[i]?.updateCharacteristic(Characteristic.CurrentRelativeHumidity, sensor.humidity);
-                        this.sensorCarbonDioxydeServices?.[i]
-                            ?.updateCharacteristic(Characteristic.CarbonDioxideDetected, sensor.carbonDioxyde > 1000)
-                            .updateCharacteristic(Characteristic.CarbonDioxideLevel, sensor.carbonDioxyde)
-                            .updateCharacteristic(Characteristic.CarbonDioxidePeakLevel, sensor.carbonDioxyde);
+
+                        const co2Service = this.sensorCarbonDioxydeServices?.[i];
+                        co2Service?.updateCharacteristic(Characteristic.CarbonDioxideDetected, sensor.carbonDioxyde > 1000);
+                        co2Service?.updateCharacteristic(Characteristic.CarbonDioxideLevel, sensor.carbonDioxyde);
+                        co2Service?.updateCharacteristic(Characteristic.CarbonDioxidePeakLevel, sensor.carbonDioxyde);
+
                         this.sensorAmbientLightServices?.[i]?.updateCharacteristic(Characteristic.CurrentAmbientLightLevel, sensor.ambientLight);
                         this.sensorMotionServices?.[i]?.updateCharacteristic(Characteristic.MotionDetected, sensor.motion);
+
+
+                        //energy
+                        const fields = [
+                            'Power', 'ApparentPower', 'ReactivePower', 'EnergyToday', 'EnergyLastDay',
+                            'EnergyLifetime', 'Current', 'Voltage', 'Factor', 'Frequency', 'ReadingTime'
+                        ];
+                        const characteristic = this.sensorEnergyServices?.[i]?.Characteristic;
+                        for (const key of fields) {
+                            characteristic?.[key]?.updateCharacteristic(Characteristic[key], sensor[key.toLowerCase()]);
+                        }
+
                     }
                 }
             }
@@ -405,6 +421,103 @@ class Sensors extends EventEmitter {
                             });
                         this.sensorMotionServices.push(sensorMotionService);
                     }
+
+                    //energy
+                    if (sensor.name === 'ENERGY') {
+                        const debug4 = this.enableDebugMode ? this.emit('debug', `Prepare Power And Energy  Service`) : false;
+                        this.sensorEnergyServices = [];
+                        const energyService = accessory.addService(Service.PowerAndEnergyService, `Power And Energy`, 'energyService');
+                        energyService.setCharacteristic(Characteristic.ConfiguredName, `Power And Energy `);
+                        if (sensor.power) {
+                            energyService.getCharacteristic(Characteristic.Power)
+                                .onGet(async () => {
+                                    const value = sensor.power;
+                                    const info = this.disableLogInfo ? false : this.emit('info', ` power: ${value} W`);
+                                    return value;
+                                });
+                        }
+                        if (sensor.apparentPower) {
+                            energyService.getCharacteristic(Characteristic.ApparentPower)
+                                .onGet(async () => {
+                                    const value = sensor.apparentPower;
+                                    const info = this.disableLogInfo ? false : this.emit('info', ` apparent power: ${value} VA`);
+                                    return value;
+                                });
+                        }
+                        if (sensor.reactivePower) {
+                            energyService.getCharacteristic(Characteristic.ReactivePower)
+                                .onGet(async () => {
+                                    const value = sensor.reactivePower;
+                                    const info = this.disableLogInfo ? false : this.emit('info', ` reactive power: ${value} VAr`);
+                                    return value;
+                                });
+                        }
+                        if (sensor.energyToday) {
+                            energyService.getCharacteristic(Characteristic.EnergyToday)
+                                .onGet(async () => {
+                                    const value = sensor.energyToday;
+                                    const info = this.disableLogInfo ? false : this.emit('info', ` energy today: ${value} kWh`);
+                                    return value;
+                                });
+                        }
+                        if (sensor.energyLastDay) {
+                            energyService.getCharacteristic(Characteristic.EnergyLastDay)
+                                .onGet(async () => {
+                                    const value = sensor.energyLastDay;
+                                    const info = this.disableLogInfo ? false : this.emit('info', ` energy last seven days: ${value} kWh`);
+                                    return value;
+                                });
+                        }
+                        if (sensor.energyLifetime) {
+                            energyService.getCharacteristic(Characteristic.EnergyLifetime)
+                                .onGet(async () => {
+                                    const value = sensor.energyLifetime;
+                                    const info = this.disableLogInfo ? false : this.emit('info', ` energy lifetime: ${value} kWh`);
+                                    return value;
+                                });
+                        }
+                        if (sensor.current) {
+                            energyService.getCharacteristic(Characteristic.Current)
+                                .onGet(async () => {
+                                    const value = sensor.current;
+                                    const info = this.disableLogInfo ? false : this.emit('info', ` current: ${value} A`);
+                                    return value;
+                                });
+                        }
+                        if (sensor.voltage) {
+                            energyService.getCharacteristic(Characteristic.Voltage)
+                                .onGet(async () => {
+                                    const value = sensor.voltage;
+                                    const info = this.disableLogInfo ? false : this.emit('info', ` voltage: ${value} V`);
+                                    return value;
+                                });
+                        }
+                        if (sensor.factor) {
+                            energyService.getCharacteristic(Characteristic.Factor)
+                                .onGet(async () => {
+                                    const value = sensor.factor;
+                                    const info = this.disableLogInfo ? false : this.emit('info', ` power factor: ${value} cos φ`);
+                                    return value;
+                                });
+                        }
+                        if (sensor.frequency) {
+                            energyService.getCharacteristic(Characteristic.Freqency)
+                                .onGet(async () => {
+                                    const value = sensor.frequency;
+                                    const info = this.disableLogInfo ? false : this.emit('info', ` frequency: ${value} Hz`);
+                                    return value;
+                                });
+                        }
+                        if (sensor.time) {
+                            energyService.getCharacteristic(Characteristic.ReadingTime)
+                                .onGet(async () => {
+                                    const value = sensor.time;
+                                    const info = this.disableLogInfo ? false : this.emit('info', ` last report: ${value}`);
+                                    return value;
+                                });
+                        }
+                        this.sensorEnergyServices.push(energyService);
+                    }
                     i++;
                 }
             }