zigbee-herdsman-converters 14.0.406 → 14.0.410

package/converters/fromZigbee.js

@@ -2522,8 +2522,8 @@ const converters = {
                 return {battpercentage: value};
             case tuya.dataPoints.neoAOMelody: // 0x21 [5] Melody
                 return {melody: value};
-            case tuya.dataPoints.neoAOVolume: // 0x5 [0]/[1]/[2] Volume 0-max, 2-low
-                return {volume: {2: 'low', 1: 'medium', 0: 'high'}[value]};
+            case tuya.dataPoints.neoAOVolume: // 0x5 [0]/[1]/[2] Volume 0-low, 2-max
+                return {volume: {0: 'low', 1: 'medium', 2: 'high'}[value]};
             default: // Unknown code
                 meta.logger.warn(`Unhandled DP #${dp}: ${JSON.stringify(msg.data)}`);
             }
@@ -3211,6 +3211,10 @@ const converters = {
                 result[postfixWithEndpointName('pi_heating_demand', msg, model)] =
                     precisionRound(msg.data['pIHeatingDemand'], 0);
             }
+            if (msg.data.hasOwnProperty('danfossWindowOpenFeatureEnable')) {
+                result[postfixWithEndpointName('window_open_feature', msg, model)] =
+                    (msg.data['danfossWindowOpenFeatureEnable'] === 1);
+            }
             if (msg.data.hasOwnProperty('danfossWindowOpenInternal')) {
                 result[postfixWithEndpointName('window_open_internal', msg, model)] =
                     constants.danfossWindowOpen.hasOwnProperty(msg.data['danfossWindowOpenInternal']) ?
@@ -5164,8 +5168,16 @@ const converters = {
     aqara_opple: {
         cluster: 'aqaraOpple',
         type: ['attributeReport', 'readResponse'],
-        options: [exposes.options.precision('temperature'), exposes.options.calibration('temperature'),
-            exposes.options.precision('illuminance'), exposes.options.calibration('illuminance', 'percentual')],
+        options: (definition) => {
+            const result = [];
+            if (definition.exposes.find((e) => e.name === 'temperature')) {
+                result.push(exposes.options.precision('temperature'), exposes.options.calibration('temperature'));
+            }
+            if (definition.exposes.find((e) => e.name === 'illuminance')) {
+                result.push(exposes.options.precision('illuminance'), exposes.options.calibration('illuminance', 'percentual'));
+            }
+            return result;
+        },
         convert: (model, msg, publish, options, meta) => {
             const payload = {};
             if (msg.data.hasOwnProperty('247')) {

package/converters/toZigbee.js

@@ -2417,12 +2417,6 @@ const converters = {
             await entity.read('genAnalogOutput', [0x0055]);
         },
     },
-    xiaomi_curtain_acn002_status: {
-        key: ['motor_state'],
-        convertGet: async (entity, key, meta) => {
-            await entity.read('genMultistateOutput', [0x0055]);
-        },
-    },
     ledvance_commands: {
         /* deprectated osram_*/
         key: ['set_transition', 'remember_state', 'osram_set_transition', 'osram_remember_state'],
@@ -2752,6 +2746,16 @@ const converters = {
             await entity.read('hvacThermostat', ['danfossTriggerTime'], manufacturerOptions.danfoss);
         },
     },
+    danfoss_window_open_feature: {
+        key: ['window_open_feature'],
+        convertSet: async (entity, key, value, meta) => {
+            await entity.write('hvacThermostat', {'danfossWindowOpenFeatureEnable': value}, manufacturerOptions.danfoss);
+            return {readAfterWriteTime: 200, state: {'window_open_feature': value}};
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read('hvacThermostat', ['danfossWindowOpenFeatureEnable'], manufacturerOptions.danfoss);
+        },
+    },
     danfoss_window_open_internal: {
         key: ['window_open_internal'],
         convertGet: async (entity, key, meta) => {

package/devices/danfoss.js

@@ -22,7 +22,8 @@ module.exports = [
             tz.danfoss_window_open_internal, tz.danfoss_window_open_external, tz.danfoss_load_estimate,
             tz.danfoss_viewing_direction, tz.danfoss_external_measured_room_sensor, tz.danfoss_radiator_covered,
             tz.thermostat_keypad_lockout, tz.thermostat_system_mode, tz.danfoss_load_balancing_enable, tz.danfoss_load_room_mean,
-            tz.thermostat_weekly_schedule, tz.thermostat_clear_weekly_schedule, tz.thermostat_programming_operation_mode],
+            tz.thermostat_weekly_schedule, tz.thermostat_clear_weekly_schedule, tz.thermostat_programming_operation_mode,
+            tz.danfoss_window_open_feature],
         exposes: [e.battery(), e.keypad_lockout(), e.programming_operation_mode(),
             exposes.binary('mounted_mode_active', ea.STATE_GET, true, false)
                 .withDescription('Is the unit in mounting mode. This is set to `false` for mounted (already on ' +
@@ -53,6 +54,8 @@ module.exports = [
             exposes.binary('radiator_covered', ea.ALL, true, false)
                 .withDescription('Set if the TRV should solely rely on external_measured_room_sensor or operate in offset mode. ' +
                     '`false` = Auto Offset Mode or `true` = Room Sensor Mode'),
+            exposes.binary('window_open_feature', ea.ALL, true, false)
+                .withDescription('Whether or not the window open feature is enabled'),
             exposes.numeric('window_open_internal', ea.STATE_GET).withValueMin(0).withValueMax(4)
                 .withDescription('0=Quarantine, 1=Windows are closed, 2=Hold - Windows are maybe about to open, ' +
                     '3=Open window detected, 4=In window open state from external but detected closed locally'),
@@ -114,6 +117,7 @@ module.exports = [
             }], options);
 
             await endpoint.read('hvacThermostat', [
+                'danfossWindowOpenFeatureEnable',
                 'danfossWindowOpenExternal',
                 'danfossDayOfWeek',
                 'danfossTriggerTime',

package/devices/gledopto.js

@@ -62,6 +62,12 @@ const gledoptoExtend = {
     }),
 };
 
+const configureReadModelID = async (device) => {
+    // https://github.com/Koenkk/zigbee-herdsman-converters/issues/3016#issuecomment-1027726604
+    const endpoint = device.endpoints[0];
+    await endpoint.read('genBasic', ['modelId']);
+};
+
 module.exports = [
     {
         fingerprint: [
@@ -116,7 +122,11 @@ module.exports = [
         vendor: 'Gledopto',
         ota: ota.zigbeeOTA,
         description: 'Zigbee LED Controller WW/CW (pro)',
-        extend: gledoptoExtend.light_onoff_brightness_colortemp(),
+        extend: gledoptoExtend.light_onoff_brightness_colortemp({noConfigure: true}),
+        configure: async (device, coordinatorEndpoint, logger) => {
+            await extend.light_onoff_brightness_colortemp().configure(device, coordinatorEndpoint, logger);
+            await configureReadModelID(device);
+        },
     },
     {
         fingerprint: [
@@ -179,7 +189,11 @@ module.exports = [
         vendor: 'Gledopto',
         ota: ota.zigbeeOTA,
         description: 'Zigbee LED Controller RGBW (pro)',
-        extend: gledoptoExtend.light_onoff_brightness_colortemp_color(),
+        extend: gledoptoExtend.light_onoff_brightness_colortemp_color({noConfigure: true}),
+        configure: async (device, coordinatorEndpoint, logger) => {
+            await extend.light_onoff_brightness_colortemp_color().configure(device, coordinatorEndpoint, logger);
+            await configureReadModelID(device);
+        },
     },
     {
         fingerprint: [
@@ -237,7 +251,11 @@ module.exports = [
         vendor: 'Gledopto',
         ota: ota.zigbeeOTA,
         description: 'Zigbee LED Controller RGB (pro)',
-        extend: gledoptoExtend.light_onoff_brightness_color(),
+        extend: gledoptoExtend.light_onoff_brightness_color({noConfigure: true}),
+        configure: async (device, coordinatorEndpoint, logger) => {
+            await extend.light_onoff_brightness_color().configure(device, coordinatorEndpoint, logger);
+            await configureReadModelID(device);
+        },
     },
     {
         zigbeeModel: ['GL-C-008P'],
@@ -245,8 +263,12 @@ module.exports = [
         vendor: 'Gledopto',
         ota: ota.zigbeeOTA,
         description: 'Zigbee LED Controller RGB+CCT (pro)',
-        extend: gledoptoExtend.light_onoff_brightness_colortemp_color({colorTempRange: [158, 495]}),
+        extend: gledoptoExtend.light_onoff_brightness_colortemp_color({colorTempRange: [158, 495], noConfigure: true}),
         meta: {disableDefaultResponse: true},
+        configure: async (device, coordinatorEndpoint, logger) => {
+            await extend.light_onoff_brightness_colortemp_color().configure(device, coordinatorEndpoint, logger);
+            await configureReadModelID(device);
+        },
     },
     {
         zigbeeModel: ['GL-C-009'],
@@ -267,7 +289,11 @@ module.exports = [
         vendor: 'Gledopto',
         ota: ota.zigbeeOTA,
         description: 'Zigbee LED Controller W (pro)',
-        extend: gledoptoExtend.light_onoff_brightness(),
+        extend: gledoptoExtend.light_onoff_brightness({noConfigure: true}),
+        configure: async (device, coordinatorEndpoint, logger) => {
+            await extend.light_onoff_brightness().configure(device, coordinatorEndpoint, logger);
+            await configureReadModelID(device);
+        },
     },
     {
         zigbeeModel: ['GL-C-009S'],

package/devices/legrand.js

@@ -6,6 +6,7 @@ const extend = require('../lib/extend');
 const e = exposes.presets;
 const ea = exposes.access;
 const ota = require('../lib/ota');
+const utils = require('../lib/utils');
 
 const readInitialBatteryState = async (type, data, device) => {
     if (['deviceAnnounce'].includes(type)) {
@@ -20,7 +21,9 @@ const fzLocal = {
         cluster: 'genOnOff',
         type: 'commandOff',
         convert: (model, msg, publish, options, meta) => {
-            return {action: 'off'};
+            const payload = {action: utils.postfixWithEndpointName('off', msg, model)};
+            utils.addActionGroup(payload, msg, model);
+            return payload;
         },
     },
 };

package/devices/m/303/274ller_licht.js

@@ -29,7 +29,7 @@ module.exports = [
         description: 'Smart power strip',
         extend: extend.switch(),
         configure: async (device, coordinatorEndpoint, logger) => {
-            const endpoint = device.getEndpoint(11);
+            const endpoint = device.getEndpoint(11) || device.getEndpoint(1);
             await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff']);
             await reporting.onOff(endpoint);
         },
@@ -88,7 +88,16 @@ module.exports = [
         toZigbee: extend.light_onoff_brightness_colortemp_color().toZigbee.concat([tz.tint_scene]),
     },
     {
-        zigbeeModel: ['ZBT-Remote-ALL-RGBW'],
+        fingerprint: [{modelID: 'TS0505B', manufacturerName: '_TZ3210_mntza0sw'}],
+        model: '404062',
+        vendor: 'Müller Licht',
+        description: 'Kea RGB+CCT',
+        extend: extend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 500]}),
+        toZigbee: extend.light_onoff_brightness_colortemp_color().toZigbee.concat([tz.tint_scene]),
+    },
+    {
+        fingerprint: [{manufacturerName: '_TZ3000_bdbb0fon'}],
+        zigbeeModel: ['ZBT-Remote-ALL-RGBW', 'TS1001'],
         model: 'MLI-404011',
         description: 'Tint remote control',
         vendor: 'Müller Licht',

package/devices/orvibo.js

@@ -292,4 +292,182 @@ module.exports = [
         },
         exposes: [e.cover_position(), e.battery()],
     },
+    {
+        zigbeeModel: ['2ae011fb6d0542f58705d6861064eb5f'],
+        model: 'T40W1Z',
+        vendor: 'ORVIBO',
+        description: 'MixSwitch 1 gang',
+        extend: extend.switch(),
+        exposes: [e.switch()],
+
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff']);
+            await reporting.onOff(endpoint);
+        },
+    },
+    {
+        zigbeeModel: ['2e13af8e17434961be98f055d68c2166'],
+        model: 'T40W2Z',
+        vendor: 'ORVIBO',
+        description: 'MixSwitch 2 gangs',
+        extend: extend.switch(),
+        exposes: [e.switch().withEndpoint('left'), e.switch().withEndpoint('right')],
+        endpoint: (device) => {
+            return {'left': 1, 'right': 2};
+        },
+        meta: {multiEndpoint: true},
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint1 = device.getEndpoint(1);
+            await reporting.bind(endpoint1, coordinatorEndpoint, ['genOnOff']);
+            await reporting.onOff(endpoint1);
+            const endpoint2 = device.getEndpoint(2);
+            await reporting.bind(endpoint2, coordinatorEndpoint, ['genOnOff']);
+            await reporting.onOff(endpoint2);
+        },
+    },
+    {
+        zigbeeModel: ['e8d667cb184b4a2880dd886c23d00976'],
+        model: 'T40W3Z',
+        vendor: 'ORVIBO',
+        description: 'MixSwitch 3 gangs',
+        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};
+        },
+        meta: {multiEndpoint: true},
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint1 = device.getEndpoint(1);
+            await reporting.bind(endpoint1, coordinatorEndpoint, ['genOnOff']);
+            await reporting.onOff(endpoint1);
+            const endpoint2 = device.getEndpoint(2);
+            await reporting.bind(endpoint2, coordinatorEndpoint, ['genOnOff']);
+            await reporting.onOff(endpoint2);
+            const endpoint3 = device.getEndpoint(3);
+            await reporting.bind(endpoint3, coordinatorEndpoint, ['genOnOff']);
+            await reporting.onOff(endpoint3);
+        },
+    },
+    {
+        zigbeeModel: ['20513b10079f4cc68cffb8b0dc6d3277'],
+        model: 'T40W4Z',
+        vendor: 'ORVIBO',
+        description: 'MixSwitch 4 gangs',
+        extend: extend.switch(),
+        exposes: [e.switch().withEndpoint('l1'), e.switch().withEndpoint('l2'), e.switch().withEndpoint('l3'),
+            e.switch().withEndpoint('l4'), e.switch().withEndpoint('l5'), e.switch().withEndpoint('l6')],
+        endpoint: (device) => {
+            return {'l1': 1, 'l2': 2, 'l3': 3, 'l4': 4, 'l5': 5, 'l6': 6};
+        },
+        meta: {multiEndpoint: true},
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint1 = device.getEndpoint(1);
+            await reporting.bind(endpoint1, coordinatorEndpoint, ['genOnOff']);
+            await reporting.onOff(endpoint1);
+            const endpoint2 = device.getEndpoint(2);
+            await reporting.bind(endpoint2, coordinatorEndpoint, ['genOnOff']);
+            await reporting.onOff(endpoint2);
+            const endpoint3 = device.getEndpoint(3);
+            await reporting.bind(endpoint3, coordinatorEndpoint, ['genOnOff']);
+            await reporting.onOff(endpoint3);
+            const endpoint4 = device.getEndpoint(4);
+            await reporting.bind(endpoint4, coordinatorEndpoint, ['genOnOff']);
+            await reporting.onOff(endpoint4);
+            const endpoint5 = device.getEndpoint(5);
+            await reporting.bind(endpoint5, coordinatorEndpoint, ['genOnOff']);
+            await reporting.onOff(endpoint5);
+            const endpoint6 = device.getEndpoint(6);
+            await reporting.bind(endpoint6, coordinatorEndpoint, ['genOnOff']);
+            await reporting.onOff(endpoint6);
+        },
+    },
+    {
+        zigbeeModel: ['bcb949e87e8c4ea6bc2803052dd8fbf5'],
+        model: 'T40S6Z',
+        vendor: 'ORVIBO',
+        description: 'MixSwitch 6 gangs',
+        fromZigbee: [fz.orvibo_raw_2],
+        toZigbee: [],
+        exposes: [e.action(['button_1_click', 'button_2_click', 'button_3_click', 'button_4_click', 'button_5_click', 'button_6_click'])],
+    },
+    {
+        zigbeeModel: ['ba8120ad03f744ecb6a973672369e80d'],
+        model: 'T41W1Z',
+        vendor: 'ORVIBO',
+        description: 'MixSwitch 1 gang (without neutral wire)',
+        extend: extend.switch(),
+        exposes: [e.switch()],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff']);
+            await reporting.onOff(endpoint);
+        },
+    },
+    {
+        zigbeeModel: ['7c8f476a0f764cd4b994bc73d07c906d'],
+        model: 'T41W2Z',
+        vendor: 'ORVIBO',
+        description: 'MixSwitch 2 gang (without neutral wire)',
+        extend: extend.switch(),
+        exposes: [e.switch().withEndpoint('left'), e.switch().withEndpoint('right')],
+        endpoint: (device) => {
+            return {'left': 1, 'right': 2};
+        },
+        meta: {multiEndpoint: true},
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint1 = device.getEndpoint(1);
+            await reporting.bind(endpoint1, coordinatorEndpoint, ['genOnOff']);
+            await reporting.onOff(endpoint1);
+            const endpoint2 = device.getEndpoint(2);
+            await reporting.bind(endpoint2, coordinatorEndpoint, ['genOnOff']);
+            await reporting.onOff(endpoint2);
+        },
+    },
+    {
+        zigbeeModel: ['cb7ce9fe2cb147e69c5ea700b39b3d5b'],
+        model: 'DM10ZW',
+        vendor: 'ORVIBO',
+        description: '0-10v dimmer',
+        extend: extend.light_onoff_brightness_colortemp({colorTempRange: [153, 371]}),
+    },
+    {
+        zigbeeModel: ['1a20628504bf48c88ed698fe96b7867c'],
+        model: 'DTZ09039',
+        vendor: 'ORVIBO',
+        description: 'Downlight (Q series)',
+        extend: extend.light_onoff_brightness(),
+    },
+    {
+        zigbeeModel: ['bbfed49c738948b989911f9f9f73d759'],
+        model: 'R30W3Z',
+        vendor: 'ORVIBO',
+        description: 'In-wall switch 3 gang',
+        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};
+        },
+        meta: {multiEndpoint: true},
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint1 = device.getEndpoint(1);
+            await reporting.bind(endpoint1, coordinatorEndpoint, ['genOnOff']);
+            await reporting.onOff(endpoint1);
+            const endpoint2 = device.getEndpoint(2);
+            await reporting.bind(endpoint2, coordinatorEndpoint, ['genOnOff']);
+            await reporting.onOff(endpoint2);
+            const endpoint3 = device.getEndpoint(3);
+            await reporting.bind(endpoint3, coordinatorEndpoint, ['genOnOff']);
+            await reporting.onOff(endpoint3);
+        },
+    },
+    {
+        zigbeeModel: ['0e93fa9c36bb417a90ad5d8a184b683a'],
+        model: 'SM20',
+        vendor: 'ORVIBO',
+        description: 'Door or window contact switch',
+        fromZigbee: [fz.ias_contact_alarm_1, fz.battery],
+        toZigbee: [],
+        exposes: [e.contact(), e.battery_low(), e.tamper(), e.battery()],
+    },
 ];

package/devices/philips.js

@@ -1613,7 +1613,7 @@ module.exports = [
         ota: ota.zigbeeOTA,
     },
     {
-        zigbeeModel: ['4080248U9'],
+        zigbeeModel: ['4080248U9', '915005987201'],
         model: '4080248U9',
         vendor: 'Philips',
         description: 'Hue White and color ambiance Signe floor light',

package/devices/schwaiger.js

@@ -45,4 +45,11 @@ module.exports = [
         description: 'LED bulb GU10 350 lumen, dimmable, color, white 2700-6500K',
         extend: extend.light_onoff_brightness_colortemp({colorTempRange: [153, 370]}),
     },
+    {
+        zigbeeModel: ['ZBT-DIMLight-GU100800'],
+        model: 'HAL400',
+        vendor: 'Schwaiger',
+        description: 'LED Schwaiger HAL400 GU10 dimmable, warm white',
+        extend: extend.light_onoff_brightness(),
+    },
 ];

package/devices/sengled.js

@@ -60,13 +60,20 @@ module.exports = [
         model: 'E11-G13',
         vendor: 'Sengled',
         description: 'Element classic (A19)',
-        extend: extend.light_onoff_brightness({noConfigure: true}),
-        ota: ota.zigbeeOTA,
+        fromZigbee: extend.light_onoff_brightness().fromZigbee.concat([fz.metering]),
+        toZigbee: extend.light_onoff_brightness().toZigbee,
         configure: async (device, coordinatorEndpoint, logger) => {
             await extend.light_onoff_brightness().configure(device, coordinatorEndpoint, logger);
             device.powerSource = 'Mains (single phase)';
             device.save();
+
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'seMetering']);
+            await reporting.readMeteringMultiplierDivisor(endpoint);
+            await reporting.currentSummDelivered(endpoint);
+            await reporting.instantaneousDemand(endpoint);
         },
+        exposes: [e.power(), e.energy(), e.light_brightness()],
     },
     {
         zigbeeModel: ['E11-G23', 'E11-G33'],

package/devices/shinasystem.js

@@ -341,4 +341,25 @@ module.exports = [
             }]);
         },
     },
