@willieee802/zigbee-herdsman-converters 15.0.8-4.1

package/devices/xinghuoyuan.js

@@ -0,0 +1,11 @@
+const extend = require('../lib/extend');
+
+module.exports = [
+    {
+        zigbeeModel: ['X2SK11'],
+        model: 'X2SK11',
+        vendor: 'XingHuoYuan',
+        description: 'Smart socket',
+        extend: extend.switch(),
+    },
+];

package/devices/yale.js

@@ -0,0 +1,227 @@
+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 e = exposes.presets;
+
+const lockExtend = (meta, lockStateOptions=null, binds=['closuresDoorLock', 'genPowerCfg']) => {
+    return {
+        fromZigbee: [fz.lock, fz.battery, fz.lock_operation_event, fz.lock_programming_event, fz.lock_pin_code_response,
+            fz.lock_user_status_response],
+        toZigbee: [tz.lock, tz.pincode_lock, tz.lock_userstatus, tz.lock_auto_relock_time, tz.lock_sound_volume],
+        meta: {pinCodeCount: 250, ...meta},
+        exposes: [e.lock(), e.battery(), e.pincode(), e.lock_action(), e.lock_action_source_name(), e.lock_action_user(),
+            e.auto_relock_time().withValueMin(0).withValueMax(3600), e.sound_volume(), e.battery_low()],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, binds);
+            await reporting.lockState(endpoint, lockStateOptions);
+            await reporting.batteryPercentageRemaining(endpoint);
+            try {
+                await reporting.batteryAlarmState(endpoint);
+            } catch (e) {
+                // Fails for some: https://github.com/Koenkk/zigbee-herdsman-converters/pull/5414
+            }
+        },
+    };
+};
+
+const fzLocal = {
+    c4_lock_operation_event: {
+        cluster: 'genAlarms',
+        type: ['commandAlarm'],
+        convert: async (model, msg, publish, options, meta) => {
+            let result = {};
+            if (msg.data.clusterid == 64512) {
+                const alarmcode = msg.data.alarmcode;
+                const lookup = {
+                    9: {action: 'error_jammed', state: 'UNLOCK', lock_state: 'not_fully_locked'},
+                    21: {action: 'manual_lock', state: 'LOCK', lock_state: 'locked'},
+                    22: {action: 'manual_unlock', state: 'UNLOCK', lock_state: 'unlocked'},
+                    24: {action: 'lock', state: 'LOCK', lock_state: 'locked'},
+                    25: {action: 'unlock', state: 'UNLOCK', lock_state: 'unlocked'},
+                    27: {action: 'auto_lock', state: 'LOCK', lock_state: 'locked'},
+                };
+                if (!lookup[alarmcode]) {
+                    result.action = 'unknown';
+                    meta.logger.warn(`zigbee-herdsman-converters:Yale Lock: Unrecognized Operation Event (${alarmcode})`);
+                    // We need to read the lock state as the alarm code is unknown
+                    try {
+                        await msg.endpoint.read('closuresDoorLock', ['lockState']);
+                    } catch (error) {
+                        meta.logger.warn(`zigbee-herdsman-converters:Yale Lock: failed to read lock state`);
+                    }
+                } else {
+                    result = lookup[alarmcode];
+                }
+            }
+            return result;
+        },
+    },
+};
+
+module.exports = [
+    {
+        zigbeeModel: ['YRD446 BLE TSDB'],
+        model: 'YRD426NRSC',
+        vendor: 'Yale',
+        description: 'Assure lock',
+        extend: lockExtend(),
+    },
+    {
+        zigbeeModel: ['YRD226 TSDB', 'YRD226L TSDB'],
+        model: 'YRD226HA2619',
+        vendor: 'Yale',
+        description: 'Assure lock',
+        extend: lockExtend(),
+    },
+    {
+        zigbeeModel: ['YRD256 TSDB', 'YRD256L TSDB'],
+        model: 'YRD256HA20BP',
+        vendor: 'Yale',
+        description: 'Assure lock SL',
+        extend: lockExtend(),
+    },
+    {
+        zigbeeModel: ['0600000001'],
+        model: 'YMF30',
+        vendor: 'Yale',
+        description: 'Digital lock',
+        extend: lockExtend({battery: {dontDividePercentage: true}}),
+    },
+    {
+        zigbeeModel: ['iZBModule01', '0700000001'],
+        model: 'YMF40/YDM4109+/YDF40',
+        vendor: 'Yale',
+        description: 'Real living lock / Intelligent biometric digital lock',
+        // Increased timeout needed: https://github.com/Koenkk/zigbee2mqtt/issues/3290 for YDM4109+
+        extend: lockExtend({battery: {dontDividePercentage: true}}, {timeout: 20000}),
+    },
+    {
+        zigbeeModel: ['YRD210 PB DB'],
+        model: 'YRD210-HA-605',
+        vendor: 'Yale',
+        description: 'Real living keyless push button deadbolt lock',
+        extend: lockExtend({battery: {dontDividePercentage: true}}),
+    },
+    {
+        zigbeeModel: ['YRL220 TS LL'],
+        // The zigbee module card indicate that the module will work on YRD 221 and YRD 221RL also
+        model: 'YRL-220L',
+        vendor: 'Yale',
+        description: 'Real living keyless leveler lock',
+        extend: lockExtend({battery: {dontDividePercentage: true}}),
+    },
+    {
+        zigbeeModel: ['YRD226/246 TSDB'],
+        model: 'YRD226/246 TSDB',
+        vendor: 'Yale',
+        description: 'Assure lock',
+        extend: lockExtend(),
+    },
+    {
+        zigbeeModel: ['YRD220/240 TSDB'],
+        model: 'YRD220/YRD221',
+        vendor: 'Yale',
+        description: 'Lockwood keyless push button deadbolt lock',
+        extend: lockExtend({battery: {dontDividePercentage: true}}),
+    },
+    {
+        zigbeeModel: ['YRD246 TSDB'],
+        model: 'YRD246HA20BP',
+        vendor: 'Yale',
+        description: 'Assure lock key free deadbolt with Zigbee',
+        extend: lockExtend({battery: {dontDividePercentage: true}}),
+    },
+    {
+        zigbeeModel: ['YRD216 PBDB'],
+        model: 'YRD216-HA2-619',
+        vendor: 'Yale',
+        description: 'Real living keyless push button deadbolt lock',
+        extend: lockExtend({battery: {dontDividePercentage: true}}),
+    },
+    {
+        zigbeeModel: ['YRL226L TS'],
+        model: 'YRL226L TS',
+        vendor: 'Yale',
+        description: 'Assure lock SL',
+        extend: lockExtend(),
+    },
+    {
+        zigbeeModel: ['YRL226 TS'],
+        model: 'YRL226 TS',
+        vendor: 'Yale',
+        description: 'Assure lock SL',
+        extend: lockExtend(),
+    },
+    {
+        zigbeeModel: ['YRD410 TS'],
+        model: 'YRD410-BLE',
+        vendor: 'Yale',
+        description: 'Assure lock 2',
+        extend: lockExtend(),
+    },
+    {
+        zigbeeModel: ['YRD420 TS'],
+        model: 'YRD420-BLE',
+        vendor: 'Yale',
+        description: 'Assure lock 2',
+        extend: lockExtend(),
+    },
+    {
+        zigbeeModel: ['YRD430 TS'],
+        model: 'YRD430-BLE',
+        vendor: 'Yale',
+        description: 'Assure lock 2',
+        extend: lockExtend(),
+    },
+    {
+        zigbeeModel: ['YRD450 TS'],
+        model: 'YRD450-BLE',
+        vendor: 'Yale',
+        description: 'Assure lock 2',
+        extend: lockExtend(),
+    },
+    {
+        // Appears to be a slightly rebranded Assure lock SL
+        // Just with Lockwood | Assa Abloy branding instead of Yale
+        // Appears to have been part of a deal with Telstra, hence the T-Lock name
+        zigbeeModel: ['YDD-D4F0 TSDB'],
+        model: 'YDD-D4F0-TSDB',
+        vendor: 'Yale',
+        description: 'Lockwood T-Lock',
+        extend: lockExtend(),
+    },
+    {
+        zigbeeModel: ['c700000202', '06ffff2029'],
+        model: 'YDF40',
+        vendor: 'Yale',
+        description: 'Real living lock / Intelligent biometric digital lock',
+        extend: lockExtend({battery: {dontDividePercentage: true}}, {max: 900}, ['closuresDoorLock']),
+    },
+    {
+        zigbeeModel: ['06ffff2027'],
+        model: 'YMF40A RL',
+        vendor: 'Yale',
+        description: 'Real living lock / Intelligent biometric digital lock',
+        extend: lockExtend({battery: {dontDividePercentage: true}}),
+    },
+    {
+        fingerprint: [{
+            type: 'EndDevice',
+            manufacturerName: 'Yale',
+            manufacturerID: 43690,
+            powerSource: 'Battery',
+            endpoints: [
+                {ID: 1, profileID: 260, deviceID: 10, inputClusters: [0, 9, 10, 257, 64512, 1], outputClusters: []},
+                {ID: 196, profileID: 260, deviceID: 10, inputClusters: [1], outputClusters: []},
+            ]},
+        ],
+        model: 'ZYA-C4-MOD-S',
+        vendor: 'Yale',
+        description: 'Control4 module for Yale KeyFree/Keyless/Doorman/Assure/nexTouch locks',
+        fromZigbee: [fz.lock, fzLocal.c4_lock_operation_event],
+        toZigbee: [tz.lock],
+        exposes: [e.lock(), e.lock_action()],
+    },
+];

