@willieee802/zigbee-herdsman-converters 15.0.8-4.1

package/devices/brimate.js

@@ -0,0 +1,15 @@
+const exposes = require('../lib/exposes');
+const fz = {...require('../converters/fromZigbee'), legacy: require('../lib/legacy').fromZigbee};
+const e = exposes.presets;
+
+module.exports = [
+    {
+        zigbeeModel: ['FB56-BOT02HM1A5'],
+        model: 'FZB8708HD-S1',
+        vendor: 'Brimate',
+        description: 'Smart motion sensor',
+        fromZigbee: [fz.ias_occupancy_alarm_1],
+        toZigbee: [],
+        exposes: [e.occupancy(), e.battery_low()],
+    },
+];

package/devices/bseed.js

@@ -0,0 +1,17 @@
+const exposes = require('../lib/exposes');
+const fz = {...require('../converters/fromZigbee'), legacy: require('../lib/legacy').fromZigbee};
+const tz = require('../converters/toZigbee');
+const e = exposes.presets;
+const ea = exposes.access;
+
+module.exports = [
+    {
+        fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_yenbr4om'}],
+        model: 'BSEED_TS0601_cover',
+        vendor: 'BSEED',
+        description: 'Zigbee curtain switch',
+        fromZigbee: [fz.tuya_cover],
+        toZigbee: [tz.tuya_cover_control],
+        exposes: [e.cover_position().setAccess('position', ea.STATE_SET)],
+    },
+];

package/devices/bticino.js