+    {
+        zigbeeModel: ['DLM-300Z'],
+        model: 'DLM-300Z',
+        vendor: 'ShinaSystem',
+        description: 'Sihas door lock',
+        fromZigbee: [fz.lock, fz.battery, fz.lock_operation_event, fz.lock_programming_event, fz.lock_pin_code_response],
+        toZigbee: [tz.lock, tz.pincode_lock],
+        meta: {pinCodeCount: 4},
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['closuresDoorLock', 'genPowerCfg']);
+            await reporting.lockState(endpoint, {min: 0, max: 3600, change: 0});
+            await reporting.batteryPercentageRemaining(endpoint, {min: 600, max: 21600, change: 1});
+            await reporting.doorState(endpoint);
+        },
+        exposes: [e.battery(), e.lock(), exposes.enum('door_state', ea.STATE, ['open', 'closed']).withDescription('Door status'),
+            exposes.composite('pin_code', 'pin_code')
+                .withFeature(exposes.numeric('user', ea.SET).withDescription('User ID can only number 1'))
+                .withFeature(exposes.numeric('pin_code', ea.SET).withDescription('Pincode to set, set pincode(4 digit) to null to clear')),
+        ],
+    },
 ];

package/devices/sinope.js

@@ -331,4 +331,36 @@ module.exports = [
         },
         exposes: [e.water_leak(), e.battery_low(), e.temperature(), e.battery()],
     },
