zigbee-herdsman-converters 14.0.691 → 14.0.693

package/converters/fromZigbee.js

@@ -383,9 +383,11 @@ const converters = {
     device_temperature: {
         cluster: 'genDeviceTempCfg',
         type: ['attributeReport', 'readResponse'],
+        options: [exposes.options.calibration('device_temperature')],
         convert: (model, msg, publish, options, meta) => {
             if (msg.data.hasOwnProperty('currentTemperature')) {
-                return {device_temperature: parseInt(msg.data['currentTemperature'])};
+                const value = parseInt(msg.data['currentTemperature']);
+                return {device_temperature: calibrateAndPrecisionRoundOptions(value, options, 'device_temperature')};
             }
         },
     },
@@ -648,7 +650,7 @@ const converters = {
             const result = converters.metering.convert(model, msg, publish, options, meta);
             // Filter incorrect 0 energy values reported by the device:
             // https://github.com/Koenkk/zigbee2mqtt/issues/7852
-            if (result.energy === 0) {
+            if (result && result.energy === 0) {
                 delete result.energy;
             }
             return result;
@@ -680,6 +682,17 @@ const converters = {
          */
         cluster: 'seMetering',
         type: ['attributeReport', 'readResponse'],
+        options: (definition) => {
+            const result = [];
+            if (definition.exposes.find((e) => e.name === 'power')) {
+                result.push(exposes.options.precision('power'), exposes.options.calibration('power', 'percentual'));
+            }
+            if (definition.exposes.find((e) => e.name === 'energy')) {
+                result.push(exposes.options.precision('energy'), exposes.options.calibration('energy', 'percentual'));
+            }
+            return result;
+        },
+
         convert: (model, msg, publish, options, meta) => {
             if (utils.hasAlreadyProcessedMessage(msg, model)) return;
             const payload = {};
@@ -692,7 +705,7 @@ const converters = {
                 if (factor != null) {
                     power = (power * factor) * 1000; // kWh to Watt
                 }
-                payload.power = precisionRound(power, 2);
+                payload.power = calibrateAndPrecisionRoundOptions(power, options, 'power');
             }
 
             if (factor != null && (msg.data.hasOwnProperty('currentSummDelivered') ||
@@ -708,7 +721,7 @@ const converters = {
                     const value = (parseInt(data[0]) << 32) + parseInt(data[1]);
                     energy -= value * factor;
                 }
-                payload.energy = precisionRound(energy, 2);
+                payload.energy = calibrateAndPrecisionRoundOptions(energy, options, 'energy');
             }
 
             return payload;
@@ -735,8 +748,11 @@ const converters = {
          */
         cluster: 'haElectricalMeasurement',
         type: ['attributeReport', 'readResponse'],
-        options: [exposes.options.calibration('power', 'percentual'), exposes.options.calibration('current', 'percentual'),
-            exposes.options.calibration('voltage', 'percentual')],
+        options: [
+            exposes.options.calibration('power', 'percentual'), exposes.options.precision('power'),
+            exposes.options.calibration('current', 'percentual'), exposes.options.precision('current'),
+            exposes.options.calibration('voltage', 'percentual'), exposes.options.precision('voltage'),
+        ],
         convert: (model, msg, publish, options, meta) => {
             if (utils.hasAlreadyProcessedMessage(msg, model)) return;
             const getFactor = (key) => {
@@ -750,6 +766,7 @@ const converters = {
                 {key: 'activePower', name: 'power', factor: 'acPower'},
                 {key: 'activePowerPhB', name: 'power_phase_b', factor: 'acPower'},
                 {key: 'activePowerPhC', name: 'power_phase_c', factor: 'acPower'},
+                {key: 'apparentPower', name: 'power_apparent', factor: 'acPower'},
                 {key: 'rmsCurrent', name: 'current', factor: 'acCurrent'},
                 {key: 'rmsCurrentPhB', name: 'current_phase_b', factor: 'acCurrent'},
                 {key: 'rmsCurrentPhC', name: 'current_phase_c', factor: 'acCurrent'},
@@ -5321,47 +5338,23 @@ const converters = {
     xiaomi_power: {
         cluster: 'genAnalogInput',
         type: ['attributeReport', 'readResponse'],
+        options: [exposes.options.calibration('power', 'percentual'), exposes.options.precision('power')],
         convert: (model, msg, publish, options, meta) => {
-            return {power: precisionRound(msg.data['presentValue'], 2)};
+            return {power: calibrateAndPrecisionRoundOptions(msg.data['presentValue'], options, 'power')};
         },
     },
     xiaomi_basic: {
         cluster: 'genBasic',
         type: ['attributeReport', 'readResponse'],
-        options: (definition) => {
-            const result = [];
-            if (definition.exposes.find((e) => e.name === 'temperature')) {
-                result.push(exposes.options.precision('temperature'), exposes.options.calibration('temperature'));
-            }
-            if (definition.exposes.find((e) => e.name === 'device_temperature')) {
-                result.push(exposes.options.calibration('device_temperature'));
-            }
-            if (definition.exposes.find((e) => e.name === 'illuminance')) {
-                result.push(exposes.options.calibration('illuminance', 'percentual'));
-            }
-            if (definition.exposes.find((e) => e.name === 'illuminance_lux')) {
-                result.push(exposes.options.calibration('illuminance_lux', 'percentual'));
-            }
-            return result;
-        },
+        options: xiaomi.numericAttributes2Options,
         convert: (model, msg, publish, options, meta) => {
-            const payload = xiaomi.numericAttributes2Payload(msg, meta, model, options, msg.data);
-            return payload;
+            return xiaomi.numericAttributes2Payload(msg, meta, model, options, msg.data);
         },
     },
     xiaomi_basic_raw: {
         cluster: 'genBasic',
         type: ['raw'],
-        options: (definition) => {
-            const result = [];
-            if (definition.exposes.find((e) => e.name === 'temperature')) {
-                result.push(exposes.options.precision('temperature'), exposes.options.calibration('temperature'));
-            }
-            if (definition.exposes.find((e) => e.name === 'device_temperature')) {
-                result.push(exposes.options.calibration('device_temperature'));
-            }
-            return result;
-        },
+        options: xiaomi.numericAttributes2Options,
         convert: (model, msg, publish, options, meta) => {
             let payload = {};
             if (Buffer.isBuffer(msg.data)) {
@@ -5374,22 +5367,9 @@ const converters = {
     aqara_opple: {
         cluster: 'aqaraOpple',
         type: ['attributeReport', 'readResponse'],
-        options: (definition) => {
-            const result = [];
-            if (definition.exposes.find((e) => e.name === 'temperature')) {
-                result.push(exposes.options.precision('temperature'), exposes.options.calibration('temperature'));
-            }
-            if (definition.exposes.find((e) => e.name === 'device_temperature')) {
-                result.push(exposes.options.calibration('device_temperature'));
-            }
-            if (definition.exposes.find((e) => e.name === 'illuminance')) {
-                result.push(exposes.options.calibration('illuminance', 'percentual'));
-            }
-            return result;
-        },
+        options: xiaomi.numericAttributes2Options,
         convert: (model, msg, publish, options, meta) => {
-            const payload = xiaomi.numericAttributes2Payload(msg, meta, model, options, msg.data);
-            return payload;
+            return xiaomi.numericAttributes2Payload(msg, meta, model, options, msg.data);
         },
     },
     xiaomi_on_off_action: {
@@ -5448,6 +5428,9 @@ const converters = {
                     61: 'all',
                 };
             }
+            if (['WS-USC02'].includes(model.model)) {
+                buttonLookup = {41: 'top', 42: 'bottom', 51: 'both'};
+            }
 
             const action = actionLookup[msg.data['presentValue']];
             if (buttonLookup) {
@@ -5724,8 +5707,9 @@ const converters = {
         type: ['attributeReport', 'readResponse'],
         options: [exposes.options.invert_cover()],
         convert: (model, msg, publish, options, meta) => {
-            if (model.model === 'ZNCLDJ12LM' && msg.type === 'attributeReport' && [0, 2].includes(msg.data['presentValue'])) {
-                // Incorrect reports from the device, ignore (re-read by onEvent of ZNCLDJ12LM)
+            if ((model.model === 'ZNCLDJ12LM' || model.model === 'ZNCLDJ14LM') &&
+              msg.type === 'attributeReport' && [0, 2].includes(msg.data['presentValue'])) {
+                // Incorrect reports from the device, ignore (re-read by onEvent of ZNCLDJ12LM and ZNCLDJ14LM)
                 // https://github.com/Koenkk/zigbee-herdsman-converters/pull/1427#issuecomment-663862724
                 return;
             }
@@ -5779,6 +5763,29 @@ const converters = {
             }
         },
     },
+    xiaomi_curtain_hagl07_status: {
+        cluster: 'genMultistateOutput',
+        type: ['attributeReport'],
+        convert: (model, msg, publish, options, meta) => {
+            let running = false;
+            const data = msg.data;
+            const lookup = {
+                0: 'closing',
+                1: 'opening',
+                2: 'stop',
+            };
+            if (data && data.hasOwnProperty('presentValue')) {
+                const value = data['presentValue'];
+                if (value < 2) {
+                    running = true;
+                }
+                return {
+                    motor_state: lookup[value],
+                    running: running,
+                };
+            }
+        },
+    },
     xiaomi_curtain_acn002_status: {
         cluster: 'genMultistateOutput',
         type: ['attributeReport'],

package/converters/toZigbee.js

@@ -2503,7 +2503,7 @@ const converters = {
             if (value.hasOwnProperty('auto_close')) opts.hand_open = value.auto_close;
             if (value.hasOwnProperty('reset_move')) opts.reset_limits = value.reset_move;
 
-            if (meta.mapped.model === 'ZNCLDJ12LM') {
+            if (meta.mapped.model === 'ZNCLDJ12LM' || meta.mapped.model === 'ZNCLDJ14LM') {
                 await entity.write('genBasic', {0xff28: {value: opts.reverse_direction, type: 0x10}}, manufacturerOptions.xiaomi);
                 await entity.write('genBasic', {0xff29: {value: !opts.hand_open, type: 0x10}}, manufacturerOptions.xiaomi);
 
@@ -2588,6 +2588,18 @@ const converters = {
             }
         },
     },
+    xiaomi_curtain_battery_voltage: {
+        key: ['voltage'],
+        convertGet: async (entity, key, meta) => {
+            switch (meta.mapped.model) {
+            case 'ZNCLBL01LM':
+                await entity.read('aqaraOpple', [0x040B], manufacturerOptions.xiaomi);
+                break;
+            default:
+                throw new Error(`xiaomi_curtain_battery_voltage - unsupported model: ${meta.mapped.model}`);
+            }
+        },
+    },
     xiaomi_curtain_acn002_charging_status: {
         key: ['charging_status'],
         convertGet: async (entity, key, meta) => {
@@ -6513,10 +6525,12 @@ const converters = {
             }
         },
     },
-    ZNCLBL01LM_battery_voltage: {
-        key: ['voltage'],
-        convertGet: async (entity, key, meta) => {
-            await entity.read('aqaraOpple', [0x040B], manufacturerOptions.xiaomi);
+    ZNCLBL01LM_hooks_lock: {
+        key: ['hooks_lock'],
+        convertSet: async (entity, key, value, meta) => {
+            const lookup = {'UNLOCK': 0, 'LOCK': 1};
+            await entity.write('aqaraOpple', {0x0427: {value: lookup[value], type: 0x20}}, manufacturerOptions.xiaomi);
+            return {state: {[key]: value}};
         },
     },
     ZNCLBL01LM_hooks_state: {
@@ -6525,6 +6539,32 @@ const converters = {
             await entity.read('aqaraOpple', [0x0428], manufacturerOptions.xiaomi);
         },
     },
+    ZNCLBL01LM_hand_open: {
+        key: ['hand_open'],
+        convertSet: async (entity, key, value, meta) => {
+            await entity.write('aqaraOpple', {0x0401: {value: !value, type: 0x10}}, manufacturerOptions.xiaomi);
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read('aqaraOpple', [0x0401], manufacturerOptions.xiaomi);
+        },
+    },
+    ZNCLBL01LM_limits_calibration: {
+        key: ['limits_calibration'],
+        convertSet: async (entity, key, value, meta) => {
+            switch (value) {
+            case 'start':
+                await entity.write('aqaraOpple', {0x0407: {value: 0x01, type: 0x20}}, manufacturerOptions.xiaomi);
+                break;
+            case 'end':
+                await entity.write('aqaraOpple', {0x0407: {value: 0x02, type: 0x20}}, manufacturerOptions.xiaomi);
+                break;
+            case 'reset':
+                await entity.write('aqaraOpple', {0x0407: {value: 0x00, type: 0x20}}, manufacturerOptions.xiaomi);
+                // also? await entity.write('aqaraOpple', {0x0402: {value: 0x00, type: 0x10}}, manufacturerOptions.xiaomi);
+                break;
+            }
+        },
+    },
     wiser_vact_calibrate_valve: {
         key: ['calibrate_valve'],
         convertSet: async (entity, key, value, meta) => {

package/devices/bosch.js

@@ -4,6 +4,7 @@ const fz = require('../converters/fromZigbee');
 const tz = require('../converters/toZigbee');
 const reporting = require('../lib/reporting');
 const utils = require('../lib/utils');
+const constants = require('../lib/constants');
 const e = exposes.presets;
 const ea = exposes.access;
 
@@ -57,7 +58,7 @@ const tzLocal = {
                 if (value=='off') {
                     opMode = operatingModes.pause; // OperatingMode 5 = Pause
                 } else if (value == 'auto') {
-                    opMode = operatingModes.automatic; // OperatingMOde 1 = Automatic
+                    opMode = operatingModes.automatic; // OperatingMode 0 = Automatic
                 }
                 await entity.write('hvacThermostat', {0x4007: {value: opMode, type: herdsman.Zcl.DataType.enum8}}, boschManufacturer);
                 return {state: {system_mode: value}};
@@ -139,9 +140,12 @@ const fzLocal = {
                 result.boost = (Object.keys(stateOffOn)[data[0x4043]]);
             }
             if (data.hasOwnProperty(0x4007)) {
-                const opModes = {0: 'auto', 1: 'heat', 2: 'unknowm 2', 3: 'unknonw 3', 4: 'unknown 4', 5: 'off'};
+                const opModes = {0: 'auto', 1: 'heat', 2: 'unknown_2', 3: 'unknown_3', 4: 'unknown_4', 5: 'off'};
                 result.system_mode = opModes[data[0x4007]];
             }
+            if (data.hasOwnProperty(0x4020)) {
+                result.pi_heating_demand = data[0x4020];
+            }
 
             return result;
         },
@@ -214,16 +218,17 @@ const definition = [
         toZigbee: [
             tz.thermostat_occupied_heating_setpoint,
             tz.thermostat_local_temperature_calibration,
-            tz.thermostat_local_temperature,
             tz.thermostat_keypad_lockout,
             tzLocal.bosch_thermostat,
-            tzLocal.bosch_userInterface],
+            tzLocal.bosch_userInterface,
+        ],
         exposes: [
             exposes.climate()
-                .withLocalTemperature()
+                .withLocalTemperature(ea.STATE)
                 .withSetpoint('occupied_heating_setpoint', 5, 30, 0.5)
                 .withLocalTemperatureCalibration(-12, 12, 0.5)
-                .withSystemMode(['off', 'heat', 'auto']),
+                .withSystemMode(['off', 'heat', 'auto'])
+                .withPiHeatingDemand(ea.STATE),
             exposes.binary('boost', ea.ALL, 'ON', 'OFF')
                 .withDescription('Activate Boost heating'),
             exposes.binary('window_open', ea.ALL, 'ON', 'OFF')
@@ -246,10 +251,33 @@ const definition = [
             await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg', 'hvacThermostat', 'hvacUserInterfaceCfg']);
             await reporting.thermostatOccupiedHeatingSetpoint(endpoint);
             await reporting.thermostatTemperature(endpoint);
+            await reporting.thermostatKeypadLockMode(endpoint);
             await reporting.batteryPercentageRemaining(endpoint);
 
+            // report operating_mode (system_mode)
+            await endpoint.configureReporting('hvacThermostat', [{
+                attribute: {ID: 0x4007, type: herdsman.Zcl.DataType.enum8},
+                minimumReportInterval: 0,
+                maximumReportInterval: constants.repInterval.HOUR,
+                reportableChange: 1,
+            }], boschManufacturer);
+            // report pi_heating_demand (valve opening)
+            await endpoint.configureReporting('hvacThermostat', [{
+                attribute: {ID: 0x4020, type: herdsman.Zcl.DataType.enum8},
+                minimumReportInterval: 0,
+                maximumReportInterval: constants.repInterval.HOUR,
+                reportableChange: 1,
+            }], boschManufacturer);
+            // report window_open
+            await endpoint.configureReporting('hvacThermostat', [{
+                attribute: {ID: 0x4042, type: herdsman.Zcl.DataType.enum8},
+                minimumReportInterval: 0,
+                maximumReportInterval: constants.repInterval.HOUR,
+                reportableChange: 1,
+            }], boschManufacturer);
+
             await endpoint.read('hvacThermostat', ['localTemperatureCalibration']);
-            await endpoint.read('hvacThermostat', [0x4007, 0x4042, 0x4043], boschManufacturer);
+            await endpoint.read('hvacThermostat', [0x4007, 0x4020, 0x4042, 0x4043], boschManufacturer);
 
             await endpoint.read('hvacUserInterfaceCfg', ['keypadLockout']);
             await endpoint.read('hvacUserInterfaceCfg', [0x400b, 0x403a, 0x403b], boschManufacturer);

package/devices/develco.js

@@ -556,6 +556,7 @@ module.exports = [
             dynExposes.push(e.linkquality());
             return dynExposes;
         },
+        ota: ota.zigbeeOTA,
         meta: {battery: {voltageToPercentage: '3V_2500'}},
         endpoint: (device) => {
             return {default: 35};

package/devices/ledvance.js

@@ -48,7 +48,7 @@ module.exports = [
         model: 'AC25697',
         vendor: 'LEDVANCE',
         description: 'SMART+ CLASSIC MULTICOLOUR 60 10W E27',
-        extend: extend.ledvance.light_onoff_brightness_colortemp_color({colorTempRange: [153, 500]}),
+        extend: extend.ledvance.light_onoff_brightness_colortemp_color({colorTempRange: [153, 500], disablePowerOnBehavior: true}),
         ota: ota.ledvance,
     },
     {

package/devices/legrand.js

@@ -209,8 +209,8 @@ module.exports = [
             exposes.numeric('ballast_maximum_level', ea.ALL).withValueMin(1).withValueMax(254)
                 .withDescription('Specifies the maximum brightness value'),
             exposes.binary('device_mode', ea.ALL, 'dimmer_on', 'dimmer_off').withDescription('Allow the device to change brightness'),
-            exposes.binary('led_in_dark', ea.ALL, 'ON', 'OFF').withDescription(`Enables the LED when the light is turned off, allowing to 
-                see the switch in the dark`),
+            exposes.binary('led_in_dark', ea.ALL, 'ON', 'OFF').withDescription(`Enables the LED when the light is turned off, allowing to` +
+                ` see the switch in the dark`),
             exposes.binary('led_if_on', ea.ALL, 'ON', 'OFF').withDescription('Enables the LED when the light is turned on'),
             e.power_on_behavior()],
         configure: async (device, coordinatorEndpoint, logger) => {
@@ -231,7 +231,7 @@ module.exports = [
         fromZigbee: [fz.identify, fz.on_off, fz.electrical_measurement, fz.power_on_behavior],
         toZigbee: [tz.on_off, tz.legrand_settingEnableLedInDark, tz.legrand_identify, tz.legrand_settingEnableLedIfOn,
             tz.power_on_behavior],
-        exposes: [e.switch(), e.action(['identify']), e.power(),
+        exposes: [e.switch(), e.action(['identify']), e.power(), e.power_apparent(),
             exposes.binary('led_in_dark', ea.ALL, 'ON', 'OFF').withDescription(`Enables the LED when the power socket is turned off,
                 allowing to see it in the dark`),
             exposes.binary('led_if_on', ea.ALL, 'ON', 'OFF').withDescription('Enables the LED when the device is turned on'),
@@ -383,8 +383,8 @@ module.exports = [
         toZigbee: [tz.on_off, tz.legrand_settingEnableLedInDark, tz.legrand_settingEnableLedIfOn],
         exposes: [e.switch().withEndpoint('left'),
             e.switch().withEndpoint('right'),
-            exposes.binary('led_in_dark', ea.ALL, 'ON', 'OFF').withDescription(`Enables the LED when the light is turned off, allowing to 
-                see the switch in the dark`),
+            exposes.binary('led_in_dark', ea.ALL, 'ON', 'OFF').withDescription(`Enables the LED when the light is turned off, allowing to` +
+                ` see the switch in the dark`),
             exposes.binary('led_if_on', ea.ALL, 'ON', 'OFF').withDescription('Enables the LED when the light is turned on')],
         meta: {multiEndpoint: true},
         configure: async (device, coordinatorEndpoint, logger) => {

package/devices/lidl.js

@@ -671,7 +671,7 @@ module.exports = [
         model: 'HG06106C',
         vendor: 'Lidl',
         description: 'Livarno Lux E27 bulb RGB',
-        ...extend.light_onoff_brightness_colortemp_color({disableColorTempStartup: true}),
+        ...extend.light_onoff_brightness_colortemp_color({disableColorTempStartup: true, disablePowerOnBehavior: true}),
         meta: {applyRedFix: true, enhancedHue: false},
         configure: async (device, coordinatorEndpoint, logger) => {
             device.getEndpoint(1).saveClusterAttributeKeyValue('lightingColorCtrl', {colorCapabilities: 29});

package/devices/namron.js

@@ -5,6 +5,7 @@ const tz = require('../converters/toZigbee');
 const constants = require('../lib/constants');
 const reporting = require('../lib/reporting');
 const globalStore = require('../lib/store');
+const ota = require('../lib/ota');
 const utils = require('../lib/utils');
 const extend = require('../lib/extend');
 const ea = exposes.access;
@@ -159,6 +160,7 @@ module.exports = [
             await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff']);
             await reporting.onOff(endpoint);
         },
+        ota: ota.zigbeeOTA,
     },
     {
         zigbeeModel: ['1402755'],
@@ -190,6 +192,7 @@ module.exports = [
         endpoint: (device) => {
             return {l1: 1, l2: 2, l3: 3, l4: 4};
         },
+        ota: ota.zigbeeOTA,
     },
     {
         zigbeeModel: ['4512721'],
@@ -207,6 +210,7 @@ module.exports = [
         endpoint: (device) => {
             return {l1: 1, l2: 2, l3: 3, l4: 4};
         },
+        ota: ota.zigbeeOTA,
     },
     {
         zigbeeModel: ['4512701'],
@@ -231,7 +235,7 @@ module.exports = [
         zigbeeModel: ['4512719'],
         model: '4512719',
         vendor: 'Namron',
-        description: 'Zigbee 2 channel switch K4 white',
+        description: 'Zigbee 2 channel switch K4 (white)',
         fromZigbee: [fz.command_on, fz.command_off, fz.battery, fz.command_move, fz.command_stop],
         meta: {multiEndpoint: true},
         exposes: [e.battery(), e.action(['on_l1', 'off_l1', 'brightness_move_up_l1', 'brightness_move_down_l1', 'brightness_stop_l1',
@@ -240,6 +244,7 @@ module.exports = [
         endpoint: (device) => {
             return {l1: 1, l2: 2};
         },
+        ota: ota.zigbeeOTA,
     },
     {
         zigbeeModel: ['4512726'],
@@ -259,12 +264,13 @@ module.exports = [
             await reporting.batteryPercentageRemaining(endpoint);
             await reporting.batteryVoltage(endpoint);
         },
+        ota: ota.zigbeeOTA,
     },
     {
         zigbeeModel: ['4512729'],
         model: '4512729',
         vendor: 'Namron',
-        description: 'Zigbee 2 channel switch K4 white',
+        description: 'Zigbee 2 channel switch K4 (black)',
         fromZigbee: [fz.command_on, fz.command_off, fz.battery, fz.command_move, fz.command_stop],
         meta: {multiEndpoint: true},
         exposes: [e.battery(), e.action(['on_l1', 'off_l1', 'brightness_move_up_l1', 'brightness_move_down_l1', 'brightness_stop_l1',
@@ -273,6 +279,7 @@ module.exports = [
         endpoint: (device) => {
             return {l1: 1, l2: 2};
         },
+        ota: ota.zigbeeOTA,
     },
     {
         zigbeeModel: ['4512706'],
@@ -589,6 +596,29 @@ module.exports = [
             await endpoint.read('hvacThermostat', [0x1008, 0x1009, 0x100A, 0x100B], options);
             await endpoint.read('hvacThermostat', [0x2001, 0x2002], options);
         },
+        ota: ota.zigbeeOTA,
+    },
+    {
+        zigbeeModel: ['4512735'],
+        model: '4512735',
+        vendor: 'Namron',
+        description: 'Multiprise with 4 AC outlets and 2 USB super charging ports (16A)',
+        fromZigbee: [fz.on_off],
+        toZigbee: [tz.on_off],
+        exposes: [e.switch().withEndpoint('l1'), e.switch().withEndpoint('l2'), e.switch().withEndpoint('l3'),
+            e.switch().withEndpoint('l4'), e.switch().withEndpoint('l5')],
+        endpoint: (device) => {
+            return {'l1': 1, 'l2': 2, 'l3': 3, 'l4': 4, 'l5': 5};
+        },
+        meta: {multiEndpoint: true},
+        configure: async (device, coordinatorEndpoint, logger) => {
+            for (const ID of [1, 2, 3, 4, 5]) {
+                const endpoint = device.getEndpoint(ID);
+                await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff']);
+            }
+            device.powerSource = 'Mains (single phase)';
+            device.save();
+        },
     },
     {
         zigbeeModel: ['5401392', '5401396', '5401393', '5401397', '5401394', '5401398', '5401395', '5401399', '5401395'],

package/devices/philips.js

@@ -769,7 +769,7 @@ module.exports = [
         extend: hueExtend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 500]}),
     },
     {
-        zigbeeModel: ['LCG002'],
+        zigbeeModel: ['LCG002', '929003047701'],
         model: '929001953101',
         vendor: 'Philips',
         description: 'Hue White and Color Ambiance GU10',
@@ -2013,11 +2013,7 @@ module.exports = [
             exposes.numeric('occupancy_timeout', ea.ALL).withUnit('second').withValueMin(0).withValueMax(65535)],
         toZigbee: [tz.occupancy_timeout, tz.hue_motion_sensitivity, tz.hue_motion_led_indication],
         endpoint: (device) => {
-            return {
-                'default': 2, // default
-                'ep1': 1,
-                'ep2': 2, // e.g. for write to msOccupancySensing
-            };
+            return {'default': 2, 'ep1': 1, 'ep2': 2};
         },
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(2);
@@ -2046,11 +2042,7 @@ module.exports = [
             exposes.numeric('occupancy_timeout', ea.ALL).withUnit('second').withValueMin(0).withValueMax(65535)],
         toZigbee: [tz.occupancy_timeout, tz.hue_motion_sensitivity, tz.hue_motion_led_indication],
         endpoint: (device) => {
-            return {
-                'default': 2, // default
-                'ep1': 1,
-                'ep2': 2, // e.g. for write to msOccupancySensing
-            };
+            return {'default': 2, 'ep1': 1, 'ep2': 2};
         },
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(2);
@@ -2078,13 +2070,6 @@ module.exports = [
             exposes.binary('led_indication', ea.ALL, true, false).withDescription('Blink green LED on motion detection'),
             exposes.numeric('occupancy_timeout', ea.ALL).withUnit('second').withValueMin(0).withValueMax(65535)],
         toZigbee: [tz.occupancy_timeout, tz.hue_motion_sensitivity, tz.hue_motion_led_indication],
-        endpoint: (device) => {
-            return {
-                'default': 2, // default
-                'ep1': 1,
-                'ep2': 2, // e.g. for write to msOccupancySensing
-            };
-        },
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(2);
             const binds = ['genPowerCfg', 'msIlluminanceMeasurement', 'msTemperatureMeasurement', 'msOccupancySensing'];
@@ -2111,13 +2096,6 @@ module.exports = [
             exposes.binary('led_indication', ea.ALL, true, false).withDescription('Blink green LED on motion detection'),
             exposes.numeric('occupancy_timeout', ea.ALL).withUnit('second').withValueMin(0).withValueMax(65535)],
         toZigbee: [tz.occupancy_timeout, tz.hue_motion_sensitivity, tz.hue_motion_led_indication],
-        endpoint: (device) => {
-            return {
-                'default': 2, // default
-                'ep1': 1,
-                'ep2': 2, // e.g. for write to msOccupancySensing
-            };
-        },
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(2);
             const binds = ['genPowerCfg', 'msIlluminanceMeasurement', 'msTemperatureMeasurement', 'msOccupancySensing'];
@@ -3011,6 +2989,13 @@ module.exports = [
         description: 'Hue Gradient Signe floor lamp (white)',
         extend: hueExtend.light_onoff_brightness_colortemp_color_gradient({colorTempRange: [153, 500]}),
     },
+    {
+        zigbeeModel: ['915005987301'],
+        model: '915005987301',
+        vendor: 'Philips',
+        description: 'Hue Gradient Signe table lamp (white)',
+        extend: hueExtend.light_onoff_brightness_colortemp_color_gradient({colorTempRange: [153, 500]}),
+    },
     {
         zigbeeModel: ['929003526301'],
         model: '929003526301',
@@ -3032,4 +3017,11 @@ module.exports = [
         description: 'Hue white ambiance Pillar spotlight with Bluetooth (black)',
         extend: hueExtend.light_onoff_brightness_colortemp({colorTempRange: [153, 454]}),
     },
+    {
+        zigbeeModel: ['8719514288232'],
+        model: '929002469216',
+        vendor: 'Philips',
+        description: 'Hue white E27 1100lm with Bluetooth',
+        extend: hueExtend.light_onoff_brightness(),
+    },
 ];

package/devices/sinope.js

@@ -990,4 +990,53 @@ module.exports = [
             await reporting.brightness(endpoint); // valve position
         },
     },
+    {
+        zigbeeModel: ['VA4220ZB'],
+        model: 'VA4220ZB',
+        vendor: 'Sinopé',
+        description: 'Sedna smart water valve',
+        fromZigbee: [fz.ignore_iaszone_statuschange, fz.cover_position_via_brightness, fz.cover_state_via_onoff,
+            fz.battery, fz.metering],
+        toZigbee: [tz.cover_via_brightness],
+        meta: {battery: {voltageToPercentage: {min: 5400, max: 6800}}},
+        exposes: [e.valve_switch(), e.valve_position(), e.battery_low(), e.battery(), e.battery_voltage()],
+        configure: async (device, coordinatorEndpoint) => {
+            const endpoint = device.getEndpoint(1);
+            const binds = [
+                'genBasic', 'genGroups', 'genOnOff', 'ssIasZone', 'genLevelCtrl',
+                'genPowerCfg', 'seMetering', 'manuSpecificSinope'];
+            await reporting.bind(endpoint, coordinatorEndpoint, binds);
+            await reporting.batteryPercentageRemaining(endpoint);
+            await reporting.onOff(endpoint);
+            await reporting.brightness(endpoint); // valve position
+            try {
+                await reporting.batteryVoltage(endpoint);
+            } catch (error) {/* Do Nothing */}
+            try {
+                await reporting.batteryAlarmState(endpoint);
+            } catch (error) {/* Do Nothing */}
+        },
+    },
+    {
+        zigbeeModel: ['RM3500ZB'],
+        model: 'RM3500ZB',
+        vendor: 'Sinopé',
+        description: 'Calypso smart water heater controller',
+        fromZigbee: [fz.on_off, fz.electrical_measurement, fz.metering, fz.ias_water_leak_alarm_1, fz.temperature],
+        toZigbee: [tz.on_off],
+        exposes: [e.switch(), e.power(), e.current(), e.voltage(), e.energy(), e.water_leak(), e.temperature()],
+        configure: async (device, coordinatorEndpoint) => {
+            const endpoint = device.getEndpoint(1);
+            const binds = ['genOnOff', 'haElectricalMeasurement', 'seMetering', 'Temperature'];
+            await reporting.bind(endpoint, coordinatorEndpoint, binds);
+            await reporting.onOff(endpoint);
+            await reporting.readEletricalMeasurementMultiplierDivisors(endpoint);
+            await reporting.activePower(endpoint);
+            await reporting.rmsCurrent(endpoint);
+            await reporting.rmsVoltage(endpoint);
+            await reporting.readMeteringMultiplierDivisor(endpoint);
+            await reporting.currentSummDelivered(endpoint);
+            await reporting.temperature(endpoint, {min: 60, max: 3600, change: 1});
+        },
+    },
 ];

package/devices/third_reality.js

@@ -102,17 +102,12 @@ module.exports = [
         model: '3RSP019BZ',
         vendor: 'Third Reality',
         description: 'Zigbee / BLE smart plug',
-        fromZigbee: [fz.on_off, fz.electrical_measurement],
-        toZigbee: [tz.on_off],
+        extend: extend.switch(),
         ota: ota.zigbeeOTA,
-        exposes: [e.switch(), e.power(), e.current(), e.voltage()],
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
-            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'haElectricalMeasurement']);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff']);
             await reporting.onOff(endpoint);
-            await reporting.activePower(endpoint);
-            await reporting.rmsCurrent(endpoint);
-            await reporting.rmsVoltage(endpoint);
         },
     },
     {
@@ -158,4 +153,21 @@ module.exports = [
         exposes: [e.battery(), e.temperature(), e.humidity(), e.battery_voltage()],
         ota: ota.zigbeeOTA,
     },
+    {
+        zigbeeModel: ['3RSP02028BZ'],
+        model: '3RSP02028BZ',
+        vendor: 'Third Reality',
+        description: 'Zigbee / BLE smart plug with power',
+        fromZigbee: [fz.on_off, fz.electrical_measurement],
+        toZigbee: [tz.on_off],
+        exposes: [e.switch(), e.power(), e.current(), e.voltage()],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'haElectricalMeasurement']);
+            await reporting.onOff(endpoint);
+            await reporting.activePower(endpoint);
+            await reporting.rmsCurrent(endpoint);
+            await reporting.rmsVoltage(endpoint);
+        },
+    },
 ];

package/devices/tuya.js

@@ -989,7 +989,8 @@ module.exports = [
             {vendor: 'Zemismart', model: 'LXZB-ZB-09A', description: 'Zemismart LED Surface Mounted Downlight 9W RGBW'},
             {vendor: 'Feconn', model: 'FE-GU10-5W', description: 'Zigbee GU10 5W smart bulb'},
         ],
-        extend: extend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 500], disableColorTempStartup: true}),
+        extend: extend.light_onoff_brightness_colortemp_color(
+            {colorTempRange: [153, 500], disableColorTempStartup: true, disablePowerOnBehavior: true}),
         meta: {applyRedFix: true, enhancedHue: false},
     },
     {
@@ -998,7 +999,7 @@ module.exports = [
         vendor: 'TuYa',
         description: 'Zigbee RGB light',
         whiteLabel: [{vendor: 'BTF-Lighting', model: 'C03Z'}],
-        extend: extend.light_onoff_brightness_color(),
+        extend: extend.light_onoff_brightness_color({disablePowerOnBehavior: true}),
         // Requires red fix: https://github.com/Koenkk/zigbee2mqtt/issues/5962#issue-796462106
         meta: {applyRedFix: true, enhancedHue: false},
     },
@@ -1007,7 +1008,7 @@ module.exports = [
         model: 'TS0504B',
         vendor: 'TuYa',
         description: 'Zigbee RGBW light',
-        extend: extend.light_onoff_brightness_color(),
+        extend: extend.light_onoff_brightness_color({disablePowerOnBehavior: true}),
         toZigbee: utils.replaceInArray(extend.light_onoff_brightness_color().toZigbee, [tz.light_color], [tzLocal.TS0504B_color]),
         meta: {applyRedFix: true},
     },
@@ -1016,14 +1017,14 @@ module.exports = [
         model: 'TS0501A',
         description: 'Zigbee light',
         vendor: 'TuYa',
-        extend: extend.light_onoff_brightness(),
+        extend: extend.light_onoff_brightness({disablePowerOnBehavior: true}),
     },
     {
         zigbeeModel: ['TS0501B'],
         model: 'TS0501B',
         description: 'Zigbee light',
         vendor: 'TuYa',
-        extend: extend.light_onoff_brightness(),
+        extend: extend.light_onoff_brightness({disablePowerOnBehavior: true}),
     },
     {
         fingerprint: tuya.fingerprint('TS0202', ['_TZ3210_cwamkvua']),
@@ -1207,6 +1208,7 @@ module.exports = [
             {modelID: 'TS0601', manufacturerName: '_TZE200_ojzhk75b'},
             {modelID: 'TS0601', manufacturerName: '_TZE200_swaamsoy'},
             {modelID: 'TS0601', manufacturerName: '_TZE200_3p5ydos3'},
+            {modelID: 'TS0601', manufacturerName: '_TZE200_p0gzbqct'},
         ],
         model: 'TS0601_dimmer',
         vendor: 'TuYa',
@@ -1557,7 +1559,7 @@ module.exports = [
         model: 'TS0503A',
         vendor: 'TuYa',
         description: 'Led strip controller',
-        extend: extend.light_onoff_brightness_color(),
+        extend: extend.light_onoff_brightness_color({disablePowerOnBehavior: true}),
         meta: {applyRedFix: true},
     },
     {
@@ -1574,7 +1576,7 @@ module.exports = [
         model: 'TS0502A',
         vendor: 'TuYa',
         description: 'Light controller',
-        extend: extend.light_onoff_brightness_colortemp(),
+        extend: extend.light_onoff_brightness_colortemp({disablePowerOnBehavior: true}),
     },
     {
         zigbeeModel: ['TS0502B'],
@@ -1585,14 +1587,14 @@ module.exports = [
             {vendor: 'Mercator Ikuü', model: 'SMI7040', description: 'Ford Batten Light'},
             {vendor: 'Mercator Ikuü', model: 'SMD9300', description: 'Donovan Panel Light'},
         ],
-        extend: extend.light_onoff_brightness_colortemp({colorTempRange: [153, 500]}),
+        extend: extend.light_onoff_brightness_colortemp({colorTempRange: [153, 500], disablePowerOnBehavior: true}),
     },
     {
         zigbeeModel: ['TS0504A'],
         model: 'TS0504A',
         vendor: 'TuYa',
         description: 'RGBW LED controller',
-        extend: extend.light_onoff_brightness_colortemp_color(),
+        extend: extend.light_onoff_brightness_colortemp_color({disablePowerOnBehavior: true}),
     },
     {
         fingerprint: [{modelID: 'TS0505A', manufacturerName: '_TZ3000_sosdczdl'}],
@@ -1608,7 +1610,7 @@ module.exports = [
         model: 'TS0505A',
         vendor: 'TuYa',
         description: 'RGB+CCT light controller',
-        extend: extend.light_onoff_brightness_colortemp_color(),
+        extend: extend.light_onoff_brightness_colortemp_color({disablePowerOnBehavior: true}),
     },
     {
         fingerprint: [{manufacturerName: '_TZ2000_a476raq2'}],
@@ -3656,7 +3658,7 @@ module.exports = [
         },
     },
     {
-        fingerprint: [{modelID: 'TS110E', manufacturerName: '_TZ3210_zxbtub8r'}],
+        fingerprint: tuya.fingerprint('TS110E', ['_TZ3210_zxbtub8r', '_TZ3210_k1msuvg6']),
         model: 'TS110E_1gang_1',
         vendor: 'TuYa',
         description: '1 channel dimmer',

package/devices/xiaomi.js

@@ -441,6 +441,7 @@ module.exports = [
         fromZigbee: [fz.temperature, fz.humidity, fzLocal.aqara_s1_pm25, fzLocal.aqara_s1_co2],
         toZigbee: [],
         exposes: [e.temperature(), e.humidity(), e.pm25(), e.co2()],
+        ota: ota.zigbeeOTA,
     },
     {
         zigbeeModel: ['lumi.magnet.acn001'],
@@ -693,7 +694,8 @@ module.exports = [
             exposes.enum('operation_mode', ea.ALL, ['control_relay', 'decoupled']).withDescription('Decoupled mode'),
             exposes.enum('mode_switch', ea.ALL, ['anti_flicker_mode', 'quick_mode'])
                 .withDescription('Anti flicker mode can be used to solve blinking issues of some lights.' +
-                    'Quick mode makes the device respond faster.')],
+                    'Quick mode makes the device respond faster.'),
+            e.power_outage_count(), e.device_temperature().withAccess(ea.STATE)],
         onEvent: preventReset,
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint1 = device.getEndpoint(1);
@@ -707,19 +709,35 @@ module.exports = [
         model: 'WS-USC02',
         vendor: 'Xiaomi',
         description: 'Aqara smart wall switch (no neutral, double rocker)',
-        extend: extend.switch(),
-        exposes: [e.switch().withEndpoint('top'), e.switch().withEndpoint('bottom')],
+        fromZigbee: [fz.on_off, fz.xiaomi_multistate_action, fz.aqara_opple],
+        toZigbee: [tz.on_off, tz.xiaomi_switch_operation_mode_opple, tz.xiaomi_flip_indicator_light, tz.aqara_switch_mode_switch],
+        exposes: [
+            e.switch().withEndpoint('top'),
+            e.switch().withEndpoint('bottom'),
+            exposes.enum('operation_mode', ea.ALL, ['control_relay', 'decoupled'])
+                .withDescription('Decoupled mode for top button')
+                .withEndpoint('top'),
+            exposes.enum('operation_mode', ea.ALL, ['control_relay', 'decoupled'])
+                .withDescription('Decoupled mode for bottom button')
+                .withEndpoint('bottom'),
+            exposes.enum('mode_switch', ea.ALL, ['anti_flicker_mode', 'quick_mode'])
+                .withDescription(
+                    'Anti flicker mode can be used to solve blinking issues of some lights.' +
+                    'Quick mode makes the device respond faster.',
+                ),
+            e.power_outage_count(),
+            e.device_temperature().withAccess(ea.STATE),
+            e.flip_indicator_light(),
+            e.action(['single_top', 'single_bottom', 'single_both', 'double_top', 'double_bottom', 'double_both'])],
         meta: {multiEndpoint: true},
         endpoint: (device) => {
             return {'top': 1, 'bottom': 2};
         },
+        onEvent: preventReset,
         configure: async (device, coordinatorEndpoint, logger) => {
-            const endpoint1 = device.getEndpoint(1);
-            await reporting.bind(endpoint1, coordinatorEndpoint, ['genOnOff']);
-            await reporting.onOff(endpoint1);
-            const endpoint2 = device.getEndpoint(2);
-            await reporting.bind(endpoint2, coordinatorEndpoint, ['genOnOff']);
-            await reporting.onOff(endpoint2);
+            await device.getEndpoint(1).write(
+                'aqaraOpple', {mode: 1}, {manufacturerCode: 0x115f, disableResponse: true},
+            );
         },
         ota: ota.zigbeeOTA,
     },
@@ -1862,6 +1880,27 @@ module.exports = [
                 .withDescription('The current state of the motor.'), e.power_outage_count()],
         ota: ota.zigbeeOTA,
     },
+    {
+        zigbeeModel: ['lumi.curtain.hagl07'],
+        model: 'ZNCLDJ14LM',
+        vendor: 'Xiaomi',
+        description: 'Aqara C2 curtain motor',
+        fromZigbee: [fz.xiaomi_basic, fz.xiaomi_curtain_position, fz.xiaomi_curtain_position_tilt, fz.xiaomi_curtain_hagl07_status],
+        toZigbee: [tz.xiaomi_curtain_position_state, tz.xiaomi_curtain_options],
+        onEvent: async (type, data, device) => {
+            // The position (genAnalogOutput.presentValue) reported via an attribute contains an invaid value
+            // however when reading it will provide the correct value.
+            if (data.type === 'attributeReport' && data.cluster === 'genAnalogOutput') {
+                await device.endpoints[0].read('genAnalogOutput', ['presentValue']);
+            }
+        },
+        exposes: [e.cover_position().setAccess('state', ea.ALL),
+            exposes.binary('running', ea.STATE, true, false)
+                .withDescription('Whether the motor is moving or not'),
+            exposes.enum('motor_state', ea.STATE, ['closing', 'opening', 'stop'])
+                .withDescription('The current state of the motor.'), e.power_outage_count()],
+        ota: ota.zigbeeOTA,
+    },
     {
         zigbeeModel: ['lumi.curtain.acn002'],
         model: 'ZNJLBL01LM',
@@ -1900,22 +1939,38 @@ module.exports = [
         vendor: 'Xiaomi',
         whiteLabel: [{vendor: 'Xiaomi', model: 'CM-M01'}],
         description: 'Aqara curtain driver E1',
-        fromZigbee: [fz.battery, fz.xiaomi_curtain_position_tilt, fz.aqara_opple, fz.power_source],
-        toZigbee: [tz.xiaomi_curtain_position_state, tz.ZNCLBL01LM_battery_voltage, tz.ZNCLBL01LM_hooks_state,
-            tz.power_source, tz.battery_percentage_remaining],
-        exposes: [e.cover_position().setAccess('state', ea.ALL), e.battery().withAccess(ea.STATE_GET),
+        fromZigbee: [
+            fz.battery,
+            fz.xiaomi_curtain_position_tilt,
+            fz.aqara_opple,
+            fz.power_source,
+        ],
+        toZigbee: [
+            tz.xiaomi_curtain_position_state,
+            tz.xiaomi_curtain_battery_voltage,
+            tz.ZNCLBL01LM_hooks_lock,
+            tz.ZNCLBL01LM_hooks_state,
+            tz.ZNCLBL01LM_hand_open,
+            tz.ZNCLBL01LM_limits_calibration,
+            tz.power_source,
+            tz.battery_percentage_remaining,
+        ],
+        exposes: [
+            e.cover_position().setAccess('state', ea.ALL),
+            exposes.binary('hand_open', ea.ALL, true, false).withDescription('Pulling curtains by hand starts the motor'),
+            exposes.enum('limits_calibration', ea.SET, ['start', 'end', 'reset']).withDescription('Calibrate the position limits'),
+            e.battery().withAccess(ea.STATE_GET),
             e.battery_voltage().withAccess(ea.STATE_GET),
             e.device_temperature(),
             e.action(['manual_open', 'manual_close']),
-            exposes.enum('motor_state', ea.STATE, ['stopped', 'opening', 'closing', 'pause'])
-                .withDescription('Motor state'),
-            exposes.binary('running', ea.STATE, true, false)
-                .withDescription('Whether the motor is moving or not'),
-            exposes.enum('hooks_state', ea.STATE_GET, ['unlocked', 'locked', 'locking', 'unlocking'])
-                .withDescription('Hooks state'),
+            exposes.enum('motor_state', ea.STATE, ['stopped', 'opening', 'closing', 'pause']).withDescription('Motor state'),
+            exposes.binary('running', ea.STATE, true, false).withDescription('Whether the motor is moving or not'),
+            exposes.enum('hooks_lock', ea.STATE_SET, ['LOCK', 'UNLOCK']).withDescription('Lock the curtain driver hooks'),
+            exposes.enum('hooks_state', ea.STATE_GET, ['unlocked', 'locked', 'locking', 'unlocking']).withDescription('Hooks state'),
             exposes.numeric('target_position', ea.STATE).withUnit('%').withDescription('Target position'),
             exposes.enum('power_source', ea.STATE_GET, ['battery', 'dc_source']).withDescription('The current power source'),
-            exposes.binary('charging', ea.STATE_GET, true, false).withDescription('The current charging state')],
+            exposes.binary('charging', ea.STATE_GET, true, false).withDescription('The current charging state'),
+        ],
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
             await endpoint.read('genPowerCfg', ['batteryPercentageRemaining']);
@@ -1944,6 +1999,10 @@ module.exports = [
                 .withDescription('Enabling prevents both relais being on at the same time'),
         ],
         ota: ota.zigbeeOTA,
+        configure: async (device, coordinatorEndpoint, logger) => {
+            device.powerSource = 'Mains (single phase)';
+            device.save();
+        },
     },
     {
         zigbeeModel: ['lumi.lock.acn02'],
@@ -2165,6 +2224,8 @@ module.exports = [
             e.voltage().withAccess(ea.STATE), e.power_outage_memory(), e.led_disabled_night(), e.switch_type()],
         configure: async (device, coordinatorEndpoint, logger) => {
             await device.getEndpoint(1).write('aqaraOpple', {'mode': 1}, {manufacturerCode: 0x115f, disableResponse: true});
+            device.powerSource = 'Mains (single phase)';
+            device.save();
         },
         ota: ota.zigbeeOTA,
     },
@@ -2441,6 +2502,7 @@ module.exports = [
             const endpoint1 = device.getEndpoint(1);
             await endpoint1.write('aqaraOpple', {'mode': 1}, {manufacturerCode: 0x115f, disableResponse: true});
         },
+        ota: ota.zigbeeOTA,
     },
     {
         zigbeeModel: ['lumi.sen_ill.agl01'],

package/lib/utils.js

@@ -77,10 +77,11 @@ function hasAlreadyProcessedMessage(msg, model, ID=null, key=null) {
 
 const calibrateAndPrecisionRoundOptionsDefaultPrecision = {
     temperature: 2, humidity: 2, pressure: 1, pm25: 0, power: 2, current: 2, current_phase_b: 2, current_phase_c: 2,
-    voltage: 2, voltage_phase_b: 2, voltage_phase_c: 2, power_phase_b: 2, power_phase_c: 2,
+    voltage: 2, voltage_phase_b: 2, voltage_phase_c: 2, power_phase_b: 2, power_phase_c: 2, energy: 2,
 };
 function calibrateAndPrecisionRoundOptionsIsPercentual(type) {
-    return type.startsWith('current') || type.startsWith('voltage') || type.startsWith('power') || type.startsWith('illuminance');
+    return type.startsWith('current') || type.startsWith('energy') || type.startsWith('voltage') || type.startsWith('power') ||
+        type.startsWith('illuminance');
 }
 function calibrateAndPrecisionRoundOptions(number, options, type) {
     // Calibrate

package/lib/xiaomi.js

@@ -3,11 +3,14 @@
 const {
     batteryVoltageToPercentage,
     calibrateAndPrecisionRoundOptions,
+    calibrateAndPrecisionRoundOptionsIsPercentual,
     postfixWithEndpointName,
     precisionRound,
     getKey,
 } = require('./utils');
 
+const exposes = require('../lib/exposes');
+
 const buffer2DataObject = (meta, model, buffer) => {
     const dataObject = {};
 
@@ -337,27 +340,27 @@ const numericAttributes2Payload = (msg, meta, model, options, dataObject) => {
             }
             break;
         case '149':
-            payload.energy = precisionRound(value, 2); // 0x95
+            payload.energy = calibrateAndPrecisionRoundOptions(value, options, 'energy'); // 0x95
             // Consumption is deprecated
             payload.consumption = payload.energy;
             break;
         case '150':
             if (!['JTYJ-GD-01LM/BW'].includes(model.model)) {
-                payload.voltage = precisionRound(value * 0.1, 1); // 0x96
+                payload.voltage = calibrateAndPrecisionRoundOptions(value * 0.1, options, 'voltage'); // 0x96
             }
             break;
         case '151':
             if (['LLKZMK11LM'].includes(model.model)) {
-                payload.current = precisionRound(value, 4);
+                payload.current = calibrateAndPrecisionRoundOptions(value, options, 'current');
             } else {
-                payload.current = precisionRound(value * 0.001, 4);
+                payload.current = calibrateAndPrecisionRoundOptions(value * 0.001, options, 'current');
             }
             break;
         case '152':
             if (['DJT11LM'].includes(model.model)) {
                 // We don't know what implies for this device, it contains values like 30, 50,... that don't seem to change
             } else {
-                payload.power = precisionRound(value, 2); // 0x98
+                payload.power = calibrateAndPrecisionRoundOptions(value, options, 'power'); // 0x98
             }
             break;
         case '154':
@@ -545,10 +548,15 @@ const numericAttributes2Payload = (msg, meta, model, options, dataObject) => {
             payload.button_switch_mode = value === 1 ? 'relay_and_usb' : 'relay';
             break;
         case '1025':
-            payload.options = {...payload.options, // next values update only when curtain finished initial setup and knows current position
-                reverse_direction: value[2] == '\u0001',
-                hand_open: value[5] == '\u0000',
-            };
+            if (['ZNCLBL01LM'].includes(model.model)) {
+                payload.hand_open = !value;
+            } else {
+                // next values update only when curtain finished initial setup and knows current position
+                payload.options = {...payload.options,
+                    reverse_direction: value[2] == '\u0001',
+                    hand_open: value[5] == '\u0000',
+                };
+            }
             break;
         case '1028':
             payload = {...payload,
@@ -597,9 +605,15 @@ const numericAttributes2Payload = (msg, meta, model, options, dataObject) => {
                     {1: 'manual_open', 2: 'manual_close'})[value];
             }
             break;
+        case '1063':
+            if (['ZNCLBL01LM'].includes(model.model)) {
+                payload.hooks_lock = {0: 'UNLOCK', 1: 'LOCK'}[value];
+            }
+            break;
         case '1064':
             if (['ZNCLBL01LM'].includes(model.model)) {
                 payload.hooks_state = {0: 'unlocked', 1: 'locked', 2: 'locking', 3: 'unlocking'}[value];
+                payload.hooks_lock = {0: 'UNLOCK', 1: 'LOCK', 2: 'UNLOCK', 3: 'LOCK'}[value];
             }
             break;
         case '1289':
@@ -650,8 +664,29 @@ const VOCKQJK11LMDisplayUnit = {
     'ppb_fahrenheit': 0x11, // ppb, °F
 };
 
+const numericAttributes2Options = (definition) => {
+    const supported = ['temperature', 'device_temperature', 'illuminance', 'illuminance_lux',
+        'pressure', 'power', 'current', 'voltage', 'energy', 'power'];
+    const precisionSupported = ['temperature', 'humidity', 'pressure', 'power', 'current', 'voltage', 'energy', 'power'];
+    const result = [];
+    for (const expose of definition.exposes) {
+        // only eletrical measurement voltage is supported, not battery
+        const isBatteryVoltage = expose.name === 'voltage' && definition.meta && definition.meta.battery;
+        if (supported.includes(expose.name) && !isBatteryVoltage) {
+            const type = calibrateAndPrecisionRoundOptionsIsPercentual(expose.name) ? 'percentual' : 'absolute';
+            result.push(exposes.options.calibration(expose.name, type));
+            if (precisionSupported.includes(expose.name)) {
+                result.push(exposes.options.precision(expose.name));
+            }
+        }
+    }
+
+    return result;
+};
+
 module.exports = {
     buffer2DataObject,
     numericAttributes2Payload,
+    numericAttributes2Options,
     VOCKQJK11LMDisplayUnit,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zigbee-herdsman-converters",
-  "version": "14.0.691",
+  "version": "14.0.693",
   "description": "Collection of device converters to be used with zigbee-herdsman",
   "main": "index.js",
   "files": [