@@ -0,0 +1,118 @@
+const exposes = require('../lib/exposes');
+const fz = {...require('../converters/fromZigbee'), legacy: require('../lib/legacy').fromZigbee};
+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 = [
+    {
+        zigbeeModel: [' Light switch with neutral\u0000\u0000\u0000\u0000\u0000'],
+        model: 'K4003C/L4003C/N4003C/NT4003C',
+        vendor: 'BTicino',
+        description: 'Light switch with neutral',
+        fromZigbee: [fz.identify, fz.on_off, fz.K4003C_binary_input, fz.legrand_cluster_fc01],
+        toZigbee: [tz.on_off, tz.legrand_settingEnableLedInDark, tz.legrand_settingEnableLedIfOn, tz.legrand_identify],
+        exposes: [
+            e.switch(), e.action(['identify', 'on', 'off']),
+            exposes.binary('led_in_dark', ea.ALL, 'ON', 'OFF').withDescription(`Enables the LED when the light is turned off, allowing ` +
+                `to see the switch in the dark`),
+            exposes.binary('led_if_on', ea.ALL, 'ON', 'OFF').withDescription('Enables the LED when the light is turned on'),
+            exposes.enum('identify', ea.SET, ['blink']).withDescription(`Blinks the built-in LED to make it easier to find the device`),
+        ],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genIdentify', 'genOnOff', 'genBinaryInput']);
+        },
+    },
+    {
+        zigbeeModel: [' Dimmer switch with neutral\u0000\u0000\u0000\u0000'],
+        model: 'L4411C/N4411C/NT4411C',
+        vendor: 'BTicino',
+        description: 'Dimmer switch with neutral',
+        extend: extend.light_onoff_brightness({noConfigure: true}),
+        fromZigbee: [fz.brightness, fz.identify, fz.on_off, fz.lighting_ballast_configuration, fz.legrand_cluster_fc01],
+        toZigbee: [tz.light_onoff_brightness, tz.legrand_settingEnableLedInDark, tz.legrand_settingEnableLedIfOn,
+            tz.legrand_deviceMode, tz.legrand_identify, tz.ballast_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.binary('device_mode', ea.ALL, 'dimmer_on', 'dimmer_off').withDescription('Allow the device to change brightness'),
+            exposes.binary('led_in_dark', ea.ALL, 'ON', 'OFF').withDescription(`Enables the LED when the light is turned off, allowing ` +
+                `to see the switch in the dark`),
+            exposes.binary('led_if_on', ea.ALL, 'ON', 'OFF').withDescription('Enables the LED when the light is turned on'),
+            exposes.enum('identify', ea.SET, ['blink']).withDescription(`Blinks the built-in LED to make it easier to find the device`),
+        ],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            await extend.light_onoff_brightness().configure(device, coordinatorEndpoint, logger);
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genIdentify', 'genOnOff', 'genLevelCtrl',
+                'genBinaryInput', 'lightingBallastCfg']);
+            await reporting.onOff(endpoint);
+            await reporting.brightness(endpoint);
+        },
+    },
+    {
+        // Newer firmwares (e.g. 001f) Does support partial position reporting
+        // Old firmware of this device provides only three values: 0, 100 and 50, 50 means an idefinite position between 1 and 99.
+        // If you have an old Firmware set no_position_support to true
+        // https://github.com/Koenkk/zigbee-herdsman-converters/pull/2214 - 1st very basic support
+        zigbeeModel: [' Shutter SW with level control\u0000'],
+        model: 'K4027C/L4027C/N4027C/NT4027C',
+        vendor: 'BTicino',
+        description: 'Shutter SW with level control',
+        fromZigbee: [fz.identify, fz.ignore_basic_report, fz.ignore_zclversion_read, fz.bticino_4027C_binary_input_moving,
+            fz.cover_position_tilt],
+        toZigbee: [tz.bticino_4027C_cover_state, tz.bticino_4027C_cover_position, tz.legrand_identify,
+            tz.legrand_settingEnableLedInDark],
+        exposes: [
+            e.cover_position(), e.action(['moving', 'identify', '']),
+            exposes.binary('led_in_dark', ea.ALL, 'ON', 'OFF').withDescription(`Enables the LED when the light is turned off, allowing ` +
+                `to see the switch in the dark`),
+            exposes.enum('identify', ea.SET, ['blink']).withDescription(`Blinks the built-in LED to make it easier to find the device`),
+        ],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genBinaryInput', 'closuresWindowCovering', 'genIdentify']);
+        },
+    },
+    {
+        zigbeeModel: ['Bticino Din power consumption module '],
+        model: 'F20T60A',
+        description: 'DIN power consumption module (same as Legrand 412015)',
+        vendor: 'BTicino',
+        extend: extend.switch(),
+        fromZigbee: [fz.identify, fz.on_off, fz.electrical_measurement, fz.legrand_cluster_fc01, fz.ignore_basic_report, fz.ignore_genOta],
+        toZigbee: [tz.legrand_deviceMode, tz.on_off, tz.legrand_identify, tz.electrical_measurement_power],
+        exposes: [exposes.switch().withState('state', true, 'On/off (works only if device is in "switch" mode)'),
+            e.power().withAccess(ea.STATE_GET), exposes.enum('device_mode', ea.ALL, ['switch', 'auto'])
+                .withDescription('switch: allow on/off, auto will use wired action via C1/C2 on contactor for example with HC/HP')],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genIdentify', 'genOnOff', 'haElectricalMeasurement']);
+            await reporting.onOff(endpoint);
+            await reporting.readEletricalMeasurementMultiplierDivisors(endpoint);
+            await reporting.activePower(endpoint);
+        },
+    },
+    {
+        zigbeeModel: ['Power socket Bticino Serie LL '],
+        model: 'L4531C',
+        vendor: 'BTicino',
+        description: 'Power socket with power consumption monitoring',
+        fromZigbee: [fz.identify, fz.on_off, fz.electrical_measurement],
+        toZigbee: [tz.on_off, tz.legrand_settingEnableLedInDark, tz.legrand_identify],
+        exposes: [e.switch(), e.action(['identify']), e.power(), e.voltage(), e.current()],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genIdentify', 'genOnOff', 'haElectricalMeasurement']);
+            await reporting.onOff(endpoint);
+            await reporting.readEletricalMeasurementMultiplierDivisors(endpoint);
+            await reporting.activePower(endpoint);
+        },
+    },
+];

package/devices/busch-jaeger.js

