zigbee-herdsman-converters 15.0.91 → 15.0.93

package/devices/bosch.js

@@ -4,7 +4,6 @@ const fz = require('../converters/fromZigbee');
 const tz = require('../converters/toZigbee');
 const reporting = require('../lib/reporting');
 const utils = require('../lib/utils');
-const extend = require('../lib/extend');
 const constants = require('../lib/constants');
 const ota = require('../lib/ota');
 const e = exposes.presets;
@@ -13,6 +12,26 @@ const ea = exposes.access;
 // Radiator Thermostat II
 const boschManufacturer = {manufacturerCode: 0x1209};
 
+// BMCT
+const stateDeviceType = {
+    'light': 0x04,
+    'shutter': 0x01,
+};
+// BMCT
+const stateMotor = {
+    'idle': 0x00,
+    'opening': 0x02,
+    'closing': 0x01,
+};
+// BMCT
+const stateSwitchType = {
+    'button': 0x01,
+    'button_key_change': 0x02,
+    'rocker_switch': 0x03,
+    'rocker_rwitch_key_change': 0x04,
+};
+
+
 // Twinguard
 const smokeSensitivity = {
     'low': 3,
@@ -55,6 +74,84 @@ const displayedTemperature = {
 
 // Radiator Thermostat II
 const tzLocal = {
+    bmct: {
+        key: [
+            'device_type',
+            'switch_type',
+            'child_lock', 'child_lock_left', 'child_lock_right',
+            'calibration_closing_time', 'calibration_opening_time',
+            'state',
+        ],
+        convertSet: async (entity, key, value, meta) => {
+            if (key === 'state') {
+                const state = value.toLowerCase();
+                utils.validateValue(state, ['toggle', 'off', 'on', 'open', 'close', 'stop']);
+                if ( state === 'on' || state === 'off' || state === 'toggle') {
+                    await entity.command('genOnOff', state, {}, utils.getOptions(meta.mapped, entity));
+                    if (state === 'toggle') {
+                        const currentState = meta.state[`state${meta.endpoint_name ? `_${meta.endpoint_name}` : ''}`];
+                        return currentState ? {state: {state: currentState === 'OFF' ? 'ON' : 'OFF'}} : {};
+                    } else {
+                        return {state: {state: state.toUpperCase()}};
+                    }
+                } else if ( state === 'open' || state === 'close' || state === 'stop') {
+                    const lookup = {'open': 'upOpen', 'close': 'downClose', 'stop': 'stop', 'on': 'upOpen', 'off': 'downClose'};
+                    value = value.toLowerCase();
+                    utils.validateValue(value, Object.keys(lookup));
+                    await entity.command('closuresWindowCovering', lookup[value], {}, utils.getOptions(meta.mapped, entity));
+                }
+            }
+            if (key === 'device_type') {
+                const index = stateDeviceType[value];
+                await entity.write(0xFCA0, {0x0000: {value: index, type: 0x30}}, boschManufacturer);
+                return {state: {device_type: value}};
+            }
+            if (key === 'switch_type') {
+                const index = stateSwitchType[value];
+                await entity.write(0xFCA0, {0x0001: {value: index, type: 0x30}}, boschManufacturer);
+                return {state: {switch_type: value}};
+            }
+            if (key === 'child_lock') {
+                const index = stateOffOn[value];
+                await entity.write(0xFCA0, {0x0008: {value: index, type: 0x10}}, boschManufacturer);
+                return {state: {child_lock: value}};
+            }
+            if (key === 'calibration_closing_time') {
+                const index = value *10;
+                await entity.write(0xFCA0, {0x0002: {value: index, type: 0x23}}, boschManufacturer);
+                return {state: {calibration_closing_time: value}};
+            }
+            if (key === 'calibration_opening_time') {
+                const index = value *10;
+                await entity.write(0xFCA0, {0x0003: {value: index, type: 0x23}}, boschManufacturer);
+                return {state: {calibration_opening_time: value}};
+            }
+        },
+        convertGet: async (entity, key, meta) => {
+            switch (key) {
+            case 'state':
+                await entity.read('genOnOff', ['onOff']);
+                break;
+            case 'device_type':
+                await entity.read(0xFCA0, [0x0000], boschManufacturer);
+                break;
+            case 'switch_type':
+                await entity.read(0xFCA0, [0x0001], boschManufacturer);
+                break;
+            case 'child_lock':
+                await entity.read(0xFCA0, [0x0008], boschManufacturer);
+                break;
+            case 'calibration_closing_time':
+                await entity.read(0xFCA0, [0x0002], boschManufacturer);
+                break;
+            case 'calibration_opening_time':
+                await entity.read(0xFCA0, [0x0003], boschManufacturer);
+                break;
+            default: // Unknown key
+                throw new Error(`Unhandled key toZigbee.bcmt.convertGet ${key}`);
+            }
+        },
+    },
     bwa1: {
         key: ['alarm_on_motion', 'test'],
         convertSet: async (entity, key, value, meta) => {
@@ -256,6 +353,27 @@ const tzLocal = {
 
 
 const fzLocal = {
+    bmct: {
+        cluster: '64672',
+        type: ['attributeReport', 'readResponse'],
+        options: [],
+        convert: (model, msg, publish, options, meta) => {
+            const result = {};
+            const data = msg.data;
+            if (data.hasOwnProperty(0x0000)) {
+                result.device_type = (Object.keys(stateDeviceType)[msg.data[0x0000]]);
+            } else if (data.hasOwnProperty(0x0001)) {
+                result.switch_type = (Object.keys(stateSwitchType)[msg.data[0x0001]]);
+            } else if (data.hasOwnProperty(0x0002)) {
+                result.calibration_closing_time = msg.data[0x0002];
+            } else if (data.hasOwnProperty(0x0003)) {
+                result.calibration_opening_time = msg.data[0x0003];
+            } else if (data.hasOwnProperty(0x0013)) {
+                result.motor_state = (Object.keys(stateMotor)[msg.data[0x0013]]);
+            }
+            return result;
+        },
+    },
     bwa1_alarm_on_motion: {
         cluster: '64684',
         type: ['attributeReport', 'readResponse'],
@@ -742,27 +860,51 @@ const definition = [
         zigbeeModel: ['RBSH-MMS-ZB-EU'],
         model: 'BMCT-SLZ',
         vendor: 'Bosch',
-        description: 'Light/shutter control II',
-        extend: extend.switch(),
-        exposes: [e.switch().withEndpoint('l1'), e.switch().withEndpoint('l2')],
+        description: 'Bosch Light/shutter control unit II',
+        fromZigbee: [fzLocal.bmct, fz.cover_position_tilt, fz.on_off, fz.power_on_behavior],
+        toZigbee: [tzLocal.bmct, tz.cover_position_tilt, tz.on_off, tz.power_on_behavior],
+        meta: {multiEndpoint: true},
         endpoint: (device) => {
-            return {'l1': 2, 'l2': 3};
+            return {'left': 2, 'right': 3};
         },
-        meta: {multiEndpoint: true},
         configure: async (device, coordinatorEndpoint, logger) => {
-            // Configuration values:
-            //                   0x0000    0x0001
-            // Roller Shutter       1         3
-            // Window Blind         2         3
-            // Light Switch         4         3
-
-            // Configure device as dual switch.
-            // Device will perform a rejoin after this write
-            await device.getEndpoint(1).write(0xfca0, {0x0000: {value: 0x04, type: 0x30}, 0x0001: {value: 0x03, type: 0x30}});
-
-            await reporting.bind(device.getEndpoint(2), coordinatorEndpoint, ['genOnOff']);
-            await reporting.bind(device.getEndpoint(3), coordinatorEndpoint, ['genOnOff']);
+            const endpoint1 = device.getEndpoint(1);
+            await reporting.bind(endpoint1, coordinatorEndpoint, ['genIdentify', 'closuresWindowCovering', 64672]);
+            await endpoint1.unbind('genOnOff', coordinatorEndpoint);
+            await endpoint1.read(64672, [0x0000, 0x0001, 0x0002, 0x0003, 0x0008, 0x0013], boschManufacturer);
+            const endpoint2 = device.getEndpoint(2);
+            await endpoint2.read(64672, [0x0008], boschManufacturer);
+            await reporting.bind(endpoint2, coordinatorEndpoint, ['genIdentify', 'genOnOff']);
+            await reporting.onOff(endpoint2);
+            const endpoint3 = device.getEndpoint(3);
+            await endpoint3.read(64672, [0x0008], boschManufacturer);
+            await reporting.bind(endpoint3, coordinatorEndpoint, ['genIdentify', 'genOnOff']);
+            await reporting.onOff(endpoint3);
         },
+        exposes: [
+            // light
+            exposes.enum('device_type', ea.ALL, Object.keys(stateDeviceType))
+                .withDescription('Device type: '),
+            exposes.enum('switch_type', ea.ALL, Object.keys(stateSwitchType))
+                .withDescription('Module controlled by a rocker switch or a button'),
+            e.switch().withEndpoint('left'),
+            e.switch().withEndpoint('right'),
+            e.power_on_behavior().withEndpoint('right'),
+            e.power_on_behavior().withEndpoint('left'),
+            exposes.binary('child_lock', ea.ALL, 'ON', 'OFF').withEndpoint('left')
+                .withDescription('Enable/Disable child lock'),
+            exposes.binary('child_lock', ea.ALL, 'ON', 'OFF').withEndpoint('right')
+                .withDescription('Enable/Disable child lock'),
+            // cover
+            e.cover_position().setAccess('state', ea.ALL),
+            exposes.enum('motor_state', ea.STATE, Object.keys(stateMotor))
+                .withDescription('Shutter motor actual state '),
+            exposes.binary('child_lock', ea.ALL, 'ON', 'OFF').withDescription('Enable/Disable child lock'),
+            exposes.numeric('calibration_closing_time', ea.ALL).withUnit('S')
+                .withDescription('Calibration opening time').withValueMin(1).withValueMax(90),
+            exposes.numeric('calibration_opening_time', ea.ALL).withUnit('S')
+                .withDescription('Calibration closing time').withValueMin(1).withValueMax(90),
+        ],
     },
 ];
 

package/devices/climax.js

@@ -82,14 +82,14 @@ module.exports = [
         vendor: 'Climax',
         description: 'Smart siren',
         fromZigbee: [fz.battery, fz.ias_wd, fz.ias_enroll, fz.ias_siren],
-        toZigbee: [tz.warning_simple, tz.ias_max_duration, tz.warning],
+        toZigbee: [tz.warning_simple, tz.ias_max_duration, tz.warning, tz.squawk],
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
             await reporting.bind(endpoint, coordinatorEndpoint, ['genBasic', 'ssIasZone', 'ssIasWd']);
             await endpoint.read('ssIasZone', ['zoneState', 'iasCieAddr', 'zoneId']);
             await endpoint.read('ssIasWd', ['maxDuration']);
         },
-        exposes: [e.battery_low(), e.tamper(), e.warning(),
+        exposes: [e.battery_low(), e.tamper(), e.warning(), e.squawk(),
             exposes.numeric('max_duration', ea.ALL).withUnit('s').withValueMin(0).withValueMax(600).withDescription('Duration of Siren'),
             exposes.binary('alarm', ea.SET, 'START', 'OFF').withDescription('Manual start of siren')],
     },

package/devices/heimgard_technologies.js

@@ -24,6 +24,24 @@ module.exports = [
         exposes: [
             e.lock(), e.battery(), e.auto_relock_time().withValueMin(0).withValueMax(3600), e.sound_volume()],
     },
+    {
+        zigbeeModel: ['HT-SLM-2'],
+        model: 'HT-SLM-2',
+        vendor: 'Heimgard Technologies',
+        description: 'Doorlock with fingerprint',
+        fromZigbee: [fz.lock, fz.battery, fz.lock_pin_code_response, fz.lock_user_status_response],
+        toZigbee: [tz.lock, tz.lock_sound_volume, tz.identify, tz.pincode_lock, tz.lock_userstatus],
+        meta: {pinCodeCount: 39},
+        ota: ota.zigbeeOTA,
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['closuresDoorLock', 'genPowerCfg']);
+            await reporting.lockState(endpoint);
+            await reporting.batteryPercentageRemaining(endpoint);
+            await endpoint.read('closuresDoorLock', ['lockState', 'soundVolume']);
+        },
+        exposes: [e.lock(), e.pincode(), e.battery(), e.sound_volume()],
+    },
     {
         zigbeeModel: ['HC-IWDIM-1'],
         model: 'HC-IWDIM-1',

package/devices/namron.js

@@ -481,13 +481,6 @@ module.exports = [
             await reporting.thermostatUnoccupiedHeatingSetpoint(endpoint);
             await reporting.thermostatKeypadLockMode(endpoint);
 
-            await endpoint.configureReporting('hvacThermostat', [{
-                attribute: 'occupancy',
-                minimumReportInterval: 0,
-                maximumReportInterval: constants.repInterval.HOUR,
-                reportableChange: null,
-            }]);
-
             // Metering
             await endpoint.read('haElectricalMeasurement', ['acVoltageMultiplier', 'acVoltageDivisor', 'acCurrentMultiplier']);
             await endpoint.read('haElectricalMeasurement', ['acCurrentDivisor']);

package/devices/niko.js

@@ -1,6 +1,7 @@
 const exposes = require('../lib/exposes');
 const fz = {...require('../converters/fromZigbee'), legacy: require('../lib/legacy').fromZigbee};
 const tz = require('../converters/toZigbee');
+const utils = require('../lib/utils');
 const reporting = require('../lib/reporting');
 const e = exposes.presets;
 const ea = exposes.access;
@@ -13,9 +14,8 @@ const local = {
             convert: (model, msg, publish, options, meta) => {
                 const state = {};
                 if (msg.data.hasOwnProperty('switchOperationMode')) {
-                    const operationModeProperty = `operation_mode${meta.endpoint_name ? `_${meta.endpoint_name}` : ''}`;
                     const operationModeMap = {0x02: 'control_relay', 0x01: 'decoupled', 0x00: 'unknown'};
-                    state[operationModeProperty] = operationModeMap[msg.data.switchOperationMode];
+                    state['operation_mode'] = operationModeMap[msg.data.switchOperationMode];
                 }
                 return state;
             },
@@ -29,9 +29,22 @@ const local = {
                 if (msg.data.hasOwnProperty('switchAction')) {
                     // NOTE: a single press = two seperate values reported, 16 followed by 64
                     //       a hold/release cyle = three seperate values, 16, 32, and 48
-                    const actionProperty = `action${meta.endpoint_name ? `_${meta.endpoint_name}` : ''}`;
-                    const actionMap = {16: null, 64: 'single', 32: 'hold', 48: 'release'};
-                    state[actionProperty] = actionMap[msg.data.switchAction];
+                    const actionMap = (model.model == '552-721X1') ? {
+                        16: null,
+                        64: 'single',
+                        32: 'hold',
+                        48: 'release',
+                    } : {
+                        16: null,
+                        64: 'single_left',
+                        32: 'hold_left',
+                        48: 'release_left',
+                        4096: 'single_right',
+                        8192: 'hold_right',
+                        12288: 'release_right',
+                    };
+
+                    state['action'] = actionMap[msg.data.switchAction];
                 }
                 return state;
             },
@@ -75,12 +88,18 @@ const local = {
                 if (!operationModeLookup.hasOwnProperty(value)) {
                     throw new Error(`operation_mode was called with an invalid value (${value})`);
                 } else {
-                    await entity.write('manuSpecificNiko1', {'switchOperationMode': operationModeLookup[value]});
+                    await utils.enforceEndpoint(entity, key, meta).write(
+                        'manuSpecificNiko1',
+                        {'switchOperationMode': operationModeLookup[value]},
+                    );
                     return {state: {operation_mode: value.toLowerCase()}};
                 }
             },
             convertGet: async (entity, key, meta) => {
-                await entity.read('manuSpecificNiko1', ['switchOperationMode']);
+                await utils.enforceEndpoint(entity, key, meta).read(
+                    'manuSpecificNiko1',
+                    ['switchOperationMode'],
+                );
             },
         },
         switch_led_enable: {
@@ -259,7 +278,7 @@ module.exports = [
         endpoint: (device) => {
             return {'l1': 1, 'l2': 2};
         },
-        meta: {multiEndpoint: true},
+        meta: {multiEndpointEnforce: {'operation_mode': 1}},
         configure: async (device, coordinatorEndpoint, logger) => {
             const ep1 = device.getEndpoint(1);
             const ep2 = device.getEndpoint(2);
@@ -272,10 +291,11 @@ module.exports = [
         },
         exposes: [
             e.switch().withEndpoint('l1'), e.switch().withEndpoint('l2'),
-            e.action(['single', 'hold', 'release']).withEndpoint('l1'),
-            e.action(['single', 'hold', 'release']).withEndpoint('l2'),
-            exposes.enum('operation_mode', ea.ALL, ['control_relay', 'decoupled']).withEndpoint('l1'),
-            exposes.enum('operation_mode', ea.ALL, ['control_relay', 'decoupled']).withEndpoint('l2'),
+            e.action([
+                'single_left', 'hold_left', 'release_left',
+                'single_right', 'hold_right', 'release_right',
+            ]),
+            exposes.enum('operation_mode', ea.ALL, ['control_relay', 'decoupled']),
             exposes.binary('led_enable', ea.ALL, true, false).withEndpoint('l1').withDescription('Enable LED'),
             exposes.binary('led_enable', ea.ALL, true, false).withEndpoint('l2').withDescription('Enable LED'),
             exposes.binary('led_state', ea.ALL, 'ON', 'OFF').withEndpoint('l1').withDescription('LED State'),

package/devices/tuya.js

@@ -805,6 +805,7 @@ module.exports = [
         fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_bq5c8xfe'},
             {modelID: 'TS0601', manufacturerName: '_TZE200_bjawzodf'},
             {modelID: 'TS0601', manufacturerName: '_TZE200_qyflbnbj'},
+            {modelID: 'TS0601', manufacturerName: '_TZE200_vs0skpuc'},
             {modelID: 'TS0601', manufacturerName: '_TZE200_9yapgbuv'},
             {modelID: 'TS0601', manufacturerName: '_TZE200_zl1kmjqx'}],
         model: 'TS0601_temperature_humidity_sensor',

package/devices/zemismart.js

@@ -199,7 +199,7 @@ module.exports = [
         exposes: [e.cover_position().setAccess('position', ea.STATE_SET)],
     },
     {
-        fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_1n2kyphz'}],
+        fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_1n2kyphz'}, {modelID: 'TS0601', manufacturerName: '_TZE200_shkxsgis'}],
         model: 'TB26-4',
         vendor: 'Zemismart',
         description: '4-gang smart wall switch',

package/package.json

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