zigbee-herdsman-converters 14.0.316 → 14.0.317

package/converters/fromZigbee.js

@@ -4295,6 +4295,33 @@ const converters = {
             }
         },
     },
+    ikea_pm25: {
+        cluster: 'manuSpecificIkeaPM25Measurement',
+        type: ['attributeReport', 'readResponse'],
+        options: [exposes.options.precision('pm25'), exposes.options.calibration('pm25')],
+        convert: (model, msg, publish, options, meta) => {
+            if (msg.data['measuredValue']) {
+                const pm25 = parseFloat(msg.data['measuredValue']) / 100.0;
+                const pm25Property = postfixWithEndpointName('pm25', msg, model);
+
+                // 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';
+                }
+
+                return {[pm25Property]: calibrateAndPrecisionRoundOptions(pm25, options, 'pm25'), [airQualityProperty]: airQuality};
+            }
+        },
+    },
     E1524_E1810_levelctrl: {
         cluster: 'genLevelCtrl',
         type: [

package/converters/toZigbee.js

@@ -1911,6 +1911,12 @@ const converters = {
             await entity.read('genBasic', [0x0033], manufacturerOptions.hue);
         },
     },
+    ikea_pm25: {
+        key: ['pm25', 'air_quality'],
+        convertGet: async (entity, key, meta) => {
+            await entity.read('manuSpecificIkeaPM25Measurement', ['measuredValue']);
+        },
+    },
     RTCGQ13LM_motion_sensitivity: {
         key: ['motion_sensitivity'],
         convertSet: async (entity, key, value, meta) => {
@@ -5293,8 +5299,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/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

@@ -154,7 +154,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 +180,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/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

@@ -625,10 +625,16 @@ module.exports = [
         model: 'E2007',
         vendor: 'IKEA',
         description: 'STARKVIND air purifier',
-        exposes: [e.fan().withModes(['off', 'low', 'medium', 'high', 'auto'])],
+        exposes: [
+            e.fan().withModes(['off', 'low', 'medium', 'high', 'auto']),
+            e.pm25().withAccess(ea.STATE_GET),
+            exposes.enum('air_quality', ea.STATE_GET, [
+                'good', 'ok', 'not_good', 'unknown',
+            ]).withDescription('Measured air quality'),
+        ],
         meta: {fanStateOn: 'auto'},
-        fromZigbee: [fz.fan],
-        toZigbee: [tz.fan_mode],
+        fromZigbee: [fz.fan, fz.ikea_pm25],
+        toZigbee: [tz.fan_mode, tz.ikea_pm25],
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
             await reporting.bind(endpoint, coordinatorEndpoint, ['hvacFanCtrl']);

package/devices/leviton.js

@@ -80,6 +80,7 @@ module.exports = [
         exposes: [
             exposes.climate().withSetpoint('occupied_heating_setpoint', 10, 30, 1).withLocalTemperature()
                 .withSystemMode(['off', 'auto', 'heat', 'cool']).withFanMode(['auto', 'on', 'smart'])
-                .withSetpoint('occupied_cooling_setpoint', 10, 30, 1).withLocalTemperatureCalibration().withPiHeatingDemand()],
+                .withSetpoint('occupied_cooling_setpoint', 10, 30, 1)
+                .withLocalTemperatureCalibration(-20, 20, 1).withPiHeatingDemand()],
     },
 ];

package/devices/moes.js

@@ -86,7 +86,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', 'heat'], ea.STATE_SET).withRunningState(['idle', 'heat', 'cool'], ea.STATE)
                 .withPreset(['hold', 'program']).withSensor(['IN', 'AL', 'OU'], ea.STATE_SET)],
         onEvent: tuya.onEventSetLocalTime,
@@ -209,7 +209,8 @@ module.exports = [
             exposes.binary('window', ea.STATE, 'CLOSED', 'OPEN').withDescription('Window status closed or open '),
             exposes.climate()
                 .withLocalTemperature(ea.STATE).withSetpoint('current_heating_setpoint', 5, 35, 0.5, ea.STATE_SET)
-                .withLocalTemperatureCalibration(ea.STATE_SET).withPreset(['programming', 'manual', 'temporary_manual', 'holiday'],
+                .withLocalTemperatureCalibration(-20, 20, 1, ea.STATE_SET)
+                .withPreset(['programming', 'manual', 'temporary_manual', 'holiday'],
                     'MANUAL MODE ☝ - In this mode, the device executes manual temperature setting. '+
                 'When the set temperature is lower than the "minimum temperature", the valve is closed (forced closed). ' +
                 'PROGRAMMING MODE ⏱ - In this mode, the device executes a preset week programming temperature time and temperature. ' +
@@ -308,7 +309,7 @@ module.exports = [
             exposes.numeric('error_status', ea.STATE).withDescription('Error status'),
             // exposes.binary('boost_mode', ea.STATE_SET).withDescription('Enables/disables boost mode'),
             exposes.climate().withSetpoint('current_heating_setpoint', 5, 29.5, 1, ea.STATE_SET)
-                .withLocalTemperature(ea.STATE).withLocalTemperatureCalibration(ea.STATE_SET)
+                .withLocalTemperature(ea.STATE).withLocalTemperatureCalibration(-20, 20, 1, ea.STATE_SET)
                 .withSystemMode(Object.values(tuya.tvThermostatMode), ea.STATE_SET)
                 .withPreset(Object.values(tuya.tvThermostatPreset)),
         ],

package/devices/philips.js

@@ -1175,6 +1175,15 @@ module.exports = [
         extend: hueExtend.light_onoff_brightness_colortemp(),
         ota: ota.zigbeeOTA,
     },
+    {
+        zigbeeModel: ['4096730U9'],
+        model: '046677803087',
+        vendor: 'Philips',
+        description: 'Hue White ambiance Cher ceiling light',
+        meta: {turnsOffAtBrightness1: true},
+        extend: hueExtend.light_onoff_brightness_colortemp({colorTempRange: [153, 500]}),
+        ota: ota.zigbeeOTA,
+    },
     {
         zigbeeModel: ['LTC013'],
         model: '3216131P5',
@@ -1390,6 +1399,15 @@ module.exports = [
         extend: hueExtend.light_onoff_brightness_colortemp_color(),
         ota: ota.zigbeeOTA,
     },
+    {
+        zigbeeModel: ['4080248U9'],
+        model: '4080248U9',
+        vendor: 'Philips',
+        description: 'Hue White and color ambiance Signe floor light',
+        meta: {turnsOffAtBrightness1: true},
+        extend: hueExtend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 500]}),
+        ota: ota.zigbeeOTA,
+    },
     {
         zigbeeModel: ['4080148P9'],
         model: '4080148P9',
@@ -1399,6 +1417,15 @@ module.exports = [
         extend: hueExtend.light_onoff_brightness_colortemp_color(),
         ota: ota.zigbeeOTA,
     },
+    {
+        zigbeeModel: ['4080148U9'],
+        model: '4080148U9',
+        vendor: 'Philips',
+        description: 'Hue White and color ambiance Signe table light',
+        meta: {turnsOffAtBrightness1: true},
+        extend: hueExtend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 500]}),
+        ota: ota.zigbeeOTA,
+    },
     {
         zigbeeModel: ['5060730P7_01', '5060730P7_02', '5060730P7_03', '5060730P7_04', '5060730P7_05'],
         model: '5060730P7',
@@ -1909,6 +1936,15 @@ module.exports = [
         extend: hueExtend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 500]}),
         ota: ota.zigbeeOTA,
     },
