zigbee-herdsman-converters 14.0.245 → 14.0.249

package/converters/fromZigbee.js

@@ -1513,44 +1513,56 @@ const converters = {
             const result = {};
             const data = msg.data;
 
-            if (data.hasOwnProperty(0x0402)) {
+            if (data.hasOwnProperty(0x0402)) { // Display text
                 result.display_text = data[0x0402];
             }
 
-            if (data.hasOwnProperty(0x0403)) {
+            if (data.hasOwnProperty(0x0403)) { // Sensor
                 const sensorModeLookup = {'0': 'air', '1': 'floor', '3': 'supervisor_floor'};
-                result.sensor_mode = sensorModeLookup[data[0x0403]];
+                result.sensor = sensorModeLookup[data[0x0403]];
             }
 
-            if (data.hasOwnProperty(0x0406)) {
+            if (data.hasOwnProperty(0x0404)) { // Regulator time
+                result.regulator_time = data[0x0404];
+            }
+
+            if (data.hasOwnProperty(0x0405)) { // Regulator mode
+                result.regulator_mode = data[0x0405] ? 'regulator' : 'thermostat';
+            }
+
+            if (data.hasOwnProperty(0x0406)) { // Power status
                 result.system_mode = data[0x0406] ? 'heat' : 'off';
             }
 
-            if (data.hasOwnProperty(0x0408)) {
+            if (data.hasOwnProperty(0x0408)) { // Mean power
                 result.mean_power = data[0x0408];
             }
 
-            if (data.hasOwnProperty(0x0409)) {
+            if (data.hasOwnProperty(0x0409)) { // External temp (floor)
                 result.floor_temp = utils.precisionRound(data[0x0409], 2) /100;
             }
 
-            if (data.hasOwnProperty(0x0412)) {
+            if (data.hasOwnProperty(0x0411)) { // Night switching
+                result.night_switching = data[0x0411] ? 'on' : 'off';
+            }
+
+            if (data.hasOwnProperty(0x0412)) { // Frost guard
                 result.frost_guard = data[0x0412] ? 'on' : 'off';
             }
 
-            if (data.hasOwnProperty(0x0413)) {
+            if (data.hasOwnProperty(0x0413)) { // Child lock
                 result.child_lock = data[0x0413] ? 'lock' : 'unlock';
             }
 
-            if (data.hasOwnProperty(0x0414)) {
+            if (data.hasOwnProperty(0x0414)) { // Max floor temp
                 result.max_floor_temp = data[0x0414];
             }
 
-            if (data.hasOwnProperty(0x0415)) {
+            if (data.hasOwnProperty(0x0415)) { // Relay state
                 result.running_state = data[0x0415] ? 'heat' : 'idle';
             }
 
-            if (data.hasOwnProperty(0x0417)) {
+            if (data.hasOwnProperty(0x0417)) { // Calibration
                 result.local_temperature_calibration = precisionRound(data[0x0417], 2) / 10;
             }
 
@@ -6471,6 +6483,20 @@ const converters = {
             }
         },
     },
+    heiman_doorbell_button: {
+        cluster: 'ssIasZone',
+        type: 'commandStatusChangeNotification',
+        convert: (model, msg, publish, options, meta) => {
+            if (utils.hasAlreadyProcessedMessage(msg)) return;
+            const lookup = {32768: 'pressed'};
+            const zoneStatus = msg.data.zonestatus;
+            return {
+                action: lookup[zoneStatus],
+                tamper: (zoneStatus & 1<<2) > 0,
+                battery_low: (zoneStatus & 1<<3) > 0,
+            };
+        },
+    },
     // #endregion
 
     // #region Ignore converters (these message dont need parsing).

package/converters/toZigbee.js

@@ -1360,6 +1360,16 @@ const converters = {
             await entity.read('hvacThermostat', ['elkoFrostGuard']);
         },
     },
+    elko_night_switching: {
+        key: ['night_switching'],
+        convertSet: async (entity, key, value, meta) => {
+            await entity.write('hvacThermostat', {'elkoNightSwitching': value === 'on'});
+            return {state: {night_switching: value}};
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read('hvacThermostat', ['elkoNightSwitching']);
+        },
+    },
     elko_relay_state: {
         key: ['running_state'],
         convertGet: async (entity, key, meta) => {
@@ -1367,13 +1377,30 @@ const converters = {
         },
     },
     elko_sensor_mode: {
-        key: ['sensor_mode'],
+        key: ['sensor'],
         convertSet: async (entity, key, value, meta) => {
             await entity.write('hvacThermostat', {'elkoSensor': {'air': '0', 'floor': '1', 'supervisor_floor': '3'}[value]});
-            return {state: {sensor_mode: value}};
+            return {state: {sensor: value}};
+        },
+    },
+    elko_regulator_time: {
+        key: ['regulator_time'],
+        convertSet: async (entity, key, value, meta) => {
+            await entity.write('hvacThermostat', {'elkoRegulatorTime': value});
+            return {state: {sensor: value}};
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read('hvacThermostat', ['elkoRegulatorTime']);
+        },
+    },
+    elko_regulator_mode: {
+        key: ['regulator_mode'],
+        convertSet: async (entity, key, value, meta) => {
+            await entity.write('hvacThermostat', {'elkoRegulatorMode': value === 'regulator'});
+            return {state: {regulator_mode: value}};
         },
         convertGet: async (entity, key, meta) => {
-            await entity.read('hvacThermostat', ['elkoSensor']);
+            await entity.read('hvacThermostat', ['elkoRegulatorMode']);
         },
     },
     elko_local_temperature_calibration: {

package/devices/bitron.js

@@ -8,42 +8,127 @@ const e = exposes.presets;
 
 module.exports = [
     {
-        zigbeeModel: ['AV2010/34'],
-        model: 'AV2010/34',
-        vendor: 'Bitron',
-        description: '4-Touch single click buttons',
-        fromZigbee: [fz.ignore_power_report, fz.command_recall, fz.legacy.AV2010_34_click],
+        zigbeeModel: ['AV2010/14', '902010/14'],
+        model: 'AV2010/14',
+        vendor: 'SMaBiT (Bitron Video)',
+        description: 'Curtain motion detector',
+        fromZigbee: [fz.ias_occupancy_alarm_1_with_timeout],
         toZigbee: [],
-        exposes: [e.action(['recall_*'])],
+        exposes: [e.occupancy(), e.battery_low()],
+    },
+    {
+        zigbeeModel: ['AV2010/16', '902010/16'],
+        model: 'AV2010/16',
+        vendor: 'SMaBiT (Bitron Video)',
+        description: 'Wall-mount relay with dimmer',
+        extend: extend.light_onoff_brightness({noConfigure: true}),
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'genLevelCtrl']);
+        },
+    },
+    {
+        zigbeeModel: ['AV2010/18', '902010/18'],
+        model: 'AV2010/18',
+        vendor: 'SMaBiT (Bitron Video)',
+        description: 'Wall-mount relay',
+        extend: extend.switch(),
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
-            await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg']);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff']);
         },
     },
     {
-        zigbeeModel: ['902010/22', 'IR_00.00.03.12TC'],
+        zigbeeModel: ['AV2010/21A', '902010/21A'],
+        model: 'AV2010/21A',
+        vendor: 'SMaBiT (Bitron Video)',
+        description: 'Compact magnetic contact sensor',
+        fromZigbee: [fz.ias_contact_alarm_1],
+        toZigbee: [],
+        exposes: [e.contact(), e.battery_low(), e.tamper()],
+    },
+    {
+        zigbeeModel: ['AV2010/21B', '902010/21B'],
+        model: 'AV2010/21B',
+        vendor: 'SMaBiT (Bitron Video)',
+        description: 'Magnetic contact sensor with additional input for wired sensors',
+        fromZigbee: [fz.ias_contact_alarm_1],
+        toZigbee: [],
+        exposes: [e.contact(), e.battery_low(), e.tamper()],
+    },
+    {
+        zigbeeModel: ['AV2010/21C', '902010/21C'],
+        model: 'AV2010/21C',
+        vendor: 'SMaBiT (Bitron Video)',
+        description: 'Ultra-flat magnetic contact sensor',
+        fromZigbee: [fz.ias_contact_alarm_1],
+        toZigbee: [],
+        exposes: [e.contact(), e.battery_low()],
+    },
+    {
+        zigbeeModel: ['AV2010/22', '902010/22', 'IR_00.00.03.12TC'],
         model: 'AV2010/22',
-        vendor: 'Bitron',
-        description: 'Wireless motion detector',
+        vendor: 'SMaBiT (Bitron Video)',
+        description: 'Professional motion detector',
         fromZigbee: [fz.ias_occupancy_alarm_1_with_timeout],
         toZigbee: [],
         exposes: [e.occupancy(), e.battery_low(), e.tamper()],
         whiteLabel: [{vendor: 'ClimaxTechnology', model: 'IR-9ZBS-SL'}],
     },
     {
-        zigbeeModel: ['AV2010/22A'],
+        zigbeeModel: ['AV2010/22A', '902010/22A'],
         model: 'AV2010/22A',
-        vendor: 'Bitron',
-        description: 'Wireless motion detector',
+        vendor: 'SMaBiT (Bitron Video)',
+        description: 'Design motion detector',
+        fromZigbee: [fz.ias_occupancy_alarm_1_with_timeout],
+        toZigbee: [],
+        exposes: [e.occupancy(), e.battery_low()],
+    },
+    {
+        zigbeeModel: ['AV2010/22B', '902010/22B'],
+        model: 'AV2010/22B',
+        vendor: 'SMaBiT (Bitron Video)',
+        description: 'Outdoor motion detector',
         fromZigbee: [fz.ias_occupancy_alarm_1_with_timeout],
         toZigbee: [],
         exposes: [e.occupancy(), e.battery_low(), e.tamper()],
     },
     {
-        zigbeeModel: ['902010/25'],
+        zigbeeModel: ['AV2010/23', '902010/23'],
+        model: 'AV2010/23',
+        vendor: 'SMaBiT (Bitron Video)',
+        description: '4 button Zigbee remote control',
+        fromZigbee: [fz.ias_no_alarm, fz.command_on, fz.command_off, fz.command_step, fz.command_recall],
+        toZigbee: [],
+        exposes: [e.action(['on', 'off', 'brightness_step_up', 'brightness_step_down', 'recall_*']), e.battery_low()],
+        configure: async (device, coordinatorEndpoint) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg', 'genBasic', 'genOnOff', 'genLevelCtrl']);
+        },
+    },
+    {
+        zigbeeModel: ['AV2010/24', '902010/24'],
+        model: 'AV2010/24',
+        vendor: 'SMaBiT (Bitron Video)',
+        description: 'Optical smoke detector (hardware version v1)',
+        fromZigbee: [fz.ias_smoke_alarm_1],
+        toZigbee: [tz.warning],
+        exposes: [e.smoke(), e.battery_low(), e.tamper(), e.warning()],
+    },
+    {
+        zigbeeModel: ['AV2010/24A', '902010/24A'],
+        model: 'AV2010/24A',
+        vendor: 'SMaBiT (Bitron Video)',
+        description: 'Optical smoke detector (hardware version v2)',
+        fromZigbee: [fz.ias_smoke_alarm_1],
+        toZigbee: [tz.warning],
+        exposes: [e.smoke(), e.battery_low(), e.tamper(), e.warning()],
+    },
+    {
+        zigbeeModel: ['AV2010/25', '902010/25'],
         model: 'AV2010/25',
-        vendor: 'Bitron',
-        description: 'Video wireless socket',
+        vendor: 'SMaBiT (Bitron Video)',
+        description: 'Wireless socket with metering',
         fromZigbee: [fz.on_off, fz.metering],
         toZigbee: [tz.on_off],
         exposes: [e.switch(), e.power(), e.energy()],
@@ -57,17 +142,21 @@ module.exports = [
         },
     },
     {
-        zigbeeModel: ['902010/26'],
+        zigbeeModel: ['AV2010/26', '902010/26'],
         model: 'AV2010/26',
-        vendor: 'Bitron',
-        description: 'Wireless socket and brightness regulator',
-        extend: extend.light_onoff_brightness(),
+        vendor: 'SMaBiT (Bitron Video)',
+        description: 'Wireless socket with dimmer',
+        extend: extend.light_onoff_brightness({noConfigure: true}),
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'genLevelCtrl']);
+        },
     },
     {
-        zigbeeModel: ['902010/28'],
-        model: '902010/128',
-        vendor: 'Bitron',
-        description: 'Home wireless socket',
+        zigbeeModel: ['AV2010/28', '902010/28'],
+        model: 'AV2010/28',
+        vendor: 'SMaBiT (Bitron Video)',
+        description: 'Wireless socket',
         extend: extend.switch(),
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
@@ -75,24 +164,34 @@ module.exports = [
         },
     },
     {
-        zigbeeModel: ['AV2010/29A'],
+        zigbeeModel: ['AV2010/29', '902010/29'],
+        model: 'AV2010/29',
+        vendor: 'SMaBiT (Bitron Video)',
+        description: 'Outdoor siren',
+        fromZigbee: [fz.battery],
+        toZigbee: [tz.warning],
+        exposes: [e.battery_low(), e.tamper(), e.warning()],
+    },
+    {
+        zigbeeModel: ['AV2010/29A', '902010/29A'],
         model: 'AV2010/29A',
-        vendor: 'Bitron',
-        description: 'SMaBiT Zigbee outdoor siren',
+        vendor: 'SMaBiT (Bitron Video)',
+        description: 'Outdoor siren',
         fromZigbee: [fz.ias_siren],
         toZigbee: [tz.warning, tz.squawk],
         exposes: [e.warning(), e.squawk(), e.battery_low(), e.tamper()],
     },
     {
-        zigbeeModel: ['902010/32'],
+        zigbeeModel: ['AV2010/32', '902010/32'],
         model: 'AV2010/32',
-        vendor: 'Bitron',
+        vendor: 'SMaBiT (Bitron Video)',
         description: 'Wireless wall thermostat with relay',
-        fromZigbee: [fz.legacy.bitron_thermostat_att_report, fz.battery],
+        fromZigbee: [fz.legacy.bitron_thermostat_att_report, fz.battery, fz.hvac_user_interface],
         toZigbee: [tz.thermostat_occupied_heating_setpoint, tz.thermostat_local_temperature_calibration, tz.thermostat_local_temperature,
-            tz.thermostat_running_state, tz.thermostat_temperature_display_mode, tz.thermostat_system_mode],
+            tz.thermostat_running_state, tz.thermostat_temperature_display_mode, tz.thermostat_keypad_lockout, tz.thermostat_system_mode],
         exposes: [e.battery(), exposes.climate().withSetpoint('occupied_heating_setpoint', 7, 30, 0.5).withLocalTemperature()
-            .withSystemMode(['off', 'auto', 'heat']).withRunningState(['idle', 'heat', 'cool']).withLocalTemperatureCalibration()],
+            .withSystemMode(['off', 'auto', 'heat']).withRunningState(['idle', 'heat', 'cool'])
+            .withLocalTemperatureCalibration(), e.keypad_lockout()],
         meta: {battery: {voltageToPercentage: '3V_2500_3200'}},
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
@@ -109,52 +208,34 @@ module.exports = [
         },
     },
     {
-        zigbeeModel: ['902010/21A'],
-        model: 'AV2010/21A',
-        vendor: 'Bitron',
-        description: 'Compact magnetic contact sensor',
-        fromZigbee: [fz.ias_contact_alarm_1],
+        zigbeeModel: ['AV2010/33', '902010/33'],
+        model: 'AV2010/33',
+        vendor: 'SMaBiT (Bitron Video)',
+        description: 'Vibration sensor',
+        fromZigbee: [fz.ias_occupancy_alarm_2],
         toZigbee: [],
-        exposes: [e.contact(), e.battery_low(), e.tamper()],
-    },
-    {
-        zigbeeModel: ['902010/24A'],
-        model: 'AV2010/24A',
-        vendor: 'Bitron',
-        description: 'Optical smoke detector (hardware version v2)',
-        fromZigbee: [fz.ias_smoke_alarm_1],
-        toZigbee: [tz.warning],
-        exposes: [e.smoke(), e.battery_low(), e.tamper(), e.warning()],
-    },
-    {
-        zigbeeModel: ['902010/24'],
-        model: '902010/24',
-        vendor: 'Bitron',
-        description: 'Optical smoke detector (hardware version v1)',
-        fromZigbee: [fz.ias_smoke_alarm_1],
-        toZigbee: [tz.warning],
-        exposes: [e.smoke(), e.battery_low(), e.tamper(), e.warning()],
-    },
-    {
-        zigbeeModel: ['902010/29'],
-        model: '902010/29',
-        vendor: 'Bitron',
-        description: 'Zigbee outdoor siren',
-        fromZigbee: [fz.battery],
-        toZigbee: [tz.warning],
-        exposes: [e.battery_low(), e.tamper(), e.warning()],
+        exposes: [e.occupancy(), e.battery_low()],
     },
     {
-        zigbeeModel: ['902010/23'],
-        model: '902010/23',
-        vendor: 'Bitron',
-        description: '4 button Zigbee remote control',
-        fromZigbee: [fz.ias_no_alarm, fz.command_on, fz.command_off, fz.command_step, fz.command_recall],
+        zigbeeModel: ['AV2010/34', '902010/34'],
+        model: 'AV2010/34',
+        vendor: 'SMaBiT (Bitron Video)',
+        description: 'Wall switch with 4 buttons',
+        fromZigbee: [fz.command_recall],
         toZigbee: [],
-        exposes: [e.action(['on', 'off', 'brightness_step_up', 'brightness_step_down', 'recall_*']), e.battery_low()],
-        configure: async (device, coordinatorEndpoint) => {
+        exposes: [e.action(['recall_*'])],
+        configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
-            await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg', 'genBasic', 'genOnOff', 'genLevelCtrl']);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'genScenes']);
         },
     },
