zigbee-herdsman-converters 14.0.677 → 14.0.678

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/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

@@ -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/tuya.js

@@ -2208,6 +2208,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',

package/package.json

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