+    {
+        zigbeeModel: ['VA4200WZ'],
+        model: 'VA4200WZ',
+        vendor: 'Sinopé',
+        description: 'Zigbee smart water valve (3/4")',
+        fromZigbee: [fz.cover_position_via_brightness, fz.cover_state_via_onoff, fz.battery],
+        toZigbee: [tz.cover_via_brightness],
+        configure: async (device, coordinatorEndpoint) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'genLevelCtrl', 'genPowerCfg']);
+            await reporting.batteryPercentageRemaining(endpoint);
+            await reporting.onOff(endpoint);
+            await reporting.brightness(endpoint); // valve position
+        },
+        exposes: [e.valve_switch(), e.valve_position(), e.battery_low(), e.battery()],
+    },
+    {
+        zigbeeModel: ['VA4201WZ'],
+        model: 'VA4201WZ',
+        vendor: 'Sinopé',
+        description: 'Zigbee smart water valve (1")',
+        fromZigbee: [fz.cover_position_via_brightness, fz.cover_state_via_onoff, fz.battery],
+        toZigbee: [tz.cover_via_brightness],
+        configure: async (device, coordinatorEndpoint) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'genLevelCtrl', 'genPowerCfg']);
+            await reporting.batteryPercentageRemaining(endpoint);
+            await reporting.onOff(endpoint);
+            await reporting.brightness(endpoint); // valve position
+        },
+        exposes: [e.valve_switch(), e.valve_position(), e.battery_low(), e.battery()],
+    },
 ];

