zigbee-herdsman-converters 14.0.528 → 14.0.529

package/devices/iluminize.js

@@ -189,10 +189,26 @@ module.exports = [
         zigbeeModel: ['ZGRC-TEUR-001'],
         model: '511.544',
         vendor: 'Iluminize',
-        description: 'Zigbee 3.0 wall dimmer RGBW 4 zone',
+        description: 'Zigbee 3.0 wall dimmer RGBW 4 zones',
         fromZigbee: [fz.command_move_to_color, fz.command_move_hue, fz.command_on, fz.command_off, fz.command_move],
         toZigbee: [],
         exposes: [e.action(['recall_*', 'on', 'off', 'color_move', 'color_temperature_move',
             'hue_move', 'brightness_step_down', 'brightness_step_up', 'brightness_move_down', 'brightness_move_up', 'brightness_stop'])],
     },
+    {
+        zigbeeModel: ['ZGRC-TEUR-003'],
+        model: '511.524',
+        vendor: 'Iluminize',
+        description: 'Zigbee 3.0 wall dimmer CCT 4 zones',
+        fromZigbee: [fz.command_on, fz.command_off, fz.command_recall,
+            fz.command_move_to_color_temp, fz.command_step, fz.command_move, fz.command_stop],
+        toZigbee: [],
+        meta: {multiEndpoint: true},
+        exposes: [e.action([
+            'recall_*', 'on', 'off',
+            'brightness_step_down', 'brightness_step_up',
+            'brightness_move_down', 'brightness_move_up', 'brightness_stop',
+            'color_move', 'color_temperature_move', 'hue_move',
+            'color_loop_set', 'enhanced_move_to_hue_and_saturation', 'hue_stop'])],
+    },
 ];

package/devices/perenio.js

@@ -1,7 +1,188 @@
 const fz = require('../converters/fromZigbee');
+const tz = require('../converters/toZigbee');
 const exposes = require('../lib/exposes');
 const reporting = require('../lib/reporting');
+const utils = require('../lib/utils');
 const e = exposes.presets;
