zigbee-herdsman-converters 14.0.391 → 14.0.395

package/converters/fromZigbee.js

@@ -699,6 +699,8 @@ const converters = {
          */
         cluster: 'haElectricalMeasurement',
         type: ['attributeReport', 'readResponse'],
+        options: [exposes.options.calibration('power', 'percentual'), exposes.options.calibration('current', 'percentual'),
+            exposes.options.calibration('voltage', 'percentual')],
         convert: (model, msg, publish, options, meta) => {
             const getFactor = (key) => {
                 const multiplier = msg.endpoint.getClusterAttributeValue('haElectricalMeasurement', `${key}Multiplier`);
@@ -724,7 +726,8 @@ const converters = {
                 if (msg.data.hasOwnProperty(entry.key)) {
                     const factor = getFactor(entry.factor);
                     const property = postfixWithEndpointName(entry.name, msg, model);
-                    payload[property] = precisionRound(msg.data[entry.key] * factor, 2);
+                    const value = msg.data[entry.key] * factor;
+                    payload[property] = calibrateAndPrecisionRoundOptions(value, options, entry.name);
                 }
             }
             return payload;
@@ -2498,6 +2501,30 @@ const converters = {
             }
         },
     },
+    neo_alarm: {
+        cluster: 'manuSpecificTuya',
+        type: ['commandDataReport', 'commandDataResponse'],
+        convert: (model, msg, publish, options, meta) => {
+            const dpValue = tuya.firstDpValue(msg, meta, 'neo_alarm');
+            const dp = dpValue.dp;
+            const value = tuya.getDataValue(dpValue);
+
+            switch (dp) {
+            case tuya.dataPoints.neoAOAlarm: // 0x13 [TRUE,FALSE]
+                return {alarm: value};
+            case tuya.dataPoints.neoAODuration: // 0x7 [0,0,0,10] duration alarm in second
+                return {duration: value};
+            case tuya.dataPoints.neoAOBattPerc: // 0x15 [0,0,0,100] battery percentage
+                return {battpercentage: value};
+            case tuya.dataPoints.neoAOMelody: // 0x21 [5] Melody
+                return {melody: value};
+            case tuya.dataPoints.neoAOVolume: // 0x5 [0]/[1]/[2] Volume 0-max, 2-low
+                return {volume: {2: 'low', 1: 'medium', 0: 'high'}[value]};
+            default: // Unknown code
+                meta.logger.warn(`Unhandled DP #${dp}: ${JSON.stringify(msg.data)}`);
+            }
+        },
+    },
     terncy_contact: {
         cluster: 'genBinaryInput',
         type: 'attributeReport',
@@ -5268,6 +5295,7 @@ const converters = {
                     payload.gas_sensitivity = {1: '15%LEL', 2: '10%LEL'}[msg.data['268']];
                 }
             }
+            if (msg.data.hasOwnProperty('293')) payload.click_mode = {1: 'fast', 2: 'multi'}[msg.data['293']];
             if (msg.data.hasOwnProperty('294')) payload.mute = msg.data['294'] === 1; // JT-BZ-01AQ/A
             if (msg.data.hasOwnProperty('295')) payload.test = msg.data['295'] === 1; // JT-BZ-01AQ/A
             if (msg.data.hasOwnProperty('313')) payload.state = msg.data['313'] === 1 ? 'preparation' : 'work'; // JT-BZ-01AQ/A
@@ -7694,7 +7722,7 @@ const converters = {
                 result = {tumble_switch: {false: 'OFF', true: 'ON'}[value]};
                 break;
             case tuya.dataPoints.trsfFallDownStatus:
-                result = {fall_down_status: {0: false, 1: true}[value]};
+                result = {fall_down_status: tuya.tuyaRadar.fallDown[value]};
                 break;
             case tuya.dataPoints.trsfStaticDwellAlarm:
                 result = {static_dwell_alarm: value};
@@ -7733,6 +7761,31 @@ const converters = {
             return result;
         },
     },
+    matsee_garage_door_opener: {
+        cluster: 'manuSpecificTuya',
+        type: ['commandDataReport', 'raw'],
+        convert: (model, msg, publish, options, meta) => {
+            const result = {};
+            for (const dpValue of msg.data.dpValues) {
+                const value = tuya.getDataValue(dpValue);
+                switch (dpValue.dp) {
+                case tuya.dataPoints.garageDoorTrigger:
+                    result.action = 'trigger';
+                    break;
+                case tuya.dataPoints.garageDoorContact:
+                    result.garage_door_contact = Boolean(!value);
+                    break;
+                case tuya.dataPoints.garageDoorStatus:
+                    // This reports a garage door status (open, closed), but it is very naive and misleading
+                    break;
+                default:
+                    meta.logger.debug(`zigbee-herdsman-converters:matsee_garage_door_opener: NOT RECOGNIZED ` +
+                        `DP #${dpValue.dp} with data ${JSON.stringify(dpValue)}`);
+                }
+            }
+            return result;
+        },
+    },
     moes_thermostat_tv: {
         cluster: 'manuSpecificTuya',
         type: ['commandDataResponse', 'commandDataReport', 'raw'],

package/converters/toZigbee.js

@@ -2333,6 +2333,12 @@ const converters = {
             tuya.sendDataPointRaw(entity, tuya.dataPoints.lidlTimer, tuya.convertDecimalValueTo4ByteHexArray(value));
         },
     },
+    matsee_garage_door_opener: {
+        key: ['trigger'],
+        convertSet: (entity, key, value, meta) => {
+            tuya.sendDataPointBool(entity, tuya.dataPoints.action, true);
+        },
+    },
     SPZ01_power_outage_memory: {
         key: ['power_outage_memory'],
         convertSet: async (entity, key, value, meta) => {
@@ -5074,6 +5080,32 @@ const converters = {
             }
         },
     },
+    neo_alarm: {
+        key: [
+            'alarm', 'melody', 'volume', 'duration',
+        ],
+        convertSet: async (entity, key, value, meta) => {
+            switch (key) {
+            case 'alarm':
+                await tuya.sendDataPointBool(entity, tuya.dataPoints.neoAOAlarm, value);
+                break;
+            case 'melody':
+                await tuya.sendDataPointEnum(entity, tuya.dataPoints.neoAOMelody, parseInt(value, 10));
+                break;
+            case 'volume':
+                await tuya.sendDataPointEnum(
+                    entity,
+                    tuya.dataPoints.neoAOVolume,
+                    {'low': 2, 'medium': 1, 'high': 0}[value]);
+                break;
+            case 'duration':
+                await tuya.sendDataPointValue(entity, tuya.dataPoints.neoAODuration, value);
+                break;
+            default: // Unknown key
+                throw new Error(`Unhandled key ${key}`);
+            }
+        },
+    },
     nous_lcd_temperature_humidity_sensor: {
         key: ['min_temperature', 'max_temperature', 'temperature_sensitivity', 'temperature_unit_convert'],
         convertSet: async (entity, key, value, meta) => {
@@ -6548,6 +6580,9 @@ const converters = {
             await entity.write('aqaraOpple', {0x0125: {value: lookupState[value], type: 0x20}}, manufacturerOptions.xiaomi);
             return {state: {click_mode: value}};
         },
+        convertGet: async (entity, key, meta) => {
+            await entity.read('aqaraOpple', [0x125], manufacturerOptions.xiaomi);
+        },
     },
     tuya_light_wz5: {
         key: ['color', 'color_temp', 'brightness', 'white_brightness'],

package/devices/custom_devices_diy.js

@@ -332,4 +332,25 @@ module.exports = [
         },
         exposes: [e.soil_moisture(), e.battery(), e.illuminance(), e.temperature(), e.humidity()],
     },
+    {
+        zigbeeModel: ['EFEKTA_PWS_MaxPro'],
+        model: 'EFEKTA_PWS_MaxPro',
+        vendor: 'Custom devices (DiY)',
+        description: '[Plant watering sensor EFEKTA PWS Max Pro,  long battery life](http://efektalab.com/PWS_MaxPro)',
+        fromZigbee: [fz.temperature, fz.humidity, fz.illuminance, fz.soil_moisture, fz.battery],
+        toZigbee: [tz.factory_reset],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const firstEndpoint = device.getEndpoint(1);
+            await reporting.bind(firstEndpoint, coordinatorEndpoint, [
+                'genPowerCfg', 'msTemperatureMeasurement', 'msRelativeHumidity', 'msIlluminanceMeasurement', 'msSoilMoisture']);
+            const overides = {min: 0, max: 21600, change: 0};
+            await reporting.batteryVoltage(firstEndpoint, overides);
+            await reporting.batteryPercentageRemaining(firstEndpoint, overides);
+            await reporting.temperature(firstEndpoint, overides);
+            await reporting.humidity(firstEndpoint, overides);
+            await reporting.illuminance(firstEndpoint, overides);
+            await reporting.soil_moisture(firstEndpoint, overides);
+        },
+        exposes: [e.soil_moisture(), e.battery(), e.illuminance(), e.temperature(), e.humidity()],
+    },
 ];

