zigbee-herdsman-converters 14.0.557 → 14.0.560

package/converters/fromZigbee.js

@@ -7273,7 +7273,7 @@ const converters = {
         cluster: 'genOnOff',
         type: ['attributeReport', 'readResponse'],
         convert: (model, msg, publish, options, meta) => {
-            const property = 0x8002;
+            const property = 'moesStartUpOnOff';
 
             if (msg.data.hasOwnProperty(property)) {
                 const dict = {0x00: 'off', 0x01: 'on', 0x02: 'restore'};

package/converters/toZigbee.js

@@ -3577,7 +3577,7 @@ const converters = {
             const lookup = {'off': 0x00, 'on': 0x01, 'restore': 0x02};
             utils.validateValue(value, Object.keys(lookup));
             const payload = lookup[value];
-            await entity.write('genOnOff', {0x8002: {value: payload, type: 0x30}});
+            await entity.write('genOnOff', {moesStartUpOnOff: payload});
             return {state: {power_outage_memory: value}};
         },
     },

package/devices/evvr.js

@@ -0,0 +1,17 @@
+const reporting = require('../lib/reporting');
+const extend = require('../lib/extend');
+
+module.exports = [
+    {
+        zigbeeModel: ['SRB01', 'SRB01A'],
+        model: 'SRB01',
+        vendor: 'Evvr',
+        description: 'In-wall relay switch',
+        extend: extend.switch(),
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff']);
+            await reporting.onOff(endpoint);
+        },
+    },
+];

package/devices/jasco.js

@@ -25,6 +25,7 @@ module.exports = [
         vendor: 'Jasco',
         description: 'Zigbee smart outlet',
         extend: extend.switch(),
+        fromZigbee: [...extend.switch().fromZigbee, fz.metering],
         exposes: [e.switch(), e.power(), e.energy()],
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
@@ -32,6 +33,7 @@ module.exports = [
             await reporting.onOff(endpoint);
             await reporting.readMeteringMultiplierDivisor(endpoint);
             await reporting.instantaneousDemand(endpoint);
+            await reporting.currentSummDelivered(endpoint);
         },
     },
     {

package/devices/lidl.js

@@ -795,7 +795,7 @@ module.exports = [
         meta: {enhancedHue: false},
     },
     {
-        fingerprint: [{modelID: 'TS0505B', manufactureName: '_TZ3000_bwlvyjwk'}],
+        fingerprint: [{modelID: 'TS0505B', manufacturerName: '_TZ3000_bwlvyjwk'}],
         model: 'HG08383B',
         vendor: 'Lidl',
         description: 'Livarno outdoor LED light chain',

package/devices/lonsonho.js

@@ -3,9 +3,47 @@ const fz = {...require('../converters/fromZigbee'), legacy: require('../lib/lega
 const tz = require('../converters/toZigbee');
 const reporting = require('../lib/reporting');
 const extend = require('../lib/extend');
+const utils = require('../lib/utils');
 const e = exposes.presets;
 const ea = exposes.access;
 
+const fzLocal = {
+    TS110E_switch_type: {
+        cluster: 'genLevelCtrl',
+        type: ['attributeReport', 'readResponse'],
+        convert: (model, msg, publish, options, meta) => {
+            const property = 0xfc02;
+            if (msg.data.hasOwnProperty(property)) {
+                const value = msg.data[property];
+                const lookup = {0: 'momentary', 1: 'toggle', 2: 'state'};
+                if (lookup.hasOwnProperty(value)) {
+                    const propertyName = utils.postfixWithEndpointName('switch_type', msg, model);
+                    return {[propertyName]: lookup[value]};
+                }
+            }
+        },
+    },
+};
+
+const tzLocal = {
+    TS110E_switch_type: {
+        key: ['switch_type'],
+        convertSet: async (entity, key, value, meta) => {
+            value = value.toLowerCase();
+            const lookup = {'momentary': 0, 'toggle': 1, 'state': 2};
+
+            utils.validateValue(value, Object.keys(lookup));
+            const payload = lookup[value];
+
+            await entity.write('genLevelCtrl', {0xfc02: {value: payload, type: 0x20}});
+            return {state: {switch_type: value}};
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read('genLevelCtrl', [0xfc02]);
+        },
+    },
+};
+
 module.exports = [
     {
         fingerprint: [{modelID: 'TS130F', manufacturerName: '_TZ3000_vd43bbfq'}, {modelID: 'TS130F', manufacturerName: '_TZ3000_fccpjz5z'}],
@@ -33,7 +71,7 @@ module.exports = [
             exposes.numeric('calibration_time', ea.STATE).withUnit('S').withDescription('Calibration time')],
     },
     {
-        fingerprint: [{modelID: 'TS130F', manufacturerName: '_TZ3000_j1xl73iw'}],
+        fingerprint: [{modelID: 'TS130F', manufacturerName: '_TZ3000_j1xl73iw'}, {modelID: 'TS130F', manufacturerName: '_TZ3000_kmsbwdol'}],
         model: 'TS130F_dual',
         vendor: 'Lonsonho',
         description: 'Dual curtain/blind module',
@@ -221,9 +259,19 @@ module.exports = [
         model: 'TS110E_2gang',
         vendor: 'Lonsonho',
         description: 'Zigbee smart dimmer module 2 gang with neutral',
-        extend: extend.light_onoff_brightness({noConfigure: true}),
+        fromZigbee: extend.light_onoff_brightness({disablePowerOnBehavior: true}).fromZigbee.concat([
+            fz.tuya_switch_power_outage_memory, fzLocal.TS110E_switch_type]),
+        toZigbee: extend.light_onoff_brightness({disablePowerOnBehavior: true}).toZigbee.concat([
+            tz.tuya_switch_power_outage_memory, tzLocal.TS110E_switch_type]),
         meta: {multiEndpoint: true},
-        exposes: [e.light_brightness().withEndpoint('l1'), e.light_brightness().withEndpoint('l2')],
+        exposes: [
+            e.light_brightness().withEndpoint('l1'),
+            e.light_brightness().withEndpoint('l2'),
+            exposes.enum('power_outage_memory', ea.STATE_SET, ['on', 'off', 'restore']).withDescription('Recover state after power outage')
+                .withEndpoint('l1'),
+            exposes.presets.switch_type_2().withEndpoint('l1'),
+            exposes.presets.switch_type_2().withEndpoint('l2'),
+        ],
         configure: async (device, coordinatorEndpoint, logger) => {
             await extend.light_onoff_brightness().configure(device, coordinatorEndpoint, logger);
             await reporting.bind(device.getEndpoint(1), coordinatorEndpoint, ['genOnOff', 'genLevelCtrl']);

package/devices/lupus.js

@@ -18,7 +18,7 @@ module.exports = [
         exposes: [e.cover_position().setAccess('state', ea.ALL)],
     },
     {
-        zigbeeModel: ['SCM-3-OTA_00.00.03.16TC', 'SCM-6-OTA_00.00.03.17TC'],
+        zigbeeModel: ['SCM-3-OTA_00.00.03.16TC', 'SCM-6-OTA_00.00.03.17TC', 'SCM-6-OTA_00.00.03.18TC'],
         model: 'LS12128',
         vendor: 'Lupus',
         description: 'Roller shutter',

package/devices/moes.js

@@ -7,6 +7,10 @@ const reporting = require('../lib/reporting');
 const extend = require('../lib/extend');
 const e = exposes.presets;
 const ea = exposes.access;
+const zosung = require('../lib/zosung');
+const fzZosung = zosung.fzZosung;
+const tzZosung = zosung.tzZosung;
+const ez = zosung.presetsZosung;
 
 module.exports = [
     {
@@ -299,7 +303,8 @@ module.exports = [
         },
     },
     {
-        fingerprint: [{modelID: 'TS0505B', manufacturerName: '_TZ3000_7hcgjxpc'}],
+        fingerprint: [{modelID: 'TS0505B', manufacturerName: '_TZ3000_7hcgjxpc'},
+            {modelID: 'TS0505B', manufacturerName: '_TZ3210_rcggc0ys'}],
         model: 'ZLD-RCW',
         vendor: 'Moes',
         description: 'RGB+CCT Zigbee LED Controller',
@@ -308,7 +313,7 @@ module.exports = [
         ]),
         meta: {applyRedFix: true, enhancedHue: false},
         fromZigbee: extend.light_onoff_brightness_colortemp_color().fromZigbee,
-        exposes: extend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 500]}).exposes.concat([
+        exposes: extend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 500], disableColorTempStartup: true}).exposes.concat([
             exposes.binary('do_not_disturb', ea.STATE_SET, true, false)
                 .withDescription('Do not disturb mode'),
             exposes.enum('color_power_on_behavior', ea.STATE_SET, ['initial', 'previous', 'cutomized'])
@@ -336,4 +341,24 @@ module.exports = [
         exposes: [e.cover_position().setAccess('position', ea.STATE_SET), exposes.enum('backlight', ea.STATE_SET, ['OFF', 'ON']),
             exposes.enum('calibration', ea.STATE_SET, ['OFF', 'ON']), exposes.enum('motor_reversal', ea.STATE_SET, ['OFF', 'ON'])],
     },
+    {
+        fingerprint: [{modelID: 'TS1201', manufacturerName: '_TZ3290_j37rooaxrcdcqo5n'}],
+        model: 'UFO-R11',
+        vendor: 'Moes',
+        description: 'Universal smart IR remote control',
+        fromZigbee: [
+            fzZosung.zosung_send_ir_code_00, fzZosung.zosung_send_ir_code_01, fzZosung.zosung_send_ir_code_02,
+            fzZosung.zosung_send_ir_code_03, fzZosung.zosung_send_ir_code_04, fzZosung.zosung_send_ir_code_05,
+            fz.battery,
+        ],
+        toZigbee: [tzZosung.zosung_ir_code_to_send, tzZosung.zosung_learn_ir_code],
+        exposes: [ez.learn_ir_code(), ez.learned_ir_code(), ez.ir_code_to_send(), e.battery(), e.battery_voltage()],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await endpoint.read('genPowerCfg', ['batteryVoltage', 'batteryPercentageRemaining']);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg']);
+            await reporting.batteryPercentageRemaining(endpoint);
+            await reporting.batteryVoltage(endpoint);
+        },
+    },
 ];

package/devices/philips.js

@@ -2111,7 +2111,7 @@ module.exports = [
         extend: hueExtend.light_onoff_brightness_colortemp(),
     },
     {
-        zigbeeModel: ['929003047101'],
+        zigbeeModel: ['929003047101', '929003045101_03'],
         model: '929003047101',
         vendor: 'Philips',
         description: 'Hue White ambiance Milliskin (round)',

package/devices/plugwise.js

@@ -2,8 +2,97 @@ const exposes = require('../lib/exposes');
 const fz = {...require('../converters/fromZigbee'), legacy: require('../lib/legacy').fromZigbee};
 const tz = require('../converters/toZigbee');
 const reporting = require('../lib/reporting');
+const utils = require('../lib/utils');
 const e = exposes.presets;
 const ea = exposes.access;
+const herdsman = require('zigbee-herdsman');
+
+const manufacturerOptions = {manufacturerCode: herdsman.Zcl.ManufacturerCode.PLUGWISE_BV};
+
+const plugwisePushForce = {
+    0: 'standard',
+    0x60000: 'high',
+    0x70000: 'very_high',
+};
+
+const plugwiseRadioStrength = {
+    0: 'normal',
+    1: 'high',
+};
+
+const fzLocal = {
+    plugwise_radiator_valve: {
+        cluster: 'hvacThermostat',
+        type: ['attributeReport', 'readResponse'],
+        convert: (model, msg, publish, options, meta) => {
+            const result = fz.thermostat.convert(model, msg, publish, options, meta);
+
+            // Reports pIHeatingDemand between 0 and 100 already
+            if (typeof msg.data['pIHeatingDemand'] == 'number') {
+                result.pi_heating_demand = utils.precisionRound(msg.data['pIHeatingDemand'], 0);
+            }
+
+            if (typeof msg.data[0x4003] == 'number') {
+                result.current_heating_setpoint = utils.precisionRound(msg.data[0x4003], 2) / 100;
+            }
+            if (typeof msg.data[0x4008] == 'number') {
+                result.plugwise_t_diff = msg.data[0x4008];
+            }
+            if (typeof msg.data[0x4002] == 'number') {
+                result.error_status = msg.data[0x4002];
+            }
+            if (typeof msg.data[0x4001] == 'number') {
+                result.valve_position = msg.data[0x4001];
+            }
+            return result;
+        },
+    },
+};
+
+const tzLocal = {
+    plugwise_calibrate_valve: {
+        key: ['calibrate_valve'],
+        convertSet: async (entity, key, value, meta) => {
+            await entity.command('hvacThermostat', 'plugwiseCalibrateValve', {},
+                {srcEndpoint: 11, disableDefaultResponse: true, sendWhen: 'active'});
+            return {state: {'calibrate_valve': value}};
+        },
+    },
+    plugwise_valve_position: {
+        key: ['plugwise_valve_position', 'valve_position'],
+        convertSet: async (entity, key, value, meta) => {
+            const payload = {0x4001: {value, type: 0x20}};
+            await entity.write('hvacThermostat', payload, manufacturerOptions);
+            // Tom does not automatically send back updated value so ask for it
+            await entity.read('hvacThermostat', [0x4001], manufacturerOptions);
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read('hvacThermostat', [0x4001], manufacturerOptions);
+        },
+    },
+    plugwise_push_force: {
+        key: ['plugwise_push_force', 'force'],
+        convertSet: async (entity, key, value, meta) => {
+            const val = utils.getKey(plugwisePushForce, value, value, Number);
+            const payload = {0x4012: {value: val, type: 0x23}};
+            await entity.write('hvacThermostat', payload, manufacturerOptions);
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read('hvacThermostat', [0x4012], manufacturerOptions);
+        },
+    },
+    plugwise_radio_strength: {
+        key: ['plugwise_radio_strength', 'radio_strength'],
+        convertSet: async (entity, key, value, meta) => {
+            const val = utils.getKey(plugwiseRadioStrength, value, value, Number);
+            const payload = {0x4014: {value: val, type: 0x10}};
+            await entity.write('hvacThermostat', payload, manufacturerOptions);
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read('hvacThermostat', [0x4014], manufacturerOptions);
+        },
+    },
+};
 
 module.exports = [
     {
@@ -27,18 +116,37 @@ module.exports = [
         model: '106-03',
         vendor: 'Plugwise',
         description: 'Tom thermostatic radiator valve',
-        fromZigbee: [fz.thermostat, fz.temperature, fz.battery],
-        toZigbee: [tz.thermostat_system_mode, tz.thermostat_occupied_heating_setpoint, tz.thermostat_pi_heating_demand],
+        fromZigbee: [fz.thermostat, fz.temperature, fz.battery, fzLocal.plugwise_radiator_valve],
+        toZigbee: [
+            tz.thermostat_system_mode,
+            tz.thermostat_occupied_heating_setpoint,
+            tz.thermostat_pi_heating_demand,
+            tzLocal.plugwise_valve_position,
+            tzLocal.plugwise_push_force,
+            tzLocal.plugwise_radio_strength,
+            tzLocal.plugwise_calibrate_valve,
+        ],
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
             await reporting.bind(endpoint, coordinatorEndpoint, ['genBasic', 'genPowerCfg', 'hvacThermostat']);
             await reporting.batteryPercentageRemaining(endpoint);
+            await reporting.thermostatTemperature(endpoint);
+            await reporting.thermostatPIHeatingDemand(endpoint);
         },
         exposes: [e.battery(),
             exposes.climate()
                 .withSetpoint('occupied_heating_setpoint', 5, 30, 0.5, ea.ALL).withLocalTemperature(ea.STATE)
                 .withSystemMode(['off', 'auto'], ea.ALL)
                 .withPiHeatingDemand(ea.STATE_GET),
+            exposes.numeric('valve_position', ea.ALL).withValueMin(0).withValueMax(100)
+                .withDescription('Directly control the radiator valve. The values range from 0 (valve ' +
+                    'closed) to 100 (valve fully open)'),
+            exposes.enum('force', ea.ALL, ['standard', 'high', 'very_high'])
+                .withDescription('How hard the motor pushes the valve. The closer to the boiler, the higher the force needed'),
+            exposes.enum('radio_strength', ea.ALL, ['normal', 'high'])
+                .withDescription('Transmits with higher power when range is not sufficient'),
+            exposes.binary('calibrate_valve', ea.STATE_SET, 'calibrate', 'idle')
+                .withDescription('Calibrates valve on next wakeup'),
         ],
     },
 ];

package/devices/third_reality.js

@@ -121,4 +121,17 @@ module.exports = [
         },
         exposes: [e.cover_position(), e.battery()],
     },
+    {
+        zigbeeModel: ['3RSB22BZ'],
+        model: '3RSB22BZ',
+        vendor: 'Third Reality',
+        description: 'Smart button',
+        fromZigbee: [fz.battery, fz.itcmdr_clicks],
+        toZigbee: [],
+        exposes: [e.battery(), e.battery_low(), e.battery_voltage(), e.action(['single', 'double', 'long'])],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            device.powerSource = 'Battery';
+            device.save();
+        },
+    },
 ];

package/devices/tuya.js

@@ -470,7 +470,6 @@ module.exports = [
             {modelID: 'TS0505B', manufacturerName: '_TZ3210_qxenlrin'},
             {modelID: 'TS0505B', manufacturerName: '_TZ3210_iwbaamgh'},
             {modelID: 'TS0505B', manufacturerName: '_TZ3210_klv2wul0'},
-            {modelID: 'TS0505B', manufacturerName: '_TZ3210_rcggc0ys'},
             {modelID: 'TS0505B', manufacturerName: '_TZ3210_s6zec0of'},
             {modelID: 'TS0505B', manufacturerName: '_TZ3210_y5fjkn7x'},
             {modelID: 'TS0505B', manufacturerName: '_TZ3210_cuqkfz2q'},
@@ -503,6 +502,7 @@ module.exports = [
         fingerprint: [{modelID: 'TS0504B', manufacturerName: '_TZ3000_ukuvyhaa'},
             {modelID: 'TS0504B', manufacturerName: '_TZ3210_bfvybixd'},
             {modelID: 'TS0504B', manufacturerName: '_TZ3210_i2i0bsnv'},
+            {modelID: 'TS0504B', manufacturerName: '_TZ3210_elzv6aia'},
             {modelID: 'TS0504B', manufacturerName: '_TZ3210_1elppmba'}],
         model: 'TS0504B',
         vendor: 'TuYa',

package/devices/weiser.js

@@ -40,14 +40,28 @@ module.exports = [
         model: '9GED21500-005',
         vendor: 'Weiser',
         description: 'SmartCode 10 Touch',
-        fromZigbee: [fz.lock, fz.lock_operation_event, fz.battery],
-        toZigbee: [tz.lock],
+        fromZigbee: [fz.lock, fz.lock_operation_event, fz.battery, fz.lock_programming_event, fz.lock_pin_code_response],
+        toZigbee: [tz.lock, tz.pincode_lock],
+        meta: {pinCodeCount: 30},
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(2);
             await reporting.bind(endpoint, coordinatorEndpoint, ['closuresDoorLock', 'genPowerCfg']);
             await reporting.lockState(endpoint);
             await reporting.batteryPercentageRemaining(endpoint);
         },
-        exposes: [e.lock(), e.battery(), e.lock_action(), e.lock_action_source_name(), e.lock_action_source_user()],
+        // Note - Keypad triggered deletions do not cause a zigbee event, though Adds work fine.
+        onEvent: async (type, data, device) => {
+            // When we receive a code updated message, lets read the new value
+            if (data.type === 'commandProgrammingEventNotification' &&
+                data.cluster === 'closuresDoorLock' &&
+                data.data &&
+                data.data.userid !== undefined &&
+                // Don't read RF events, we can do this with retrieve_state
+                (data.data.programeventsrc === undefined || constants.lockSourceName[data.data.programeventsrc] != 'rf')
+            ) {
+                await device.endpoints[0].command('closuresDoorLock', 'getPinCode', {userid: data.data.userid}, {});
+            }
+        },
+        exposes: [e.lock(), e.battery(), e.pincode(), e.lock_action(), e.lock_action_source_name(), e.lock_action_source_user()],
     },
 ];

package/devices/xiaomi.js

@@ -47,7 +47,7 @@ module.exports = [
         description: 'Aqara E1 door & window contact sensor',
         fromZigbee: [fz.ias_contact_alarm_1, fz.aqara_opple, fz.battery],
         toZigbee: [],
-        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
         exposes: [e.contact(), e.battery(), e.battery_low(), e.battery_voltage()],
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
@@ -63,7 +63,7 @@ module.exports = [
         description: 'Aqara P1 door & window contact sensor',
         fromZigbee: [fz. xiaomi_contact, fz.ias_contact_alarm_1, fz.aqara_opple],
         toZigbee: [],
-        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
         exposes: [e.contact(), e.battery(), e.battery_voltage()],
     },
     {
@@ -168,7 +168,7 @@ module.exports = [
         whiteLabel: [{vendor: 'Xiaomi', model: 'YTC4040GL'}, {vendor: 'Xiaomi', model: 'YTC4006CN'},
             {vendor: 'Xiaomi', model: 'YTC4017CN'}, {vendor: 'Xiaomi', model: 'ZHTZ02LM'}],
         description: 'MiJia wireless switch',
-        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
         fromZigbee: [fz.xiaomi_basic, fz.xiaomi_WXKG01LM_action, fz.legacy.WXKG01LM_click],
         exposes: [e.battery(), e.action(['single', 'double', 'triple', 'quadruple', 'hold', 'release', 'many']), e.battery_voltage(),
             e.power_outage_count(false)],
@@ -179,7 +179,7 @@ module.exports = [
         model: 'WXKG11LM',
         vendor: 'Xiaomi',
         description: 'Aqara wireless switch',
-        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
         exposes: [e.battery(), e.battery_voltage(), e.action(['single', 'double', 'triple', 'quadruple', 'hold', 'release']),
             e.device_temperature(), e.power_outage_count()],
         fromZigbee: [fz.xiaomi_multistate_action, fz.xiaomi_WXKG11LM_action, fz.xiaomi_basic,
@@ -191,7 +191,7 @@ module.exports = [
         model: 'WXKG12LM',
         vendor: 'Xiaomi',
         description: 'Aqara wireless switch (with gyroscope)',
-        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
         exposes: [e.battery(), e.action(['single', 'double', 'hold', 'release', 'shake']), e.battery_voltage()],
         fromZigbee: [fz.xiaomi_basic, fz.xiaomi_multistate_action, fz.legacy.WXKG12LM_action_click_multistate],
         toZigbee: [],
@@ -201,7 +201,7 @@ module.exports = [
         model: 'WXKG03LM_rev1',
         vendor: 'Xiaomi',
         description: 'Aqara single key wireless wall switch (2016 model)',
-        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
         exposes: [e.battery(), e.action(['single']), e.battery_voltage()],
         fromZigbee: [fz.xiaomi_on_off_action, fz.xiaomi_basic, fz.legacy.WXKG03LM_click],
         toZigbee: [],
@@ -212,7 +212,7 @@ module.exports = [
         model: 'WXKG03LM_rev2',
         vendor: 'Xiaomi',
         description: 'Aqara single key wireless wall switch (2018 model)',
-        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
         exposes: [e.battery(), e.action(['single', 'double', 'hold']), e.battery_voltage()],
         fromZigbee: [fz.xiaomi_on_off_action, fz.xiaomi_multistate_action, fz.xiaomi_basic,
             fz.legacy.WXKG03LM_click, fz.legacy.xiaomi_action_click_multistate],
@@ -230,7 +230,7 @@ module.exports = [
             e.action(['single', 'double', 'hold']),
             e.battery_voltage()],
         onEvent: preventReset,
-        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
         configure: async (device, coordinatorEndpoint, logger) => {
             try {
                 const endpoint = device.endpoints[1];
@@ -245,7 +245,7 @@ module.exports = [
         model: 'WXKG02LM_rev1',
         vendor: 'Xiaomi',
         description: 'Aqara double key wireless wall switch (2016 model)',
-        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
         exposes: [e.battery(), e.action(['single_left', 'single_right', 'single_both']), e.battery_voltage(), e.power_outage_count(false)],
         fromZigbee: [fz.xiaomi_on_off_action, fz.xiaomi_basic, fz.legacy.WXKG02LM_click],
         toZigbee: [],
@@ -256,7 +256,7 @@ module.exports = [
         model: 'WXKG02LM_rev2',
         vendor: 'Xiaomi',
         description: 'Aqara double key wireless wall switch (2018 model)',
-        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
         exposes: [e.battery(), e.action(['single_left', 'single_right', 'single_both', 'double_left', 'double_right', 'double_both',
             'hold_left', 'hold_right', 'hold_both']), e.battery_voltage()],
         fromZigbee: [fz.xiaomi_on_off_action, fz.xiaomi_multistate_action, fz.xiaomi_basic,
@@ -560,7 +560,7 @@ module.exports = [
         model: 'WXKG07LM',
         vendor: 'Xiaomi',
         description: 'Aqara D1 double key wireless wall switch',
-        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
         fromZigbee: [fz.xiaomi_basic, fz.legacy.xiaomi_on_off_action, fz.legacy.xiaomi_multistate_action],
         toZigbee: [],
         endpoint: (device) => {
@@ -840,7 +840,7 @@ module.exports = [
         whiteLabel: [{vendor: 'Xiaomi', model: 'YTC4042GL'}, {vendor: 'Xiaomi', model: 'YTC4007CN'},
             {vendor: 'Xiaomi', model: 'YTC4018CN'}],
         description: 'MiJia temperature & humidity sensor',
-        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
         fromZigbee: [fz.xiaomi_basic, fz.xiaomi_temperature, fz.humidity],
         toZigbee: [],
         exposes: [e.battery(), e.temperature(), e.humidity(), e.battery_voltage()],
@@ -850,7 +850,7 @@ module.exports = [
         model: 'WSDCGQ11LM',
         vendor: 'Xiaomi',
         description: 'Aqara temperature, humidity and pressure sensor',
-        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
         fromZigbee: [fz.xiaomi_basic, fz.xiaomi_temperature, fz.humidity, fz.pressure],
         toZigbee: [],
         exposes: [e.battery(), e.temperature(), e.humidity(), e.pressure(), e.battery_voltage()],
@@ -868,7 +868,7 @@ module.exports = [
         toZigbee: [],
         exposes: [e.temperature(), e.humidity(), e.pressure(), e.device_temperature(), e.battery(), e.battery_voltage(),
             e.power_outage_count(false)],
-        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
             const binds = ['msTemperatureMeasurement', 'msRelativeHumidity', 'msPressureMeasurement'];
@@ -884,7 +884,7 @@ module.exports = [
         whiteLabel: [{vendor: 'Xiaomi', model: 'YTC4041GL'}, {vendor: 'Xiaomi', model: 'YTC4004CN'},
             {vendor: 'Xiaomi', model: 'YTC4016CN'}, {vendor: 'Xiaomi', model: 'ZHTZ02LM'}],
         description: 'MiJia human body movement sensor',
-        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
         fromZigbee: [fz.xiaomi_basic, fz.occupancy_with_timeout],
         toZigbee: [],
         exposes: [e.battery(), e.occupancy(), e.battery_voltage(), e.power_outage_count(false)],
@@ -894,7 +894,7 @@ module.exports = [
         model: 'RTCGQ11LM',
         vendor: 'Xiaomi',
         description: 'Aqara human body movement and illuminance sensor',
-        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
         fromZigbee: [fz.xiaomi_basic, fz.occupancy_with_timeout, fz.RTCGQ11LM_illuminance],
         toZigbee: [],
         exposes: [e.battery(), e.occupancy(), e.device_temperature(), e.battery_voltage(), e.illuminance_lux().withProperty('illuminance'),
@@ -912,7 +912,7 @@ module.exports = [
             exposes.numeric('detection_interval', ea.ALL).withValueMin(2).withValueMax(65535).withUnit('s')
                 .withDescription('Time interval for detecting actions'),
             e.device_temperature(), e.battery(), e.battery_voltage(), e.power_outage_count(false)],
-        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
             await endpoint.read('genPowerCfg', ['batteryVoltage']);
@@ -931,7 +931,7 @@ module.exports = [
             exposes.numeric('detection_interval', ea.ALL).withValueMin(2).withValueMax(65535).withUnit('s')
                 .withDescription('Time interval for detecting actions'),
             e.device_temperature(), e.battery(), e.battery_voltage(), e.power_outage_count(false)],
-        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
             await endpoint.read('genPowerCfg', ['batteryVoltage']);
@@ -959,7 +959,7 @@ module.exports = [
                 'blue LED will blink once when motion is detected. ' +
                 'Press pairing button right before changing this otherwise it will fail.'),
             e.device_temperature(), e.battery(), e.battery_voltage()],
-        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
             await endpoint.read('genPowerCfg', ['batteryVoltage']);
@@ -1005,7 +1005,7 @@ module.exports = [
         whiteLabel: [{vendor: 'Xiaomi', model: 'YTC4039GL'}, {vendor: 'Xiaomi', model: 'YTC4005CN'},
             {vendor: 'Xiaomi', model: 'YTC4015CN'}, {vendor: 'Xiaomi', model: 'ZHTZ02LM'}],
         description: 'MiJia door & window contact sensor',
-        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
         fromZigbee: [fz.xiaomi_basic, fz.xiaomi_contact],
         toZigbee: [],
         exposes: [e.battery(), e.contact(), e.battery_voltage(), e.power_outage_count(false)],
@@ -1015,7 +1015,7 @@ module.exports = [
         model: 'MCCGQ11LM',
         vendor: 'Xiaomi',
         description: 'Aqara door & window contact sensor',
-        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
         fromZigbee: [fz.xiaomi_basic, fz.xiaomi_contact],
         toZigbee: [],
         exposes: [e.battery(), e.contact(), e.device_temperature(), e.battery_voltage(), e.power_outage_count(false)],
@@ -1029,7 +1029,7 @@ module.exports = [
         model: 'SJCGQ11LM',
         vendor: 'Xiaomi',
         description: 'Aqara water leak sensor',
-        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
         fromZigbee: [fz.xiaomi_basic, fz.ias_water_leak_alarm_1],
         toZigbee: [],
         exposes: [e.battery(), e.water_leak(), e.battery_low(), e.battery_voltage(), e.device_temperature(), e.power_outage_count(false)],
@@ -1039,7 +1039,7 @@ module.exports = [
         model: 'SJCGQ12LM',
         vendor: 'Xiaomi',
         description: 'Aqara T1 water leak sensor',
-        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
         fromZigbee: [fz.xiaomi_basic, fz.ias_water_leak_alarm_1],
         toZigbee: [],
         exposes: [e.battery(), e.water_leak(), e.battery_low(), e.tamper(), e.battery_voltage()],
@@ -1050,7 +1050,7 @@ module.exports = [
         model: 'MFKZQ01LM',
         vendor: 'Xiaomi',
         description: 'Mi/Aqara smart home cube',
-        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
         fromZigbee: [fz.xiaomi_basic, fz.MFKZQ01LM_action_multistate, fz.MFKZQ01LM_action_analog],
         exposes: [e.battery(), e.battery_voltage(), e.angle('action_angle'), e.device_temperature(), e.power_outage_count(false),
             e.cube_side('action_from_side'), e.cube_side('action_side'), e.cube_side('action_to_side'), e.cube_side('side'),
@@ -1210,7 +1210,7 @@ module.exports = [
         description: 'MiJia Honeywell smoke detector',
         vendor: 'Xiaomi',
         whiteLabel: [{vendor: 'Xiaomi', model: 'YTC4020RT'}],
-        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
         fromZigbee: [fz.xiaomi_basic, fz.JTYJGD01LMBW_smoke],
         toZigbee: [tz.JTQJBF01LMBW_JTYJGD01LMBW_sensitivity, tz.JTQJBF01LMBW_JTYJGD01LMBW_selfest],
         exposes: [
@@ -1290,7 +1290,7 @@ module.exports = [
             exposes.binary('linkage_alarm', ea.ALL, true, false).withDescription('When this option is enabled and a smoke ' +
                 'is detected, other detectors with this option enabled will also sound the alarm buzzer'),
             e.device_temperature(), e.battery(), e.battery_voltage(), e.power_outage_count(false)],
-        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
             await endpoint.read('genPowerCfg', ['batteryVoltage']);
@@ -1316,7 +1316,7 @@ module.exports = [
         model: 'DJT11LM',
         vendor: 'Xiaomi',
         description: 'Aqara vibration sensor',
-        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
         fromZigbee: [fz.xiaomi_basic, fz.DJT11LM_vibration],
         toZigbee: [tz.DJT11LM_vibration_sensitivity],
         exposes: [
@@ -1541,7 +1541,7 @@ module.exports = [
         ]), exposes.enum('operation_mode', ea.ALL, ['command', 'event'])
             .withDescription('Operation mode, select "command" to enable bindings (wake up the device before changing modes!)')],
         toZigbee: [tz.aqara_opple_operation_mode],
-        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
             await endpoint.write('aqaraOpple', {'mode': 1}, {manufacturerCode: 0x115f});
@@ -1563,7 +1563,7 @@ module.exports = [
         ]), exposes.enum('operation_mode', ea.ALL, ['command', 'event'])
             .withDescription('Operation mode, select "command" to enable bindings (wake up the device before changing modes!)')],
         toZigbee: [tz.aqara_opple_operation_mode],
-        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
             await endpoint.write('aqaraOpple', {'mode': 1}, {manufacturerCode: 0x115f});
@@ -1590,7 +1590,7 @@ module.exports = [
             .withDescription('Operation mode, select "command" to enable bindings (wake up the device before changing modes!)'),
         e.power_outage_count(false)],
         toZigbee: [tz.aqara_opple_operation_mode],
-        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
             await endpoint.write('aqaraOpple', {'mode': 1}, {manufacturerCode: 0x115f});
@@ -1607,7 +1607,7 @@ module.exports = [
         description: 'MiJia light intensity sensor',
         fromZigbee: [fz.battery, fz.illuminance, fz.aqara_opple],
         toZigbee: [],
-        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
             await reporting.bind(endpoint, coordinatorEndpoint, ['msIlluminanceMeasurement']);
@@ -1761,7 +1761,7 @@ module.exports = [
         description: 'Aqara wireless remote switch H1 (double rocker)',
         fromZigbee: [fz.battery, fz.xiaomi_multistate_action, fz.aqara_opple, fz.command_toggle],
         toZigbee: [tz.xiaomi_switch_click_mode, tz.aqara_opple_operation_mode],
-        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}, multiEndpoint: true},
+        meta: {battery: {voltageToPercentage: '3V_2850_3200'}, multiEndpoint: true},
         exposes: [
             e.battery(), e.battery_voltage(), e.action([
                 'single_left', 'single_right', 'single_both',
@@ -1848,7 +1848,7 @@ module.exports = [
         description: 'Aqara TVOC air quality monitor',
         fromZigbee: [fz.xiaomi_tvoc, fz.battery, fz.temperature, fz.humidity, fz.aqara_opple],
         toZigbee: [],
-        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
         exposes: [e.temperature(), e.humidity(), e.voc(), e.device_temperature(), e.battery(), e.battery_voltage()],
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
@@ -1927,7 +1927,7 @@ module.exports = [
         model: 'WXKG13LM',
         vendor: 'Xiaomi',
         description: 'Aqara T1 wireless mini switch',
-        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
         fromZigbee: [fz.battery, fz.aqara_opple_multistate, fz.aqara_opple],
         toZigbee: [],
         exposes: [e.battery(), e.battery_voltage(), e.action(['single', 'double', 'triple', 'quintuple', 'hold', 'release', 'many'])],
@@ -1943,7 +1943,7 @@ module.exports = [
         description: 'Aqara T1 light intensity sensor',
         fromZigbee: [fz.battery, fz.illuminance, fz.aqara_opple],
         toZigbee: [tz.GZCGQ11LM_detection_period],
-        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
         exposes: [e.battery(), e.battery_voltage(), e.illuminance(), e.illuminance_lux(),
             exposes.numeric('detection_period', exposes.access.ALL).withValueMin(1).withValueMax(59).withUnit('s')
                 .withDescription('Time interval in seconds to report after light changes')],
@@ -1982,7 +1982,7 @@ module.exports = [
         description: 'Aqara T1 door & window contact sensor',
         fromZigbee: [fz.xiaomi_contact, fz.aqara_opple],
         toZigbee: [],
-        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
         exposes: [e.contact(), e.battery(), e.battery_voltage()],
     },
     {
@@ -2006,7 +2006,7 @@ module.exports = [
         model: 'ZNXNKG02LM',
         vendor: 'Xiaomi',
         description: 'Aqara knob H1 (wireless)',
-        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
         exposes: [e.battery(), e.battery_voltage(),
             e.action(['single', 'double', 'hold', 'release', 'start_rotating', 'rotation', 'stop_rotating']),
             exposes.enum('operation_mode', ea.ALL, ['event', 'command']).withDescription('Button mode'),
@@ -2029,7 +2029,7 @@ module.exports = [
         model: 'WXKG16LM',
         vendor: 'Xiaomi',
         description: 'Aqara wireless remote switch E1 (single rocker)',
-        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
         fromZigbee: [fz.xiaomi_multistate_action, fz.aqara_opple],
         toZigbee: [tz.xiaomi_switch_click_mode],
         exposes: [e.battery(), e.battery_voltage(), e.action(['single', 'double', 'hold']),
@@ -2045,7 +2045,7 @@ module.exports = [
         model: 'WXKG17LM',
         vendor: 'Xiaomi',
         description: 'Aqara E1 double key wireless switch',
-        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
         exposes: [e.battery(), e.battery_voltage(),
             e.action(['single_left', 'single_right', 'single_both', 'double_left', 'double_right', 'hold_left', 'hold_right']),
             // eslint-disable-next-line max-len
@@ -2073,7 +2073,7 @@ module.exports = [
                     'multi: supports more events like double and hold'),
             exposes.enum('operation_mode', ea.ALL, ['command', 'event'])
                 .withDescription('Operation mode, select "command" to enable bindings (wake up the device before changing modes!)')],
-        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint1 = device.getEndpoint(1);
             await endpoint1.write('aqaraOpple', {'mode': 1}, {manufacturerCode: 0x115f, disableResponse: true});

package/lib/extend.js

@@ -12,11 +12,16 @@ const extend = {
         return {exposes, fromZigbee, toZigbee};
     },
     light_onoff_brightness: (options={}) => {
-        options = {disableEffect: false, ...options};
+        options = {disableEffect: false, disablePowerOnBehavior: false, ...options};
         const exposes = [e.light_brightness(), ...(!options.disableEffect ? [e.effect()] : [])];
-        const fromZigbee = [fz.on_off, fz.brightness, fz.level_config, fz.power_on_behavior, fz.ignore_basic_report];
+        const fromZigbee = [fz.on_off, fz.brightness, fz.level_config, fz.ignore_basic_report];
         const toZigbee = [tz.light_onoff_brightness, tz.ignore_transition, tz.ignore_rate, tz.light_brightness_move,
-            tz.light_brightness_step, tz.level_config, tz.power_on_behavior, ...(!options.disableEffect ? [tz.effect] : [])];
+            tz.light_brightness_step, tz.level_config, ...(!options.disableEffect ? [tz.effect] : [])];
+
+        if (!options.disablePowerOnBehavior) {
+            fromZigbee.push(fz.power_on_behavior);
+            toZigbee.push(tz.power_on_behavior);
+        }
 
         const result = {exposes, fromZigbee, toZigbee};
         if (!options.noConfigure) {
@@ -28,18 +33,23 @@ const extend = {
         return result;
     },
     light_onoff_brightness_colortemp: (options={}) => {
-        options = {disableEffect: false, disableColorTempStartup: false, ...options};
+        options = {disableEffect: false, disableColorTempStartup: false, disablePowerOnBehavior: false, ...options};
         const exposes = [e.light_brightness_colortemp(options.colorTempRange), ...(!options.disableEffect ? [e.effect()] : [])];
         const toZigbee = [tz.light_onoff_brightness, tz.light_colortemp, tz.ignore_transition, tz.ignore_rate, tz.light_brightness_move,
             tz.light_colortemp_move, tz.light_brightness_step, tz.light_colortemp_step, tz.light_colortemp_startup, tz.level_config,
-            tz.power_on_behavior, tz.light_color_options, tz.light_color_mode, ...(!options.disableEffect ? [tz.effect] : [])];
-        const fromZigbee = [fz.color_colortemp, fz.on_off, fz.brightness, fz.level_config, fz.power_on_behavior, fz.ignore_basic_report];
+            tz.light_color_options, tz.light_color_mode, ...(!options.disableEffect ? [tz.effect] : [])];
+        const fromZigbee = [fz.color_colortemp, fz.on_off, fz.brightness, fz.level_config, fz.ignore_basic_report];
 
         if (options.disableColorTempStartup) {
             exposes[0].removeFeature('color_temp_startup');
             toZigbee.splice(toZigbee.indexOf(tz.light_colortemp_startup), 1);
         }
 
+        if (!options.disablePowerOnBehavior) {
+            fromZigbee.push(fz.power_on_behavior);
+            toZigbee.push(tz.power_on_behavior);
+        }
+
         const result = {exposes, fromZigbee, toZigbee};
         if (!options.noConfigure) {
             result.configure = async (device, coordinatorEndpoint, logger) => {
@@ -50,14 +60,19 @@ const extend = {
         return result;
     },
     light_onoff_brightness_color: (options={}) => {
-        options = {disableEffect: false, supportsHS: false, preferHS: false, ...options};
+        options = {disableEffect: false, supportsHS: false, preferHS: false, disablePowerOnBehavior: false, ...options};
         const exposes = [(options.supportsHS ? e.light_brightness_color(options.preferHS) : e.light_brightness_colorxy()),
             ...(!options.disableEffect ? [e.effect()] : [])];
-        const fromZigbee = [fz.color_colortemp, fz.on_off, fz.brightness, fz.level_config, fz.power_on_behavior, fz.ignore_basic_report];
+        const fromZigbee = [fz.color_colortemp, fz.on_off, fz.brightness, fz.level_config, fz.ignore_basic_report];
         const toZigbee = [tz.light_onoff_brightness, tz.light_color, tz.ignore_transition, tz.ignore_rate, tz.light_brightness_move,
-            tz.light_brightness_step, tz.level_config, tz.power_on_behavior, tz.light_hue_saturation_move,
+            tz.light_brightness_step, tz.level_config, tz.light_hue_saturation_move,
             tz.light_hue_saturation_step, tz.light_color_options, tz.light_color_mode, ...(!options.disableEffect ? [tz.effect] : [])];
 
+        if (!options.disablePowerOnBehavior) {
+            fromZigbee.push(fz.power_on_behavior);
+            toZigbee.push(tz.power_on_behavior);
+        }
+
         const result = {exposes, fromZigbee, toZigbee};
         if (!options.noConfigure) {
             result.configure = async (device, coordinatorEndpoint, logger) => {
@@ -68,14 +83,20 @@ const extend = {
         return result;
     },
     light_onoff_brightness_colortemp_color: (options={}) => {
-        options = {disableEffect: false, supportsHS: false, disableColorTempStartup: false, preferHS: false, ...options};
+        options = {
+            disableEffect: false,
+            supportsHS: false,
+            disableColorTempStartup: false,
+            preferHS: false,
+            disablePowerOnBehavior: false,
+            ...options};
         const exposes = [(options.supportsHS ? e.light_brightness_colortemp_color(options.colorTempRange, options.preferHS) :
             e.light_brightness_colortemp_colorxy(options.colorTempRange)), ...(!options.disableEffect ? [e.effect()] : [])];
-        const fromZigbee = [fz.color_colortemp, fz.on_off, fz.brightness, fz.level_config, fz.power_on_behavior, fz.ignore_basic_report];
+        const fromZigbee = [fz.color_colortemp, fz.on_off, fz.brightness, fz.level_config, fz.ignore_basic_report];
         const toZigbee = [
             tz.light_onoff_brightness, tz.light_color_colortemp, tz.ignore_transition, tz.ignore_rate, tz.light_brightness_move,
             tz.light_colortemp_move, tz.light_brightness_step, tz.light_colortemp_step, tz.light_hue_saturation_move,
-            tz.light_hue_saturation_step, tz.light_colortemp_startup, tz.level_config, tz.power_on_behavior, tz.light_color_options,
+            tz.light_hue_saturation_step, tz.light_colortemp_startup, tz.level_config, tz.light_color_options,
             tz.light_color_mode, ...(!options.disableEffect ? [tz.effect] : [])];
 
         if (options.disableColorTempStartup) {
@@ -83,6 +104,11 @@ const extend = {
             toZigbee.splice(toZigbee.indexOf(tz.light_colortemp_startup), 1);
         }
 
+        if (!options.disablePowerOnBehavior) {
+            fromZigbee.push(fz.power_on_behavior);
+            toZigbee.push(tz.power_on_behavior);
+        }
+
         const result = {exposes, fromZigbee, toZigbee};
         if (!options.noConfigure) {
             result.configure = async (device, coordinatorEndpoint, logger) => {

package/lib/utils.js

@@ -102,13 +102,7 @@ function toPercentage(value, min, max, log=false) {
     }
 
     const normalised = (value - min) / (max - min);
-    let percentage;
-    if (log == true) {
-        percentage = normalised === 0 ? 0 : normalised * (1 - Math.log( normalised ));
-    } else {
-        percentage = normalised;
-    }
-    return Math.round(percentage * 100);
+    return Math.round(normalised * 100);
 }
 
 function addActionGroup(payload, msg, definition) {
@@ -169,8 +163,6 @@ function batteryVoltageToPercentage(voltage, option) {
         percentage = Math.round(percentage);
     } else if (option === '3V_2850_3200') {
         percentage = toPercentage(voltage, 2850, 3200);
-    } else if (option === '3V_2850_3000_log') {
-        percentage = toPercentage(voltage, 2850, 3000, true);
     } else if (option === '4LR6AA1_5v') {
         percentage = toPercentage(voltage, 3000, 4200);
     } else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zigbee-herdsman-converters",
-  "version": "14.0.557",
+  "version": "14.0.560",
   "description": "Collection of device converters to be used with zigbee-herdsman",
   "main": "index.js",
   "files": [
@@ -38,7 +38,7 @@
     "buffer-crc32": "^0.2.13",
     "https-proxy-agent": "^5.0.1",
     "tar-stream": "^2.2.0",
-    "zigbee-herdsman": "^0.14.35"
+    "zigbee-herdsman": "^0.14.40"
   },
   "devDependencies": {
     "eslint": "*",