zigbee-herdsman-converters 14.0.666 → 14.0.668

package/README.md

@@ -9,6 +9,7 @@ See [Zigbee2MQTT how to support new devices](https://www.zigbee2mqtt.io/advanced
 ## Submitting a pull request
 If you'd like to submit a pull request, you should run the following commands to ensure your changes will pass the tests:
 ```sh
+npm install
 npm run lint
 npm test
 ```

package/converters/fromZigbee.js

@@ -3476,6 +3476,22 @@ const converters = {
             return result;
         },
     },
+    sinope_thermostat: {
+        cluster: 'hvacThermostat',
+        type: ['readResponse'],
+        convert: (model, msg, publish, options, meta) => {
+            const lookup = {0: 'unoccupied', 1: 'occupied'};
+            const lookup1 = {0: 'on_demand', 1: 'sensing'};
+            const result = {};
+            if (msg.data.hasOwnProperty('1024')) {
+                result.thermostat_occupancy = lookup[msg.data['1024']];
+            }
+            if (msg.data.hasOwnProperty('1026')) {
+                result.backlight_auto_dim = lookup1[msg.data['1026']];
+            }
+            return result;
+        },
+    },
     danfoss_thermostat: {
         cluster: 'hvacThermostat',
         type: ['attributeReport', 'readResponse'],

package/converters/toZigbee.js

@@ -884,17 +884,28 @@ const converters = {
                 // TODO: same problem as above.
                 // TODO: if transition is not specified, should use device default (OnTransitionTime), not 0.
                 if (transition.specified || globalStore.getValue(entity, 'turnedOffWithTransition') === true) {
-                    const current = utils.getObjectProperty(meta.state, 'brightness', 254);
-                    brightness = globalStore.getValue(entity, 'brightness', current);
-                    try {
-                        const attributeRead = await entity.read('genLevelCtrl', ['onLevel']);
-                        // TODO: for groups, `read` does not wait for responses. If it did, we could still issue a single
-                        //  command if all values of `OnLevel` are equal, or split into one command per device if not.
-                        if (attributeRead !== undefined && attributeRead['onLevel'] != 255) {
-                            brightness = attributeRead['onLevel'];
+                    const levelConfig = utils.getObjectProperty(meta.state, 'level_config', {});
+                    let onLevel = utils.getObjectProperty(levelConfig, 'on_level', 0);
+                    if (onLevel === 0 && entity.meta.onLevelSupported !== false) {
+                        try {
+                            const attributeRead = await entity.read('genLevelCtrl', ['onLevel']);
+                            if (attributeRead !== undefined) {
+                                onLevel = attributeRead['onLevel'];
+                            }
+                        } catch (e) {
+                            // OnLevel not supported
                         }
-                    } catch (e) {
-                        // OnLevel not supported
+                    }
+                    if (onLevel === 0) {
+                        onLevel = 'previous';
+                        entity.meta.onLevelSupported = false;
+                        entity.save();
+                    }
+                    if (onLevel === 255 || onLevel === 'previous') {
+                        const current = utils.getObjectProperty(meta.state, 'brightness', 254);
+                        brightness = globalStore.getValue(entity, 'brightness', current);
+                    } else {
+                        brightness = onLevel;
                     }
                     // Published state might have gotten clobbered by reporting.
                     publishBrightness = true;
@@ -1308,7 +1319,7 @@ const converters = {
     thermostat_occupancy: {
         key: ['occupancy'],
         convertGet: async (entity, key, meta) => {
-            await entity.read('hvacThermostat', ['ocupancy']);
+            await entity.read('hvacThermostat', ['occupancy']);
         },
     },
     thermostat_clear_weekly_schedule: {
@@ -1394,6 +1405,7 @@ const converters = {
             }
             const unoccupiedCoolingSetpoint = result;
             await entity.write('hvacThermostat', {unoccupiedCoolingSetpoint});
+            return {state: {unoccupied_heating_setpoint: value}};
         },
         convertGet: async (entity, key, meta) => {
             await entity.read('hvacThermostat', ['unoccupiedCoolingSetpoint']);
@@ -4286,17 +4298,16 @@ const converters = {
             const sinopeOccupancy = {0: 'unoccupied', 1: 'occupied'};
             const SinopeOccupancy = utils.getKey(sinopeOccupancy, value, value, Number);
             await entity.write('hvacThermostat', {SinopeOccupancy});
+            return {state: {'thermostat_occupancy': value}};
         },
     },
     sinope_thermostat_backlight_autodim_param: {
         key: ['backlight_auto_dim'],
         convertSet: async (entity, key, value, meta) => {
-            const sinopeBacklightParam = {
-                0: 'on demand',
-                1: 'sensing',
-            };
+            const sinopeBacklightParam = {0: 'on_demand', 1: 'sensing'};
             const SinopeBacklight = utils.getKey(sinopeBacklightParam, value, value, Number);
             await entity.write('hvacThermostat', {SinopeBacklight});
+            return {state: {'backlight_auto_dim': value}};
         },
     },
     sinope_thermostat_enable_outdoor_temperature: {

package/devices/awox.js

@@ -169,7 +169,7 @@ module.exports = [
             },
         ],
         model: '33955',
-        vendor: 'Eglo',
+        vendor: 'AwoX',
         description: 'LED light with color temperature',
         extend: extend.light_onoff_brightness_colortemp({colorTempRange: [153, 370]}),
     },

package/devices/eglo.js

@@ -8,4 +8,11 @@ module.exports = [
         description: 'ROVITO-Z ceiling light',
         extend: extend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 370]}),
     },
+    {
+        zigbeeModel: ['ESMLFzm_w6_TW'],
+        model: '12242',
+        vendor: 'EGLO',
+        description: 'ST64 adjustable white filament bulb',
+        extend: extend.light_onoff_brightness_colortemp({colorTempRange: [153, 454]}),
+    },
 ];

package/devices/giex.js

@@ -118,18 +118,18 @@ module.exports = [
             e.battery(),
             exposes.binary('state', ea.STATE_SET, 'ON', 'OFF').withDescription('State'),
             exposes.enum('mode', ea.STATE_SET, ['duration', 'capacity']).withDescription('Irrigation mode'),
-            exposes.numeric('irrigation_target', exposes.access.STATE_SET).withValueMin(0).withValueMax(1440).withUnit('minutes or Litres')
-                .withDescription('Irrigation Target, duration in minutes or capacity in Litres (depending on mode)'),
-            exposes.numeric('cycle_irrigation_num_times', exposes.access.STATE_SET).withValueMin(0).withValueMax(100).withUnit('#')
+            exposes.numeric('irrigation_target', exposes.access.STATE_SET).withValueMin(0).withValueMax(3600).withUnit('seconds or litres')
+                .withDescription('Irrigation target, duration in seconds or capacity in litres (depending on mode)'),
+            exposes.numeric('cycle_irrigation_num_times', exposes.access.STATE_SET).withValueMin(0).withValueMax(100)
                 .withDescription('Number of cycle irrigation times, set to 0 for single cycle'),
-            exposes.numeric('cycle_irrigation_interval', exposes.access.STATE_SET).withValueMin(0).withValueMax(1440).withUnit('min')
+            exposes.numeric('cycle_irrigation_interval', exposes.access.STATE_SET).withValueMin(0).withValueMax(3600).withUnit('sec')
                 .withDescription('Cycle irrigation interval'),
-            exposes.numeric('irrigation_start_time', ea.STATE).withUnit('GMT+8').withDescription('Irrigation start time'),
-            exposes.numeric('irrigation_end_time', ea.STATE).withUnit('GMT+8').withDescription('Irrigation end time'),
-            exposes.numeric('last_irrigation_duration', exposes.access.STATE).withUnit('min')
+            exposes.numeric('irrigation_start_time', ea.STATE).withDescription('Last irrigation start time (GMT)'),
+            exposes.numeric('irrigation_end_time', ea.STATE).withDescription('Last irrigation end time (GMT)'),
+            exposes.numeric('last_irrigation_duration', exposes.access.STATE)
                 .withDescription('Last irrigation duration'),
             exposes.numeric('water_consumed', exposes.access.STATE).withUnit('L')
-                .withDescription('Water consumed (Litres)'),
+                .withDescription('Last irrigation water consumption'),
         ],
     },
 ];

