zigbee-herdsman-converters 14.0.569 → 14.0.570

package/converters/fromZigbee.js

@@ -3597,10 +3597,13 @@ const converters = {
                         msg.data['danfossRoomStatusCode'];
             }
             if (msg.data.hasOwnProperty('danfossOutputStatus')) {
-                result[postfixWithEndpointName('output_status', msg, model)] =
-                    constants.danfossOutputStatus.hasOwnProperty(msg.data['danfossOutputStatus']) ?
-                        constants.danfossOutputStatus[msg.data['danfossOutputStatus']] :
-                        msg.data['danfossOutputStatus'];
+                if (msg.data['danfossOutputStatus'] === 1) {
+                    result[postfixWithEndpointName('output_status', msg, model)] = 'active';
+                    result[postfixWithEndpointName('running_state', msg, model)] = 'heat';
+                } else {
+                    result[postfixWithEndpointName('output_status', msg, model)] = 'inactive';
+                    result[postfixWithEndpointName('running_state', msg, model)] = 'idle';
+                }
             }
             return result;
         },
@@ -4028,6 +4031,8 @@ const converters = {
                 default:
                     return {sensor: 'not_supported'};
                 }
+            case tuya.dataPoints.bacFanMode:
+                return {fan_mode: tuya.fanModes[value]};
             default: // DataPoint 17 is unknown
                 meta.logger.warn(`zigbee-herdsman-converters:Moes BHT-002: Unrecognized DP #${
                     dp} with data ${JSON.stringify(dpValue)}`);

package/converters/toZigbee.js

@@ -4807,6 +4807,17 @@ const converters = {
             }
         },
     },
+    tuya_thermostat_bac_fan_mode: {
+        key: ['fan_mode'],
+        convertSet: async (entity, key, value, meta) => {
+            const modeId = utils.getKey(tuya.fanModes, value, null, Number);
+            if (modeId !== null) {
+                await tuya.sendDataPointEnum(entity, tuya.dataPoints.bacFanMode, parseInt(modeId));
+            } else {
+                throw new Error(`TRV fan mode ${value} is not recognized.`);
+            }
+        },
+    },
     tuya_thermostat_auto_lock: {
         key: ['auto_lock'],
         convertSet: async (entity, key, value, meta) => {

package/devices/custom_devices_diy.js

@@ -36,7 +36,7 @@ const tzLocal = {
     },
     co2_config: {
         key: ['auto_brightness', 'forced_recalibration', 'factory_reset_co2', 'long_chart_period', 'set_altitude',
-            'manual_forced_recalibration'],
+            'manual_forced_recalibration', 'light_indicator', 'light_indicator_level'],
         convertSet: async (entity, key, rawValue, meta) => {
             const lookup = {'OFF': 0x00, 'ON': 0x01};
             const value = lookup.hasOwnProperty(rawValue) ? lookup[rawValue] : parseInt(rawValue, 10);
@@ -47,6 +47,8 @@ const tzLocal = {
                 long_chart_period: ['msCO2', {0x0204: {value, type: 0x10}}],
                 set_altitude: ['msCO2', {0x0205: {value, type: 0x21}}],
                 manual_forced_recalibration: ['msCO2', {0x0207: {value, type: 0x21}}],
+                light_indicator: ['msCO2', {0x0211: {value, type: 0x10}}],
+                light_indicator_level: ['msCO2', {0x0209: {value, type: 0x20}}],
             };
             await entity.write(payloads[key][0], payloads[key][1]);
             return {
@@ -80,6 +82,54 @@ const tzLocal = {
             };
         },
     },
+    termostat_config: {
+        key: ['high_temperature', 'low_temperature', 'enable_temperature'],
+        convertSet: async (entity, key, rawValue, meta) => {
+            const lookup = {'OFF': 0x00, 'ON': 0x01};
+            const value = lookup.hasOwnProperty(rawValue) ? lookup[rawValue] : parseInt(rawValue, 10);
+            const payloads = {
+                high_temperature: ['msTemperatureMeasurement', {0x0221: {value, type: 0x29}}],
+                low_temperature: ['msTemperatureMeasurement', {0x0222: {value, type: 0x29}}],
+                enable_temperature: ['msTemperatureMeasurement', {0x0220: {value, type: 0x10}}],
+            };
+            await entity.write(payloads[key][0], payloads[key][1]);
+            return {
+                state: {[key]: rawValue},
+            };
+        },
+    },
+    hydrostat_config: {
+        key: ['high_humidity', 'low_humidity', 'enable_humidity'],
+        convertSet: async (entity, key, rawValue, meta) => {
+            const lookup = {'OFF': 0x00, 'ON': 0x01};
+            const value = lookup.hasOwnProperty(rawValue) ? lookup[rawValue] : parseInt(rawValue, 10);
+            const payloads = {
+                high_humidity: ['msRelativeHumidity', {0x0221: {value, type: 0x21}}],
+                low_humidity: ['msRelativeHumidity', {0x0222: {value, type: 0x21}}],
+                enable_humidity: ['msRelativeHumidity', {0x0220: {value, type: 0x10}}],
+            };
+            await entity.write(payloads[key][0], payloads[key][1]);
+            return {
+                state: {[key]: rawValue},
+            };
+        },
+    },
+    co2_gasstat_config: {
+        key: ['high_gas', 'low_gas', 'enable_gas'],
+        convertSet: async (entity, key, rawValue, meta) => {
+            const lookup = {'OFF': 0x00, 'ON': 0x01};
+            const value = lookup.hasOwnProperty(rawValue) ? lookup[rawValue] : parseInt(rawValue, 10);
+            const payloads = {
+                high_gas: ['msCO2', {0x0221: {value, type: 0x21}}],
+                low_gas: ['msCO2', {0x0222: {value, type: 0x21}}],
+                enable_gas: ['msCO2', {0x0220: {value, type: 0x10}}],
+            };
+            await entity.write(payloads[key][0], payloads[key][1]);
+            return {
+                state: {[key]: rawValue},
+            };
+        },
+    },
 };
 
 const fzLocal = {
@@ -127,6 +177,12 @@ const fzLocal = {
             if (msg.data.hasOwnProperty(0x0207)) {
                 result.manual_forced_recalibration = msg.data[0x0207];
             }
+            if (msg.data.hasOwnProperty(0x0211)) {
+                result.light_indicator = ['OFF', 'ON'][msg.data[0x0211]];
+            }
+            if (msg.data.hasOwnProperty(0x0209)) {
+                result.light_indicator_level = msg.data[0x0209];
+            }
             return result;
         },
     },
@@ -152,6 +208,57 @@ const fzLocal = {
             return result;
         },
     },
