zigbee-herdsman-converters 14.0.315 → 14.0.319

package/converters/fromZigbee.js

@@ -648,6 +648,26 @@ const converters = {
             return payload;
         },
     },
+    develco_metering: {
+        cluster: 'seMetering',
+        type: ['attributeReport', 'readResponse'],
+        convert: (model, msg, publish, options, meta) => {
+            const result = {};
+            if (msg.data.hasOwnProperty('develcoPulseConfiguration')) {
+                result[postfixWithEndpointName('pulse_configuration', msg, model)] =
+                    msg.data['develcoPulseConfiguration'];
+            }
+
+            if (msg.data.hasOwnProperty('develcoInterfaceMode')) {
+                result[postfixWithEndpointName('interface_mode', msg, model)] =
+                    constants.develcoInterfaceMode.hasOwnProperty(msg.data['develcoInterfaceMode']) ?
+                        constants.develcoInterfaceMode[msg.data['develcoInterfaceMode']] :
+                        msg.data['develcoInterfaceMode'];
+            }
+
+            return result;
+        },
+    },
     electrical_measurement: {
         /**
          * When using this converter also add the following to the configure method of the device:
@@ -2485,6 +2505,22 @@ const converters = {
             }
         },
     },
+    livolo_curtain_switch_state: {
+        cluster: 'genPowerCfg',
+        type: ['raw'],
+        convert: (model, msg, publish, options, meta) => {
+            const stateHeader = Buffer.from([122, 209]);
+            if (msg.data.indexOf(stateHeader) === 0) {
+                if (msg.data[10] === 5) {
+                    const status = msg.data[14];
+                    return {
+                        state_left: status === 1 ? 'ON' : 'OFF',
+                        state_right: status === 0 ? 'ON' : 'OFF',
+                    };
+                }
+            }
+        },
+    },
     livolo_dimmer_state: {
         cluster: 'genPowerCfg',
         type: ['raw'],
@@ -2592,16 +2628,24 @@ const converters = {
             [124,210,21,216,128,  199,147,3,24,0,75,18,0,  19,7,0]       after interview
             [122,209,             199,147,3,24,0,75,18,0,  7,1,6,1,0,11] off
             [122,209,             199,147,3,24,0,75,18,0,  7,1,6,1,1,11] on
+
             new switch
             [124,210,21,216,128,  228,41,3,24,0,75,18,0,  19,1,0]       after interview
             [122,209,             228,41,3,24,0,75,18,0,  7,1,0,1,0,11] off
             [122,209,             228,41,3,24,0,75,18,0,  7,1,0,1,1,11] on
+
             old switch
             [124,210,21,216,128,  170, 10,2,24,0,75,18,0,  17,0,1] after interview
             [124,210,21,216,0,     18, 15,5,24,0,75,18,0,  34,0,0] left: 0, right: 0
             [124,210,21,216,0,     18, 15,5,24,0,75,18,0,  34,0,1] left: 1, right: 0
             [124,210,21,216,0,     18, 15,5,24,0,75,18,0,  34,0,2] left: 0, right: 1
             [124,210,21,216,0,     18, 15,5,24,0,75,18,0,  34,0,3] left: 1, right: 1
+
+            curtain switch
+            [124,210,21,216,128,  110,74,116,33,0,75,18,0,  19,5,0]        after interview
+            [122,209,             110,74,116,33,0,75,18,0,  5,1,5,0,2,11]  left: 0, right: 0  (off)
+            [122,209,             110,74,116,33,0,75,18,0,  5,1,5,0,1,11]  left: 1, right: 0  (left on)
+            [122,209,             110,74,116,33,0,75,18,0,  5,1,5,0,0,11]  left: 0, right: 1  (right on)
             */
             const malformedHeader = Buffer.from([0x7c, 0xd2, 0x15, 0xd8, 0x00]);
             const infoHeader = Buffer.from([0x7c, 0xd2, 0x15, 0xd8, 0x80]);
@@ -2630,6 +2674,12 @@ const converters = {
                     meta.device.modelID = 'TI0001-switch-2gang';
                     meta.device.save();
                 }
+                if (msg.data.includes(Buffer.from([19, 5, 0]), 13)) {
+                    if (meta.logger) meta.logger.debug('Detected Livolo Curtain Switch');
+                    // curtain switch, hack
+                    meta.device.modelID = 'TI0001-curtain-switch';
+                    meta.device.save();
+                }
                 if (msg.data.includes(Buffer.from([19, 20, 0]), 13)) {
                     // new dimmer, hack
                     meta.device.modelID = 'TI0001-dimmer';
@@ -4245,6 +4295,79 @@ const converters = {
             }
         },
     },
