zigbee-herdsman-converters 14.0.612 → 14.0.615

package/converters/fromZigbee.js

@@ -5119,7 +5119,7 @@ const converters = {
                 '105_14': 'press_2_and_3_and_4', '105_15': 'press_all', '105_16': 'press_energy_bar', '106_0': 'release',
             };
 
-            const ID = `${commandID}_${msg.data.commandFrame.raw.join('_')}`;
+            const ID = `${commandID}_${msg.data.commandFrame.raw.slice(0, 1).join('_')}`;
             if (!lookup.hasOwnProperty(ID)) {
                 meta.logger.error(`PTM 216Z: missing command '${ID}'`);
             } else {

package/converters/toZigbee.js

@@ -859,7 +859,6 @@ const converters = {
                 state = meta.message.state = brightness === 0 ? 'off' : 'on';
             }
 
-            let publishFakeOnLevel = false;
             let publishBrightness = brightness !== undefined;
             const targetState = state === 'toggle' ? (meta.state.state === 'ON' ? 'off' : 'on') : state;
             if (targetState === 'off') {
@@ -886,27 +885,17 @@ const converters = {
                 // TODO: same problem as above.
                 // TODO: if transition is not specified, should use device default (OnTransitionTime), not 0.
                 if (transition.specified || globalStore.getValue(entity, 'turnedOffWithTransition') === true) {
-                    const levelConfig = utils.getObjectProperty(meta.state, 'level_config', {});
-                    let onLevel = utils.getObjectProperty(levelConfig, 'on_level', 0);
-                    if (onLevel === 0) {
-                        try {
-                            const attributeRead = await entity.read('genLevelCtrl', ['onLevel']);
-                            if (attributeRead !== undefined) {
-                                onLevel = attributeRead['onLevel'];
-                            }
-                        } catch (e) {
-                            // OnLevel not supported; write a 'previous' value to state to avoid re-reads
+                    const current = utils.getObjectProperty(meta.state, 'brightness', 254);
+                    brightness = globalStore.getValue(entity, 'brightness', current);
+                    try {
+                        const attributeRead = await entity.read('genLevelCtrl', ['onLevel']);
+                        // TODO: for groups, `read` does not wait for responses. If it did, we could still issue a single
+                        //  command if all values of `OnLevel` are equal, or split into one command per device if not.
+                        if (attributeRead !== undefined && attributeRead['onLevel'] != 255) {
+                            brightness = attributeRead['onLevel'];
                         }
-                    }
-                    if (onLevel === 0) {
-                        onLevel = 'previous';
-                        publishFakeOnLevel = true;
-                    }
-                    if (onLevel === 255 || onLevel === 'previous') {
-                        const current = utils.getObjectProperty(meta.state, 'brightness', 254);
-                        brightness = globalStore.getValue(entity, 'brightness', current);
-                    } else {
-                        brightness = onLevel;
+                    } catch (e) {
+                        // OnLevel not supported
                     }
                     // Published state might have gotten clobbered by reporting.
                     publishBrightness = true;
@@ -944,9 +933,6 @@ const converters = {
             if (publishBrightness) {
                 result.state.brightness = Number(brightness);
             }
-            if (publishFakeOnLevel) {
-                result.state.level_config = {on_level: 'previous'};
-            }
             if (state !== null) {
                 result.state.state = brightness === 0 ? 'OFF' : 'ON';
             }
@@ -1240,6 +1226,7 @@ const converters = {
                     Object.values(constants.thermostatProgrammingOperationModes).join(', '));
             }
             await entity.write('hvacThermostat', {programingOperMode: val});
+            return {state: {programming_operation_mode: value}};
         },
         convertGet: async (entity, key, meta) => {
             await entity.read('hvacThermostat', ['programingOperMode']);
@@ -1355,6 +1342,7 @@ const converters = {
             }
             const occupiedHeatingSetpoint = result;
             await entity.write('hvacThermostat', {occupiedHeatingSetpoint});
+            return {state: {occupied_heating_setpoint: value}};
         },
         convertGet: async (entity, key, meta) => {
             await entity.read('hvacThermostat', ['occupiedHeatingSetpoint']);
@@ -1389,6 +1377,7 @@ const converters = {
             }
             const occupiedCoolingSetpoint = result;
             await entity.write('hvacThermostat', {occupiedCoolingSetpoint});
+            return {state: {occupied_cooling_setpoint: value}};
         },
         convertGet: async (entity, key, meta) => {
             await entity.read('hvacThermostat', ['occupiedCoolingSetpoint']);
@@ -1441,6 +1430,7 @@ const converters = {
             }
             const minHeatSetpointLimit = result;
             await entity.write('hvacThermostat', {minHeatSetpointLimit});
+            return {state: {min_heat_setpoint_limit: value}};
         },
         convertGet: async (entity, key, meta) => {
             await entity.read('hvacThermostat', ['minHeatSetpointLimit']);
@@ -1457,11 +1447,46 @@ const converters = {
             }
             const maxHeatSetpointLimit = result;
             await entity.write('hvacThermostat', {maxHeatSetpointLimit});
+            return {state: {max_heat_setpoint_limit: value}};
         },
         convertGet: async (entity, key, meta) => {
             await entity.read('hvacThermostat', ['maxHeatSetpointLimit']);
         },
     },
+    thermostat_min_cool_setpoint_limit: {
+        key: ['min_cool_setpoint_limit'],
+        convertSet: async (entity, key, value, meta) => {
+            let result;
+            if (meta.options.thermostat_unit === 'fahrenheit') {
+                result = Math.round(utils.normalizeCelsiusVersionOfFahrenheit(value) * 100);
+            } else {
+                result = (Math.round((value * 2).toFixed(1)) / 2).toFixed(1) * 100;
+            }
+            const minCoolSetpointLimit = result;
+            await entity.write('hvacThermostat', {minCoolSetpointLimit});
+            return {state: {min_cool_setpoint_limit: value}};
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read('hvacThermostat', ['minCoolSetpointLimit']);
+        },
+    },
+    thermostat_max_cool_setpoint_limit: {
+        key: ['max_cool_setpoint_limit'],
+        convertSet: async (entity, key, value, meta) => {
+            let result;
+            if (meta.options.thermostat_unit === 'fahrenheit') {
+                result = Math.round(utils.normalizeCelsiusVersionOfFahrenheit(value) * 100);
+            } else {
+                result = (Math.round((value * 2).toFixed(1)) / 2).toFixed(1) * 100;
+            }
+            const maxCoolSetpointLimit = result;
+            await entity.write('hvacThermostat', {maxCoolSetpointLimit});
+            return {state: {max_cool_setpoint_limit: value}};
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read('hvacThermostat', ['maxCoolSetpointLimit']);
+        },
+    },
     thermostat_ac_louver_position: {
         key: ['ac_louver_position'],
         convertSet: async (entity, key, value, meta) => {

package/devices/atlantic.js

@@ -0,0 +1,110 @@
+const fz = require('../converters/fromZigbee');
+const tz = require('../converters/toZigbee');
+const exposes = require('../lib/exposes');
+const reporting = require('../lib/reporting');
+const utils = require('../lib/utils');
+const assert = require('assert');
+const e = exposes.presets;
+const ea = exposes.access;
+
+
+const thermostatPositions = {
+    'quarter_open': 1,
+    'half_open': 2,
+    'three_quarters_open': 3,
+    'fully_open': 4,
+};
+
+const tzLocal = {
+    quiet_fan: {
+        key: ['quiet_fan'],
+        convertSet: async (entity, key, value, meta) => {
+            assert(typeof value === 'boolean');
+            await entity.write('hvacFanCtrl', {0x1000: {value: value ? 1 : 0, type: 0x10}}, {manufacturerCode: 0x125b});
+            return {state: {quiet_fan: value}};
+        },
+    },
+    ac_louver_position: {
+        key: ['ac_louver_position'],
+        convertSet: async (entity, key, value, meta) => {
+            value = value.toLowerCase();
+            utils.validateValue(value, Object.keys(thermostatPositions));
+            const index = thermostatPositions[value];
+            await entity.write('hvacThermostat', {0x4273: {value: index, type: 0x30}}, {manufacturerCode: 0x125b});
+            return {state: {ac_louver_position: value}};
+        },
+    },
+    preset: {
+        key: ['preset'],
+        convertSet: async (entity, key, value, meta) => {
+            value = value.toLowerCase();
+            utils.validateValue(value, ['activity', 'boost', 'eco', 'none']);
+            const activity = value === 'activity' ? 1 : 0;
+            const boost = value === 'boost' ? 1 : 0;
+            const eco = value === 'eco' ? 4 : 0;
+
+            await entity.write('hvacThermostat', {0x4275: {value: activity, type: 0x30}}, {manufacturerCode: 0x125b});
+            await entity.write('hvacThermostat', {'programingOperMode': eco});
+            await entity.write('hvacThermostat', {0x4270: {value: boost, type: 0x10}}, {manufacturerCode: 0x125b});
+
+            return {state: {preset: value}};
+        },
+    },
+    swingMode: {
+        key: ['swing_mode'],
+        convertSet: async (entity, key, value, meta) => {
+            value = value.toLowerCase();
+            utils.validateValue(value, ['on', 'off']);
+            await entity.write('hvacThermostat', {0x4274: {value: value === 'on' ? 1 : 0, type: 0x10}}, {manufacturerCode: 0x125b});
+            return {state: {swing_mode: value}};
+        },
+    },
+};
+
+module.exports = [{
+    zigbeeModel: ['Adapter Zigbee FUJITSU'],
+    model: 'GW003-AS-IN-TE-FC',
+    vendor: 'Atlantic Group',
+    description: 'Interface Naviclim for Takao air conditioners',
+    fromZigbee: [
+        fz.thermostat,
+        fz.fan,
+    ],
+    toZigbee: [
+        tzLocal.ac_louver_position,
+        tzLocal.preset,
+        tzLocal.quiet_fan,
+        tzLocal.swingMode,
+        tz.fan_mode,
+        tz.thermostat_local_temperature,
+        tz.thermostat_occupied_cooling_setpoint,
+        tz.thermostat_occupied_heating_setpoint,
+        tz.thermostat_programming_operation_mode,
+        tz.thermostat_system_mode,
+    ],
+    exposes: [
+        e.programming_operation_mode(),
+        exposes.climate()
+            .withLocalTemperature()
+            .withSetpoint('occupied_cooling_setpoint', 18, 30, 0.5)
+            .withSetpoint('occupied_heating_setpoint', 16, 30, 0.5)
+            .withSystemMode(['off', 'heat', 'cool', 'auto', 'dry', 'fan_only'])
+            .withPreset(['activity', 'boost', 'eco'])
+            .withFanMode(['low', 'medium', 'high', 'auto'])
+            .withSwingMode(['on', 'off'], ea.STATE_SET),
+        exposes.binary('quiet_fan', ea.STATE_SET, true, false).withDescription('Fan quiet mode'),
+        exposes.enum('ac_louver_position', ea.STATE_SET, Object.keys(thermostatPositions))
+            .withDescription('Ac louver position of this device'),
+    ],
+    configure: async (device, coordinatorEndpoint, logger) => {
+        const endpoint1 = device.getEndpoint(1);
+        const binds1 = ['hvacFanCtrl', 'genIdentify', 'hvacFanCtrl', 'hvacThermostat', 'manuSpecificPhilips2'];
+        await reporting.bind(endpoint1, coordinatorEndpoint, binds1);
+        await reporting.thermostatTemperature(endpoint1);
+        await reporting.thermostatOccupiedCoolingSetpoint(endpoint1);
+        await reporting.thermostatSystemMode(endpoint1);
+
+        const endpoint232 = device.getEndpoint(232);
+        await reporting.bind(endpoint232, coordinatorEndpoint, ['haDiagnostic']);
+    },
+}];

package/devices/custom_devices_diy.js

@@ -772,9 +772,39 @@ module.exports = [
             exposes.binary('factory_reset_co2', ea.STATE_SET, 'ON', 'OFF').withDescription('Factory Reset CO2 sensor'),
             exposes.binary('enable_gas', ea.STATE_SET, 'ON', 'OFF').withDescription('Enable CO2 Gas Control'),
             exposes.numeric('high_gas', ea.STATE_SET).withUnit('ppm').withDescription('Setting High CO2 Gas Border')
-                .withValueMin(0).withValueMax(99),
+                .withValueMin(400).withValueMax(2000),
             exposes.numeric('low_gas', ea.STATE_SET).withUnit('ppm').withDescription('Setting Low CO2 Gas Border')
+                .withValueMin(400).withValueMax(2000),
+            exposes.binary('enable_temperature', ea.STATE_SET, 'ON', 'OFF').withDescription('Enable Temperature Control'),
+            exposes.numeric('high_temperature', ea.STATE_SET).withUnit('C').withDescription('Setting High Temperature Border')
+                .withValueMin(-5).withValueMax(50),
+            exposes.numeric('low_temperature', ea.STATE_SET).withUnit('C').withDescription('Setting Low Temperature Border')
+                .withValueMin(-5).withValueMax(50),
+            exposes.binary('enable_humidity', ea.STATE_SET, 'ON', 'OFF').withDescription('Enable Humidity Control'),
+            exposes.numeric('high_humidity', ea.STATE_SET).withUnit('C').withDescription('Setting High Humidity Border')
                 .withValueMin(0).withValueMax(99),
+            exposes.numeric('low_humidity', ea.STATE_SET).withUnit('C').withDescription('Setting Low Humidity Border')
+                .withValueMin(0).withValueMax(99)],
+    },
+    {
+        zigbeeModel: ['SNZB-02_EFEKTA'],
+        model: 'SNZB-02_EFEKTA',
+        vendor: 'Custom devices (DiY)',
+        description: 'Alternative firmware for the SONOFF SNZB-02 sensor from EfektaLab, DIY',
+        fromZigbee: [fz.temperature, fz.humidity, fz.battery, fzLocal.termostat_config, fzLocal.hydrostat_config, fzLocal.node_config],
+        toZigbee: [tz.factory_reset, tzLocal.termostat_config, tzLocal.hydrostat_config, tzLocal.node_config],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, [
+                'genPowerCfg', 'msTemperatureMeasurement', 'msRelativeHumidity']);
+            const overides = {min: 0, max: 21600, change: 0};
+            await reporting.batteryVoltage(endpoint, overides);
+            await reporting.batteryPercentageRemaining(endpoint, overides);
+        },
+        exposes: [e.battery(), e.temperature(), e.humidity(),
+            exposes.numeric('report_delay', ea.STATE_SET).withUnit('Minutes')
+                .withDescription('Adjust Report Delay. Setting the time in minutes, by default 5 minutes')
+                .withValueMin(1).withValueMax(60),
             exposes.binary('enable_temperature', ea.STATE_SET, 'ON', 'OFF').withDescription('Enable Temperature Control'),
             exposes.numeric('high_temperature', ea.STATE_SET).withUnit('C').withDescription('Setting High Temperature Border')
                 .withValueMin(-5).withValueMax(50),

package/devices/ecodim.js

@@ -38,6 +38,11 @@ module.exports = [
                 {ID: 1, profileID: 260, deviceID: 257, inputClusters: [0, 3, 4, 5, 6, 8, 2821, 4096], outputClusters: [25]},
                 {ID: 242, profileID: 41440, deviceID: 97, inputClusters: [], outputClusters: [33]},
             ]},
+            {type: 'Router', manufacturerName: 'EcoDim BV', modelID: 'EcoDim-Zigbee 3.0', endpoints: [
+                {ID: 1, profileID: 260, deviceID: 257, inputClusters: [0, 3, 4, 5, 6, 8, 2821, 4096], outputClusters: [25]},
+                {ID: 67, inputClusters: [], outputClusters: []},
+                {ID: 242, profileID: 41440, deviceID: 97, inputClusters: [], outputClusters: [33]},
+            ]},
         ],
         zigbeeModel: ['Dimmer-Switch-ZB3.0'],
         model: 'Eco-Dim.07/Eco-Dim.10',

package/devices/ikea.js

@@ -457,7 +457,7 @@ module.exports = [
         meta: {supportsHueAndSaturation: false},
     },
     {
-        zigbeeModel: ['TRADFRI bulb E26 CWS 800lm', 'TRADFRI bulb E27 CWS 806lm'],
+        zigbeeModel: ['TRADFRI bulb E26 CWS 800lm', 'TRADFRI bulb E27 CWS 806lm', 'TRADFRI bulb E26 CWS 806lm'],
         model: 'LED1924G9',
         vendor: 'IKEA',
         description: 'TRADFRI bulb E26/E27 CWS 800/806 lumen, dimmable, color, opal white',

package/devices/kwikset.js

@@ -55,15 +55,16 @@ module.exports = [
         model: '99140-031',
         vendor: 'Kwikset',
         description: 'SmartCode traditional electronic deadbolt',
-        fromZigbee: [fz.lock, fz.lock_operation_event, fz.battery],
-        toZigbee: [tz.lock],
+        fromZigbee: [fz.lock, fz.lock_operation_event, fz.battery, fz.lock_programming_event, fz.lock_pin_code_response],
+        toZigbee: [tz.lock, tz.pincode_lock],
+        meta: {pinCodeCount: 30},
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(2);
             await reporting.bind(endpoint, coordinatorEndpoint, ['closuresDoorLock', 'genPowerCfg']);
             await reporting.lockState(endpoint);
             await reporting.batteryPercentageRemaining(endpoint);
         },
-        exposes: [e.lock(), e.battery(), e.lock_action(), e.lock_action_source_name(), e.lock_action_user()],
+        exposes: [e.lock(), e.battery(), e.pincode(), e.lock_action(), e.lock_action_source_name(), e.lock_action_user()],
     },
     {
         zigbeeModel: ['SMARTCODE_DEADBOLT_5'],

package/devices/ledvance.js

@@ -175,4 +175,53 @@ module.exports = [
         extend: extend.ledvance.light_onoff_brightness(),
         ota: ota.ledvance,
     },
+    {
+        zigbeeModel: ['B40 DIM T'],
+        model: '4058075729063',
+        vendor: 'LEDVANCE',
+        description: 'SMART+ Classic B40 E14 dimmable white',
+        extend: extend.ledvance.light_onoff_brightness(),
+        ota: ota.ledvance,
+    },
+    {
+        zigbeeModel: ['PAR16 DIM T'],
+        model: '4058075729148',
+        vendor: 'LEDVANCE',
+        description: 'SMART+ Spot PAR16 50 GU10 dimmable white',
+        extend: extend.ledvance.light_onoff_brightness(),
+        ota: ota.ledvance,
+    },
+    {
+        zigbeeModel: ['P40 DIM T'],
+        model: '4058075729100',
+        vendor: 'LEDVANCE',
+        description: 'SMART+ Classic P40 E14 dimmable white',
+        extend: extend.ledvance.light_onoff_brightness(),
+        ota: ota.ledvance,
+    },
+    {
+        zigbeeModel: ['A60 FIL DIM T'],
+        model: '4058075729209',
+        vendor: 'LEDVANCE',
+        description: 'SMART+ Filament Classic A 52 E27 Amber dimmable',
+        extend: extend.ledvance.light_onoff_brightness(),
+        ota: ota.ledvance,
+    },
+    {
+        zigbeeModel: ['EDISON60 FIL DIM T'],
+        model: '4058075729223',
+        vendor: 'LEDVANCE',
+        description: 'SMART+ Filament Edison 52 E27 Amber dimmable',
+        extend: extend.ledvance.light_onoff_brightness(),
+        ota: ota.ledvance,
+    },
+    {
+        zigbeeModel: ['GLOBE60 FIL DIM T'],
+        model: '4058075729247',
+        vendor: 'LEDVANCE',
+        description: 'SMART+ Filament Globe125 52 E27 Amber dimmable',
+        extend: extend.ledvance.light_onoff_brightness(),
+        ota: ota.ledvance,
+    },
+
 ];

package/devices/legrand.js

@@ -174,9 +174,10 @@ module.exports = [
         vendor: 'Legrand',
         description: 'Wired switch without neutral',
         extend: extend.light_onoff_brightness({noConfigure: true}),
-        fromZigbee: [fz.brightness, fz.identify, fz.on_off, fz.lighting_ballast_configuration, fz.legrand_cluster_fc01],
+        fromZigbee: [fz.brightness, fz.identify, fz.on_off, fz.lighting_ballast_configuration, fz.legrand_cluster_fc01,
+            fz.power_on_behavior],
         toZigbee: [tz.light_onoff_brightness, tz.legrand_settingEnableLedInDark, tz.legrand_settingEnableLedIfOn,
-            tz.legrand_deviceMode, tz.legrand_identify, tz.ballast_config],
+            tz.legrand_deviceMode, tz.legrand_identify, tz.ballast_config, tz.power_on_behavior],
         exposes: [e.light_brightness(),
             exposes.numeric('ballast_minimum_level', ea.ALL).withValueMin(1).withValueMax(254)
                 .withDescription('Specifies the minimum brightness value'),
@@ -185,7 +186,8 @@ module.exports = [
             exposes.binary('device_mode', ea.ALL, 'dimmer_on', 'dimmer_off').withDescription('Allow the device to change brightness'),
             exposes.binary('led_in_dark', ea.ALL, 'ON', 'OFF').withDescription(`Enables the LED when the light is turned off, allowing to 
                 see the switch in the dark`),
-            exposes.binary('led_if_on', ea.ALL, 'ON', 'OFF').withDescription('Enables the LED when the light is turned on')],
+            exposes.binary('led_if_on', ea.ALL, 'ON', 'OFF').withDescription('Enables the LED when the light is turned on'),
+            e.power_on_behavior()],
         configure: async (device, coordinatorEndpoint, logger) => {
             await extend.light_onoff_brightness().configure(device, coordinatorEndpoint, logger);
             const endpoint = device.getEndpoint(1);
@@ -201,10 +203,14 @@ module.exports = [
         vendor: 'Legrand',
         ota: ota.zigbeeOTA,
         description: 'Power socket with power consumption monitoring',
-        fromZigbee: [fz.identify, fz.on_off, fz.electrical_measurement],
-        toZigbee: [tz.on_off, tz.legrand_settingEnableLedInDark, tz.legrand_identify, tz.legrand_settingEnableLedIfOn],
+        fromZigbee: [fz.identify, fz.on_off, fz.electrical_measurement, fz.power_on_behavior],
+        toZigbee: [tz.on_off, tz.legrand_settingEnableLedInDark, tz.legrand_identify, tz.legrand_settingEnableLedIfOn,
+            tz.power_on_behavior],
         exposes: [e.switch(), e.action(['identify']), e.power(),
-            exposes.binary('led_if_on', ea.ALL, 'ON', 'OFF').withDescription('Enables the LED when the device is turned on')],
+            exposes.binary('led_in_dark', ea.ALL, 'ON', 'OFF').withDescription(`Enables the LED when the power socket is turned off,
+                allowing to see it in the dark`),
+            exposes.binary('led_if_on', ea.ALL, 'ON', 'OFF').withDescription('Enables the LED when the device is turned on'),
+            e.power_on_behavior()],
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
             await reporting.bind(endpoint, coordinatorEndpoint, ['genIdentify', 'genOnOff', 'haElectricalMeasurement']);
@@ -326,12 +332,14 @@ module.exports = [
         model: '064882',
         vendor: 'Legrand',
         description: 'Cable outlet with pilot wire and consumption measurement',
-        fromZigbee: [fz.legrand_cluster_fc01, fz.legrand_cable_outlet_mode, fz.on_off, fz.electrical_measurement],
-        toZigbee: [tz.legrand_deviceMode, tz.legrand_cableOutletMode, tz.on_off, tz.electrical_measurement_power],
+        fromZigbee: [fz.legrand_cluster_fc01, fz.legrand_cable_outlet_mode, fz.on_off, fz.electrical_measurement, fz.power_on_behavior],
+        toZigbee: [tz.legrand_deviceMode, tz.legrand_cableOutletMode, tz.on_off, tz.electrical_measurement_power, tz.power_on_behavior],
         exposes: [exposes.binary('device_mode', ea.ALL, 'pilot_on', 'pilot_off'),
             exposes.enum('cable_outlet_mode', ea.ALL, ['comfort', 'comfort-1', 'comfort-2', 'eco', 'frost_protection', 'off']),
             exposes.switch().withState('state', true, 'Works only when the pilot wire is deactivated'),
-            e.power().withAccess(ea.STATE_GET)],
+            e.power().withAccess(ea.STATE_GET),
+            e.power_on_behavior().withDescription(`Controls the behavior when the device is powered on. Works only when the pilot wire is
+                deactivated`)],
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
             await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'haElectricalMeasurement', 'manuSpecificLegrandDevices2']);

package/devices/owon.js

@@ -227,4 +227,51 @@ module.exports = [
             exposes.numeric('reactive_power_l3', ea.STATE).withUnit('VAr').withDescription('Phase 3 reactive power'),
         ],
     },
+    {
+        zigbeeModel: ['PCT504'],
+        model: 'PCT504',
+        vendor: 'OWON',
+        description: 'HVAC fan coil',
+        fromZigbee: [fz.fan, fz.thermostat, fz.humidity, fz.occupancy, fz.legacy.hvac_user_interface],
+        toZigbee: [tz.fan_mode, tz.thermostat_system_mode,
+            tz.thermostat_occupied_heating_setpoint, tz.thermostat_unoccupied_heating_setpoint,
+            tz.thermostat_occupied_cooling_setpoint, tz.thermostat_unoccupied_cooling_setpoint,
+            tz.thermostat_min_heat_setpoint_limit, tz.thermostat_max_heat_setpoint_limit,
+            tz.thermostat_min_cool_setpoint_limit, tz.thermostat_max_cool_setpoint_limit,
+            tz.thermostat_local_temperature, tz.thermostat_running_state,
+            tz.thermostat_keypad_lockout],
+        exposes: [e.local_temperature(), e.humidity(), e.occupancy(),
+            exposes.climate().withSystemMode(['off', 'heat', 'cool', 'fan_only']).withRunningState(['idle', 'heat', 'cool', 'fan_only'])
+                .withSetpoint('occupied_heating_setpoint', 5, 30, 0.5).withSetpoint('unoccupied_heating_setpoint', 5, 30, 0.5)
+                .withSetpoint('occupied_cooling_setpoint', 7, 35, 0.5).withSetpoint('unoccupied_cooling_setpoint', 7, 35, 0.5),
+            e.fan().withModes(['low', 'medium', 'high', 'on', 'auto']), e.keypad_lockout(),
+            e.max_heat_setpoint_limit(5, 30, 0.5), e.min_heat_setpoint_limit(5, 30, 0.5),
+            e.max_cool_setpoint_limit(7, 35, 0.5), e.min_cool_setpoint_limit(7, 35, 0.5)],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            const binds = ['genBasic', 'genIdentify', 'genGroups', 'hvacThermostat', 'hvacUserInterfaceCfg', 'hvacFanCtrl',
+                'msTemperatureMeasurement', 'msOccupancySensing'];
+            await reporting.bind(endpoint, coordinatorEndpoint, binds);
+            await reporting.fanMode(endpoint);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['hvacThermostat']);
+            await reporting.thermostatOccupiedHeatingSetpoint(endpoint);
+            await reporting.thermostatUnoccupiedHeatingSetpoint(endpoint);
+            await reporting.thermostatOccupiedCoolingSetpoint(endpoint);
+            await reporting.thermostatUnoccupiedCoolingSetpoint(endpoint);
+            await reporting.thermostatTemperature(endpoint, {min: 60, max: 600, change: 0.1});
+            await reporting.thermostatSystemMode(endpoint);
+            await reporting.humidity(endpoint, {min: 60, max: 600, change: 1});
+            await reporting.thermostatKeypadLockMode(endpoint);
+
+            await endpoint.read('hvacThermostat', ['systemMode', 'runningState', 'occupiedHeatingSetpoint', 'unoccupiedHeatingSetpoint',
+                'occupiedCoolingSetpoint', 'unoccupiedCoolingSetpoint', 'localTemp'],
+            'minHeatSetpointLimit', 'maxHeatSetpointLimit', 'minCoolSetpointLimit', 'maxCoolSetpointLimit');
+            await endpoint.read('msRelativeHumidity', ['measuredValue']);
+
+            const endpoint2 = device.getEndpoint(2);
+            await reporting.bind(endpoint2, coordinatorEndpoint, ['msOccupancySensing']);
+            await reporting.occupancy(endpoint2, {min: 1, max: 600, change: 1});
+            await endpoint2.read('msOccupancySensing', ['occupancy']);
+        },
+    },
 ];