+    termostat_config: {
+        cluster: 'msTemperatureMeasurement',
+        type: ['attributeReport', 'readResponse'],
+        convert: (model, msg, publish, options, meta) => {
+            const result = {};
+            if (msg.data.hasOwnProperty(0x0221)) {
+                result.high_temperature = msg.data[0x0221];
+            }
+            if (msg.data.hasOwnProperty(0x0222)) {
+                result.low_temperature = msg.data[0x0222];
+            }
+            if (msg.data.hasOwnProperty(0x0220)) {
+                result.enable_temperature = ['OFF', 'ON'][msg.data[0x0220]];
+            }
+            return result;
+        },
+    },
+    hydrostat_config: {
+        cluster: 'msRelativeHumidity',
+        type: ['attributeReport', 'readResponse'],
+        convert: (model, msg, publish, options, meta) => {
+            const result = {};
+            if (msg.data.hasOwnProperty(0x0221)) {
+                result.high_humidity = msg.data[0x0221];
+            }
+            if (msg.data.hasOwnProperty(0x0222)) {
+                result.low_humidity = msg.data[0x0222];
+            }
+            if (msg.data.hasOwnProperty(0x0220)) {
+                result.enable_humidity = ['OFF', 'ON'][msg.data[0x0220]];
+            }
+            return result;
+        },
+    },
+    co2_gasstat_config: {
+        cluster: 'msCO2',
+        type: ['attributeReport', 'readResponse'],
+        convert: (model, msg, publish, options, meta) => {
+            const result = {};
+            if (msg.data.hasOwnProperty(0x0221)) {
+                result.high_gas = msg.data[0x0221];
+            }
+            if (msg.data.hasOwnProperty(0x0222)) {
+                result.low_gas = msg.data[0x0222];
+            }
+            if (msg.data.hasOwnProperty(0x0220)) {
+                result.enable_gas = ['OFF', 'ON'][msg.data[0x0220]];
+            }
+            return result;
+        },
+    },
 };
 
 module.exports = [
@@ -621,4 +728,56 @@ module.exports = [
                 .withDescription('Start Manual FRC (Perform Forced Recalibration of the CO2 Sensor)')
                 .withValueMin(0).withValueMax(5000)],
     },
