homebridge-tasmota-control 1.6.1-beta.2 → 1.6.1-beta.21

package/package.json

@@ -1,7 +1,7 @@
 {
   "displayName": "Tasmota Control",
   "name": "homebridge-tasmota-control",
-  "version": "1.6.1-beta.2",
+  "version": "1.6.1-beta.21",
   "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 === 'C' ? '°C' : statusSns.TempUnit,
+                        tempUnit: statusSns.TempUnit,
                         pressureUnit: statusSns.PressureUnit,
                         temperature: sensorData.Temperature,
                         referenceTemperature: sensorData.ReferenceTemperature,
@@ -114,9 +114,13 @@ class Sensors extends EventEmitter {
                         carbonDioxyde: sensorData.CarbonDioxyde,
                         ambientLight: sensorData.Ambient,
                         motion: sensorData.Motion
-                    };
+                    }
+                    if (obj.tempUnit === 'C') {
+                        obj.tempUnit = '°C';
+                    }
 
-                    const energy = {
+                    //energy
+                    const obj1 = {
                         power: sensorData.Power,
                         apparentPower: sensorData.ApparentPower,
                         reactivePower: sensorData.ReactivePower,
@@ -130,67 +134,46 @@ class Sensors extends EventEmitter {
                         factor: sensorData.Factor,
                         frequency: sensorData.Frequency,
                         load: sensorData.Load,
-                    };
-
-                    const sensor = key === 'ENERGY' ? { ...obj, ...energy } : obj;
+                    }
+                    const sensor = key === 'ENERGY' ? { ...obj, ...obj1 } : obj;
                     const debug1 = this.enableDebugMode ? this.emit('debug', `Sensor: ${JSON.stringify(sensor, null, 2)}`) : false;
 
+                    //push to array
                     this.sensors.push(sensor);
-
-                    //update characteristics
-                    const update = (servicesArray, expectedDisplayName, charName, value) => {
-                        const service = servicesArray?.[i];
-                        const characteristic = service?.Characteristic?.[charName];
-                        if (service?.displayName === expectedDisplayName && characteristic && Characteristic?.[charName]) {
-                            characteristic.updateCharacteristic(Characteristic[charName], value);
-                        }
-                    };
-
-                    const updates = [
-                        // Temperature
-                        { service: 'sensorTemperatureService', char: 'CurrentTemperature', key: 'temperature' },
-                        { service: 'sensorReferenceTemperatureService', char: 'CurrentTemperature', key: 'referenceTemperature' },
-                        { service: 'sensorObjTemperatureService', char: 'CurrentTemperature', key: 'objTemperature' },
-                        { service: 'sensorAmbTemperatureService', char: 'CurrentTemperature', key: 'ambTemperature' },
-                        { service: 'sensorDewPointTemperatureService', char: 'CurrentTemperature', key: 'dewPointTemperature' },
-
-                        // Humidity
-                        { service: 'sensorHumidityService', char: 'CurrentRelativeHumidity', key: 'humidity' },
-
-                        // CO₂
-                        { service: 'sensorCarbonDioxydeService', char: 'CarbonDioxideDetected', key: 'carbonDioxyde', transform: v => v > 1000 },
-                        { service: 'sensorCarbonDioxydeService', char: 'CarbonDioxideLevel', key: 'carbonDioxyde' },
-                        { service: 'sensorCarbonDioxydeService', char: 'CarbonDioxidePeakLevel', key: 'carbonDioxyde' },
-
-                        // Ambient Light
-                        { service: 'sensorAmbientLightService', char: 'CurrentAmbientLightLevel', key: 'ambientLight' },
-
-                        // Motion
-                        { service: 'sensorMotionService', char: 'MotionDetected', key: 'motion' },
-
-                        // Energy
-                        { service: 'sensorEnergyService', char: 'Power', key: 'power' },
-                        { service: 'sensorEnergyService', char: 'ApparentPower', key: 'apparentPower' },
-                        { service: 'sensorEnergyService', char: 'ReactivePower', key: 'reactivePower' },
-                        { service: 'sensorEnergyService', char: 'EnergyToday', key: 'energyToday' },
-                        { service: 'sensorEnergyService', char: 'EnergyLastDay', key: 'energyLastDay' },
-                        { service: 'sensorEnergyService', char: 'EnergyLifetime', key: 'energyLifetime' },
-                        { service: 'sensorEnergyService', char: 'Current', key: 'current' },
-                        { service: 'sensorEnergyService', char: 'Voltage', key: 'voltage' },
-                        { service: 'sensorEnergyService', char: 'Factor', key: 'factor' },
-                        { service: 'sensorEnergyService', char: 'Frequency', key: 'frequency' },
-                        { service: 'sensorEnergyService', char: 'ReadingTime', key: 'time' },
-                    ];
-
-                    for (const { service, char, key, transform } of updates) {
-                        const value = transform ? transform(sensor[key]) : sensor[key];
-                        update(this.sensorServices, `${service}${i}`, char, value);
+                }
+                this.sensorsCount = this.sensors.length;
+
+                //update characteristics
+                if (this.sensorsCount > 0) {
+                    for (let i = 0; i < this.sensorsCount; i++) {
+                        const sensor = this.sensors[i];
+                        this.sensorTemperatureServices?.[i]?.Characteristic?.CurrentTemperature?.updateCharacteristic(Characteristic.CurrentTemperature, sensor.temperature);
+                        this.sensorReferenceTemperatureServices?.[i]?.Characteristic?.CurrentTemperature?.updateCharacteristic(Characteristic.CurrentTemperature, sensor.referenceTemperature);
+                        this.sensorObjTemperatureServices?.[i]?.Characteristic?.CurrentTemperature?.updateCharacteristic(Characteristic.CurrentTemperature, sensor.objTemperature);
+                        this.sensorAmbTemperatureServices?.[i]?.Characteristic?.CurrentTemperature?.updateCharacteristic(Characteristic.CurrentTemperature, sensor.ambTemperature);
+                        this.sensorDewPointTemperatureServices?.[i]?.Characteristic?.CurrentTemperature?.updateCharacteristic(Characteristic.CurrentTemperature, sensor.dewPointTemperature);
+                        this.sensorHumidityServices?.[i]?.Characteristic?.CurrentRelativeHumidity?.updateCharacteristic(Characteristic.CurrentRelativeHumidity, sensor.humidity);
+                        this.sensorCarbonDioxydeServices?.[i]?.Characteristic?.CarbonDioxideDetected?.updateCharacteristic(Characteristic.CarbonDioxideDetected, sensor.carbonDioxyde > 1000);
+                        this.sensorCarbonDioxydeServices?.[i]?.Characteristic?.CarbonDioxideLevel?.updateCharacteristic(Characteristic.CarbonDioxideLevel, sensor.carbonDioxyde);
+                        this.sensorCarbonDioxydeServices?.[i]?.Characteristic?.CarbonDioxidePeakLevel?.updateCharacteristic(Characteristic.CarbonDioxidePeakLevel, sensor.carbonDioxyde);
+                        this.sensorAmbientLightServices?.[i]?.Characteristic?.CurrentAmbientLightLevel?.updateCharacteristic(Characteristic.CurrentAmbientLightLevel, sensor.ambientLight);
+                        this.sensorMotionServices?.[i]?.Characteristic?.MotionDetected?.updateCharacteristic(Characteristic.MotionDetected, sensor.motion);
+
+                        //energy
+                        this.sensorEnergyServices?.[i]?.Characteristic?.Power?.updateCharacteristic(Characteristic.Power, sensor.power);
+                        this.sensorEnergyServices?.[i]?.Characteristic?.ApparentPower?.updateCharacteristic(Characteristic.ApparentPower, sensor.apparentPower);
+                        this.sensorEnergyServices?.[i]?.Characteristic?.ReactivePower?.updateCharacteristic(Characteristic.ReactivePower, sensor.reactivePower);
+                        this.sensorEnergyServices?.[i]?.Characteristic?.EnergyToday?.updateCharacteristic(Characteristic.EnergyToday, sensor.energyToday);
+                        this.sensorEnergyServices?.[i]?.Characteristic?.EnergyLastDay?.updateCharacteristic(Characteristic.EnergyLastDay, sensor.energyLastDay);
+                        this.sensorEnergyServices?.[i]?.Characteristic?.EnergyLifetime?.updateCharacteristic(Characteristic.EnergyLifetime, sensor.energyLifetime);
+                        this.sensorEnergyServices?.[i]?.Characteristic?.Current?.updateCharacteristic(Characteristic.Current, sensor.current);
+                        this.sensorEnergyServices?.[i]?.Characteristic?.Voltage?.updateCharacteristic(Characteristic.Voltage, sensor.voltage);
+                        this.sensorEnergyServices?.[i]?.Characteristic?.Factor?.updateCharacteristic(Characteristic.Factor, sensor.factor);
+                        this.sensorEnergyServices?.[i]?.Characteristic?.Frequency?.updateCharacteristic(Characteristic.Frequency, sensor.frequency);
+                        this.sensorEnergyServices?.[i]?.Characteristic?.ReadingTime?.updateCharacteristic(Characteristic.ReadingTime, sensor.time);
                     }
-
-                    i++;
                 }
             }