package/devices/stelpro.js

@@ -103,6 +103,36 @@ module.exports = [
                 reportableChange: 1}]);
         },
     },
+    {
+        zigbeeModel: ['SORB'],
+        model: 'SORB',
+        vendor: 'Stelpro',
+        description: 'ORLÉANS fan heater',
+        fromZigbee: [fz.stelpro_thermostat, fz.hvac_user_interface],
+        toZigbee: [tz.thermostat_local_temperature, tz.thermostat_occupied_heating_setpoint,
+            tz.thermostat_temperature_display_mode, tz.thermostat_keypad_lockout, tz.thermostat_system_mode, tz.thermostat_running_state],
+        exposes: [e.local_temperature(), e.keypad_lockout(),
+            exposes.climate().withSetpoint('occupied_heating_setpoint', 5, 30, 0.5).withLocalTemperature()
+                .withSystemMode(['off', 'auto', 'heat']).withRunningState(['idle', 'heat'])],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(25);
+            const binds = ['genBasic', 'genIdentify', 'genGroups', 'hvacThermostat', 'hvacUserInterfaceCfg', 'msTemperatureMeasurement'];
+            await reporting.bind(endpoint, coordinatorEndpoint, binds);
+
+            // Those exact parameters (min/max/change) are required for reporting to work with Stelpro SORB
+            await reporting.thermostatTemperature(endpoint);
+            await reporting.thermostatOccupiedHeatingSetpoint(endpoint);
+            await reporting.thermostatSystemMode(endpoint);
+            await reporting.thermostatPIHeatingDemand(endpoint);
+            await reporting.thermostatKeypadLockMode(endpoint);
+            // cluster 0x0201 attribute 0x401c
+            await endpoint.configureReporting('hvacThermostat', [{
+                attribute: 'StelproSystemMode',
+                minimumReportInterval: constants.repInterval.MINUTE,
+                maximumReportInterval: constants.repInterval.HOUR,
+                reportableChange: 1}]);
+        },
+    },
     {
         zigbeeModel: ['SMT402AD'],
         model: 'SMT402AD',

package/devices/sunricher.js

@@ -103,7 +103,7 @@ module.exports = [
         },
     },
     {
-        zigbeeModel: ['ON/OFF', 'ZIGBEE-SWITCH'],
+        zigbeeModel: ['ON/OFF -M', 'ON/OFF', 'ZIGBEE-SWITCH'],
         model: 'ZG9101SAC-HP-Switch',
         vendor: 'Sunricher',
         description: 'Zigbee AC in wall switch',

package/devices/tplink.js

@@ -23,4 +23,20 @@ module.exports = [
             device.save();
         },
     },
