zigbee-herdsman-converters 14.0.526 → 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/letsled.js

@@ -0,0 +1,11 @@
+const extend = require('../lib/extend');
+
+module.exports = [
+    {
+        fingerprint: [{modelID: 'RGBW Down Light', manufacturerName: 'Letsleds China'}],
+        model: 'HLC929-Z-RGBW-4C-IA-OTA-3.0',
+        vendor: 'Letsleds',
+        description: 'RGBW down light (color temp is inverted)',
+        extend: extend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 370]}),
+    },
+];

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/philips.js

@@ -121,6 +121,15 @@ module.exports = [
         extend: hueExtend.light_onoff_brightness_colortemp({colorTempRange: [153, 454]}),
         ota: ota.zigbeeOTA,
     },
+    {
+        zigbeeModel: ['915005996601'],
+        model: '915005996601',
+        vendor: 'Philips',
+        description: 'Hue white ambiance ceiling white Enrave M with Bluetooth',
+        meta: {turnsOffAtBrightness1: true},
+        extend: hueExtend.light_onoff_brightness_colortemp({colorTempRange: [153, 454]}),
+        ota: ota.zigbeeOTA,
+    },
     {
         zigbeeModel: ['915005996801', '915005996901'],
         model: '915005996901',
@@ -2368,6 +2377,17 @@ module.exports = [
         vendor: 'Philips',
         description: 'Hue Being',
         extend: hueExtend.light_onoff_brightness_colortemp({colorTempRange: [153, 454]}),
+        ota: ota.zigbeeOTA,
+        meta: {turnsOffAtBrightness1: true},
+    },
+    {
+        zigbeeModel: ['4100448U9'],
+        model: '4100448U9',
+        vendor: 'Philips',
+        description: 'Hue Being',
+        extend: hueExtend.light_onoff_brightness_colortemp({colorTempRange: [153, 454]}),
+        ota: ota.zigbeeOTA,
+        meta: {turnsOffAtBrightness1: true},
     },
     {
         zigbeeModel: ['1743630P7', '1743630V7'],

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'}],
@@ -1435,7 +1452,7 @@ module.exports = [
         description: 'Smart plug (with power monitoring by polling)',
         vendor: 'TuYa',
         whiteLabel: [{vendor: 'VIKEFON', model: 'TS011F'}, {vendor: 'BlitzWolf', model: 'BW-SHP15'},
-            {vendor: 'Avatto', model: 'MIUCOT10Z'}],
+            {vendor: 'Avatto', model: 'MIUCOT10Z'}, {vendor: 'Neo', model: 'NAS-WR01B'}],
         ota: ota.zigbeeOTA,
         fromZigbee: [fz.on_off, fz.electrical_measurement, fz.metering, fz.ignore_basic_report, fz.tuya_switch_power_outage_memory,
             fz.ts011f_plug_indicator_mode, fz.ts011f_plug_child_mode],
@@ -2373,5 +2390,37 @@ module.exports = [
                 .withDescription('PIR keep time in seconds (refresh and update only while active)'),
         ],
     },
-
+    {
+        fingerprint: [{modelID: 'TS004F', manufacturerName: '_TZ3000_kjfzuycl'}],
+        model: 'ERS-10TZBVB-AA',
+        vendor: 'TuYa',
+        description: 'Smart button',
+        fromZigbee: [
+            fz.command_step, fz.command_on, fz.command_off, fz.command_move_to_color_temp, fz.command_move_to_level,
+            fz.tuya_multi_action, fz.tuya_operation_mode, fz.battery,
+        ],
+        toZigbee: [tz.tuya_operation_mode],
+        exposes: [
+            e.action([
+                'single', 'double', 'hold', 'brightness_move_to_level', 'color_temperature_move',
+                'brightness_step_up', 'brightness_step_down', 'on', 'off',
+            ]),
+            e.battery(),
+            exposes.enum('operation_mode', ea.ALL, ['command', 'event']).withDescription(
+                'Operation mode: "command" - for group control, "event" - for clicks'),
+        ],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await endpoint.read('genBasic', [0x0004, 0x000, 0x0001, 0x0005, 0x0007, 0xfffe]);
+            await endpoint.write('genOnOff', {'tuyaOperationMode': 1});
+            await endpoint.read('genOnOff', ['tuyaOperationMode']);
+            try {
+                await endpoint.read(0xE001, [0xD011]);
+            } catch (err) {/* do nothing */}
+            await endpoint.read('genPowerCfg', ['batteryVoltage', 'batteryPercentageRemaining']);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg']);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff']);
+            await reporting.batteryPercentageRemaining(endpoint);
+        },
+    },
 ];