+    {
+        zigbeeModel: ['AV2010/37', '902010/37'],
+        model: 'AV2010/37',
+        vendor: 'SMaBiT (Bitron Video)',
+        description: 'Water detector with siren',
+        fromZigbee: [fz.ias_water_leak_alarm_1],
+        toZigbee: [],
+        exposes: [e.water_leak(), e.battery_low()],
+    },
 ];

package/devices/custom_devices_diy.js

@@ -195,4 +195,25 @@ module.exports = [
         },
         exposes: [e.soil_moisture(), e.battery(), e.temperature()],
     },
+    {
+        zigbeeModel: ['EFEKTA_THP_LR'],
+        model: 'EFEKTA_THP_LR',
+        vendor: 'Custom devices (DiY)',
+        description: 'DIY outdoor long-range sensor for temperature, humidity and atmospheric pressure',
+        fromZigbee: [fz.temperature, fz.humidity, fz.pressure, fz.battery],
+        toZigbee: [tz.factory_reset],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, [
+                'genPowerCfg', 'msTemperatureMeasurement', 'msRelativeHumidity', 'msPressureMeasurement']);
+            const overides = {min: 0, max: 64800, change: 0};
+            await reporting.batteryVoltage(endpoint, overides);
+            await reporting.batteryPercentageRemaining(endpoint, overides);
+            await reporting.temperature(endpoint, overides);
+            await reporting.humidity(endpoint, overides);
+            await reporting.pressureExtended(endpoint, overides);
+            await endpoint.read('msPressureMeasurement', ['scale']);
+        },
+        exposes: [e.battery(), e.temperature(), e.humidity(), e.pressure()],
+    },
 ];

