zigbee-herdsman-converters 14.0.677 → 14.0.679

package/converters/fromZigbee.js

@@ -4213,12 +4213,19 @@ const converters = {
     tuya_air_quality: {
         cluster: 'manuSpecificTuya',
         type: ['commandDataReport', 'commandDataResponse'],
-        options: [exposes.options.precision('temperature'), exposes.options.calibration('temperature'),
-            exposes.options.precision('humidity'), exposes.options.calibration('humidity'),
-            exposes.options.precision('co2'), exposes.options.calibration('co2'),
-            exposes.options.precision('voc'), exposes.options.calibration('voc'),
-            exposes.options.precision('formaldehyd'), exposes.options.calibration('formaldehyd'),
-            exposes.options.precision('pm25'), exposes.options.calibration('pm25')],
+        options: (definition) => {
+            const result = [
+                exposes.options.precision('temperature'), exposes.options.calibration('temperature'),
+                exposes.options.precision('humidity'), exposes.options.calibration('humidity'),
+                exposes.options.precision('co2'), exposes.options.calibration('co2'),
+                exposes.options.precision('voc'), exposes.options.calibration('voc'),
+                exposes.options.precision('formaldehyd'), exposes.options.calibration('formaldehyd'),
+            ];
+            if (definition.exposes.find((e) => e.name === 'pm25')) {
+                result.push(exposes.options.precision('pm25'), exposes.options.calibration('pm25'));
+            }
+            return result;
+        },
         convert: (model, msg, publish, options, meta) => {
             const dpValue = tuya.firstDpValue(msg, meta, 'tuya_air_quality');
             const dp = dpValue.dp;

package/devices/bosch.js

@@ -1,10 +1,176 @@
+const herdsman = require('zigbee-herdsman');
 const exposes = require('../lib/exposes');
 const fz = require('../converters/fromZigbee');
 const tz = require('../converters/toZigbee');
 const reporting = require('../lib/reporting');
+const utils = require('../lib/utils');
 const e = exposes.presets;
+const ea = exposes.access;
 
-module.exports = [
+// Radiator Thermostat II
+const boschManufacturer = {manufacturerCode: 0x1209};
+
+// Radiator Thermostat II
+const operatingModes = {
+    'automatic': 0,
+    'manual': 1,
+    'pause': 5,
+};
+
+// Radiator Thermostat II
+const stateOffOn = {
+    'OFF': 0,
+    'ON': 1,
+};
+
+// Radiator Thermostat II
+const displayOrientation = {
+    'normal': 0,
+    'flipped': 1,
+};
+
+// Radiator Thermostat II
+const tzLocal = {
+    bosch_thermostat: {
+        key: ['window_open', 'boost', 'system_mode'],
+        convertSet: async (entity, key, value, meta) => {
+            if (key === 'window_open') {
+                value = value.toUpperCase();
+                utils.validateValue(value, Object.keys(stateOffOn));
+                const index = stateOffOn[value];
+                await entity.write('hvacThermostat', {0x4042: {value: index, type: herdsman.Zcl.DataType.enum8}}, boschManufacturer);
+                return {state: {window_open: value}};
+            }
+            if (key === 'boost') {
+                value = value.toUpperCase();
+                utils.validateValue(value, Object.keys(stateOffOn));
+                const index = stateOffOn[value];
+                await entity.write('hvacThermostat', {0x4043: {value: index, type: herdsman.Zcl.DataType.enum8}}, boschManufacturer);
+                return {state: {boost: value}};
+            }
+            if (key === 'system_mode') {
+                // Map system_mode (Off/Auto/Heat) to Boschg operating mode
+                value = value.toLowerCase();
+
+                let opMode = operatingModes.manual; // OperatingMode 1 = Manual (Default)
+
+                if (value=='off') {
+                    opMode = operatingModes.pause; // OperatingMode 5 = Pause
+                } else if (value == 'auto') {
+                    opMode = operatingModes.automatic; // OperatingMOde 1 = Automatic
+                }
+                await entity.write('hvacThermostat', {0x4007: {value: opMode, type: herdsman.Zcl.DataType.enum8}}, boschManufacturer);
+                return {state: {system_mode: value}};
+            }
+        },
+        convertGet: async (entity, key, meta) => {
+            switch (key) {
+            case 'window_open':
+                await entity.read('hvacThermostat', [0x4042], boschManufacturer);
+                break;
+            case 'boost':
+                await entity.read('hvacThermostat', [0x4043], boschManufacturer);
+                break;
+            case 'system_mode':
+                await entity.read('hvacThermostat', [0x4007], boschManufacturer);
+                break;
+
+            default: // Unknown key
+                throw new Error(`Unhandled key toZigbee.bosch_thermostat.convertGet ${key}`);
+            }
+        },
+    },
+    bosch_userInterface: {
+        key: ['display_orientation', 'display_ontime', 'display_brightness', 'child_lock'],
+        convertSet: async (entity, key, value, meta) => {
+            if (key === 'display_orientation') {
+                const index = displayOrientation[value];
+                await entity.write('hvacUserInterfaceCfg', {0x400b: {value: index, type: herdsman.Zcl.DataType.uint8}}, boschManufacturer);
+                return {state: {display_orientation: value}};
+            }
+            if (key === 'display_ontime') {
+                await entity.write('hvacUserInterfaceCfg', {0x403a: {value: value, type: herdsman.Zcl.DataType.enum8}}, boschManufacturer);
+                return {state: {display_onTime: value}};
+            }
+            if (key === 'display_brightness') {
+                await entity.write('hvacUserInterfaceCfg', {0x403b: {value: value, type: herdsman.Zcl.DataType.enum8}}, boschManufacturer);
+                return {state: {display_brightness: value}};
+            }
+            if (key === 'child_lock') {
+                const keypadLockout = Number(value === 'LOCK');
+                await entity.write('hvacUserInterfaceCfg', {keypadLockout});
+                return {state: {child_lock: value}};
+            }
+        },
+        convertGet: async (entity, key, meta) => {
+            switch (key) {
+            case 'display_orientation':
+                await entity.read('hvacUserInterfaceCfg', [0x400b], boschManufacturer);
+                break;
+            case 'display_ontime':
+                await entity.read('hvacUserInterfaceCfg', [0x403a], boschManufacturer);
+                break;
+            case 'display_brightness':
+                await entity.read('hvacUserInterfaceCfg', [0x403b], boschManufacturer);
+                break;
+            case 'child_lock':
+                await entity.read('hvacUserInterfaceCfg', ['keypadLockout']);
+                break;
+            default: // Unknown key
+                throw new Error(`Unhandled key toZigbee.bosch_userInterface.convertGet ${key}`);
+            }
+        },
+    },
+};
+
+
+// Radiator Thermostat II
+const fzLocal = {
+    bosch_thermostat: {
+        cluster: 'hvacThermostat',
+        type: ['attributeReport', 'readResponse'],
+        convert: (model, msg, publish, options, meta) => {
+            const result = {};
+            const data = msg.data;
+            if (data.hasOwnProperty(0x4042)) {
+                result.window_open = (Object.keys(stateOffOn)[data[0x4042]]);
+            }
+            if (data.hasOwnProperty(0x4043)) {
+                result.boost = (Object.keys(stateOffOn)[data[0x4043]]);
+            }
+            if (data.hasOwnProperty(0x4007)) {
+                const opModes = {0: 'auto', 1: 'heat', 2: 'unknowm 2', 3: 'unknonw 3', 4: 'unknown 4', 5: 'off'};
+                result.system_mode = opModes[data[0x4007]];
+            }
+
+            return result;
+        },
+    },
+    bosch_userInterface: {
+        cluster: 'hvacUserInterfaceCfg',
+        type: ['attributeReport', 'readResponse'],
+        convert: (model, msg, publish, options, meta) => {
+            const result = {};
+            const data = msg.data;
+            if (data.hasOwnProperty(0x400b)) {
+                result.display_orientation = (Object.keys(displayOrientation)[data[0x400b]]);
+            }
+            if (data.hasOwnProperty(0x403a)) {
+                result.display_ontime = data[0x403a];
+            }
+            if (data.hasOwnProperty(0x403b)) {
+                result.display_brightness = data[0x403b];
+            }
+            if (data.hasOwnProperty('keypadLockout')) {
+                result.child_lock = (data['keypadLockout'] == 1 ? 'LOCK' : 'UNLOCK');
+            }
+
+            return result;
+        },
+    },
+};
+
+const definition = [
     {
         zigbeeModel: ['RFDL-ZB', 'RFDL-ZB-EU', 'RFDL-ZB-H', 'RFDL-ZB-K', 'RFDL-ZB-CHI', 'RFDL-ZB-MS', 'RFDL-ZB-ES', 'RFPR-ZB',
             'RFPR-ZB-EU', 'RFPR-ZB-CHI', 'RFPR-ZB-ES', 'RFPR-ZB-MS'],
@@ -44,21 +210,51 @@ module.exports = [
         model: 'BTH-RA',
         vendor: 'Bosch',
         description: 'Radiator thermostat II',
-        fromZigbee: [fz.thermostat, fz.battery],
-        toZigbee: [tz.thermostat_occupied_heating_setpoint, tz.thermostat_local_temperature_calibration, tz.thermostat_local_temperature],
+        fromZigbee: [fz.thermostat, fz.battery, fzLocal.bosch_thermostat, fzLocal.bosch_userInterface],
+        toZigbee: [
+            tz.thermostat_occupied_heating_setpoint,
+            tz.thermostat_local_temperature_calibration,
+            tz.thermostat_local_temperature,
+            tz.thermostat_keypad_lockout,
+            tzLocal.bosch_thermostat,
+            tzLocal.bosch_userInterface],
         exposes: [
-            e.battery(),
             exposes.climate()
-                .withSetpoint('occupied_heating_setpoint', 5, 30, 0.5)
                 .withLocalTemperature()
-                .withLocalTemperatureCalibration(-30, 30, 0.1),
+                .withSetpoint('occupied_heating_setpoint', 5, 30, 0.5)
+                .withLocalTemperatureCalibration(-12, 12, 0.5)
+                .withSystemMode(['off', 'heat', 'auto']),
+            exposes.binary('boost', ea.ALL, 'ON', 'OFF')
+                .withDescription('Activate Boost heating'),
+            exposes.binary('window_open', ea.ALL, 'ON', 'OFF')
+                .withDescription('Window open'),
+            exposes.enum('display_orientation', ea.ALL, Object.keys(displayOrientation))
+                .withDescription('Display orientation'),
+            exposes.numeric('display_ontime', ea.ALL)
+                .withValueMin(5)
+                .withValueMax(30)
+                .withDescription('Specifies the diplay On-time'),
+            exposes.numeric('display_brightness', ea.ALL)
+                .withValueMin(0)
+                .withValueMax(10)
+                .withDescription('Specifies the brightness value of the display'),
+            e.child_lock().setAccess('state', ea.ALL),
+            e.battery(),
         ],
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
-            await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg', 'hvacThermostat']);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg', 'hvacThermostat', 'hvacUserInterfaceCfg']);
             await reporting.thermostatOccupiedHeatingSetpoint(endpoint);
             await reporting.thermostatTemperature(endpoint);
             await reporting.batteryPercentageRemaining(endpoint);
+
+            await endpoint.read('hvacThermostat', ['localTemperatureCalibration']);
+            await endpoint.read('hvacThermostat', [0x4007, 0x4042, 0x4043], boschManufacturer);
+
+            await endpoint.read('hvacUserInterfaceCfg', ['keypadLockout']);
+            await endpoint.read('hvacUserInterfaceCfg', [0x400b, 0x403a, 0x403b], boschManufacturer);
         },
     },
 ];
+
+module.exports = definition;

package/devices/eglo.js

@@ -15,4 +15,11 @@ module.exports = [
         description: 'ST64 adjustable white filament bulb',
         extend: extend.light_onoff_brightness_colortemp({colorTempRange: [153, 454]}),
     },
+    {
+        zigbeeModel: ['EGLO_ZM_RGB_TW'],
+        model: '900024',
+        vendor: 'EGLO',
+        description: 'SALITERAS-Z ceiling light',
+        extend: extend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 370]}),
+    },
 ];

