zigbee-herdsman-converters 14.0.430 → 14.0.431

package/devices/awox.js

@@ -117,6 +117,11 @@ module.exports = [
                 {ID: 1, profileID: 260, deviceID: 268, inputClusters: [0, 3, 4, 5, 6, 8, 768, 4096, 64599], outputClusters: [6]},
                 {ID: 3, profileID: 4751, deviceID: 268, inputClusters: [65360, 65361], outputClusters: [65360, 65361]},
             ]},
+            {type: 'Router', manufacturerName: 'AwoX', modelID: 'TLSR82xx', endpoints: [
+                {ID: 1, profileID: 260, deviceID: 268, inputClusters: [0, 3, 4, 5, 6, 8, 768, 4096, 64599], outputClusters: [6]},
+                {ID: 242, profileID: 41440, deviceID: 97, inputClusters: [], outputClusters: [33]},
+                {ID: 3, profileID: 4751, deviceID: 268, inputClusters: [65360, 65361], outputClusters: [65360, 65361]},
+            ]},
         ],
         model: '33957',
         vendor: 'AwoX',

package/devices/philips.js

@@ -706,7 +706,7 @@ module.exports = [
         ota: ota.zigbeeOTA,
     },
     {
-        zigbeeModel: ['LTA001'],
+        zigbeeModel: ['LTA001', '4080130P6'],
         model: '9290022169',
         vendor: 'Philips',
         description: 'Hue white ambiance E27 with Bluetooth',
@@ -1906,8 +1906,8 @@ module.exports = [
         description: 'Hue dimmer switch',
         fromZigbee: [fz.ignore_command_on, fz.ignore_command_off, fz.ignore_command_step, fz.ignore_command_stop,
             fz.legacy.hue_dimmer_switch, fz.battery],
-        exposes: [e.battery(), e.action(['on-press', 'on-hold', 'on-hold-release', 'up-press', 'up-hold', 'up-hold-release',
-            'down-press', 'down-hold', 'down-hold-release', 'off-press', 'off-hold', 'off-hold-release']),
+        exposes: [e.battery(), e.action(['on_press', 'on_hold', 'on_hold_release', 'up_press', 'up_hold', 'up_hold_release',
+            'down_press', 'down_hold', 'down_hold_release', 'off_press', 'off_hold', 'off_hold_release']),
         exposes.numeric('action_duration', ea.STATE).withUnit('second')],
         toZigbee: [],
         configure: async (device, coordinatorEndpoint, logger) => {

package/devices/sprut.js

@@ -3,12 +3,21 @@ const fz = require('../converters/fromZigbee');
 const tz = require('../converters/toZigbee');
 const reporting = require('../lib/reporting');
 const ota = require('../lib/ota');
+const constants = require('../lib/constants');
 const e = exposes;
 const ep = exposes.presets;
 const eo = exposes.options;
 const ea = exposes.access;
 const {calibrateAndPrecisionRoundOptions, getOptions} = require('../lib/utils');
 
+const sprutCode = 0x6666;
+const manufacturerOptions = {manufacturerCode: sprutCode};
+const switchActionValues = ['OFF', 'ON'];
+const co2Lookup = {
+    co2_autocalibration: 'sprutCO2AutoCalibration',
+    co2_manual_calibration: 'sprutCO2Calibration',
+};
+
 const fzLocal = {
     temperature: {
         cluster: 'msTemperatureMeasurement',
@@ -19,7 +28,7 @@ const fzLocal = {
             return {temperature: calibrateAndPrecisionRoundOptions(temperature, options, 'temperature')};
         },
     },
-    occupancy: {
+    occupancy_level: {
         cluster: 'msOccupancySensing',
         type: ['readResponse', 'attributeReport'],
         convert: (model, msg, publish, options, meta) => {
@@ -59,27 +68,65 @@ const fzLocal = {
         cluster: 'msOccupancySensing',
         type: ['readResponse', 'attributeReport'],
         convert: (model, msg, publish, options, meta) => {
-            return {occupancy_timeout: msg.data.pirOToUDelay};
+            return {occupancy_timeout: msg.data['pirOToUDelay']};
         },
     },
     noise_timeout: {
         cluster: 'sprutNoise',
         type: ['readResponse', 'attributeReport'],
         convert: (model, msg, publish, options, meta) => {
-            return {noise_timeout: msg.data.noiseAfterDetectDelay};
+            return {noise_timeout: msg.data['noiseAfterDetectDelay']};
+        },
+    },
+    occupancy_sensitivity: {
+        cluster: 'msOccupancySensing',
+        type: ['readResponse', 'attributeReport'],
+        convert: (model, msg, publish, options, meta) => {
+            return {occupancy_sensitivity: msg.data['sprutOccupancySensitivity']};
+        },
+    },
+    noise_detect_level: {
+        cluster: 'sprutNoise',
+        type: ['readResponse', 'attributeReport'],
+        convert: (model, msg, publish, options, meta) => {
+            return {noise_detect_level: msg.data['noiseDetectLevel']};
+        },
+    },
+    co2_config: {
+        key: ['co2_autocalibration', 'co2_manual_calibration'],
+        cluster: 'msCO2',
+        type: ['attributeReport', 'readResponse'],
+        convert: (model, msg, publish, options, meta) => {
+            if (msg.data.hasOwnProperty('sprutCO2AutoCalibration')) {
+                return {co2_autocalibration: switchActionValues[msg.data['sprutCO2AutoCalibration']]};
+            }
+            if (msg.data.hasOwnProperty('sprutCO2Calibration')) {
+                return {co2_manual_calibration: switchActionValues[msg.data['sprutCO2Calibration']]};
+            }
+        },
+    },
+    th_heater: {
+        key: ['th_heater'],
+        cluster: 'msRelativeHumidity',
+        type: ['attributeReport', 'readResponse'],
+        convert: (model, msg, publish, options, meta) => {
+            if (msg.data.hasOwnProperty('sprutHeater')) {
+                return {th_heater: switchActionValues[msg.data['sprutHeater']]};
+            }
         },
     },
 };
 
 const tzLocal = {
     sprut_ir_remote: {
-        key: ['play_store', 'learn_start', 'learn_stop'],
+        key: ['play_store', 'learn_start', 'learn_stop', 'clear_store', 'play_ram', 'learn_ram_start', 'learn_ram_stop'],
         convertSet: async (entity, key, value, meta) => {
             const options = {
-                frameType: 0, manufacturerCode: 26214, disableDefaultResponse: true,
+                frameType: 0, manufacturerCode: sprutCode, disableDefaultResponse: true,
                 disableResponse: true, reservedBits: 0, direction: 0, writeUndiv: false,
                 transactionSequenceNumber: null,
             };
+
             switch (key) {
             case 'play_store':
                 await entity.command('sprutIrBlaster', 'playStore',
@@ -93,6 +140,22 @@ const tzLocal = {
                 await entity.command('sprutIrBlaster', 'learnStop',
                     {value: value['rom']}, options);
                 break;
+            case 'clear_store':
+                await entity.command('sprutIrBlaster', 'clearStore',
+                    {}, options);
+                break;
+            case 'play_ram':
+                await entity.command('sprutIrBlaster', 'playRam',
+                    {}, options);
+                break;
+            case 'learn_ram_start':
+                await entity.command('sprutIrBlaster', 'learnRamStart',
+                    {}, options);
+                break;
+            case 'learn_ram_stop':
+                await entity.command('sprutIrBlaster', 'learnRamStop',
+                    {}, options);
+                break;
             }
         },
     },
@@ -100,26 +163,85 @@ const tzLocal = {
         key: ['occupancy_timeout'],
         convertSet: async (entity, key, value, meta) => {
             value *= 1;
-            const endpoint = meta.device.getEndpoint(1);
-            await endpoint.write('msOccupancySensing', {pirOToUDelay: value}, getOptions(meta.mapped, entity));
-            return {state: {occupancy_timeout: value}};
+            await entity.write('msOccupancySensing', {pirOToUDelay: value}, getOptions(meta.mapped, entity));
+            return {state: {[key]: value}};
         },
         convertGet: async (entity, key, meta) => {
-            const endpoint = meta.device.getEndpoint(1);
-            await endpoint.read('msOccupancySensing', ['pirOToUDelay']);
+            await entity.read('msOccupancySensing', ['pirOToUDelay']);
         },
     },
     noise_timeout: {
         key: ['noise_timeout'],
         convertSet: async (entity, key, value, meta) => {
             value *= 1;
-            const endpoint = meta.device.getEndpoint(1);
-            await endpoint.write('sprutNoise', {noiseAfterDetectDelay: value}, getOptions(meta.mapped, entity));
-            return {state: {noise_timeout: value}};
+            await entity.write('sprutNoise', {noiseAfterDetectDelay: value}, getOptions(meta.mapped, entity));
+            return {state: {[key]: value}};
         },
         convertGet: async (entity, key, meta) => {
-            const endpoint = meta.device.getEndpoint(1);
-            await endpoint.read('sprutNoise', ['noiseAfterDetectDelay']);
+            await entity.read('sprutNoise', ['noiseAfterDetectDelay']);
+        },
+    },
+    occupancy_sensitivity: {
+        key: ['occupancy_sensitivity'],
+        convertSet: async (entity, key, value, meta) => {
+            value *= 1;
+            const options = getOptions(meta.mapped, entity, manufacturerOptions);
+            await entity.write('msOccupancySensing', {'sprutOccupancySensitivity': value}, options);
+            return {state: {[key]: value}};
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read('msOccupancySensing', ['sprutOccupancySensitivity'], manufacturerOptions);
+        },
+    },
+    noise_detect_level: {
+        key: ['noise_detect_level'],
+        convertSet: async (entity, key, value, meta) => {
+            value *= 1;
+            const options = getOptions(meta.mapped, entity, manufacturerOptions);
+            await entity.write('sprutNoise', {'noiseDetectLevel': value}, options);
+            return {state: {[key]: value}};
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read('sprutNoise', ['noiseDetectLevel'], manufacturerOptions);
+        },
+    },
+    temperature_offset: {
+        key: ['temperature_offset'],
+        convertSet: async (entity, key, value, meta) => {
+            value *= 1;
+            const newValue = parseFloat(value) * 100.0;
+            const options = getOptions(meta.mapped, entity, manufacturerOptions);
+            await entity.write('msTemperatureMeasurement', {'sprutTemperatureOffset': newValue}, options);
+            return {state: {[key]: value}};
+        },
+    },
+    co2_config: {
+        key: ['co2_autocalibration', 'co2_manual_calibration'],
+        convertSet: async (entity, key, value, meta) => {
+            let newValue = value;
+            newValue = switchActionValues.indexOf(value);
+            const options = getOptions(meta.mapped, entity, manufacturerOptions);
+            await entity.write('msCO2', {[co2Lookup[key]]: newValue}, options);
+
+
+            return {state: {[key]: value}};
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read('msCO2', [co2Lookup[key]], manufacturerOptions);
+        },
+    },
+    th_heater: {
+        key: ['th_heater'],
+        convertSet: async (entity, key, value, meta) => {
+            let newValue = value;
+            newValue = switchActionValues.indexOf(value);
+            const options = getOptions(meta.mapped, entity, manufacturerOptions);
+            await entity.write('msRelativeHumidity', {'sprutHeater': newValue}, options);
+
+            return {state: {[key]: value}};
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read('msRelativeHumidity', ['sprutHeater'], manufacturerOptions);
         },
     },
 };
@@ -130,22 +252,53 @@ module.exports = [
         model: 'WB-MSW-ZIGBEE v.3',
         vendor: 'Sprut.device',
         description: 'Wall-mounted Zigbee sensor',
-        fromZigbee: [fzLocal.temperature, fz.illuminance, fz.humidity, fz.occupancy, fzLocal.occupancy, fz.co2, fzLocal.voc,
-            fzLocal.noise, fzLocal.noise_detected, fz.on_off, fzLocal.occupancy_timeout, fzLocal.noise_timeout],
-        toZigbee: [tz.on_off, tzLocal.sprut_ir_remote, tzLocal.occupancy_timeout, tzLocal.noise_timeout],
-        exposes: [ep.temperature(), ep.illuminance(), ep.illuminance_lux(), ep.humidity(),
-            ep.occupancy(), ep.occupancy_level(), ep.co2(), ep.voc(), ep.noise(), ep.noise_detected(ea.STATE_GET),
-            ep.switch().withEndpoint('l1'), ep.switch().withEndpoint('l2'), ep.switch().withEndpoint('default'),
+        fromZigbee: [fzLocal.temperature, fz.illuminance, fz.humidity, fz.occupancy, fzLocal.occupancy_level, fz.co2, fzLocal.voc,
+            fzLocal.noise, fzLocal.noise_detected, fz.on_off, fzLocal.occupancy_timeout, fzLocal.noise_timeout, fzLocal.co2_config,
+            fzLocal.th_heater, fzLocal.occupancy_sensitivity, fzLocal.noise_detect_level],
+        toZigbee: [tz.on_off, tzLocal.sprut_ir_remote, tzLocal.occupancy_timeout, tzLocal.noise_timeout, tzLocal.co2_config,
+            tzLocal.th_heater, tzLocal.temperature_offset, tzLocal.occupancy_sensitivity, tzLocal.noise_detect_level],
+        exposes: [ep.temperature(), ep.illuminance(), ep.illuminance_lux(), ep.humidity(), ep.occupancy(), ep.occupancy_level(), ep.co2(),
+            ep.voc(), ep.noise(), ep.noise_detected(ea.STATE_GET), ep.switch().withEndpoint('l1'), ep.switch().withEndpoint('l2'),
+            ep.switch().withEndpoint('l3'),
             e.numeric('noise_timeout', ea.ALL).withValueMin(0).withValueMax(2000).withUnit('s')
-                .withDescription('Time in seconds after which noise is cleared after detecting it (default: 30)'),
+                .withDescription('Time in seconds after which noise is cleared after detecting it (default: 60)'),
             e.numeric('occupancy_timeout', ea.ALL).withValueMin(0).withValueMax(2000).withUnit('s')
-                .withDescription('Time in seconds after which occupancy is cleared after detecting it (default: 30)')],
+                .withDescription('Time in seconds after which occupancy is cleared after detecting it (default: 60)'),
+            e.numeric('temperature_offset', ea.SET).withValueMin(-10).withValueMax(10).withUnit('°C')
+                .withDescription('Self-heating compensation. The compensation value is subtracted from the measured temperature'),
+            e.numeric('occupancy_sensitivity', ea.ALL).withValueMin(0).withValueMax(2000)
+                .withDescription('If the sensor is triggered by the slightest movement, reduce the sensitivity, '+
+                    'otherwise increase it (default: 50)'),
+            e.numeric('noise_detect_level', ea.ALL).withValueMin(0).withValueMax(150).withUnit('dBA')
+                .withDescription('The minimum noise level at which the detector will work (default: 50)'),
+            e.enum('co2_autocalibration', ea.ALL, switchActionValues)
+                .withDescription('Automatic calibration of the CO2 sensor. If ON, the CO2 sensor will automatically calibrate '+
+                    'every 7 days.'),
+            e.enum('co2_manual_calibration', ea.ALL, switchActionValues)
+                .withDescription('Ventilate the room for 20 minutes, turn on manual calibration, and turn it off after one second. '+
+                    'After about 5 minutes the CO2 sensor will show 400ppm. Calibration completed'),
+            e.enum('th_heater', ea.ALL, switchActionValues)
+                .withDescription('Turn on when working in conditions of high humidity (more than 70 %, RH) or condensation, '+
+                    'if the sensor shows 0 or 100 %.'),
+        ],
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint1 = device.getEndpoint(1);
             const binds = ['genBasic', 'msTemperatureMeasurement', 'msIlluminanceMeasurement', 'msRelativeHumidity',
                 'msOccupancySensing', 'msCO2', 'sprutVoc', 'sprutNoise', 'sprutIrBlaster', 'genOta'];
             await reporting.bind(endpoint1, coordinatorEndpoint, binds);
 
+            // report configuration
+            await reporting.temperature(endpoint1);
+            await reporting.illuminance(endpoint1);
+            await reporting.humidity(endpoint1);
+            await reporting.occupancy(endpoint1);
+
+            let payload = reporting.payload('sprutOccupancyLevel', 10, constants.repInterval.MINUTE, 5);
+            await endpoint1.configureReporting('msOccupancySensing', payload, manufacturerOptions);
+
+            payload = reporting.payload('noise', 10, constants.repInterval.MINUTE, 5);
+            await endpoint1.configureReporting('sprutNoise', payload);
+
             // led_red
             await device.getEndpoint(2).read('genOnOff', ['onOff']);
 
@@ -155,10 +308,6 @@ module.exports = [
             // buzzer
             await device.getEndpoint(4).read('genOnOff', ['onOff']);
 
-            // Read settings at start
-            await endpoint1.read('msOccupancySensing', ['pirOToUDelay']);
-            await endpoint1.read('sprutNoise', ['noiseAfterDetectDelay']);
-
             // Read data at start
             await endpoint1.read('msTemperatureMeasurement', ['measuredValue']);
             await endpoint1.read('msIlluminanceMeasurement', ['measuredValue']);
@@ -168,7 +317,7 @@ module.exports = [
             await endpoint1.read('sprutNoise', ['noiseDetected']);
         },
         endpoint: (device) => {
-            return {'system': 1, 'l1': 2, 'l2': 3, 'default': 4};
+            return {'default': 1, 'l1': 2, 'l2': 3, 'l3': 4};
         },
         meta: {multiEndpoint: true},
         ota: ota.zigbeeOTA,

package/devices/sylvania.js

@@ -57,11 +57,11 @@ module.exports = [
         ota: ota.ledvance,
     },
     {
-        zigbeeModel: ['LIGHTIFY BR Tunable White'],
+        zigbeeModel: ['LIGHTIFY BR Tunable White', 'BR30 TW'],
         model: '73740',
         vendor: 'Sylvania',
         description: 'LIGHTIFY LED adjustable white BR30',
-        extend: extend.ledvance.light_onoff_brightness_colortemp(),
+        extend: extend.ledvance.light_onoff_brightness_colortemp({colorTempRange: [153, 370]}),
         ota: ota.ledvance,
     },
     {

package/devices/vrey.js

@@ -0,0 +1,18 @@
+const reporting = require('../lib/reporting');
+const extend = require('../lib/extend');
+
+module.exports = [
+    {
+        fingerprint: [
+            {modelID: 'TS0001', manufacturerName: '_TYZB01_reyozfcg'},
+            {modelID: 'TS0001', manufacturerName: '_TYZB01_4vgantdz'},
+        ],
+        model: 'VR-X701U',
+        vendor: 'Vrey',
+        description: '1 gang switch',
+        extend: extend.switch(),
+        configure: async (device, coordinatorEndpoint, logger) => {
+            await reporting.bind(device.getEndpoint(1), coordinatorEndpoint, ['genOnOff']);
+        },
+    },
+];

package/devices/xiaomi.js

@@ -56,7 +56,7 @@ module.exports = [
         description: 'Aqara P1 door & window contact sensor',
         fromZigbee: [fz. xiaomi_contact, fz.ias_contact_alarm_1, fz.aqara_opple, fz.battery],
         toZigbee: [],
-        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
         exposes: [e.contact(), e.battery(), e.battery_voltage()],
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
@@ -158,7 +158,7 @@ module.exports = [
         model: 'WXKG01LM',
         vendor: 'Xiaomi',
         description: 'MiJia wireless switch',
-        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
         fromZigbee: [fz.xiaomi_battery, fz.xiaomi_WXKG01LM_action, fz.legacy.WXKG01LM_click],
         exposes: [e.battery(), e.action(['single', 'double', 'triple', 'quadruple', 'hold', 'release', 'many']), e.battery_voltage()],
         toZigbee: [],
@@ -168,7 +168,7 @@ module.exports = [
         model: 'WXKG11LM',
         vendor: 'Xiaomi',
         description: 'Aqara wireless switch',
-        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
         exposes: [e.battery(), e.battery_voltage(), e.action(['single', 'double', 'triple', 'quadruple', 'hold', 'release'])],
         fromZigbee: [fz.xiaomi_multistate_action, fz.xiaomi_WXKG11LM_action, fz.xiaomi_battery,
             fz.legacy.WXKG11LM_click, fz.legacy.xiaomi_action_click_multistate],
@@ -179,7 +179,7 @@ module.exports = [
         model: 'WXKG12LM',
         vendor: 'Xiaomi',
         description: 'Aqara wireless switch (with gyroscope)',
-        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
         exposes: [e.battery(), e.action(['single', 'double', 'hold', 'release', 'shake']), e.battery_voltage()],
         fromZigbee: [fz.xiaomi_battery, fz.xiaomi_multistate_action, fz.legacy.WXKG12LM_action_click_multistate],
         toZigbee: [],
@@ -189,7 +189,7 @@ module.exports = [
         model: 'WXKG03LM_rev1',
         vendor: 'Xiaomi',
         description: 'Aqara single key wireless wall switch (2016 model)',
-        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
         exposes: [e.battery(), e.action(['single']), e.battery_voltage()],
         fromZigbee: [fz.xiaomi_on_off_action, fz.xiaomi_battery, fz.legacy.WXKG03LM_click],
         toZigbee: [],
@@ -200,7 +200,7 @@ module.exports = [
         model: 'WXKG03LM_rev2',
         vendor: 'Xiaomi',
         description: 'Aqara single key wireless wall switch (2018 model)',
-        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
         exposes: [e.battery(), e.action(['single', 'double', 'hold']), e.battery_voltage()],
         fromZigbee: [fz.xiaomi_on_off_action, fz.xiaomi_multistate_action, fz.xiaomi_battery,
             fz.legacy.WXKG03LM_click, fz.legacy.xiaomi_action_click_multistate],
@@ -218,7 +218,7 @@ module.exports = [
             e.action(['single', 'double', 'hold']),
             e.battery_voltage()],
         onEvent: preventReset,
-        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
         configure: async (device, coordinatorEndpoint, logger) => {
             try {
                 const endpoint = device.endpoints[1];
@@ -233,7 +233,7 @@ module.exports = [
         model: 'WXKG02LM_rev1',
         vendor: 'Xiaomi',
         description: 'Aqara double key wireless wall switch (2016 model)',
-        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
         exposes: [e.battery(), e.action(['single_left', 'single_right', 'single_both']), e.battery_voltage()],
         fromZigbee: [fz.xiaomi_on_off_action, fz.xiaomi_battery, fz.legacy.WXKG02LM_click],
         toZigbee: [],
@@ -244,7 +244,7 @@ module.exports = [
         model: 'WXKG02LM_rev2',
         vendor: 'Xiaomi',
         description: 'Aqara double key wireless wall switch (2018 model)',
-        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
         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_battery,
@@ -537,7 +537,7 @@ module.exports = [
         model: 'WXKG07LM',
         vendor: 'Xiaomi',
         description: 'Aqara D1 double key wireless wall switch',
-        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
         fromZigbee: [fz.xiaomi_battery, fz.legacy.xiaomi_on_off_action, fz.legacy.xiaomi_multistate_action],
         toZigbee: [],
         endpoint: (device) => {
@@ -814,7 +814,7 @@ module.exports = [
         model: 'WSDCGQ01LM',
         vendor: 'Xiaomi',
         description: 'MiJia temperature & humidity sensor',
-        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
         fromZigbee: [fz.xiaomi_battery, fz.WSDCGQ01LM_WSDCGQ11LM_interval, fz.xiaomi_temperature, fz.humidity],
         toZigbee: [],
         exposes: [e.battery(), e.temperature(), e.humidity(), e.battery_voltage()],
@@ -824,7 +824,7 @@ module.exports = [
         model: 'WSDCGQ11LM',
         vendor: 'Xiaomi',
         description: 'Aqara temperature, humidity and pressure sensor',
-        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
         fromZigbee: [fz.xiaomi_battery, fz.xiaomi_temperature, fz.humidity, fz.pressure, fz.WSDCGQ01LM_WSDCGQ11LM_interval],
         toZigbee: [],
         exposes: [e.battery(), e.temperature(), e.humidity(), e.pressure(), e.battery_voltage()],
@@ -840,7 +840,7 @@ module.exports = [
         description: 'Aqara T1 temperature, humidity and pressure sensor',
         fromZigbee: [fz.xiaomi_battery, fz.temperature, fz.humidity, fz.pressure],
         toZigbee: [],
-        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
             const binds = ['msTemperatureMeasurement', 'msRelativeHumidity', 'msPressureMeasurement'];
@@ -853,7 +853,7 @@ module.exports = [
         model: 'RTCGQ01LM',
         vendor: 'Xiaomi',
         description: 'MiJia human body movement sensor',
-        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
         fromZigbee: [fz.xiaomi_battery, fz.occupancy_with_timeout],
         toZigbee: [],
         exposes: [e.battery(), e.occupancy(), e.battery_voltage()],
@@ -863,7 +863,7 @@ module.exports = [
         model: 'RTCGQ11LM',
         vendor: 'Xiaomi',
         description: 'Aqara human body movement and illuminance sensor',
-        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
         fromZigbee: [fz.xiaomi_battery, fz.occupancy_with_timeout, fz.RTCGQ11LM_illuminance, fz.RTCGQ11LM_interval],
         toZigbee: [],
         exposes: [e.battery(), e.occupancy(), e.temperature(), e.battery_voltage(), e.illuminance_lux().withProperty('illuminance'),
@@ -879,7 +879,7 @@ module.exports = [
         exposes: [e.occupancy(), e.illuminance().withUnit('lx').withDescription('Measured illuminance in lux'),
             exposes.numeric('detection_interval', ea.ALL).withValueMin(2).withValueMax(65535).withUnit('s')
                 .withDescription('Time interval for detecting actions'), e.battery()],
-        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
             await endpoint.read('genPowerCfg', ['batteryVoltage']);
@@ -897,7 +897,7 @@ module.exports = [
         exposes: [e.occupancy(), exposes.enum('motion_sensitivity', ea.ALL, ['low', 'medium', 'high']),
             exposes.numeric('detection_interval', ea.ALL).withValueMin(2).withValueMax(65535).withUnit('s')
                 .withDescription('Time interval for detecting actions'), e.battery()],
-        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
             await endpoint.read('genPowerCfg', ['batteryVoltage']);
@@ -935,7 +935,7 @@ module.exports = [
         model: 'MCCGQ01LM',
         vendor: 'Xiaomi',
         description: 'MiJia door & window contact sensor',
-        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
         fromZigbee: [fz.xiaomi_battery, fz.xiaomi_contact],
         toZigbee: [],
         exposes: [e.battery(), e.contact(), e.battery_voltage()],
@@ -945,7 +945,7 @@ module.exports = [
         model: 'MCCGQ11LM',
         vendor: 'Xiaomi',
         description: 'Aqara door & window contact sensor',
-        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
         fromZigbee: [fz.xiaomi_battery, fz.xiaomi_contact, fz.xiaomi_contact_interval],
         toZigbee: [],
         exposes: [e.battery(), e.contact(), e.temperature(), e.battery_voltage()],
@@ -959,7 +959,7 @@ module.exports = [
         model: 'SJCGQ11LM',
         vendor: 'Xiaomi',
         description: 'Aqara water leak sensor',
-        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
         fromZigbee: [fz.xiaomi_battery, fz.ias_water_leak_alarm_1, fz.SJCGQ11LM_temperature],
         toZigbee: [],
         exposes: [e.battery(), e.water_leak(), e.battery_low(), e.battery_voltage(), e.temperature()],
@@ -969,7 +969,7 @@ module.exports = [
         model: 'SJCGQ12LM',
         vendor: 'Xiaomi',
         description: 'Aqara T1 water leak sensor',
-        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
         fromZigbee: [fz.xiaomi_battery, fz.ias_water_leak_alarm_1],
         toZigbee: [],
         exposes: [e.battery(), e.water_leak(), e.battery_low(), e.tamper(), e.battery_voltage()],
@@ -980,7 +980,7 @@ module.exports = [
         model: 'MFKZQ01LM',
         vendor: 'Xiaomi',
         description: 'Mi/Aqara smart home cube',
-        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
         fromZigbee: [fz.xiaomi_battery, fz.MFKZQ01LM_action_multistate, fz.MFKZQ01LM_action_analog],
         exposes: [e.battery(), e.battery_voltage(), e.angle('action_angle'),
             e.cube_side('action_from_side'), e.cube_side('action_side'), e.cube_side('action_to_side'),
@@ -1138,7 +1138,7 @@ module.exports = [
         model: 'JTYJ-GD-01LM/BW',
         description: 'MiJia Honeywell smoke detector',
         vendor: 'Xiaomi',
-        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
         fromZigbee: [fz.xiaomi_battery, fz.JTYJGD01LMBW_smoke, fz.JTYJGD01LMBW_smoke_density],
         toZigbee: [tz.JTQJBF01LMBW_JTYJGD01LMBW_sensitivity, tz.JTQJBF01LMBW_JTYJGD01LMBW_selfest],
         exposes: [
@@ -1208,7 +1208,7 @@ module.exports = [
         model: 'DJT11LM',
         vendor: 'Xiaomi',
         description: 'Aqara vibration sensor',
-        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
         fromZigbee: [fz.xiaomi_battery, fz.DJT11LM_vibration],
         toZigbee: [tz.DJT11LM_vibration_sensitivity],
         exposes: [
@@ -1380,7 +1380,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_3200'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
             await endpoint.write('aqaraOpple', {'mode': 1}, {manufacturerCode: 0x115f});
@@ -1402,7 +1402,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_3200'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
             await endpoint.write('aqaraOpple', {'mode': 1}, {manufacturerCode: 0x115f});
@@ -1428,7 +1428,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_3200'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
             await endpoint.write('aqaraOpple', {'mode': 1}, {manufacturerCode: 0x115f});
@@ -1444,7 +1444,7 @@ module.exports = [
         description: 'MiJia light intensity sensor',
         fromZigbee: [fz.battery, fz.illuminance],
         toZigbee: [],
-        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
             await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg', 'msIlluminanceMeasurement']);
@@ -1596,7 +1596,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_3200'}, multiEndpoint: true},
+        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}, multiEndpoint: true},
         exposes: [
             e.battery(), e.battery_voltage(), e.action([
                 'single_left', 'single_right', 'single_both',
@@ -1683,7 +1683,7 @@ module.exports = [
         description: 'Aqara TVOC air quality monitor',
         fromZigbee: [fz.xiaomi_tvoc, fz.battery, fz.temperature, fz.humidity],
         toZigbee: [],
-        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
         exposes: [e.battery(), e.temperature(), e.humidity(), e.voc()],
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
@@ -1762,7 +1762,7 @@ module.exports = [
         model: 'WXKG13LM',
         vendor: 'Xiaomi',
         description: 'Aqara T1 wireless mini switch',
-        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
         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'])],
@@ -1778,7 +1778,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_3200'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
         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')],
@@ -1817,7 +1817,7 @@ module.exports = [
         description: 'Aqara T1 door & window contact sensor',
         fromZigbee: [fz.xiaomi_contact, fz.battery],
         toZigbee: [],
-        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
         exposes: [e.contact(), e.battery(), e.battery_voltage()],
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
@@ -1846,7 +1846,7 @@ module.exports = [
         model: 'ZNXNKG02LM',
         vendor: 'Xiaomi',
         description: 'Aqara knob H1 (wireless)',
-        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
         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'),
@@ -1884,7 +1884,7 @@ module.exports = [
         model: 'WXKG17LM',
         vendor: 'Xiaomi',
         description: 'Aqara E1 double key wireless switch',
-        meta: {battery: {voltageToPercentage: '3V_2850_3200'}},
+        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
         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

package/lib/utils.js

@@ -94,7 +94,7 @@ function calibrateAndPrecisionRoundOptions(number, options, type) {
     return precisionRound(number, precision);
 }
 
-function toPercentage(value, min, max) {
+function toPercentage(value, min, max, log=false) {
     if (value > max) {
         value = max;
     } else if (value < min) {
@@ -102,7 +102,13 @@ function toPercentage(value, min, max) {
     }
 
     const normalised = (value - min) / (max - min);
-    return Math.round(normalised * 100);
+    let percentage;
+    if (log == true) {
+        percentage = normalised === 0 ? 0 : normalised * (1 - Math.log( normalised ));
+    } else {
+        percentage = normalised;
+    }
+    return Math.round(percentage * 100);
 }
 
 function addActionGroup(payload, msg, definition) {
@@ -163,6 +169,8 @@ 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/npm-shrinkwrap.json

@@ -1,6 +1,6 @@
 {
   "name": "zigbee-herdsman-converters",
-  "version": "14.0.430",
+  "version": "14.0.431",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {

package/package.json

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