package/devices/elko.js

@@ -29,15 +29,21 @@ module.exports = [
         fromZigbee: [fz.elko_thermostat, fz.thermostat],
         toZigbee: [tz.thermostat_occupied_heating_setpoint, tz.thermostat_occupied_heating_setpoint,
             tz.elko_display_text, tz.elko_power_status, tz.elko_external_temp, tz.elko_mean_power, tz.elko_child_lock, tz.elko_frost_guard,
-            tz.elko_relay_state, tz.elko_sensor_mode, tz.elko_local_temperature_calibration, tz.elko_max_floor_temp],
+            tz.elko_relay_state, tz.elko_sensor_mode, tz.elko_local_temperature_calibration, tz.elko_max_floor_temp,
+            tz.elko_regulator_mode, tz.elko_regulator_time, tz.elko_night_switching],
         exposes: [exposes.text('display_text', ea.ALL).withDescription('Displayed text on thermostat display (zone). Max 14 characters'),
+            exposes.binary('regulator_mode', ea.ALL, 'regulator', 'thermostat')
+                .withDescription('Device in regulator or thermostat mode.'),
+            exposes.numeric('regulator_time', ea.ALL).withUnit('min')
+                .withValueMin(5).withValueMax(20).withDescription('When device is in regulator mode this controls the time between each ' +
+                'in/out connection. When device is in thermostat mode this controls the  time between each in/out switch when measured ' +
+                'temperature is within +-0.5 °C set temperature. Choose a long time for (slow) concrete floors and a short time for ' +
+                '(quick) wooden floors.'),
             exposes.climate().withSetpoint('occupied_heating_setpoint', 5, 50, 1)
-                .withLocalTemperature(ea.STATE).withSystemMode(['off', 'heat']).withRunningState(['idle', 'heat'])
-                .withLocalTemperatureCalibration(),
-            exposes.enum('sensor_mode', ea.ALL, ['air', 'floor', 'supervisor_floor'])
-                .withDescription('"air" = Thermostat uses air sensor.' +
-                  '"floor" = Thermostat uses floor sensor. ' +
-                  '"supervisor_floor" = Thermostat uses air sensor and with max temperatur from "max_floor_temp"'),
+                .withLocalTemperature(ea.STATE)
+                .withLocalTemperatureCalibration()
+                .withSystemMode(['off', 'heat']).withRunningState(['idle', 'heat'])
+                .withSensor(['air', 'floor', 'supervisor_floor']),
             exposes.numeric('floor_temp', ea.STATE_GET).withUnit('°C')
                 .withDescription('Current temperature measured from the floor sensor'),
             exposes.numeric('max_floor_temp', ea.ALL).withUnit('°C')
@@ -51,6 +57,8 @@ module.exports = [
                 .withDescription('When frost guard is ON, it is activated when the thermostat is switched OFF with the ON/OFF button.' +
                 'At the same time, the display will fade and the text "Frostsikring x °C" appears in the display and remains until the ' +
                 'thermostat is switched on again.'),
+            exposes.binary('night_switching', ea.ALL, 'on', 'off')
+                .withDescription('Turn on or off night setting.'),
         ],
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
@@ -68,7 +76,6 @@ module.exports = [
                 maximumReportInterval: constants.repInterval.HOUR,
                 reportableChange: null,
             }]);
