homebridge-tasmota-control 1.6.1-beta.1 → 1.6.1-beta.11

package/package.json

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

package/src/sensors.js

@@ -94,14 +94,14 @@ class Sensors extends EventEmitter {
                         return obj;
                     }, {});
 
+                let i = 0;
                 for (const [key, value] of Object.entries(sensorData)) {
                     const sensorData = value;
 
-                    //sensor
                     const obj = {
                         name: key,
                         time: statusSns.Time,
-                        tempUnit: statusSns.TempUnit,
+                        tempUnit: statusSns.TempUnit === 'C' ? '°C' : statusSns.TempUnit,
                         pressureUnit: statusSns.PressureUnit,
                         temperature: sensorData.Temperature,
                         referenceTemperature: sensorData.ReferenceTemperature,
@@ -115,12 +115,8 @@ class Sensors extends EventEmitter {
                         ambientLight: sensorData.Ambient,
                         motion: sensorData.Motion
                     };
-                    if (obj.tempUnit === 'C') {
-                        obj.tempUnit = '°C';
-                    }
 
-                    //energy
-                    const obj1 = {
+                    const energy = {
                         power: sensorData.Power,
                         apparentPower: sensorData.ApparentPower,
                         reactivePower: sensorData.ReactivePower,
@@ -135,73 +131,60 @@ class Sensors extends EventEmitter {
                         frequency: sensorData.Frequency,
                         load: sensorData.Load,
                     };
-                    const sensor = key === 'ENERGY' ? { ...obj, ...obj1 } : obj;
-                    const debug1 = this.enableDebugMode ? this.emit('debug', `Sensor: ${JSON.stringify(sensor, null, 2)}`) : false;
 
-                    //push to array
+                    const sensor = key === 'ENERGY' ? { ...obj, ...energy } : obj;
+                    const debug1 = this.enableDebugMode ? this.emit('debug', `Sensor: ${JSON.stringify(sensor, null, 2)}`) : false;
                     this.sensors.push(sensor);
-                }
-                this.sensorsCount = this.sensors.length;
 
-                //update characteristics
-                if (this.sensorsCount > 0) {
-                    for (let i = 0; i < this.sensorsCount; i++) {
-                        const sensor = this.sensors[i];
-
-                        const update = (service, charName, value) => {
-                            const characteristic = service?.[i]?.Characteristic?.[charName];
-                            if (characteristic && Characteristic?.[charName]) {
-                                characteristic.updateCharacteristic(Characteristic[charName], value);
+                    //update characteristics
+                    if (this.sensorServices?.[i]) {
+                        const update = (service, subtype, charName, value) => {
+                            const serviceExist = service?.subtype === subtype;
+                             const characteristic = service?.Characteristic?.[charName];
+                            if (serviceExist && characteristic) {
+                                service.updateCharacteristic(Characteristic[charName], value);
                             }
                         };
 
-                        //temperature
-                        update(this.sensorTemperatureServices, 'CurrentTemperature', sensor.temperature);
-                        update(this.sensorReferenceTemperatureServices, 'CurrentTemperature', sensor.referenceTemperature);
-                        update(this.sensorObjTemperatureServices, 'CurrentTemperature', sensor.objTemperature);
-                        update(this.sensorAmbTemperatureServices, 'CurrentTemperature', sensor.ambTemperature);
-                        update(this.sensorDewPointTemperatureServices, 'CurrentTemperature', sensor.dewPointTemperature);
-
-                        //humidity
-                        update(this.sensorHumidityServices, 'CurrentRelativeHumidity', sensor.humidity);
-
-                        //co₂
-                        const co2Service = this.sensorCarbonDioxydeServices?.[i];
-                        update(this.sensorCarbonDioxydeServices, 'CarbonDioxideDetected', sensor.carbonDioxyde > 1000);
-                        update(this.sensorCarbonDioxydeServices, 'CarbonDioxideLevel', sensor.carbonDioxyde);
-                        update(this.sensorCarbonDioxydeServices, 'CarbonDioxidePeakLevel', sensor.carbonDioxyde);
-
-                        //ambient light
-                        update(this.sensorAmbientLightServices, 'CurrentAmbientLightLevel', sensor.ambientLight);
-
-                        //motion
-                        update(this.sensorMotionServices, 'MotionDetected', sensor.motion);
-
-                        //energy
-                        const energyFields = {
-                            Power: 'power',
-                            ApparentPower: 'apparentpower',
-                            ReactivePower: 'reactivepower',
-                            EnergyToday: 'energytoday',
-                            EnergyLastDay: 'energylastday',
-                            EnergyLifetime: 'energylifetime',
-                            Current: 'current',
-                            Voltage: 'voltage',
-                            Factor: 'factor',
-                            Frequency: 'frequency',
-                            ReadingTime: 'readingtime'
-                        };
-
-                        const energyService = this.sensorEnergyServices?.[i]?.Characteristic;
-                        for (const [charName, sensorKey] of Object.entries(energyFields)) {
-                            const value = sensor[sensorKey];
-                            if (energyService?.[charName] && Characteristic?.[charName] !== undefined) {
-                                energyService[charName].updateCharacteristic(Characteristic[charName], value);
-                            }
-                        }
+                        // temperature
+                        update(this.sensorServices[i], `sensorTemperatureService${i}`, 'CurrentTemperature', sensor.temperature);
+                        update(this.sensorServices[i], `sensorReferenceTemperatureService${i}`, 'CurrentTemperature', sensor.referenceTemperature);
+                        update(this.sensorServices[i], `sensorObjTemperatureService${i}`, 'CurrentTemperature', sensor.objTemperature);
+                        update(this.sensorServices[i], `sensorAmbTemperatureService${i}`, 'CurrentTemperature', sensor.ambTemperature);
+                        update(this.sensorServices[i], `sensorDewPointTemperatureService${i}`, 'CurrentTemperature', sensor.dewPointTemperature);
+
+                        // humidity
+                        update(this.sensorServices[i], `sensorHumidityService${i}`, 'CurrentRelativeHumidity', sensor.humidity);
+
+                        // CO₂
+                        update(this.sensorServices[i], `sensorCarbonDioxydeService${i}`, 'CarbonDioxideDetected', sensor.carbonDioxyde > 1000);
+                        update(this.sensorServices[i], `sensorCarbonDioxydeService${i}`, 'CarbonDioxideLevel', sensor.carbonDioxyde);
+                        update(this.sensorServices[i], `sensorCarbonDioxydeService${i}`, 'CarbonDioxidePeakLevel', sensor.carbonDioxyde);
+
+                        // ambient light
+                        update(this.sensorServices[i], `sensorAmbientLightService${i}`, 'CurrentAmbientLightLevel', sensor.ambientLight);
+
+                        // motion
+                        update(this.sensorServices[i], `sensorMotionService${i}`, 'MotionDetected', sensor.motion);
+
+                        // energy
+                        update(this.sensorServices[i], `sensorEnergyService${i}`, 'Power', sensor.power);
+                        update(this.sensorServices[i], `sensorEnergyService${i}`, 'ApparentPower', sensor.apparentPower);
+                        update(this.sensorServices[i], `sensorEnergyService${i}`, 'ReactivePower', sensor.reactivePower);
+                        update(this.sensorServices[i], `sensorEnergyService${i}`, 'EnergyToday', sensor.energyToday);
+                        update(this.sensorServices[i], `sensorEnergyService${i}`, 'EnergyLastDay', sensor.energyLastDay);
+                        update(this.sensorServices[i], `sensorEnergyService${i}`, 'EnergyLifetime', sensor.energyLifetime);
+                        update(this.sensorServices[i], `sensorEnergyService${i}`, 'Current', sensor.current);
+                        update(this.sensorServices[i], `sensorEnergyService${i}`, 'Voltage', sensor.voltage);
+                        update(this.sensorServices[i], `sensorEnergyService${i}`, 'Factor', sensor.factor);
+                        update(this.sensorServices[i], `sensorEnergyService${i}`, 'Frequency', sensor.frequency);
+                        update(this.sensorServices[i], `sensorEnergyService${i}`, 'ReadingTime', sensor.time);
+
+                        i++;
                     }
                 }
             }
+            this.sensorsCount = this.sensors.length;
 
             return true;
         } catch (error) {
@@ -274,25 +257,17 @@ class Sensors extends EventEmitter {
             //Prepare services 
             if (this.sensorsCount > 0) {
                 const debug = this.enableDebugMode ? this.emit('debug', `Prepare Sensor Services`) : false;
-                this.sensorTemperatureServices = [];
-                this.sensorReferenceTemperatureServices = [];
-                this.sensorObjTemperatureServices = [];
-                this.sensorAmbTemperatureServices = [];
-                this.sensorDewPointTemperatureServices = [];
-                this.sensorHumidityServices = [];
-                this.sensorCarbonDioxydeServices = [];
-                this.sensorAmbientLightServices = [];
-                this.sensorMotionServices = [];
-                this.sensorEnergyServices = [];
+                this.sensorServices = [];
 
                 //temperature
                 let i = 0;
                 for (const sensor of this.sensors) {
                     const sensorName = sensor.name;
+                    const service = {};
                     if (sensor.temperature) {
                         const debug = this.enableDebugMode ? this.emit('debug', `Prepare Temperature Sensor Services`) : false;
                         const serviceName = this.sensorsNamePrefix ? `${accessoryName} ${sensorName} Temperature` : `${sensorName} Temperature`;
-                        const sensorTemperatureService = accessory.addService(Service.TemperatureSensor, serviceName, `Temperature Sensor ${i}`);
+                        const sensorTemperatureService = accessory.addService(Service.TemperatureSensor, serviceName, `sensorTemperatureService${i}`);
                         sensorTemperatureService.addOptionalCharacteristic(Characteristic.ConfiguredName);
                         sensorTemperatureService.setCharacteristic(Characteristic.ConfiguredName, serviceName);
                         sensorTemperatureService.getCharacteristic(Characteristic.CurrentTemperature)
@@ -301,14 +276,14 @@ class Sensors extends EventEmitter {
                                 const logInfo = this.disableLogInfo ? false : this.emit('info', `sensor: ${sensorName} temperature: ${value} °${sensor.tempUnit}`);
                                 return value;
                             });
-                        this.sensorTemperatureServices.push(sensorTemperatureService);
+                        service.sensorTemperatureService = sensorTemperatureService;
                     }
 
                     //reference temperature
                     if (sensor.referenceTemperature) {
                         const debug = this.enableDebugMode ? this.emit('debug', `Prepare Reference Temperature Sensor Services`) : false;
                         const serviceName = this.sensorsNamePrefix ? `${accessoryName} ${sensorName} Reference Temperature` : `${sensorName} Reference Temperature`;
-                        const sensorReferenceTemperatureService = accessory.addService(Service.TemperatureSensor, serviceName, `Reference Temperature Sensor ${i}`);
+                        const sensorReferenceTemperatureService = accessory.addService(Service.TemperatureSensor, serviceName, `sensorReferenceTemperatureService${i}`);
                         sensorReferenceTemperatureService.addOptionalCharacteristic(Characteristic.ConfiguredName);
                         sensorReferenceTemperatureService.setCharacteristic(Characteristic.ConfiguredName, serviceName);
                         sensorReferenceTemperatureService.getCharacteristic(Characteristic.CurrentTemperature)
@@ -317,14 +292,14 @@ class Sensors extends EventEmitter {
                                 const logInfo = this.disableLogInfo ? false : this.emit('info', `sensor: ${sensorName} reference temperature: ${value} °${sensor.tempUnit}`);
                                 return value;
                             });
-                        this.sensorReferenceTemperatureServices.push(sensorReferenceTemperatureService);
+                        service.sensorReferenceTemperatureService = sensorReferenceTemperatureService;
                     }
 
                     //object temperature
                     if (sensor.objTemperature) {
                         const debug = this.enableDebugMode ? this.emit('debug', `Prepare Obj Temperature Sensor Services`) : false;
                         const serviceName = this.sensorsNamePrefix ? `${accessoryName} ${sensorName} Obj Temperature` : `${sensorName} Obj Temperature`;
-                        const sensorObjTemperatureService = accessory.addService(Service.TemperatureSensor, serviceName, `Obj Temperature Sensor ${i}`);
+                        const sensorObjTemperatureService = accessory.addService(Service.TemperatureSensor, serviceName, `sensorObjTemperatureService${i}`);
                         sensorObjTemperatureService.addOptionalCharacteristic(Characteristic.ConfiguredName);
                         sensorObjTemperatureService.setCharacteristic(Characteristic.ConfiguredName, serviceName);
                         sensorObjTemperatureService.getCharacteristic(Characteristic.CurrentTemperature)
@@ -333,14 +308,14 @@ class Sensors extends EventEmitter {
                                 const logInfo = this.disableLogInfo ? false : this.emit('info', `sensor: ${sensorName} obj temperature: ${value} °${sensor.tempUnit}`);
                                 return value;
                             });
-                        this.sensorObjTemperatureServices.push(sensorObjTemperatureService);
+                        service.sensorObjTemperatureService = sensorObjTemperatureService;
                     }
 
                     //ambient temperature
                     if (sensor.ambTemperature) {
                         const debug = this.enableDebugMode ? this.emit('debug', `Prepare Amb Temperature Sensor Services`) : false;
                         const serviceName = this.sensorsNamePrefix ? `${accessoryName} ${sensorName} Amb Temperature` : `${sensorName} Amb Temperature`;
-                        const sensorAmbTemperatureService = accessory.addService(Service.TemperatureSensor, serviceName, `Amb Temperature Sensor ${i}`);
+                        const sensorAmbTemperatureService = accessory.addService(Service.TemperatureSensor, serviceName, `sensorAmbTemperatureService${i}`);
                         sensorAmbTemperatureService.addOptionalCharacteristic(Characteristic.ConfiguredName);
                         sensorAmbTemperatureService.setCharacteristic(Characteristic.ConfiguredName, serviceName);
                         sensorAmbTemperatureService.getCharacteristic(Characteristic.CurrentTemperature)
@@ -349,14 +324,14 @@ class Sensors extends EventEmitter {
                                 const logInfo = this.disableLogInfo ? false : this.emit('info', `sensor: ${sensorName} amb temperature: ${value} °${sensor.tempUnit}`);
                                 return value;
                             });
-                        this.sensorAmbTemperatureServices.push(sensorAmbTemperatureService);
+                        service.sensorAmbTemperatureService = sensorAmbTemperatureService;
                     }
 
                     //dew point temperature
                     if (sensor.dewPointTemperature) {
                         const debug = this.enableDebugMode ? this.emit('debug', `Prepare Dew Point Temperature Sensor Services`) : false;
                         const serviceName = this.sensorsNamePrefix ? `${accessoryName} ${sensorName} Dew Point` : `${sensorName} Dew Point`;
-                        const sensorDewPointTemperatureService = accessory.addService(Service.TemperatureSensor, serviceName, `Dew Point Temperature Sensor ${i}`);
+                        const sensorDewPointTemperatureService = accessory.addService(Service.TemperatureSensor, serviceName, `sensorDewPointTemperatureService${i}`);
                         sensorDewPointTemperatureService.addOptionalCharacteristic(Characteristic.ConfiguredName);
                         sensorDewPointTemperatureService.setCharacteristic(Characteristic.ConfiguredName, serviceName);
                         sensorDewPointTemperatureService.getCharacteristic(Characteristic.CurrentTemperature)
@@ -365,14 +340,14 @@ class Sensors extends EventEmitter {
                                 const logInfo = this.disableLogInfo ? false : this.emit('info', `sensor: ${sensorName} dew point: ${value} °${sensor.tempUnit}`);
                                 return value;
                             });
-                        this.sensorDewPointTemperatureServices.push(sensorDewPointTemperatureService);
+                        service.sensorDewPointTemperatureService = sensorDewPointTemperatureService;
                     }
 
                     //humidity
                     if (sensor.humidity) {
                         const debug = this.enableDebugMode ? this.emit('debug', `Prepare Humidity Sensor Services`) : false;
                         const serviceName = this.sensorsNamePrefix ? `${accessoryName} ${sensorName} Humidity` : `${sensorName} Humidity`;
-                        const sensorHumidityService = accessory.addService(Service.HumiditySensor, serviceName, `Humidity Sensor ${i}`);
+                        const sensorHumidityService = accessory.addService(Service.HumiditySensor, serviceName, `sensorHumidityService${i}`);
                         sensorHumidityService.addOptionalCharacteristic(Characteristic.ConfiguredName);
                         sensorHumidityService.setCharacteristic(Characteristic.ConfiguredName, serviceName);
                         sensorHumidityService.getCharacteristic(Characteristic.CurrentRelativeHumidity)
@@ -381,7 +356,7 @@ class Sensors extends EventEmitter {
                                 const logInfo = this.disableLogInfo ? false : this.emit('info', `sensor: ${sensorName} humidity: ${value} %`);
                                 return value;
                             });
-                        this.sensorHumidityServices.push(sensorHumidityService);
+                        service.sensorHumidityService = sensorHumidityService;
                     }
 
                     //pressure
@@ -392,7 +367,7 @@ class Sensors extends EventEmitter {
                     if (sensor.carbonDioxyde) {
                         const debug = this.enableDebugMode ? this.emit('debug', `Prepare Carbon Dioxyde Sensor Services`) : false;
                         const serviceName = this.sensorsNamePrefix ? `${accessoryName} ${sensorName} Carbon Dioxyde` : `${sensorName} Carbon Dioxyde`;
-                        const sensorCarbonDioxydeService = accessory.addService(Service.CarbonDioxideSensor, serviceName, `Carbon Dioxyde Sensor ${i}`);
+                        const sensorCarbonDioxydeService = accessory.addService(Service.CarbonDioxideSensor, serviceName, `sensorCarbonDioxydeService${i}`);
                         sensorCarbonDioxydeService.addOptionalCharacteristic(Characteristic.ConfiguredName);
                         sensorCarbonDioxydeService.setCharacteristic(Characteristic.ConfiguredName, serviceName);
                         sensorCarbonDioxydeService.getCharacteristic(Characteristic.CarbonDioxideDetected)
@@ -413,14 +388,14 @@ class Sensors extends EventEmitter {
                                 const logInfo = this.disableLogInfo ? false : this.emit('info', `sensor: ${sensorName} carbon dioxyde peak level: ${value} ppm`);
                                 return value;
                             });
-                        this.sensorCarbonDioxydeServices.push(sensorCarbonDioxydeService);
+                        service.sensorCarbonDioxydeService = sensorCarbonDioxydeService;
                     }
 
                     //ambient light
                     if (sensor.ambientLight) {
                         const debug = this.enableDebugMode ? this.emit('debug', `Prepare Ambient Light Sensor Services`) : false;
                         const serviceName = this.sensorsNamePrefix ? `${accessoryName} ${sensorName} Ambient Light` : `${sensorName} Ambient Light`;
-                        const sensorAmbientLightService = accessory.addService(Service.LightSensor, serviceName, `Ambient Light Sensor ${i}`);
+                        const sensorAmbientLightService = accessory.addService(Service.LightSensor, serviceName, `sensorAmbientLightService${i}`);
                         sensorAmbientLightService.addOptionalCharacteristic(Characteristic.ConfiguredName);
                         sensorAmbientLightService.setCharacteristic(Characteristic.ConfiguredName, serviceName);
                         sensorAmbientLightService.getCharacteristic(Characteristic.CurrentAmbientLightLevel)
@@ -429,14 +404,14 @@ class Sensors extends EventEmitter {
                                 const logInfo = this.disableLogInfo ? false : this.emit('info', `sensor: ${sensorName} ambient light: ${value} lx`);
                                 return value;
                             });
-                        this.sensorAmbientLightServices.push(sensorAmbientLightService);
+                        service.sensorAmbientLightService = sensorAmbientLightService;
                     }
 
                     //motion
                     if (sensor.motion) {
                         const debug = this.enableDebugMode ? this.emit('debug', `Prepare Motion Sensor Services`) : false;
                         const serviceName = this.sensorsNamePrefix ? `${accessoryName} ${sensorName} Motion` : `${sensorName} Motion`;
-                        const sensorMotionService = accessory.addService(Service.MotionSensor, serviceName, `Motion Sensor ${i}`);
+                        const sensorMotionService = accessory.addService(Service.MotionSensor, serviceName, `sensorMotionService${i}`);
                         sensorMotionService.addOptionalCharacteristic(Characteristic.ConfiguredName);
                         sensorMotionService.setCharacteristic(Characteristic.ConfiguredName, serviceName);
                         sensorMotionService.getCharacteristic(Characteristic.MotionDetected)
@@ -445,17 +420,17 @@ class Sensors extends EventEmitter {
                                 const logInfo = this.disableLogInfo ? false : this.emit('info', `sensor: ${sensorName} motion: ${state ? 'ON' : 'OFF'}`);
                                 return state;
                             });
-                        this.sensorMotionServices.push(sensorMotionService);
+                        service.sensorMotionService = sensorMotionService;
                     }
 
                     //energy
                     if (sensor.name === 'ENERGY') {
                         const debug4 = this.enableDebugMode ? this.emit('debug', `Prepare Power And Energy Service`) : false;
                         const serviceName = this.sensorsNamePrefix ? `${accessoryName} ${sensorName}` : `${sensorName}`;
-                        const energyService = accessory.addService(Service.PowerAndEnergyService, serviceName, `Energy Sensor ${i}`);
-                        energyService.setCharacteristic(Characteristic.ConfiguredName, serviceName);
+                        const sensorEnergyService = accessory.addService(Service.PowerAndEnergyService, serviceName, `sensorEnergyService${i}`);
+                        sensorEnergyService.setCharacteristic(Characteristic.ConfiguredName, serviceName);
                         if (sensor.power) {
-                            energyService.getCharacteristic(Characteristic.Power)
+                            sensorEnergyService.getCharacteristic(Characteristic.Power)
                                 .onGet(async () => {
                                     const value = sensor.power;
                                     const info = this.disableLogInfo ? false : this.emit('info', `sensor: ${sensorName} power: ${value} W`);
@@ -463,7 +438,7 @@ class Sensors extends EventEmitter {
                                 });
                         }
                         if (sensor.apparentPower) {
-                            energyService.getCharacteristic(Characteristic.ApparentPower)
+                            sensorEnergyService.getCharacteristic(Characteristic.ApparentPower)
                                 .onGet(async () => {
                                     const value = sensor.apparentPower;
                                     const info = this.disableLogInfo ? false : this.emit('info', `sensor: ${sensorName} apparent power: ${value} VA`);
@@ -471,7 +446,7 @@ class Sensors extends EventEmitter {
                                 });
                         }
                         if (sensor.reactivePower) {
-                            energyService.getCharacteristic(Characteristic.ReactivePower)
+                            sensorEnergyService.getCharacteristic(Characteristic.ReactivePower)
                                 .onGet(async () => {
                                     const value = sensor.reactivePower;
                                     const info = this.disableLogInfo ? false : this.emit('info', `sensor: ${sensorName} reactive power: ${value} VAr`);
@@ -479,7 +454,7 @@ class Sensors extends EventEmitter {
                                 });
                         }
                         if (sensor.energyToday) {
-                            energyService.getCharacteristic(Characteristic.EnergyToday)
+                            sensorEnergyService.getCharacteristic(Characteristic.EnergyToday)
                                 .onGet(async () => {
                                     const value = sensor.energyToday;
                                     const info = this.disableLogInfo ? false : this.emit('info', `sensor: ${sensorName} energy today: ${value} kWh`);
@@ -487,7 +462,7 @@ class Sensors extends EventEmitter {
                                 });
                         }
                         if (sensor.energyLastDay) {
-                            energyService.getCharacteristic(Characteristic.EnergyLastDay)
+                            sensorEnergyService.getCharacteristic(Characteristic.EnergyLastDay)
                                 .onGet(async () => {
                                     const value = sensor.energyLastDay;
                                     const info = this.disableLogInfo ? false : this.emit('info', `sensor: ${sensorName} energy last day: ${value} kWh`);
@@ -495,7 +470,7 @@ class Sensors extends EventEmitter {
                                 });
                         }
                         if (sensor.energyLifetime) {
-                            energyService.getCharacteristic(Characteristic.EnergyLifetime)
+                            sensorEnergyService.getCharacteristic(Characteristic.EnergyLifetime)
                                 .onGet(async () => {
                                     const value = sensor.energyLifetime;
                                     const info = this.disableLogInfo ? false : this.emit('info', `sensor: ${sensorName} energy lifetime: ${value} kWh`);
@@ -503,7 +478,7 @@ class Sensors extends EventEmitter {
                                 });
                         }
                         if (sensor.current) {
-                            energyService.getCharacteristic(Characteristic.Current)
+                            sensorEnergyService.getCharacteristic(Characteristic.Current)
                                 .onGet(async () => {
                                     const value = sensor.current;
                                     const info = this.disableLogInfo ? false : this.emit('info', `sensor: ${sensorName} current: ${value} A`);
@@ -511,7 +486,7 @@ class Sensors extends EventEmitter {
                                 });
                         }
                         if (sensor.voltage) {
-                            energyService.getCharacteristic(Characteristic.Voltage)
+                            sensorEnergyService.getCharacteristic(Characteristic.Voltage)
                                 .onGet(async () => {
                                     const value = sensor.voltage;
                                     const info = this.disableLogInfo ? false : this.emit('info', `sensor: ${sensorName} voltage: ${value} V`);
@@ -519,7 +494,7 @@ class Sensors extends EventEmitter {
                                 });
                         }
                         if (sensor.factor) {
-                            energyService.getCharacteristic(Characteristic.Factor)
+                            sensorEnergyService.getCharacteristic(Characteristic.Factor)
                                 .onGet(async () => {
                                     const value = sensor.factor;
                                     const info = this.disableLogInfo ? false : this.emit('info', `sensor: ${sensorName} power factor: ${value} cos φ`);
@@ -527,7 +502,7 @@ class Sensors extends EventEmitter {
                                 });
                         }
                         if (sensor.frequency) {
-                            energyService.getCharacteristic(Characteristic.Freqency)
+                            sensorEnergyService.getCharacteristic(Characteristic.Freqency)
                                 .onGet(async () => {
                                     const value = sensor.frequency;
                                     const info = this.disableLogInfo ? false : this.emit('info', `sensor: ${sensorName} frequency: ${value} Hz`);
@@ -535,15 +510,16 @@ class Sensors extends EventEmitter {
                                 });
                         }
                         if (sensor.time) {
-                            energyService.getCharacteristic(Characteristic.ReadingTime)
+                            sensorEnergyService.getCharacteristic(Characteristic.ReadingTime)
                                 .onGet(async () => {
                                     const value = sensor.time;
                                     const info = this.disableLogInfo ? false : this.emit('info', `sensor: ${sensorName} last report: ${value}`);
                                     return value;
                                 });
                         }
-                        this.sensorEnergyServices.push(energyService);
+                        service.sensorEnergyService = sensorEnergyService;
                     }
+                    this.sensorServices.push(service);
                     i++;
                 }
             }