+const ea = exposes.access;
+
+const switchTypeValues = [
+    'maintained_state',
+    'maintained_toggle',
+    'momentary_state',
+    'momentary_press',
+    'momentary_release',
+];
+
+const defaultOnOffStateValues = [
+    'on',
+    'off',
+    'previous',
+];
+
+const fzPerenio = {
+    diagnostic: {
+        cluster: 'haDiagnostic',
+        type: ['attributeReport', 'readResponse'],
+        convert: (model, msg, publish, options, meta) => {
+            const result = {};
+            if (msg.data.hasOwnProperty('lastMessageLqi')) {
+                result['last_message_lqi'] = msg.data['lastMessageLqi'];
+            }
+            if (msg.data.hasOwnProperty('lastMessageRssi')) {
+                result['last_message_rssi'] = msg.data['lastMessageRssi'];
+            }
+            return result;
+        },
+    },
+    switch_type: {
+        cluster: 'genMultistateValue',
+        type: ['attributeReport', 'readResponse'],
+        convert: (model, msg, publish, options, meta) => {
+            const result = {};
+            const switchTypeLookup = {
+                0x0001: 'momentary_state',
+                0x0010: 'maintained_state',
+                0x00CC: 'maintained_toggle',
+                0x00CD: 'momentary_release',
+                0x00DC: 'momentary_press',
+            };
+            if (msg.data.hasOwnProperty('presentValue')) {
+                const property = utils.postfixWithEndpointName('switch_type', msg, model);
+                result[property] = switchTypeLookup[msg.data['presentValue']];
+            }
+            return result;
+        },
+    },
+    smart_plug: {
+        cluster: '64635',
+        type: ['attributeReport', 'readResponse'],
+        convert: (model, msg, publish, options, meta) => {
+            const result = {};
+            if (msg.data.hasOwnProperty(3)) {
+                result['rms_voltage'] = msg.data[3];
+            }
+            if (msg.data.hasOwnProperty(10)) {
+                result['active_power'] = msg.data[10];
+            }
+            if (msg.data.hasOwnProperty(14)) {
+                result['consumed_energy'] = msg.data[14];
+            }
+            if (msg.data.hasOwnProperty(24)) {
+                result['rssi'] = msg.data[24];
+            }
+            const powerOnStateLookup = {
+                0: 'off',
+                1: 'on',
+                2: 'previous',
+            };
+            if (msg.data.hasOwnProperty(0)) {
+                result['default_on_off_state'] = powerOnStateLookup[msg.data[0]];
+            }
+            if (msg.data.hasOwnProperty(1)) {
+                if (msg.data[1] == 0) {
+                    result['alarm_voltage_min'] = false;
+                    result['alarm_voltage_max'] = false;
+                    result['alarm_power_max'] = false;
+                } else {
+                    if (msg.data[1] & 1) {
+                        result['alarm_voltage_min'] = true;
+                    }
+                    if (msg.data[1] & 2) {
+                        result['alarm_voltage_max'] = true;
+                    }
+                    if (msg.data[1] & 4) {
+                        result['alarm_power_max'] = true;
+                    }
+                }
+            }
+            return result;
+        },
+    },
+};
+
+const tzPerenio = {
+    switch_type: {
+        key: ['switch_type'],
+        convertSet: async (entity, key, value, meta) => {
+            const switchTypeLookup = {
+                'momentary_state': 0x0001,
+                'maintained_state': 0x0010,
+                'maintained_toggle': 0x00CC,
+                'momentary_release': 0x00CD,
+                'momentary_press': 0x00DC,
+            };
+            await entity.write('genMultistateValue', {presentValue: switchTypeLookup[value]}, utils.getOptions(meta.mapped, entity));
+            return {state: {switch_type: value}};
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read('genMultistateValue', ['presentValue']);
+        },
+    },
+    default_state: {
+        key: ['default_on_off_state'],
+        convertSet: async (entity, key, val, meta) => {
+            const powerOnStateLookup = {
+                'off': 0,
+                'on': 1,
+                'previous': 2,
+            };
+            await entity.write(64635, {0: {value: powerOnStateLookup[val], type: 0x20}}, {manufacturerCode: 0x007B});
+            return {state: {default_on_off_state: val}};
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read(64635, [0]);
+        },
+    },
+    alarms_reset: {
+        key: ['alarm_voltage_min', 'alarm_voltage_max', 'alarm_power_max'],
+        convertSet: async (entity, key, val, meta) => {
+            await entity.write(64635, {1: {value: 0, type: 0x20}}, {manufacturerCode: 0x007B});
+            return {state: {alarm_voltage_min: false, alarm_voltage_max: false, alarm_power_max: false}};
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read(64635, [1]);
+        },
+    },
+    on_off_mod: {
+        key: ['state', 'on_time', 'off_wait_time'],
+        convertSet: async (entity, key, value, meta) => {
+            const state = meta.message.hasOwnProperty('state') ? meta.message.state.toLowerCase() : null;
+            utils.validateValue(state, ['toggle', 'off', 'on']);
+            const alarmVoltageMin = meta.state[`alarm_voltage_min${meta.endpoint_name ? `_${meta.endpoint_name}` : ''}`];
+            const alarmVoltageMax = meta.state[`alarm_voltage_max${meta.endpoint_name ? `_${meta.endpoint_name}` : ''}`];
+            const alarmPowerMax = meta.state[`alarm_power_max${meta.endpoint_name ? `_${meta.endpoint_name}` : ''}`];
+            if (alarmVoltageMin || alarmVoltageMax || alarmPowerMax) {
+                return {state: {state: 'OFF'}};
+            }
+            if (state === 'on' && (meta.message.hasOwnProperty('on_time') || meta.message.hasOwnProperty('off_wait_time'))) {
+                const onTime = meta.message.hasOwnProperty('on_time') ? meta.message.on_time : 0;
+                const offWaitTime = meta.message.hasOwnProperty('off_wait_time') ? meta.message.off_wait_time : 0;
+
+                if (typeof onTime !== 'number') {
+                    throw Error('The on_time value must be a number!');
+                }
+                if (typeof offWaitTime !== 'number') {
+                    throw Error('The off_wait_time value must be a number!');
+                }
+
+                const payload = {ctrlbits: 0, ontime: Math.round(onTime * 10), offwaittime: Math.round(offWaitTime * 10)};
+                await entity.command('genOnOff', 'onWithTimedOff', payload, utils.getOptions(meta.mapped, entity));
+            } else {
+                await entity.command('genOnOff', state, {}, utils.getOptions(meta.mapped, entity));
+                if (state === 'toggle') {
+                    const currentState = meta.state[`state${meta.endpoint_name ? `_${meta.endpoint_name}` : ''}`];
+                    return currentState ? {state: {state: currentState === 'OFF' ? 'ON' : 'OFF'}} : {};
+                } else {
+                    return {state: {state: state.toUpperCase()}};
+                }
+            }
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read('genOnOff', ['onOff']);
+        },
+    },
+};
 
 module.exports = [
     {
@@ -47,4 +228,97 @@ module.exports = [
             await reporting.batteryPercentageRemaining(endpoint);
         },
     },
+    {
+        zigbeeModel: ['PEHWE20', 'PEHWE2X'],
+        model: 'PEHWE20',
+        vendor: 'Perenio',
+        description: 'Two channel single wire mini-relay',
+        fromZigbee: [fz.on_off, fz.power_on_behavior, fzPerenio.diagnostic, fzPerenio.switch_type],
+        toZigbee: [tz.on_off, tz.power_on_behavior, tzPerenio.switch_type],
+        endpoint: (device) => {
+            return {l1: 1, l2: 2};
+        },
+        meta: {multiEndpoint: true},
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint1 = device.getEndpoint(1);
+            const endpoint2 = device.getEndpoint(2);
+            const endpoint10 = device.getEndpoint(10);
+            await reporting.bind(endpoint1, coordinatorEndpoint, ['genOnOff']);
+            await reporting.bind(endpoint2, coordinatorEndpoint, ['genOnOff']);
+            await reporting.bind(endpoint10, coordinatorEndpoint, ['haDiagnostic']);
+            const payload = [{
+                attribute: 'onOff',
+                minimumReportInterval: 0,
+                maximumReportInterval: 3600,
+                reportableChange: 0,
+            }];
+            const payloadDiagnostic = [{
+                attribute: 'lastMessageLqi',
+                minimumReportInterval: 5,
+                maximumReportInterval: 60,
+                reportableChange: 0,
+            }, {
+                attribute: 'lastMessageRssi',
+                minimumReportInterval: 5,
+                maximumReportInterval: 60,
+                reportableChange: 0,
+            }];
+            await endpoint1.configureReporting('genOnOff', payload);
+            await endpoint2.configureReporting('genOnOff', payload);
+            await endpoint10.configureReporting('haDiagnostic', payloadDiagnostic);
+            await endpoint1.read('genOnOff', ['onOff', 'startUpOnOff']);
+            await endpoint2.read('genOnOff', ['onOff', 'startUpOnOff']);
+            await endpoint1.read('genMultistateValue', ['presentValue']);
+            await endpoint2.read('genMultistateValue', ['presentValue']);
+            await endpoint10.read('haDiagnostic', ['lastMessageLqi', 'lastMessageRssi']);
+        },
+        exposes: [
+            e.switch().withEndpoint('l1'),
+            e.power_on_behavior().withEndpoint('l1'),
+            exposes.enum('switch_type', ea.ALL, switchTypeValues).withEndpoint('l1'),
+            e.switch().withEndpoint('l2'),
+            e.power_on_behavior().withEndpoint('l2'),
+            exposes.enum('switch_type', ea.ALL, switchTypeValues).withEndpoint('l2'),
+            exposes.numeric('last_message_lqi', ea.STATE).withUnit('lqi')
+                .withDescription('LQI seen by the device').withValueMin(0).withValueMax(255),
+            exposes.numeric('last_message_rssi', ea.STATE).withUnit('dB')
+                .withDescription('RSSI seen by the device').withValueMin(-128).withValueMax(127),
+        ],
+    },
+    {
+        zigbeeModel: ['PEHPL0X'],
+        model: 'PEHPL0X',
+        vendor: 'Perenio',
+        description: 'Power link',
+        fromZigbee: [fz.on_off, fzPerenio.smart_plug],
+        toZigbee: [tzPerenio.on_off_mod, tzPerenio.default_state, tzPerenio.alarms_reset],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 64635]);
+            const payload = [{
+                attribute: 'onOff',
+                minimumReportInterval: 1,
+                maximumReportInterval: 3600,
+                reportableChange: 0,
+            }];
+            await endpoint.configureReporting('genOnOff', payload);
+            await endpoint.read(64635, [0, 1]);
+        },
+        exposes: [
+            e.switch(),
+            exposes.enum('default_on_off_state', ea.ALL, defaultOnOffStateValues),
+            exposes.numeric('rms_voltage', ea.STATE).withUnit('V').withDescription('RMS voltage'),
+            exposes.numeric('active_power', ea.STATE).withUnit('W').withDescription('Active power'),
+            exposes.numeric('consumed_energy', ea.STATE).withUnit('W*h').withDescription('Consumed energy'),
+            exposes.binary('alarm_voltage_min', ea.ALL, true, false)
+                .withDescription('Indicates if the alarm is triggered on the voltage drop below the limit, allows to reset alarms'),
+            exposes.binary('alarm_voltage_max', ea.ALL, true, false)
+                .withDescription('Indicates if the alarm is triggered on the voltage rise above the limit, allows to reset alarms'),
+            exposes.binary('alarm_power_max', ea.ALL, true, false)
+                .withDescription('Indicates if the alarm is triggered on the active power rise above the limit, allows to reset alarms'),
+            exposes.numeric('rssi', ea.STATE).withUnit('dB')
+                .withDescription('RSSI seen by the device').withValueMin(-128).withValueMax(127),
+        ],
+    },
 ];