-
             // Power consumption
             await endpoint.configureReporting('hvacThermostat', [{
                 attribute: 'elkoMeanPower',
@@ -76,7 +83,6 @@ module.exports = [
                 maximumReportInterval: constants.repInterval.HOUR,
                 reportableChange: 5,
             }]);
-
             // External temp sensor (floor)
             await endpoint.configureReporting('hvacThermostat', [{
                 attribute: 'elkoExternalTemp',
@@ -84,7 +90,6 @@ module.exports = [
                 maximumReportInterval: constants.repInterval.HOUR,
                 reportableChange: 10,
             }]);
-
             // Child lock active/inactive
             await endpoint.configureReporting('hvacThermostat', [{
                 attribute: 'elkoChildLock',
@@ -92,14 +97,20 @@ module.exports = [
                 maximumReportInterval: constants.repInterval.HOUR,
                 reportableChange: null,
             }]);
-
+            // Night switching
+            await endpoint.configureReporting('hvacThermostat', [{
+                attribute: 'elkoNightSwitching',
+                minimumReportInterval: 0,
+                maximumReportInterval: constants.repInterval.HOUR,
+                reportableChange: null,
+            }]);
+            // Frost guard
             await endpoint.configureReporting('hvacThermostat', [{
                 attribute: 'elkoFrostGuard',
                 minimumReportInterval: 0,
                 maximumReportInterval: constants.repInterval.HOUR,
                 reportableChange: null,
             }]);
-
             // Heating active/inactive
             await endpoint.configureReporting('hvacThermostat', [{
                 attribute: 'elkoRelayState',
@@ -107,7 +118,6 @@ module.exports = [
                 maximumReportInterval: constants.repInterval.HOUR,
                 reportableChange: null,
             }]);
-
             // Max floor temp
             await endpoint.configureReporting('hvacThermostat', [{
                 attribute: 'elkoMaxFloorTemp',
@@ -116,6 +126,20 @@ module.exports = [
                 reportableChange: 1,
             }]);
 
+            // Regulator mode
+            await endpoint.configureReporting('hvacThermostat', [{
+                attribute: 'elkoRegulatorMode',
+                minimumReportInterval: 0,
+                maximumReportInterval: constants.repInterval.HOUR,
+                reportableChange: null,
+            }]);
+            // Regulator time
+            await endpoint.configureReporting('hvacThermostat', [{
+                attribute: 'elkoRegulatorTime',
+                minimumReportInterval: 0,
+                maximumReportInterval: constants.repInterval.HOUR,
+                reportableChange: 1,
+            }]);
             // Trigger read
             await endpoint.read('hvacThermostat', ['elkoDisplayText', 'elkoSensor']);
 

package/devices/heiman.js

@@ -669,4 +669,18 @@ module.exports = [
         toZigbee: [],
         exposes: [e.occupancy(), e.battery_low(), e.tamper()],
     },
+    {
+        fingerprint: [{modelID: 'DoorBell-EM', manufacturerName: 'HEIMAN'}],
+        model: 'HS2DB',
+        vendor: 'HEIMAN',
+        description: 'Smart doorbell button',
+        fromZigbee: [fz.battery, fz.heiman_doorbell_button, fz.ignore_basic_report],
+        toZigbee: [],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg']);
+            await reporting.batteryPercentageRemaining(endpoint);
+        },
+        exposes: [e.battery(), e.action(['pressed']), e.battery_low(), e.tamper()],
+    },
 ];

package/devices/ikea.js

@@ -340,7 +340,7 @@ module.exports = [
             fz.ikea_arrow_release],
         exposes: [e.battery(), e.action(['arrow_left_click', 'arrow_left_hold', 'arrow_left_release', 'arrow_right_click',
             'arrow_right_hold', 'arrow_right_release', 'brightness_down_click', 'brightness_down_hold', 'brightness_down_release',
-            'brightness_up_click', 'brightness_up_hold', 'brightness_up_release'])],
+            'brightness_up_click', 'brightness_up_hold', 'brightness_up_release', 'toggle'])],
         toZigbee: [],
         ota: ota.tradfri,
         meta: {battery: {dontDividePercentage: true}},