+    {
+        zigbeeModel: ['EFEKTA_CO2_Smart_Monitor'],
+        model: 'EFEKTA_CO2_Smart_Monitor',
+        vendor: 'Custom devices (DiY)',
+        description: '[EFEKTA CO2 Smart Monitor, ws2812b indicator, can control the relay, binding](https://efektalab.com/CO2_Monitor)',
+        fromZigbee: [fz.temperature, fz.humidity, fzLocal.co2, fzLocal.co2_config, fzLocal.temperature_config,
+            fzLocal.humidity_config, fzLocal.termostat_config, fzLocal.hydrostat_config, fzLocal.co2_gasstat_config],
+        toZigbee: [tz.factory_reset, tzLocal.co2_config, tzLocal.temperature_config, tzLocal.humidity_config,
+            tzLocal.termostat_config, tzLocal.hydrostat_config, tzLocal.co2_gasstat_config],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            const clusters = ['msTemperatureMeasurement', 'msRelativeHumidity', 'msCO2'];
+            await reporting.bind(endpoint, coordinatorEndpoint, clusters);
+            for (const cluster of clusters) {
+                await endpoint.configureReporting(cluster, [
+                    {attribute: 'measuredValue', minimumReportInterval: 0, maximumReportInterval: 3600, reportableChange: 0},
+                ]);
+            }
+        },
+        exposes: [e.co2(), e.temperature(), e.humidity(),
+            exposes.binary('light_indicator', ea.STATE_SET, 'ON', 'OFF').withDescription('Enable or Disable light_indicator'),
+            exposes.numeric('light_indicator_level', ea.STATE_SET).withUnit('%').withDescription('light_indicator_level')
+                .withValueMin(0).withValueMax(100),
+            exposes.numeric('set_altitude', ea.STATE_SET).withUnit('meters')
+                .withDescription('Setting the altitude above sea level (for high accuracy of the CO2 sensor)')
+                .withValueMin(0).withValueMax(3000),
+            exposes.numeric('temperature_offset', ea.STATE_SET).withUnit('°C').withDescription('Adjust temperature')
+                .withValueMin(-30).withValueMax(60),
+            exposes.numeric('humidity_offset', ea.STATE_SET).withUnit('%').withDescription('Adjust humidity')
+                .withValueMin(0).withValueMax(99),
+            exposes.binary('forced_recalibration', ea.STATE_SET, 'ON', 'OFF')
+                .withDescription('Start FRC (Perform Forced Recalibration of the CO2 Sensor)'),
+            exposes.numeric('manual_forced_recalibration', ea.STATE_SET)
+                .withUnit('ppm').withDescription('Start Manual FRC (Perform Forced Recalibration of the CO2 Sensor)')
+                .withValueMin(0).withValueMax(5000),
+            exposes.binary('factory_reset_co2', ea.STATE_SET, 'ON', 'OFF').withDescription('Factory Reset CO2 sensor'),
+            exposes.binary('enable_gas', ea.STATE_SET, 'ON', 'OFF').withDescription('Enable CO2 Gas Control'),
+            exposes.numeric('high_gas', ea.STATE_SET).withUnit('ppm').withDescription('Setting High CO2 Gas Border')
+                .withValueMin(0).withValueMax(99),
+            exposes.numeric('low_gas', ea.STATE_SET).withUnit('ppm').withDescription('Setting Low CO2 Gas Border')
+                .withValueMin(0).withValueMax(99),
+            exposes.binary('enable_temperature', ea.STATE_SET, 'ON', 'OFF').withDescription('Enable Temperature Control'),
+            exposes.numeric('high_temperature', ea.STATE_SET).withUnit('C').withDescription('Setting High Temperature Border')
+                .withValueMin(-5).withValueMax(50),
+            exposes.numeric('low_temperature', ea.STATE_SET).withUnit('C').withDescription('Setting Low Temperature Border')
+                .withValueMin(-5).withValueMax(50),
+            exposes.binary('enable_humidity', ea.STATE_SET, 'ON', 'OFF').withDescription('Enable Humidity Control'),
+            exposes.numeric('high_humidity', ea.STATE_SET).withUnit('C').withDescription('Setting High Humidity Border')
+                .withValueMin(0).withValueMax(99),
+            exposes.numeric('low_humidity', ea.STATE_SET).withUnit('C').withDescription('Setting Low Humidity Border')
+                .withValueMin(0).withValueMax(99)],
+    },
 ];