+    {
+        zigbeeModel: ['CS100'],
+        model: 'CS100',
+        vendor: 'TP-Link',
+        description: 'Contact sensor',
+        fromZigbee: [fz.ias_contact_alarm_1, fz.battery],
+        toZigbee: [],
+        exposes: [e.contact(), e.battery_low(), e.battery()],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg']);
+            await reporting.batteryPercentageRemaining(endpoint);
+            device.powerSource = 'Battery';
+            device.save();
+        },
+    },
 ];

package/devices/tuya.js

@@ -12,7 +12,7 @@ const utils = require('../lib/utils');
 
 const TS011Fplugs = ['_TZ3000_5f43h46b', '_TZ3000_cphmq0q7', '_TZ3000_dpo1ysak', '_TZ3000_ew3ldmgx', '_TZ3000_gjnozsaz',
     '_TZ3000_jvzvulen', '_TZ3000_mraovvmm', '_TZ3000_nfnmi125', '_TZ3000_ps3dmato', '_TZ3000_w0qqde0g', '_TZ3000_u5u4cakc',
-    '_TZ3000_rdtixbnu', '_TZ3000_typdpbpg'];
+    '_TZ3000_rdtixbnu', '_TZ3000_typdpbpg', '_TZ3000_2xlvlnez'];
 
 const tzLocal = {
     TS0504B_color: {
@@ -109,7 +109,8 @@ module.exports = [
     },
     {
         fingerprint: [{modelID: 'TS0001', manufacturerName: '_TZ3000_hktqahrq'}, {manufacturerName: '_TZ3000_hktqahrq'},
-            {manufacturerName: '_TZ3000_q6a3tepg'}, {modelID: 'TS000F', manufacturerName: '_TZ3000_m9af2l6g'}],
+            {manufacturerName: '_TZ3000_q6a3tepg'}, {modelID: 'TS000F', manufacturerName: '_TZ3000_m9af2l6g'},
+            {modelID: 'TS0001', manufacturerName: '_TZ3000_npzfdcof'}],
         model: 'WHD02',
         vendor: 'TuYa',
         description: 'Wall switch module',
@@ -1119,7 +1120,9 @@ module.exports = [
                 acVoltageMultiplier: 1, acVoltageDivisor: 1, acCurrentMultiplier: 1, acCurrentDivisor: 1000, acPowerMultiplier: 1,
                 acPowerDivisor: 1,
             });
-            await reporting.currentSummDelivered(endpoint);
+            try {
+                await reporting.currentSummDelivered(endpoint);
+            } catch (error) {/* fails for some https://github.com/Koenkk/zigbee2mqtt/issues/11179 */}
         },
         options: [exposes.options.measurement_poll_interval()],
         // This device doesn't support reporting correctly.