+    {
+        zigbeeModel: ['1746730V7'],
+        model: '1746730V7',
+        vendor: 'Philips',
+        description: 'Hue Lily outdoor spot light',
+        meta: {turnsOffAtBrightness1: true},
+        extend: hueExtend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 500]}),
+        ota: ota.zigbeeOTA,
+    },
     {
         zigbeeModel: ['1746230V7', '1746230P7'],
         model: '1746230V7',
@@ -1954,6 +1990,15 @@ module.exports = [
         meta: {turnsOffAtBrightness1: true},
         extend: hueExtend.light_onoff_brightness_colortemp({colorTempRange: [222, 454]}),
     },
+    {
+        zigbeeModel: ['LTO004'],
+        model: '9290024785',
+        vendor: 'Philips',
+        description: 'Hue White Ambinance G25 E26 Edison Filament Globe',
+        meta: {turnsOffAtBrightness1: true},
+        extend: hueExtend.light_onoff_brightness_colortemp({colorTempRange: [222, 454]}),
+        ota: ota.zigbeeOTA,
+    },
     {
         zigbeeModel: ['LWV002'],
         model: '046677551780',

package/devices/saswell.js

@@ -42,7 +42,8 @@ module.exports = [
         },
         exposes: [e.battery_low(), e.window_detection(), e.child_lock(), exposes.climate()
             .withSetpoint('current_heating_setpoint', 5, 30, 0.5, ea.STATE_SET).withLocalTemperature(ea.STATE)
-            .withSystemMode(['off', 'heat', 'auto'], ea.STATE_SET).withLocalTemperatureCalibration(ea.STATE_SET)
+            .withSystemMode(['off', 'heat', 'auto'], ea.STATE_SET)
+            .withLocalTemperatureCalibration(-6, 6, 1, ea.STATE_SET)
             .withAwayMode()],
     },
 ];