package/devices/danfoss.js

@@ -204,6 +204,7 @@ module.exports = [
             tz.thermostat_local_temperature,
             tz.thermostat_occupied_heating_setpoint,
             tz.thermostat_system_mode,
+            tz.thermostat_running_state,
             tz.thermostat_min_heat_setpoint_limit,
             tz.thermostat_max_heat_setpoint_limit,
             tz.danfoss_output_status,
@@ -227,8 +228,8 @@ module.exports = [
                 const epName = `l${i}`;
                 if (i!=16) {
                     features.push(e.battery().withEndpoint(epName));
-                    features.push(exposes.climate().withSetpoint('occupied_heating_setpoint', 4, 30, 0.5)
-                        .withLocalTemperature().withSystemMode(['heat']).withEndpoint(epName));
+                    features.push(exposes.climate().withSetpoint('occupied_heating_setpoint', 5, 35, 0.5)
+                        .withLocalTemperature().withRunningState(['idle', 'heat']).withSystemMode(['heat']).withEndpoint(epName));
                     features.push(exposes.numeric('abs_min_heat_setpoint_limit', ea.STATE)
                         .withUnit('°C').withEndpoint(epName)
                         .withDescription('Absolute min temperature allowed on the device'));
@@ -236,10 +237,10 @@ module.exports = [
                         .withUnit('°C').withEndpoint(epName)
                         .withDescription('Absolute max temperature allowed on the device'));
                     features.push(exposes.numeric('min_heat_setpoint_limit', ea.ALL)
-                        .withValueMin(4).withValueMax(30).withValueStep(0.5).withUnit('°C')
+                        .withValueMin(4).withValueMax(35).withValueStep(0.5).withUnit('°C')
                         .withEndpoint(epName).withDescription('Min temperature limit set on the device'));
                     features.push(exposes.numeric('max_heat_setpoint_limit', ea.ALL)
-                        .withValueMin(4).withValueMax(30).withValueStep(0.5).withUnit('°C')
+                        .withValueMin(4).withValueMax(35).withValueStep(0.5).withUnit('°C')
                         .withEndpoint(epName).withDescription('Max temperature limit set on the device'));
                     features.push(exposes.enum('setpoint_change_source', ea.STATE, ['manual', 'schedule', 'externally'])
                         .withEndpoint(epName));

package/devices/hgkg.js

@@ -11,15 +11,44 @@ module.exports = [
         model: 'BAC-002-ALZB',
         vendor: 'HKGK',
         description: 'BAC series thermostat',
-        fromZigbee: [fz.moes_thermostat],
-        toZigbee: [tz.moes_thermostat_child_lock, tz.moes_thermostat_current_heating_setpoint, tz.moes_thermostat_mode,
-            tz.hgkg_thermostat_standby, tz.moes_thermostat_sensor, tz.moes_thermostat_calibration,
-            tz.moes_thermostat_deadzone_temperature, tz.moes_thermostat_max_temperature_limit],
-        exposes: [e.child_lock(), e.deadzone_temperature(), e.max_temperature_limit(),
-            exposes.climate().withSetpoint('current_heating_setpoint', 5, 30, 1, ea.STATE_SET)
-                .withLocalTemperature(ea.STATE).withLocalTemperatureCalibration(-30, 30, 0.1, ea.STATE_SET)
-                .withSystemMode(['off', 'cool'], ea.STATE_SET).withRunningState(['idle', 'heat', 'cool'], ea.STATE)
-                .withPreset(['hold', 'program']).withSensor(['IN', 'AL', 'OU'], ea.STATE_SET)],
+        fromZigbee: [
+            fz.moes_thermostat,
+            fz.ignore_basic_report,
+            fz.ignore_tuya_set_time,
+        ],
         onEvent: tuya.onEventSetLocalTime,
+        toZigbee: [
+            tz.moes_thermostat_child_lock,
+            tz.moes_thermostat_current_heating_setpoint,
+            tz.moes_thermostat_mode,
+            tz.hgkg_thermostat_standby,
+            tz.moes_thermostat_sensor,
+            tz.moes_thermostat_calibration,
+            tz.tuya_thermostat_schedule,
+            tz.tuya_thermostat_week,
+            tz.tuya_thermostat_schedule_programming_mode,
+            tz.tuya_thermostat_bac_fan_mode,
+        ],
+        exposes: [
+            // e.switch(),
+            e.child_lock(),
+            // e.deadzone_temperature(),
+            exposes.climate()
+                .withSetpoint('current_heating_setpoint', 5, 45, 0.5, ea.STATE_SET)
+                .withLocalTemperature(ea.STATE)
+                .withLocalTemperatureCalibration(-10, 10, 0.1, ea.STATE_SET)
+                .withSystemMode(['off', 'cool'], ea.STATE_SET)
+                // .withRunningState(['off','on'], ea.STATE)
+                .withPreset(['hold', 'program'])
+                .withSensor(['IN', 'AL', 'OU'], ea.STATE_SET)
+                .withFanMode(['off', 'low', 'medium', 'high', 'auto'], ea.STATE_SET),
+            exposes.composite('programming_mode')
+                .withDescription(
+                    'Schedule MODE ⏱ - In this mode, the device executes a preset week programming temperature time and temperature.',
+                )
+                .withFeature(e.week())
+                .withFeature(exposes.text('workdays_schedule', ea.STATE_SET))
+                .withFeature(exposes.text('holidays_schedule', ea.STATE_SET)),
+        ],
     },
 ];

package/devices/osram.js

@@ -75,9 +75,8 @@ module.exports = [
         model: 'AC03645',
         vendor: 'OSRAM',
         description: 'LIGHTIFY LED CLA60 E27 RGBW',
-        extend: extend.ledvance.light_onoff_brightness_colortemp_color({colorTempRange: [153, 526], disableColorTempStartup: true}),
+        extend: extend.ledvance.light_onoff_brightness_colortemp_color({colorTempRange: [153, 526]}),
         ota: ota.ledvance,
-        exposes: [e.light_brightness_colortemp_colorhs([153, 526]).removeFeature('color_temp_startup'), e.effect()],
     },
     {
         zigbeeModel: ['CLA60 TW OSRAM'],
@@ -252,7 +251,7 @@ module.exports = [
         model: '4058075047853',
         vendor: 'OSRAM',
         description: 'Smart+ gardenpole 4W RGBW',
-        extend: extend.ledvance.light_onoff_brightness_colortemp_color(),
+        extend: extend.ledvance.light_onoff_brightness_colortemp_color({supportsHS: true, preferHS: true}),
         meta: {disableDefaultResponse: true},
         ota: ota.ledvance,
     },

package/devices/tuya.js

@@ -128,6 +128,19 @@ const tzLocal = {
             }
         },
     },
+    temperature_unit: {
+        key: ['temperature_unit'],
+        convertSet: async (entity, key, value, meta) => {
+            switch (key) {
+            case 'temperature_unit': {
+                await entity.write('manuSpecificTuya_2', {'57355': {value: {'celsius': 0, 'fahrenheit': 1}[value], type: 48}});
+                break;
+            }
+            default: // Unknown key
+                meta.logger.warn(`Unhandled key ${key}`);
+            }
+        },
+    },
 };
 
 const fzLocal = {
@@ -262,6 +275,28 @@ const fzLocal = {
             return result;
         },
     },