package/devices/xiaomi.js

@@ -88,7 +88,7 @@ module.exports = [
                 .withDescription('Switch between rgbw mode or dual color temperature mode')],
     },
     {
-        zigbeeModel: ['lumi.light.aqcn02', 'lumi.light.acn014'],
+        zigbeeModel: ['lumi.light.aqcn02'],
         model: 'ZNLDP12LM',
         vendor: 'Xiaomi',
         description: 'Aqara smart LED bulb',
@@ -109,7 +109,7 @@ module.exports = [
         ota: ota.zigbeeOTA,
     },
     {
-        zigbeeModel: ['lumi.light.cwac02'],
+        zigbeeModel: ['lumi.light.cwac02', 'lumi.light.acn014'],
         model: 'ZNLDP13LM',
         vendor: 'Xiaomi',
         description: 'Aqara T1 smart LED bulb',
@@ -1188,7 +1188,7 @@ module.exports = [
         exposes: [
             e.smoke(), e.battery_low(), e.tamper(), e.battery(), exposes.enum('sensitivity', ea.STATE_SET, ['low', 'medium', 'high']),
             exposes.numeric('smoke_density', ea.STATE), exposes.enum('selftest', ea.SET, ['']), e.battery_voltage(),
-            exposes.binary('test', ea.STATE, true, false).withDescription('Test mode activated'),
+            exposes.binary('test', ea.STATE, true, false).withDescription('Test mode activated'), e.device_temperature(),
         ],
     },
     {
@@ -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/exposes.js

@@ -327,7 +327,6 @@ class Cover extends Base {
         super();
         this.type = 'cover';
         this.features = [];
-        this.features.push(new Enum('state', access.STATE_SET, ['OPEN', 'CLOSE', 'STOP']));
     }
 
     withPosition() {
@@ -341,6 +340,12 @@ class Cover extends Base {
         this.features.push(new Numeric('tilt', access.ALL).withValueMin(0).withValueMax(100).withDescription('Tilt of this cover'));
         return this;
     }
+
+    withState(property='state', access=a.STATE_SET, values=['OPEN', 'CLOSE', 'STOP']) {
+        assert(!this.endpoint, 'Cannot add feature after adding endpoint');
+        this.features.push(new Enum(property, access, values));
+        return this;
+    }
 }
 
 class Fan extends Base {
@@ -532,9 +537,9 @@ module.exports = {
         comfort_temperature: () => new Numeric('comfort_temperature', access.STATE_SET).withUnit('°C').withDescription('Comfort temperature').withValueMin(0).withValueMax(30),
         consumer_connected: () => new Binary('consumer_connected', access.STATE, true, false).withDescription('Indicates whether a plug is physically attached. Device does not have to pull power or even be connected electrically (state of this binary switch can be ON even if main power switch is OFF)'),
         contact: () => new Binary('contact', access.STATE, false, true).withDescription('Indicates if the contact is closed (= true) or open (= false)'),
-        cover_position: () => new Cover().withPosition(),
-        cover_position_tilt: () => new Cover().withPosition().withTilt(),
-        cover_tilt: () => new Cover().withTilt(),
+        cover_position: () => new Cover().withState().withPosition(),
+        cover_position_tilt: () => new Cover().withState().withPosition().withTilt(),
+        cover_tilt: () => new Cover().withState().withTilt(),
         cpu_temperature: () => new Numeric('cpu_temperature', access.STATE).withUnit('°C').withDescription('Temperature of the CPU'),
         cube_side: (name) => new Numeric(name, access.STATE).withDescription('Side of the cube').withValueMin(0).withValueMax(6).withValueStep(1),
         current: () => new Numeric('current', access.STATE).withUnit('A').withDescription('Instantaneous measured electrical current'),

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.526",
+  "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": "*",