+

package/devices/siglis.js

@@ -4,6 +4,7 @@ const exposes = require('../lib/exposes');
 const reporting = require('../lib/reporting');
 const e = exposes.presets;
 
+
 const siglisManufacturerCode = 0x129C;
 const zigfredEndpoint = 5;
 
@@ -42,6 +43,27 @@ const zifgredFromZigbee = {
     },
 };
 
+const coverAndLightToZigbee = {
+    key: ['state', 'brightness', 'brightness_percent', 'on_time'],
+    options: [exposes.options.transition()],
+    convertSet: async (entity, key, value, meta) => {
+        const isCover = (typeof value === 'string' && ['open', 'close', 'stop'].includes(value.toLowerCase()));
+        if (isCover) {
+            return tz.cover_state.convertSet(entity, key, value, meta);
+        } else {
+            return tz.light_onoff_brightness.convertSet(entity, key, value, meta);
+        }
+    },
+    convertGet: async (entity, key, meta) => {
+        if (key === 'brightness') {
+            await entity.read('genLevelCtrl', ['currentLevel']);
+        } else if (key === 'state') {
+            await tz.on_off.convertGet(entity, key, meta);
+        }
+    },
+};
+
+
 module.exports = [
     {
         zigbeeModel: ['zigfred uno'],
@@ -92,11 +114,9 @@ module.exports = [
             const dimmerEp = device.getEndpoint(7);
 
             // Bind Control EP (LED)
-            await reporting.bind(controlEp, coordinatorEndpoint, ['genOnOff']);
-            await reporting.bind(controlEp, coordinatorEndpoint, ['genLevelCtrl']);
+            await reporting.bind(controlEp, coordinatorEndpoint, ['genOnOff', 'genLevelCtrl', 'manuSpecificSiglisZigfred']);
             await reporting.onOff(controlEp);
             await reporting.brightness(controlEp);
-            await reporting.bind(controlEp, coordinatorEndpoint, ['manuSpecificSiglisZigfred']);
             const payload = [{
                 attribute: 'buttonEvent',
                 minimumReportInterval: 0,
@@ -110,10 +130,121 @@ module.exports = [
             await reporting.onOff(relayEp);
 
             // Bind Dimmer EP
-            await reporting.bind(dimmerEp, coordinatorEndpoint, ['genOnOff']);
-            await reporting.bind(dimmerEp, coordinatorEndpoint, ['genLevelCtrl']);
+            await reporting.bind(dimmerEp, coordinatorEndpoint, ['genOnOff', 'genLevelCtrl']);
             await reporting.onOff(dimmerEp);
             await reporting.brightness(dimmerEp);
         },
     },
+    {
+        zigbeeModel: ['zigfred plus'],
+        model: 'ZFP-1A-CH',
+        vendor: 'Siglis',
+        description: 'zigfred plus smart in-wall switch',
+        exposes: [
+            e.light_brightness_colorxy().withEndpoint('l1'),
+            e.light_brightness().withEndpoint('l2'),
+            e.light_brightness().withEndpoint('l3'),
+            e.light_brightness().withEndpoint('l4'),
+            e.light_brightness().withEndpoint('l5'),
+            exposes.cover().withState('state', exposes.access.STATE_SET | exposes.access.STATE_GET)
+                .withPosition().withTilt().withEndpoint('l6'),
+            exposes.cover().withState('state', exposes.access.STATE_SET | exposes.access.STATE_GET)
+                .withPosition().withTilt().withEndpoint('l7'),
+            e.action([
+                'button_1_single', 'button_1_double', 'button_1_hold', 'button_1_release',
+                'button_2_single', 'button_2_double', 'button_2_hold', 'button_2_release',
+                'button_3_single', 'button_3_double', 'button_3_hold', 'button_3_release',
+                'button_4_single', 'button_4_double', 'button_4_hold', 'button_4_release',
+            ])],
+        fromZigbee: [
+            zifgredFromZigbee,
+            fz.color_colortemp,
+            fz.on_off,
+            fz.brightness,
+            fz.level_config,
+            fz.power_on_behavior,
+            fz.ignore_basic_report,
+            fz.cover_position_tilt,
+            fz.command_cover_open,
+            fz.command_cover_close,
+            fz.command_cover_stop,
+        ],
+        toZigbee: [
+            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_hue_saturation_step,
+            tz.light_color_options,
+            tz.light_color_mode,
+            tz.cover_position_tilt,
+            coverAndLightToZigbee,
+        ],
+        meta: {multiEndpoint: true, coverInverted: true},
+        endpoint: (device) => {
+            return {
+                'l1': zigfredEndpoint,
+                'l2': 7,
+                'l3': 8,
+                'l4': 9,
+                'l5': 10,
+                'l6': 11,
+                'l7': 12,
+            };
+        },
+        configure: async (device, coordinatorEndpoint, logger) => {
+            // Bind Control EP (LED)
+            const controlEp = device.getEndpoint(zigfredEndpoint);
+            await reporting.bind(controlEp, coordinatorEndpoint, ['genOnOff', 'genLevelCtrl', 'manuSpecificSiglisZigfred']);
+            await reporting.onOff(controlEp);
+            await reporting.brightness(controlEp);
+            const payload = [{
+                attribute: 'buttonEvent',
+                minimumReportInterval: 0,
+                maximumReportInterval: 0,
+                reportableChange: 0,
+            }];
+            await controlEp.configureReporting('manuSpecificSiglisZigfred', payload, {manufacturerCode: siglisManufacturerCode});
+
+            // Bind Dimmer 1 EP
+            const dimmer1Ep = device.getEndpoint(7);
+            await reporting.bind(dimmer1Ep, coordinatorEndpoint, ['genOnOff', 'genLevelCtrl']);
+            await reporting.onOff(dimmer1Ep);
+            await reporting.brightness(dimmer1Ep);
+
+            // Bind Dimmer 2 EP
+            const dimmer2Ep = device.getEndpoint(8);
+            await reporting.bind(dimmer2Ep, coordinatorEndpoint, ['genOnOff', 'genLevelCtrl']);
+            await reporting.onOff(dimmer2Ep);
+            await reporting.brightness(dimmer2Ep);
+
+            // Bind Dimmer 3 EP
+            const dimmer3Ep = device.getEndpoint(9);
+            await reporting.bind(dimmer3Ep, coordinatorEndpoint, ['genOnOff', 'genLevelCtrl']);
+            await reporting.onOff(dimmer3Ep);
+            await reporting.brightness(dimmer3Ep);
+
+            // Bind Dimmer 4 EP
+            const dimmer4Ep = device.getEndpoint(10);
+            await reporting.bind(dimmer4Ep, coordinatorEndpoint, ['genOnOff', 'genLevelCtrl']);
+            await reporting.onOff(dimmer4Ep);
+            await reporting.brightness(dimmer4Ep);
+
+            // Bind Cover 1 EP
+            const cover1Ep = device.getEndpoint(11);
+            await reporting.bind(cover1Ep, coordinatorEndpoint, ['closuresWindowCovering']);
+            await reporting.currentPositionLiftPercentage(cover1Ep);
+            await reporting.currentPositionTiltPercentage(cover1Ep);
+
+            // Bind Cover 2 EP
+            const cover2Ep = device.getEndpoint(12);
+            await reporting.bind(cover2Ep, coordinatorEndpoint, ['closuresWindowCovering']);
+            await reporting.currentPositionLiftPercentage(cover2Ep);
+            await reporting.currentPositionTiltPercentage(cover2Ep);
+        },
+    },
 ];

package/devices/tuya.js

@@ -86,6 +86,19 @@ const fzLocal = {
             return result;
         },
     },
+    ZM35HQ_battery: {
+        cluster: 'manuSpecificTuya',
+        type: ['commandDataReport'],
+        convert: (model, msg, publish, options, meta) => {
+            const dpValue = tuya.firstDpValue(msg, meta, 'ZM35HQ');
+            const dp = dpValue.dp;
+            const value = tuya.getDataValue(dpValue);
+            if (dp === 4) return {battery: value};
+            else {
+                meta.logger.warn(`zigbee-herdsman-converters:ZM35HQ: NOT RECOGNIZED DP #${dp} with data ${JSON.stringify(dpValue)}`);
+            }
+        },
+    },
 };
 
 module.exports = [
@@ -395,13 +408,17 @@ module.exports = [
         fingerprint: [{modelID: 'TS0202', manufacturerName: '_TZ3000_msl6wxk9'}],
         model: 'ZM-35H-Q',
         vendor: 'TuYa',
-        description: 'Motion Sensor',
-        fromZigbee: [fz.ias_occupancy_alarm_1, fz.battery, fz.ignore_basic_report, fz.ZM35HQ_attr],
+        description: 'Motion sensor',
+        fromZigbee: [fz.ias_occupancy_alarm_1, fz.battery, fz.ignore_basic_report, fz.ZM35HQ_attr, fzLocal.ZM35HQ_battery],
         toZigbee: [tz.ZM35HQ_attr],
         exposes: [e.occupancy(), e.battery_low(), e.tamper(), e.battery(),
             exposes.enum('sensitivity', ea.ALL, ['low', 'medium', 'high']).withDescription('PIR sensor sensitivity'),
             exposes.enum('keep_time', ea.ALL, [30, 60, 120]).withDescription('PIR keep time in seconds'),
         ],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await endpoint.read('genBasic', ['manufacturerName', 'zclVersion', 'appVersion', 'modelId', 'powerSource', 0xfffe]);
+        },
     },
     {
         fingerprint: [{modelID: 'TS0202', manufacturerName: '_TZ3000_mcxw5ehu'}],

package/devices/xiaomi.js

@@ -1779,19 +1779,19 @@ module.exports = [
         vendor: 'Xiaomi',
         whiteLabel: [{vendor: 'Xiaomi', model: 'AAQS-S01'}],
         description: 'Aqara TVOC air quality monitor',
-        fromZigbee: [fz.xiaomi_tvoc, fz.battery, fz.temperature, fz.humidity],
+        fromZigbee: [fz.xiaomi_tvoc, fz.battery, fz.temperature, fz.humidity, fz.aqara_opple],
         toZigbee: [],
         meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
-        exposes: [e.temperature(), e.humidity(), e.voc(), e.battery(), e.battery_voltage()],
+        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);
-            const binds = ['msTemperatureMeasurement', 'msRelativeHumidity', 'genPowerCfg', 'genAnalogInput'];
+            const binds = ['msTemperatureMeasurement', 'msRelativeHumidity', 'genAnalogInput'];
             await reporting.bind(endpoint, coordinatorEndpoint, binds);
-            await reporting.batteryVoltage(endpoint);
             await reporting.humidity(endpoint);
             await reporting.temperature(endpoint);
             const payload = reporting.payload('presentValue', 10, constants.repInterval.HOUR, 5);
             await endpoint.configureReporting('genAnalogInput', payload);
+            await endpoint.read('genPowerCfg', ['batteryVoltage']);
         },
         ota: ota.zigbeeOTA,
     },