+    humidity10: {
+        cluster: 'msRelativeHumidity',
+        type: ['attributeReport', 'readResponse'],
+        options: [exposes.options.precision('humidity'), exposes.options.calibration('humidity')],
+        convert: (model, msg, publish, options, meta) => {
+            const humidity = parseFloat(msg.data['measuredValue']) / 10.0;
+            if (humidity >= 0 && humidity <= 100) {
+                return {humidity: utils.calibrateAndPrecisionRoundOptions(humidity, options, 'humidity')};
+            }
+        },
+    },
+    temperature_unit: {
+        cluster: 'manuSpecificTuya_2',
+        type: ['attributeReport', 'readResponse'],
+        convert: (model, msg, publish, options, meta) => {
+            const result = {};
+            if (msg.data.hasOwnProperty('57355')) {
+                result.temperature_unit = {'0': 'celsius', '1': 'fahrenheit'}[msg.data['57355']];
+            }
+            return result;
+        },
+    },
 };
 
 module.exports = [
@@ -2682,4 +2717,21 @@ module.exports = [
         toZigbee: [tzZosung.zosung_ir_code_to_send, tzZosung.zosung_learn_ir_code],
         exposes: [ez.learn_ir_code(), ez.learned_ir_code(), ez.ir_code_to_send()],
     },
+    {
+        fingerprint: [{modelID: 'TS0201', manufacturerName: '_TZ3000_itnrsufe'}],
+        model: 'KCTW1Z',
+        vendor: 'TuYa',
+        description: 'Temperature & humidity sensor with LCD',
+        fromZigbee: [fz.temperature, fzLocal.humidity10, fzLocal.temperature_unit, fz.battery, fz.ignore_tuya_set_time],
+        toZigbee: [tzLocal.temperature_unit],
+        onEvent: tuya.onEventSetLocalTime,
+        exposes: [
+            e.temperature(), e.humidity(), e.battery(), e.battery_voltage(),
+            exposes.enum('temperature_unit', ea.STATE_SET, ['celsius', 'fahrenheit']).withDescription('Current display unit'),
+        ],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg', 'msTemperatureMeasurement', 'msRelativeHumidity']);
+        },
+    },
 ];