package/devices/philips.js

@@ -329,6 +329,13 @@ module.exports = [
         description: 'Hue White ambiance Pillar spotlight',
         extend: hueExtend.light_onoff_brightness_colortemp({colorTempRange: [153, 454]}),
     },
+    {
+        zigbeeModel: ['929003046001'],
+        model: '5309031P8',
+        vendor: 'Philips',
+        description: 'Hue White ambiance Runner spot white (1 spot)',
+        extend: hueExtend.light_onoff_brightness_colortemp({colorTempRange: [153, 454]}),
+    },
     {
         zigbeeModel: ['929002376301'],
         model: '929002376301',

package/devices/salus_controls.js

@@ -87,7 +87,12 @@ module.exports = [
         ota: ota.salus,
     },
     {
-        zigbeeModel: ['SS909ZB'],
+        zigbeeModel: [
+            'SS909ZB',
+            'PS600\u0000\u0000 �\u0001 ��\u0000\u0000\t\u0001@\u0011�u\u0000\u0000\u0018&\n\u0005\u0000B',
+            'PS600\u0000\u0000 �\u0001 ��\u0000\u0000\t\u0001@\u0011�u\u0000\u0000\u0018\u0006\n\u0005\u0000',
+            'PS600\u0000\u0000 �\u0001 ��\u0000\u0000\t\u0001@\u0011�u\u0000\u0000\u0018\u0006\n\u0005\u0000B',
+        ],
         model: 'PS600',
         vendor: 'Salus Controls',
         description: 'Pipe temperature sensor',

package/devices/smartwings.js

@@ -12,7 +12,7 @@ module.exports = [
         description: 'Roller shade',
         fromZigbee: [fz.cover_position_tilt, fz.battery],
         toZigbee: [tz.cover_state, tz.cover_position_tilt],
-        meta: {battery: {dontDividePercentage: true}},
+        meta: {battery: {dontDividePercentage: true}, coverInverted: true},
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
             await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg', 'closuresWindowCovering']);

package/devices/tuya.js

@@ -336,6 +336,16 @@ const fzLocal = {
             return fz.battery.convert(model, msg, publish, options, meta);
         },
     },
+    TS0201_humidity: {
+        ...fz.humidity,
+        convert: (model, msg, publish, options, meta) => {
+            const result = fz.humidity.convert(model, msg, publish, options, meta);
+            if (meta.device.manufacturerName === '_TZ3000_ywagc4rj') {
+                result.humidity = result.humidity * 10;
+            }
+            return result;
+        },
+    },
     TS0222: {
         cluster: 'manuSpecificTuya',
         type: ['commandDataResponse', 'commandDataReport'],
@@ -1326,7 +1336,7 @@ module.exports = [
         vendor: 'TuYa',
         description: 'Temperature & humidity sensor with display',
         whiteLabel: [{vendor: 'BlitzWolf', model: 'BW-IS4'}],
-        fromZigbee: [fzLocal.TS0201_battery, fz.temperature, fz.humidity],
+        fromZigbee: [fzLocal.TS0201_battery, fz.temperature, fzLocal.TS0201_humidity],
         toZigbee: [],
         exposes: [e.battery(), e.temperature(), e.humidity(), e.battery_voltage()],
         configure: async (device, coordinatorEndpoint, logger) => {

package/lib/constants.js

@@ -24,6 +24,7 @@ const thermostatControlSequenceOfOperations = {
 const thermostatProgrammingOperationModes = {
     0: 'setpoint',
     1: 'schedule',
+    4: 'eco',
 };
 
 const thermostatSystemModes = {

package/lib/exposes.js

@@ -588,6 +588,10 @@ module.exports = {
         lock_action: () => new Enum('action', access.STATE, ['unknown', 'lock', 'unlock', 'lock_failure_invalid_pin_or_id', 'lock_failure_invalid_schedule', 'unlock_failure_invalid_pin_or_id', 'unlock_failure_invalid_schedule', 'one_touch_lock', 'key_lock', 'key_unlock', 'auto_lock', 'schedule_lock', 'schedule_unlock', 'manual_lock', 'manual_unlock', 'non_access_user_operational_event']).withDescription('Triggered action on the lock'),
         lock_action_source_name: () => new Enum('action_source_name', access.STATE, ['keypad', 'rfid', 'manual', 'rf']).withDescription('Source of the triggered action on the lock'),
         lock_action_user: () => new Numeric('action_user', access.STATE).withDescription('ID of user that triggered the action on the lock'),
+        max_cool_setpoint_limit: (min, max, step) => new Numeric('max_cool_setpoint_limit', access.ALL).withUnit('°C').withDescription('Maximum Cooling set point limit').withValueMin(min).withValueMax(max).withValueStep(step),
+        min_cool_setpoint_limit: (min, max, step) => new Numeric('min_cool_setpoint_limit', access.ALL).withUnit('°C').withDescription('Minimum Cooling point limit').withValueMin(min).withValueMax(max).withValueStep(step),
+        max_heat_setpoint_limit: (min, max, step) => new Numeric('max_heat_setpoint_limit', access.ALL).withUnit('°C').withDescription('Maximum Heating set point limit').withValueMin(min).withValueMax(max).withValueStep(step),
+        min_heat_setpoint_limit: (min, max, step) => new Numeric('min_heat_setpoint_limit', access.ALL).withUnit('°C').withDescription('Minimum Heating set point limit').withValueMin(min).withValueMax(max).withValueStep(step),
         max_temperature: () => new Numeric('max_temperature', access.STATE_SET).withUnit('°C').withDescription('Maximum temperature').withValueMin(15).withValueMax(35),
         max_temperature_limit: () => new Numeric('max_temperature_limit', access.STATE_SET).withUnit('°C').withDescription('Maximum temperature limit').withValueMin(0).withValueMax(35),
         min_temperature: () => new Numeric('min_temperature', access.STATE_SET).withUnit('°C').withDescription('Minimum temperature').withValueMin(1).withValueMax(15),
@@ -608,7 +612,7 @@ module.exports = {
         power_outage_memory: () => new Binary('power_outage_memory', access.ALL, true, false).withDescription('Enable/disable the power outage memory, this recovers the on/off mode after power failure'),
         presence: () => new Binary('presence', access.STATE, true, false).withDescription('Indicates whether the device detected presence'),
         pressure: () => new Numeric('pressure', access.STATE).withUnit('hPa').withDescription('The measured atmospheric pressure'),
-        programming_operation_mode: () => new Enum('programming_operation_mode', access.ALL, ['setpoint', 'schedule']).withDescription('Controls how programming affects the thermostat. Possible values: setpoint (only use specified setpoint), schedule (follow programmed setpoint schedule). Changing this value does not clear programmed schedules.'),
+        programming_operation_mode: () => new Enum('programming_operation_mode', access.ALL, ['setpoint', 'schedule', 'eco']).withDescription('Controls how programming affects the thermostat. Possible values: setpoint (only use specified setpoint), schedule (follow programmed setpoint schedule). Changing this value does not clear programmed schedules.'),
         smoke: () => new Binary('smoke', access.STATE, true, false).withDescription('Indicates whether the device detected smoke'),
         soil_moisture: () => new Numeric('soil_moisture', access.STATE).withUnit('%').withDescription('Measured soil moisture value'),
         sos: () => new Binary('sos', access.STATE, true, false).withDescription('SOS alarm'),

package/lib/tuya.js

@@ -595,6 +595,8 @@ const dataPoints = {
     dinrailPowerMeterCurrent: 18,
     dinrailPowerMeterPower: 19,
     dinrailPowerMeterVoltage: 20,
+    dinrailPowerMeterTotalEnergy2: 101,
+    dinrailPowerMeterPower2: 103,
     // tuya smart air box
     tuyaSabCO2: 2,
     tuyaSabTemp: 18,

package/package.json

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