zigbee-herdsman-converters 14.0.627 → 14.0.629

package/converters/fromZigbee.js

@@ -8155,9 +8155,12 @@ const converters = {
         convert: (model, msg, publish, options, meta) => {
             const lookup = {'0': 'idle', '1': 'in', '2': 'out'};
             const value = precisionRound(parseFloat(msg.data['presentValue']), 1);
+            const people = precisionRound(msg.data.presentValue, 0);
             let result = null;
-            result = {people: precisionRound(msg.data.presentValue, 0), status: lookup[value*10%10]};
-            return result;
+            if (value <= 80) {
+                result = {people: people, status: lookup[value*10%10]};
+                return result;
+            }
         },
     },
     sihas_action: {

package/converters/toZigbee.js

@@ -582,7 +582,8 @@ const converters = {
             'ballast_physical_minimum_level',
             'ballast_physical_maximum_level',
             'ballast_minimum_level',
-            'ballast_maximum_level'],
+            'ballast_maximum_level',
+            'ballast_power_on_level'],
         // zcl attribute names are camel case, but we want to use snake case in the outside communication
         convertSet: async (entity, key, value, meta) => {
             if (key === 'ballast_config') {
@@ -599,6 +600,9 @@ const converters = {
             if (key === 'ballast_maximum_level') {
                 await entity.write('lightingBallastCfg', {'maxLevel': value});
             }
+            if (key === 'ballast_power_on_level') {
+                await entity.write('lightingBallastCfg', {'powerOnLevel': value});
+            }
             converters.ballast_config.convertGet(entity, key, meta);
         },
         convertGet: async (entity, key, meta) => {

package/devices/ctm.js

@@ -281,15 +281,6 @@ const fzLocal = {
 
 
 const tzLocal = {
-    ballast_power_on_level: {
-        key: ['ballast_power_on_level'],
-        convertSet: async (entity, key, value, meta) => {
-            await entity.write('lightingBallastCfg', {'powerOnLevel': value});
-        },
-        convertGet: async (entity, key, meta) => {
-            await entity.read('lightingBallastCfg', ['powerOnLevel']);
-        },
-    },
     ctm_device_mode: {
         key: ['device_mode'],
         convertGet: async (entity, key, meta) => {
@@ -577,7 +568,7 @@ module.exports = [
         vendor: 'CTM Lyng',
         description: 'mTouch Dim OP, touch dimmer',
         fromZigbee: [fz.on_off, fz.brightness, fz.lighting_ballast_configuration],
-        toZigbee: [tz.on_off, tz.light_onoff_brightness, tz.light_brightness_move, tz.ballast_config, tzLocal.ballast_power_on_level],
+        toZigbee: [tz.on_off, tz.light_onoff_brightness, tz.light_brightness_move, tz.ballast_config],
         meta: {disableDefaultResponse: true},
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);

package/devices/envilar.js

@@ -13,7 +13,7 @@ module.exports = [
         extend: extend.light_onoff_brightness(),
     },
     {
-        zigbeeModel: ['ZG50CC-CCT-DRIVER'],
+        zigbeeModel: ['ZG50CC-CCT-DRIVER', 'HK-CCT'],
         model: 'ZG50CC-CCT-DRIVER',
         vendor: 'Envilar',
         description: 'Zigbee CCT LED driver',

package/devices/heiman.js

@@ -444,6 +444,21 @@ module.exports = [
             await reporting.batteryPercentageRemaining(endpoint);
         },
     },
+    {
+        zigbeeModel: ['TempDimmerSw-EM-3.0'],
+        model: 'HS2WDSC-E',
+        vendor: 'HEIMAN',
+        description: 'Remote dimmer and temperature control',
+        fromZigbee: [fz.battery, fz.command_on, fz.command_off, fz.command_move, fz.command_stop, fz.command_move_to_color,
+            fz.command_move_to_color_temp],
+        exposes: [e.battery(), e.action(['on', 'off', 'move', 'stop', 'color_move', 'color_temperature_move'])],
+        toZigbee: [],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg', 'genOnOff', 'genLevelCtrl', 'lightingColorCtrl']);
+            await reporting.batteryPercentageRemaining(endpoint, {min: constants.repInterval.MINUTES_5, max: constants.repInterval.HOUR});
+        },
+    },
     {
         fingerprint: [{modelID: 'ColorDimmerSw-EM-3.0', manufacturerName: 'HEIMAN'}],
         model: 'HS2WDSR-E',
@@ -667,6 +682,13 @@ module.exports = [
         exposes: [e.switch().withEndpoint('left'), e.switch().withEndpoint('center'), e.switch().withEndpoint('right'),
             e.device_temperature()],
     },
+    {
+        zigbeeModel: ['TemperLight'],
+        model: 'HS2WDS',
+        vendor: 'HEIMAN',
+        description: 'LED 9W CCT E27',
+        extend: extend.light_onoff_brightness_colortemp({colorTempRange: [153, 370]}),
+    },
     {
         zigbeeModel: ['CurtainMo-EF-3.0', 'CurtainMo-EF'],
         model: 'HS2CM-N-DC',

package/devices/hzc_electric.js

@@ -1,5 +1,7 @@
 const reporting = require('../lib/reporting');
 const extend = require('../lib/extend');
+const exposes = require('../lib/exposes');
+const e = exposes.presets;
 
 module.exports = [
     {
@@ -8,11 +10,20 @@ module.exports = [
         vendor: 'HZC Electric',
         description: 'Zigbee dual dimmer',
         extend: extend.light_onoff_brightness({noConfigure: true}),
+        exposes: [e.light_brightness().withEndpoint('l1'), e.light_brightness().withEndpoint('l2')],
         configure: async (device, coordinatorEndpoint, logger) => {
             await extend.light_onoff_brightness().configure(device, coordinatorEndpoint, logger);
-            const endpoint = device.getEndpoint(1);
-            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'genLevelCtrl']);
-            await reporting.onOff(endpoint);
+            const endpoint1 = device.getEndpoint(1);
+            await reporting.bind(endpoint1, coordinatorEndpoint, ['genOnOff', 'genLevelCtrl']);
+            await reporting.onOff(endpoint1);
+
+            await extend.light_onoff_brightness().configure(device, coordinatorEndpoint, logger);
+            const endpoint2 = device.getEndpoint(2);
+            await reporting.bind(endpoint2, coordinatorEndpoint, ['genOnOff', 'genLevelCtrl']);
+            await reporting.onOff(endpoint2);
+        },
+        endpoint: () => {
+            return {l1: 1, l2: 2};
         },
     },
 ];

package/devices/leviton.js

@@ -3,6 +3,8 @@ const fz = {...require('../converters/fromZigbee'), legacy: require('../lib/lega
 const tz = require('../converters/toZigbee');
 const reporting = require('../lib/reporting');
 const extend = require('../lib/extend');
+const e = exposes.presets;
+const ea = exposes.access;
 
 module.exports = [
     {
@@ -83,4 +85,31 @@ module.exports = [
                 .withSetpoint('occupied_cooling_setpoint', 10, 30, 1)
                 .withLocalTemperatureCalibration(-30, 30, 0.1).withPiHeatingDemand()],
     },
+    {
+        // Reference from a similar switch: https://gist.github.com/nebhead/dc5a0a827ec14eef6196ded4be6e2dd0
+        zigbeeModel: ['ZS057'],
+        model: 'ZS057-D0Z',
+        vendor: 'Leviton',
+        description: 'Wall switch, 0-10V dimmer, 120-277V, Lumina™ RF',
+        extend: extend.light_onoff_brightness({disableEffect: true, noConfigure: true}),
+        fromZigbee: [fz.brightness, fz.identify, fz.lighting_ballast_configuration, fz.level_config],
+        toZigbee: [tz.light_onoff_brightness, tz.ballast_config, tz.level_config],
+        exposes: [e.light_brightness(),
+            exposes.numeric('ballast_minimum_level', ea.ALL).withValueMin(1).withValueMax(254)
+                .withDescription('Specifies the minimum brightness value'),
+            exposes.numeric('ballast_maximum_level', ea.ALL).withValueMin(1).withValueMax(254)
+                .withDescription('Specifies the maximum brightness value'),
+            exposes.numeric('ballast_power_on_level', ea.ALL).withValueMin(1).withValueMax(254)
+                .withDescription('Specifies the initialisation light level. Can not be set lower than "ballast_minimum_level"'),
+            exposes.numeric('ballast_physical_minimum_level', ea.ALL).withValueMin(1).withValueMax(254)
+                .withDescription('Specifies the minimum light output the ballast can achieve.'),
+            exposes.numeric('ballast_physical_maximum_level', ea.ALL).withValueMin(1).withValueMax(254)
+                .withDescription('Specifies the maximum light output the ballast can achieve.')],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            await extend.light_onoff_brightness().configure(device, coordinatorEndpoint, logger);
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'genLevelCtrl', 'lightingBallastCfg']);
+            await reporting.onOff(endpoint);
+        },
+    },
 ];

package/devices/philips.js

@@ -609,6 +609,13 @@ module.exports = [
         description: 'Hue Calla outdoor',
         extend: hueExtend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 500]}),
     },
+    {
+        zigbeeModel: ['1741930V7'],
+        model: '1741930V7',
+        vendor: 'Philips',
+        description: 'Hue Calla outdoor',
+        extend: hueExtend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 500]}),
+    },
     {
         zigbeeModel: ['1744130P7'],
         model: '1744130P7',
@@ -1815,7 +1822,9 @@ module.exports = [
         vendor: 'Philips',
         description: 'Hue wall switch module',
         fromZigbee: [fz.battery, fz.hue_wall_switch_device_mode, fz.hue_wall_switch],
-        exposes: [e.battery(), e.action(['left_press', 'left_press_release', 'right_press', 'right_press_release']),
+        exposes: [
+            e.battery(), e.action(['left_press', 'left_press_release', 'right_press', 'right_press_release',
+                'left_hold', 'left_hold_release', 'right_hold', 'right_hold_release']),
             exposes.enum('device_mode', ea.ALL, ['single_rocker', 'single_push_button', 'dual_rocker', 'dual_push_button'])],
         toZigbee: [tz.hue_wall_switch_device_mode],
         configure: async (device, coordinatorEndpoint, logger) => {
@@ -2303,6 +2312,13 @@ module.exports = [
         description: 'Hue white filament Edison ST72 E27 LED',
         extend: hueExtend.light_onoff_brightness(),
     },
+    {
+        zigbeeModel: ['LWV004'],
+        model: '8719514279193',
+        vendor: 'Philips',
+        description: 'Hue white filament Edison ST72 B22 LED',
+        extend: hueExtend.light_onoff_brightness(),
+    },
     {
         zigbeeModel: ['HML004'],
         model: '3115331PH',
@@ -2776,4 +2792,11 @@ module.exports = [
         description: 'Hue White ambiance Runner spot white (1 spot)',
         extend: hueExtend.light_onoff_brightness_colortemp({colorTempRange: [153, 454]}),
     },
+    {
+        zigbeeModel: ['915005998101'],
+        model: '915005998101',
+        vendor: 'Philips',
+        description: 'Hue white ambiance ceiling black Enrave',
+        extend: hueExtend.light_onoff_brightness_colortemp({colorTempRange: [153, 454]}),
+    },
 ];

package/devices/saswell.js

@@ -19,6 +19,7 @@ module.exports = [
             {modelID: 'TS0601', manufacturerName: '_TZE200_zuhszj9s'},
             {modelID: 'TS0601', manufacturerName: '_TZE200_9gvruqf5'},
             {modelID: 'TS0601', manufacturerName: '_TZE200_zr9c0day'},
+            {modelID: 'TS0601', manufacturerName: '_TZE200_0dvm9mva'},
         ],
         model: 'SEA801-Zigbee/SEA802-Zigbee',
         vendor: 'Saswell',

package/devices/siglis.js

@@ -1,44 +1,41 @@
+/* eslint-disable linebreak-style */
 const fz = require('../converters/fromZigbee');
 const tz = require('../converters/toZigbee');
 const exposes = require('../lib/exposes');
 const reporting = require('../lib/reporting');
 const e = exposes.presets;
+const ea = exposes.access;
 
 
-const siglisManufacturerCode = 0x129C;
 const zigfredEndpoint = 5;
 
-const zifgredFromZigbee = {
-    cluster: 'manuSpecificSiglisZigfred',
-    type: ['attributeReport'],
-    convert: (model, msg, publish, options, meta) => {
-        const buttonEvent = msg.data['buttonEvent'];
-
-        if (buttonEvent != null) {
-            const buttonLookup = {
-                0: 'button_1',
-                1: 'button_2',
-                2: 'button_3',
-                3: 'button_4',
-            };
+const buttonLookup = {
+    0: 'button_1',
+    1: 'button_2',
+    2: 'button_3',
+    3: 'button_4',
+};
 
-            const actionLookup = {
-                0: 'release',
-                1: 'single',
-                2: 'double',
-                3: 'hold',
-            };
+const actionLookup = {
+    0: 'release',
+    1: 'single',
+    2: 'double',
+    3: 'hold',
+};
 
-            const button = buttonEvent & 0xff;
-            const state = (buttonEvent >> 8) & 0xff;
+const zifgredFromZigbeeButtonEvent = {
+    cluster: 'manuSpecificSiglisZigfred',
+    type: ['commandSiglisZigfredButtonEvent'],
+    convert: (model, msg, publish, options, meta) => {
+        const button = msg.data.button;
+        const type = msg.data.type;
 
-            const buttonName = buttonLookup[button];
-            const stateName = actionLookup[state];
+        const buttonName = buttonLookup[button];
+        const typeName = actionLookup[type];
 
-            if (buttonName && stateName) {
-                const action = `${buttonName}_${stateName}`;
-                return {action};
-            }
+        if (buttonName && typeName) {
+            const action = `${buttonName}_${typeName}`;
+            return {action};
         }
     },
 };
@@ -63,6 +60,37 @@ const coverAndLightToZigbee = {
     },
 };
 
+const buttonEventExposes = 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',
+]);
+
+function checkOption(device, options, key) {
+    if (options.hasOwnProperty(key)) {
+        if (options[key] === 'true') {
+            return true;
+        } else if (options[key] === 'false') {
+            return false;
+        }
+    }
+
+    return checkMetaOption(device, key);
+}
+
+function checkMetaOption(device, key) {
+    const enabled = device.meta[key];
+    if (enabled === undefined) {
+        return false;
+    } else {
+        return !!enabled;
+    }
+}
+
+function setMetaOption(device, key, enabled) {
+    device.meta[key] = enabled;
+}
 
 module.exports = [
     {
@@ -70,15 +98,44 @@ module.exports = [
         model: 'ZFU-1D-CH',
         vendor: 'Siglis',
         description: 'zigfred uno smart in-wall switch',
-        exposes: [e.light_brightness_colorxy().withEndpoint('l1'), e.switch().withEndpoint('l2'), e.light_brightness().withEndpoint('l3'),
-            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',
-            ])],
+        options: [
+            exposes.enum(`front_surface_enabled`, ea.SET, ['auto', 'true', 'false'])
+                .withDescription('Front Surface LED enabled'),
+            exposes.enum(`relay_enabled`, ea.SET, ['auto', 'true', 'false'])
+                .withDescription('Relay enabled'),
+            exposes.enum(`dimmer_enabled`, ea.SET, ['auto', 'true', 'false'])
+                .withDescription('Dimmer enabled'),
+            exposes.enum(`dimmer_dimming_enabled`, ea.SET, ['auto', 'true', 'false'])
+                .withDescription('Dimmer dimmable'),
+        ],
+        exposes: (device, options) => {
+            const expose = [];
+
+            expose.push(buttonEventExposes);
+            expose.push(e.linkquality());
+
+            if (device != null && options != null) {
+                if (checkOption(device, options, 'front_surface_enabled')) {
+                    expose.push(e.light_brightness_colorxy().withEndpoint('l1'));
+                }
+
+                if (checkOption(device, options, 'relay_enabled')) {
+                    expose.push(e.switch().withEndpoint('l2'));
+                }
+
+                if (checkOption(device, options, 'dimmer_enabled')) {
+                    if (checkOption(device, options, 'dimmer_dimming_enabled')) {
+                        expose.push(e.light_brightness().withEndpoint('l3'));
+                    } else {
+                        expose.push(e.switch().withEndpoint('l3'));
+                    }
+                }
+            }
+
+            return expose;
+        },
         fromZigbee: [
-            zifgredFromZigbee,
+            zifgredFromZigbeeButtonEvent,
             fz.color_colortemp,
             fz.on_off,
             fz.brightness,
@@ -108,31 +165,38 @@ module.exports = [
                 'l3': 7,
             };
         },
-        configure: async (device, coordinatorEndpoint, logger) => {
-            const controlEp = device.getEndpoint(zigfredEndpoint);
-            const relayEp = device.getEndpoint(6);
-            const dimmerEp = device.getEndpoint(7);
-
-            // Bind Control EP (LED)
-            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 Relay EP
-            await reporting.bind(relayEp, coordinatorEndpoint, ['genOnOff']);
-            await reporting.onOff(relayEp);
-
-            // Bind Dimmer EP
-            await reporting.bind(dimmerEp, coordinatorEndpoint, ['genOnOff', 'genLevelCtrl']);
-            await reporting.onOff(dimmerEp);
-            await reporting.brightness(dimmerEp);
+        configure: async (device, coordinatorEndpoint, logger, options) => {
+            if (device != null) {
+                const controlEp = device.getEndpoint(zigfredEndpoint);
+                const relayEp = device.getEndpoint(6);
+                const dimmerEp = device.getEndpoint(7);
+
+                // Bind Control EP (LED)
+                setMetaOption(device, 'front_surface_enabled', (await controlEp.read('genBasic', ['deviceEnabled'])).deviceEnabled);
+                if (checkMetaOption(device, 'front_surface_enabled')) {
+                    await reporting.bind(controlEp, coordinatorEndpoint, ['genOnOff', 'genLevelCtrl', 'manuSpecificSiglisZigfred']);
+                    await reporting.onOff(controlEp);
+                    await reporting.brightness(controlEp);
+                }
+
+                // Bind Relay EP
+                setMetaOption(device, 'relay_enabled', (await relayEp.read('genBasic', ['deviceEnabled'])).deviceEnabled);
+                if (checkMetaOption(device, 'relay_enabled')) {
+                    await reporting.bind(relayEp, coordinatorEndpoint, ['genOnOff']);
+                    await reporting.onOff(relayEp);
+                }
+
+                // Bind Dimmer EP
+                setMetaOption(device, 'dimmer_enabled', (await dimmerEp.read('genBasic', ['deviceEnabled'])).deviceEnabled);
+                if (checkMetaOption(device, 'dimmer_enabled')) {
+                    await reporting.bind(dimmerEp, coordinatorEndpoint, ['genOnOff', 'genLevelCtrl']);
+                    await reporting.onOff(dimmerEp);
+                    await reporting.brightness(dimmerEp);
+                }
+                setMetaOption(device, 'dimmer_dimming_enabled', true);
+
+                device.save();
+            }
         },
     },
     {
@@ -140,24 +204,106 @@ module.exports = [
         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().setAccess('state', exposes.access.STATE_SET | exposes.access.STATE_GET)
-                .withPosition().withTilt().withEndpoint('l6'),
-            exposes.cover().setAccess('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',
-            ])],
+        options: [
+            exposes.enum(`front_surface_enabled`, ea.SET, ['auto', 'true', 'false'])
+                .withDescription('Front Surface LED enabled'),
+            exposes.enum(`dimmer_1_enabled`, ea.SET, ['auto', 'true', 'false'])
+                .withDescription('Dimmer 1 enabled'),
+            exposes.enum(`dimmer_1_dimming_enabled`, ea.SET, ['auto', 'true', 'false'])
+                .withDescription('Dimmer 1 dimmable'),
+            exposes.enum(`dimmer_2_enabled`, ea.SET, ['auto', 'true', 'false'])
+                .withDescription('Dimmer 2 enabled'),
+            exposes.enum(`dimmer_2_dimming_enabled`, ea.SET, ['auto', 'true', 'false'])
+                .withDescription('Dimmer 2 dimmable'),
+            exposes.enum(`dimmer_3_enabled`, ea.SET, ['auto', 'true', 'false'])
+                .withDescription('Dimmer 3 enabled'),
+            exposes.enum(`dimmer_3_dimming_enabled`, ea.SET, ['auto', 'true', 'false'])
+                .withDescription('Dimmer 3 dimmable'),
+            exposes.enum(`dimmer_4_enabled`, ea.SET, ['auto', 'true', 'false'])
+                .withDescription('Dimmer 4 enabled'),
+            exposes.enum(`dimmer_4_dimming_enabled`, ea.SET, ['auto', 'true', 'false'])
+                .withDescription('Dimmer 4 dimmable'),
+            exposes.enum(`cover_1_enabled`, ea.SET, ['auto', 'true', 'false'])
+                .withDescription('Cover 1 enabled'),
+            exposes.enum(`cover_1_tilt_enabled`, ea.SET, ['auto', 'true', 'false'])
+                .withDescription('Cover 1 tiltable'),
+            exposes.enum(`cover_2_enabled`, ea.SET, ['auto', 'true', 'false'])
+                .withDescription('Cover 2 enabled'),
+            exposes.enum(`cover_2_tilt_enabled`, ea.SET, ['auto', 'true', 'false'])
+                .withDescription('Cover 2 tiltable'),
+        ],
+        exposes: (device, options) => {
+            const expose = [];
+
+            expose.push(buttonEventExposes);
+            expose.push(e.linkquality());
+
+            if (device != null && options != null) {
+                if (checkOption(device, options, 'front_surface_enabled')) {
+                    expose.push(e.light_brightness_colorxy().withEndpoint('l1'));
+                }
+
+                if (checkOption(device, options, 'dimmer_1_enabled')) {
+                    if (checkOption(device, options, 'dimmer_1_dimming_enabled')) {
+                        expose.push(e.light_brightness().withEndpoint('l2'));
+                    } else {
+                        expose.push(e.switch().withEndpoint('l2'));
+                    }
+                }
+
+                if (checkOption(device, options, 'dimmer_2_enabled')) {
+                    if (checkOption(device, options, 'dimmer_2_dimming_enabled')) {
+                        expose.push(e.light_brightness().withEndpoint('l3'));
+                    } else {
+                        expose.push(e.switch().withEndpoint('l3'));
+                    }
+                }
+
+                if (checkOption(device, options, 'dimmer_3_enabled')) {
+                    if (checkOption(device, options, 'dimmer_3_dimming_enabled')) {
+                        expose.push(e.light_brightness().withEndpoint('l4'));
+                    } else {
+                        expose.push(e.switch().withEndpoint('l4'));
+                    }
+                }
+
+                if (checkOption(device, options, 'dimmer_4_enabled')) {
+                    if (checkOption(device, options, 'dimmer_4_dimming_enabled')) {
+                        expose.push(e.light_brightness().withEndpoint('l5'));
+                    } else {
+                        expose.push(e.switch().withEndpoint('l5'));
+                    }
+                }
+
+                if (checkOption(device, options, 'cover_1_enabled')) {
+                    if (checkOption(device, options, 'cover_1_tilt_enabled')) {
+                        expose.push(exposes.cover()
+                            .setAccess('state', exposes.access.STATE_SET | exposes.access.STATE_GET)
+                            .withPosition().withTilt().withEndpoint('l6'));
+                    } else {
+                        expose.push(exposes.cover()
+                            .setAccess('state', exposes.access.STATE_SET | exposes.access.STATE_GET)
+                            .withPosition().withEndpoint('l6'));
+                    }
+                }
+
+                if (checkOption(device, options, 'cover_2_enabled')) {
+                    if (checkOption(device, options, 'cover_2_tilt_enabled')) {
+                        expose.push(exposes.cover()
+                            .setAccess('state', exposes.access.STATE_SET | exposes.access.STATE_GET)
+                            .withPosition().withTilt().withEndpoint('l7'));
+                    } else {
+                        expose.push(exposes.cover()
+                            .setAccess('state', exposes.access.STATE_SET | exposes.access.STATE_GET)
+                            .withPosition().withEndpoint('l7'));
+                    }
+                }
+            }
+
+            return expose;
+        },
         fromZigbee: [
-            zifgredFromZigbee,
+            zifgredFromZigbeeButtonEvent,
             fz.color_colortemp,
             fz.on_off,
             fz.brightness,
@@ -196,55 +342,93 @@ module.exports = [
                 '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);
+        configure: async (device, coordinatorEndpoint, logger, options) => {
+            if (device != null) {
+                // Bind Control EP (LED)
+                const controlEp = device.getEndpoint(zigfredEndpoint);
+                setMetaOption(device, 'front_surface_enabled', (await controlEp.read('genBasic', ['deviceEnabled'])).deviceEnabled);
+                if (checkMetaOption(device, 'front_surface_enabled')) {
+                    await reporting.bind(controlEp, coordinatorEndpoint, ['genOnOff', 'genLevelCtrl', 'manuSpecificSiglisZigfred']);
+                    await reporting.onOff(controlEp);
+                    await reporting.brightness(controlEp);
+                }
+
+                // Bind Dimmer 1 EP
+                const dimmer1Ep = device.getEndpoint(7);
+                setMetaOption(device, 'dimmer_1_enabled', (await dimmer1Ep.read('genBasic', ['deviceEnabled'])).deviceEnabled);
+                if (checkMetaOption(device, 'dimmer_1_enabled')) {
+                    await reporting.bind(dimmer1Ep, coordinatorEndpoint, ['genOnOff', 'genLevelCtrl']);
+                    await reporting.onOff(dimmer1Ep);
+                    await reporting.brightness(dimmer1Ep);
+                }
+                setMetaOption(device, 'dimmer_1_dimming_enabled', true);
+
+                // Bind Dimmer 2 EP
+                const dimmer2Ep = device.getEndpoint(8);
+                setMetaOption(device, 'dimmer_2_enabled', (await dimmer2Ep.read('genBasic', ['deviceEnabled'])).deviceEnabled);
+                if (checkMetaOption(device, 'dimmer_2_enabled')) {
+                    await reporting.bind(dimmer2Ep, coordinatorEndpoint, ['genOnOff', 'genLevelCtrl']);
+                    await reporting.onOff(dimmer2Ep);
+                    await reporting.brightness(dimmer2Ep);
+                }
+                setMetaOption(device, 'dimmer_2_dimming_enabled', true);
+
+                // Bind Dimmer 3 EP
+                const dimmer3Ep = device.getEndpoint(9);
+                setMetaOption(device, 'dimmer_3_enabled', (await dimmer3Ep.read('genBasic', ['deviceEnabled'])).deviceEnabled);
+                if (checkMetaOption(device, 'dimmer_3_enabled')) {
+                    await reporting.bind(dimmer3Ep, coordinatorEndpoint, ['genOnOff', 'genLevelCtrl']);
+                    await reporting.onOff(dimmer3Ep);
+                    await reporting.brightness(dimmer3Ep);
+                }
+                setMetaOption(device, 'dimmer_3_dimming_enabled', true);
+
+                // Bind Dimmer 4 EP
+                const dimmer4Ep = device.getEndpoint(10);
+                setMetaOption(device, 'dimmer_4_enabled', (await dimmer4Ep.read('genBasic', ['deviceEnabled'])).deviceEnabled);
+                if (checkMetaOption(device, 'dimmer_4_enabled')) {
+                    await reporting.bind(dimmer4Ep, coordinatorEndpoint, ['genOnOff', 'genLevelCtrl']);
+                    await reporting.onOff(dimmer4Ep);
+                    await reporting.brightness(dimmer4Ep);
+                }
+                setMetaOption(device, 'dimmer_4_dimming_enabled', true);
+
+                // Bind Cover 1 EP
+                const cover1Ep = device.getEndpoint(11);
+                setMetaOption(device, 'cover_1_enabled', (await cover1Ep.read('genBasic', ['deviceEnabled'])).deviceEnabled);
+                if (checkMetaOption(device, 'cover_1_enabled')) {
+                    await reporting.bind(cover1Ep, coordinatorEndpoint, ['closuresWindowCovering']);
+                    await reporting.currentPositionLiftPercentage(cover1Ep);
+                    setMetaOption(
+                        device,
+                        'cover_1_tilt_enabled',
+                        (await cover1Ep.read('closuresWindowCovering', ['windowCoveringType'])).windowCoveringType === 0x08);
+                    if (checkMetaOption(device, 'cover_1_tilt_enabled')) {
+                        await reporting.currentPositionTiltPercentage(cover1Ep);
+                    }
+                } else {
+                    setMetaOption(device, 'cover_1_tilt_enabled', false);
+                }
+
+                // Bind Cover 2 EP
+                const cover2Ep = device.getEndpoint(12);
+                setMetaOption(device, 'cover_2_enabled', (await cover2Ep.read('genBasic', ['deviceEnabled'])).deviceEnabled);
+                if (checkMetaOption(device, 'cover_2_enabled')) {
+                    await reporting.bind(cover2Ep, coordinatorEndpoint, ['closuresWindowCovering']);
+                    await reporting.currentPositionLiftPercentage(cover2Ep);
+                    setMetaOption(
+                        device,
+                        'cover_2_tilt_enabled',
+                        (await cover2Ep.read('closuresWindowCovering', ['windowCoveringType'])).windowCoveringType === 0x08);
+                    if (checkMetaOption(device, 'cover_2_tilt_enabled')) {
+                        await reporting.currentPositionTiltPercentage(cover2Ep);
+                    }
+                } else {
+                    setMetaOption(device, 'cover_2_tilt_enabled', false);
+                }
+
+                device.save();
+            }
         },
     },
 ];

package/devices/tuya.js

@@ -21,7 +21,7 @@ const TS011Fplugs = ['_TZ3000_5f43h46b', '_TZ3000_cphmq0q7', '_TZ3000_dpo1ysak',
     '_TZ3000_1h2x4akh', '_TZ3000_9vo5icau', '_TZ3000_cehuw1lw', '_TZ3000_ko6v90pg', '_TZ3000_f1bapcit', '_TZ3000_cjrngdr3',
     '_TZ3000_zloso4jk', '_TZ3000_r6buo8ba', '_TZ3000_iksasdbv', '_TZ3000_idrffznf', '_TZ3000_okaz9tjs', '_TZ3210_q7oryllx',
     '_TZ3000_ss98ec5d', '_TZ3000_gznh2xla', '_TZ3000_hdopuwv6', '_TZ3000_gvn91tmx', '_TZ3000_dksbtrzs', '_TZ3000_b28wrpvx',
-    '_TZ3000_aim0ztek', '_TZ3000_mlswgkc3'];
+    '_TZ3000_aim0ztek', '_TZ3000_mlswgkc3', '_TZ3000_7dndcnnb'];
 
 const tzLocal = {
     SA12IZL_silence_siren: {

package/devices/xiaomi.js

@@ -886,8 +886,7 @@ module.exports = [
             e.switch().withEndpoint('right'),
             e.power().withAccess(ea.STATE_GET),
             e.action([
-                'hold_left', 'single_left', 'double_left', 'release_left', 'hold_right', 'single_right',
-                'double_right', 'release_right', 'hold_both', 'single_both', 'double_both', 'release_both',
+                'hold_left', 'single_left', 'double_left', 'single_right', 'double_right', 'single_both', 'double_both',
             ]),
             exposes.enum('operation_mode', ea.ALL, ['control_left_relay', 'decoupled'])
                 .withDescription('Decoupled mode for left button')

package/package.json

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