package/devices/legrand.js

@@ -5,6 +5,7 @@ const reporting = require('../lib/reporting');
 const extend = require('../lib/extend');
 const e = exposes.presets;
 const ea = exposes.access;
+const ota = require('../lib/ota');
 
 const readInitialBatteryState = async (type, data, device) => {
     if (['deviceAnnounce'].includes(type)) {
@@ -63,6 +64,7 @@ module.exports = [
         fromZigbee: [fz.identify, fz.ignore_basic_report, fz.command_cover_open, fz.command_cover_close, fz.command_cover_stop, fz.battery,
             fz.legrand_binary_input_moving],
         toZigbee: [],
+        ota: ota.zigbeeOTA,
         exposes: [e.battery(), e.action(['identify', 'open', 'close', 'stop', 'moving', 'stopped'])],
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
@@ -182,6 +184,7 @@ module.exports = [
         zigbeeModel: [' Connected outlet\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000'],
         model: '067775/741811',
         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_settingAlwaysEnableLed, tz.legrand_identify],
@@ -200,6 +203,7 @@ module.exports = [
         vendor: 'Legrand',
         description: 'Wired micromodule switch',
         extend: extend.switch(),
+        ota: ota.zigbeeOTA,
         fromZigbee: [fz.identify, fz.on_off],
         toZigbee: [tz.on_off, tz.legrand_identify],
         configure: async (device, coordinatorEndpoint, logger) => {

package/devices/lg.js

@@ -0,0 +1,18 @@
+const extend = require('../lib/extend');
+
+module.exports = [
+    {
+        zigbeeModel: ['B1027EB0Z01'],
+        model: 'B1027EB0Z01',
+        vendor: 'LG Electronics',
+        description: 'Smart bulb 1',
+        extend: extend.light_onoff_brightness(),
+    },
+    {
+        zigbeeModel: ['B1027EB0Z02'],
+        model: 'B1027EB0Z02',
+        vendor: 'LG Electronics',
+        description: 'Smart bulb 2',
+        extend: extend.light_onoff_brightness(),
+    },
+];

package/devices/micromatic.js

@@ -0,0 +1,31 @@
+const fz = require('../converters/fromZigbee');
+const exposes = require('../lib/exposes');
+const reporting = require('../lib/reporting');
+const extend = require('../lib/extend');
+const e = exposes.presets;
+const ea = exposes.access;
+
+
+module.exports = [
+    {
+        zigbeeModel: ['SZ1000'],
+        model: 'ZB250',
+        vendor: 'Micro Matic Norge AS',
+        description: 'Zigbee dimmer for LED',
+        fromZigbee: extend.light_onoff_brightness().fromZigbee.concat([fz.electrical_measurement, fz.metering]),
+        toZigbee: extend.light_onoff_brightness().toZigbee,
+        configure: async (device, coordinatorEndpoint, logger) => {
+            await extend.light_onoff_brightness().configure(device, coordinatorEndpoint, logger);
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'genLevelCtrl', 'haElectricalMeasurement', 'seMetering']);
+            await reporting.brightness(endpoint);
+            await reporting.readEletricalMeasurementMultiplierDivisors(endpoint);
+            await reporting.rmsVoltage(endpoint, {min: 10, change: 20}); // Voltage - Min change of 2V
+            await reporting.rmsCurrent(endpoint, {min: 10, change: 10}); // A - z2m displays only the first decimals, change of 10 / 0,01A
+            await reporting.activePower(endpoint, {min: 10, change: 15}); // W - Min change of 1,5W
+            await reporting.currentSummDelivered(endpoint, {min: 300}); // Report KWH every 5min
+        },
+        exposes: [e.light_brightness(), e.power(), e.current(), e.voltage().withAccess(ea.STATE), e.energy()],
+    },
+];
+

package/devices/neo.js

@@ -34,6 +34,29 @@ module.exports = [
             await endpoint.command('manuSpecificTuya', 'mcuVersionRequest', {'seq': 0x0002});
         },
     },
+    {
+        fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_t1blo2bj'}],
+        zigbeeModel: ['1blo2bj'],
+        model: 'NAS-AB02B2',
+        vendor: 'Neo',
+        description: 'Alarm',
+        fromZigbee: [fz.neo_alarm, fz.ignore_basic_report],
+        toZigbee: [tz.neo_alarm],
+        exposes: [
+            e.battery_low(),
+            exposes.binary('alarm', ea.STATE_SET, true, false),
+            exposes.enum('melody', ea.STATE_SET, Array.from(Array(18).keys()).map((x)=>(x+1).toString())),
+            exposes.numeric('duration', ea.STATE_SET).withUnit('second').withValueMin(0).withValueMax(1800),
+            exposes.enum('volume', ea.STATE_SET, ['low', 'medium', 'high']),
+            exposes.numeric('battpercentage', ea.STATE).withUnit('%'),
+        ],
+        onEvent: tuya.onEventSetLocalTime,
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await endpoint.command('manuSpecificTuya', 'dataQuery', {});
+            await endpoint.command('manuSpecificTuya', 'mcuVersionRequest', {'seq': 0x0002});
+        },
+    },
     {
         fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_7hfcudw5'}],
         model: 'NAS-PD07',

package/devices/philips.js

@@ -29,6 +29,13 @@ const hueExtend = {
 };
 
 module.exports = [
+    {
+        zigbeeModel: ['929003055801'],
+        model: '929003055801',
+        vendor: 'Philips',
+        description: 'Hue white ambiance bathroom ceiling light Adore with Bluetooth',
+        extend: extend.light_onoff_brightness_colortemp({colorTempRange: [153, 454]}),
+    },
     {
         zigbeeModel: ['929003056901'],
         model: '929003056901',
@@ -66,7 +73,7 @@ module.exports = [
         ota: ota.zigbeeOTA,
     },
     {
-        zigbeeModel: ['915005996401'],
+        zigbeeModel: ['915005996401', '915005996501'],
         model: '915005996401',
         vendor: 'Philips',
         description: 'Hue white ambiance ceiling light Enrave S with Bluetooth',
@@ -261,7 +268,7 @@ module.exports = [
         ota: ota.zigbeeOTA,
     },
     {
-        zigbeeModel: ['LLC012', 'LLC011'],
+        zigbeeModel: ['LLC012', 'LLC011', 'LLC013'],
         model: '7299760PH',
         vendor: 'Philips',
         description: 'Hue Bloom',
@@ -494,6 +501,15 @@ module.exports = [
         extend: hueExtend.light_onoff_brightness(),
         ota: ota.zigbeeOTA,
     },
+    {
+        zigbeeModel: ['1746630V7'],
+        model: '1746630V7',
+        vendor: 'Philips',
+        description: 'Amarant linear outdoor light',
+        meta: {turnsOffAtBrightness1: true},
+        extend: hueExtend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 500]}),
+        ota: ota.zigbeeOTA,
+    },
     {
         zigbeeModel: ['LCC001'],
         model: '4090531P7',
@@ -1005,7 +1021,7 @@ module.exports = [
         ota: ota.zigbeeOTA,
     },
     {
-        zigbeeModel: ['3417931P6'],
+        zigbeeModel: ['3417931P6', '929003056201'],
         model: '3417931P6',
         vendor: 'Philips',
         description: 'Hue white ambiance Adore GU10 with Bluetooth (2 spots)',
@@ -2627,4 +2643,13 @@ module.exports = [
         extend: hueExtend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 500]}),
         ota: ota.zigbeeOTA,
     },
+    {
+        zigbeeModel: ['929003045001_01', '929003045001_02', '929003045001_03'],
+        model: '9290019533',
+        vendor: 'Philips',
+        description: 'Hue white ambiance GU10 with Bluetooth',
+        meta: {turnsOffAtBrightness1: true},
+        extend: extend.light_onoff_brightness_colortemp({colorTempRange: [153, 454]}),
+        ota: ota.zigbeeOTA,
+    },
 ];

package/devices/scanproducts.js

@@ -0,0 +1,20 @@
+const reporting = require('../lib/reporting');
+const extend = require('../lib/extend');
+
+module.exports = [
+    {
+        zigbeeModel: ['12501'],
+        model: '12501',
+        vendor: 'Scan Products',
+        description: 'Zigbee push dimmer',
+        fromZigbee: extend.light_onoff_brightness().fromZigbee,
+        toZigbee: extend.light_onoff_brightness().toZigbee,
+        extend: extend.light_onoff_brightness({noConfigure: true}),
+        configure: async (device, coordinatorEndpoint, logger) => {
+            await extend.light_onoff_brightness().configure(device, coordinatorEndpoint, logger);
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'genLevelCtrl']);
+            await reporting.onOff(endpoint);
+        },
+    },
+];

