zigbee-herdsman-converters 14.0.295 → 14.0.296

package/converters/fromZigbee.js

@@ -108,6 +108,26 @@ const converters = {
             if (msg.data.hasOwnProperty('tempSetpointHoldDuration')) {
                 result[postfixWithEndpointName('temperature_setpoint_hold_duration', msg, model)] = msg.data['tempSetpointHoldDuration'];
             }
+            if (msg.data.hasOwnProperty('minHeatSetpointLimit')) {
+                let value = precisionRound(msg.data['minHeatSetpointLimit'], 2) / 100;
+                value = value < -250 ? 0 : value;
+                result[postfixWithEndpointName('min_heat_setpoint_limit', msg, model)] = value;
+            }
+            if (msg.data.hasOwnProperty('maxHeatSetpointLimit')) {
+                let value = precisionRound(msg.data['maxHeatSetpointLimit'], 2) / 100;
+                value = value < -250 ? 0 : value;
+                result[postfixWithEndpointName('max_heat_setpoint_limit', msg, model)] = value;
+            }
+            if (msg.data.hasOwnProperty('absMinHeatSetpointLimit')) {
+                let value = precisionRound(msg.data['absMinHeatSetpointLimit'], 2) / 100;
+                value = value < -250 ? 0 : value;
+                result[postfixWithEndpointName('abs_min_heat_setpoint_limit', msg, model)] = value;
+            }
+            if (msg.data.hasOwnProperty('absMaxHeatSetpointLimit')) {
+                let value = precisionRound(msg.data['absMaxHeatSetpointLimit'], 2) / 100;
+                value = value < -250 ? 0 : value;
+                result[postfixWithEndpointName('abs_max_heat_setpoint_limit', msg, model)] = value;
+            }
             return result;
         },
     },
@@ -3007,6 +3027,62 @@ const converters = {
             if (msg.data.hasOwnProperty('danfossLoadEstimate')) {
                 result[postfixWithEndpointName('load_estimate', msg, model)] = msg.data['danfossLoadEstimate'];
             }
+            // Danfoss Icon Converters
+            if (msg.data.hasOwnProperty('danfossRoomStatusCode')) {
+                result[postfixWithEndpointName('room_status_code', msg, model)] =
+                    constants.danfossRoomStatusCode.hasOwnProperty(msg.data['danfossRoomStatusCode']) ?
+                        constants.danfossRoomStatusCode[msg.data['danfossRoomStatusCode']] :
+                        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'];
+            }
+            return result;
+        },
+    },
+    danfoss_icon_battery: {
+        cluster: 'genPowerCfg',
+        type: ['attributeReport', 'readResponse'],
+        convert: (model, msg, publish, options, meta) => {
+            const result = {};
+            if (msg.data.hasOwnProperty('batteryPercentageRemaining')) {
+                // Some devices do not comply to the ZCL and report a
+                // batteryPercentageRemaining of 100 when the battery is full (should be 200).
+                const dontDividePercentage = model.meta && model.meta.battery && model.meta.battery.dontDividePercentage;
+                let percentage = msg.data['batteryPercentageRemaining'];
+                percentage = dontDividePercentage ? percentage : percentage / 2;
+
+                result[postfixWithEndpointName('battery', msg, model)] = precisionRound(percentage, 2);
+            }
+            return result;
+        },
+    },
+    danfoss_icon_regulator: {
+        cluster: 'haDiagnostic',
+        type: ['attributeReport', 'readResponse'],
+        convert: (model, msg, publish, options, meta) => {
+            const result = {};
+            if (msg.data.hasOwnProperty('danfossSystemStatusCode')) {
+                result[postfixWithEndpointName('system_status_code', msg, model)] =
+                constants.danfossSystemStatusCode.hasOwnProperty(msg.data['danfossSystemStatusCode']) ?
+                    constants.danfossSystemStatusCode[msg.data['danfossSystemStatusCode']] :
+                    msg.data['danfossSystemStatusCode'];
+            }
+            if (msg.data.hasOwnProperty('danfossSystemStatusWater')) {
+                result[postfixWithEndpointName('system_status_water', msg, model)] =
+                constants.danfossSystemStatusWater.hasOwnProperty(msg.data['danfossSystemStatusWater']) ?
+                    constants.danfossSystemStatusWater[msg.data['danfossSystemStatusWater']] :
+                    msg.data['danfossSystemStatusWater'];
+            }
+            if (msg.data.hasOwnProperty('danfossMultimasterRole')) {
+                result[postfixWithEndpointName('multimaster_role', msg, model)] =
+                constants.danfossMultimasterRole.hasOwnProperty(msg.data['danfossMultimasterRole']) ?
+                    constants.danfossMultimasterRole[msg.data['danfossMultimasterRole']] :
+                    msg.data['danfossMultimasterRole'];
+            }
             return result;
         },
     },