@@ -599,4 +599,25 @@ module.exports = [
         description: 'TRADFRI LED bulb E14 WW clear 250 lumen, dimmable',
         extend: tradfriExtend.light_onoff_brightness(),
     },
+    {
+        zigbeeModel: ['TTRADFRIbulbGU10WS345lm'],
+        model: 'LED2005R5',
+        vendor: 'IKEA',
+        description: 'TRADFRI LED bulb GU10 345 lumen, dimmable, white spectrum',
+        extend: tradfriExtend.light_onoff_brightness_colortemp(),
+    },
+    {
+        zigbeeModel: ['STARKVIND Air purifier'],
+        model: 'E3007',
+        vendor: 'IKEA',
+        description: 'STARKVIND air purifier',
+        exposes: [e.fan().withModes(['off', 'low', 'medium', 'high', 'on', 'auto'])],
+        fromZigbee: [fz.fan],
+        toZigbee: [tz.fan_mode],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['hvacFanCtrl']);
+            await reporting.fanMode(endpoint);
+        },
+    },
 ];

package/devices/legrand.js

@@ -158,14 +158,22 @@ module.exports = [
         // led blink RED when battery is low
         description: 'Wired switch without neutral',
         extend: extend.light_onoff_brightness({noConfigure: true}),
-        fromZigbee: [fz.brightness, fz.identify, fz.on_off],
+        fromZigbee: [fz.brightness, fz.identify, fz.on_off, fz.lighting_ballast_configuration],
         toZigbee: [tz.light_onoff_brightness, tz.legrand_settingAlwaysEnableLed, tz.legrand_settingEnableLedIfOn,
-            tz.legrand_settingEnableDimmer, tz.legrand_identify],
-        exposes: [e.light_brightness()],
+            tz.legrand_settingEnableDimmer, tz.legrand_identify, tz.ballast_config],
+        exposes: [e.light_brightness(),
+            exposes.numeric('ballast_minimum_level', ea.ALL).withValueMin(1).withValueMax(254)
+                .withDescription('Specifies the minimum brightness value'),
+            exposes.numeric('ballast_maximum_level', ea.ALL).withValueMin(1).withValueMax(254)
+                .withDescription('Specifies the maximum brightness value'),
+            exposes.binary('dimmer_enabled', ea.STATE_SET, 'ON', 'OFF').withDescription('Allow the device to change brightness'),
+            exposes.binary('permanent_led', ea.STATE_SET, 'ON', 'OFF').withDescription('Enable or disable the permanent blue LED'),
+            exposes.binary('led_when_on', ea.STATE_SET, 'ON', 'OFF').withDescription('Enables the LED when the light is on')],
         configure: async (device, coordinatorEndpoint, logger) => {
             await extend.light_onoff_brightness().configure(device, coordinatorEndpoint, logger);
             const endpoint = device.getEndpoint(1);
-            await reporting.bind(endpoint, coordinatorEndpoint, ['genIdentify', 'genOnOff', 'genLevelCtrl', 'genBinaryInput']);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genIdentify', 'genOnOff', 'genLevelCtrl',
+                'genBinaryInput', 'lightingBallastCfg']);
             await reporting.onOff(endpoint);
             await reporting.brightness(endpoint);
         },