@@ -0,0 +1,140 @@
+const exposes = require('../lib/exposes');
+const fz = {...require('../converters/fromZigbee'), legacy: require('../lib/legacy').fromZigbee};
+const tz = require('../converters/toZigbee');
+const globalStore = require('../lib/store');
+const reporting = require('../lib/reporting');
+const extend = require('../lib/extend');
+const e = exposes.presets;
+
+module.exports = [
+    {
+        zigbeeModel: ['PU01'],
+        model: '6717-84',
+        vendor: 'Busch-Jaeger',
+        description: 'Adaptor plug',
+        extend: extend.switch(),
+    },
+    {
+        // Busch-Jaeger 6735, 6736 and 6737 have been tested with the 6710 U (Power Adapter),
+        // 6711 U (Relay) and 6715 U (dimmer) back-ends. Unfortunately both the relay and the dimmer
+        // report as model 'RM01' with genLevelCtrl clusters, so we need to set up both of them
+        // as dimmable lights.
+        //
+        // The battery-powered version of the device ('RB01') is supported as well. These devices are
+        // sold as Busch-Jaeger 6735/01, 6736/01 and 6737/01.
+        //
+        // In order to manually capture scenes as described in the devices manual, the endpoint
+        // corresponding to the row needs to be unbound (https://www.zigbee2mqtt.io/information/binding.html)
+        // If that operation was successful, the switch will respond to button presses on that
+        // by blinking multiple times (vs. just blinking once if it's bound).
+        zigbeeModel: ['RM01', 'RB01'],
+        model: '6735/6736/6737',
+        vendor: 'Busch-Jaeger',
+        description: 'Zigbee Light Link power supply/relay/dimmer/wall-switch',
+        endpoint: (device) => {
+            return {'row_1': 0x0a, 'row_2': 0x0b, 'row_3': 0x0c, 'row_4': 0x0d, 'relay': 0x12};
+        },
+        exposes: (device, options) => {
+            const expose = [];
+
+            // If endpoint 0x12 (18) is present this means the following two things:
+            //  1. The device is connected to a relay or dimmer and needs to be exposed as a dimmable light
+            //  2. The top rocker will not be usable (not emit any events) as it's hardwired to the relay/dimmer
+            if (!device || device.getEndpoint(0x12) != null) {
+                expose.push(e.light_brightness().withEndpoint('relay'));
+                // Exposing the device as a switch without endpoint is actually wrong, but this is the historic
+                // definition and we are keeping it for compatibility reasons.
+                // DEPRECATED and should be removed in the future
+                expose.push(e.switch());
+            }
+            // Not all devices support all actions (depends on number of rocker rows and if relay/dimmer is installed),
+            // but defining all possible actions here won't do any harm.
+            expose.push(e.action([
+                'row_1_on', 'row_1_off', 'row_1_up', 'row_1_down', 'row_1_stop',
+                'row_2_on', 'row_2_off', 'row_2_up', 'row_2_down', 'row_2_stop',
+                'row_3_on', 'row_3_off', 'row_3_up', 'row_3_down', 'row_3_stop',
+                'row_4_on', 'row_4_off', 'row_4_up', 'row_4_down', 'row_4_stop',
+            ]));
+            expose.push(e.linkquality());
+
+            return expose;
+        },
+        meta: {multiEndpoint: true},
+        configure: async (device, coordinatorEndpoint, logger) => {
+            // Depending on the actual devices - 6735, 6736, or 6737 - there are 1, 2, or 4 endpoints for
+            // the rockers. If the module is installed on a dimmer or relay, there is an additional endpoint (18).
+            const endpoint18 = device.getEndpoint(0x12);
+            if (endpoint18 != null) {
+                await reporting.bind(endpoint18, coordinatorEndpoint, ['genOnOff', 'genLevelCtrl']);
+            } else {
+                // We only need to bind endpoint 10 (top rocker) if endoint 18 (relay/dimmer) is not present.
+                // Otherwise the top rocker is hard-wired to the relay/dimmer and cannot be used anyways.
+                const endpoint10 = device.getEndpoint(0x0a);
+                if (endpoint10 != null) {
+                    await reporting.bind(endpoint10, coordinatorEndpoint, ['genLevelCtrl']);
+                }
+            }
+
+            // The total number of bindings seems to be severely limited with some of these devices.
+            // In order to be able to toggle groups, we need to remove the scenes cluster from RM01.
+            const dropScenesCluster = device.modelID == 'RM01';
+
+            const endpoint11 = device.getEndpoint(0x0b);
+            if (endpoint11 != null) {
+                if (dropScenesCluster) {
+                    const index = endpoint11.outputClusters.indexOf(5);
+                    if (index > -1) {
+                        endpoint11.outputClusters.splice(index, 1);
+                    }
+                }
+                await reporting.bind(endpoint11, coordinatorEndpoint, ['genLevelCtrl']);
+            }
+            const endpoint12 = device.getEndpoint(0x0c);
+            if (endpoint12 != null) {
+                if (dropScenesCluster) {
+                    const index = endpoint12.outputClusters.indexOf(5);
+                    if (index > -1) {
+                        endpoint12.outputClusters.splice(index, 1);
+                    }
+                }
+                await reporting.bind(endpoint12, coordinatorEndpoint, ['genLevelCtrl']);
+            }
+            const endpoint13 = device.getEndpoint(0x0d);
+            if (endpoint13 != null) {
+                if (dropScenesCluster) {
+                    const index = endpoint13.outputClusters.indexOf(5);
+                    if (index > -1) {
+                        endpoint13.outputClusters.splice(index, 1);
+                    }
+                }
+                await reporting.bind(endpoint13, coordinatorEndpoint, ['genLevelCtrl']);
+            }
+        },
+        fromZigbee: [fz.ignore_basic_report, fz.on_off, fz.brightness, fz.legacy.RM01_on_click, fz.legacy.RM01_off_click,
+            fz.legacy.RM01_up_hold, fz.legacy.RM01_down_hold, fz.legacy.RM01_stop],
+        toZigbee: [tz.RM01_light_onoff_brightness, tz.RM01_light_brightness_step, tz.RM01_light_brightness_move],
+        onEvent: async (type, data, device) => {
+            const switchEndpoint = device.getEndpoint(0x12);
+            if (switchEndpoint == null) {
+                return;
+            }
+            // This device doesn't support reporting.
+            // Therefore we read the on/off state every 5 seconds.
+            // This is the same way as the Hue bridge does it.
+            if (type === 'stop') {
+                clearInterval(globalStore.getValue(device, 'interval'));
+                globalStore.clearValue(device, 'interval');
+            } else if (!globalStore.hasValue(device, 'interval')) {
+                const interval = setInterval(async () => {
+                    try {
+                        await switchEndpoint.read('genOnOff', ['onOff']);
+                        await switchEndpoint.read('genLevelCtrl', ['currentLevel']);
+                    } catch (error) {
+                        // Do nothing
+                    }
+                }, 5000);
+                globalStore.putValue(device, 'interval', interval);
+            }
+        },
+    },
+];