package/devices/ynoa.js

@@ -0,0 +1,68 @@
+const exposes = require('../lib/exposes');
+const fz = require('../converters/fromZigbee');
+const tz = require('../converters/toZigbee');
+const reporting = require('../lib/reporting');
+const e = exposes.presets;
+const extend = require('..//lib/extend');
+
+module.exports = [
+    {
+        zigbeeModel: ['ZBT-CCTLight-GU100001'],
+        model: '8718801528273',
+        vendor: 'Ynoa',
+        description: 'Smart LED GU10 CCT',
+        extend: extend.light_onoff_brightness_colortemp({colorTempRange: [153, 454]}),
+    },
+    {
+        zigbeeModel: ['ZBT-DIMSwitch-D0000'],
+        model: '8718801528334',
+        vendor: 'Ynoa',
+        description: 'Remote control one button dimmer',
+        fromZigbee: [fz.command_on, fz.command_off, fz.command_move, fz.command_stop, fz.battery],
+        exposes: [e.action(['on', 'off', 'brightness_move_up', 'brightness_move_down', 'brightness_stop']), e.battery()],
+        toZigbee: [],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg']);
+            await reporting.batteryPercentageRemaining(endpoint);
+        },
+    },
+    {
+        zigbeeModel: ['ZBT-RGBWLight-M0000'],
+        model: 'LA-GU10-RGBW',
+        vendor: 'Ynoa',
+        description: 'Smart LED GU10 RGB CCT',
+        extend: extend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 526], supportsHS: true}),
+    },
+    {
+        zigbeeModel: ['ZBT-RGBWSwitch-D0800'],
+        model: 'LA-5KEY-RGBW',
+        vendor: 'Ynoa',
+        description: '5 key control for RGBW light',
+        fromZigbee: [fz.command_on, fz.command_off, fz.command_move_to_color_temp,
+            fz.command_move_to_color, fz.command_move_to_level, fz.battery],
+        exposes: [e.battery(), e.battery_low(), e.action(['on', 'off', 'brightness_move_to_level',
+            'color_temperature_move', 'color_move'])],
+        toZigbee: [],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg']);
+            await reporting.batteryPercentageRemaining(endpoint);
+        },
+    },
+    {
+        zigbeeModel: ['ZBT-ONOFFPlug-D0009'],
+        model: 'LA-PLUG-10Amp',
+        vendor: 'Ynoa',
+        description: 'Smart plug Zigbee 3.0',
+        fromZigbee: [fz.on_off, fz.electrical_measurement, fz.metering],
+        toZigbee: [tz.on_off],
+        exposes: [e.switch(), e.power()],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'haElectricalMeasurement', 'seMetering']);
+            await reporting.onOff(endpoint);
+            await reporting.activePower(endpoint);
+        },
+    },
+];