package/lib/exposes.js

@@ -407,11 +407,11 @@ class Climate extends Base {
         return this;
     }
 
-    withFanMode(modes) {
+    withFanMode(modes, access=a.ALL) {
         assert(!this.endpoint, 'Cannot add feature after adding endpoint');
         const allowed = ['off', 'low', 'medium', 'high', 'on', 'auto', 'smart'];
         modes.forEach((m) => assert(allowed.includes(m)));
-        this.features.push(new Enum('fan_mode', access.ALL, modes).withDescription('Mode of the fan'));
+        this.features.push(new Enum('fan_mode', access, modes).withDescription('Mode of the fan'));
         return this;
     }
 

package/lib/extend.js

@@ -125,7 +125,7 @@ const extend = {
             ...extend.light_onoff_brightness(options),
             toZigbee: extend.light_onoff_brightness(options).toZigbee.concat([tz.ledvance_commands]),
         }),
-        light_onoff_brightness_colortemp: (options={}) => ({
+        light_onoff_brightness_colortemp: (options={disableColorTempStartup: true}) => ({
             ...extend.light_onoff_brightness_colortemp(options),
             toZigbee: extend.light_onoff_brightness_colortemp(options).toZigbee.concat([tz.ledvance_commands]),
         }),
@@ -133,7 +133,7 @@ const extend = {
             ...extend.light_onoff_brightness_color({supportsHS: true, ...options}),
             toZigbee: extend.light_onoff_brightness_color({supportsHS: true, ...options}).toZigbee.concat([tz.ledvance_commands]),
         }),
-        light_onoff_brightness_colortemp_color: (options={}) => ({
+        light_onoff_brightness_colortemp_color: (options={disableColorTempStartup: true}) => ({
             ...extend.light_onoff_brightness_colortemp_color({supportsHS: true, ...options}),
             toZigbee: extend.light_onoff_brightness_colortemp_color({supportsHS: true, ...options}).toZigbee.concat([tz.ledvance_commands]),
         }),

package/lib/tuya.js

@@ -710,6 +710,8 @@ const dataPoints = {
     alectoBatteryState: 14,
     alectoBatteryPercentage: 15,
     alectoSilence: 16,
+    // BAC-002-ALZB - Moes like thermostat with Fan control
+    bacFanMode: 28,
 };
 
 const thermostatWeekFormat = {

package/package.json

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