package/devices/byun.js

@@ -0,0 +1,24 @@
+const exposes = require('../lib/exposes');
+const fz = {...require('../converters/fromZigbee'), legacy: require('../lib/legacy').fromZigbee};
+const e = exposes.presets;
+
+module.exports = [
+    {
+        zigbeeModel: ['Windows switch  '],
+        model: 'M415-6C',
+        vendor: 'BYUN',
+        description: 'Smoke sensor',
+        fromZigbee: [fz.byun_smoke_true, fz.byun_smoke_false],
+        toZigbee: [],
+        exposes: [e.smoke()],
+    },
+    {
+        zigbeeModel: ['GAS  SENSOR     '],
+        model: 'M415-5C',
+        vendor: 'BYUN',
+        description: 'Gas sensor',
+        fromZigbee: [fz.byun_gas_true, fz.byun_gas_false],
+        toZigbee: [],
+        exposes: [e.gas()],
+    },
+];

package/devices/calex.js

@@ -0,0 +1,37 @@
+const exposes = require('../lib/exposes');
+const fz = {...require('../converters/fromZigbee'), legacy: require('../lib/legacy').fromZigbee};
+const extend = require('../lib/extend');
+const e = exposes.presets;
+
+module.exports = [
+    {
+        zigbeeModel: ['EC-Z3.0-CCT'],
+        model: '421786',
+        vendor: 'Calex',
+        description: 'LED A60 Zigbee GLS-lamp',
+        extend: extend.light_onoff_brightness(),
+    },
+    {
+        zigbeeModel: ['EC-Z3.0-RGBW'],
+        model: '421792',
+        vendor: 'Calex',
+        description: 'LED A60 Zigbee RGB lamp',
+        extend: extend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 370]}),
+    },
+    {
+        zigbeeModel: ['Smart Wall Switch '], // Yes, it has a space at the end :(
+        model: '421782',
+        vendor: 'Calex',
+        description: 'Smart Wall Switch, wall mounted RGB controller',
+        toZigbee: [],
+        fromZigbee: [fz.command_off, fz.command_on, fz.command_step, fz.command_move_to_color_temp,
+            fz.command_move, fz.command_stop, fz.command_ehanced_move_to_hue_and_saturation,
+        ],
+        exposes: [e.action([
+            'on', 'off', 'color_temperature_move', 'brightness_step_up', 'brightness_step_down',
+            'brightness_move_up', 'brightness_move_down', 'brightness_stop',
+            'enhanced_move_to_hue_and_saturation',
+        ])],
+        meta: {disableActionGroup: true},
+    },
+];