-            this.sensorsCount = this.sensors.length;
 
             return true;
         } catch (error) {
@@ -240,14 +223,6 @@ class Sensors extends EventEmitter {
         return;
     }
 
-    createSensorService({ accessory, serviceType, serviceName, characteristicType, getValue }) {
-        const service = accessory.addService(serviceType, serviceName, serviceName);
-        service.addOptionalCharacteristic(Characteristic.ConfiguredName);
-        service.setCharacteristic(Characteristic.ConfiguredName, serviceName);
-        service.getCharacteristic(characteristicType).onGet(getValue);
-        return service;
-    }
-
     //prepare accessory
     async prepareAccessory() {
         const debug = this.enableDebugMode ? this.emit('debug', `Prepare Accessory`) : false;
@@ -271,158 +246,276 @@ class Sensors extends EventEmitter {
             //Prepare services 
             if (this.sensorsCount > 0) {
                 const debug = this.enableDebugMode ? this.emit('debug', `Prepare Sensor Services`) : false;
-                this.sensorServices = [];
-
+                this.sensorTemperatureServices = [];
+                this.sensorReferenceTemperatureServices = [];
+                this.sensorObjTemperatureServices = [];
+                this.sensorAmbTemperatureServices = [];
+                this.sensorDewPointTemperatureServices = [];
+                this.sensorHumidityServices = [];
+                this.sensorCarbonDioxydeServices = [];
+                this.sensorAmbientLightServices = [];
+                this.sensorMotionServices = [];
+                this.sensorEnergyServices = [];
+
+                //temperature
                 let i = 0;
                 for (const sensor of this.sensors) {
                     const sensorName = sensor.name;
-                    const service = {};
-
-                    const fullName = (suffix) =>
-                        this.sensorsNamePrefix ? `${accessoryName} ${sensorName} ${suffix}` : `${sensorName} ${suffix}`;
-
-                    // Temperature Variants
-                    const tempTypes = [
-                        { key: 'temperature', label: 'Temperature' },
-                        { key: 'referenceTemperature', label: 'Reference Temperature' },
-                        { key: 'objTemperature', label: 'Obj Temperature' },
-                        { key: 'ambTemperature', label: 'Amb Temperature' },
-                        { key: 'dewPointTemperature', label: 'Dew Point' }
-                    ];
-                    for (const { key, label } of tempTypes) {
-                        if (sensor[key] !== undefined) {
-                            if (this.enableDebugMode) this.emit('debug', `Prepare ${label} Sensor Services`);
-                            const value = sensor[key];
-                            const name = fullName(label);
-                            const temperatureService = this.createSensorService({
-                                accessory,
-                                serviceType: Service.TemperatureSensor,
-                                serviceName: name,
-                                characteristicType: Characteristic.CurrentTemperature,
-                                getValue: async () => {
-                                    if (!this.disableLogInfo) this.emit('info', `sensor: ${sensorName} ${label.toLowerCase()}: ${value} °${sensor.tempUnit}`);
-                                    return value;
-                                }
+                    if (sensor.temperature !== undefined) {
+                        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}`);
+                        sensorTemperatureService.addOptionalCharacteristic(Characteristic.ConfiguredName);
+                        sensorTemperatureService.setCharacteristic(Characteristic.ConfiguredName, serviceName);
+                        sensorTemperatureService.getCharacteristic(Characteristic.CurrentTemperature)
+                            .onGet(async () => {
+                                const value = sensor.temperature;
+                                const logInfo = this.disableLogInfo ? false : this.emit('info', `sensor: ${sensorName} temperature: ${value} °${sensor.tempUnit}`);
+                                return value;
                             });
-                            service[`sensor${label.replace(/\s/g, '')}Service`] = temperatureService;
-                        }
+                        this.sensorTemperatureServices.push(sensorTemperatureService);
                     }
 
-                    // Humidity
-                    if (sensor.humidity !== undefined) {
-                        if (this.enableDebugMode) this.emit('debug', `Prepare Humidity Sensor Services`);
-                        const name = fullName('Humidity');
-                        const humidityService = this.createSensorService({
-                            accessory,
-                            serviceType: Service.HumiditySensor,
-                            serviceName: name,
-                            characteristicType: Characteristic.CurrentRelativeHumidity,
-                            getValue: async () => {
+                    //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}`);
+                        sensorReferenceTemperatureService.addOptionalCharacteristic(Characteristic.ConfiguredName);
+                        sensorReferenceTemperatureService.setCharacteristic(Characteristic.ConfiguredName, serviceName);
+                        sensorReferenceTemperatureService.getCharacteristic(Characteristic.CurrentTemperature)
+                            .onGet(async () => {
+                                const value = sensor.referenceTemperature;
+                                const logInfo = this.disableLogInfo ? false : this.emit('info', `sensor: ${sensorName} reference temperature: ${value} °${sensor.tempUnit}`);
+                                return value;
+                            });
+                        this.sensorReferenceTemperatureServices.push(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}`);
+                        sensorObjTemperatureService.addOptionalCharacteristic(Characteristic.ConfiguredName);
+                        sensorObjTemperatureService.setCharacteristic(Characteristic.ConfiguredName, serviceName);
+                        sensorObjTemperatureService.getCharacteristic(Characteristic.CurrentTemperature)
+                            .onGet(async () => {
+                                const value = sensor.objTemperature;
+                                const logInfo = this.disableLogInfo ? false : this.emit('info', `sensor: ${sensorName} obj temperature: ${value} °${sensor.tempUnit}`);
+                                return value;
+                            });
+                        this.sensorObjTemperatureServices.push(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}`);
+                        sensorAmbTemperatureService.addOptionalCharacteristic(Characteristic.ConfiguredName);
+                        sensorAmbTemperatureService.setCharacteristic(Characteristic.ConfiguredName, serviceName);
+                        sensorAmbTemperatureService.getCharacteristic(Characteristic.CurrentTemperature)
+                            .onGet(async () => {
+                                const value = sensor.ambTemperature;
+                                const logInfo = this.disableLogInfo ? false : this.emit('info', `sensor: ${sensorName} amb temperature: ${value} °${sensor.tempUnit}`);
+                                return value;
+                            });
+                        this.sensorAmbTemperatureServices.push(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}`);
+                        sensorDewPointTemperatureService.addOptionalCharacteristic(Characteristic.ConfiguredName);
+                        sensorDewPointTemperatureService.setCharacteristic(Characteristic.ConfiguredName, serviceName);
+                        sensorDewPointTemperatureService.getCharacteristic(Characteristic.CurrentTemperature)
+                            .onGet(async () => {
+                                const value = sensor.dewPointTemperature;
+                                const logInfo = this.disableLogInfo ? false : this.emit('info', `sensor: ${sensorName} dew point: ${value} °${sensor.tempUnit}`);
+                                return value;
+                            });
+                        this.sensorDewPointTemperatureServices.push(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}`);
+                        sensorHumidityService.addOptionalCharacteristic(Characteristic.ConfiguredName);
+                        sensorHumidityService.setCharacteristic(Characteristic.ConfiguredName, serviceName);
+                        sensorHumidityService.getCharacteristic(Characteristic.CurrentRelativeHumidity)
+                            .onGet(async () => {
                                 const value = sensor.humidity;
-                                if (!this.disableLogInfo) this.emit('info', `sensor: ${sensorName} humidity: ${value} %`);
+                                const logInfo = this.disableLogInfo ? false : this.emit('info', `sensor: ${sensorName} humidity: ${value} %`);
                                 return value;
-                            }
-                        });
-                        service.sensorHumidityService = humidityService;
+                            });
+                        this.sensorHumidityServices.push(sensorHumidityService);
                     }
 
-                    // Carbon Dioxide
-                    if (sensor.carbonDioxyde !== undefined) {
-                        if (this.enableDebugMode) this.emit('debug', `Prepare Carbon Dioxyde Sensor Services`);
-                        const name = fullName('Carbon Dioxyde');
-                        const co2Service = accessory.addService(Service.CarbonDioxideSensor, name, `sensorCarbonDioxydeService${i}`);
-                        co2Service.addOptionalCharacteristic(Characteristic.ConfiguredName);
-                        co2Service.setCharacteristic(Characteristic.ConfiguredName, name);
-
-                        co2Service.getCharacteristic(Characteristic.CarbonDioxideDetected).onGet(async () => {
-                            const detected = sensor.carbonDioxyde > 1000;
-                            if (!this.disableLogInfo) this.emit('info', `sensor: ${sensorName} carbon dioxyde detected: ${detected ? 'Yes' : 'No'}`);
-                            return detected;
-                        });
-                        co2Service.getCharacteristic(Characteristic.CarbonDioxideLevel).onGet(async () => {
-                            const value = sensor.carbonDioxyde;
-                            if (!this.disableLogInfo) this.emit('info', `sensor: ${sensorName} carbon dioxyde level: ${value} ppm`);
-                            return value;
-                        });
-                        co2Service.getCharacteristic(Characteristic.CarbonDioxidePeakLevel).onGet(async () => {
-                            const value = sensor.carbonDioxyde;
-                            if (!this.disableLogInfo) this.emit('info', `sensor: ${sensorName} carbon dioxyde peak level: ${value} ppm`);
-                            return value;
-                        });
-                        service.sensorCarbonDioxydeService = co2Service;
+                    //pressure
+
+                    //gas
+
+                    //carbon dioxyde
+                    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}`);
+                        sensorCarbonDioxydeService.addOptionalCharacteristic(Characteristic.ConfiguredName);
+                        sensorCarbonDioxydeService.setCharacteristic(Characteristic.ConfiguredName, serviceName);
+                        sensorCarbonDioxydeService.getCharacteristic(Characteristic.CarbonDioxideDetected)
+                            .onGet(async () => {
+                                const state = sensor.carbonDioxyde > 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 = sensor.carbonDioxyde;
+                                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 = sensor.carbonDioxyde;
+                                const logInfo = this.disableLogInfo ? false : this.emit('info', `sensor: ${sensorName} carbon dioxyde peak level: ${value} ppm`);
+                                return value;
+                            });
+                        this.sensorCarbonDioxydeServices.push(sensorCarbonDioxydeService);
                     }
 
-                    // Ambient Light
-                    if (sensor.ambientLight !== undefined) {
-                        if (this.enableDebugMode) this.emit('debug', `Prepare Ambient Light Sensor Services`);
-                        const name = fullName('Ambient Light');
-                        const lightService = this.createSensorService({
-                            accessory,
-                            serviceType: Service.LightSensor,
-                            serviceName: name,
-                            characteristicType: Characteristic.CurrentAmbientLightLevel,
-                            getValue: async () => {
+                    //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}`);
+                        sensorAmbientLightService.addOptionalCharacteristic(Characteristic.ConfiguredName);
+                        sensorAmbientLightService.setCharacteristic(Characteristic.ConfiguredName, serviceName);
+                        sensorAmbientLightService.getCharacteristic(Characteristic.CurrentAmbientLightLevel)
+                            .onGet(async () => {
                                 const value = sensor.ambientLight;
-                                if (!this.disableLogInfo) this.emit('info', `sensor: ${sensorName} ambient light: ${value} lx`);
+                                const logInfo = this.disableLogInfo ? false : this.emit('info', `sensor: ${sensorName} ambient light: ${value} lx`);
                                 return value;
-                            }
-                        });
-                        service.sensorAmbientLightService = lightService;
+                            });
+                        this.sensorAmbientLightServices.push(sensorAmbientLightService);
                     }
 