package/devices/ikea.js

@@ -999,4 +999,11 @@ module.exports = [
         description: 'STOFTMOLN ceiling/wall lamp 24 warm light dimmable',
         extend: tradfriExtend.light_onoff_brightness(),
     },
+    {
+        zigbeeModel: ['TRADFRIbulbPAR38WS900lm'],
+        model: 'LED2006R9',
+        vendor: 'IKEA',
+        description: 'TRADFRI E26 PAR38 LED bulb 900 lumen, dimmable, white spectrum, downlight',
+        extend: tradfriExtend.light_onoff_brightness_colortemp(),
+    },
 ];

package/devices/innr.js

@@ -176,6 +176,14 @@ module.exports = [
         extend: extend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 555], supportsHS: true}),
         meta: {enhancedHue: false, applyRedFix: true, turnsOffAtBrightness1: true},
     },
+    {
+        zigbeeModel: ['RB 286 C'],
+        model: 'RB 286 C',
+        vendor: 'Innr',
+        description: 'E27 bulb RGBW',
+        extend: extend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 555], supportsHS: true}),
+        meta: {applyRedFix: true, turnsOffAtBrightness1: true},
+    },
     {
         zigbeeModel: ['BY 285 C'],
         model: 'BY 285 C',
@@ -591,6 +599,7 @@ module.exports = [
             await reporting.rmsVoltage(endpoint);
             // Gives UNSUPPORTED_ATTRIBUTE on reporting.readMeteringMultiplierDivisor.
             endpoint.saveClusterAttributeKeyValue('seMetering', {multiplier: 1, divisor: 100});
+            await reporting.currentSummDelivered(endpoint);
         },
         ota: ota.zigbeeOTA,
         exposes: [e.power(), e.current(), e.voltage().withAccess(ea.STATE), e.switch(), e.energy()],

package/devices/leedarson.js

@@ -111,4 +111,20 @@ module.exports = [
         toZigbee: [],
         exposes: [e.battery(), e.occupancy()],
     },
+    {
+        zigbeeModel: ['LDHD2AZW'],
+        model: 'LDHD2AZW',
+        vendor: 'Leedarson',
+        description: 'Magnetic door & window contact sensor',
+        fromZigbee: [fz.ias_contact_alarm_1, fz.temperature, fz.battery],
+        toZigbee: [],
+        meta: {battery: {voltageToPercentage: '3V_2100'}},
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['msTemperatureMeasurement', 'genPowerCfg']);
+            await reporting.temperature(endpoint);
+            await reporting.batteryVoltage(endpoint);
+        },
+        exposes: [e.contact(), e.battery_low(), e.tamper(), e.temperature(), e.battery()],
+    },
 ];

package/devices/legrand.js