package/devices/yookee.js

@@ -0,0 +1,23 @@
+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 e = exposes.presets;
+
+module.exports = [
+    {
+        zigbeeModel: ['D10110'],
+        model: 'D10110',
+        vendor: 'Yookee',
+        description: 'Smart blind controller',
+        fromZigbee: [fz.cover_position_tilt, fz.battery],
+        toZigbee: [tz.cover_state, tz.cover_position_tilt],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg', 'closuresWindowCovering']);
+            await reporting.batteryPercentageRemaining(endpoint);
+            await reporting.currentPositionLiftPercentage(endpoint);
+        },
+        exposes: [e.cover_position(), e.battery()],
+    },
+];

package/devices/ysrsai.js

@@ -0,0 +1,26 @@
+const tuya = require('../lib/tuya');
+
+module.exports = [
+    {
+        fingerprint: [{modelID: 'ZB-CL01', manufacturerName: 'YSRSAI'}],
+        zigbeeModel: ['ZB-CL03', 'FB56-ZCW20FB1.2'],
+        model: 'YSR-MINI-01_rgbcct',
+        vendor: 'YSRSAI',
+        description: 'Zigbee LED controller (RGB+CCT)',
+        extend: tuya.extend.light_onoff_brightness_colortemp_color({colorTempRange: [160, 370]}),
+    },
+    {
+        zigbeeModel: ['ZB-CT01'],
+        model: 'YSR-MINI-01_wwcw',
+        vendor: 'YSRSAI',
+        description: 'Zigbee LED controller (WW/CW)',
+        extend: tuya.extend.light_onoff_brightness_colortemp_color(),
+    },
+    {
+        zigbeeModel: ['ZB-DL01'],
+        model: 'YSR-MINI-01_dimmer',
+        vendor: 'YSRSAI',
+        description: 'Zigbee LED controller (Dimmer)',
+        extend: tuya.extend.light_onoff_brightness(),
+    },
+];