@@ -6945,7 +7021,11 @@ const converters = {
         convert: (model, msg, publish, options, meta) => {
             const lookup = {'commandToggle': 'long', 'commandOn': 'double', 'commandOff': 'single'};
             let buttonMapping = null;
-            if (model.model === 'MSM-300ZB') {
+            if (model.model === 'SBM300ZB2') {
+                buttonMapping = {1: '1', 2: '2'};
+            } else if (model.model === 'SBM300ZB3') {
+                buttonMapping = {1: '1', 2: '2', 3: '3'};
+            } else if (model.model === 'MSM-300ZB') {
                 buttonMapping = {1: '1', 2: '2', 3: '3', 4: '4'};
             }
             const button = buttonMapping ? `${buttonMapping[msg.endpoint.ID]}_` : '';

package/converters/toZigbee.js

@@ -1327,6 +1327,38 @@ const converters = {
             await entity.read('hvacThermostat', ['runningMode']);
         },
     },
+    thermostat_min_heat_setpoint_limit: {
+        key: ['min_heat_setpoint_limit'],
+        convertSet: async (entity, key, value, meta) => {
+            let result;
+            if (meta.options.thermostat_unit === 'fahrenheit') {
+                result = utils.normalizeCelsiusVersionOfFahrenheit(value) * 100;
+            } else {
+                result = (Math.round((value * 2).toFixed(1)) / 2).toFixed(1) * 100;
+            }
+            const minHeatSetpointLimit = result;
+            await entity.write('hvacThermostat', {minHeatSetpointLimit});
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read('hvacThermostat', ['minHeatSetpointLimit']);
+        },
+    },
+    thermostat_max_heat_setpoint_limit: {
+        key: ['max_heat_setpoint_limit'],
+        convertSet: async (entity, key, value, meta) => {
+            let result;
+            if (meta.options.thermostat_unit === 'fahrenheit') {
+                result = utils.normalizeCelsiusVersionOfFahrenheit(value) * 100;
+            } else {
+                result = (Math.round((value * 2).toFixed(1)) / 2).toFixed(1) * 100;
+            }
+            const maxHeatSetpointLimit = result;
+            await entity.write('hvacThermostat', {maxHeatSetpointLimit});
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read('hvacThermostat', ['maxHeatSetpointLimit']);
+        },
+    },
     electrical_measurement_power: {
         key: ['power'],
         convertGet: async (entity, key, meta) => {
@@ -2484,6 +2516,36 @@ const converters = {
             await entity.read('hvacThermostat', ['danfossLoadEstimate'], manufacturerOptions.danfoss);
         },
     },
+    danfoss_output_status: {
+        key: ['output_status'],
+        convertGet: async (entity, key, meta) => {
+            await entity.read('hvacThermostat', ['danfossOutputStatus'], manufacturerOptions.danfoss);
+        },
+    },
+    danfoss_room_status_code: {
+        key: ['room_status_code'],
+        convertGet: async (entity, key, meta) => {
+            await entity.read('hvacThermostat', ['danfossRoomStatusCode'], manufacturerOptions.danfoss);
+        },
+    },
+    danfoss_system_status_code: {
+        key: ['system_status_code'],
+        convertGet: async (entity, key, meta) => {
+            await entity.read('haDiagnostic', ['danfossSystemStatusCode'], manufacturerOptions.danfoss);
+        },
+    },
+    danfoss_system_status_water: {
+        key: ['system_status_water'],
+        convertGet: async (entity, key, meta) => {
+            await entity.read('haDiagnostic', ['danfossSystemStatusWater'], manufacturerOptions.danfoss);
+        },
+    },
+    danfoss_multimaster_role: {
+        key: ['multimaster_role'],
+        convertGet: async (entity, key, meta) => {
+            await entity.read('haDiagnostic', ['danfossMultimasterRole'], manufacturerOptions.danfoss);
+        },
+    },
     ZMCSW032D_cover_position: {
         key: ['position', 'tilt'],
         convertSet: async (entity, key, value, meta) => {

package/devices/adeo.js

@@ -76,4 +76,13 @@ module.exports = [
         },
         exposes: [e.power(), e.switch(), e.energy()],
     },
+    {
+        zigbeeModel: ['LDSENK10'],
+        model: 'LDSENK10',
+        vendor: 'ADEO',
+        description: 'LEXMAN motion sensor',
+        fromZigbee: [fz.ias_occupancy_alarm_1],
+        toZigbee: [],
+        exposes: [e.occupancy(), e.battery_low(), e.tamper()],
+    },
 ];

package/devices/danfoss.js

@@ -122,4 +122,133 @@ module.exports = [
             endpoint.write('genTime', values);
         },
     },
+    {
+        fingerprint: [
+            {modelID: '0x8020', manufacturerName: 'Danfoss'}, // RT24V Display
+            {modelID: '0x8021', manufacturerName: 'Danfoss'}, // RT24V Display  Floor sensor
+            {modelID: '0x8030', manufacturerName: 'Danfoss'}, // RTbattery Display
+            {modelID: '0x8031', manufacturerName: 'Danfoss'}, // RTbattery Display Infrared
+            {modelID: '0x8034', manufacturerName: 'Danfoss'}, // RTbattery Dial
+            {modelID: '0x8035', manufacturerName: 'Danfoss'}], // RTbattery Dial Infrared
+        model: 'Icon',
+        vendor: 'Danfoss',
+        description: 'Icon floor heating (regulator, Zigbee module & thermostats)',
+        fromZigbee: [
+            fz.danfoss_icon_regulator,
+            fz.danfoss_thermostat,
+            fz.danfoss_icon_battery,
+            fz.thermostat],
+        toZigbee: [
+            tz.thermostat_local_temperature,
+            tz.thermostat_occupied_heating_setpoint,
+            tz.thermostat_system_mode,
+            tz.thermostat_min_heat_setpoint_limit,
+            tz.thermostat_max_heat_setpoint_limit,
+            tz.danfoss_output_status,
+            tz.danfoss_room_status_code,
+            tz.danfoss_system_status_water,
+            tz.danfoss_system_status_code,
+            tz.danfoss_multimaster_role,
+        ],
+        meta: {multiEndpoint: true},
+        // ota: ota.zigbeeOTA,
+        endpoint: (device) => {
+            return {
+                'l1': 1, 'l2': 2, 'l3': 3, 'l4': 4, 'l5': 5,
+                'l6': 6, 'l7': 7, 'l8': 8, 'l9': 9, 'l10': 10,
+                'l11': 11, 'l12': 12, 'l13': 13, 'l14': 14, 'l15': 15, 'l16': 232,
+            };
+        },
+        exposes: [].concat(((endpointsCount) => {
+            const features = [];
+            for (let i = 1; i <= endpointsCount; i++) {
+                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.numeric('abs_min_heat_setpoint_limit', ea.STATE)
+                        .withUnit('°C').withEndpoint(epName)
+                        .withDescription('Absolute min temperature allowed on the device'));
+                    features.push(exposes.numeric('abs_max_heat_setpoint_limit', ea.STATE)
+                        .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')
+                        .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')
+                        .withEndpoint(epName).withDescription('Max temperature limit set on the device'));
+                    features.push(exposes.enum('setpoint_change_source', ea.STATE, ['manual', 'schedule', 'externally'])
+                        .withEndpoint(epName));
+                    features.push(exposes.enum('output_status', ea.STATE_GET, ['inactive', 'active'])
+                        .withEndpoint(epName).withDescription('Danfoss Output Status [Active vs Inactive])'));
+                    features.push(exposes.enum('room_status_code', ea.STATE_GET, ['no_error', 'missing_rt',
+                        'rt_touch_error', 'floor_sensor_short_circuit', 'floor_sensor_disconnected'])
+                        .withEndpoint(epName).withDescription('Thermostat status'));
+                } else {
+                    features.push(exposes.enum('system_status_code', ea.STATE_GET, ['no_error', 'missing_expansion_board',
+                        'missing_radio_module', 'missing_command_module', 'missing_master_rail', 'missing_slave_rail_no_1',
+                        'missing_slave_rail_no_2', 'pt1000_input_short_circuit', 'pt1000_input_open_circuit',
+                        'error_on_one_or_more_output']).withEndpoint('l16').withDescription('Regulator Status'));
+                    features.push(exposes.enum('system_status_water', ea.STATE_GET, ['hot_water_flow_in_pipes', 'cool_water_flow_in_pipes'])
+                        .withEndpoint('l16').withDescription('Water Status of Regulator'));
+                    features.push(exposes.enum('multimaster_role', ea.STATE_GET, ['invalid_unused', 'master', 'slave_1', 'slave_2'])
+                        .withEndpoint('l16').withDescription('Regulator role (Master vs Slave)'));
+                }
+            }
+
+            return features;
+        })(16)),
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const options = {manufacturerCode: 0x1246};
+
+            for (let i = 1; i <= 15; i++) {
+                const endpoint = device.getEndpoint(i);
+                if (typeof endpoint !== 'undefined') {
+                    await reporting.bind(endpoint, coordinatorEndpoint,
+                        ['genPowerCfg', 'hvacThermostat', 'hvacUserInterfaceCfg']);
+                    await reporting.batteryPercentageRemaining(endpoint,
+                        {min: constants.repInterval.HOUR, max: 43200, change: 1});
+                    await reporting.thermostatTemperature(endpoint,
+                        {min: 0, max: constants.repInterval.MINUTES_10, change: 10});
+                    await reporting.thermostatOccupiedHeatingSetpoint(endpoint,
+                        {min: 0, max: constants.repInterval.MINUTES_10, change: 10});
+
+                    await endpoint.configureReporting('hvacThermostat', [{
+                        attribute: 'danfossOutputStatus',
+                        minimumReportInterval: constants.repInterval.MINUTE,
+                        maximumReportInterval: constants.repInterval.MINUTES_10,
+                        reportableChange: 1,
+                    }], options);
+
+                    // Danfoss Icon Thermostat Specific
+                    await endpoint.read('hvacThermostat', [
+                        'danfossOutputStatus',
+                        'danfossRoomStatusCode'], options);
+
+                    // Standard Thermostat
+                    await endpoint.read('hvacThermostat', ['localTemp']);
+                    await endpoint.read('hvacThermostat', ['occupiedHeatingSetpoint']);
+                    await endpoint.read('hvacThermostat', ['systemMode']);
+                    await endpoint.read('hvacThermostat', ['setpointChangeSource']);
+                    await endpoint.read('hvacThermostat', ['absMinHeatSetpointLimit']);
+                    await endpoint.read('hvacThermostat', ['absMaxHeatSetpointLimit']);
+                    await endpoint.read('hvacThermostat', ['minHeatSetpointLimit']);
+                    await endpoint.read('hvacThermostat', ['maxHeatSetpointLimit']);
+                    await endpoint.read('genPowerCfg', ['batteryPercentageRemaining']);
+                }
+            }
+
+            // Danfoss Icon Regulator Specific
+            const endpoint232 = device.getEndpoint(232);
+
+            await reporting.bind(endpoint232, coordinatorEndpoint, ['haDiagnostic']);
+
+            await endpoint232.read('haDiagnostic', [
+                'danfossSystemStatusCode',
+                'danfossSystemStatusWater',
+                'danfossMultimasterRole'], options);
+        },
+    },
 ];