-                    // Motion
-                    if (sensor.motion !== undefined) {
-                        if (this.enableDebugMode) this.emit('debug', `Prepare Motion Sensor Services`);
-                        const name = fullName('Motion');
-                        const motionService = this.createSensorService({
-                            accessory,
-                            serviceType: Service.MotionSensor,
-                            serviceName: name,
-                            characteristicType: Characteristic.MotionDetected,
-                            getValue: async () => {
+                    //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}`);
+                        sensorMotionService.addOptionalCharacteristic(Characteristic.ConfiguredName);
+                        sensorMotionService.setCharacteristic(Characteristic.ConfiguredName, serviceName);
+                        sensorMotionService.getCharacteristic(Characteristic.MotionDetected)
+                            .onGet(async () => {
                                 const state = sensor.motion;
-                                if (!this.disableLogInfo) this.emit('info', `sensor: ${sensorName} motion: ${state ? 'ON' : 'OFF'}`);
+                                const logInfo = this.disableLogInfo ? false : this.emit('info', `sensor: ${sensorName} motion: ${state ? 'ON' : 'OFF'}`);
                                 return state;
-                            }
-                        });
-                        service.sensorMotionService = motionService;
+                            });
+                        this.sensorMotionServices.push(sensorMotionService);
                     }
 
