zigbee-herdsman-converters 14.0.385 → 14.0.389

package/converters/fromZigbee.js

@@ -4362,6 +4362,14 @@ const converters = {
         convert: (model, msg, publis, options, meta) => {
             // Don't use in production!
             // Used in: https://www.zigbee2mqtt.io/how_tos/how_to_support_new_tuya_devices.html
+            const getType = (datatype) => {
+                const entry = Object.entries(tuya.dataTypes).find(([typeName, typeId]) => typeId === datatype);
+                return (entry ? entry[0] : 'unknown');
+            };
+            const getAllDpIds = (dp) => {
+                const entries = Object.entries(tuya.dataPoints).filter(([dpName, dpId]) => dpId === dp);
+                return entries.map(([dpName, dpId]) => dpName);
+            };
             const getHex = (value) => {
                 let hex = value.toString(16);
                 if (hex.length < 2) {
@@ -4372,6 +4380,11 @@ const converters = {
             const now = Date.now().toString();
             let dataStr = '';
             for (const [i, dpValue] of msg.data.dpValues.entries()) {
+                const value = tuya.getDataValue(dpValue);
+                meta.logger.info(`zigbee-herdsman-converters:tuya_data_point_dump: Received DP #${
+                    dpValue.dp} from ${meta.device.ieeeAddr} with raw data '${JSON.stringify(dpValue)}': type='${msg.type}', datatype='${
+                    getType(dpValue.datatype)}', value='${value}', known DP# usage: ${JSON.stringify(getAllDpIds(dpValue.dp))}`);
+
                 dataStr +=
                     now + ' ' +
                     meta.device.ieeeAddr + ' ' +
@@ -5177,7 +5190,9 @@ const converters = {
                         payload.voltage = value;
                         payload.battery = batteryVoltageToPercentage(value, '3V_2100');
                     } else if (index === 3) payload.temperature = calibrateAndPrecisionRoundOptions(value, options, 'temperature'); // 0x03
-                    else if (index === 100) {
+                    else if (index === 5) {
+                        if (['JT-BZ-01AQ/A'].includes(model.model)) payload.power_outage_count = value;
+                    } else if (index === 100) {
                         if (['QBKG19LM', 'QBKG20LM', 'QBKG39LM', 'QBKG41LM', 'QBCZ15LM'].includes(model.model)) {
                             const mapping = model.model === 'QBCZ15LM' ? 'relay' : 'left';
                             payload[`state_${mapping}`] = value === 1 ? 'ON' : 'OFF';
@@ -5198,15 +5213,37 @@ const converters = {
                     } else if (index === 150) payload.voltage = precisionRound(value * 0.1, 1); // 0x96
                     else if (index === 151) payload.current = precisionRound(value * 0.001, 4); // 0x97
                     else if (index === 152) payload.power = precisionRound(value, 2); // 0x98
+                    else if (index === 159) payload.gas_sensitivity = {1: '15%LEL', 2: '10%LEL'}[value]; // JT-BZ-01AQ/A
+                    else if (index === 160) payload.gas = value === 1; // JT-BZ-01AQ/A
+                    else if (index === 161) payload.gas_density = value; // JT-BZ-01AQ/A
+                    else if (index === 162) payload.test = value === 1; // JT-BZ-01AQ/A
+                    else if (index === 163) payload.mute = value === 1; // JT-BZ-01AQ/A
+                    else if (index === 164) payload.state = value === 1 ? 'preparation' : 'work'; // JT-BZ-01AQ/A
+                    else if (index === 166) payload.linkage_alarm = value === 1; // JT-BZ-01AQ/A
                     else if (meta.logger) meta.logger.debug(`${model.zigbeeModel}: unknown index ${index} with value ${value}`);
                 }
             }
 
             if (msg.data.hasOwnProperty('0')) payload.detection_period = msg.data['0'];
+            if (msg.data.hasOwnProperty('2')) {
+                if (['JT-BZ-01AQ/A'].includes(model.model)) payload.power_outage_count = msg.data['2'];
+            }
             if (msg.data.hasOwnProperty('4')) payload.mode_switch = {4: 'anti_flicker_mode', 1: 'quick_mode'}[msg.data['4']];
             if (msg.data.hasOwnProperty('10')) payload.switch_type = {1: 'toggle', 2: 'momentary'}[msg.data['10']];
             if (msg.data.hasOwnProperty('258')) payload.detection_interval = msg.data['258'];
-            if (msg.data.hasOwnProperty('268')) payload.motion_sensitivity = {1: 'low', 2: 'medium', 3: 'high'}[msg.data['268']];
+            if (msg.data.hasOwnProperty('268')) {
+                if (['RTCGQ13LM'].includes(model.model)) {
+                    payload.motion_sensitivity = {1: 'low', 2: 'medium', 3: 'high'}[msg.data['268']];
+                } else if (['JT-BZ-01AQ/A'].includes(model.model)) {
+                    payload.gas_sensitivity = {1: '15%LEL', 2: '10%LEL'}[msg.data['268']];
+                }
+            }
+            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
+            if (msg.data.hasOwnProperty('314')) payload.gas = msg.data['314'] === 1; // JT-BZ-01AQ/A
+            if (msg.data.hasOwnProperty('315')) payload.gas_density = msg.data['315']; // JT-BZ-01AQ/A
+            if (msg.data.hasOwnProperty('331')) payload.linkage_alarm = msg.data['331'] === 1; // JT-BZ-01AQ/A
             if (msg.data.hasOwnProperty('512')) {
                 if (['ZNCZ15LM', 'QBCZ14LM', 'QBCZ15LM'].includes(model.model)) {
                     payload.button_lock = msg.data['512'] === 1 ? 'OFF' : 'ON';
@@ -7590,6 +7627,57 @@ const converters = {
             return result;
         },
     },
+    tuya_radar_sensor_fall: {
+        cluster: 'manuSpecificTuya',
+        type: ['commandDataResponse', 'commandDataReport'],
+        convert: (model, msg, publish, options, meta) => {
+            const dpValue = tuya.firstDpValue(msg, meta, 'tuya_radar_sensor_fall');
+            const dp = dpValue.dp;
+            const value = tuya.getDataValue(dpValue);
+            let result = null;
+            switch (dp) {
+            case tuya.dataPoints.trsfPresenceState:
+                result = {presence: {0: false, 1: true}[value]};
+                break;
+            case tuya.dataPoints.trsfMotionState:
+                result = {occupancy: {1: false, 2: true}[value]};
+                break;
+            case tuya.dataPoints.trsfMotionSpeed:
+                result = {motion_speed: value};
+                break;
+            case tuya.dataPoints.trsfMotionDirection:
+                result = {motion_direction: tuya.tuyaRadar.motionDirection[value]};
+                break;
+            case tuya.dataPoints.trsfScene:
+                result = {radar_scene: tuya.tuyaRadar.radarScene[value]};
+                break;
+            case tuya.dataPoints.trsfSensitivity:
+                result = {radar_sensitivity: value};
+                break;
+            case tuya.dataPoints.trsfIlluminanceLux:
+                result = {illuminance_lux: value};
+                break;
+            case tuya.dataPoints.trsfTumbleAlarmTime:
+                result = {tumble_alarm_time: value+1};
+                break;
+            case tuya.dataPoints.trsfTumbleSwitch:
+                result = {tumble_switch: {false: 'OFF', true: 'ON'}[value]};
+                break;
+            case tuya.dataPoints.trsfFallDownStatus:
+                result = {fall_down_status: {0: false, 1: true}[value]};
+                break;
+            case tuya.dataPoints.trsfStaticDwellAlarm:
+                result = {static_dwell_alarm: value};
+                break;
+            case tuya.dataPoints.trsfFallSensitivity:
+                result = {fall_sensitivity: value};
+                break;
+            default:
+                meta.logger.warn(`fromZigbee.tuya_radar_sensor_fall: NOT RECOGNIZED DP ${dp} with data ${JSON.stringify(dpValue)}`);
+            }
+            return result;
+        },
+    },
     tuya_smart_vibration_sensor: {
         cluster: 'manuSpecificTuya',
         type: ['commandGetData', 'commandDataResponse', 'raw'],
@@ -7956,6 +8044,81 @@ const converters = {
             return {action};
         },
     },
+    ZMAM02: {
+        cluster: 'manuSpecificTuya',
+        type: ['commandDataResponse', 'commandDataReport', 'commandSetDataresponse'],
+        convert: (model, msg, publish, options, meta) => {
+            const result = {};
+            // let value = tuya.getDataValue(dpValue);
+            // let result = null;
+            for (const dpValue of msg.data.dpValues) {
+                const value = tuya.getDataValue(dpValue);
+                switch (dpValue.dp) {
+                case tuya.dataPoints.AM02Control:
+                    result.control = tuya.ZMAM02.AM02Control[value];
+                    break;
+                case tuya.dataPoints.AM02PercentControl:
+                    result.percent_control = value;
+                    break;
+                case tuya.dataPoints.AM02ControlBackMode:
+                    result.control_back_mode = tuya.ZMAM02.AM02Direction[value];
+                    break;
+                case tuya.dataPoints.AM02MotorWorkingMode:
+                    switch (value) {
+                    case 0: // continuous 1
+                        result.motor_working_mode = 'continuous';
+                        break;
+                    case 1: // intermittently
+                        result.motor_working_mode = 'intermittently';
+                        break;
+                    default:
+                        meta.logger.warn('zigbee-herdsman-converters:ZM_AM_02: ' +
+                        `Mode ${value} is not recognized.`);
+                        break;
+                    }
+                    break;
+                case tuya.dataPoints.AM02Border:
+                    switch (value) {
+                    case 0: // up
+                        result.border = 'up';
+                        break;
+                    case 1: // down
+                        result.border = 'down';
+                        break;
+                    case 2: // down_delete
+                        result.border = 'down_delete';
+                        break;
+                    default:
+                        meta.logger.warn('zigbee-herdsman-converters:ZM_AM_02: ' +
+                        `Mode ${value} is not recognized.`);
+                        break;
+                    }
+                    break;
+                case tuya.dataPoints.AM02PercentState:
+                    result.percent_state = value;
+                    break;
+                case tuya.dataPoints.AM02Mode:
+                    switch (value) {
+                    case 0: // morning
+                        result.mode = 'morning';
+                        break;
+                    case 1: // night
+                        result.mode = 'night';
+                        break;
+                    default:
+                        meta.logger.warn('zigbee-herdsman-converters:ZM_AM_02: ' +
+                          `Mode ${value} is not recognized.`);
+                        break;
+                    }
+                    break;
+                default:
+                    meta.logger.warn(`fromZigbee.Zemismart Shader Konverter (Zm_AM02): NOT RECOGNIZED ` +
+                      `DP #${dpValue.dp} with data ${JSON.stringify(dpValue)}`);
+                }
+            }
+            return result;
+        },
+    },
     // #endregion
 
     // #region Ignore converters (these message dont need parsing).

package/converters/toZigbee.js

@@ -1982,7 +1982,7 @@ const converters = {
         convertSet: async (entity, key, value, meta) => {
             const lookup = {'siren_led': 3, 'siren': 2, 'led': 1, 'nothing': 0};
             await entity.write('genBasic', {0x400a: {value: lookup[value], type: 32}},
-                {manufacturerCode: 0x1168, disableDefaultResponse: true, sendWhenActive: true});
+                {manufacturerCode: 0x1168, disableDefaultResponse: true, sendWhen: 'active'});
             return {state: {alert_behaviour: value}};
         },
     },
@@ -2419,6 +2419,72 @@ const converters = {
             await entity.write('ssIasZone', {0xFFF1: {value: 0x03010000, type: 0x23}}, options);
         },
     },
+    JTBZ01AQA_gas: {
+        key: ['gas'],
+        convertGet: async (entity, key, meta) => {
+            await entity.read('aqaraOpple', [0x013a], manufacturerOptions.xiaomi);
+        },
+    },
+    JTBZ01AQA_gas_density: {
+        key: ['gas_density'],
+        convertGet: async (entity, key, meta) => {
+            await entity.read('aqaraOpple', [0x013b], manufacturerOptions.xiaomi);
+        },
+    },
+    JTBZ01AQA_gas_sensitivity: {
+        key: ['gas_sensitivity'],
+        convertSet: async (entity, key, value, meta) => {
+            value = value.toLowerCase();
+            const lookup = {'15%lel': 1, '10%lel': 2};
+            await entity.write('aqaraOpple', {0x010c: {value: lookup[value], type: 0x20}}, manufacturerOptions.xiaomi);
+            return {state: {gas_sensitivity: value}};
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read('aqaraOpple', [0x010c], manufacturerOptions.xiaomi);
+        },
+    },
+    JTBZ01AQA_selftest: {
+        key: ['selftest'],
+        convertSet: async (entity, key, value, meta) => {
+            await entity.write('aqaraOpple', {0x0127: {value: true, type: 0x10}}, manufacturerOptions.xiaomi);
+        },
+    },
+    JTBZ01AQA_mute_buzzer: {
+        key: ['mute_buzzer'],
+        convertSet: async (entity, key, value, meta) => {
+            await entity.write('aqaraOpple', {0x013f: {value: 15360, type: 0x23}}, manufacturerOptions.xiaomi);
+            await entity.write('aqaraOpple', {0x0126: {value: 1, type: 0x20}}, manufacturerOptions.xiaomi);
+        },
+    },
+    JTBZ01AQA_mute: {
+        key: ['mute'],
+        convertGet: async (entity, key, meta) => {
+            await entity.read('aqaraOpple', [0x0126], manufacturerOptions.xiaomi);
+        },
+    },
+    JTBZ01AQA_linkage_alarm: {
+        key: ['linkage_alarm'],
+        convertSet: async (entity, key, value, meta) => {
+            const lookup = {true: 1, false: 0};
+            await entity.write('aqaraOpple', {0x014b: {value: lookup[value], type: 0x20}}, manufacturerOptions.xiaomi);
+            return {state: {linkage_alarm: value}};
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read('aqaraOpple', [0x014b], manufacturerOptions.xiaomi);
+        },
+    },
+    JTBZ01AQA_state: {
+        key: ['state'],
+        convertGet: async (entity, key, meta) => {
+            await entity.read('aqaraOpple', [0x0139], manufacturerOptions.xiaomi);
+        },
+    },
+    aqara_power_outage_count: {
+        key: ['power_outage_count'],
+        convertGet: async (entity, key, meta) => {
+            await entity.read('aqaraOpple', [0x0002], manufacturerOptions.xiaomi);
+        },
+    },
     LLKZMK11LM_interlock: {
         key: ['interlock'],
         convertSet: async (entity, key, value, meta) => {
@@ -6033,7 +6099,7 @@ const converters = {
         key: ['keypad_lockout'],
         convertSet: async (entity, key, value, meta) => {
             const keypadLockout = utils.getKey(constants.keypadLockoutMode, value, value, Number);
-            entity.write('hvacUserInterfaceCfg', {keypadLockout}, {sendWhenActive: true});
+            entity.write('hvacUserInterfaceCfg', {keypadLockout}, {sendWhen: 'active'});
             entity.saveClusterAttributeKeyValue('hvacUserInterfaceCfg', {keypadLockout});
             return {state: {keypad_lockout: value}};
         },
@@ -6172,7 +6238,7 @@ const converters = {
         key: ['calibrate_valve'],
         convertSet: async (entity, key, value, meta) => {
             await entity.command('hvacThermostat', 'wiserSmartCalibrateValve', {},
-                {srcEndpoint: 11, disableDefaultResponse: true, sendWhenActive: true});
+                {srcEndpoint: 11, disableDefaultResponse: true, sendWhen: 'active'});
             return {state: {'calibrate_valve': value}};
         },
     },
@@ -6194,7 +6260,7 @@ const converters = {
         key: ['local_temperature_calibration'],
         convertSet: (entity, key, value, meta) => {
             entity.write('hvacThermostat', {localTemperatureCalibration: Math.round(value * 10)},
-                {srcEndpoint: 11, disableDefaultResponse: true, sendWhenActive: true});
+                {srcEndpoint: 11, disableDefaultResponse: true, sendWhen: 'active'});
             return {state: {local_temperature_calibration: value}};
         },
     },
@@ -6203,7 +6269,7 @@ const converters = {
         convertSet: async (entity, key, value, meta) => {
             const keypadLockout = utils.getKey(constants.keypadLockoutMode, value, value, Number);
             await entity.write('hvacUserInterfaceCfg', {keypadLockout},
-                {srcEndpoint: 11, disableDefaultResponse: true, sendWhenActive: true});
+                {srcEndpoint: 11, disableDefaultResponse: true, sendWhen: 'active'});
             return {state: {keypad_lockout: value}};
         },
     },
@@ -6305,6 +6371,30 @@ const converters = {
             }
         },
     },
+    tuya_radar_sensor_fall: {
+        key: ['radar_scene', 'radar_sensitivity', 'tumble_alarm_time', 'tumble_switch', 'fall_sensitivity'],
+        convertSet: async (entity, key, value, meta) => {
+            switch (key) {
+            case 'radar_scene':
+                await tuya.sendDataPointEnum(entity, tuya.dataPoints.trsfScene, utils.getKey(tuya.tuyaRadar.radarScene, value));
+                break;
+            case 'radar_sensitivity':
+                await tuya.sendDataPointValue(entity, tuya.dataPoints.trsfSensitivity, value);
+                break;
+            case 'tumble_switch':
+                await tuya.sendDataPointEnum(entity, tuya.dataPoints.trsfTumbleSwitch, {'on': true, 'off': false}[value.toLowerCase()]);
+                break;
+            case 'tumble_alarm_time':
+                await tuya.sendDataPointEnum(entity, tuya.dataPoints.trsfTumbleAlarmTime, value-1);
+                break;
+            case 'fall_sensitivity':
+                await tuya.sendDataPointValue(entity, tuya.dataPoints.trsfFallSensitivity, value);
+                break;
+            default: // Unknown Key
+                meta.logger.warn(`toZigbee.tuya_radar_sensor_fall: Unhandled Key ${key}`);
+            }
+        },
+    },
     javis_microwave_sensor: {
         key: [
             'illuminance_calibration', 'led_enable',
@@ -6592,6 +6682,33 @@ const converters = {
             }
         },
     },
+    ZMAM02: {
+        key: ['control', 'percent_control', 'mode', 'control_back_mode', 'border', 'motor_working_mode'],
+        convertSet: async (entity, key, value, meta) => {
+            switch (key) {
+            case 'control':
+                await tuya.sendDataPointEnum(entity, tuya.dataPoints.AM02Control, utils.getKey(tuya.ZMAM02.AM02Control, value));
+                break;
+            case 'percent_control':
+                await tuya.sendDataPointValue(entity, tuya.dataPoints.AM02PercentState, value);
+                break;
+            case 'mode':
+                await tuya.sendDataPointEnum(entity, tuya.dataPoints.AM02Mode, utils.getKey(tuya.ZMAM02.AM02Mode, value));
+                break;
+            case 'control_back_mode':
+                await tuya.sendDataPointEnum(entity, tuya.dataPoints.AM02ControlBackMode, utils.getKey(tuya.ZMAM02.AM02Direction, value));
+                break;
+            case 'border':
+                await tuya.sendDataPointEnum(entity, tuya.dataPoints.AM02Border, utils.getKey(tuya.ZMAM02.AM02Border, value));
+                break;
+            case 'motor_working_mode':
+                await tuya.sendDataPointEnum(entity, tuya.dataPoints.AM02MotorWorkingMode, utils.getKey(tuya.ZMAM02.AM02MotorMode, value));
+                break;
+            default: // Unknown Key
+                meta.logger.warn(`toZigbee.ZMAM02: Unhandled Key ${key}`);
+            }
+        },
+    },
     // #endregion
 
     // #region Ignore converters

package/devices/ikea.js

@@ -252,7 +252,7 @@ module.exports = [
         extend: tradfriExtend.light_onoff_brightness_colortemp(),
     },
     {
-        zigbeeModel: ['TRADFRI bulb E27 WS clear 950lm', 'TRADFRI bulb E26 WS clear 950lm'],
+        zigbeeModel: ['TRADFRI bulb E27 WS clear 950lm', 'TRADFRI bulb E26 WS clear 950lm', 'TRADFRI bulb E27 WS\uFFFDclear 950lm'],
         model: 'LED1546G12',
         vendor: 'IKEA',
         description: 'TRADFRI LED bulb E26/E27 950 lumen, dimmable, white spectrum, clear',

package/devices/ledvance.js

@@ -91,7 +91,7 @@ module.exports = [
         zigbeeModel: ['LEDVANCE DIM'],
         model: '4058075208421',
         vendor: 'LEDVANCE',
-        description: 'SMART+ candle E14 tunable white',
+        description: 'SMART+ candle E14 dimmable white',
         extend: extend.ledvance.light_onoff_brightness(),
         ota: ota.ledvance,
     },

package/devices/miboxer.js

@@ -4,6 +4,7 @@ const tz = require('../converters/toZigbee');
 const e = exposes.presets;
 const ea = exposes.access;
 const extend = require('../lib/extend');
+const tuya = require('../lib/tuya');
 
 module.exports = [
     {
@@ -21,11 +22,13 @@ module.exports = [
         ],
     },
     {
-        fingerprint: [{modelID: 'TS0501B', manufacturerName: '_TZ3210_dxroobu3'}],
+        fingerprint: [{modelID: 'TS0501B', manufacturerName: '_TZ3210_dxroobu3'},
+            {modelID: 'TS0501B', manufacturerName: '_TZ3210_dbilpfqk'}],
         model: 'FUT036Z',
         description: 'Single color LED controller',
         vendor: 'Miboxer',
         extend: extend.light_onoff_brightness(),
+        onEvent: tuya.onEventSetTime,
     },
     {
         fingerprint: [{modelID: 'TS0502B', manufacturerName: '_TZ3210_frm6149r'}],

package/devices/moes.js

@@ -9,6 +9,27 @@ const e = exposes.presets;
 const ea = exposes.access;
 
 module.exports = [
+    {
+        fingerprint: [{modelID: 'TS011F', manufacturerName: '_TZ3000_cymsnfvf'}],
+        model: 'ZP-LZ-FR2U',
+        vendor: 'Moes',
+        description: 'Zigbee 3.0 dual USB wireless socket plug',
+        fromZigbee: [fz.on_off, fz.tuya_switch_power_outage_memory],
+        toZigbee: [tz.on_off, tz.tuya_switch_power_outage_memory],
+        exposes: [e.switch().withEndpoint('l1'), e.switch().withEndpoint('l2'),
+            exposes.enum('power_outage_memory', ea.STATE_SET, ['on', 'off', 'restore'])
+                .withDescription('Recover state after power outage')],
+        endpoint: (device) => {
+            return {'l1': 1, 'l2': 2};
+        },
+        meta: {multiEndpoint: true},
+        configure: async (device, coordinatorEndpoint, logger) => {
+            await reporting.bind(device.getEndpoint(1), coordinatorEndpoint, ['genOnOff']);
+            await reporting.bind(device.getEndpoint(2), coordinatorEndpoint, ['genOnOff']);
+            await reporting.onOff(device.getEndpoint(1));
+            await reporting.onOff(device.getEndpoint(2));
+        },
+    },
     {
         fingerprint: [{modelID: 'TS0121', manufacturerName: '_TYZB01_iuepbmpv'}, {modelID: 'TS011F', manufacturerName: '_TZ3000_zmy1waw6'},
             {modelID: 'TS011F', manufacturerName: '_TZ3000_bkfe0bab'}],

package/devices/philips.js

@@ -1543,6 +1543,15 @@ module.exports = [
         extend: hueExtend.light_onoff_brightness_colortemp_color(),
         ota: ota.zigbeeOTA,
     },
+    {
+        zigbeeModel: ['LCF003', '4080248P7'],
+        model: '4080248P7',
+        vendor: 'Philips',
+        description: 'Hue Signe floor light',
+        meta: {turnsOffAtBrightness1: true},
+        extend: hueExtend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 500]}),
+        ota: ota.zigbeeOTA,
+    },
     {
         zigbeeModel: ['4080248U9'],
         model: '4080248U9',

package/devices/tuya.js

@@ -845,7 +845,6 @@ module.exports = [
             {modelID: 'TS0601', manufacturerName: '_TZE200_fzo2pocs'},
             {modelID: 'TS0601', manufacturerName: '_TZE200_5sbebbzs'},
             {modelID: 'TS0601', manufacturerName: '_TZE200_zuz7f94z'},
-            {modelID: 'TS0601', manufacturerName: '_TZE200_iossyxra'},
         ],
         model: 'TS0601_cover',
         vendor: 'TuYa',
@@ -1127,7 +1126,6 @@ module.exports = [
     {
         fingerprint: [
             {modelID: 'TS011F', manufacturerName: '_TZ3000_hyfvrar3'},
-            {modelID: 'TS011F', manufacturerName: '_TZ3000_cymsnfvf'},
             {modelID: 'TS011F', manufacturerName: '_TZ3000_bfn1w0mm'}],
         model: 'TS011F_plug_2',
         description: 'Smart plug (without power monitoring)',
@@ -1718,9 +1716,7 @@ module.exports = [
         ],
     },
     {
-        fingerprint: [
-            {modelID: 'TS0601', manufacturerName: '_TZE200_vrfecyku'},
-            {modelID: 'TS0601', manufacturerName: '_TZE200_lu01t0zl'}],
+        fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_vrfecyku'}],
         model: 'MIR-HE200-TY',
         vendor: 'TuYa',
         description: 'Human presence sensor',
@@ -1737,6 +1733,35 @@ module.exports = [
                 .withDescription('presets for sensitivity for presence and movement'),
         ],
     },
+    {
+        fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_lu01t0zl'}],
+        model: 'MIR-HE200-TY_fall',
+        vendor: 'TuYa',
+        description: 'Human presence sensor with fall function',
+        fromZigbee: [fz.tuya_radar_sensor_fall],
+        toZigbee: [tz.tuya_radar_sensor_fall],
+        exposes: [
+            e.illuminance_lux(), e.presence(), e.occupancy(),
+            exposes.numeric('motion_speed', ea.STATE).withDescription('Speed of movement'),
+            exposes.enum('motion_direction', ea.STATE, Object.values(tuya.tuyaRadar.motionDirection))
+                .withDescription('direction of movement from the point of view of the radar'),
+            exposes.numeric('radar_sensitivity', ea.STATE_SET).withValueMin(0).withValueMax(10).withValueStep(1)
+                .withDescription('sensitivity of the radar'),
+            exposes.enum('radar_scene', ea.STATE_SET, Object.values(tuya.tuyaRadar.radarScene))
+                .withDescription('presets for sensitivity for presence and movement'),
+            exposes.enum('tumble_switch', ea.STATE_SET, ['ON', 'OFF']).withDescription('Tumble status switch'),
+            exposes.numeric('fall_sensitivity', ea.STATE_SET).withValueMin(1).withValueMax(10).withValueStep(1)
+                .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.text('static_dwell_alarm', ea.STATE).withDescription('static dwell alarm'),
+        ],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await tuya.sendDataPointEnum(endpoint, tuya.dataPoints.trsfTumbleSwitch, false);
+        },
+    },
     {
         fingerprint: [{modelID: 'TS004F', manufacturerName: '_TZ3000_pcqjmcud'}],
         model: 'YSR-MINI-Z',

package/devices/xiaomi.js

@@ -1133,6 +1133,41 @@ module.exports = [
             exposes.numeric('gas_density', ea.STATE), exposes.enum('selftest', ea.SET, ['']),
         ],
     },
+    {
+        zigbeeModel: ['lumi.sensor_gas.acn02'],
+        model: 'JT-BZ-01AQ/A',
+        vendor: 'Xiaomi',
+        description: 'Aqara smart natural gas detector',
+        fromZigbee: [fz.aqara_opple],
+        toZigbee: [tz.JTBZ01AQA_gas, tz.JTBZ01AQA_gas_density, tz.JTBZ01AQA_gas_sensitivity, tz.JTBZ01AQA_selftest,
+            tz.JTBZ01AQA_mute_buzzer, tz.JTBZ01AQA_mute, tz.JTBZ01AQA_linkage_alarm, tz.JTBZ01AQA_state, tz.aqara_power_outage_count],
+        exposes: [e.gas().withAccess(ea.STATE_GET),
+            exposes.numeric('gas_density', ea.STATE_GET).withUnit('%LEL').withDescription('Value of gas concentration'),
+            exposes.enum('gas_sensitivity', ea.ALL, ['10%LEL', '15%LEL']).withDescription('Gas concentration value at which ' +
+                'an alarm is triggered ("10%LEL" is more sensitive than "15%LEL")'),
+            exposes.enum('selftest', ea.SET, ['Test']).withDescription('Starts the self-test process (checking the indicator ' +
+                'light and buzzer work properly)'),
+            exposes.binary('test', ea.STATE, true, false).withDescription('Self-test in progress'),
+            exposes.enum('mute_buzzer', ea.SET, ['Mute']).withDescription('Mute the buzzer for 10 minutes (buzzer cannot be ' +
+                'pre-muted, because this function only works when the alarm is triggered)'),
+            exposes.binary('mute', ea.STATE_GET, true, false).withDescription('Buzzer muted'),
+            exposes.switch().withState('linkage_alarm', true, 'After being turned on, one of the devices triggers the ' +
+                'natural gas leakage alarm, and other devices with linkage turned on', ea.ALL, true, false),
+            exposes.binary('state', ea.STATE_GET, 'preparation', 'work').withDescription('"Preparation" or "work" ' +
+                '(measurement of the gas concentration value and triggering of an alarm are only performed in the "work" state)'),
+            exposes.numeric('power_outage_count', ea.STATE_GET).withDescription('Number of power outages (since last pairing)')],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await endpoint.read('aqaraOpple', [0x013a], {manufacturerCode: 0x115f});
+            await endpoint.read('aqaraOpple', [0x013b], {manufacturerCode: 0x115f});
+            await endpoint.read('aqaraOpple', [0x0126], {manufacturerCode: 0x115f});
+            await endpoint.read('aqaraOpple', [0x0139], {manufacturerCode: 0x115f});
+            await endpoint.read('aqaraOpple', [0x010c], {manufacturerCode: 0x115f});
+            await endpoint.read('aqaraOpple', [0x014b], {manufacturerCode: 0x115f});
+            await endpoint.read('aqaraOpple', [0x0002], {manufacturerCode: 0x115f});
+        },
+        ota: ota.zigbeeOTA,
+    },
     {
         zigbeeModel: ['lumi.lock.v1'],
         model: 'A6121',

package/devices/zemismart.js

@@ -124,4 +124,26 @@ module.exports = [
             await reporting.onOff(device.getEndpoint(2));
         },
     },
+    {
+        fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_iossyxra'}],
+        model: 'ZM-AM02',
+        vendor: 'Zemismart',
+        description: 'Zigbee/RF curtain converter',
+        fromZigbee: [fz.ZMAM02],
+        toZigbee: [tz.ZMAM02],
+        exposes: [exposes.enum('motor_working_mode', ea.STATE_SET, Object.values(tuya.ZMAM02.AM02MotorMode)),
+            exposes.enum('control', ea.STATE_SET, Object.values(tuya.ZMAM02.AM02Control)),
+            exposes.numeric('percent_state', ea.STATE).withValueMin(0).withValueMax(100).withValueStep(1).withUnit('%'),
+            exposes.enum('mode', ea.STATE_SET, Object.values(tuya.ZMAM02.AM02Mode)),
+            exposes.enum('control_back_mode', ea.STATE_SET, Object.values(tuya.ZMAM02.AM02Direction)),
+            exposes.enum('border', ea.STATE_SET, Object.values(tuya.ZMAM02.AM02Border)),
+        // ---------------------------------------------------------------------------------
+        // DP exists, but not used at the moment
+        // exposes.numeric('percent_control', ea.STATE_SET).withValueMin(0).withValueMax(100).withValueStep(1).withUnit('%'),
+        // exposes.enum('work_state', ea.STATE, Object.values(tuya.ZMAM02.AM02WorkState)),
+        // exposes.numeric('countdown_left', ea.STATE).withUnit('s'),
+        // exposes.numeric('time_total', ea.STATE).withUnit('ms'),
+        // exposes.enum('situation_set', ea.STATE, Object.values(tuya.ZMAM02.AM02Situation)),
+        ],
+    },
 ];

package/lib/ota/common.js

@@ -385,11 +385,18 @@ async function updateToLatest(device, logger, onProgress, getNewImage, getImageM
 
                 endpoint.commandResponse('genOta', 'upgradeEndResponse', payload).then(
                     () => {
-                        logger.debug(`Update succeeded, waiting for device to restart`);
-                        setTimeout(() => {
-                            onProgress(100, null);
+                        logger.debug(`Update succeeded, waiting for device announce`);
+                        onProgress(100, null);
+
+                        let timer = null;
+                        const cb = () => {
+                            logger.debug('Got device announce or timed out, call resolve');
+                            clearInterval(timer);
+                            device.removeListener('deviceAnnounce', cb);
                             resolve();
-                        }, 90 * 1000);
+                        };
+                        timer = setTimeout(cb, 120 * 1000); // timeout after 2 minutes
+                        device.once('deviceAnnounce', cb);
                     },
                     (e) => {
                         const message = `Upgrade end reponse failed (${e.message})`;