+    ikea_air_purifier: {
+        cluster: 'manuSpecificIkeaAirPurifier',
+        type: ['attributeReport', 'readResponse'],
+        options: [exposes.options.precision('pm25'), exposes.options.calibration('pm25')],
+        convert: (model, msg, publish, options, meta) => {
+            const state = {};
+
+            if (msg.data.hasOwnProperty('particulateMatter25Measurement')) {
+                const pm25Property = postfixWithEndpointName('pm25', msg, model);
+                let pm25 = parseFloat(msg.data['particulateMatter25Measurement']);
+
+                // Air Quality Scale (ikea app):
+                // 0-35=Good, 35-80=OK, 80+=Not Good
+                let airQuality;
+                const airQualityProperty = postfixWithEndpointName('air_quality', msg, model);
+                if (pm25 <= 35) {
+                    airQuality = 'good';
+                } else if (pm25 <= 80) {
+                    airQuality = 'ok';
+                } else if (pm25 < 65535) {
+                    airQuality = 'not_good';
+                } else {
+                    airQuality = 'unknown';
+                }
+
+                // calibrate and round pm25 unless invalid
+                pm25 = (pm25 == 65535) ? -1 : calibrateAndPrecisionRoundOptions(pm25, options, 'pm25');
+
+                state[pm25Property] = calibrateAndPrecisionRoundOptions(pm25, options, 'pm25');
+                state[airQualityProperty] = airQuality;
+            }
+
+            if (msg.data.hasOwnProperty('filterRunTime')) {
+                // Filter needs to be replaced after 6 months
+                state['replace_filter'] = (parseInt(msg.data['filterRunTime']) >= 259200);
+            }
+
+            if (msg.data.hasOwnProperty('controlPanelLight')) {
+                state['led_enable'] = (msg.data['controlPanelLight'] == 0);
+            }
+
+            if (msg.data.hasOwnProperty('childLock')) {
+                state['child_lock'] = (msg.data['childLock'] > 0 ? 'LOCK' : 'UNLOCK');
+            }
+
+            if (msg.data.hasOwnProperty('fanSpeed')) {
+                let fanSpeed = msg.data['fanSpeed'];
+                if (fanSpeed >= 10) {
+                    fanSpeed = (((fanSpeed - 5) * 2) / 10);
+                } else {
+                    fanSpeed = 0;
+                }
+
+                state['fan_speed'] = fanSpeed;
+            }
+
+            if (msg.data.hasOwnProperty('fanMode')) {
+                let fanMode = msg.data['fanMode'];
+                if (fanMode >= 10) {
+                    fanMode = (((fanMode - 5) * 2) / 10).toString();
+                } else if (fanMode == 1) {
+                    fanMode = 'auto';
+                } else {
+                    fanMode = 'off';
+                }
+
+                state['fan_mode'] = fanMode;
+                state['fan_state'] = (fanMode === 'off' ? 'OFF' : 'ON');
+            }
+
+            return state;
+        },
+    },
     E1524_E1810_levelctrl: {
         cluster: 'genLevelCtrl',
         type: [

package/converters/toZigbee.js

@@ -15,7 +15,9 @@ const manufacturerOptions = {
     osram: {manufacturerCode: herdsman.Zcl.ManufacturerCode.OSRAM},
     eurotronic: {manufacturerCode: herdsman.Zcl.ManufacturerCode.JENNIC},
     danfoss: {manufacturerCode: herdsman.Zcl.ManufacturerCode.DANFOSS},
+    develco: {manufacturerCode: herdsman.Zcl.ManufacturerCode.DEVELCO},
     hue: {manufacturerCode: herdsman.Zcl.ManufacturerCode.PHILIPS},
+    ikea: {manufacturerCode: herdsman.Zcl.ManufacturerCode.IKEA_OF_SWEDEN},
     sinope: {manufacturerCode: herdsman.Zcl.ManufacturerCode.SINOPE_TECH},
     /*
      * Ubisys doesn't accept a manufacturerCode on some commands
@@ -328,7 +330,7 @@ const converters = {
 
             let info;
             // https://github.com/Koenkk/zigbee2mqtt/issues/8310 some devices require the info to be reversed.
-            if (['SIRZB-110', 'SRAC-23B-ZBSR', 'AV2010/29A'].includes(meta.mapped.model)) {
+            if (['SIRZB-110', 'SRAC-23B-ZBSR', 'AV2010/29A', 'AV2010/24A'].includes(meta.mapped.model)) {
                 info = (mode[values.mode]) + ((values.strobe ? 1 : 0) << 4) + (level[values.level] << 6);
             } else {
                 info = (mode[values.mode] << 4) + ((values.strobe ? 1 : 0) << 2) + (level[values.level]);
@@ -1910,6 +1912,71 @@ const converters = {
             await entity.read('genBasic', [0x0033], manufacturerOptions.hue);
         },
     },
+    ikea_air_purifier_fan_mode: {
+        key: ['fan_mode', 'fan_state'],
+        convertSet: async (entity, key, value, meta) => {
+            if (key == 'fan_state' && value.toLowerCase() == 'on') {
+                value = utils.getMetaValue(entity, meta.mapped, 'fanStateOn', 'allEqual', 'on');
+            }
+
+            let fanMode;
+            switch (value.toLowerCase()) {
+            case 'off':
+                fanMode = 0;
+                break;
+            case 'auto':
+                fanMode = 1;
+                break;
+            default:
+                fanMode = parseInt(((parseInt(value) / 2.0) * 10) + 5);
+            }
+
+            await entity.write('manuSpecificIkeaAirPurifier', {'fanMode': fanMode}, manufacturerOptions.ikea);
+            return {state: {fan_mode: value.toLowerCase(), fan_state: value.toLowerCase() === 'off' ? 'OFF' : 'ON'}};
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read('manuSpecificIkeaAirPurifier', ['fanMode']);
+        },
+    },
+    ikea_air_purifier_fan_speed: {
+        key: ['fan_speed'],
+        convertGet: async (entity, key, meta) => {
+            await entity.read('manuSpecificIkeaAirPurifier', ['fanSpeed']);
+        },
+    },
+    ikea_air_purifier_pm25: {
+        key: ['pm25', 'air_quality'],
+        convertGet: async (entity, key, meta) => {
+            await entity.read('manuSpecificIkeaAirPurifier', ['particulateMatter25Measurement']);
+        },
+    },
+    ikea_air_purifier_replace_filter: {
+        key: ['replace_filter'],
+        convertGet: async (entity, key, meta) => {
+            await entity.read('manuSpecificIkeaAirPurifier', ['filterRunTime']);
+        },
+    },
+    ikea_air_purifier_child_lock: {
+        key: ['child_lock'],
+        convertSet: async (entity, key, value, meta) => {
+            await entity.write('manuSpecificIkeaAirPurifier', {'childLock': ((value.toLowerCase() === 'lock') ? 1 : 0)},
+                manufacturerOptions.ikea);
+            return {state: {child_lock: ((value.toLowerCase() === 'lock') ? 'LOCK' : 'UNLOCK')}};
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read('manuSpecificIkeaAirPurifier', ['childLock']);
+        },
+    },
+    ikea_air_purifier_led_enable: {
+        key: ['led_enable'],
+        convertSet: async (entity, key, value, meta) => {
+            await entity.write('manuSpecificIkeaAirPurifier', {'controlPanelLight': ((value) ? 0 : 1)}, manufacturerOptions.ikea);
+            return {state: {led_enable: ((value) ? true : false)}};
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read('manuSpecificIkeaAirPurifier', ['controlPanelLight']);
+        },
+    },
     RTCGQ13LM_motion_sensitivity: {
         key: ['motion_sensitivity'],
         convertSet: async (entity, key, value, meta) => {
@@ -2569,6 +2636,34 @@ const converters = {
             await entity.read('haDiagnostic', ['danfossMultimasterRole'], manufacturerOptions.danfoss);
         },
     },
+    develco_pulse_configuration: {
+        key: ['pulse_configuration'],
+        convertSet: async (entity, key, value, meta) => {
+            await entity.write('seMetering', {'develcoPulseConfiguration': value}, manufacturerOptions.develco);
+            return {readAfterWriteTime: 200, state: {'pulse_configuration': value}};
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read('seMetering', ['develcoPulseConfiguration'], manufacturerOptions.develco);
+        },
+    },
+    develco_interface_mode: {
+        key: ['interface_mode'],
+        convertSet: async (entity, key, value, meta) => {
+            const payload = {'develcoInterfaceMode': utils.getKey(constants.develcoInterfaceMode, value, undefined, Number)};
+            await entity.write('seMetering', payload, manufacturerOptions.develco);
+            return {readAfterWriteTime: 200, state: {'interface_mode': value}};
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read('seMetering', ['develcoInterfaceMode'], manufacturerOptions.develco);
+        },
+    },
+    develco_current_summation: {
+        key: ['current_summation'],
+        convertSet: async (entity, key, value, meta) => {
+            await entity.write('seMetering', {'develcoCurrentSummation': value}, manufacturerOptions.develco);
+            return {state: {'current_summation': value}};
+        },
+    },
     ZMCSW032D_cover_position: {
         key: ['position', 'tilt'],
         convertSet: async (entity, key, value, meta) => {
@@ -2762,9 +2857,9 @@ const converters = {
                 await tuya.sendDataPointBool(entity, tuya.dataPoints.tvChildLock, value === 'LOCK');
                 break;
             case 'local_temperature_calibration':
-                // value = Math.round(value);
-                value = (value < 0) ? 0xFFFFFFFF + value + 1 : value;
-                await tuya.sendDataPointValue(entity, tuya.dataPoints.tvTempCalibration, value * 10);
+                if (value > 0) value = value*10;
+                if (value < 0) value = value*10 + 0x100000000;
+                await tuya.sendDataPointValue(entity, tuya.dataPoints.tvTempCalibration, value);
                 break;
             case 'current_heating_setpoint':
                 await tuya.sendDataPointValue(entity, tuya.dataPoints.tvHeatingSetpoint, value * 10);
@@ -5264,8 +5359,6 @@ const converters = {
     saswell_thermostat_calibration: {
         key: ['local_temperature_calibration'],
         convertSet: async (entity, key, value, meta) => {
-            if (value > 6) value = 6;
-            if (value < -6) value = -6;
             if (value < 0) value = 0xFFFFFFFF + value + 1;
             await tuya.sendDataPointValue(entity, tuya.dataPoints.saswellTempCalibration, value);
         },

package/devices/aurora_lighting.js

@@ -5,6 +5,31 @@ const reporting = require('../lib/reporting');
 const extend = require('../lib/extend');
 const e = exposes.presets;
 
+const batteryRotaryDimmer = (...endpointsIds) => ({
+    fromZigbee: [fz.battery, fz.command_on, fz.command_off, fz.command_step, fz.command_step_color_temperature],
+    toZigbee: [],
+    exposes: [e.battery(), e.action([
+        'on', 'off', 'brightness_step_up', 'brightness_step_down', 'color_temperature_step_up', 'color_temperature_step_down'])],
+    configure: async (device, coordinatorEndpoint, logger) => {
+        const endpoints = endpointsIds.map((endpoint) => device.getEndpoint(endpoint));
+
+        // Battery level is only reported on first endpoint
+        await reporting.batteryVoltage(endpoints[0]);
+
+        for await (const endpoint of endpoints) {
+            logger.debug(`processing endpoint ${endpoint.ID}`);
+            await reporting.bind(endpoint, coordinatorEndpoint,
+                ['genIdentify', 'genOnOff', 'genLevelCtrl', 'lightingColorCtrl']);
+
+            // The default is for the device to also report the on/off and
+            // brightness at the same time as sending on/off and step commands.
+            // Disable the reporting by setting the max interval to 0xFFFF.
+            await reporting.brightness(endpoint, {max: 0xFFFF});
+            await reporting.onOff(endpoint, {max: 0xFFFF});
+        }
+    },
+});
+
 module.exports = [
     {
         zigbeeModel: ['TWGU10Bulb50AU'],
@@ -167,38 +192,20 @@ module.exports = [
         model: 'AU-A1ZBR1GW',
         vendor: 'Aurora Lighting',
         description: 'AOne one gang wireless battery rotary dimmer',
-        fromZigbee: [fz.battery, fz.command_on, fz.command_off, fz.command_step, fz.command_step_color_temperature],
-        toZigbee: [],
-        exposes: [e.battery(), e.action([
-            'on', 'off', 'brightness_step_up', 'brightness_step_down', 'color_temperature_step_up', 'color_temperature_step_down'])],
         meta: {battery: {voltageToPercentage: '3V_2100'}},
-        configure: async (device, coordinatorEndpoint, logger) => {
-            const endpoint1 = device.getEndpoint(1);
-            await reporting.bind(endpoint1, coordinatorEndpoint,
-                ['genIdentify', 'genOnOff', 'genLevelCtrl', 'lightingColorCtrl', 'genPowerCfg']);
-            await reporting.batteryVoltage(endpoint1);
-        },
+        // One gang battery rotary dimmer with endpoint ID 1
+        ...batteryRotaryDimmer(1),
     },
     {
         zigbeeModel: ['2GBatteryDimmer50AU'],
         model: 'AU-A1ZBR2GW',
         vendor: 'Aurora Lighting',
         description: 'AOne two gang wireless battery rotary dimmer',
-        fromZigbee: [fz.battery, fz.command_on, fz.command_off, fz.command_step, fz.command_step_color_temperature],
-        toZigbee: [],
-        exposes: [e.battery(), e.action([
-            'on', 'off', 'brightness_step_up', 'brightness_step_down', 'color_temperature_step_up', 'color_temperature_step_down'])],
         meta: {multiEndpoint: true, battery: {voltageToPercentage: '3V_2100'}},
         endpoint: (device) => {
             return {'right': 1, 'left': 2};
         },
-        configure: async (device, coordinatorEndpoint, logger) => {
-            const endpoint1 = device.getEndpoint(1);
-            await reporting.bind(endpoint1, coordinatorEndpoint,
-                ['genIdentify', 'genOnOff', 'genLevelCtrl', 'lightingColorCtrl', 'genPowerCfg']);
-            await reporting.batteryVoltage(endpoint1);
-            const endpoint2 = device.getEndpoint(2);
-            await reporting.bind(endpoint2, coordinatorEndpoint, ['genIdentify', 'genOnOff', 'genLevelCtrl', 'lightingColorCtrl']);
-        },
+        // Two gang battery rotary dimmer with endpoint IDs 1 and 2
+        ...batteryRotaryDimmer(1, 2),
     },
 ];

package/devices/bitron.js

@@ -190,7 +190,7 @@ module.exports = [
             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(), e.keypad_lockout()],
+            .withLocalTemperatureCalibration(-20, 20, 1), e.keypad_lockout()],
         meta: {battery: {voltageToPercentage: '3V_2500_3200'}},
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);

package/devices/centralite.js

@@ -26,6 +26,26 @@ module.exports = [
             await reporting.activePower(endpoint);
         },
     },
+    {
+        zigbeeModel: ['4256050-ZHAC'],
+        model: '4256050-ZHAC',
+        vendor: 'Centralite',
+        description: '3-Series smart dimming outlet',
+        fromZigbee: [fz.restorable_brightness, fz.on_off, fz.electrical_measurement],
+        toZigbee: [tz.light_onoff_restorable_brightness],
+        exposes: [e.light_brightness(), e.power(), e.voltage(), e.current()],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'genLevelCtrl', 'haElectricalMeasurement']);
+            await reporting.onOff(endpoint);
+            // 4256050-ZHAC doesn't support reading 'acVoltageMultiplier' or 'acVoltageDivisor'
+            await endpoint.read('haElectricalMeasurement', ['acCurrentMultiplier', 'acCurrentDivisor']);
+            await endpoint.read('haElectricalMeasurement', ['acPowerMultiplier', 'acPowerDivisor']);
+            await reporting.rmsVoltage(endpoint, {change: 2}); // Voltage reports in V
+            await reporting.rmsCurrent(endpoint, {change: 10}); // Current reports in mA
+            await reporting.activePower(endpoint, {change: 2}); // Power reports in 0.1W
+        },
+    },
     {
         zigbeeModel: ['4257050-ZHAC'],
         model: '4257050-ZHAC',
@@ -154,7 +174,8 @@ module.exports = [
         exposes: [e.battery(), exposes.climate().withSetpoint('occupied_heating_setpoint', 10, 30, 1).withLocalTemperature()
             .withSystemMode(['off', 'heat', 'cool', 'emergency_heating'])
             .withRunningState(['idle', 'heat', 'cool', 'fan_only']).withFanMode(['auto', 'on'])
-            .withSetpoint('occupied_cooling_setpoint', 10, 30, 1).withLocalTemperatureCalibration()],
+            .withSetpoint('occupied_cooling_setpoint', 10, 30, 1)
+            .withLocalTemperatureCalibration(-20, 20, 1)],
         meta: {battery: {voltageToPercentage: '3V_1500_2800'}},
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
@@ -179,7 +200,8 @@ module.exports = [
         exposes: [e.battery(), exposes.climate().withSetpoint('occupied_heating_setpoint', 10, 30, 1).withLocalTemperature()
             .withSystemMode(['off', 'heat', 'cool', 'emergency_heating'])
             .withRunningState(['idle', 'heat', 'cool', 'fan_only']).withFanMode(['auto', 'on'])
-            .withSetpoint('occupied_cooling_setpoint', 10, 30, 1).withLocalTemperatureCalibration()],
+            .withSetpoint('occupied_cooling_setpoint', 10, 30, 1)
+            .withLocalTemperatureCalibration(-20, 20, 1)],
         meta: {battery: {voltageToPercentage: '3V_1500_2800'}},
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);

package/devices/develco.js

@@ -297,15 +297,28 @@ module.exports = [
         model: 'ZHEMI101',
         vendor: 'Develco',
         description: 'Energy meter',
-        fromZigbee: [fz.metering],
-        toZigbee: [],
+        fromZigbee: [fz.metering, fz.develco_metering],
+        toZigbee: [tz.develco_pulse_configuration, tz.develco_interface_mode, tz.develco_current_summation],
+        endpoint: (device) => {
+            return {'default': 2};
+        },
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(2);
             await reporting.bind(endpoint, coordinatorEndpoint, ['seMetering']);
             await reporting.instantaneousDemand(endpoint);
             await reporting.readMeteringMultiplierDivisor(endpoint);
         },
-        exposes: [e.power(), e.energy()],
+        exposes: [
+            e.power(),
+            e.energy(),
+            exposes.numeric('pulse_configuration', ea.ALL).withValueMin(0).withValueMax(65535)
+                .withDescription('Pulses per kwh. Default 1000 imp/kWh. Range 0 to 65535'),
+            exposes.enum('interface_mode', ea.ALL,
+                ['electricity', 'gas', 'water', 'kamstrup-kmp', 'linky', 'IEC62056-21', 'DSMR-2.3', 'DSMR-4.0'])
+                .withDescription('Operating mode/probe'),
+            exposes.numeric('current_summation', ea.SET)
+                .withDescription('Current summation value sent to the display. e.g. 570 = 0,570 kWh'),
+        ],
     },
     {
         zigbeeModel: ['SMRZB-332'],

package/devices/ecozy.js

@@ -18,7 +18,8 @@ module.exports = [
             tz.thermostat_weekly_schedule, tz.thermostat_clear_weekly_schedule, tz.thermostat_relay_status_log,
             tz.thermostat_pi_heating_demand, tz.thermostat_running_state],
         exposes: [e.battery(), exposes.climate().withSetpoint('occupied_heating_setpoint', 7, 30, 1).withLocalTemperature()
-            .withSystemMode(['off', 'auto', 'heat']).withRunningState(['idle', 'heat']).withLocalTemperatureCalibration()
+            .withSystemMode(['off', 'auto', 'heat']).withRunningState(['idle', 'heat'])
+            .withLocalTemperatureCalibration(-20, 20, 1)
             .withPiHeatingDemand(ea.STATE_GET)],
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(3);

package/devices/elko.js

@@ -41,7 +41,7 @@ module.exports = [
                 '(quick) wooden floors.'),
             exposes.climate().withSetpoint('occupied_heating_setpoint', 5, 50, 1)
                 .withLocalTemperature(ea.STATE)
-                .withLocalTemperatureCalibration()
+                .withLocalTemperatureCalibration(-20, 20, 1)
                 .withSystemMode(['off', 'heat']).withRunningState(['idle', 'heat'])
                 .withSensor(['air', 'floor', 'supervisor_floor']),
             exposes.numeric('floor_temp', ea.STATE_GET).withUnit('°C')

package/devices/eurotronic.js

@@ -19,7 +19,8 @@ module.exports = [
             tz.thermostat_remote_sensing, tz.thermostat_local_temperature, tz.thermostat_running_state,
             tz.eurotronic_current_heating_setpoint, tz.eurotronic_trv_mode, tz.eurotronic_valve_position],
         exposes: [e.battery(), exposes.climate().withSetpoint('occupied_heating_setpoint', 5, 30, 0.5).withLocalTemperature()
-            .withSystemMode(['off', 'auto', 'heat']).withRunningState(['idle', 'heat']).withLocalTemperatureCalibration()
+            .withSystemMode(['off', 'auto', 'heat']).withRunningState(['idle', 'heat'])
+            .withLocalTemperatureCalibration(-20, 20, 1)
             .withPiHeatingDemand(),
         exposes.enum('trv_mode', exposes.access.ALL, [1, 2])
             .withDescription('Select between direct control of the valve via the `valve_position` or automatic control of the '+

package/devices/hgkg.js

@@ -17,7 +17,7 @@ module.exports = [
             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(ea.STATE_SET)
+                .withLocalTemperature(ea.STATE).withLocalTemperatureCalibration(-20, 20, 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)],
         onEvent: tuya.onEventSetLocalTime,

package/devices/ikea.js

@@ -4,6 +4,7 @@ const tz = require('../converters/toZigbee');
 const ota = require('../lib/ota');
 const constants = require('../lib/constants');
 const reporting = require('../lib/reporting');
+const {repInterval} = require('../lib/constants');
 const extend = require('../lib/extend');
 const e = exposes.presets;
 const ea = exposes.access;
@@ -625,14 +626,45 @@ module.exports = [
         model: 'E2007',
         vendor: 'IKEA',
         description: 'STARKVIND air purifier',
-        exposes: [e.fan().withModes(['off', 'low', 'medium', 'high', 'auto'])],
+        exposes: [
+            e.fan().withModes(['off', 'auto', '1', '2', '3', '4', '5', '6', '7', '8', '9']),
+            exposes.numeric('fan_speed', exposes.access.STATE_GET).withValueMin(0).withValueMax(9)
+                .withDescription('Current fan speed'),
+            e.pm25().withAccess(ea.STATE_GET),
+            exposes.enum('air_quality', ea.STATE_GET, [
+                'good', 'ok', 'not_good', 'unknown',
+            ]).withDescription('Measured air quality'),
+            exposes.binary('led_enable', ea.ALL, true, false).withDescription('Enabled LED'),
+            exposes.binary('child_lock', ea.ALL, 'LOCK', 'UNLOCK').withDescription('Enables/disables physical input on the device'),
+            exposes.binary('replace_filter', ea.STATE_GET, true, false)
+                .withDescription('Filter is older than 6 months and needs replacing'),
+        ],
         meta: {fanStateOn: 'auto'},
-        fromZigbee: [fz.fan],
-        toZigbee: [tz.fan_mode],
+        fromZigbee: [fz.ikea_air_purifier],
+        toZigbee: [
+            tz.ikea_air_purifier_fan_mode, tz.ikea_air_purifier_fan_speed,
+            tz.ikea_air_purifier_pm25, tz.ikea_air_purifier_child_lock, tz.ikea_air_purifier_led_enable,
+            tz.ikea_air_purifier_replace_filter,
+        ],
         configure: async (device, coordinatorEndpoint, logger) => {
+            const options = {manufacturerCode: 0x117c};
             const endpoint = device.getEndpoint(1);
-            await reporting.bind(endpoint, coordinatorEndpoint, ['hvacFanCtrl']);
-            await reporting.fanMode(endpoint);
+
+            await reporting.bind(endpoint, coordinatorEndpoint, ['manuSpecificIkeaAirPurifier']);
+            await endpoint.configureReporting('manuSpecificIkeaAirPurifier', [{attribute: 'particulateMatter25Measurement',
+                minimumReportInterval: repInterval.MINUTE, maximumReportInterval: repInterval.HOUR, reportableChange: 1}],
+            options);
+            await endpoint.configureReporting('manuSpecificIkeaAirPurifier', [{attribute: 'filterRunTime',
+                minimumReportInterval: repInterval.HOUR, maximumReportInterval: repInterval.HOUR, reportableChange: 0}],
+            options);
+            await endpoint.configureReporting('manuSpecificIkeaAirPurifier', [{attribute: 'fanMode',
+                minimumReportInterval: 0, maximumReportInterval: repInterval.HOUR, reportableChange: 1}],
+            options);
+            await endpoint.configureReporting('manuSpecificIkeaAirPurifier', [{attribute: 'fanSpeed',
+                minimumReportInterval: 0, maximumReportInterval: repInterval.HOUR, reportableChange: 1}],
+            options);
+
+            await endpoint.read('manuSpecificIkeaAirPurifier', ['controlPanelLight', 'childLock', 'filterRunTime']);
         },
     },
     {

package/devices/innr.js

@@ -477,6 +477,30 @@ module.exports = [
             await reporting.onOff(endpoint);
         },
     },
+    {
+        zigbeeModel: ['SP 234'],
+        model: 'SP 234',
+        vendor: 'Innr',
+        description: 'Smart plug',
+        fromZigbee: [fz.electrical_measurement, fz.on_off, fz.ignore_genLevelCtrl_report, fz.metering],
+        toZigbee: [tz.on_off],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'haElectricalMeasurement', 'seMetering']);
+            await reporting.onOff(endpoint);
+            // Gives UNSUPPORTED_ATTRIBUTE on reporting.readEletricalMeasurementMultiplierDivisors.
+            endpoint.saveClusterAttributeKeyValue('haElectricalMeasurement', {
+                acCurrentDivisor: 1000,
+                acCurrentMultiplier: 1,
+            });
+            await reporting.activePower(endpoint);
+            await reporting.rmsCurrent(endpoint);
+            await reporting.rmsVoltage(endpoint);
+            // Gives UNSUPPORTED_ATTRIBUTE on reporting.readMeteringMultiplierDivisor.
+            endpoint.saveClusterAttributeKeyValue('seMetering', {multiplier: 1, divisor: 100});
+        },
+        exposes: [e.power(), e.current(), e.voltage().withAccess(ea.STATE), e.switch(), e.energy()],
+    },
     {
         zigbeeModel: ['OFL 120 C'],
         model: 'OFL 120 C',