zigbee-herdsman-converters 14.0.628 → 14.0.630

package/converters/fromZigbee.js

@@ -785,6 +785,20 @@ const converters = {
             }
         },
     },
+    on_off_force_multiendpoint: {
+        cluster: 'genOnOff',
+        type: ['attributeReport', 'readResponse'],
+        convert: (model, msg, publish, options, meta) => {
+            // This converted is need instead of `fz.on_off` when no meta: {multiEndpoint: true} can be defined for this device
+            // but it is needed for the `state`. E.g. when a switch has 3 channels (state_l1, state_l2, state_l3) but
+            // has combined power measurements (power, energy))
+            if (msg.data.hasOwnProperty('onOff')) {
+                const endpointName = model.hasOwnProperty('endpoint') ?
+                    utils.getKey(model.endpoint(meta.device), msg.endpoint.ID) : msg.endpoint.ID;
+                return {[`state_${endpointName}`]: msg.data['onOff'] === 1 ? 'ON' : 'OFF'};
+            }
+        },
+    },
     on_off_skip_duplicate_transaction: {
         cluster: 'genOnOff',
         type: ['attributeReport', 'readResponse'],

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

@@ -79,6 +79,13 @@ const batteryRotaryDimmer = (...endpointsIds) => ({
 });
 
 module.exports = [
+    {
+        zigbeeModel: ['TWBulb51AU'],
+        model: 'AU-A1GSZ9CX',
+        vendor: 'Aurora',
+        description: 'AOne GLS lamp 9w tunable dimmable 2200-5000K',
+        extend: extend.light_onoff_brightness_colortemp({colorTempRange: [200, 454]}),
+    },
     {
         zigbeeModel: ['RGBCXStrip50AU'],
         model: 'AU-A1ZBSCRGBCX',

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

@@ -83,7 +83,7 @@ module.exports = [
                 {ID: 242, profileID: 41440, deviceID: 97},
             ]},
         ],
-        zigbeeModel: ['57004000'],
+        zigbeeModel: ['NEXENTRO Pushbutton Interface', '57004000'],
         model: '57004000',
         vendor: 'Insta',
         description: 'Pushbutton Interface 2-gang 230V',

package/devices/lellki.js

@@ -133,14 +133,16 @@ module.exports = [
         description: 'Power cord 4 sockets EU (with power monitoring)',
         vendor: 'LELLKI',
         extend: extend.switch(),
-        fromZigbee: [fz.on_off, fz.electrical_measurement, fz.metering, fz.ignore_basic_report, fz.tuya_switch_power_outage_memory],
+        fromZigbee: [fz.on_off_force_multiendpoint, fz.electrical_measurement, fz.metering, fz.ignore_basic_report,
+            fz.tuya_switch_power_outage_memory],
         toZigbee: [tz.on_off, tz.tuya_switch_power_outage_memory],
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
             await endpoint.read('genBasic', ['manufacturerName', 'zclVersion', 'appVersion', 'modelId', 'powerSource', 0xfffe]);
-            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff']);
-            await reporting.bind(device.getEndpoint(2), coordinatorEndpoint, ['genOnOff']);
-            await reporting.bind(device.getEndpoint(3), coordinatorEndpoint, ['genOnOff']);
+            for (const ep of [1, 2, 3]) {
+                await reporting.bind(device.getEndpoint(ep), coordinatorEndpoint, ['genOnOff']);
+                await reporting.onOff(device.getEndpoint(ep));
+            }
             endpoint.saveClusterAttributeKeyValue('haElectricalMeasurement', {acCurrentDivisor: 1000, acCurrentMultiplier: 1});
             endpoint.saveClusterAttributeKeyValue('seMetering', {divisor: 100, multiplier: 1});
             device.save();

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

@@ -131,6 +131,29 @@ module.exports = [
             exposes.binary('led_enable', ea.ALL, true, false).withDescription('Enable LED'),
         ],
     },
+    {
+        zigbeeModel: ['Smart plug Zigbee SE'],
+        model: '552-80698',
+        vendor: 'Niko',
+        description: 'Smart plug with side earthing pin',
+        fromZigbee: [fz.on_off, fz.electrical_measurement, fz.metering, fz.power_on_behavior],
+        toZigbee: [tz.on_off, tz.power_on_behavior, tz.electrical_measurement_power, tz.currentsummdelivered],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'haElectricalMeasurement', 'seMetering']);
+            await reporting.onOff(endpoint);
+            // only activePower seems to be support, although compliance document states otherwise
+            await endpoint.read('haElectricalMeasurement', ['acPowerMultiplier', 'acPowerDivisor']);
+            await reporting.activePower(endpoint);
+            await reporting.readMeteringMultiplierDivisor(endpoint);
+            await reporting.currentSummDelivered(endpoint, {min: 60, change: 1});
+        },
+        exposes: [
+            e.switch(), e.power().withAccess(ea.STATE_GET), e.energy().withAccess(ea.STATE_GET),
+            exposes.enum('power_on_behavior', ea.ALL, ['off', 'previous', 'on'])
+                .withDescription('Controls the behaviour when the device is powered on'),
+        ],
+    },
     {
         zigbeeModel: ['Smart plug Zigbee PE'],
         model: '552-80699',

package/devices/philips.js

@@ -2312,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',
@@ -2694,6 +2701,13 @@ module.exports = [
         description: 'Akari downlight',
         extend: hueExtend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 500]}),
     },
+    {
+        zigbeeModel: ['LCD005'],
+        model: '9290031345',
+        vendor: 'Philips',
+        description: 'Hue white and color ambiance 4" retrofit recessed downlight',
+        extend: hueExtend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 500]}),
+    },
     {
         zigbeeModel: ['LCD006'],
         model: '9290031346',
@@ -2785,4 +2799,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/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/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.628",
+  "version": "14.0.630",
   "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.55"
+    "zigbee-herdsman": "^0.14.59"
   },
   "devDependencies": {
     "eslint": "*",