zigbee-herdsman-converters 14.0.608 → 14.0.611

package/converters/toZigbee.js

@@ -4633,22 +4633,22 @@ const converters = {
             }
         },
     },
-    legrand_settingAlwaysEnableLed: {
+    legrand_settingEnableLedInDark: {
         // connected power outlet is on attribute 2 and not 1
-        key: ['led_when_off'],
+        key: ['led_in_dark'],
         convertSet: async (entity, key, value, meta) => {
             // enable or disable the LED (blue) when permitJoin=false (LED off)
             const enableLedIfOn = value === 'ON' || (value === 'OFF' ? false : !!value);
             const payload = {1: {value: enableLedIfOn, type: 16}};
             await entity.write('manuSpecificLegrandDevices', payload, manufacturerOptions.legrand);
-            return {state: {'led_when_off': value}};
+            return {state: {'led_in_dark': value}};
         },
         convertGet: async (entity, key, meta) => {
             await entity.read('manuSpecificLegrandDevices', [0x0001], manufacturerOptions.legrand);
         },
     },
     legrand_settingEnableLedIfOn: {
-        key: ['led_when_on'],
+        key: ['led_if_on'],
         convertSet: async (entity, key, value, meta) => {
             // enable the LED when the light object is "doing something"
             // on the light switch, the LED is on when the light is on,
@@ -4656,7 +4656,7 @@ const converters = {
             const enableLedIfOn = value === 'ON' || (value === 'OFF' ? false : !!value);
             const payload = {2: {value: enableLedIfOn, type: 16}};
             await entity.write('manuSpecificLegrandDevices', payload, manufacturerOptions.legrand);
-            return {state: {'led_when_on': value}};
+            return {state: {'led_if_on': value}};
         },
         convertGet: async (entity, key, meta) => {
             await entity.read('manuSpecificLegrandDevices', [0x0002], manufacturerOptions.legrand);

package/devices/bticino.js

@@ -13,11 +13,12 @@ module.exports = [
         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_settingAlwaysEnableLed, tz.legrand_settingEnableLedIfOn, tz.legrand_identify],
+        toZigbee: [tz.on_off, tz.legrand_settingEnableLedInDark, tz.legrand_settingEnableLedIfOn, tz.legrand_identify],
         exposes: [
             e.switch(), e.action(['identify', 'on', 'off']),
-            exposes.binary('led_when_off', ea.ALL, 'ON', 'OFF').withDescription('Enables the LED when the light is off'),
-            exposes.binary('led_when_on', ea.ALL, 'ON', 'OFF').withDescription('Enables the LED when the light is on'),
+            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'),
         ],
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
@@ -31,7 +32,7 @@ module.exports = [
         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_settingAlwaysEnableLed, tz.legrand_settingEnableLedIfOn,
+        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)
@@ -39,8 +40,9 @@ module.exports = [
             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_when_off', ea.ALL, 'ON', 'OFF').withDescription('Enables the LED when the light is off'),
-            exposes.binary('led_when_on', ea.ALL, 'ON', 'OFF').withDescription('Enables the LED when the light is on')],
+            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')],
         configure: async (device, coordinatorEndpoint, logger) => {
             await extend.light_onoff_brightness().configure(device, coordinatorEndpoint, logger);
             const endpoint = device.getEndpoint(1);
@@ -62,7 +64,7 @@ module.exports = [
         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_settingAlwaysEnableLed],
+            tz.legrand_settingEnableLedInDark],
         exposes: [e.cover_position()],
         meta: {coverInverted: true},
         configure: async (device, coordinatorEndpoint, logger) => {
@@ -95,7 +97,7 @@ module.exports = [
         vendor: 'BTicino',
         description: 'Power socket with power consumption monitoring',
         fromZigbee: [fz.identify, fz.on_off, fz.electrical_measurement],
-        toZigbee: [tz.on_off, tz.legrand_settingAlwaysEnableLed, tz.legrand_identify],
+        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);

package/devices/ledvance.js

@@ -167,4 +167,12 @@ module.exports = [
         extend: extend.ledvance.light_onoff_brightness_colortemp_color({colorTempRange: [153, 370]}),
         ota: ota.ledvance,
     },
+    {
+        zigbeeModel: ['CLA 60 DIM'],
+        model: '4058075728981',
+        vendor: 'LEDVANCE',
+        description: 'SMART+ Classic A E27 dimmable white',
+        extend: extend.ledvance.light_onoff_brightness(),
+        ota: ota.ledvance,
+    },
 ];

package/devices/legrand.js

@@ -106,7 +106,7 @@ module.exports = [
             fz.identify, fz.ignore_basic_report,
             // support binary report on moving state (supposed)
             fz.legrand_binary_input_moving, fz.cover_position_tilt],
-        toZigbee: [tz.cover_state, tz.cover_position_tilt, tz.legrand_identify, tz.legrand_settingAlwaysEnableLed],
+        toZigbee: [tz.cover_state, tz.cover_position_tilt, tz.legrand_identify, tz.legrand_settingEnableLedInDark],
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
             await reporting.bind(endpoint, coordinatorEndpoint, ['genBinaryInput', 'closuresWindowCovering', 'genIdentify']);
@@ -175,7 +175,7 @@ module.exports = [
         description: 'Wired switch without 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_settingAlwaysEnableLed, tz.legrand_settingEnableLedIfOn,
+        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)
@@ -183,8 +183,9 @@ module.exports = [
             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_when_off', ea.ALL, 'ON', 'OFF').withDescription('Enable the LED when the light is off'),
-            exposes.binary('led_when_on', ea.ALL, 'ON', 'OFF').withDescription('Enables the LED when the light is on')],
+            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')],
         configure: async (device, coordinatorEndpoint, logger) => {
             await extend.light_onoff_brightness().configure(device, coordinatorEndpoint, logger);
             const endpoint = device.getEndpoint(1);
@@ -201,8 +202,9 @@ module.exports = [
         ota: ota.zigbeeOTA,
         description: 'Power socket with power consumption monitoring',
         fromZigbee: [fz.identify, fz.on_off, fz.electrical_measurement],
-        toZigbee: [tz.on_off, tz.legrand_settingAlwaysEnableLed, tz.legrand_identify],
-        exposes: [e.switch(), e.action(['identify']), e.power()],
+        toZigbee: [tz.on_off, tz.legrand_settingEnableLedInDark, tz.legrand_identify, tz.legrand_settingEnableLedIfOn],
+        exposes: [e.switch(), e.action(['identify']), e.power(),
+            exposes.binary('led_if_on', ea.ALL, 'ON', 'OFF').withDescription('Enables the LED when the device is turned on')],
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
             await reporting.bind(endpoint, coordinatorEndpoint, ['genIdentify', 'genOnOff', 'haElectricalMeasurement']);
@@ -256,7 +258,7 @@ module.exports = [
         vendor: 'Legrand',
         description: 'DIN power consumption module',
         fromZigbee: [fz.identify, fz.metering, fz.electrical_measurement, fz.ignore_basic_report, fz.ignore_genOta, fz.legrand_power_alarm],
-        toZigbee: [tz.legrand_settingAlwaysEnableLed, tz.legrand_identify, tz.electrical_measurement_power, tz.legrand_powerAlarm],
+        toZigbee: [tz.legrand_settingEnableLedInDark, tz.legrand_identify, tz.electrical_measurement_power, tz.legrand_powerAlarm],
         exposes: [e.power().withAccess(ea.STATE_GET), exposes.binary('power_alarm_active', ea.STATE, true, false),
             exposes.binary('power_alarm', ea.ALL, true, false).withDescription('Enable/disable the power alarm')],
         configure: async (device, coordinatorEndpoint, logger) => {
@@ -344,11 +346,12 @@ module.exports = [
         vendor: 'Legrand',
         description: 'Double wired switch with neutral',
         fromZigbee: [fz.on_off, fz.legrand_binary_input_on_off, fz.legrand_cluster_fc01],
-        toZigbee: [tz.on_off, tz.legrand_settingAlwaysEnableLed, tz.legrand_settingEnableLedIfOn],
+        toZigbee: [tz.on_off, tz.legrand_settingEnableLedInDark, tz.legrand_settingEnableLedIfOn],
         exposes: [e.switch().withEndpoint('left'),
             e.switch().withEndpoint('right'),
-            exposes.binary('led_when_off', ea.ALL, 'ON', 'OFF').withDescription('Enable the LED when the light is off'),
-            exposes.binary('led_when_on', ea.ALL, 'ON', 'OFF').withDescription('Enables the LED when the light is on')],
+            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')],
         meta: {multiEndpoint: true},
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpointLeft = device.getEndpoint(2);
@@ -368,7 +371,7 @@ module.exports = [
         ota: ota.zigbeeOTA,
         description: 'Outlet with power consumption monitoring',
         fromZigbee: [fz.identify, fz.on_off, fz.electrical_measurement],
-        toZigbee: [tz.on_off, tz.legrand_settingAlwaysEnableLed, tz.legrand_identify],
+        toZigbee: [tz.on_off, tz.legrand_settingEnableLedInDark, tz.legrand_identify],
         exposes: [e.switch(), e.action(['identify']), e.power()],
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);

package/devices/lidl.js

@@ -378,6 +378,28 @@ module.exports = [
             await reporting.onOff(endpoint);
         },
     },
+    {
+        fingerprint: [{modelID: 'TS011F', manufacturerName: '_TZ3000_ynmowqk2'}],
+        model: 'HG08673-FR',
+        vendor: 'Lidl',
+        description: 'Silvercrest smart plug FR with power monitoring',
+        fromZigbee: [fz.on_off, 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],
+        exposes: [e.switch(), e.power(), e.current(), e.voltage().withAccess(ea.STATE),
+            e.energy(), exposes.enum('power_outage_memory', ea.ALL, ['on', 'off', 'restore'])
+                .withDescription('Recover state after power outage')],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'haElectricalMeasurement']);
+            endpoint.saveClusterAttributeKeyValue('seMetering', {divisor: 100, multiplier: 1});
+            endpoint.saveClusterAttributeKeyValue('haElectricalMeasurement', {
+                acVoltageMultiplier: 1, acVoltageDivisor: 1, acCurrentMultiplier: 1, acCurrentDivisor: 1000, acPowerMultiplier: 1,
+                acPowerDivisor: 1,
+            });
+        },
+        options: [exposes.options.measurement_poll_interval()],
+        onEvent: tuya.onEventMeasurementPoll,
+    },
     {
         fingerprint: [{modelID: 'TS004F', manufacturerName: '_TZ3000_rco1yzb1'}],
         model: 'HG08164',

package/devices/mecrator.js

@@ -62,4 +62,21 @@ module.exports = [
             device.save();
         },
     },
+    {
+        fingerprint: [{modelID: 'TS0501', manufacturerName: '_TZ3210_lzqq3u4r'},
+            {modelID: 'TS0501', manufacturerName: '_TZ3210_4whigl8i'}],
+        model: 'SSWF01G',
+        description: 'AC fan controller',
+        vendor: 'Mercator',
+        fromZigbee: [fz.on_off, fz.fan],
+        toZigbee: [tz.fan_mode, tz.on_off],
+        exposes: [e.switch(), e.fan().withModes(['off', 'low', 'medium', 'high', 'on'])],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genBasic', 'genOta', 'genTime', 'genGroups', 'genScenes']);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'genIdentify', 'manuSpecificTuya', 'hvacFanCtrl']);
+            await reporting.onOff(endpoint);
+            await reporting.fanMode(endpoint);
+        },
+    },
 ];

package/devices/moes.js

@@ -273,9 +273,14 @@ module.exports = [
         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],
+            e.switch().withEndpoint('l4').setAccess('state', ea.STATE_SET),
+            exposes.enum('indicate_light', ea.STATE_SET, Object.values(tuya.moesSwitch.indicateLight))
+                .withDescription('Indicator light status'),
+            exposes.enum('power_on_behavior', ea.STATE_SET, Object.values(tuya.moesSwitch.powerOnBehavior))
+                .withDescription('Controls the behavior when the device is powered on')],
+        fromZigbee: [fz.ignore_basic_report, fz.tuya_switch, fz.moes_switch],
+        toZigbee: [tz.tuya_switch_state, tz.moes_switch],
+        onEvent: tuya.onEventSetLocalTime,
         meta: {multiEndpoint: true},
         endpoint: (device) => {
             // Endpoint selection is made in tuya_switch_state
@@ -428,7 +433,10 @@ module.exports = [
             exposes.enum('calibration', ea.STATE_SET, ['OFF', 'ON']), exposes.enum('motor_reversal', ea.STATE_SET, ['OFF', 'ON'])],
     },
     {
-        fingerprint: [{modelID: 'TS1201', manufacturerName: '_TZ3290_j37rooaxrcdcqo5n'}],
+        fingerprint: [
+            {modelID: 'TS1201', manufacturerName: '_TZ3290_j37rooaxrcdcqo5n'},
+            {modelID: 'TS1201', manufacturerName: '_TZ3290_ot6ewjvmejq5ekhl'},
+        ],
         model: 'UFO-R11',
         vendor: 'Moes',
         description: 'Universal smart IR remote control',

package/devices/niko.js

@@ -61,9 +61,8 @@ const local = {
                 if (!operationModeLookup.hasOwnProperty(value)) {
                     throw new Error(`operation_mode was called with an invalid value (${value})`);
                 } else {
-                    const operationModeProperty = `operation_mode${meta.endpoint_name ? `_${meta.endpoint_name}` : ''}`;
                     await entity.write('manuSpecificNiko1', {'switchOperationMode': operationModeLookup[value]});
-                    return {state: {[operationModeProperty]: value.toLowerCase()}};
+                    return {state: {operation_mode: value.toLowerCase()}};
                 }
             },
             convertGet: async (entity, key, meta) => {

package/devices/onesti.js

@@ -8,7 +8,7 @@ const constants = require('../lib/constants');
 
 module.exports = [
     {
-        zigbeeModel: ['easyCodeTouch_v1', 'EasyCodeTouch'],
+        zigbeeModel: ['easyCodeTouch_v1', 'EasyCodeTouch', 'EasyFingerTouch'],
         model: 'easyCodeTouch_v1',
         vendor: 'Onesti Products AS',
         description: 'Zigbee module for EasyAccess code touch series',
@@ -21,6 +21,8 @@ module.exports = [
             await reporting.lockState(endpoint);
             await reporting.batteryPercentageRemaining(endpoint);
             await endpoint.read('closuresDoorLock', ['lockState', 'soundVolume']);
+            device.powerSource = 'Battery';
+            device.save();
         },
         exposes: [e.lock(), e.battery(), e.sound_volume(),
             e.lock_action_source_name(), e.lock_action_user(),

package/devices/perenio.js

@@ -59,15 +59,30 @@ const fzPerenio = {
         type: ['attributeReport', 'readResponse'],
         convert: (model, msg, publish, options, meta) => {
             const result = {};
+            if (msg.data.hasOwnProperty(2)) {
+                result['rms_current'] = msg.data[2];
+            }
             if (msg.data.hasOwnProperty(3)) {
                 result['rms_voltage'] = msg.data[3];
             }
+            if (msg.data.hasOwnProperty(4)) {
+                result['voltage_min'] = msg.data[4];
+            }
+            if (msg.data.hasOwnProperty(5)) {
+                result['voltage_max'] = msg.data[5];
+            }
             if (msg.data.hasOwnProperty(10)) {
                 result['active_power'] = msg.data[10];
             }
+            if (msg.data.hasOwnProperty(11)) {
+                result['power_max'] = msg.data[11];
+            }
             if (msg.data.hasOwnProperty(14)) {
                 result['consumed_energy'] = msg.data[14];
             }
+            if (msg.data.hasOwnProperty(15)) {
+                result['consumed_energy_limit'] = msg.data[15];
+            }
             if (msg.data.hasOwnProperty(24)) {
                 result['rssi'] = msg.data[24];
             }
@@ -84,6 +99,7 @@ const fzPerenio = {
                     result['alarm_voltage_min'] = false;
                     result['alarm_voltage_max'] = false;
                     result['alarm_power_max'] = false;
+                    result['alarm_consumed_energy'] = false;
                 } else {
                     if (msg.data[1] & 1) {
                         result['alarm_voltage_min'] = true;
@@ -94,6 +110,9 @@ const fzPerenio = {
                     if (msg.data[1] & 4) {
                         result['alarm_power_max'] = true;
                     }
+                    if (msg.data[1] & 8) {
+                        result['alarm_consumed_energy'] = true;
+                    }
                 }
             }
             return result;
@@ -135,15 +154,51 @@ const tzPerenio = {
         },
     },
     alarms_reset: {
-        key: ['alarm_voltage_min', 'alarm_voltage_max', 'alarm_power_max'],
+        key: ['alarm_voltage_min', 'alarm_voltage_max', 'alarm_power_max', 'alarm_consumed_energy'],
         convertSet: async (entity, key, val, meta) => {
             await entity.write(64635, {1: {value: 0, type: 0x20}}, {manufacturerCode: 0x007B});
-            return {state: {alarm_voltage_min: false, alarm_voltage_max: false, alarm_power_max: false}};
+            return {state: {alarm_voltage_min: false, alarm_voltage_max: false, alarm_power_max: false, alarm_consumed_energy: false}};
         },
         convertGet: async (entity, key, meta) => {
             await entity.read(64635, [1]);
         },
     },
+    alarms_limits: {
+        key: ['voltage_min', 'voltage_max', 'power_max', 'consumed_energy_limit'],
+        convertSet: async (entity, key, val, meta) => {
+            switch (key) {
+            case 'voltage_min':
+                await entity.write(64635, {4: {value: val, type: 0x21}}, {manufacturerCode: 0x007B});
+                break;
+            case 'voltage_max':
+                await entity.write(64635, {5: {value: val, type: 0x21}}, {manufacturerCode: 0x007B});
+                break;
+            case 'power_max':
+                await entity.write(64635, {11: {value: val, type: 0x21}}, {manufacturerCode: 0x007B});
+                break;
+            case 'consumed_energy_limit':
+                await entity.write(64635, {15: {value: val, type: 0x21}}, {manufacturerCode: 0x007B});
+                break;
+            }
+            return {state: {[key]: val}};
+        },
+        convertGet: async (entity, key, meta) => {
+            switch (key) {
+            case 'voltage_min':
+                await entity.read(64635, [4]);
+                break;
+            case 'voltage_max':
+                await entity.read(64635, [5]);
+                break;
+            case 'power_max':
+                await entity.read(64635, [11]);
+                break;
+            case 'consumed_energy_limit':
+                await entity.read(64635, [15]);
+                break;
+            }
+        },
+    },
     on_off_mod: {
         key: ['state', 'on_time', 'off_wait_time'],
         convertSet: async (entity, key, value, meta) => {
@@ -291,8 +346,8 @@ module.exports = [
         model: 'PEHPL0X',
         vendor: 'Perenio',
         description: 'Power link',
-        fromZigbee: [fz.on_off, fzPerenio.smart_plug],
-        toZigbee: [tzPerenio.on_off_mod, tzPerenio.default_state, tzPerenio.alarms_reset],
+        fromZigbee: [fz.on_off, fzPerenio.smart_plug, fz.metering],
+        toZigbee: [tzPerenio.on_off_mod, tzPerenio.default_state, tzPerenio.alarms_reset, tzPerenio.alarms_limits],
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
             await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 64635]);
@@ -303,7 +358,26 @@ module.exports = [
                 reportableChange: 0,
             }];
             await endpoint.configureReporting('genOnOff', payload);
-            await endpoint.read(64635, [0, 1]);
+            await endpoint.configureReporting(64635, [{
+                attribute: {ID: 0x000a, type: 0x21},
+                minimumReportInterval: 5,
+                maximumReportInterval: 60,
+                reportableChange: 0,
+            }]);
+            await endpoint.configureReporting(64635, [{
+                attribute: {ID: 0x000e, type: 0x23},
+                minimumReportInterval: 5,
+                maximumReportInterval: 60,
+                reportableChange: 0,
+            }]);
+            await endpoint.configureReporting(64635, [{
+                attribute: {ID: 0x0003, type: 0x21},
+                minimumReportInterval: 5,
+                maximumReportInterval: 5,
+                reportableChange: 0,
+            }]);
+            await endpoint.read(64635, [0, 1, 2, 3]);
+            await endpoint.read(64635, [4, 5, 11, 15]);
         },
         exposes: [
             e.switch(),
@@ -317,6 +391,17 @@ module.exports = [
                 .withDescription('Indicates if the alarm is triggered on the voltage rise above the limit, allows to reset alarms'),
             exposes.binary('alarm_power_max', ea.ALL, true, false)
                 .withDescription('Indicates if the alarm is triggered on the active power rise above the limit, allows to reset alarms'),
+            exposes.binary('alarm_consumed_energy', ea.ALL, true, false)
+                .withDescription(
+                    'Indicates if the alarm is triggered when the consumption energy limit is reached, allows to reset alarms'),
+            exposes.numeric('voltage_min', ea.ALL).withValueMin(0).withValueMax(253)
+                .withDescription('Minimum allowable voltage limit for alarms.'),
+            exposes.numeric('voltage_max', ea.ALL).withValueMin(0).withValueMax(253)
+                .withDescription('Maximum allowable voltage limit for alarms.'),
+            exposes.numeric('power_max', ea.ALL).withValueMin(0).withValueMax(65534)
+                .withDescription('Maximum allowable power limit for alarms.'),
+            exposes.numeric('consumed_energy_limit', ea.ALL).withValueMin(0).withValueMax(65534)
+                .withDescription('Limit of electric energy consumption in kW*h. 0 value represents no limit'),
             exposes.numeric('rssi', ea.STATE).withUnit('dB')
                 .withDescription('RSSI seen by the device').withValueMin(-128).withValueMax(127),
         ],

package/devices/qoto.js

@@ -0,0 +1,113 @@
+const fz = require('../converters/fromZigbee');
+const exposes = require('../lib/exposes');
+const tuya = require('../lib/tuya');
+const e = exposes.presets;
+const ea = exposes.access;
+
+const dataPoints = {
+    valve_state_auto_shutdown: 2,
+    water_flow: 3,
+    shutdown_timer: 11,
+    remaining_watering_time: 101,
+    valve_state: 102,
+    last_watering_duration: 107,
+    battery: 110,
+};
+
+const fzLocal = {
+    watering_timer: {
+        cluster: 'manuSpecificTuya',
+        type: ['commandDataReport'],
+        convert: (model, msg, publish, options, meta) => {
+            const result = {};
+            for (const dpValue of msg.data.dpValues) {
+                const dp = dpValue.dp; // First we get the data point ID
+                const value = tuya.getDataValue(dpValue); // This function will take care of converting the data to proper JS type
+                switch (dp) {
+                case dataPoints.water_flow: {
+                    result.water_flow = value;
+                    break;
+                }
+                case dataPoints.remaining_watering_time: {
+                    result.remaining_watering_time = value;
+                    break;
+                }
+                case dataPoints.last_watering_duration: {
+                    result.last_watering_duration = value;
+                    break;
+                }
+
+                case dataPoints.valve_state: {
+                    result.valve_state = value;
+                    break;
+                }
+
+                case dataPoints.shutdown_timer: {
+                    result.shutdown_timer = value;
+                    break;
+                }
+                case dataPoints.valve_state_auto_shutdown: {
+                    result.valve_state_auto_shutdown = value;
+                    result.valve_state = value;
+                    break;
+                }
+
+                case dataPoints.battery: {
+                    result.battery = value;
+                    break;
+                }
+                default: {
+                    meta.logger.debug(`>>> UNKNOWN DP #${dp} with data "${JSON.stringify(dpValue)}"`);
+                }
+                }
+            }
+            return result;
+        },
+    },
+};
+
+const tzLocal = {
+    valve_state: {
+        key: ['valve_state'],
+        convertSet: async (entity, key, value, meta) => {
+            await tuya.sendDataPointValue(entity, dataPoints.valve_state, value);
+        },
+    },
+    shutdown_timer: {
+        key: ['shutdown_timer'],
+        convertSet: async (entity, key, value, meta) => {
+            await tuya.sendDataPointValue(entity, dataPoints.shutdown_timer, value);
+        },
+    },
+    valve_state_auto_shutdown: {
+        key: ['valve_state_auto_shutdown'],
+        convertSet: async (entity, key, value, meta) => {
+            await tuya.sendDataPointValue(entity, dataPoints.valve_state_auto_shutdown, value);
+        },
+    },
+};
+
+module.exports = [
+    {
+        fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_arge1ptm'}],
+        model: 'QT-05M',
+        vendor: 'QOTO',
+        description: 'Solar powered garden watering timer',
+        fromZigbee: [fz.ignore_basic_report, fz.ignore_tuya_set_time, fz.ignore_onoff_report, fzLocal.watering_timer],
+        toZigbee: [tzLocal.valve_state, tzLocal.shutdown_timer, tzLocal.valve_state_auto_shutdown],
+        exposes: [
+            exposes.numeric('water_flow', ea.STATE).withUnit('%').withValueMin(0).withDescription('Current water flow in %.'),
+            exposes.numeric('last_watering_duration', ea.STATE).withUnit('sec').withValueMin(0)
+                .withDescription('Last watering duration in seconds.'),
+            exposes.numeric('remaining_watering_time', ea.STATE).withUnit('sec').withValueMin(0)
+                .withDescription('Remaning watering time (for auto shutdown). Updates every minute, and every 10s in the last minute.'),
+            exposes.numeric('valve_state', ea.STATE_SET).withValueMin(0).withValueMax(100).withValueStep(5).withUnit('%')
+                .withDescription('Set valve to %.'),
+            exposes.numeric('shutdown_timer', ea.STATE_SET).withValueMin(0).withValueMax(14400).withUnit('sec')
+                .withDescription('Auto shutdown in seconds.'),
+            exposes.numeric('valve_state_auto_shutdown', ea.STATE_SET).withValueMin(0).withValueMax(100).withValueStep(5).withUnit('%')
+                .withDescription('Set valve to % with auto shutdown.'),
+            e.battery(),
+        ],
+    },
+];

package/devices/sylvania.js

@@ -41,7 +41,7 @@ module.exports = [
         },
     },
     {
-        zigbeeModel: ['LIGHTIFY RT Tunable White'],
+        zigbeeModel: ['LIGHTIFY RT Tunable White', 'RT TW'],
         model: '73742',
         vendor: 'Sylvania',
         description: 'LIGHTIFY LED adjustable white RT 5/6',

package/devices/tuya.js

@@ -20,7 +20,7 @@ const TS011Fplugs = ['_TZ3000_5f43h46b', '_TZ3000_cphmq0q7', '_TZ3000_dpo1ysak',
     '_TZ3000_rdtixbnu', '_TZ3000_typdpbpg', '_TZ3000_kx0pris5', '_TZ3000_amdymr7l', '_TZ3000_z1pnpsdo', '_TZ3000_ksw8qtmt',
     '_TZ3000_1h2x4akh', '_TZ3000_9vo5icau', '_TZ3000_cehuw1lw', '_TZ3000_ko6v90pg', '_TZ3000_f1bapcit', '_TZ3000_cjrngdr3',
     '_TZ3000_zloso4jk', '_TZ3000_r6buo8ba', '_TZ3000_iksasdbv', '_TZ3000_idrffznf', '_TZ3000_okaz9tjs', '_TZ3210_q7oryllx',
-    '_TZ3000_ss98ec5d', '_TZ3000_gznh2xla'];
+    '_TZ3000_ss98ec5d', '_TZ3000_gznh2xla', '_TZ3000_hdopuwv6', '_TZ3000_gvn91tmx'];
 
 const tzLocal = {
     hpsz: {
@@ -801,6 +801,7 @@ module.exports = [
             {modelID: 'TS0505B', manufacturerName: '_TZ3210_remypqqm'},
             {modelID: 'TS0505B', manufacturerName: '_TZ3000_kohbva1f'},
             {modelID: 'TS0505B', manufacturerName: '_TZ3000_luit1t00'},
+            {modelID: 'TS0505B', manufacturerName: '_TZ3210_r5afgmkl'},
             {modelID: 'TS0505B', manufacturerName: '_TZ3210_wslkvrau'},
             {modelID: 'TS0505B', manufacturerName: '_TZ3210_0rn9qhnu'},
             {modelID: 'TS0505B', manufacturerName: '_TZ3210_ejctepku'},
@@ -818,6 +819,7 @@ module.exports = [
             {modelID: 'TS0505B', manufacturerName: '_TZ3210_mzdax7ha'},
             {modelID: 'TS0505B', manufacturerName: '_TZB210_tmi0rihb'},
             {modelID: 'TS0505B', manufacturerName: '_TZ3210_a4s41wm4'},
+            {modelID: 'TS0505B', manufacturerName: '_TZ3210_ijczzg9h'},
             {modelID: 'TS0505B', manufacturerName: '_TZ3210_qxenlrin'},
             {modelID: 'TS0505B', manufacturerName: '_TZ3210_iwbaamgh'},
             {modelID: 'TS0505B', manufacturerName: '_TZ3210_klv2wul0'},
@@ -826,6 +828,7 @@ module.exports = [
             {modelID: 'TS0505B', manufacturerName: '_TZ3210_cuqkfz2q'},
             {modelID: 'TS0505B', manufacturerName: '_TZ3210_6amjviba'},
             {modelID: 'TS0505B', manufacturerName: '_TZ3000_xr5m6kfg'},
+            {modelID: 'TS0505B', manufacturerName: '_TZ3210_xr5m6kfg'},
             {modelID: 'TS0505B', manufacturerName: '_TZ3210_bf175wi4'}],
         model: 'TS0505B',
         vendor: 'TuYa',
@@ -887,7 +890,8 @@ module.exports = [
             {modelID: 'TS0501B', manufacturerName: '_TZ3210_wuheofsg'},
             {modelID: 'TS0501B', manufacturerName: '_TZ3210_e5t9bfdv'},
             {modelID: 'TS0501B', manufacturerName: '_TZ3210_19qb27da'},
-            {modelID: 'TS0501B', manufacturerName: '_TZ3210_4zinq6io'}],
+            {modelID: 'TS0501B', manufacturerName: '_TZ3210_4zinq6io'},
+            {modelID: 'TS0501B', manufacturerName: '_TZ3210_93gnbdgz'}],
         model: 'TS0501B',
         description: 'Zigbee light',
         vendor: 'TuYa',
@@ -1465,7 +1469,7 @@ module.exports = [
         },
     },
     {
-        fingerprint: [{modelID: 'TS004F', manufacturerName: '_TZ3000_xabckq1v'}],
+        fingerprint: [{modelID: 'TS004F', manufacturerName: '_TZ3000_xabckq1v'}, {modelID: 'TS004F', manufacturerName: '_TZ3000_czuyt8lz'}],
         model: 'TS004F',
         vendor: 'TuYa',
         description: 'Wireless switch with 4 buttons',

package/devices/woox.js

@@ -34,6 +34,7 @@ const fzLocal = {
                 case 14: {
                     const batteryLevels = {0: 'low', 1: 'middle', 2: 'high'};
                     result.battery_level = batteryLevels[value];
+                    result.battery_low = value === 0;
                     break;
                 }
                 case 16:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zigbee-herdsman-converters",
-  "version": "14.0.608",
+  "version": "14.0.611",
   "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.48"
+    "zigbee-herdsman": "^0.14.53"
   },
   "devDependencies": {
     "eslint": "*",