package/devices/sercomm.js

@@ -37,6 +37,22 @@ module.exports = [
             endpoint.saveClusterAttributeKeyValue('seMetering', {divisor: 1000000, multiplier: 1});
         },
     },
+    {
+        zigbeeModel: ['SZ-ESW02'],
+        model: 'SZ-ESW02',
+        vendor: 'Sercomm',
+        description: 'Telstra smart plug 2',
+        fromZigbee: [fz.on_off, fz.metering],
+        exposes: [e.switch(), e.power()],
+        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.instantaneousDemand(endpoint);
+            endpoint.saveClusterAttributeKeyValue('seMetering', {divisor: 1000000, multiplier: 1});
+        },
+    },
     {
         zigbeeModel: ['XHS2-SE'],
         model: 'XHS2-SE',

package/devices/skydance.js

@@ -46,7 +46,7 @@ module.exports = [
         toZigbee: [tz.tuya_dimmer_state, tz.tuya_light_wz5],
         exposes: [
             exposes.light().withBrightness().setAccess('state', ea.STATE_SET).setAccess('brightness',
-                ea.STATE_SET).withColor('hs'),
+                ea.STATE_SET).withColor(['hs']),
         ],
     },
     {
@@ -61,7 +61,7 @@ module.exports = [
         toZigbee: [tz.tuya_dimmer_state, tz.tuya_light_wz5],
         exposes: [
             exposes.light().withBrightness().setAccess('state', ea.STATE_SET).setAccess('brightness',
-                ea.STATE_SET).withColor('hs'),
+                ea.STATE_SET).withColor(['hs']),
             exposes.numeric('white_brightness', ea.STATE_SET).withValueMin(0).withValueMax(254).withDescription(
                 'White brightness of this light'),
         ],
@@ -79,7 +79,7 @@ module.exports = [
         toZigbee: [tz.tuya_dimmer_state, tz.tuya_light_wz5],
         exposes: [
             exposes.light().withBrightness().setAccess('state', ea.STATE_SET).setAccess('brightness',
-                ea.STATE_SET).withColor('hs').withColorTemp([250, 454]).setAccess('color_temp',
+                ea.STATE_SET).withColor(['hs']).withColorTemp([250, 454]).setAccess('color_temp',
                 ea.STATE_SET),
             exposes.numeric('white_brightness', ea.STATE_SET).withValueMin(0).withValueMax(254).withDescription(
                 'White brightness of this light'),

package/devices/tuya.js

@@ -206,7 +206,8 @@ module.exports = [
             {modelID: 'TS0501B', manufacturerName: '_TZ3210_4whigl8i'},
             {modelID: 'TS0501B', manufacturerName: '_TZ3210_9q49basr'},
             {modelID: 'TS0501B', manufacturerName: '_TZ3210_grnwgegn'},
-            {modelID: 'TS0501B', manufacturerName: '_TZ3210_wuheofsg'}],
+            {modelID: 'TS0501B', manufacturerName: '_TZ3210_wuheofsg'},
+            {modelID: 'TS0501B', manufacturerName: '_TZ3210_e5t9bfdv'}],
         model: 'TS0501B',
         description: 'Zigbee light',
         vendor: 'TuYa',
@@ -509,6 +510,7 @@ module.exports = [
             {modelID: 'TS0502B', manufacturerName: '_TZ3000_zw7wr5uo'},
             {modelID: 'TS0502B', manufacturerName: '_TZ3210_pz9zmxjj'},
             {modelID: 'TS0502B', manufacturerName: '_TZ3000_fzwhym79'},
+            {modelID: 'TS0502B', manufacturerName: '_TZ3210_rm0hthdo'},
         ],
         model: 'TS0502B',
         vendor: 'TuYa',
@@ -839,6 +841,7 @@ module.exports = [
             {modelID: 'TS0601', manufacturerName: '_TZE200_sbordckq'},
             {modelID: 'TS0601', manufacturerName: '_TZE200_fctwhugx'},
             {modelID: 'TS0601', manufacturerName: '_TZE200_zah67ekd'},
+            {modelID: 'TS0601', manufacturerName: '_TZE200_hsgrhjpf'},
             // Window pushers:
             {modelID: 'TS0601', manufacturerName: '_TZE200_g5wdnuow'},
             // Tubular motors:
@@ -1663,6 +1666,21 @@ module.exports = [
             e.energy(), exposes.enum('power_outage_memory', ea.STATE_SET, ['on', 'off', 'restore'])
                 .withDescription('Recover state after power outage')],
     },
+    {
+        fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_nklqjk62'}],
+        model: 'PJ-ZGD01',
+        vendor: 'TuYa',
+        description: 'Garage door opener',
+        fromZigbee: [fz.matsee_garage_door_opener, fz.ignore_basic_report],
+        toZigbee: [tz.matsee_garage_door_opener, tz.tuya_data_point_test],
+        whiteLabel: [{vendor: 'MatSee Plus', model: 'PJ-ZGD01'}],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genBasic']);
+        },
+        exposes: [exposes.binary('trigger', ea.STATE_SET, true, false).withDescription('Trigger the door movement'),
+            e.action(['trigger']), exposes.binary('garage_door_contact', ea.STATE, true, false)],
+    },
     {
         fingerprint: [{modelID: 'TS0201', manufacturerName: '_TZ3000_qaaysllp'}],
         model: 'LCZ030',
@@ -1755,7 +1773,8 @@ module.exports = [
                 .withDescription('fall sensitivity of the radar'),
             exposes.numeric('tumble_alarm_time', ea.STATE_SET).withValueMin(1).withValueMax(5).withValueStep(1)
                 .withUnit('min').withDescription('tumble alarm time'),
-            exposes.binary('fall_down_status', ea.STATE).withDescription('fall down status'),
+            exposes.enum('fall_down_status', ea.STATE, Object.values(tuya.tuyaRadar.fallDown))
+                .withDescription('fall down status'),
             exposes.text('static_dwell_alarm', ea.STATE).withDescription('static dwell alarm'),
         ],
         configure: async (device, coordinatorEndpoint, logger) => {

package/devices/useelink.js

@@ -22,6 +22,21 @@ module.exports = [
             return {'l1': 1, 'l2': 2, 'l3': 3, 'l4': 4, 'l5': 5};
         },
     },
+    {
+        fingerprint: [{modelID: 'TS011F', manufacturerName: '_TZ3000_cfnprab5'}],
+        model: 'SM-0306E-2W',
+        vendor: 'UseeLink',
+        description: '4 gang switch, with USB',
+        exposes: [e.switch().withEndpoint('l1'), e.switch().withEndpoint('l2'), e.switch().withEndpoint('l3'),
+            e.switch().withEndpoint('l4'), e.switch().withEndpoint('l5')],
+        extend: extend.switch(),
+        meta: {multiEndpoint: true},
+        configure: async (device, coordinatorEndpoint, logger) => {
+            for (const ID of [1, 2, 3, 4, 5]) {
+                await reporting.bind(device.getEndpoint(ID), coordinatorEndpoint, ['genOnOff']);
+            }
+        },
+    },
     {
         fingerprint: [{modelID: 'TS011F', manufacturerName: '_TZ3000_tvuarksa'}],
         model: 'SM-AZ713',

package/devices/xiaomi.js

@@ -1448,6 +1448,7 @@ module.exports = [
             await reporting.onOff(endpoint);
             await reporting.deviceTemperature(endpoint);
             device.powerSource = 'Mains (single phase)';
+            device.type = 'Router';
             device.save();
         },
     },
@@ -1654,6 +1655,7 @@ module.exports = [
             const payload = reporting.payload('presentValue', 10, constants.repInterval.HOUR, 5);
             await endpoint.configureReporting('genAnalogInput', payload);
         },
+        ota: ota.zigbeeOTA,
     },
     {
         zigbeeModel: ['lumi.switch.b2nc01'],
@@ -1837,7 +1839,7 @@ module.exports = [
         fromZigbee: [fz.xiaomi_multistate_action, fz.aqara_opple],
         toZigbee: [tz.xiaomi_switch_click_mode],
         exposes: [e.battery(), e.battery_voltage(), e.action(['single', 'double', 'hold']),
-            exposes.enum('click_mode', ea.SET, ['fast', 'multi'])
+            exposes.enum('click_mode', ea.ALL, ['fast', 'multi'])
                 .withDescription('Click mode, fast: only supports single click which will be send immediately after clicking.' +
                     'multi: supports more events like double and hold')],
         configure: async (device, coordinatorEndpoint, logger) => {
@@ -1853,7 +1855,7 @@ module.exports = [
         exposes: [e.battery(), e.battery_voltage(),
             e.action(['single_left', 'single_right', 'single_both', 'double_left', 'double_right', 'hold_left', 'hold_right']),
             // eslint-disable-next-line max-len
-            exposes.enum('click_mode', ea.SET, ['fast', 'multi']).withDescription('Click mode, fast: only supports single click which will be send immediately after clicking, multi: supports more events like double and hold'),
+            exposes.enum('click_mode', ea.ALL, ['fast', 'multi']).withDescription('Click mode, fast: only supports single click which will be send immediately after clicking, multi: supports more events like double and hold'),
         ],
         fromZigbee: [fz.xiaomi_multistate_action, fz.aqara_opple],
         toZigbee: [tz.xiaomi_switch_click_mode],
@@ -1864,4 +1866,23 @@ module.exports = [
             await endpoint1.write('aqaraOpple', {0x0125: {value: 0x02, type: 0x20}}, {manufacturerCode: 0x115f});
         },
     },
+    {
+        zigbeeModel: ['lumi.remote.b18ac1'],
+        model: 'WXKG14LM',
+        vendor: 'Xiaomi',
+        description: 'Aqara wireless remote switch H1 (single rocker)',
+        fromZigbee: [fz.xiaomi_multistate_action, fz.aqara_opple],
+        toZigbee: [tz.xiaomi_switch_click_mode, tz.aqara_opple_operation_mode],
+        exposes: [e.battery(), e.battery_voltage(), e.action(['single', 'double', 'triple', 'hold']),
+            exposes.enum('click_mode', ea.ALL, ['fast', 'multi'])
+                .withDescription('Click mode, fast: only supports single click which will be send immediately after clicking.' +
+                    'multi: supports more events like double and hold'),
+            exposes.enum('operation_mode', ea.ALL, ['command', 'event'])
+                .withDescription('Operation mode, select "command" to enable bindings (wake up the device before changing modes!)')],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint1 = device.getEndpoint(1);
+            await endpoint1.write('aqaraOpple', {'mode': 1}, {manufacturerCode: 0x115f, disableResponse: true});
+            await endpoint1.read('aqaraOpple', [0x0125], {manufacturerCode: 0x115f});
+        },
+    },
 ];

package/lib/exposes.js

@@ -294,20 +294,22 @@ class Light extends Base {
 
     withColor(types) {
         assert(!this.endpoint, 'Cannot add feature after adding endpoint');
-        if (types.includes('xy')) {
-            const colorXY = new Composite('color_xy', 'color')
-                .withFeature(new Numeric('x', access.ALL))
-                .withFeature(new Numeric('y', access.ALL))
-                .withDescription('Color of this light in the CIE 1931 color space (x/y)');
-            this.features.push(colorXY);
-        }
-
-        if (types.includes('hs')) {
-            const colorHS = new Composite('color_hs', 'color')
-                .withFeature(new Numeric('hue', access.ALL))
-                .withFeature(new Numeric('saturation', access.ALL))
-                .withDescription('Color of this light expressed as hue/saturation');
-            this.features.push(colorHS);
+        for (const type of types) {
+            if (type === 'xy') {
+                const colorXY = new Composite('color_xy', 'color')
+                    .withFeature(new Numeric('x', access.ALL))
+                    .withFeature(new Numeric('y', access.ALL))
+                    .withDescription('Color of this light in the CIE 1931 color space (x/y)');
+                this.features.push(colorXY);
+            } else if (type === 'hs') {
+                const colorHS = new Composite('color_hs', 'color')
+                    .withFeature(new Numeric('hue', access.ALL))
+                    .withFeature(new Numeric('saturation', access.ALL))
+                    .withDescription('Color of this light expressed as hue/saturation');
+                this.features.push(colorHS);
+            } else {
+                assert(false, `Unsupported color type ${type}`);
+            }
         }
 
         return this;
@@ -547,10 +549,10 @@ module.exports = {
         keypad_lockout: () => new Enum('keypad_lockout', access.ALL, ['unlock', 'lock1', 'lock2']).withDescription('Enables/disables physical input on the device'),
         led_disabled_night: () => new Binary('led_disabled_night', access.ALL, true, false).withDescription('Enable/disable the LED at night'),
         light_brightness: () => new Light().withBrightness(),
-        light_brightness_color: () => new Light().withBrightness().withColor((['xy', 'hs'])),
+        light_brightness_color: (preferHS) => new Light().withBrightness().withColor((preferHS ? ['hs', 'xy'] : ['xy', 'hs'])),
         light_brightness_colorhs: () => new Light().withBrightness().withColor(['hs']),
         light_brightness_colortemp: (colorTempRange) => new Light().withBrightness().withColorTemp(colorTempRange).withColorTempStartup(colorTempRange),
-        light_brightness_colortemp_color: (colorTempRange) => new Light().withBrightness().withColorTemp(colorTempRange).withColorTempStartup(colorTempRange).withColor(['xy', 'hs']),
+        light_brightness_colortemp_color: (colorTempRange, preferHS) => new Light().withBrightness().withColorTemp(colorTempRange).withColorTempStartup(colorTempRange).withColor(preferHS ? ['hs', 'xy'] : ['xy', 'hs']),
         light_brightness_colortemp_colorhs: (colorTempRange) => new Light().withBrightness().withColorTemp(colorTempRange).withColorTempStartup(colorTempRange).withColor(['hs']),
         light_brightness_colortemp_colorxy: (colorTempRange) => new Light().withBrightness().withColorTemp(colorTempRange).withColorTempStartup(colorTempRange).withColor(['xy']),
         light_brightness_colorxy: () => new Light().withBrightness().withColor((['xy'])),

package/lib/extend.js

@@ -50,8 +50,8 @@ const extend = {
         return result;
     },
     light_onoff_brightness_color: (options={}) => {
-        options = {disableEffect: false, supportsHS: false, ...options};
-        const exposes = [(options.supportsHS ? e.light_brightness_color() : e.light_brightness_colorxy()),
+        options = {disableEffect: false, supportsHS: false, preferHS: false, ...options};
+        const exposes = [(options.supportsHS ? e.light_brightness_color(options.preferHS) : e.light_brightness_colorxy()),
             ...(!options.disableEffect ? [e.effect()] : [])];
         const fromZigbee = [fz.color_colortemp, fz.on_off, fz.brightness, fz.level_config, fz.power_on_behavior, fz.ignore_basic_report];
         const toZigbee = [tz.light_onoff_brightness, tz.light_color, tz.ignore_transition, tz.ignore_rate, tz.light_brightness_move,
@@ -66,8 +66,8 @@ const extend = {
         };
     },
     light_onoff_brightness_colortemp_color: (options={}) => {
-        options = {disableEffect: false, supportsHS: false, disableColorTempStartup: false, ...options};
-        const exposes = [(options.supportsHS ? e.light_brightness_colortemp_color(options.colorTempRange) :
+        options = {disableEffect: false, supportsHS: false, disableColorTempStartup: false, preferHS: false, ...options};
+        const exposes = [(options.supportsHS ? e.light_brightness_colortemp_color(options.colorTempRange, options.preferHS) :
             e.light_brightness_colortemp_colorxy(options.colorTempRange)), ...(!options.disableEffect ? [e.effect()] : [])];
         const fromZigbee = [fz.color_colortemp, fz.on_off, fz.brightness, fz.level_config, fz.power_on_behavior, fz.ignore_basic_report];
         const toZigbee = [

package/lib/tuya.js

@@ -314,6 +314,12 @@ const dataPoints = {
     neoHumidityAlarm: 114,
     neoUnknown3: 115,
     neoVolume: 116,
+    // Neo AlarmOnly
+    neoAOBattPerc: 15,
+    neoAOMelody: 21,
+    neoAODuration: 7,
+    neoAOAlarm: 13,
+    neoAOVolume: 5,
     // Saswell TRV
     saswellHeating: 3,
     saswellWindowDetection: 8,
@@ -565,6 +571,10 @@ const dataPoints = {
     AM02Border: 16,
     AM02MotorWorkingMode: 20,
     AM02AddRemoter: 101,
+    // Matsee Tuya Garage Door Opener
+    garageDoorTrigger: 1,
+    garageDoorContact: 3,
+    garageDoorStatus: 12,
 };
 
 const thermostatWeekFormat = {
@@ -644,6 +654,11 @@ const tuyaRadar = {
         1: 'moving_forward',
         2: 'moving_backward',
     },
+    fallDown: {
+        0: 'none',
+        1: 'maybe_fall',
+        2: 'fall',
+    },
 };
 
 // Motion sensor lookups

package/lib/utils.js

@@ -72,12 +72,12 @@ function hasAlreadyProcessedMessage(msg, ID=null, key=null) {
     return false;
 }
 
-const defaultPrecision = {temperature: 2, humidity: 2, pressure: 1, pm25: 0};
+const defaultPrecision = {temperature: 2, humidity: 2, pressure: 1, pm25: 0, power: 2, voltage: 2, current: 2};
 function calibrateAndPrecisionRoundOptions(number, options, type) {
     // Calibrate
     const calibrateKey = `${type}_calibration`;
     let calibrationOffset = options && options.hasOwnProperty(calibrateKey) ? options[calibrateKey] : 0;
-    if (type == 'illuminance' || type === 'illuminance_lux') {
+    if (['illuminance', 'illuminance_lux', 'power', 'current', 'voltage'].includes(type)) {
         // linear calibration because measured value is zero based
         // +/- percent
         calibrationOffset = Math.round(number * calibrationOffset / 100);

package/npm-shrinkwrap.json

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

package/package.json

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