package/devices/schneider_electric.js

@@ -443,7 +443,7 @@ module.exports = [
             exposes.climate()
                 .withSetpoint('occupied_heating_setpoint', 7, 30, 0.5, ea.STATE_SET)
                 .withLocalTemperature(ea.STATE)
-                .withLocalTemperatureCalibration(ea.STATE_SET)
+                .withLocalTemperatureCalibration(-20, 20, 1, ea.STATE_SET)
                 .withPiHeatingDemand()],
         meta: {battery: {voltageToPercentage: '3V_2500'}},
         configure: async (device, coordinatorEndpoint, logger) => {

package/devices/tuya.js

@@ -782,7 +782,7 @@ module.exports = [
             e.child_lock(), e.window_detection(), e.battery_low(), e.valve_detection(), e.position(),
             exposes.climate().withSetpoint('current_heating_setpoint', 5, 35, 0.5, ea.STATE_SET)
                 .withLocalTemperature(ea.STATE).withSystemMode(['heat', 'auto', 'off'], ea.STATE_SET)
-                .withLocalTemperatureCalibration(ea.STATE_SET)
+                .withLocalTemperatureCalibration(-20, 20, 1, ea.STATE_SET)
                 .withAwayMode().withPreset(['schedule', 'manual', 'boost', 'complex', 'comfort', 'eco']),
             e.auto_lock(), e.away_mode(), e.away_preset_days(), e.boost_time(), e.comfort_temperature(), e.eco_temperature(), e.force(),
             e.max_temperature(), e.min_temperature(), e.away_preset_temperature(),
@@ -805,7 +805,7 @@ module.exports = [
         exposes: [
             e.battery_low(), e.window_detection(), e.child_lock(), e.comfort_temperature(), e.eco_temperature(),
             e.open_window_temperature(), e.holiday_temperature(),
-            exposes.climate().withPreset(['auto', 'manual', 'holiday']).withLocalTemperatureCalibration(ea.STATE_SET)
+            exposes.climate().withPreset(['auto', 'manual', 'holiday']).withLocalTemperatureCalibration(-20, 20, 1, ea.STATE_SET)
                 .withLocalTemperature(ea.STATE).withSetpoint('current_heating_setpoint', 0, 30, 0.5, ea.STATE_SET),
             exposes.numeric('boost_timeset_countdown', ea.STATE_SET).withUnit('second').withDescription('Setting '+
                     'minimum 0 - maximum 465 seconds boost time. The boost (♨) function is activated. The remaining '+
@@ -903,7 +903,7 @@ module.exports = [
             exposes.binary('heating', ea.STATE, 'ON', 'OFF').withDescription('Device valve is open or closed (heating or not)'),
             exposes.climate()
                 .withLocalTemperature(ea.STATE).withSetpoint('current_heating_setpoint', 5, 35, 0.5, ea.STATE_SET)
-                .withLocalTemperatureCalibration(ea.STATE_SET).withPreset(['auto', 'manual', 'off', 'on'],
+                .withLocalTemperatureCalibration(-20, 20, 1, ea.STATE_SET).withPreset(['auto', 'manual', 'off', 'on'],
                     'MANUAL MODE ☝ - In this mode, the device executes manual temperature setting. ' +
                     'When the set temperature is lower than the "minimum temperature", the valve is closed (forced closed). ' +
                     'AUTO MODE ⏱ - In this mode, the device executes a preset week programming temperature time and temperature. ' +
@@ -1418,7 +1418,7 @@ module.exports = [
         exposes: [exposes.climate().withSetpoint('occupied_heating_setpoint', 5, 30, 0.5).withLocalTemperature()
             .withSystemMode(['off', 'auto', 'heat'], ea.ALL)
             .withRunningState(['idle', 'heat', 'cool'], ea.STATE)
-            .withLocalTemperatureCalibration(ea.ALL).withPiHeatingDemand()],
+            .withLocalTemperatureCalibration(-20, 20, 1, ea.ALL).withPiHeatingDemand()],
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(9);
             await reporting.bind(endpoint, coordinatorEndpoint, ['hvacThermostat', 'hvacFanCtrl']);

package/devices/zen.js

@@ -17,7 +17,7 @@ module.exports = [
             tz.thermostat_weekly_schedule, tz.thermostat_clear_weekly_schedule, tz.thermostat_relay_status_log],
         exposes: [exposes.climate().withSetpoint('occupied_heating_setpoint', 10, 30, 0.5).withLocalTemperature()
             .withSystemMode(['off', 'auto', 'heat', 'cool']).withRunningState(['idle', 'heat', 'cool'])
-            .withLocalTemperatureCalibration().withPiHeatingDemand()],
+            .withLocalTemperatureCalibration(-20, 20, 1).withPiHeatingDemand()],
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(3) || device.getEndpoint(1);
             const binds = ['genBasic', 'genIdentify', 'genPowerCfg', 'genTime', 'hvacThermostat', 'hvacUserInterfaceCfg'];

package/lib/exposes.js

@@ -371,9 +371,10 @@ class Climate extends Base {
         return this;
     }
 
-    withLocalTemperatureCalibration(access=a.ALL) {
+    withLocalTemperatureCalibration(min, max, step, access=a.ALL) {
         assert(!this.endpoint, 'Cannot add feature after adding endpoint');
-        this.features.push(new Numeric('local_temperature_calibration', access).withUnit('°C').withDescription('Offset to be used in the local_temperature'));
+        this.features.push(new Numeric('local_temperature_calibration', access)
+            .withValueMin(min).withValueMax(max).withValueStep(step).withUnit('°C').withDescription('Offset to be used in the local_temperature'));
         return this;
     }
 

package/lib/utils.js

@@ -72,7 +72,7 @@ function hasAlreadyProcessedMessage(msg, ID=null, key=null) {
     return false;
 }
 
-const defaultPrecision = {temperature: 2, humidity: 2, pressure: 1};
+const defaultPrecision = {temperature: 2, humidity: 2, pressure: 1, pm25: 2};
 function calibrateAndPrecisionRoundOptions(number, options, type) {
     // Calibrate
     const calibrateKey = `${type}_calibration`;

package/npm-shrinkwrap.json

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

package/package.json

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