-                    // Energy Sensor
+                    //energy
                     if (sensor.name === 'ENERGY') {
-                        if (this.enableDebugMode) this.emit('debug', `Prepare Power And Energy Service`);
-                        const name = this.sensorsNamePrefix ? `${accessoryName} ${sensorName}` : sensorName;
-                        const energyService = accessory.addService(Service.PowerAndEnergyService, name, `sensorEnergyService${i}`);
-                        energyService.setCharacteristic(Characteristic.ConfiguredName, name);
-
-                        const energyFields = [
-                            { key: 'power', type: Characteristic.Power, label: 'power', unit: 'W' },
-                            { key: 'apparentPower', type: Characteristic.ApparentPower, label: 'apparent power', unit: 'VA' },
-                            { key: 'reactivePower', type: Characteristic.ReactivePower, label: 'reactive power', unit: 'VAr' },
-                            { key: 'energyToday', type: Characteristic.EnergyToday, label: 'energy today', unit: 'kWh' },
-                            { key: 'energyLastDay', type: Characteristic.EnergyLastDay, label: 'energy last day', unit: 'kWh' },
-                            { key: 'energyLifetime', type: Characteristic.EnergyLifetime, label: 'energy lifetime', unit: 'kWh' },
-                            { key: 'current', type: Characteristic.Current, label: 'current', unit: 'A' },
-                            { key: 'voltage', type: Characteristic.Voltage, label: 'voltage', unit: 'V' },
-                            { key: 'factor', type: Characteristic.Factor, label: 'power factor', unit: 'cos φ' },
-                            { key: 'frequency', type: Characteristic.Freqency, label: 'frequency', unit: 'Hz' },
-                            { key: 'time', type: Characteristic.ReadingTime, label: 'last report', unit: '' }
-                        ];
-
-                        for (const { key, type, label, unit } of energyFields) {
-                            if (sensor[key] !== undefined) {
-                                energyService.getCharacteristic(type).onGet(async () => {
-                                    const value = sensor[key];
-                                    if (!this.disableLogInfo) this.emit('info', `sensor: ${sensorName} ${label}: ${value} ${unit}`);
+                        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);
+                        if (sensor.power) {
+                            energyService.getCharacteristic(Characteristic.Power)
+                                .onGet(async () => {
+                                    const value = sensor.power;
+                                    const info = this.disableLogInfo ? false : this.emit('info', `sensor: ${sensorName} power: ${value} W`);
                                     return value;
                                 });
-                            }
                         }
-
-                        service.sensorEnergyService = energyService;
+                        if (sensor.apparentPower) {
+                            energyService.getCharacteristic(Characteristic.ApparentPower)
+                                .onGet(async () => {
+                                    const value = sensor.apparentPower;
+                                    const info = this.disableLogInfo ? false : this.emit('info', `sensor: ${sensorName} 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', `sensor: ${sensorName} 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', `sensor: ${sensorName} 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', `sensor: ${sensorName} energy last day: ${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', `sensor: ${sensorName} 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', `sensor: ${sensorName} 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', `sensor: ${sensorName} 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', `sensor: ${sensorName} 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', `sensor: ${sensorName} 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', `sensor: ${sensorName} last report: ${value}`);
+                                    return value;
+                                });
+                        }
+                        this.sensorEnergyServices.push(energyService);
                     }
-
-                    this.sensorServices.push(service);
                     i++;
                 }
             }