package/devices/linkind.js

@@ -5,8 +5,43 @@ const reporting = require('../lib/reporting');
 const extend = require('../lib/extend');
 const e = exposes.presets;
 const ea = exposes.access;
+const globalStore = require('../lib/store');
 
 module.exports = [
+    {
+        zigbeeModel: ['ZB-KeypadGeneric-D0002'],
+        model: 'ZS130000078',
+        vendor: 'Linkind',
+        description: 'Security keypad battery',
+        meta: {battery: {voltageToPercentage: '3V_2100'}},
+        fromZigbee: [fz.command_arm_with_transaction, fz.battery, fz.ias_ace_occupancy_with_timeout,
+            fz.ias_smoke_alarm_1, fz.command_panic],
+        exposes: [e.battery(), e.battery_voltage(), e.battery_low(), e.occupancy(), e.tamper(),
+            exposes.numeric('action_code', ea.STATE).withDescription('Pin code introduced.'),
+            exposes.numeric('action_transaction', ea.STATE).withDescription('Last action transaction number.'),
+            exposes.text('action_zone', ea.STATE).withDescription('Alarm zone. Default value 23'),
+            e.action([
+                'panic', 'disarm', 'arm_day_zones', 'arm_all_zones', 'exit_delay', 'entry_delay'])],
+        toZigbee: [tz.arm_mode],
+        configure: async (device, coordinatorEndpoint) => {
+            const endpoint = device.getEndpoint(1);
+            const clusters = ['genPowerCfg', 'ssIasZone', 'ssIasAce', 'genBasic', 'genIdentify'];
+            await reporting.bind(endpoint, coordinatorEndpoint, clusters);
+            await reporting.batteryVoltage(endpoint);
+        },
+        onEvent: async (type, data, device) => {
+            if (type === 'message' && data.type === 'commandGetPanelStatus' && data.cluster === 'ssIasAce' &&
+                globalStore.hasValue(device.getEndpoint(1), 'panelStatus')) {
+                const payload = {
+                    panelstatus: globalStore.getValue(device.getEndpoint(1), 'panelStatus'),
+                    secondsremain: 0x00, audiblenotif: 0x00, alarmstatus: 0x00,
+                };
+                await device.getEndpoint(1).commandResponse(
+                    'ssIasAce', 'getPanelStatusRsp', payload, {}, data.meta.zclTransactionSequenceNumber,
+                );
+            }
+        },
+    },
     {
         zigbeeModel: ['ZBT-RGBWSwitch-D0801'],
         model: 'ZS230002',

package/devices/moes.js

@@ -99,8 +99,12 @@ module.exports = [
         exposes: [e.switch().setAccess('state', ea.STATE_SET)],
         fromZigbee: [fz.tuya_switch],
         toZigbee: [tz.tuya_switch_state],
+        onEvent: tuya.onEventSetLocalTime,
         configure: async (device, coordinatorEndpoint, logger) => {
             await reporting.bind(device.getEndpoint(1), coordinatorEndpoint, ['genOnOff']);
+            // Reports itself as battery which is not correct: https://github.com/Koenkk/zigbee2mqtt/issues/6190
+            device.powerSource = 'Mains (single phase)';
+            device.save();
         },
     },
     {
@@ -112,6 +116,7 @@ module.exports = [
             e.switch().withEndpoint('l2').setAccess('state', ea.STATE_SET)],
         fromZigbee: [fz.ignore_basic_report, fz.tuya_switch],
         toZigbee: [tz.tuya_switch_state],
+        onEvent: tuya.onEventSetLocalTime,
         meta: {multiEndpoint: true},
         endpoint: (device) => {
             // Endpoint selection is made in tuya_switch_state
@@ -134,6 +139,7 @@ module.exports = [
             e.switch().withEndpoint('l2').setAccess('state', ea.STATE_SET), e.switch().withEndpoint('l3').setAccess('state', ea.STATE_SET)],
         fromZigbee: [fz.ignore_basic_report, fz.tuya_switch],
         toZigbee: [tz.tuya_switch_state],
+        onEvent: tuya.onEventSetLocalTime,
         meta: {multiEndpoint: true},
         endpoint: (device) => {
             // Endpoint selection is made in tuya_switch_state

package/devices/paulmann.js

@@ -39,6 +39,13 @@ module.exports = [
         description: 'Smart Home Zigbee YourLED RGB Controller max. 60W / Smart Home Zigbee LED Reflektor 3,5W GU10 RGBW dimmbar',
         extend: extend.light_onoff_brightness_colortemp_color(),
     },
+    {
+        zigbeeModel: ['RGBCW_LIGHT'],
+        model: '4137',
+        vendor: 'Paulmann',
+        description: 'Smart Home Zigbee LED bulb 9,3W Matt E27 RGBW',
+        extend: extend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 370]}),
+    },
     {
         zigbeeModel: ['CCT light'],
         model: '50064',

package/devices/philips.js

@@ -1964,7 +1964,7 @@ module.exports = [
         vendor: 'Philips',
         description: 'Hue White and Color Ambiance A19 1100 lumen',
         meta: {turnsOffAtBrightness1: true},
-        extend: extend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 500]}),
+        extend: hueExtend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 500]}),
         ota: ota.zigbeeOTA,
     },
     {

package/devices/plaid.js

@@ -0,0 +1,23 @@
+const fz = require('zigbee-herdsman-converters/converters/fromZigbee');
+const exposes = require('zigbee-herdsman-converters/lib/exposes');
+const reporting = require('zigbee-herdsman-converters/lib/reporting');
+const e = exposes.presets;
+
+module.exports = [
+    {
+        fingerprint: [{modelID: 'PS-SPRZMS-SLP3', manufacturerName: 'PLAID SYSTEMS'}],
+        zigbeeModel: ['PS-SPRZMS-SLP3'],
+        model: 'PS-SPRZMS-SLP3',
+        vendor: 'PLAID SYSTEMS',
+        description: 'Spruce temperature and moisture sensor',
+        toZigbee: [],
+        fromZigbee: [fz.temperature, fz.humidity],
+        exposes: [e.humidity(), e.temperature()],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['msTemperatureMeasurement', 'msRelativeHumidity']);
+            await reporting.temperature(endpoint);
+            await reporting.humidity(endpoint);
+        },
+    },
+];