package/devices/zemismart.js

@@ -0,0 +1,254 @@
+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 tuya = require('../lib/tuya');
+const ea = exposes.access;
+
+const fzLocal = {
+    ZMRM02: {
+        cluster: 'manuSpecificTuya',
+        type: ['commandGetData', 'commandSetDataResponse', 'commandDataResponse'],
+        convert: (model, msg, publish, options, meta) => {
+            const dpValue = tuya.firstDpValue(msg, meta, 'ZMRM02');
+            if (dpValue.dp === 10) {
+                return {battery: tuya.getDataValue(dpValue)};
+            } else {
+                const button = dpValue.dp;
+                const actionValue = tuya.getDataValue(dpValue);
+                const lookup = {0: 'single', 1: 'double', 2: 'hold'};
+                const action = lookup[actionValue];
+                return {action: `button_${button}_${action}`};
+            }
+        },
+    },
+};
+
+module.exports = [
+    {
+        zigbeeModel: ['NUET56-DL27LX1.1'],
+        model: 'LXZB-12A',
+        vendor: 'Zemismart',
+        description: 'RGB LED downlight',
+        extend: extend.light_onoff_brightness_colortemp_color(),
+    },
+    {
+        zigbeeModel: ['LXT56-LS27LX1.6'],
+        model: 'HGZB-DLC4-N15B',
+        vendor: 'Zemismart',
+        description: 'RGB LED downlight',
+        extend: extend.light_onoff_brightness_colortemp_color(),
+    },
+    {
+        zigbeeModel: ['TS0302'],
+        model: 'ZM-CSW032-D',
+        vendor: 'Zemismart',
+        description: 'Curtain/roller blind switch',
+        fromZigbee: [fz.ignore_basic_report, fz.ZMCSW032D_cover_position],
+        toZigbee: [tz.cover_state, tz.ZMCSW032D_cover_position],
+        exposes: [e.cover_position()],
+        meta: {multiEndpoint: true},
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['closuresWindowCovering']);
+            // Configure reporing of currentPositionLiftPercentage always fails.
+            // https://github.com/Koenkk/zigbee2mqtt/issues/3216
+        },
+    },
+    {
+        zigbeeModel: ['TS0003'],
+        model: 'ZM-L03E-Z',
+        vendor: 'Zemismart',
+        description: 'Smart light switch - 3 gang with neutral wire',
+        extend: extend.switch(),
+        exposes: [e.switch().withEndpoint('left'), e.switch().withEndpoint('center'), e.switch().withEndpoint('right')],
+        endpoint: (device) => {
+            return {'left': 1, 'center': 2, 'right': 3};
+        },
+        whiteLabel: [{vendor: 'BSEED', model: 'TS0003', description: 'Zigbee switch'}],
+        meta: {multiEndpoint: true, disableDefaultResponse: true},
+        configure: async (device, coordinatorEndpoint, logger) => {
+            await tuya.configureMagicPacket(device, coordinatorEndpoint, logger);
+            await reporting.bind(device.getEndpoint(1), coordinatorEndpoint, ['genOnOff']);
+            await reporting.bind(device.getEndpoint(2), coordinatorEndpoint, ['genOnOff']);
+            await reporting.bind(device.getEndpoint(3), coordinatorEndpoint, ['genOnOff']);
+        },
+    },
+    {
+        fingerprint: [{modelID: 'TS0003', manufacturerName: '_TZ3000_vjhcenzo'}, {modelID: 'TS0003', manufacturerName: '_TZ3000_f09j9qjb'}],
+        model: 'TB25',
+        vendor: 'Zemismart',
+        description: 'Smart light switch and socket - 2 gang with neutral wire',
+        extend: tuya.extend.switch({endpoints: ['left', 'center', 'right']}),
+        meta: {multiEndpoint: true},
+        endpoint: () => {
+            return {'left': 1, 'center': 2, 'right': 3};
+        },
+        configure: async (device, coordinatorEndpoint, logger) => {
+            await tuya.configureMagicPacket(device, coordinatorEndpoint, logger);
+            for (const endpointID of [1, 2, 3]) {
+                const endpoint = device.getEndpoint(endpointID);
+                await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff']);
+                await reporting.onOff(endpoint);
+            }
+        },
+    },
+    {
+        zigbeeModel: ['LXN56-SS27LX1.1'],
+        model: 'LXN56-SS27LX1.1',
+        vendor: 'Zemismart',
+        description: 'Smart light switch - 2 gang with neutral wire',
+        extend: extend.switch(),
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(10);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff']);
+            await reporting.onOff(endpoint);
+        },
+    },
+    {
+        fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_zqtiam4u'}],
+        model: 'ZM-RM02',
+        vendor: 'Zemismart',
+        description: 'Smart 6 key scene switch',
+        fromZigbee: [fzLocal.ZMRM02],
+        toZigbee: [],
+        onEvent: tuya.onEventSetTime,
+        exposes: [e.battery(), e.action([
+            'button_1_hold', 'button_1_single', 'button_1_double',
+            'button_2_hold', 'button_2_single', 'button_2_double',
+            'button_3_hold', 'button_3_single', 'button_3_double',
+            'button_4_hold', 'button_4_single', 'button_4_double',
+            'button_5_hold', 'button_5_single', 'button_5_double',
+            'button_6_hold', 'button_6_single', 'button_6_double'])],
+    },
+    {
+        fingerprint: tuya.fingerprint('TS011F', ['_TZ3000_zigisuyh', '_TZ3000_v4mevirn', '_TZ3000_mlswgkc3']),
+        model: 'ZIGBEE-B09-UK',
+        vendor: 'Zemismart',
+        description: 'Zigbee smart outlet universal socket with USB port',
+        extend: tuya.extend.switch({powerOutageMemory: true, endpoints: ['l1', 'l2']}),
+        endpoint: (device) => {
+            return {'l1': 1, 'l2': 2};
+        },
+        meta: {multiEndpoint: true},
+        configure: async (device, coordinatorEndpoint, logger) => {
+            await tuya.configureMagicPacket(device, coordinatorEndpoint, logger);
+            await reporting.bind(device.getEndpoint(1), coordinatorEndpoint, ['genOnOff']);
+            await reporting.bind(device.getEndpoint(2), coordinatorEndpoint, ['genOnOff']);
+            await reporting.onOff(device.getEndpoint(1));
+            await reporting.onOff(device.getEndpoint(2));
+        },
+    },
+    {
+        fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_iossyxra'}],
+        model: 'ZM-AM02_cover',
+        vendor: 'Zemismart',
+        description: 'Zigbee/RF curtain converter',
+        fromZigbee: [fz.ZMAM02_cover],
+        toZigbee: [tz.ZMAM02_cover],
+        exposes: [e.cover_position().setAccess('position', ea.STATE_SET),
+            exposes.composite('options', 'options', ea.STATE)
+                .withFeature(exposes.numeric('motor_speed', ea.STATE)
+                    .withValueMin(0)
+                    .withValueMax(255)
+                    .withDescription('Motor speed')),
+            exposes.enum('motor_working_mode', ea.STATE_SET, Object.values(tuya.ZMLookups.AM02MotorWorkingMode)),
+            exposes.numeric('percent_state', ea.STATE).withValueMin(0).withValueMax(100).withValueStep(1).withUnit('%'),
+            exposes.enum('mode', ea.STATE_SET, Object.values(tuya.ZMLookups.AM02Mode)),
+            exposes.enum('motor_direction', ea.STATE_SET, Object.values(tuya.ZMLookups.AM02Direction)),
+            exposes.enum('border', ea.STATE_SET, Object.values(tuya.ZMLookups.AM02Border)),
+        // ---------------------------------------------------------------------------------
+        // DP exists, but not used at the moment
+        // exposes.numeric('percent_control', ea.STATE_SET).withValueMin(0).withValueMax(100).withValueStep(1).withUnit('%'),
+        // exposes.enum('work_state', ea.STATE, Object.values(tuya.ZMAM02.AM02WorkState)),
+        // exposes.numeric('countdown_left', ea.STATE).withUnit('s'),
+        // exposes.numeric('time_total', ea.STATE).withUnit('ms'),
+        // exposes.enum('situation_set', ea.STATE, Object.values(tuya.ZMAM02.AM02Situation)),
+        ],
+    },
+    {
+        fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_gubdgai2'}],
+        model: 'M515EGBZTN',
+        vendor: 'Zemismart',
+        description: 'Roller shade driver',
+        fromZigbee: [fz.ZMAM02_cover],
+        toZigbee: [tz.ZMAM02_cover],
+        exposes: [e.cover_position().setAccess('position', ea.STATE_SET),
+            exposes.enum('motor_direction', ea.STATE_SET, Object.values(tuya.ZMLookups.AM02Direction)),
+            exposes.enum('border', ea.STATE_SET, Object.values(tuya.ZMLookups.AM02Border)),
+        ],
+    },
+    {
+        fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_fzo2pocs'}],
+        model: 'ZM25TQ',
+        vendor: 'Zemismart',
+        description: 'Tubular motor',
+        fromZigbee: [fz.tuya_cover, fz.ignore_basic_report],
+        toZigbee: [tz.tuya_cover_control, tz.tuya_cover_options, tz.tuya_data_point_test],
+        exposes: [e.cover_position().setAccess('position', ea.STATE_SET)],
+    },
+    {
+        fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_7eue9vhc'}],
+        model: 'ZM25RX-08/30',
+        vendor: 'Zemismart',
+        description: 'Tubular motor',
+        fromZigbee: [fz.tuya_cover, fz.ignore_basic_report],
+        toZigbee: [tz.tuya_cover_control, tz.tuya_cover_options],
+        exposes: [e.cover_position().setAccess('position', ea.STATE_SET)],
+    },
+    {
+        fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_1n2kyphz'}],
+        model: 'TB26-4',
+        vendor: 'Zemismart',
+        description: '4-gang smart wall switch',
+        exposes: [e.switch().withEndpoint('l1').setAccess('state', ea.STATE_SET),
+            e.switch().withEndpoint('l2').setAccess('state', ea.STATE_SET),
+            e.switch().withEndpoint('l3').setAccess('state', ea.STATE_SET),
+            e.switch().withEndpoint('l4').setAccess('state', ea.STATE_SET)],
+        fromZigbee: [fz.ignore_basic_report, fz.tuya_switch],
+        toZigbee: [tz.tuya_switch_state],
+        meta: {multiEndpoint: true},
+        endpoint: (device) => {
+            return {'l1': 1, 'l2': 1, 'l3': 1, 'l4': 1};
+        },
+        configure: async (device, coordinatorEndpoint, logger) => {
+            await reporting.bind(device.getEndpoint(1), coordinatorEndpoint, ['genOnOff']);
+            if (device.getEndpoint(2)) await reporting.bind(device.getEndpoint(2), coordinatorEndpoint, ['genOnOff']);
+            if (device.getEndpoint(3)) await reporting.bind(device.getEndpoint(3), coordinatorEndpoint, ['genOnOff']);
+            if (device.getEndpoint(4)) await reporting.bind(device.getEndpoint(4), coordinatorEndpoint, ['genOnOff']);
+            device.powerSource = 'Mains (single phase)';
+            device.save();
+        },
+    },
+    {
+        fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_9mahtqtg'}, {modelID: 'TS0601', manufacturerName: '_TZE200_r731zlxk'}],
+        model: 'TB26-6',
+        vendor: 'Zemismart',
+        description: '6-gang smart wall switch',
+        exposes: [e.switch().withEndpoint('l1').setAccess('state', ea.STATE_SET),
+            e.switch().withEndpoint('l2').setAccess('state', ea.STATE_SET),
+            e.switch().withEndpoint('l3').setAccess('state', ea.STATE_SET),
+            e.switch().withEndpoint('l4').setAccess('state', ea.STATE_SET),
+            e.switch().withEndpoint('l5').setAccess('state', ea.STATE_SET),
+            e.switch().withEndpoint('l6').setAccess('state', ea.STATE_SET)],
+        fromZigbee: [fz.ignore_basic_report, fz.tuya_switch],
+        toZigbee: [tz.tuya_switch_state],
+        meta: {multiEndpoint: true},
+        endpoint: (device) => {
+            return {'l1': 1, 'l2': 1, 'l3': 1, 'l4': 1, 'l5': 1, 'l6': 1};
+        },
+        configure: async (device, coordinatorEndpoint, logger) => {
+            await reporting.bind(device.getEndpoint(1), coordinatorEndpoint, ['genOnOff']);
+            if (device.getEndpoint(2)) await reporting.bind(device.getEndpoint(2), coordinatorEndpoint, ['genOnOff']);
+            if (device.getEndpoint(3)) await reporting.bind(device.getEndpoint(3), coordinatorEndpoint, ['genOnOff']);
+            if (device.getEndpoint(4)) await reporting.bind(device.getEndpoint(4), coordinatorEndpoint, ['genOnOff']);
+            if (device.getEndpoint(5)) await reporting.bind(device.getEndpoint(5), coordinatorEndpoint, ['genOnOff']);
+            if (device.getEndpoint(6)) await reporting.bind(device.getEndpoint(6), coordinatorEndpoint, ['genOnOff']);
+            // Reports itself as battery which is not correct: https://github.com/Koenkk/zigbee2mqtt/issues/6190
+            device.powerSource = 'Mains (single phase)';
+            device.save();
+        },
+    },
+];