package/lib/xiaomi.js

@@ -158,9 +158,10 @@ const numericAttributes2Payload = (msg, meta, model, options, dataObject) => {
             }
             break;
         case '3':
-            if (['WXCJKG11LM', 'WXCJKG12LM', 'WXCJKG13LM'].includes(model.model)) {
+            if (['WXCJKG11LM', 'WXCJKG12LM', 'WXCJKG13LM', 'MCCGQ14LM'].includes(model.model)) {
                 // The temperature value is constant 25 °C and does not change, so we ignore it
                 // https://github.com/Koenkk/zigbee2mqtt/issues/11126
+                // https://github.com/Koenkk/zigbee-herdsman-converters/pull/3585
             } else {
                 payload.device_temperature = calibrateAndPrecisionRoundOptions(value, options, 'device_temperature'); // 0x03
             }
@@ -207,7 +208,7 @@ const numericAttributes2Payload = (msg, meta, model, options, dataObject) => {
                 // We don't know what the value means for these devices.
                 // https://github.com/Koenkk/zigbee2mqtt/issues/11126
                 // https://github.com/Koenkk/zigbee2mqtt/issues/12279
-            } else if (['WSDCGQ01LM', 'WSDCGQ11LM', 'WSDCGQ12LM'].includes(model.model)) {
+            } else if (['WSDCGQ01LM', 'WSDCGQ11LM', 'WSDCGQ12LM', 'VOCKQJK11LM'].includes(model.model)) {
                 // https://github.com/Koenkk/zigbee2mqtt/issues/798
                 // Sometimes the sensor publishes non-realistic vales, filter these
                 const temperature = parseFloat(value) / 100.0;
@@ -249,7 +250,7 @@ const numericAttributes2Payload = (msg, meta, model, options, dataObject) => {
                 payload[`state_${mapping}`] = value === 1 ? 'ON' : 'OFF';
             } else if (['RTCGQ12LM', 'RTCGQ14LM'].includes(model.model)) {
                 payload.illuminance = calibrateAndPrecisionRoundOptions(value, options, 'illuminance');
-            } else if (['WSDCGQ01LM', 'WSDCGQ11LM', 'WSDCGQ12LM'].includes(model.model)) {
+            } else if (['WSDCGQ01LM', 'WSDCGQ11LM', 'WSDCGQ12LM', 'VOCKQJK11LM'].includes(model.model)) {
                 // https://github.com/Koenkk/zigbee2mqtt/issues/798
                 // Sometimes the sensor publishes non-realistic vales, filter these
                 const humidity = parseFloat(value) / 100.0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zigbee-herdsman-converters",
-  "version": "14.0.528",
+  "version": "14.0.529",
   "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.32"
+    "zigbee-herdsman": "^0.14.33"
   },
   "devDependencies": {
     "eslint": "*",