@@ -16,6 +16,28 @@ const readInitialBatteryState = async (type, data, device) => {
 };
 
 module.exports = [
+    {
+        zigbeeModel: [' Dry contact\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000'+
+            '\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000'],
+        model: '412173',
+        description: 'DIN dry contactor module',
+        vendor: 'Legrand',
+        extend: extend.switch(),
+        fromZigbee: [fz.identify, fz.on_off, fz.electrical_measurement, fz.legrand_cluster_fc01, fz.ignore_basic_report, fz.ignore_genOta],
+        toZigbee: [tz.legrand_deviceMode, tz.on_off, tz.legrand_identify, tz.electrical_measurement_power],
+        exposes: [exposes.switch().withState('state', true, 'On/off (works only if device is in "switch" mode)'),
+            e.power().withAccess(ea.STATE_GET), exposes.enum('device_mode', ea.ALL, ['switch', 'auto'])
+                .withDescription('switch: allow on/off, auto will use wired action via C1/C2 on contactor for example with HC/HP')],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genIdentify', 'genOnOff', 'haElectricalMeasurement']);
+            await reporting.onOff(endpoint);
+            await reporting.readEletricalMeasurementMultiplierDivisors(endpoint);
+            await reporting.activePower(endpoint);
+            // Read configuration values that are not sent periodically as well as current power (activePower).
+            await endpoint.read('haElectricalMeasurement', ['activePower', 0xf000, 0xf001, 0xf002]);
+        },
+    },
     {
         zigbeeModel: [' Contactor\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000'+
             '\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000'],

package/devices/lonsonho.js

@@ -148,8 +148,10 @@ module.exports = [
         model: 'QS-Zigbee-D02-TRIAC-LN',
         vendor: 'Lonsonho',
         description: '1 gang smart dimmer switch module with neutral',
-        fromZigbee: extend.light_onoff_brightness().fromZigbee.concat([fz.tuya_min_brightness]),
-        toZigbee: extend.light_onoff_brightness().toZigbee.concat([tz.tuya_min_brightness]),
+        fromZigbee: extend.light_onoff_brightness({disableMoveStep: true, disableTransition: true})
+            .fromZigbee.concat([fz.tuya_min_brightness]),
+        toZigbee: extend.light_onoff_brightness({disableMoveStep: true, disableTransition: true})
+            .toZigbee.concat([tz.tuya_min_brightness]),
         exposes: [e.light_brightness().withMinBrightness()],
     },
     {
@@ -268,10 +270,10 @@ module.exports = [
         model: 'TS110E_2gang',
         vendor: 'Lonsonho',
         description: 'Zigbee smart dimmer module 2 gang with neutral',
-        fromZigbee: extend.light_onoff_brightness({disablePowerOnBehavior: true}).fromZigbee.concat([
-            fz.tuya_switch_power_outage_memory, fzLocal.TS110E_switch_type]),
-        toZigbee: extend.light_onoff_brightness({disablePowerOnBehavior: true}).toZigbee.concat([
-            tz.tuya_switch_power_outage_memory, tzLocal.TS110E_switch_type]),
+        fromZigbee: extend.light_onoff_brightness({disablePowerOnBehavior: true, disableMoveStep: true, disableTransition: true})
+            .fromZigbee.concat([fz.tuya_switch_power_outage_memory, fzLocal.TS110E_switch_type]),
+        toZigbee: extend.light_onoff_brightness({disablePowerOnBehavior: true, disableMoveStep: true, disableTransition: true})
+            .toZigbee.concat([tz.tuya_switch_power_outage_memory, tzLocal.TS110E_switch_type]),
         meta: {multiEndpoint: true},
         exposes: [
             e.light_brightness().withEndpoint('l1'),

package/devices/namron.js

@@ -461,7 +461,7 @@ module.exports = [
             await reporting.thermostatKeypadLockMode(endpoint);
 
             await endpoint.configureReporting('hvacThermostat', [{
-                attribute: 'ocupancy',
+                attribute: 'occupancy',
                 minimumReportInterval: 0,
                 maximumReportInterval: constants.repInterval.HOUR,
                 reportableChange: null,

package/devices/owon.js

@@ -123,8 +123,8 @@ module.exports = [
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint2 = device.getEndpoint(2);
             const endpoint3 = device.getEndpoint(3);
-            await reporting.bind(endpoint2, coordinatorEndpoint, ['msTemperatureMeasurement', 'msRelativeHumidity']);
-            await reporting.bind(endpoint3, coordinatorEndpoint, ['msIlluminanceMeasurement']);
+            await reporting.bind(endpoint2, coordinatorEndpoint, ['msIlluminanceMeasurement']);
+            await reporting.bind(endpoint3, coordinatorEndpoint, ['msTemperatureMeasurement', 'msRelativeHumidity']);
             device.powerSource = 'Battery';
             device.save();
         },

package/devices/paulmann.js

@@ -113,6 +113,13 @@ module.exports = [
         description: 'LED panels',
         extend: extend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 350]}),
     },
+    {
+        zigbeeModel: ['500.44'],
+        model: '500.44',
+        vendor: 'Paulmann',
+        description: 'URail power supply',
+        extend: extend.light_onoff_brightness_color(),
+    },
     {
         zigbeeModel: ['500.45'],
         model: '500.45',

package/devices/saswell.js

@@ -20,6 +20,7 @@ module.exports = [
             {modelID: 'TS0601', manufacturerName: '_TZE200_9gvruqf5'},
             {modelID: 'TS0601', manufacturerName: '_TZE200_zr9c0day'},
             {modelID: 'TS0601', manufacturerName: '_TZE200_0dvm9mva'},
+            {modelID: 'TS0601', manufacturerName: '_TZE200_h4cgnbzg'},
         ],
         model: 'SEA801-Zigbee/SEA802-Zigbee',
         vendor: 'Saswell',

package/devices/sinope.js

@@ -15,20 +15,20 @@ module.exports = [
         description: 'Zigbee line volt thermostat',
         meta: {thermostat: {dontMapPIHeatingDemand: true}},
         fromZigbee: [fz.legacy.sinope_thermostat_att_report, fz.legacy.hvac_user_interface, fz.electrical_measurement, fz.metering,
-            fz.ignore_temperature_report, fz.legacy.sinope_thermostat_state],
+            fz.ignore_temperature_report, fz.legacy.sinope_thermostat_state, fz.sinope_thermostat],
         toZigbee: [tz.thermostat_local_temperature, tz.thermostat_occupied_heating_setpoint, tz.thermostat_unoccupied_heating_setpoint,
             tz.thermostat_temperature_display_mode, tz.thermostat_keypad_lockout, tz.thermostat_system_mode, tz.thermostat_running_state,
             tz.sinope_thermostat_occupancy, tz.sinope_thermostat_backlight_autodim_param, tz.sinope_thermostat_time,
             tz.sinope_thermostat_enable_outdoor_temperature, tz.sinope_thermostat_outdoor_temperature, tz.sinope_time_format],
         exposes: [e.local_temperature(), e.keypad_lockout(), e.power(), e.current(), e.voltage(), e.energy(),
             exposes.climate().withSetpoint('occupied_heating_setpoint', 5, 30, 0.5).withLocalTemperature()
-                .withSystemMode(['off', 'heat']).withRunningState(['idle', 'heat']),
+                .withSystemMode(['off', 'heat']).withRunningState(['idle', 'heat']).withPiHeatingDemand(),
+            exposes.enum('thermostat_occupancy', ea.SET, ['unoccupied', 'occupied']).withDescription('Occupancy state of the thermostat'),
             exposes.enum('backlight_auto_dim', ea.SET, ['on demand', 'sensing']).withDescription('Control backlight dimming behavior')],
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
             const binds = ['genBasic', 'genIdentify', 'genGroups', 'hvacThermostat', 'hvacUserInterfaceCfg', 'msTemperatureMeasurement',
                 'haElectricalMeasurement', 'seMetering', 'manuSpecificSinope'];
-
             await reporting.bind(endpoint, coordinatorEndpoint, binds);
             await reporting.thermostatTemperature(endpoint);
             await reporting.thermostatPIHeatingDemand(endpoint);
@@ -72,7 +72,7 @@ module.exports = [
         description: 'Zigbee line volt thermostat',
         meta: {thermostat: {dontMapPIHeatingDemand: true}},
         fromZigbee: [fz.legacy.sinope_thermostat_att_report, fz.legacy.hvac_user_interface, fz.electrical_measurement, fz.metering,
-            fz.ignore_temperature_report, fz.legacy.sinope_thermostat_state],
+            fz.ignore_temperature_report, fz.legacy.sinope_thermostat_state, fz.sinope_thermostat],
         toZigbee: [tz.thermostat_local_temperature, tz.thermostat_occupied_heating_setpoint, tz.thermostat_unoccupied_heating_setpoint,
             tz.thermostat_temperature_display_mode, tz.thermostat_keypad_lockout, tz.thermostat_system_mode, tz.thermostat_running_state,
             tz.sinope_thermostat_occupancy, tz.sinope_thermostat_backlight_autodim_param, tz.sinope_thermostat_time,
@@ -80,6 +80,7 @@ module.exports = [
         exposes: [e.local_temperature(), e.keypad_lockout(), e.power(), e.current(), e.voltage(), e.energy(),
             exposes.climate().withSetpoint('occupied_heating_setpoint', 5, 30, 0.5).withLocalTemperature()
                 .withSystemMode(['off', 'heat']).withRunningState(['idle', 'heat']).withPiHeatingDemand(),
+            exposes.enum('thermostat_occupancy', ea.SET, ['unoccupied', 'occupied']).withDescription('Occupancy state of the thermostat'),
             exposes.enum('backlight_auto_dim', ea.SET, ['on demand', 'sensing']).withDescription('Control backlight dimming behavior')],
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);

package/devices/sunricher.js

@@ -465,7 +465,7 @@ module.exports = [
             await reporting.thermostatKeypadLockMode(endpoint);
 
             await endpoint.configureReporting('hvacThermostat', [{
-                attribute: 'ocupancy',
+                attribute: 'occupancy',
                 minimumReportInterval: 0,
                 maximumReportInterval: constants.repInterval.HOUR,
                 reportableChange: null,

package/devices/tuya.js

@@ -22,7 +22,7 @@ const TS011Fplugs = ['_TZ3000_5f43h46b', '_TZ3000_cphmq0q7', '_TZ3000_dpo1ysak',
     '_TZ3000_zloso4jk', '_TZ3000_r6buo8ba', '_TZ3000_iksasdbv', '_TZ3000_idrffznf', '_TZ3000_okaz9tjs', '_TZ3210_q7oryllx',
     '_TZ3000_ss98ec5d', '_TZ3000_gznh2xla', '_TZ3000_hdopuwv6', '_TZ3000_gvn91tmx', '_TZ3000_dksbtrzs', '_TZ3000_b28wrpvx',
     '_TZ3000_aim0ztek', '_TZ3000_mlswgkc3', '_TZ3000_7dndcnnb', '_TZ3000_waho4jtj', '_TZ3000_nmsciidq', '_TZ3000_jtgxgmks',
-    '_TZ3000_rdfh8cfs', '_TZ3000_yujkchbz', '_TZ3000_fgwhjm9j'];
+    '_TZ3000_rdfh8cfs', '_TZ3000_yujkchbz', '_TZ3000_fgwhjm9j', '_TZ3000_qeuvnohg'];
 
 const tzLocal = {
     SA12IZL_silence_siren: {
@@ -1768,12 +1768,13 @@ module.exports = [
         exposes: [e.battery(), e.water_leak()],
     },
     {
-        fingerprint: tuya.fingerprint('TS0001', ['_TZ3000_xkap8wtb', '_TZ3000_qnejhcsu', '_TZ3000_x3ewpzyr']),
+        fingerprint: tuya.fingerprint('TS0001', ['_TZ3000_xkap8wtb', '_TZ3000_qnejhcsu', '_TZ3000_x3ewpzyr', '_TZ3000_mkhkxx1p']),
         model: 'TS0001_power',
         description: 'Switch with power monitoring',
         vendor: 'TuYa',
-        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],
+        fromZigbee: [fz.on_off, fz.electrical_measurement, fz.metering, fz.ignore_basic_report,
+            fz.tuya_switch_power_outage_memory, fz.tuya_switch_type],
+        toZigbee: [tz.on_off, tz.tuya_switch_power_outage_memory, tz.tuya_switch_type],
         configure: async (device, coordinatorEndpoint, logger) => {
             await tuya.configureMagicPacket(device, coordinatorEndpoint, logger);
             const endpoint = device.getEndpoint(1);
@@ -1786,7 +1787,7 @@ module.exports = [
             endpoint.saveClusterAttributeKeyValue('seMetering', {divisor: 100, multiplier: 1});
             device.save();
         },
-        exposes: [e.switch(), e.power(), e.current(), e.voltage().withAccess(ea.STATE), e.energy(),
+        exposes: [e.switch(), e.power(), e.current(), e.voltage().withAccess(ea.STATE), e.energy(), e.switch_type_2(),
             exposes.enum('power_outage_memory', ea.ALL, ['on', 'off', 'restore']).withDescription('Recover state after power outage')],
     },
     {
@@ -2117,19 +2118,21 @@ module.exports = [
         exposes: [
             e.battery_low(), e.child_lock(), e.open_window(), e.open_window_temperature().withValueMin(5).withValueMax(30),
             e.comfort_temperature().withValueMin(5).withValueMax(30), e.eco_temperature().withValueMin(5).withValueMax(30),
-            exposes.climate().withSystemMode(['off', 'heat'], ea.STATE_SET, 'When switched to the "off" mode, the device will display ' +
-                '"HS" and the valve will be fully closed. Press the pair button to cancel or switch back to "heat" mode. Battery life ' +
-                'can be prolonged by switching the heating off. After switching to `heat` mode, `preset` will be reset to `auto` and ' +
-                'after changing `preset` to `manual` temperature setpoint will be 20 degrees.').withPreset(['auto', 'manual', 'holiday'],
-                '`auto` uses schedule properties, check them. `manual` allows you to control the device, `holiday` uses ' +
-                '`holiday_start_stop` and `holiday_temperature` properties.').withLocalTemperatureCalibration(-5, 5, 0.1, ea.STATE_SET)
-                .withLocalTemperature(ea.STATE).withSetpoint('current_heating_setpoint', 5, 30, 0.5, ea.STATE_SET),
+            tuya.exposes.errorStatus(), tuya.exposes.frostProtection('The device display "AF", press the pair button to cancel.'),
+            exposes.climate()
+                .withSystemMode(['off', 'heat'], ea.STATE_SET, 'When switched to the "off" mode, the device will display ' +
+                    '"HS" and the valve will be fully closed. Press the pair button to cancel or switch back to "heat" mode. Battery life' +
+                    ' can be prolonged by switching the heating off. After switching to `heat` mode, `preset` will be reset to `auto` and' +
+                    ' after changing `preset` to `manual` temperature setpoint will be 20 degrees.')
+                .withPreset(['auto', 'manual', 'holiday'],
+                    '`auto` uses schedule properties, check them. `manual` allows you to control the device, `holiday` uses ' +
+                    '`holiday_start_stop` and `holiday_temperature` properties.')
+                .withLocalTemperatureCalibration(-5, 5, 0.1, ea.STATE_SET)
+                .withLocalTemperature(ea.STATE)
+                .withSetpoint('current_heating_setpoint', 5, 30, 0.5, ea.STATE_SET),
             exposes.numeric('boost_timeset_countdown', ea.STATE_SET).withUnit('second').withDescription('Setting '+
                     'minimum 0 - maximum 465 seconds boost time. The boost (♨) function is activated. The remaining '+
                     'time for the function will be counted down in seconds ( 465 to 0 ).').withValueMin(0).withValueMax(465),
-            exposes.binary('frost_protection', ea.STATE_SET, 'ON', 'OFF').withDescription('When Anti-Freezing function'+
-                    ' is activated, the temperature in the house is kept at 8 °C, the device display "AF".press the '+
-                    'pair button to cancel.'),
             exposes.binary('heating_stop', ea.STATE_SET, 'ON', 'OFF').withDescription('Same as `system_mode`. Left for compatibility.'),
             exposes.numeric('holiday_temperature', ea.STATE_SET).withUnit('°C').withDescription('Holiday temperature')
                 .withValueMin(5).withValueMax(30),
@@ -2153,17 +2156,10 @@ module.exports = [
                 '18:40/24 22:50/19.5`; `06:00/21.5 17:20/26 24:00/18`. The temperature will be set from the beginning/start of one ' +
                 'period and until the next period, e.g., `04:00/20 24:00/22` means that from 00:00 to 04:00 temperature will be 20 ' +
                 'degrees and from 04:00 to 00:00 temperature will be 22 degrees.'),
-            exposes.text('schedule_monday', ea.STATE),
-            exposes.text('schedule_tuesday', ea.STATE),
-            exposes.text('schedule_wednesday', ea.STATE),
-            exposes.text('schedule_thursday', ea.STATE),
-            exposes.text('schedule_friday', ea.STATE),
-            exposes.text('schedule_saturday', ea.STATE),
-            exposes.text('schedule_sunday', ea.STATE),
+            ...tuya.exposes.scheduleAllDays(ea.STATE, 'HH:MM/C'),
             exposes.binary('online', ea.STATE_SET, 'ON', 'OFF').withDescription('Turn on this property to poll current data from the ' +
                 'device. It can be used to periodically fetch a new local temperature since the device doesn\'t update itself. ' +
                 'Setting this property doesn\'t turn on the display.'),
-            exposes.numeric('error_status', ea.STATE).withDescription('Error status'),
         ],
         meta: {
             tuyaDatapoints: [
@@ -2184,20 +2180,67 @@ module.exports = [
                 [102, 'open_window_temperature', tuya.valueConverter.divideBy10],
                 [104, 'comfort_temperature', tuya.valueConverter.divideBy10],
                 [105, 'eco_temperature', tuya.valueConverter.divideBy10],
-                [106, 'schedule', tuya.valueConverter.thermostatScheduleDay],
+                [106, 'schedule', tuya.valueConverter.thermostatScheduleDaySingleDP],
                 [107, null, tuya.valueConverter.TV02SystemMode],
                 [107, 'system_mode', tuya.valueConverterBasic.lookup({'heat': false, 'off': true})],
                 [107, 'heating_stop', tuya.valueConverter.onOff],
                 [115, 'online', tuya.valueConverter.onOffNotStrict],
-                [108, 'schedule_monday', tuya.valueConverter.thermostatScheduleDay],
-                [112, 'schedule_tuesday', tuya.valueConverter.thermostatScheduleDay],
-                [109, 'schedule_wednesday', tuya.valueConverter.thermostatScheduleDay],
-                [113, 'schedule_thursday', tuya.valueConverter.thermostatScheduleDay],
-                [110, 'schedule_friday', tuya.valueConverter.thermostatScheduleDay],
-                [114, 'schedule_saturday', tuya.valueConverter.thermostatScheduleDay],
-                [111, 'schedule_sunday', tuya.valueConverter.thermostatScheduleDay],
+                [108, 'schedule_monday', tuya.valueConverter.thermostatScheduleDaySingleDP],
+                [112, 'schedule_tuesday', tuya.valueConverter.thermostatScheduleDaySingleDP],
+                [109, 'schedule_wednesday', tuya.valueConverter.thermostatScheduleDaySingleDP],
+                [113, 'schedule_thursday', tuya.valueConverter.thermostatScheduleDaySingleDP],
+                [110, 'schedule_friday', tuya.valueConverter.thermostatScheduleDaySingleDP],
+                [114, 'schedule_saturday', tuya.valueConverter.thermostatScheduleDaySingleDP],
+                [111, 'schedule_sunday', tuya.valueConverter.thermostatScheduleDaySingleDP],
+            ],
+        },
+    },
+    {
+        fingerprint: tuya.fingerprint('TS0601', [
+            '_TZE200_0hg58wyk', /* model: 'S366', vendor: 'Cloud Even' */
+        ]),
+        model: 'TS0601_thermostat_2',
+        vendor: 'TuYa',
+        description: 'Thermostat radiator valve',
+        whiteLabel: [
+            {vendor: 'S366', model: 'Cloud Even'},
+        ],
+        fromZigbee: [tuya.fzDataPoints],
+        toZigbee: [tuya.tzDataPoints],
+        onEvent: tuya.onEventSetLocalTime,
+        configure: tuya.configureMagicPacket,
+        meta: {
+            tuyaDatapoints: [
+                [1, 'system_mode', tuya.valueConverterBasic.lookup({'heat': true, 'off': false})],
+                [2, 'preset', tuya.valueConverterBasic.lookup({'manual': tuya.enum(0), 'holiday': tuya.enum(1), 'program': tuya.enum(2)})],
+                [3, null, null], // TODO: Unknown DP
+                [8, 'open_window', tuya.valueConverter.onOff],
+                [10, 'frost_protection', tuya.valueConverter.onOff],
+                [16, 'current_heating_setpoint', tuya.valueConverter.divideBy10],
+                [24, 'local_temperature', tuya.valueConverter.divideBy10],
+                [27, 'local_temperature_calibration', tuya.valueConverter.localTempCalibration],
+                [35, 'battery_low', tuya.valueConverter.true0ElseFalse],
+                [40, 'child_lock', tuya.valueConverter.lockUnlock],
+                [45, 'error_status', tuya.valueConverter.raw],
+                [101, 'schedule_monday', tuya.valueConverter.thermostatScheduleDayMultiDP],
+                [102, 'schedule_tuesday', tuya.valueConverter.thermostatScheduleDayMultiDP],
+                [103, 'schedule_wednesday', tuya.valueConverter.thermostatScheduleDayMultiDP],
+                [104, 'schedule_thursday', tuya.valueConverter.thermostatScheduleDayMultiDP],
+                [105, 'schedule_friday', tuya.valueConverter.thermostatScheduleDayMultiDP],
+                [106, 'schedule_saturday', tuya.valueConverter.thermostatScheduleDayMultiDP],
+                [107, 'schedule_sunday', tuya.valueConverter.thermostatScheduleDayMultiDP],
             ],
         },
+        exposes: [
+            e.battery_low(), e.child_lock(), e.open_window(), tuya.exposes.frostProtection(), tuya.exposes.errorStatus(),
+            exposes.climate()
+                .withSystemMode(['off', 'heat'], ea.STATE_SET)
+                .withPreset(['manual', 'holiday', 'program'])
+                .withLocalTemperatureCalibration(-5, 5, 0.1, ea.STATE_SET)
+                .withLocalTemperature(ea.STATE)
+                .withSetpoint('current_heating_setpoint', 5, 30, 0.5, ea.STATE_SET),
+            ...tuya.exposes.scheduleAllDays(ea.STATE_SET, 'HH:MM/C HH:MM/C HH:MM/C HH:MM/C'),
+        ],
     },
     {
         fingerprint: [
@@ -2467,7 +2510,7 @@ module.exports = [
         onEvent: tuya.onEventsetTime,
     },
     {
-        fingerprint: tuya.fingerprint('TS0601', ['_TZE200_lsanae15', '_TZE200_bkkmqmyo', '_TZE200_eaac7dkw']),
+        fingerprint: tuya.fingerprint('TS0601', ['_TZE200_bkkmqmyo', '_TZE200_eaac7dkw']),
         model: 'TS0601_din_1',
         vendor: 'TuYa',
         description: 'Zigbee DIN energy meter',
@@ -2479,7 +2522,7 @@ module.exports = [
         meta: {
             tuyaDatapoints: [
                 [1, 'energy', tuya.valueConverter.divideBy100],
-                [6, null, tuya.valueConverter.phaseA], // voltage and current
+                [6, null, tuya.valueConverter.phaseVariant1], // voltage and current
                 [16, 'state', tuya.valueConverter.onOff],
                 [102, 'produced_energy', tuya.valueConverter.divideBy100],
                 [103, 'power', tuya.valueConverter.raw],
@@ -2496,6 +2539,54 @@ module.exports = [
         },
         whiteLabel: [{vendor: 'Hiking', model: 'DDS238-2'}, {vendor: 'TuYa', model: 'RC-MCB'}],
     },
+    {
+        fingerprint: tuya.fingerprint('TS0601', ['_TZE200_lsanae15']),
+        model: 'TS0601_din_2',
+        vendor: 'TuYa',
+        description: 'Zigbee DIN energy meter',
+        fromZigbee: [tuya.fzDataPoints],
+        toZigbee: [tuya.tzDataPoints],
+        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)'),
+            exposes.enum('threshold_1', ea.STATE, ['not_set', 'over_current_threshold', 'over_voltage_threshold'])
+                .withDescription('State of threshold_1'),
+            exposes.binary('threshold_1_protection', ea.STATE, 'ON', 'OFF')
+                .withDescription('OFF - alarm only, ON - relay will be off when threshold reached'),
+            exposes.numeric('threshold_1_value', ea.STATE)
+                .withDescription('Can be in Volt or Ampere depending on threshold setting. Setup the value on the device'),
+            exposes.enum('threshold_2', ea.STATE, ['not_set', 'over_current_threshold', 'over_voltage_threshold'])
+                .withDescription('State of threshold_2'),
+            exposes.binary('threshold_2_protection', ea.STATE, 'ON', 'OFF')
+                .withDescription('OFF - alarm only, ON - relay will be off when threshold reached'),
+            exposes.numeric('threshold_2_value', ea.STATE)
+                .withDescription('Setup value on the device'),
+            exposes.binary('clear_fault', ea.STATE_SET, 'ON', 'OFF')
+                .withDescription('Turn ON to clear last the fault'),
+            exposes.text('meter_id', ea.STATE).withDescription('Meter ID (ID of device)'),
+        ],
+        meta: {
+            tuyaDatapoints: [
+                [1, 'energy', tuya.valueConverter.divideBy100],
+                [3, null, null], // Monthly, but sends data only after request
+                [4, null, null], // Dayly, but sends data only after request
+                [6, null, tuya.valueConverter.phaseVariant2], // voltage and current
+                [10, 'fault', tuya.valueConverterBasic.lookup({'clear': 0, 'over_current_threshold': 1,
+                    'over_power_threshold': 2, 'over_voltage_threshold': 4, 'wrong_frequency_threshold': 8})],
+                [11, null, null], // Frozen - strange function, in native app - nothing is clear
+                [16, 'state', tuya.valueConverter.onOff],
+                [17, null, tuya.valueConverter.threshold], // It's settable, but can't write converter
+                [18, 'meter_id', tuya.valueConverter.raw],
+                [20, 'clear_fault', tuya.valueConverter.onOff], // Clear fault
+                [21, null, null], // Forward Energy T1 - don't know what this
+                [22, null, null], // Forward Energy T2 - don't know what this
+                [23, null, null], // Forward Energy T3 - don't know what this
+                [24, null, null], // Forward Energy T4 - don't know what this
+            ],
+        },
+    },
     {
         fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_byzdayie'},
             {modelID: 'TS0601', manufacturerName: '_TZE200_fsb6zw01'},
@@ -3015,8 +3106,7 @@ module.exports = [
     },
     {
         fingerprint: [{modelID: 'TS011F', manufacturerName: '_TZ3000_8bxrzyxz'},
-            {modelID: 'TS011F', manufacturerName: '_TZ3000_ky0fq4ho'},
-            {modelID: 'TS011F', manufacturerName: '_TZ3000_qeuvnohg'}],
+            {modelID: 'TS011F', manufacturerName: '_TZ3000_ky0fq4ho'}],
         model: 'TS011F_din_smart_relay',
         description: 'Din smart relay (with power monitoring)',
         vendor: 'TuYa',

package/devices/ubisys.js

@@ -80,10 +80,10 @@ const ubisys = {
             type: ['attributeReport', 'readResponse'],
             convert: (model, msg, publish, options, meta) => {
                 const result = {};
-                if (msg.data.hasOwnProperty('input_configurations')) {
-                    result['input_configurations'] = msg.data['input_configurations'];
+                if (msg.data['inputConfigurations'] != null) {
+                    result['input_configurations'] = msg.data['inputConfigurations'];
                 }
-                if (msg.data.hasOwnProperty('inputActions')) {
+                if (msg.data['inputActions'] != null) {
                     result['input_actions'] = msg.data['inputActions'].map(function(el) {
                         return Object.values(el);
                     });
@@ -95,8 +95,8 @@ const ubisys = {
             cluster: 'hvacThermostat',
             type: ['attributeReport', 'readResponse'],
             convert: (model, msg, publish, options, meta) => {
-                if (msg.data.hasOwnProperty('ocupancy')) {
-                    return {vacation_mode: msg.data.ocupancy === 0};
+                if (msg.data.hasOwnProperty('occupancy')) {
+                    return {vacation_mode: msg.data.occupancy === 0};
                 }
             },
         },
@@ -516,7 +516,7 @@ const ubisys = {
         thermostat_vacation_mode: {
             key: ['vacation_mode'],
             convertGet: async (entity, key, meta) => {
-                await entity.read('hvacThermostat', ['ocupancy']);
+                await entity.read('hvacThermostat', ['occupancy']);
             },
         },
     },

package/devices/villeroy_boch.js

@@ -2,7 +2,7 @@ const extend = require('../lib/extend');
 
 module.exports = [
     {
-        zigbeeModel: ['5991711'],
+        zigbeeModel: ['5991711', '5991713'],
         model: 'C5850000',
         vendor: 'Villeroy & Boch',
         description: 'Subway 3.0 Zigbee home automation kit',

package/lib/extend.js

@@ -12,11 +12,13 @@ const extend = {
         return {exposes, fromZigbee, toZigbee};
     },
     light_onoff_brightness: (options={}) => {
-        options = {disableEffect: false, disablePowerOnBehavior: false, ...options};
+        options = {disableEffect: false, disablePowerOnBehavior: false, disableMoveStep: false, disableTransition: false, ...options};
         const exposes = [e.light_brightness(), ...(!options.disableEffect ? [e.effect()] : [])];
         const fromZigbee = [fz.on_off, fz.brightness, fz.level_config, fz.ignore_basic_report];
-        const toZigbee = [tz.light_onoff_brightness, tz.ignore_transition, tz.ignore_rate, tz.light_brightness_move,
-            tz.light_brightness_step, tz.level_config, ...(!options.disableEffect ? [tz.effect] : [])];
+        const toZigbee = [tz.light_onoff_brightness, tz.ignore_rate, tz.level_config,
+            ...(!options.disableTransition ? [tz.ignore_transition] : []),
+            ...(!options.disableEffect ? [tz.effect] : []),
+            ...(!options.disableMoveStep ? [tz.light_brightness_move, tz.light_brightness_step] : [])];
 
         if (!options.disablePowerOnBehavior) {
             exposes.push(e.power_on_behavior(['off', 'on', 'toggle', 'previous']));

package/lib/reporting.js

@@ -179,7 +179,7 @@ module.exports = {
         await endpoint.configureReporting('hvacThermostat', p);
     },
     thermostatOcupancy: async (endpoint, overrides) => {
-        const p = payload('ocupancy', 0, repInterval.HOUR, 0, overrides);
+        const p = payload('occupancy', 0, repInterval.HOUR, 0, overrides);
         await endpoint.configureReporting('hvacThermostat', p);
     },
     thermostatTemperatureSetpointHold: async (endpoint, overrides) => {

package/lib/tuya.js

@@ -1165,6 +1165,11 @@ const tuyaExposes = {
         .withDescription('Result of the self-test'),
     faultAlarm: () => exposes.binary('fault_alarm', ea.STATE, true, false).withDescription('Indicates whether a fault was detected'),
     silence: () => exposes.binary('silence', ea.STATE_SET, true, false).withDescription('Silence the alarm'),
+    frostProtection: (extraNote='') => exposes.binary('frost_protection', ea.STATE_SET, 'ON', 'OFF').withDescription(
+        `When Anti-Freezing function is activated, the temperature in the house is kept at 8 °C.${extraNote}`),
+    errorStatus: () => exposes.numeric('error_status', ea.STATE).withDescription('Error status'),
+    scheduleAllDays: (access, format) => ['monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday']
+        .map((day) => exposes.text(`schedule_${day}`, access).withDescription(`Schedule for ${day}, format: "${format}"`)),
 };
 
 const skip = {
@@ -1252,12 +1257,33 @@ const valueConverter = {
     divideBy100: valueConverterBasic.divideBy(100),
     divideBy10: valueConverterBasic.divideBy(10),
     raw: valueConverterBasic.raw(),
-    phaseA: {
+    phaseVariant1: {
         from: (v) => {
             const buffer = Buffer.from(v, 'base64');
             return {voltage: (buffer[14] | buffer[13] << 8) / 10, current: (buffer[12] | buffer[11] << 8) / 1000};
         },
     },
+    phaseVariant2: {
+        from: (v) => {
+            const buf = Buffer.from(v, 'base64');
+            return {voltage: (buf[1] | buf[0] << 8) / 10, current: (buf[4] | buf[3] << 8) / 1000, power: (buf[7] | buf[6] << 8)};
+        },
+    },
+    threshold: {
+        from: (v) => {
+            const buffer = Buffer.from(v, 'base64');
+            const stateLookup = {0: 'not_set', 1: 'over_current_threshold', 3: 'over_voltage_threshold'};
+            const protectionLookup = {0: 'OFF', 1: 'ON'};
+            return {
+                threshold_1_protection: protectionLookup[buffer[1]],
+                threshold_1: stateLookup[buffer[0]],
+                threshold_1_value: (buffer[3] | buffer[2] << 8),
+                threshold_2_protection: protectionLookup[buffer[5]],
+                threshold_2: stateLookup[buffer[4]],
+                threshold_2_value: (buffer[7] | buffer[6] << 8),
+            };
+        },
+    },
     true0ElseFalse: {from: (v) => v === 0},
     selfTestResult: valueConverterBasic.lookup({'checking': 0, 'success': 1, 'failure': 2, 'others': 3}),
     lockUnlock: valueConverterBasic.lookup({'LOCK': true, 'UNLOCK': false}),
@@ -1291,7 +1317,7 @@ const valueConverter = {
             return v.match(numberPattern).join([]).toString();
         },
     },
-    thermostatScheduleDay: {
+    thermostatScheduleDaySingleDP: {
         from: (v) => {
             // day splitted to 10 min segments = total 144 segments
             const maxPeriodsInDay = 10;
@@ -1381,6 +1407,46 @@ const valueConverter = {
             return payload;
         },
     },
+    thermostatScheduleDayMultiDP: {
+        from: (v) => {
+            const schedule = [];
+            for (let index = 1; index < 17; index = index + 4) {
+                schedule.push(
+                    String(parseInt(v[index+0])).padStart(2, '0') + ':' +
+                    String(parseInt(v[index+1])).padStart(2, '0') + '/' +
+                    (parseFloat((v[index+2] << 8) + v[index+3]) / 10.0).toFixed(1),
+                );
+            }
+            return schedule.join(' ');
+        },
+        to: (v) => {
+            const payload = [0];
+            const transitions = v.split(' ');
+            if (transitions.length != 4) {
+                throw new Error('Invalid schedule: there should be 4 transitions');
+            }
+            for (const transition of transitions) {
+                const timeTemp = transition.split('/');
+                if (timeTemp.length != 2) {
+                    throw new Error('Invalid schedule: wrong transition format: ' + transition);
+                }
+                const hourMin = timeTemp[0].split(':');
+                const hour = hourMin[0];
+                const min = hourMin[1];
+                const temperature = Math.floor(timeTemp[1] *10);
+                if (hour < 0 || hour > 24 || min < 0 || min > 60 || temperature < 50 || temperature > 300) {
+                    throw new Error('Invalid hour, minute or temperature of: ' + transition);
+                }
+                payload.push(
+                    hour,
+                    min,
+                    (temperature & 0xff00) >> 8,
+                    temperature & 0xff,
+                );
+            }
+            return payload;
+        },
+    },
     TV02SystemMode: {
         from: (v) => {
             return {system_mode: v === false ? 'heat' : 'off', heating_stop: v === false ? 'OFF' : 'ON'};
@@ -1395,7 +1461,8 @@ const tzDataPoints = {
         'countdown', 'light_type', 'silence', 'self_test', 'child_lock', 'open_window', 'open_window_temperature', 'frost_protection',
         'system_mode', 'heating_stop', 'current_heating_setpoint', 'local_temperature_calibration', 'preset', 'boost_timeset_countdown',
         'holiday_start_stop', 'holiday_temperature', 'comfort_temperature', 'eco_temperature', 'working_day', 'week_schedule_programming',
-        'online', 'holiday_mode_date', 'schedule',
+        'online', 'holiday_mode_date', 'schedule', 'schedule_monday', 'schedule_tuesday', 'schedule_wednesday', 'schedule_thursday',
+        'schedule_friday', 'schedule_saturday', 'schedule_sunday', 'clear_fault',
     ],
     convertSet: async (entity, key, value, meta) => {
         // A set converter is only called once; therefore we need to loop

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zigbee-herdsman-converters",
-  "version": "14.0.666",
+  "version": "14.0.668",
   "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.68"
+    "zigbee-herdsman": "^0.14.71"
   },
   "devDependencies": {
     "eslint": "*",