package/devices/philips.js

@@ -2165,4 +2165,22 @@ module.exports = [
         meta: {turnsOffAtBrightness1: true},
         ota: ota.zigbeeOTA,
     },
+    {
+        zigbeeModel: ['LTF001'],
+        model: '6109231C5',
+        vendor: 'Philips',
+        description: 'Hue white ambiance Apogee square',
+        meta: {turnsOffAtBrightness1: true},
+        extend: hueExtend.light_onoff_brightness_colortemp({colorTempRange: [153, 454]}),
+        ota: ota.zigbeeOTA,
+    },
+    {
+        zigbeeModel: ['LTF002'],
+        model: '6109331C5',
+        vendor: 'Philips',
+        description: 'Hue white ambiance Apogee round',
+        meta: {turnsOffAtBrightness1: true},
+        extend: hueExtend.light_onoff_brightness_colortemp({colorTempRange: [153, 454]}),
+        ota: ota.zigbeeOTA,
+    },
 ];

package/devices/shinasystem.js

@@ -236,4 +236,50 @@ module.exports = [
             await reporting.batteryVoltage(endpoint, {min: 30, max: 21600, change: 1});
         },
     },
+    {
+        zigbeeModel: ['SBM300ZB1'],
+        model: 'SBM300ZB1',
+        vendor: 'ShinaSystem',
+        description: 'SiHAS remote control',
+        meta: {battery: {voltageToPercentage: '3V_2100'}},
+        fromZigbee: [fz.battery, fz.sihas_action],
+        toZigbee: [],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg']);
+            await reporting.batteryVoltage(endpoint);
+        },
+        exposes: [e.battery(), e.battery_voltage(), e.action(['single', 'double', 'long'])],
+    },
+    {
+        zigbeeModel: ['SBM300ZB2'],
+        model: 'SBM300ZB2',
+        vendor: 'ShinaSystem',
+        description: 'SiHAS remote control 2 button',
+        fromZigbee: [fz.sihas_action, fz.battery],
+        toZigbee: [],
+        exposes: [e.action(['1_single', '1_double', '1_long', '2_single', '2_double', '2_long']), e.battery(), e.battery_voltage()],
+        meta: {battery: {voltageToPercentage: '3V_2100'}},
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg']);
+            await reporting.batteryVoltage(endpoint, {min: 30, max: 21600, change: 1});
+        },
+    },
+    {
+        zigbeeModel: ['SBM300ZB3'],
+        model: 'SBM300ZB3',
+        vendor: 'ShinaSystem',
+        description: 'SiHAS remote control 3 button',
+        fromZigbee: [fz.sihas_action, fz.battery],
+        toZigbee: [],
+        exposes: [e.action(['1_single', '1_double', '1_long', '2_single', '2_double', '2_long',
+            '3_single', '3_double', '3_long']), e.battery(), e.battery_voltage()],
+        meta: {battery: {voltageToPercentage: '3V_2100'}},
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg']);
+            await reporting.batteryVoltage(endpoint, {min: 30, max: 21600, change: 1});
+        },
+    },
 ];