package/devices/innr.js

@@ -621,6 +621,14 @@ module.exports = [
         extend: extend.light_onoff_brightness_colortemp_color({supportsHS: true}),
         meta: {applyRedFix: true, turnsOffAtBrightness1: true},
     },
+    {
+        zigbeeModel: ['OFL 142 C'],
+        model: 'OFL 142 C',
+        vendor: 'Innr',
+        description: 'Outdoor flex light colour LED strip 4m, 1440lm, RGBW',
+        extend: extend.light_onoff_brightness_colortemp_color({colorTempRange: [100, 350], supportsHS: true}),
+        meta: {applyRedFix: true, turnsOffAtBrightness1: true},
+    },
     {
         zigbeeModel: ['OSL 130 C'],
         model: 'OSL 130 C',

package/devices/ledvance.js

@@ -285,6 +285,19 @@ module.exports = [
             await reporting.onOff(endpoint);
         },
     },
+    {
+        zigbeeModel: ['PLUG EU T'],
+        model: '4058075729261',
+        vendor: 'LEDVANCE',
+        description: 'SMART+ Plug EU',
+        extend: extend.switch(),
+        ota: ota.ledvance,
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff']);
+            await reporting.onOff(endpoint);
+        },
+    },
     {
         zigbeeModel: ['PLUG OUTDOOR EU T'],
         model: '4058075729308',

package/devices/owon.js

@@ -87,6 +87,22 @@ const fzLocal = {
 };
 
 module.exports = [
+    {
+        zigbeeModel: ['WSP402'],
+        model: 'WSP402',
+        vendor: 'OWON',
+        description: 'Smart plug',
+        fromZigbee: [fz.on_off, fz.metering],
+        toZigbee: [tz.on_off],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'seMetering']);
+            await reporting.onOff(endpoint);
+            await reporting.readMeteringMultiplierDivisor(endpoint);
+            await reporting.instantaneousDemand(endpoint, {min: 5, max: constants.repInterval.MINUTES_5, change: 2});
+        },
+        exposes: [e.switch(), e.power(), e.energy()],
+    },
     {
         zigbeeModel: ['WSP404'],
         model: 'WSP404',

package/devices/philips.js

@@ -2904,7 +2904,7 @@ module.exports = [
         zigbeeModel: ['4090131P9'],
         model: '8718696174548',
         vendor: 'Philips',
-        description: ' Hue Sana wall lamp with Bluetooth white',
+        description: 'Hue Sana wall lamp with Bluetooth white',
         extend: hueExtend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 500]}),
     },
     {
@@ -2933,6 +2933,9 @@ module.exports = [
         model: '929003535301',
         vendor: 'Philips',
         description: 'Hue Festavia gradient light string 250',
+        toZigbee: [tzLocal.gradient_scene, ...hueExtend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 500]}).toZigbee],
+        exposes: [exposes.enum('gradient_scene', ea.SET, Object.keys(gradientScenes)),
+            ...hueExtend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 500]}).exposes],
         extend: hueExtend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 500]}),
     },
     {

package/devices/schneider_electric.js

@@ -759,16 +759,23 @@ module.exports = [
         zigbeeModel: ['FLS/SYSTEM-M/4'],
         model: 'WDE002906',
         vendor: 'Schneider Electric',
-        description: 'Wiser wireless switch 1-gang',
+        description: 'Wiser wireless switch 1-gang or 2-gang',
         fromZigbee: [fz.command_on, fz.command_off, fz.command_move, fz.command_stop, fz.battery],
         toZigbee: [],
-        exposes: [e.action(['on', 'off', 'brightness_move_up', 'brightness_move_down', 'brightness_stop']),
-            e.battery()],
-        meta: {disableActionGroup: true},
+        endpoint: (device) => {
+            return {'right': 21, 'left': 22};
+        },
+        meta: {multiEndpoint: true},
+        exposes: [e.action(['on_left', 'off_left', 'on_right', 'off_right', 'brightness_move_up_left', 'brightness_stop_left',
+            'brightness_move_down_left', 'brightness_stop_left', 'brightness_move_up_right', 'brightness_stop_right',
+            'brightness_move_down_right', 'brightness_stop_right']), e.battery()],
         configure: async (device, coordinatorEndpoint, logger) => {
-            const endpoint = device.getEndpoint(21);
-            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'genLevelCtrl', 'genPowerCfg']);
-            await reporting.batteryPercentageRemaining(endpoint);
+            // When in 2-gang operation mode, unit operates out of endpoints 21 and 22, otherwise just 21
+            const leftButtonsEndpoint = device.getEndpoint(21);
+            await reporting.bind(leftButtonsEndpoint, coordinatorEndpoint, ['genOnOff', 'genLevelCtrl', 'genPowerCfg']);
+            const rightButtonsEndpoint = device.getEndpoint(22);
+            await reporting.bind(rightButtonsEndpoint, coordinatorEndpoint, ['genOnOff', 'genLevelCtrl']);
+            await reporting.batteryPercentageRemaining(leftButtonsEndpoint);
         },
     },
     {

package/devices/third_reality.js

@@ -60,7 +60,6 @@ module.exports = [
         vendor: 'Third Reality',
         description: 'Water sensor',
         fromZigbee: [fz.ias_water_leak_alarm_1, fz.battery],
-        meta: {battery: {dontDividePercentage: true}},
         toZigbee: [],
         ota: ota.zigbeeOTA,
         exposes: [e.water_leak(), e.battery_low(), e.battery(), e.battery_voltage()],

package/devices/tuya.js

@@ -15,15 +15,6 @@ const tzZosung = zosung.tzZosung;
 const ez = zosung.presetsZosung;
 const globalStore = require('../lib/store');
 
-const TS011Fplugs = ['_TZ3000_5f43h46b', '_TZ3000_cphmq0q7', '_TZ3000_dpo1ysak', '_TZ3000_ew3ldmgx', '_TZ3000_gjnozsaz',
-    '_TZ3000_jvzvulen', '_TZ3000_mraovvmm', '_TZ3000_nfnmi125', '_TZ3000_ps3dmato', '_TZ3000_w0qqde0g', '_TZ3000_u5u4cakc',
-    '_TZ3000_rdtixbnu', '_TZ3000_typdpbpg', '_TZ3000_kx0pris5', '_TZ3000_amdymr7l', '_TZ3000_z1pnpsdo', '_TZ3000_ksw8qtmt',
-    '_TZ3000_1h2x4akh', '_TZ3000_9vo5icau', '_TZ3000_cehuw1lw', '_TZ3000_ko6v90pg', '_TZ3000_f1bapcit', '_TZ3000_cjrngdr3',
-    '_TZ3000_zloso4jk', '_TZ3000_r6buo8ba', '_TZ3000_iksasdbv', '_TZ3000_idrffznf', '_TZ3000_okaz9tjs', '_TZ3210_q7oryllx',
-    '_TZ3000_ss98ec5d', '_TZ3000_gznh2xla', '_TZ3000_hdopuwv6', '_TZ3000_gvn91tmx', '_TZ3000_dksbtrzs', '_TZ3000_b28wrpvx',
-    '_TZ3000_aim0ztek', '_TZ3000_mlswgkc3', '_TZ3000_7dndcnnb', '_TZ3000_waho4jtj', '_TZ3000_nmsciidq', '_TZ3000_jtgxgmks',
-    '_TZ3000_rdfh8cfs', '_TZ3000_yujkchbz', '_TZ3000_fgwhjm9j', '_TZ3000_qeuvnohg', '_TZ3000_rul9yxcc'];
-
 const tzLocal = {
     TS110E_options: {
         key: ['min_brightness', 'max_brightness', 'light_type'],
@@ -1552,6 +1543,7 @@ module.exports = [
             {modelID: 'TS0201', manufacturerName: '_TZ3000_fllyghyj'},
             {modelID: 'TS0201', manufacturerName: '_TZ3000_yd2e749y'},
             {modelID: 'TS0201', manufacturerName: '_TZ3000_6uzkisv2'},
+            {modelID: 'TS0201', manufacturerName: '_TZ3000_xr3htd96'},
             {modelID: 'TS0601', manufacturerName: '_TZE200_9yapgbuv'},
         ],
         model: 'WSD500A',
@@ -1809,7 +1801,7 @@ module.exports = [
     },
     {
         fingerprint: [{modelID: 'TS0002', manufacturerName: '_TZ3000_01gpyda5'}, {modelID: 'TS0002', manufacturerName: '_TZ3000_bvrlqyj7'},
-            {modelID: 'TS0002', manufacturerName: '_TZ3000_7ed9cqgi'}],
+            {modelID: 'TS0002', manufacturerName: '_TZ3000_7ed9cqgi'}, {modelID: 'TS0002', manufacturerName: '_TZ3000_zmy4lslw'}],
         model: 'TS0002_switch_module',
         vendor: 'TuYa',
         description: '2 gang switch module',
@@ -2208,6 +2200,7 @@ module.exports = [
         fingerprint: [
             {modelID: 'TS0601', manufacturerName: '_TZE200_a4bpgplm'},
             {modelID: 'TS0601', manufacturerName: '_TZE200_dv8abrrz'},
+            {modelID: 'TS0601', manufacturerName: '_TZE200_z1tyspqw'},
         ],
         model: 'TS0601_thermostat_1',
         vendor: 'TuYa',
@@ -2292,9 +2285,9 @@ module.exports = [
         extend: tuya.extend.switch({indicatorMode: true}),
     },
     {
-        fingerprint: TS011Fplugs.map((manufacturerName) => {
-            return {modelID: 'TS011F', manufacturerName};
-        }),
+        // Note: below you will find the TS011F_plug_2 and TS011F_plug_3. These are identified via a fingerprint and
+        // thus preferred above the TS011F_plug_1 if the fingerprint matches
+        zigbeeModel: ['TS011F'],
         model: 'TS011F_plug_1',
         description: 'Smart plug (with power monitoring)',
         vendor: 'TuYa',
@@ -2318,12 +2311,8 @@ module.exports = [
         },
     },
     {
-        fingerprint: [
-            {modelID: 'TS011F', manufacturerName: '_TZ3000_hyfvrar3'},
-            {modelID: 'TS011F', manufacturerName: '_TZ3000_v1pdxuqq'},
-            {modelID: 'TS011F', manufacturerName: '_TZ3000_8a833yls'},
-            {modelID: 'TS011F', manufacturerName: '_TZ3000_bfn1w0mm'},
-            {modelID: 'TS011F', manufacturerName: '_TZ3000_nzkqcvvs'}],
+        fingerprint: tuya.fingerprint('TS011F',
+            ['_TZ3000_hyfvrar3', '_TZ3000_v1pdxuqq', '_TZ3000_8a833yls', '_TZ3000_bfn1w0mm', '_TZ3000_nzkqcvvs']),
         model: 'TS011F_plug_2',
         description: 'Smart plug (without power monitoring)',
         vendor: 'TuYa',
@@ -2334,11 +2323,9 @@ module.exports = [
         },
     },
     {
-        fingerprint: [].concat(...TS011Fplugs.map((manufacturerName) => {
-            return [160, 69, 68, 65, 64].map((applicationVersion) => {
-                return {modelID: 'TS011F', manufacturerName, applicationVersion};
-            });
-        })),
+        fingerprint: [160, 69, 68, 65, 64].map((applicationVersion) => {
+            return {modelID: 'TS011F', applicationVersion};
+        }),
         model: 'TS011F_plug_3',
         description: 'Smart plug (with power monitoring by polling)',
         vendor: 'TuYa',

package/package.json

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