package/devices/candeo.js

@@ -0,0 +1,49 @@
+const exposes = require('../lib/exposes');
+const fz = require('../converters/fromZigbee');
+const reporting = require('../lib/reporting');
+const extend = require('../lib/extend');
+const e = exposes.presets;
+
+module.exports = [
+    {
+        zigbeeModel: ['HK-DIM-A', 'Candeo Zigbee Dimmer'],
+        model: 'HK-DIM-A',
+        vendor: 'Candeo',
+        description: 'Zigbee LED dimmer smart switch',
+        extend: extend.light_onoff_brightness({noConfigure: true, disableEffect: true}),
+        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);
+
+            // The default reporting from the Candeo dimmer can result in a lot of Zigbee traffic
+            // to the extent that reported brighness values can arrive at the endpoint out of order
+            // giving the appearance that the values are jumping around.
+            // Limit the reporting to once a second to give a smoother reporting of brightness.
+            await reporting.brightness(endpoint, {min: 1});
+        },
+    },
+    {
+        zigbeeModel: ['C204'],
+        model: 'C204',
+        vendor: 'Candeo',
+        description: 'Zigbee micro smart dimmer',
+        fromZigbee: extend.light_onoff_brightness().fromZigbee.concat([fz.electrical_measurement, fz.metering, fz.ignore_genOta]),
+        toZigbee: extend.light_onoff_brightness().toZigbee,
+        exposes: [e.light_brightness(), e.power(), e.voltage(), e.current(), e.energy()],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            const binds = ['genOnOff', 'genLevelCtrl', 'haElectricalMeasurement', 'seMetering'];
+            await reporting.bind(endpoint, coordinatorEndpoint, binds);
+            await reporting.onOff(endpoint);
+            await reporting.brightness(endpoint);
+            await reporting.readEletricalMeasurementMultiplierDivisors(endpoint);
+            await reporting.activePower(endpoint);
+            await reporting.rmsCurrent(endpoint, {min: 10, change: 10});
+            await reporting.rmsVoltage(endpoint, {min: 10});
+            await reporting.readMeteringMultiplierDivisor(endpoint);
+            await reporting.currentSummDelivered(endpoint);
+        },
+    },
+];

package/devices/casaia.js

@@ -0,0 +1,52 @@
+const exposes = require('../lib/exposes');
+const fz = {...require('../converters/fromZigbee'), legacy: require('../lib/legacy').fromZigbee};
+const reporting = require('../lib/reporting');
+const e = exposes.presets;
+const tz = require('../converters/toZigbee');
+const extend = require('../lib/extend');
+
+module.exports = [
+    {
+        zigbeeModel: ['CSLC601-D-E'],
+        model: 'CSLC601-D-E',
+        vendor: 'CASAIA',
+        description: 'Dry contact relay switch module in 220v AC for gas boiler',
+        extend: extend.switch(),
+    },
+    {
+        zigbeeModel: ['CTHS317ET'],
+        model: 'CTHS-317-ET',
+        vendor: 'CASAIA',
+        description: 'Remote temperature probe on cable',
+        fromZigbee: [fz.temperature, fz.battery],
+        toZigbee: [],
+        meta: {battery: {voltageToPercentage: '3V_2500'}},
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(3);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['msTemperatureMeasurement']);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg']);
+            await reporting.temperature(endpoint);
+            await reporting.batteryVoltage(endpoint);
+            await reporting.batteryPercentageRemaining(endpoint);
+        },
+        exposes: [e.temperature(), e.battery_low(), e.battery()],
+    },
+    {
+        zigbeeModel: ['CCB432'],
+        model: 'CCB432',
+        vendor: 'CASAIA',
+        description: 'Rail-Din relay and energy meter',
+        fromZigbee: [fz.electrical_measurement, fz.metering, fz.on_off],
+        toZigbee: [tz.on_off],
+        exposes: [e.switch(), e.power(), e.energy()],
+        meta: {publishDuplicateTransaction: true},
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'haElectricalMeasurement', 'seMetering']);
+            await reporting.onOff(endpoint);
+            await reporting.readMeteringMultiplierDivisor(endpoint);
+            await reporting.instantaneousDemand(endpoint);
+            await reporting.currentSummDelivered(endpoint);
+        },
+    },
+];