package/devices/zen.js

@@ -0,0 +1,34 @@
+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');
+
+module.exports = [
+    {
+        zigbeeModel: ['Zen-01'],
+        model: 'Zen-01-W',
+        vendor: 'Zen',
+        description: 'Thermostat',
+        fromZigbee: [fz.battery, fz.legacy.thermostat_att_report],
+        toZigbee: [tz.thermostat_local_temperature, tz.thermostat_local_temperature_calibration,
+            tz.thermostat_occupancy, tz.thermostat_occupied_heating_setpoint, tz.thermostat_occupied_cooling_setpoint,
+            tz.thermostat_unoccupied_heating_setpoint, tz.thermostat_setpoint_raise_lower, tz.thermostat_running_state,
+            tz.thermostat_remote_sensing, tz.thermostat_control_sequence_of_operation, tz.thermostat_system_mode,
+            tz.thermostat_weekly_schedule, tz.thermostat_clear_weekly_schedule, tz.thermostat_relay_status_log],
+        exposes: [exposes.climate().withSetpoint('occupied_heating_setpoint', 10, 30, 0.5)
+            .withSetpoint('occupied_cooling_setpoint', 10, 31, 0.5).withLocalTemperature()
+            .withSystemMode(['off', 'auto', 'heat', 'cool']).withRunningState(['idle', 'heat', 'cool'])
+            .withLocalTemperatureCalibration().withPiHeatingDemand()],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(3) || device.getEndpoint(1);
+            const binds = ['genBasic', 'genIdentify', 'genPowerCfg', 'genTime', 'hvacThermostat', 'hvacUserInterfaceCfg'];
+            await reporting.bind(endpoint, coordinatorEndpoint, binds);
+
+            await reporting.thermostatSystemMode(endpoint);
+            await reporting.batteryVoltage(endpoint);
+            await reporting.thermostatTemperature(endpoint);
+            await reporting.thermostatRunningState(endpoint);
+            await reporting.thermostatOccupiedHeatingSetpoint(endpoint);
+        },
+    },
+];

package/devices/zipato.js

@@ -0,0 +1,11 @@
+const extend = require('../lib/extend');
+
+module.exports = [
+    {
+        zigbeeModel: ['ZHA-ColorLight'],
+        model: 'rgbw2.zbee27',
+        vendor: 'Zipato',
+        description: 'RGBW LED bulb with dimmer',
+        extend: extend.light_onoff_brightness_colortemp_color(),
+    },
+];