package/devices/the_light_group.js

@@ -1,5 +1,7 @@
 const exposes = require('../lib/exposes');
 const fz = {...require('../converters/fromZigbee'), legacy: require('../lib/legacy').fromZigbee};
+const reporting = require('../lib/reporting');
+const extend = require('../lib/extend');
 const e = exposes.presets;
 
 module.exports = [
@@ -21,4 +23,17 @@ module.exports = [
             return {l1: 1, l2: 2, l3: 3, l4: 4};
         },
     },
+    {
+        zigbeeModel: ['S24013'],
+        model: 'S24013',
+        vendor: 'The Light Group',
+        description: 'SLC SmartOne AC dimmer mini 200W Zigbee LN',
+        extend: extend.light_onoff_brightness({noConfigure: true}),
+        configure: async (device, coordinatorEndpoint, logger) => {
+            await extend.light_onoff_brightness().configure(device, coordinatorEndpoint, logger);
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'genLevelCtrl']);
+            await reporting.onOff(endpoint);
+        },
+    },
 ];

package/devices/tuya.js

@@ -916,6 +916,7 @@ module.exports = [
         toZigbee: [tz.on_off, tz.tuya_switch_power_outage_memory],
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff']);
             endpoint.saveClusterAttributeKeyValue('haElectricalMeasurement', {acCurrentDivisor: 1000, acCurrentMultiplier: 1});
             endpoint.saveClusterAttributeKeyValue('seMetering', {divisor: 100, multiplier: 1});
             device.save();

package/devices/yale.js

@@ -100,6 +100,13 @@ module.exports = [
         description: 'Assure lock SL',
         extend: lockExtend(),
     },
+    {
+        zigbeeModel: ['YRL226 TS'],
+        model: 'YRL226 TS',
+        vendor: 'Yale',
+        description: 'Assure lock SL',
+        extend: lockExtend(),
+    },
     {
         // Appears to be a slightly rebranded Assure lock SL
         // Just with Lockwood | Assa Abloy branding instead of Yale

package/lib/constants.js

@@ -91,6 +91,44 @@ const danfossWindowOpen = {
     4: 'external_open',
 };
 
+const danfossRoomStatusCode = {
+    0x0000: 'no_error',
+    0x0101: 'missing_rt',
+    0x0201: 'rt_touch_error',
+    0x0401: 'floor_sensor_short_circuit',
+    0x0801: 'floor_sensor_disconnected',
+};
+
+const danfossOutputStatus = {
+    0: 'inactive',
+    1: 'active',
+};
+
+const danfossSystemStatusWater = {
+    0: 'hot_water_flow_in_pipes',
+    1: 'cool_water_flow_in_pipes',
+};
+
+const danfossSystemStatusCode = {
+    0x0000: 'no_error',
+    0x0101: 'missing_expansion_board',
+    0x0201: 'missing_radio_module',
+    0x0401: 'missing_command_module',
+    0x0801: 'missing_master_rail',
+    0x1001: 'missing_slave_rail_no_1',
+    0x2001: 'missing_slave_rail_no_2',
+    0x4001: 'pt1000_input_short_circuit',
+    0x8001: 'pt1000_input_open_circuit',
+    0x0102: 'error_on_one_or_more_output',
+};
+
+const danfossMultimasterRole = {
+    0: 'invalid_unused',
+    1: 'master',
+    2: 'slave_1',
+    3: 'slave_2',
+};
+
 const keypadLockoutMode = {
     0: 'unlock',
     1: 'lock1',
@@ -196,6 +234,11 @@ module.exports = {
     fanMode,
     temperatureDisplayMode,
     danfossWindowOpen,
+    danfossRoomStatusCode,
+    danfossOutputStatus,
+    danfossSystemStatusWater,
+    danfossSystemStatusCode,
+    danfossMultimasterRole,
     keypadLockoutMode,
     lockSourceName,
     armMode,

package/npm-shrinkwrap.json

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

package/package.json

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