zigbee-herdsman-converters 15.0.97 → 15.0.99

package/devices/develco.js

@@ -292,7 +292,7 @@ module.exports = [
         description: 'Power plug',
         fromZigbee: [fz.on_off, develco.fz.electrical_measurement, develco.fz.metering],
         toZigbee: [tz.on_off],
-        exposes: [e.switch(), e.power(), e.current(), e.voltage(), e.energy()],
+        exposes: [e.switch(), e.power(), e.current(), e.voltage(), e.energy(), e.ac_frequency()],
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(2);
             await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'haElectricalMeasurement', 'seMetering']);
@@ -303,6 +303,7 @@ module.exports = [
             await reporting.rmsVoltage(endpoint);
             await reporting.readMeteringMultiplierDivisor(endpoint);
             await reporting.currentSummDelivered(endpoint);
+            await reporting.acFrequency(endpoint);
         },
         endpoint: (device) => {
             return {default: 2};

package/devices/lidl.js

@@ -7,9 +7,6 @@ const ea = exposes.access;
 const tuya = require('../lib/tuya');
 const globalStore = require('../lib/store');
 const ota = require('../lib/ota');
-const utils = require('../lib/utils');
-const {ColorMode, colorModeLookup} = require('../lib/constants');
-const libColor = require('../lib/color');
 
 const tuyaLocal = {
     dataPoints: {
@@ -145,105 +142,6 @@ const fzLocal = {
     },
 };
 const tzLocal = {
-    led_control: {
-        key: ['brightness', 'color', 'color_temp', 'transition'],
-        options: [exposes.options.color_sync()],
-        convertSet: async (entity, _key, _value, meta) => {
-            const newState = {};
-
-            // The color mode encodes whether the light is using its white LEDs or its color LEDs
-            let colorMode = meta.state.color_mode ?? colorModeLookup[ColorMode.ColorTemp];
-
-            // Color mode switching is done by setting color temperature (switch to white LEDs) or setting color (switch
-            // to color LEDs)
-            if ('color_temp' in meta.message) colorMode = colorModeLookup[ColorMode.ColorTemp];
-            if ('color' in meta.message) colorMode = colorModeLookup[ColorMode.HS];
-
-            if (colorMode != meta.state.color_mode) {
-                newState.color_mode = colorMode;
-
-                // To switch between white mode and color mode, we have to send a special command:
-                const rgbMode = (colorMode == colorModeLookup[ColorMode.HS]);
-                await entity.command('lightingColorCtrl', 'tuyaRgbMode', {enable: rgbMode}, {}, {disableDefaultResponse: true});
-            }
-
-            // A transition time of 0 would be treated as about 1 second, probably some kind of fallback/default
-            // transition time, so for "no transition" we use 1 (tenth of a second).
-            const transtime = 'transition' in meta.message ? meta.message.transition * 10 : 1;
-
-            if (colorMode == colorModeLookup[ColorMode.ColorTemp]) {
-                if ('brightness' in meta.message) {
-                    const zclData = {level: Number(meta.message.brightness), transtime};
-                    await entity.command('genLevelCtrl', 'moveToLevel', zclData, utils.getOptions(meta.mapped, entity));
-                    newState.brightness = meta.message.brightness;
-                }
-
-                if ('color_temp' in meta.message) {
-                    const zclData = {colortemp: meta.message.color_temp, transtime: transtime};
-                    await entity.command('lightingColorCtrl', 'moveToColorTemp', zclData, utils.getOptions(meta.mapped, entity));
-                    newState.color_temp = meta.message.color_temp;
-                }
-            } else if (colorMode == colorModeLookup[ColorMode.HS]) {
-                if ('brightness' in meta.message || 'color' in meta.message) {
-                    // We ignore the brightness of the color and instead use the overall brightness setting of the lamp
-                    // for the brightness because I think that's the expected behavior and also because the color
-                    // conversion below always returns 100 as brightness ("value") even for very dark colors, except
-                    // when the color is completely black/zero.
-
-                    // Load current state or defaults
-                    const newSettings = {
-                        brightness: meta.state.brightness ?? 254, //      full brightness
-                        hue: (meta.state.color ?? {}).hue ?? 0, //          red
-                        saturation: (meta.state.color ?? {}).saturation ?? 100, // full saturation
-                    };
-
-                    // Apply changes
-                    if ('brightness' in meta.message) {
-                        newSettings.brightness = meta.message.brightness;
-                        newState.brightness = meta.message.brightness;
-                    }
-                    if ('color' in meta.message) {
-                        // The Z2M UI sends `{ hex:'#xxxxxx' }`.
-                        // Home Assistant sends `{ h: xxx, s: xxx }`.
-                        // We convert the former into the latter.
-                        const c = libColor.Color.fromConverterArg(meta.message.color);
-                        if (c.isRGB()) {
-                            // https://github.com/Koenkk/zigbee2mqtt/issues/13421#issuecomment-1426044963
-                            c.hsv = c.rgb.gammaCorrected().toXY().toHSV();
-                        }
-                        const color = c.hsv;
-
-                        newSettings.hue = color.hue;
-                        newSettings.saturation = color.saturation;
-
-                        newState.color = {
-                            hue: color.hue,
-                            saturation: color.saturation,
-                        };
-                    }
-
-                    // Convert to device specific format and send
-                    const zclData = {
-                        brightness: utils.mapNumberRange(newSettings.brightness, 0, 254, 0, 1000),
-                        hue: newSettings.hue,
-                        saturation: utils.mapNumberRange(newSettings.saturation, 0, 100, 0, 1000),
-                    };
-                    // This command doesn't support a transition time
-                    await entity.command('lightingColorCtrl', 'tuyaMoveToHueAndSaturationBrightness2', zclData,
-                        utils.getOptions(meta.mapped, entity));
-                }
-            }
-
-            // If we're in white mode, calculate a matching display color for the set color temperature. This also kind
-            // of works in the other direction.
-            Object.assign(newState, libColor.syncColorState(newState, meta.state, entity, meta.options, meta.logger));
-
-            return {state: newState};
-        },
-        convertGet: async (entity, key, meta) => {
-            await entity.read('lightingColorCtrl', ['currentHue', 'currentSaturation', 'currentLevel', 'tuyaRgbMode', 'colorTemperature']);
-        },
-    },
     zs_thermostat_child_lock: {
         key: ['child_lock'],
         convertSet: async (entity, key, value, meta) => {
@@ -626,18 +524,6 @@ module.exports = [
             device.getEndpoint(1).saveClusterAttributeKeyValue('lightingColorCtrl', {colorCapabilities: 29});
         },
     },
-    {
-        fingerprint: [{modelID: 'TS0505B', manufacturerName: '_TZ3210_iystcadi'}],
-        model: '14149505L/14149506L_2',
-        vendor: 'Lidl',
-        description: 'Livarno Lux light bar RGB+CCT (black/white)',
-        toZigbee: [tz.on_off, tzLocal.led_control],
-        fromZigbee: [fz.on_off, fz.tuya_led_controller, fz.brightness, fz.ignore_basic_report],
-        exposes: [e.light_brightness_colortemp_colorhs([153, 500]).removeFeature('color_temp_startup')],
-        configure: async (device, coordinatorEndpoint, logger) => {
-            device.getEndpoint(1).saveClusterAttributeKeyValue('lightingColorCtrl', {colorCapabilities: 29});
-        },
-    },
     {
         fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_htnnfasr'}],
         model: 'PSBZS A1',

package/devices/niko.js

@@ -34,14 +34,27 @@ const local = {
                         64: 'single',
                         32: 'hold',
                         48: 'release',
+                        256: null,
+                        1024: 'single_ext',
+                        512: 'hold_ext',
+                        768: 'release_ext',
                     } : {
                         16: null,
                         64: 'single_left',
                         32: 'hold_left',
                         48: 'release_left',
-                        4096: 'single_right',
+                        256: null,
+                        1024: 'single_left_ext',
+                        512: 'hold_left_ext',
+                        768: 'release_left_ext',
+                        4096: null,
+                        16384: 'single_right',
                         8192: 'hold_right',
                         12288: 'release_right',
+                        65536: null,
+                        262144: 'single_right_ext',
+                        131072: 'hold_right_ext',
+                        196608: 'release_right_ext',
                     };
 
                     state['action'] = actionMap[msg.data.switchAction];
@@ -262,7 +275,10 @@ module.exports = [
         },
         exposes: [
             e.switch(),
-            e.action(['single', 'hold', 'release']),
+            e.action([
+                'single', 'hold', 'release',
+                'single_ext', 'hold_ext', 'release_ext',
+            ]),
             exposes.enum('operation_mode', ea.ALL, ['control_relay', 'decoupled']),
             exposes.binary('led_enable', ea.ALL, true, false).withDescription('Enable LED'),
             exposes.binary('led_state', ea.ALL, 'ON', 'OFF').withDescription('LED State'),
@@ -293,7 +309,9 @@ module.exports = [
             e.switch().withEndpoint('l1'), e.switch().withEndpoint('l2'),
             e.action([
                 'single_left', 'hold_left', 'release_left',
+                'single_left_ext', 'hold_left_ext', 'release_left_ext',
                 'single_right', 'hold_right', 'release_right',
+                'single_right_ext', 'hold_right_ext', 'release_right_ext',
             ]),
             exposes.enum('operation_mode', ea.ALL, ['control_relay', 'decoupled']),
             exposes.binary('led_enable', ea.ALL, true, false).withEndpoint('l1').withDescription('Enable LED'),

package/devices/sinope.js

@@ -370,7 +370,7 @@ const tzLocal = {
         },
     },
     connected_load: {
-        // TH1400ZB specific
+        // TH1400ZB and SW2500ZB
         key: ['connected_load'],
         convertSet: async (entity, key, value, meta) => {
             await entity.write('manuSpecificSinope', {connectedLoad: value});
@@ -413,7 +413,7 @@ const tzLocal = {
             if (value >= 0 && value <= 100) {
                 await entity.write('manuSpecificSinope', {ledIntensityOn: value});
             }
-            return {readAfterWriteTime: 250, state: {ledIntensityOn: value}};
+            return {state: {led_intensity_on: value}};
         },
         convertGet: async (entity, key, meta) => {
             await entity.read('manuSpecificSinope', ['ledIntensityOn']);
@@ -426,7 +426,7 @@ const tzLocal = {
             if (value >= 0 && value <= 100) {
                 await entity.write('manuSpecificSinope', {ledIntensityOff: value});
             }
-            return {readAfterWriteTime: 250, state: {ledIntensityOff: value}};
+            return {state: {led_intensity_off: value}};
         },
         convertGet: async (entity, key, meta) => {
             await entity.read('manuSpecificSinope', ['ledIntensityOff']);
@@ -476,13 +476,13 @@ const tzLocal = {
             if (value >= 0 && value <= 10800) {
                 await entity.write('manuSpecificSinope', {dimmerTimmer: value});
             }
-            return {readAfterWriteTime: 250, state: {dimmerTimmer: value}};
+            return {state: {timer_seconds: value}};
         },
         convertGet: async (entity, key, meta) => {
             await entity.read('manuSpecificSinope', ['dimmerTimmer']);
         },
     },
-    keypad_lock: {
+    keypad_lockout: {
         // SW2500ZB
         key: ['keypad_lockout'],
         convertSet: async (entity, key, value, meta) => {
@@ -991,16 +991,16 @@ module.exports = [
         model: 'SW2500ZB',
         vendor: 'Sinopé',
         description: 'Zigbee smart light switch',
-        fromZigbee: [fz.on_off, fz.electrical_measurement, fzLocal.sinope],
+        fromZigbee: [fz.on_off, fzLocal.sinope, fz.metering],
         toZigbee: [tz.on_off, tzLocal.timer_seconds, tzLocal.led_intensity_on, tzLocal.led_intensity_off,
-            tzLocal.led_color_on, tzLocal.led_color_off, tzLocal.keypad_lock],
+            tzLocal.led_color_on, tzLocal.led_color_off, tzLocal.keypad_lockout, tzLocal.connected_load],
         exposes: [e.switch(),
             e.action(['up_single', 'up_double', 'up_hold', 'down_single', 'down_double', 'down_hold']),
-            exposes.numeric('timer_seconds', ea.ALL).withValueMin(0).withValueMax(10800)
+            exposes.numeric('timer_seconds', ea.ALL).withUnit('seconds').withValueMin(0).withValueMax(10800)
                 .withDescription('Automatically turn off load after x seconds'),
-            exposes.numeric('led_intensity_on', ea.ALL).withValueMin(0).withValueMax(100)
+            exposes.numeric('led_intensity_on', ea.ALL).withUnit('%').withValueMin(0).withValueMax(100)
                 .withDescription('Control status LED intensity when load ON'),
-            exposes.numeric('led_intensity_off', ea.ALL).withValueMin(0).withValueMax(100)
+            exposes.numeric('led_intensity_off', ea.ALL).withUnit('%').withValueMin(0).withValueMax(100)
                 .withDescription('Control status LED intensity when load OFF'),
             exposes.composite('led_color_on', 'led_color_on', ea.SET)
                 .withFeature(exposes.numeric('r', ea.SET))
@@ -1013,12 +1013,20 @@ module.exports = [
                 .withFeature(exposes.numeric('b', ea.SET))
                 .withDescription('Control status LED color when load OFF'),
             exposes.enum('keypad_lockout', ea.ALL, ['unlock', 'lock'])
-                .withDescription('Enables or disables the device’s buttons')],
+                .withDescription('Enables or disables the device’s buttons'),
+            exposes.numeric('connected_load', ea.ALL)
+                .withUnit('W').withValueMin(1).withValueMax(1800)
+                .withDescription('Load connected in watt'),
+            e.energy(),
+        ],
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
-            const binds = ['genOnOff'];
+            const binds = ['genOnOff', 'manuSpecificSinope', 'seMetering'];
             await reporting.bind(endpoint, coordinatorEndpoint, binds);
             await reporting.onOff(endpoint);
+            try {
+                await reporting.currentSummDelivered(endpoint, {min: 10, max: 300, change: [0, 10]});
+            } catch (error) {/* Do nothing*/}
             const payload = [{
                 attribute: 'actionReport',
                 minimumReportInterval: 0,

package/devices/tuya.js

@@ -14,8 +14,108 @@ const fzZosung = zosung.fzZosung;
 const tzZosung = zosung.tzZosung;
 const ez = zosung.presetsZosung;
 const globalStore = require('../lib/store');
+const {ColorMode, colorModeLookup} = require('../lib/constants');
 
 const tzLocal = {
+    led_control: {
+        key: ['brightness', 'color', 'color_temp', 'transition'],
+        options: [exposes.options.color_sync()],
+        convertSet: async (entity, _key, _value, meta) => {
+            const newState = {};
+
+            // The color mode encodes whether the light is using its white LEDs or its color LEDs
+            let colorMode = meta.state.color_mode ?? colorModeLookup[ColorMode.ColorTemp];
+
+            // Color mode switching is done by setting color temperature (switch to white LEDs) or setting color (switch
+            // to color LEDs)
+            if ('color_temp' in meta.message) colorMode = colorModeLookup[ColorMode.ColorTemp];
+            if ('color' in meta.message) colorMode = colorModeLookup[ColorMode.HS];
+
+            if (colorMode != meta.state.color_mode) {
+                newState.color_mode = colorMode;
+
+                // To switch between white mode and color mode, we have to send a special command:
+                const rgbMode = (colorMode == colorModeLookup[ColorMode.HS]);
+                await entity.command('lightingColorCtrl', 'tuyaRgbMode', {enable: rgbMode}, {}, {disableDefaultResponse: true});
+            }
+
+            // A transition time of 0 would be treated as about 1 second, probably some kind of fallback/default
+            // transition time, so for "no transition" we use 1 (tenth of a second).
+            const transtime = 'transition' in meta.message ? meta.message.transition * 10 : 1;
+
+            if (colorMode == colorModeLookup[ColorMode.ColorTemp]) {
+                if ('brightness' in meta.message) {
+                    const zclData = {level: Number(meta.message.brightness), transtime};
+                    await entity.command('genLevelCtrl', 'moveToLevel', zclData, utils.getOptions(meta.mapped, entity));
+                    newState.brightness = meta.message.brightness;
+                }
+
+                if ('color_temp' in meta.message) {
+                    const zclData = {colortemp: meta.message.color_temp, transtime: transtime};
+                    await entity.command('lightingColorCtrl', 'moveToColorTemp', zclData, utils.getOptions(meta.mapped, entity));
+                    newState.color_temp = meta.message.color_temp;
+                }
+            } else if (colorMode == colorModeLookup[ColorMode.HS]) {
+                if ('brightness' in meta.message || 'color' in meta.message) {
+                    // We ignore the brightness of the color and instead use the overall brightness setting of the lamp
+                    // for the brightness because I think that's the expected behavior and also because the color
+                    // conversion below always returns 100 as brightness ("value") even for very dark colors, except
+                    // when the color is completely black/zero.
+
+                    // Load current state or defaults
+                    const newSettings = {
+                        brightness: meta.state.brightness ?? 254, //      full brightness
+                        hue: (meta.state.color ?? {}).hue ?? 0, //          red
+                        saturation: (meta.state.color ?? {}).saturation ?? 100, // full saturation
+                    };
+
+                    // Apply changes
+                    if ('brightness' in meta.message) {
+                        newSettings.brightness = meta.message.brightness;
+                        newState.brightness = meta.message.brightness;
+                    }
+                    if ('color' in meta.message) {
+                        // The Z2M UI sends `{ hex:'#xxxxxx' }`.
+                        // Home Assistant sends `{ h: xxx, s: xxx }`.
+                        // We convert the former into the latter.
+                        const c = libColor.Color.fromConverterArg(meta.message.color);
+                        if (c.isRGB()) {
+                            // https://github.com/Koenkk/zigbee2mqtt/issues/13421#issuecomment-1426044963
+                            c.hsv = c.rgb.gammaCorrected().toXY().toHSV();
+                        }
+                        const color = c.hsv;
+
+                        newSettings.hue = color.hue;
+                        newSettings.saturation = color.saturation;
+
+                        newState.color = {
+                            hue: color.hue,
+                            saturation: color.saturation,
+                        };
+                    }
+
+                    // Convert to device specific format and send
+                    const zclData = {
+                        brightness: utils.mapNumberRange(newSettings.brightness, 0, 254, 0, 1000),
+                        hue: newSettings.hue,
+                        saturation: utils.mapNumberRange(newSettings.saturation, 0, 100, 0, 1000),
+                    };
+                    // This command doesn't support a transition time
+                    await entity.command('lightingColorCtrl', 'tuyaMoveToHueAndSaturationBrightness2', zclData,
+                        utils.getOptions(meta.mapped, entity));
+                }
+            }
+
+            // If we're in white mode, calculate a matching display color for the set color temperature. This also kind
+            // of works in the other direction.
+            Object.assign(newState, libColor.syncColorState(newState, meta.state, entity, meta.options, meta.logger));
+
+            return {state: newState};
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read('lightingColorCtrl', ['currentHue', 'currentSaturation', 'currentLevel', 'tuyaRgbMode', 'colorTemperature']);
+        },
+    },
     TS110E_options: {
         key: ['min_brightness', 'max_brightness', 'light_type', 'switch_type'],
         convertSet: async (entity, key, value, meta) => {
@@ -338,6 +438,79 @@ const tzLocal = {
             }
         },
     },
+    TS011F_threshold: {
+        key: [
+            'temperature_threshold', 'temperature_breaker', 'power_threshold', 'power_breaker',
+            'over_current_threshold', 'over_current_breaker', 'over_voltage_threshold', 'over_voltage_breaker',
+            'under_voltage_threshold', 'under_voltage_breaker',
+        ],
+        convertSet: async (entity, key, value, meta) => {
+            switch (key) {
+            case 'temperature_threshold': {
+                const state = meta.state['temperature_breaker'];
+                const buf = Buffer.from([5, {'ON': 1, 'OFF': 0}[state], 0, value]);
+                await entity.command('manuSpecificTuya_3', 'setOptions2', {data: buf});
+                break;
+            }
+            case 'temperature_breaker': {
+                const threshold = meta.state['temperature_threshold'];
+                const buf = Buffer.from([5, {'ON': 1, 'OFF': 0}[value], 0, threshold]);
+                await entity.command('manuSpecificTuya_3', 'setOptions2', {data: buf});
+                break;
+            }
+            case 'power_threshold': {
+                const state = meta.state['power_breaker'];
+                const buf = Buffer.from([7, {'ON': 1, 'OFF': 0}[state], 0, value]);
+                await entity.command('manuSpecificTuya_3', 'setOptions2', {data: buf});
+                break;
+            }
+            case 'power_breaker': {
+                const threshold = meta.state['power_threshold'];
+                const buf = Buffer.from([7, {'ON': 1, 'OFF': 0}[value], 0, threshold]);
+                await entity.command('manuSpecificTuya_3', 'setOptions2', {data: buf});
+                break;
+            }
+            case 'over_current_threshold': {
+                const state = meta.state['over_current_breaker'];
+                const buf = Buffer.from([1, {'ON': 1, 'OFF': 0}[state], 0, value]);
+                await entity.command('manuSpecificTuya_3', 'setOptions3', {data: buf});
+                break;
+            }
+            case 'over_current_breaker': {
+                const threshold = meta.state['over_current_threshold'];
+                const buf = Buffer.from([1, {'ON': 1, 'OFF': 0}[value], 0, threshold]);
+                await entity.command('manuSpecificTuya_3', 'setOptions3', {data: buf});
+                break;
+            }
+            case 'over_voltage_threshold': {
+                const state = meta.state['over_voltage_breaker'];
+                const buf = Buffer.from([3, {'ON': 1, 'OFF': 0}[state], 0, value]);
+                await entity.command('manuSpecificTuya_3', 'setOptions3', {data: buf});
+                break;
+            }
+            case 'over_voltage_breaker': {
+                const threshold = meta.state['over_voltage_threshold'];
+                const buf = Buffer.from([3, {'ON': 1, 'OFF': 0}[value], 0, threshold]);
+                await entity.command('manuSpecificTuya_3', 'setOptions3', {data: buf});
+                break;
+            }
+            case 'under_voltage_threshold': {
+                const state = meta.state['under_voltage_breaker'];
+                const buf = Buffer.from([4, {'ON': 1, 'OFF': 0}[state], 0, value]);
+                await entity.command('manuSpecificTuya_3', 'setOptions3', {data: buf});
+                break;
+            }
+            case 'under_voltage_breaker': {
+                const threshold = meta.state['under_voltage_threshold'];
+                const buf = Buffer.from([4, {'ON': 1, 'OFF': 0}[value], 0, threshold]);
+                await entity.command('manuSpecificTuya_3', 'setOptions3', {data: buf});
+                break;
+            }
+            default: // Unknown key
+                meta.logger.warn(`Unhandled key ${key}`);
+            }
+        },
+    },
 };
 
 const fzLocal = {
@@ -739,6 +912,46 @@ const fzLocal = {
             return result;
         },
     },
+    TS011F_threshold: {
+        cluster: 'manuSpecificTuya_3',
+        type: 'raw',
+        convert: (model, msg, publish, options, meta) => {
+            const splitToAttributes = (value) => {
+                const result = {};
+                const len = value.length;
+                let i = 0;
+                while (i < len) {
+                    const key = value.readUInt8(i);
+                    result[key] = [value.readUInt8(i+1), value.readUInt16BE(i+2)];
+                    i += 4;
+                }
+                return result;
+            };
+            const lookup = {0: 'OFF', 1: 'ON'};
+            const command = msg.data[2];
+            const data = msg.data.slice(3);
+            if (command == 0xE6) {
+                const value = splitToAttributes(data);
+                return {
+                    'temperature_threshold': value[0x05][1],
+                    'temperature_breaker': lookup[value[0x05][0]],
+                    'power_threshold': value[0x07][1],
+                    'power_breaker': lookup[value[0x07][0]],
+                };
+            }
+            if (command == 0xE7) {
+                const value = splitToAttributes(data);
+                return {
+                    'over_current_threshold': value[0x01][1],
+                    'over_current_breaker': lookup[value[0x01][0]],
+                    'over_voltage_threshold': value[0x03][1],
+                    'over_voltage_breaker': lookup[value[0x03][0]],
+                    'under_voltage_threshold': value[0x04][1],
+                    'under_voltage_breaker': lookup[value[0x04][0]],
+                };
+            }
+        },
+    },
 };
 
 module.exports = [
@@ -1016,7 +1229,7 @@ module.exports = [
     },
     {
         zigbeeModel: ['TS0505B'],
-        model: 'TS0505B',
+        model: 'TS0505B_1',
         vendor: 'TuYa',
         description: 'Zigbee RGB+CCT light',
         whiteLabel: [{vendor: 'Mercator Ikuü', model: 'SMD4106W-RGB-ZB'},
@@ -1055,6 +1268,22 @@ module.exports = [
             device.getEndpoint(1).saveClusterAttributeKeyValue('lightingColorCtrl', {colorCapabilities: 29});
         },
     },
+    {
+        fingerprint: tuya.fingerprint('TS0505B', ['_TZ3210_c0s1xloa', '_TZ3210_iystcadi']),
+        model: 'TS0505B_2',
+        vendor: 'TuYa',
+        description: 'Zigbee RGB+CCT light',
+        whiteLabel: [
+            tuya.whitelabel('Lidl', '14149505L/14149506L_2', 'Livarno Lux light bar RGB+CCT (black/white)', ['_TZ3210_iystcadi']),
+            tuya.whitelabel('Lidl', '399629_2110', 'Livarno Lux Ceiling Panel RGB+CCT', ['_TZ3210_c0s1xloa']),
+        ],
+        toZigbee: [tz.on_off, tzLocal.led_control],
+        fromZigbee: [fz.on_off, fz.tuya_led_controller, fz.brightness, fz.ignore_basic_report],
+        exposes: [e.light_brightness_colortemp_colorhs([153, 500]).removeFeature('color_temp_startup')],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            device.getEndpoint(1).saveClusterAttributeKeyValue('lightingColorCtrl', {colorCapabilities: 29});
+        },
+    },
     {
         zigbeeModel: ['TS0503B'],
         model: 'TS0503B',
@@ -1175,13 +1404,15 @@ module.exports = [
             {modelID: 'TS0202', manufacturerName: '_TZ3000_h4wnrtck'},
             {modelID: 'TS0202', manufacturerName: '_TZ3000_sr0vaafi'},
             {modelID: 'WHD02', manufacturerName: '_TZ3000_hktqahrq'},
+            {modelID: 'TS0202', manufacturerName: '_TZ3040_wqmtjsyk'},
         ],
         model: 'TS0202',
         vendor: 'TuYa',
         description: 'Motion sensor',
         whiteLabel: [{vendor: 'Mercator Ikuü', model: 'SMA02P'},
             {vendor: 'TuYa', model: 'TY-ZPR06'},
-            {vendor: 'Tesla Smart', model: 'TS0202'}],
+            {vendor: 'Tesla Smart', model: 'TS0202'},
+            tuya.whitelabel('MiBoxer', 'PIR1-ZB', 'PIR Sensor', ['_TZ3040_wqmtjsyk'])],
         fromZigbee: [fz.ias_occupancy_alarm_1, fz.battery, fz.ignore_basic_report, fz.ias_occupancy_alarm_1_report],
         toZigbee: [],
         exposes: [e.occupancy(), e.battery_low(), e.tamper(), e.battery(), e.battery_voltage()],
@@ -2128,11 +2359,14 @@ module.exports = [
     },
     {
         fingerprint: tuya.fingerprint('TS0002', ['_TZ3000_01gpyda5', '_TZ3000_bvrlqyj7', '_TZ3000_7ed9cqgi',
-            '_TZ3000_zmy4lslw', '_TZ3000_ruxexjfz']),
+            '_TZ3000_zmy4lslw', '_TZ3000_ruxexjfz', '_TZ3000_4xfqlgqo']),
         model: 'TS0002_switch_module',
         vendor: 'TuYa',
         description: '2 gang switch module',
-        whiteLabel: [{vendor: 'OXT', model: 'SWTZ22'}, {vendor: 'Nous', model: 'L13Z'}],
+        whiteLabel: [
+            {vendor: 'OXT', model: 'SWTZ22'}, {vendor: 'Nous', model: 'L13Z'},
+            tuya.whitelabel('pcblab.io', 'RR620ZB', '2 gang Zigbee switch module', ['_TZ3000_4xfqlgqo']),
+        ],
         extend: tuya.extend.switch({switchType: true, endpoints: ['l1', 'l2']}),
         endpoint: (device) => {
             return {'l1': 1, 'l2': 2};
@@ -2411,8 +2645,8 @@ module.exports = [
             exposes.enum('motor_direction', ea.STATE_SET, ['normal', 'reversed']).withDescription('Set the motor direction'),
             exposes.numeric('motor_speed', ea.STATE_SET).withValueMin(0).withValueMax(255).withDescription('Motor speed').withUnit('rpm'),
             exposes.enum('opening_mode', ea.STATE_SET, ['tilt', 'lift']).withDescription('Opening mode'),
-            exposes.enum('set_upper_limit', ea.SET, ['SET']).withDescription('Set the upper limit, to reset limits use factory_reset'),
-            exposes.enum('set_bottom_limit', ea.SET, ['SET']).withDescription('Set the bottom limit, to reset limits use factory_reset'),
+            exposes.enum('set_upper_limit', ea.STATE_SET, ['SET']).withDescription('Set the upper limit, to reset limits use factory_reset'),
+            exposes.enum('set_bottom_limit', ea.STATE_SET, ['SET']).withDescription('Set the bottom limit, to reset limits use factory_reset'),
             exposes.binary('factory_reset', ea.STATE_SET, true, false).withDescription('Factory reset the device'),
         ],
         whiteLabel: [
@@ -3075,14 +3309,13 @@ module.exports = [
         whiteLabel: [{vendor: 'Hiking', model: 'DDS238-2'}, {vendor: 'TuYa', model: 'RC-MCB'}],
     },
     {
-        fingerprint: tuya.fingerprint('TS0601', ['_TZE200_lsanae15']),
+        fingerprint: tuya.fingerprint('TS0601', ['_TZE200_lsanae15', '_TZE204_lsanae15']),
         model: 'TS0601_din_2',
         vendor: 'TuYa',
         description: 'Zigbee DIN energy meter',
         fromZigbee: [tuya.fz.datapoints],
         toZigbee: [tuya.tz.datapoints],
         configure: tuya.configureMagicPacket,
-        whiteLabel: [{vendor: 'XOCA', model: 'DAC2161C'}],
         exposes: [tuya.exposes.switch(), e.energy(), e.power(), e.voltage(), e.current(),
             exposes.enum('fault', ea.STATE, ['clear', 'over_current_threshold', 'over_power_threshold',
                 'over_voltage threshold', 'wrong_frequency_threshold']).withDescription('Fault status of the device (clear = nothing)'),
@@ -3121,6 +3354,9 @@ module.exports = [
                 [24, null, null], // Forward Energy T4 - don't know what this
             ],
         },
+        whiteLabel: [
+            tuya.whitelabel('MatSee Plus', 'DAC2161C', 'Smart Zigbee energy meter 80A din rail', ['_TZE200_lsanae15', '_TZE204_lsanae15']),
+        ],
     },
     {
         fingerprint: tuya.fingerprint('TS0601', ['_TZE200_rhblgy0z']),
@@ -4504,4 +4740,57 @@ module.exports = [
         toZigbee: [],
         configure: tuya.configureMagicPacket,
     },
+    {
+        fingerprint: tuya.fingerprint('TS011F', ['_TZ3000_cayepv1a']),
+        model: 'TS011F_with_threshold',
+        description: 'Din rail switch with power monitoring and threshold settings',
+        vendor: 'TuYa',
+        ota: ota.zigbeeOTA,
+        extend: tuya.extend.switch({
+            electricalMeasurements: true, electricalMeasurementsFzConverter: fzLocal.TS011F_electrical_measurement,
+            powerOutageMemory: true, indicatorMode: true,
+            fromZigbee: [fz.temperature, fzLocal.TS011F_threshold],
+            toZigbee: [tzLocal.TS011F_threshold],
+            exposes: [
+                e.temperature(),
+                exposes.numeric('temperature_threshold', ea.STATE_SET).withValueMin(40).withValueMax(100).withValueStep(1).withUnit('*C')
+                    .withDescription('High temperature threshold'),
+                exposes.binary('temperature_breaker', ea.STATE_SET, 'ON', 'OFF')
+                    .withDescription('High temperature breaker'),
+                exposes.numeric('power_threshold', ea.STATE_SET).withValueMin(1).withValueMax(26).withValueStep(1).withUnit('kW')
+                    .withDescription('High power threshold'),
+                exposes.binary('power_breaker', ea.STATE_SET, 'ON', 'OFF')
+                    .withDescription('High power breaker'),
+                exposes.numeric('over_current_threshold', ea.STATE_SET).withValueMin(1).withValueMax(64).withValueStep(1).withUnit('A')
+                    .withDescription('Over-current threshold'),
+                exposes.binary('over_current_breaker', ea.STATE_SET, 'ON', 'OFF')
+                    .withDescription('Over-current breaker'),
+                exposes.numeric('over_voltage_threshold', ea.STATE_SET).withValueMin(220).withValueMax(260).withValueStep(1).withUnit('V')
+                    .withDescription('Over-voltage threshold'),
+                exposes.binary('over_voltage_breaker', ea.STATE_SET, 'ON', 'OFF')
+                    .withDescription('Over-voltage breaker'),
+                exposes.numeric('under_voltage_threshold', ea.STATE_SET).withValueMin(76).withValueMax(240).withValueStep(1).withUnit('V')
+                    .withDescription('Under-voltage threshold'),
+                exposes.binary('under_voltage_breaker', ea.STATE_SET, 'ON', 'OFF')
+                    .withDescription('Under-voltage breaker'),
+            ],
+        }),
+        configure: async (device, coordinatorEndpoint, logger) => {
+            await tuya.configureMagicPacket(device, coordinatorEndpoint, logger);
+            const endpoint = device.getEndpoint(1);
+            endpoint.command('genBasic', 'tuyaSetup', {});
+            await reporting.bind(endpoint, coordinatorEndpoint, ['msTemperatureMeasurement']);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'haElectricalMeasurement', 'seMetering']);
+            await reporting.rmsVoltage(endpoint, {change: 5});
+            await reporting.rmsCurrent(endpoint, {change: 50});
+            await reporting.activePower(endpoint, {change: 10});
+            await reporting.currentSummDelivered(endpoint);
+            endpoint.saveClusterAttributeKeyValue('haElectricalMeasurement', {acCurrentDivisor: 1000, acCurrentMultiplier: 1});
+            endpoint.saveClusterAttributeKeyValue('seMetering', {divisor: 100, multiplier: 1});
+            device.save();
+        },
+        whiteLabel: [
+            tuya.whitelabel('TONGOU', 'TO-Q-SY2-163JZT', 'Smart circuit breaker', ['_TZ3000_cayepv1a']),
+        ],
+    },
 ];

package/lib/tuya.js

@@ -1932,6 +1932,9 @@ const tuyaExtend = {
             toZigbee.push(tuyaTz.child_lock);
             exposes.push(e.child_lock());
         }
+        if (options.fromZigbee) fromZigbee.push(...options.fromZigbee);
+        if (options.toZigbee) toZigbee.push(...options.toZigbee);
+        if (options.exposes) exposes.push(...options.exposes);
         return {exposes, fromZigbee, toZigbee};
     },
     light_onoff_brightness_colortemp_color: (options={}) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zigbee-herdsman-converters",
-  "version": "15.0.97",
+  "version": "15.0.99",
   "description": "Collection of device converters to be used with zigbee-herdsman",
   "main": "index.js",
   "files": [
@@ -34,11 +34,11 @@
   },
   "homepage": "https://github.com/Koenkk/zigbee-herdsman-converters",
   "dependencies": {
-    "axios": "^1.3.6",
+    "axios": "^1.4.0",
     "buffer-crc32": "^0.2.13",
     "https-proxy-agent": "^5.0.1",
     "tar-stream": "^3.0.0",
-    "zigbee-herdsman": "^0.14.108"
+    "zigbee-herdsman": "^0.14.110"
   },
   "devDependencies": {
     "eslint": "*",