package/devices/schlage.js

@@ -10,14 +10,15 @@ module.exports = [
         model: 'BE468',
         vendor: 'Schlage',
         description: 'Connect smart deadbolt',
-        fromZigbee: [fz.lock, fz.lock_operation_event, fz.battery],
-        toZigbee: [tz.lock],
+        fromZigbee: [fz.lock, fz.lock_operation_event, fz.battery, fz.lock_pin_code_response, fz.lock_programming_event],
+        toZigbee: [tz.lock, tz.pincode_lock],
+        meta: {pinCodeCount: 30},
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.endpoints[0];
             await reporting.bind(endpoint, coordinatorEndpoint, ['closuresDoorLock', 'genPowerCfg']);
             await reporting.lockState(endpoint);
             await reporting.batteryPercentageRemaining(endpoint);
         },
-        exposes: [e.lock(), e.battery()],
+        exposes: [e.lock(), e.battery(), e.pincode()],
     },
 ];

package/devices/tuya.js

@@ -132,7 +132,8 @@ module.exports = [
         meta: {applyRedFix: true},
     },
     {
-        fingerprint: [{modelID: 'TS0501B', manufacturerName: '_TZ3000_4whigl8i'}],
+        fingerprint: [{modelID: 'TS0501B', manufacturerName: '_TZ3000_4whigl8i'},
+            {modelID: 'TS0501B', manufacturerName: '_TZ3210_4whigl8i'}],
         model: 'TS0501B',
         description: 'Zigbee light',
         vendor: 'TuYa',
@@ -881,14 +882,20 @@ module.exports = [
         exposes: [e.humidity(), e.temperature(), e.battery()],
     },
     {
+        fingerprint: [{modelID: 'TS0011', manufacturerName: '_TZ3000_l8fsgo6p'}],
         zigbeeModel: ['TS0011'],
         model: 'TS0011',
         vendor: 'TuYa',
         description: 'Smart light switch - 1 gang',
         extend: extend.switch(),
-        whiteLabel: [{vendor: 'Vrey', model: 'VR-X712U-0013'}, {vendor: 'TUYATEC', model: 'GDKES-01TZXD'},
-            {vendor: 'Lonsonho', model: 'QS-Zigbee-S05-L', description: '1 gang smart switch module without neutral wire'}],
+        whiteLabel: [
+            {vendor: 'Vrey', model: 'VR-X712U-0013'},
+            {vendor: 'TUYATEC', model: 'GDKES-01TZXD'},
+            {vendor: 'Lonsonho', model: 'QS-Zigbee-S05-L', description: '1 gang smart switch module without neutral wire'},
+            {vendor: 'Mercator ikuü', model: 'SSW01'},
+        ],
         configure: async (device, coordinatorEndpoint, logger) => {
+            await reporting.bind(device.getEndpoint(1), coordinatorEndpoint, ['genOnOff']);
             // Reports itself as battery which is not correct: https://github.com/Koenkk/zigbee2mqtt/issues/6190
             device.powerSource = 'Mains (single phase)';
             device.save();

package/lib/exposes.js

@@ -494,7 +494,7 @@ module.exports = {
         humidity: () => new Numeric('humidity', access.STATE).withUnit('%').withDescription('Measured relative humidity'),
         illuminance: () => new Numeric('illuminance', access.STATE).withDescription('Raw measured illuminance'),
         illuminance_lux: () => new Numeric('illuminance_lux', access.STATE).withUnit('lx').withDescription('Measured illuminance in lux'),
-        keypad_lockout: () => new Binary('keypad_lockout', access.ALL, 'lock1', 'unlock').withDescription('Enables/disables physical input on the device'),
+        keypad_lockout: () => new Enum('keypad_lockout', access.ALL, ['unlock', 'lock1', 'lock2']).withDescription('Enables/disables physical input on the device'),
         led_disabled_night: () => new Binary('led_disabled_night', access.ALL, true, false).withDescription('Enable/disable the LED at night'),
         light_brightness: () => new Light().withBrightness(),
         light_brightness_color: () => new Light().withBrightness().withColor((['xy', 'hs'])),

package/npm-shrinkwrap.json

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

package/package.json

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

package/devices/smabit.js

@@ -1,15 +0,0 @@
-const exposes = require('../lib/exposes');
-const fz = {...require('../converters/fromZigbee'), legacy: require('../lib/legacy').fromZigbee};
-const e = exposes.presets;
-
-module.exports = [
-    {
-        zigbeeModel: ['AV2010/21C'],
-        model: 'AV2010/21C',
-        vendor: 'SMaBiT',
-        description: 'Ultra-flat magnetic contact sensor ',
-        fromZigbee: [fz.ias_contact_alarm_1],
-        toZigbee: [],
-        exposes: [e.contact(), e.battery_low(), e.tamper()],
-    },
-];