package/devices/xiaomi.js

@@ -1174,8 +1174,8 @@ module.exports = [
             exposes.enum('mute_buzzer', ea.SET, ['Mute']).withDescription('Mute the buzzer for 10 minutes (buzzer cannot be ' +
                 'pre-muted, because this function only works when the alarm is triggered)'),
             exposes.binary('mute', ea.STATE_GET, true, false).withDescription('Buzzer muted'),
-            exposes.switch().withState('linkage_alarm', true, 'After being turned on, one of the devices triggers the ' +
-                'natural gas leakage alarm, and other devices with linkage turned on', ea.ALL, true, false),
+            exposes.binary('linkage_alarm', ea.ALL, true, false).withDescription('When this option is enabled and a gas leak ' +
+                'is detected, other detectors with this option enabled will also sound the alarm buzzer'),
             exposes.binary('state', ea.STATE_GET, 'preparation', 'work').withDescription('"Preparation" or "work" ' +
                 '(measurement of the gas concentration value and triggering of an alarm are only performed in the "work" state)'),
             exposes.numeric('power_outage_count', ea.STATE_GET).withDescription('Number of power outages (since last pairing)')],
@@ -1272,9 +1272,9 @@ module.exports = [
         vendor: 'Xiaomi',
         fromZigbee: [fz.xiaomi_curtain_acn002_position, fz.xiaomi_curtain_acn002_status, fz.cover_position_tilt, fz.ignore_basic_report,
             fz.aqara_opple],
-        toZigbee: [tz.xiaomi_curtain_position_state, tz.xiaomi_curtain_acn002_status],
+        toZigbee: [tz.xiaomi_curtain_position_state],
         exposes: [e.cover_position().setAccess('state', ea.ALL), e.battery(),
-            exposes.enum('motor_state', ea.STATE_GET, ['declining', 'rising', 'pause', 'blocked'])
+            exposes.enum('motor_state', ea.STATE, ['declining', 'rising', 'pause', 'blocked'])
                 .withDescription('The current state of the motor.'),
             exposes.binary('running', ea.STATE, true, false)
                 .withDescription('Whether the motor is moving or not.')],
@@ -1289,7 +1289,7 @@ module.exports = [
         model: 'LLKZMK11LM',
         vendor: 'Xiaomi',
         description: 'Aqara wireless relay controller',
-        fromZigbee: [fz.xiaomi_switch_basic, fz.xiaomi_power, fz.ignore_multistate_report, fz.on_off],
+        fromZigbee: [fz.xiaomi_switch_basic, fz.xiaomi_power, fz.ignore_multistate_report, fz.on_off, fz.aqara_opple],
         meta: {multiEndpoint: true},
         toZigbee: [tz.on_off, tz.LLKZMK11LM_interlock, tz.xiaomi_power],
         endpoint: (device) => {
@@ -1299,7 +1299,7 @@ module.exports = [
             e.switch().withEndpoint('l1'), e.switch().withEndpoint('l2'),
             exposes.binary('interlock', ea.STATE_SET, true, false)
                 .withDescription('Enabling prevents both relais being on at the same time')],
-        // TEMP DISABLED: https://github.com/Koenkk/zigbee2mqtt/issues/7112 ota: ota.zigbeeOTA,
+        ota: ota.zigbeeOTA,
     },
     {
         zigbeeModel: ['lumi.lock.acn02'],
@@ -1597,7 +1597,8 @@ module.exports = [
             e.battery(), e.battery_voltage(), e.action([
                 'single_left', 'single_right', 'single_both',
                 'double_left', 'double_right', 'double_both',
-                'triple_left', 'triple_right', 'triple_both']),
+                'triple_left', 'triple_right', 'triple_both',
+                'hold_left', 'hold_right', 'hold_both']),
             exposes.enum('click_mode', ea.ALL, ['fast', 'multi'])
                 .withDescription('Click mode, fast: only supports single click which will be send immediately after clicking.' +
                     'multi: supports more events like double and hold'),

package/devices/yale.js

@@ -124,4 +124,11 @@ module.exports = [
         description: 'Real living lock / Intelligent biometric digital lock',
         extend: lockExtend(),
     },
+    {
+        zigbeeModel: ['06ffff2027'],
+        model: 'YMF40A RL',
+        vendor: 'Yale',
+        description: 'Real living lock / Intelligent biometric digital lock',
+        extend: lockExtend({battery: {dontDividePercentage: true}}),
+    },
 ];

package/index.js

@@ -62,7 +62,7 @@ function addDefinition(definition) {
     const {extend, ...definitionWithoutExtend} = definition;
     if (extend) {
         if (extend.hasOwnProperty('configure') && definition.hasOwnProperty('configure')) {
-            console.log(`'${definition.model}' has configure in extend and device, this is not allowed`);
+            assert.fail(`'${definition.model}' has configure in extend and device, this is not allowed`);
         }
 
         definition = {
@@ -89,7 +89,8 @@ function addDefinition(definition) {
     const optionKeys = definition.options.map((o) => o.name);
     for (const converter of [...definition.toZigbee, ...definition.fromZigbee]) {
         if (converter.options) {
-            for (const option of converter.options) {
+            const options = typeof converter.options === 'function' ? converter.options(definition) : converter.options;
+            for (const option of options) {
                 if (!optionKeys.includes(option.name)) {
                     definition.options.push(option);
                     optionKeys.push(option.name);

package/lib/exposes.js

@@ -589,6 +589,8 @@ module.exports = {
         tamper: () => new Binary('tamper', access.STATE, true, false).withDescription('Indicates whether the device is tampered'),
         temperature: () => new Numeric('temperature', access.STATE).withUnit('°C').withDescription('Measured temperature value'),
         test: () => new Binary('test', access.STATE, true, false).withDescription('Indicates whether the device is being tested'),
+        valve_position: () => new Numeric('position', access.ALL).withValueMin(0).withValueMax(100).withDescription('Position of the valve'),
+        valve_switch: () => new Binary('state', access.ALL, 'OPEN', 'CLOSE').withDescription('Valve state if open or closed'),
         valve_state: () => new Binary('valve_state', access.STATE, 'OPEN', 'CLOSED').withDescription('Valve state if open or closed'),
         valve_detection: () => new Switch().withState('valve_detection', true).setAccess('state', access.STATE_SET),
         vibration: () => new Binary('vibration', access.STATE, true, false).withDescription('Indicates whether the device detected vibration'),

package/lib/extend.js

@@ -58,12 +58,14 @@ const extend = {
             tz.light_brightness_step, tz.level_config, tz.power_on_behavior, tz.light_hue_saturation_move,
             tz.light_hue_saturation_step, tz.light_color_options, tz.light_color_mode, ...(!options.disableEffect ? [tz.effect] : [])];
 
-        return {
-            exposes, fromZigbee, toZigbee,
-            configure: async (device, coordinatorEndpoint, logger) => {
+        const result = {exposes, fromZigbee, toZigbee};
+        if (!options.noConfigure) {
+            result.configure = async (device, coordinatorEndpoint, logger) => {
                 await light.configure(device, coordinatorEndpoint, logger, false);
-            },
-        };
+            };
+        }
+
+        return result;
     },
     light_onoff_brightness_colortemp_color: (options={}) => {
         options = {disableEffect: false, supportsHS: false, disableColorTempStartup: false, preferHS: false, ...options};

package/lib/reporting.js

@@ -71,6 +71,10 @@ module.exports = {
         const p = payload('lockState', 0, repInterval.HOUR, 0, overrides);
         await endpoint.configureReporting('closuresDoorLock', p);
     },
+    doorState: async (endpoint, overrides) => {
+        const p = payload('doorState', 0, repInterval.HOUR, 0, overrides);
+        await endpoint.configureReporting('closuresDoorLock', p);
+    },
     brightness: async (endpoint, overrides) => {
         const p = payload('currentLevel', 0, repInterval.HOUR, 1, overrides);
         await endpoint.configureReporting('genLevelCtrl', p);

package/npm-shrinkwrap.json

@@ -1,6 +1,6 @@
 {
   "name": "zigbee-herdsman-converters",
-  "version": "14.0.406",
+  "version": "14.0.410",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {

package/package.json

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