zigbee-herdsman-converters 14.0.500 → 14.0.503

package/converters/fromZigbee.js

@@ -2562,42 +2562,51 @@ const converters = {
             const dpValue = tuya.firstDpValue(msg, meta, 'neo_nas_pd07');
             const dp = dpValue.dp;
             const value = tuya.getDataValue(dpValue);
-            if (dp === 101) return {occupancy: value > 0 ? true : false};
-            else if (dp === 102) {
+            switch (dp) {
+            case tuya.dataPoints.neoOccupancy:
+                return {occupancy: value > 0 ? true : false};
+            case 102:
                 return {
                     power_type: {0: 'battery_full', 1: 'battery_high', 2: 'battery_medium', 3: 'battery_low', 4: 'usb'}[value],
                     battery_low: value === 3,
                 };
-            } else if (dp === 103) {
+            case tuya.dataPoints.neoTamper:
                 return {tamper: value > 0 ? true : false};
-            } else if (dp === 104) {
+            case 104:
                 return {temperature: calibrateAndPrecisionRoundOptions(value / 10, options, 'temperature')};
-            } else if (dp === 105) {
+            case 105:
                 return {humidity: calibrateAndPrecisionRoundOptions(value, options, 'humidity')};
-            } else if (dp === tuya.dataPoints.neoMinTemp) {
+            case tuya.dataPoints.neoMinTemp:
                 return {temperature_min: value};
-            } else if (dp === tuya.dataPoints.neoMaxTemp) {
+            case tuya.dataPoints.neoMaxTemp:
                 return {temperature_max: value};
-            } else if (dp === tuya.dataPoints.neoMinHumidity) {
+            case tuya.dataPoints.neoMinHumidity:
                 return {humidity_min: value};
-            } else if (dp === tuya.dataPoints.neoMaxHumidity) {
+            case tuya.dataPoints.neoMaxHumidity:
                 return {humidity_max: value};
-            } else if (dp === 113) {
+            case tuya.dataPoints.neoTempScale:
+                return {temperature_scale: value ? '°C' : '°F'};
+            case 111:
+                return {unknown_111: value ? 'ON' : 'OFF'};
+            case 112:
+                return {unknown_112: value ? 'ON' : 'OFF'};
+            case tuya.dataPoints.neoTempHumidityAlarm:
                 return {alarm: {0: 'over_temperature', 1: 'over_humidity',
                     2: 'below_min_temperature', 3: 'below_min_humdity', 4: 'off'}[value]};
-            } else {
-                meta.logger.warn(`fromZigbee.neo_nas_pd07: Unrecognized DP #${dp} with data ${JSON.stringify(dpValue)}`);
+            default: // Unknown code
+                meta.logger.warn(`fz.neo_nas_pd07: Unhandled DP #${dp}: ${JSON.stringify(dpValue)}`);
             }
         },
     },
     neo_t_h_alarm: {
         cluster: 'manuSpecificTuya',
         type: ['commandDataReport', 'commandDataResponse'],
+        options: [exposes.options.precision('temperature'), exposes.options.calibration('temperature'),
+            exposes.options.precision('humidity'), exposes.options.calibration('humidity')],
         convert: (model, msg, publish, options, meta) => {
             const dpValue = tuya.firstDpValue(msg, meta, 'neo_t_h_alarm');
             const dp = dpValue.dp;
             const value = tuya.getDataValue(dpValue);
-
             switch (dp) {
             case tuya.dataPoints.neoAlarm:
                 return {alarm: value};
@@ -2610,9 +2619,9 @@ const converters = {
             case tuya.dataPoints.neoDuration: // 0x0267 [0,0,0,10] duration alarm in second
                 return {duration: value};
             case tuya.dataPoints.neoTemp: // 0x0269 [0,0,0,240] temperature
-                return {temperature: (value / 10).toFixed(1)};
+                return {temperature: calibrateAndPrecisionRoundOptions((value / 10), options, 'temperature')};
             case tuya.dataPoints.neoHumidity: // 0x026A [0,0,0,36] humidity
-                return {humidity: value};
+                return {humidity: calibrateAndPrecisionRoundOptions(value, options, 'humidity')};
             case tuya.dataPoints.neoMinTemp: // 0x026B [0,0,0,18] min alarm temperature
                 return {temperature_min: value};
             case tuya.dataPoints.neoMaxTemp: // 0x026C [0,0,0,27] max alarm temperature
@@ -2633,7 +2642,7 @@ const converters = {
             case tuya.dataPoints.neoVolume: // 0x0474 [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(dpValue)}`);
+                meta.logger.warn(`fz.neo_t_h_alarm: Unhandled DP #${dp}: ${JSON.stringify(dpValue)}`);
             }
         },
     },
@@ -4309,14 +4318,19 @@ const converters = {
                 // DP2: Smart Air Box: co2, Smart Air Housekeeper: MP25
             case tuya.dataPoints.tuyaSabCO2:
                 if (meta.device.manufacturerName === '_TZE200_dwcarsat') {
+                    if (value === 0xaaab) return; // Ignore: https://github.com/Koenkk/zigbee2mqtt/issues/11033#issuecomment-1109808552
                     return {pm25: calibrateAndPrecisionRoundOptions(value, options, 'pm25')};
                 } else if (meta.device.manufacturerName === '_TZE200_ryfmq5rl') {
-                    return {formaldehyd: calibrateAndPrecisionRoundOptions(value, options, 'formaldehyd')};
+                    return {formaldehyd: calibrateAndPrecisionRoundOptions(value, options, 'formaldehyd') / 100};
                 } else {
                     return {co2: calibrateAndPrecisionRoundOptions(value, options, 'co2')};
                 }
             case tuya.dataPoints.tuyaSabVOC:
-                return {voc: calibrateAndPrecisionRoundOptions(value, options, 'voc')};
+                if (meta.device.manufacturerName === '_TZE200_ryfmq5rl') {
+                    return {voc: calibrateAndPrecisionRoundOptions(value, options, 'voc') / 10};
+                } else {
+                    return {voc: calibrateAndPrecisionRoundOptions(value, options, 'voc')};
+                }
             case tuya.dataPoints.tuyaSahkFormaldehyd:
                 return {formaldehyd: calibrateAndPrecisionRoundOptions(value, options, 'formaldehyd')};
             default:
@@ -4737,7 +4751,7 @@ const converters = {
                     }
                     return {brightness: mapNumberRange(value, 10, 1000, 0, 254)};
                 }
-            } else if (meta.device.manufacturerName === '_TZE200_3p5ydos3') {
+            } else if (['_TZE200_3p5ydos3', '_TZE200_9i9dt8is', '_TZE200_dfxkcots'].includes(meta.device.manufacturerName)) {
                 if (dpValue.dp === tuya.dataPoints.eardaDimmerLevel) {
                     return {brightness: mapNumberRange(value, 0, 1000, 0, 254)};
                 } else if (dpValue.dp === tuya.dataPoints.dimmerMinLevel) {
@@ -7258,14 +7272,14 @@ const converters = {
             const dpValue = tuya.firstDpValue(msg, meta, 'ZB003X');
             const dp = dpValue.dp;
             const value = tuya.getDataValue(dpValue);
-
             switch (dp) {
             case tuya.dataPoints.fantemTemp:
-                return {temperature: calibrateAndPrecisionRoundOptions((value / 10).toFixed(1), options, 'temperature')};
+                return {temperature: calibrateAndPrecisionRoundOptions((value / 10), options, 'temperature')};
             case tuya.dataPoints.fantemHumidity:
                 return {humidity: calibrateAndPrecisionRoundOptions(value, options, 'humidity')};
             case tuya.dataPoints.fantemBattery:
-                return {battery: value};
+                // second battery level, first battery is reported by fz.battery
+                return {battery2: value};
             case tuya.dataPoints.fantemReportingTime:
                 return {reporting_time: value};
             case tuya.dataPoints.fantemTempCalibration:
@@ -7281,12 +7295,11 @@ const converters = {
             case tuya.dataPoints.fantemMotionEnable:
                 return {pir_enable: value};
             case tuya.dataPoints.fantemLedEnable:
-                return {led_enable: value};
+                return {led_enable: value ? false : true};
             case tuya.dataPoints.fantemReportingEnable:
                 return {reporting_enable: value};
             default:
-                meta.logger.warn(`zigbee-herdsman-converters:FantemZB003X: Unrecognized DP #${
-                    dp} with data ${JSON.stringify(dpValue)}`);
+                meta.logger.warn(`fz.ZB003X: Unhandled DP #${dp}: ${JSON.stringify(dpValue)}`);
             }
         },
     },
@@ -7296,7 +7309,7 @@ const converters = {
         convert: (model, msg, publish, options, meta) => {
             const data = msg.data;
             const senslookup = {'0': 'low', '1': 'medium', '2': 'high'};
-            const keeptimelookup = {'0': 0, '1': 30, '2': 60, '3': 120, '4': 240};
+            const keeptimelookup = {'0': 0, '1': 30, '2': 60, '3': 120, '4': 240, '5': 480};
             if (data && data.hasOwnProperty('currentZoneSensitivityLevel')) {
                 const value = data.currentZoneSensitivityLevel;
                 return {sensitivity: senslookup[value]};
@@ -7326,12 +7339,11 @@ const converters = {
             case tuya.dataPoints.fantemPowerSupplyMode:
                 return {power_supply_mode: {0: 'unknown', 1: 'no_neutral', 2: 'with_neutral'}[value]};
             case tuya.dataPoints.fantemExtSwitchType:
-                return {ext_switch_type: {0: 'unknown', 1: 'toggle_sw', 2: 'momentary_sw', 3: 'rotary_sw',
-                    4: 'auto_config'}[value]};
+                return {switch_type: {0: 'unknown', 1: 'toggle', 2: 'momentary', 3: 'rotary', 4: 'auto_config'}[value]};
             case tuya.dataPoints.fantemLoadDetectionMode:
                 return {load_detection_mode: {0: 'none', 1: 'first_power_on', 2: 'every_power_on'}[value]};
             case tuya.dataPoints.fantemExtSwitchStatus:
-                return {ext_switch_status: value};
+                return {switch_status: value};
             case tuya.dataPoints.fantemControlMode:
                 return {control_mode: {0: 'ext_switch', 1: 'remote', 2: 'both'}[value]};
             case 111:
@@ -8399,6 +8411,52 @@ const converters = {
             return result;
         },
     },
+    tuya_smart_human_presense_sensor: {
+        cluster: 'manuSpecificTuya',
+        type: ['commandDataResponse', 'commandDataReport'],
+        convert: (model, msg, publish, options, meta) => {
+            const dpValue = tuya.firstDpValue(msg, meta, 'tuya_smart_human_presense_sensor');
+            const dp = dpValue.dp;
+            const value = tuya.getDataValue(dpValue);
+            let result = null;
+            switch (dp) {
+            case tuya.dataPoints.tshpsPresenceState:
+                result = {presence: {0: false, 1: true}[value]};
+                break;
+            case tuya.dataPoints.tshpscSensitivity:
+                result = {radar_sensitivity: value};
+                break;
+            case tuya.dataPoints.tshpsMinimumRange:
+                result = {minimum_range: value/100};
+                break;
+            case tuya.dataPoints.tshpsMaximumRange:
+                result = {maximum_range: value/100};
+                break;
+            case tuya.dataPoints.tshpsTargetDistance:
+                result = {target_distance: value/100};
+                break;
+            case tuya.dataPoints.tshpsDetectionDelay:
+                result = {detection_delay: value/10};
+                break;
+            case tuya.dataPoints.tshpsFadingTime:
+                result = {fading_time: value/10};
+                break;
+            case tuya.dataPoints.tshpsIlluminanceLux:
+                result = {illuminance_lux: value};
+                break;
+            case tuya.dataPoints.tshpsCLI: // not recognize
+                result = {cli: value};
+                break;
+            case tuya.dataPoints.tshpsSelfTest:
+                result = {self_test: tuya.tuyaHPSCheckingResult [value]};
+                break;
+            default:
+                meta.logger
+                    .warn(`fromZigbee.tuya_smart_human_presense_sensor: NOT RECOGNIZED DP ${dp} with data ${JSON.stringify(dpValue)}`);
+            }
+            return result;
+        },
+    },
     // #endregion
 
     // #region Ignore converters (these message dont need parsing).

package/converters/toZigbee.js

@@ -5531,7 +5531,7 @@ const converters = {
         },
     },
     neo_nas_pd07: {
-        key: ['temperature_max', 'temperature_min', 'humidity_max', 'humidity_min'],
+        key: ['temperature_max', 'temperature_min', 'humidity_max', 'humidity_min', 'temperature_scale', 'unknown_111', 'unknown_112'],
         convertSet: async (entity, key, value, meta) => {
             switch (key) {
             case 'temperature_max':
@@ -5546,8 +5546,17 @@ const converters = {
             case 'humidity_min':
                 await tuya.sendDataPointValue(entity, tuya.dataPoints.neoMinHumidity, value);
                 break;
+            case 'temperature_scale':
+                await tuya.sendDataPointBool(entity, tuya.dataPoints.neoTempScale, value === '°C');
+                break;
+            case 'unknown_111':
+                await tuya.sendDataPointBool(entity, 111, value === 'ON');
+                break;
+            case 'unknown_112':
+                await tuya.sendDataPointBool(entity, 112, value === 'ON');
+                break;
             default: // Unknown key
-                throw new Error(`toZigbee.neo_nas_pd07: Unhandled key ${key}`);
+                throw new Error(`tz.neo_nas_pd07: Unhandled key ${key}`);
             }
         },
     },
@@ -5593,7 +5602,7 @@ const converters = {
                 await tuya.sendDataPointBool(entity, tuya.dataPoints.neoHumidityAlarm, value);
                 break;
             default: // Unknown key
-                throw new Error(`Unhandled key ${key}`);
+                throw new Error(`tz.neo_t_h_alarm: Unhandled key ${key}`);
             }
         },
     },
@@ -5624,7 +5633,10 @@ const converters = {
         },
     },
     nous_lcd_temperature_humidity_sensor: {
-        key: ['min_temperature', 'max_temperature', 'temperature_sensitivity', 'temperature_unit_convert'],
+        key: [
+            'min_temperature', 'max_temperature', 'temperature_sensitivity', 'temperature_unit_convert',
+            'min_humidity', 'max_humidity', 'report_interval',
+        ],
         convertSet: async (entity, key, value, meta) => {
             switch (key) {
             case 'temperature_unit_convert':
@@ -5639,6 +5651,15 @@ const converters = {
             case 'temperature_sensitivity':
                 await tuya.sendDataPointValue(entity, tuya.dataPoints.nousTempSensitivity, Math.round(value * 10));
                 break;
+            case 'min_humidity':
+                await tuya.sendDataPointValue(entity, tuya.dataPoints.nousMinHumi, Math.round(value * 10));
+                break;
+            case 'max_humidity':
+                await tuya.sendDataPointValue(entity, tuya.dataPoints.nousMaxHumi, Math.round(value * 10));
+                break;
+            case 'report_interval':
+                await tuya.sendDataPointValue(entity, tuya.dataPoints.nousReportInterval, value);
+                break;
             default: // Unknown key
                 meta.logger.warn(`Unhandled key ${key}`);
             }
@@ -6469,48 +6490,49 @@ const converters = {
         convertSet: async (entity, key, value, meta) => {
             switch (key) {
             case 'reporting_time':
-                await tuya.sendDataPointValue(entity, 102, value, 'sendData');
+                await tuya.sendDataPointValue(entity, tuya.dataPoints.fantemReportingTime, value, 'sendData');
                 break;
             case 'temperature_calibration':
                 value = Math.round(value * 10);
                 if (value < 0) value = 0xFFFFFFFF + value + 1;
-                await tuya.sendDataPointValue(entity, 104, value, 'sendData');
+                await tuya.sendDataPointValue(entity, tuya.dataPoints.fantemTempCalibration, value, 'sendData');
                 break;
             case 'humidity_calibration':
                 if (value < 0) value = 0xFFFFFFFF + value + 1;
-                await tuya.sendDataPointValue(entity, 105, value, 'sendData');
+                await tuya.sendDataPointValue(entity, tuya.dataPoints.fantemHumidityCalibration, value, 'sendData');
                 break;
             case 'illuminance_calibration':
                 if (value < 0) value = 0xFFFFFFFF + value + 1;
-                await tuya.sendDataPointValue(entity, 106, value, 'sendData');
+                await tuya.sendDataPointValue(entity, tuya.dataPoints.fantemLuxCalibration, value, 'sendData');
                 break;
             case 'pir_enable':
-                await tuya.sendDataPointBool(entity, 109, value, 'sendData');
+                await tuya.sendDataPointBool(entity, tuya.dataPoints.fantemMotionEnable, value, 'sendData');
                 break;
             case 'led_enable':
-                await tuya.sendDataPointBool(entity, 111, value, 'sendData');
+                await tuya.sendDataPointBool(entity, tuya.dataPoints.fantemLedEnable, value === false, 'sendData');
                 break;
             case 'reporting_enable':
-                await tuya.sendDataPointBool(entity, 112, value, 'sendData');
+                await tuya.sendDataPointBool(entity, tuya.dataPoints.fantemReportingEnable, value, 'sendData');
                 break;
             case 'sensitivity':
                 await entity.write('ssIasZone', {currentZoneSensitivityLevel: {'low': 0, 'medium': 1, 'high': 2}[value]});
                 break;
             case 'keep_time':
-                await entity.write('ssIasZone', {61441: {value: {'0': 0, '30': 1, '60': 2, '120': 3, '240': 4}[value], type: 0x20}});
+                await entity.write('ssIasZone', {61441: {value: {'0': 0, '30': 1, '60': 2, '120': 3,
+                    '240': 4, '480': 5}[value], type: 0x20}});
                 break;
             default: // Unknown key
-                throw new Error(`Unhandled key ${key}`);
+                throw new Error(`tz.ZB003X: Unhandled key ${key}`);
             }
         },
     },
     ZB006X_settings: {
-        key: ['ext_switch_type', 'load_detection_mode', 'control_mode'],
+        key: ['switch_type', 'load_detection_mode', 'control_mode'],
         convertSet: async (entity, key, value, meta) => {
             switch (key) {
-            case 'ext_switch_type':
-                await tuya.sendDataPointEnum(entity, tuya.dataPoints.fantemExtSwitchType, {'unknown': 0, 'toggle_sw': 1,
-                    'momentary_sw': 2, 'rotary_sw': 3, 'auto_config': 4}[value], 'sendData');
+            case 'switch_type':
+                await tuya.sendDataPointEnum(entity, tuya.dataPoints.fantemExtSwitchType, {'unknown': 0, 'toggle': 1,
+                    'momentary': 2, 'rotary': 3, 'auto_config': 4}[value], 'sendData');
                 break;
             case 'load_detection_mode':
                 await tuya.sendDataPointEnum(entity, tuya.dataPoints.fantemLoadDetectionMode, {'none': 0, 'first_power_on': 1,
@@ -7363,6 +7385,30 @@ const converters = {
             }
         },
     },
+    tuya_smart_human_presense_sensor: {
+        key: ['radar_sensitivity', 'minimum_range', 'maximum_range', 'detection_delay', 'fading_time'],
+        convertSet: async (entity, key, value, meta) => {
+            switch (key) {
+            case 'radar_sensitivity':
+                await tuya.sendDataPointValue(entity, tuya.dataPoints.tshpscSensitivity, value);
+                break;
+            case 'minimum_range':
+                await tuya.sendDataPointValue(entity, tuya.dataPoints.tshpsMinimumRange, value*100);
+                break;
+            case 'maximum_range':
+                await tuya.sendDataPointValue(entity, tuya.dataPoints.tshpsMaximumRange, value*100);
+                break;
+            case 'detection_delay':
+                await tuya.sendDataPointValue(entity, tuya.dataPoints.tshpsDetectionDelay, value*10);
+                break;
+            case 'fading_time':
+                await tuya.sendDataPointValue(entity, tuya.dataPoints.tshpsFadingTime, value*10);
+                break;
+            default: // Unknown Key
+                meta.logger.warn(`toZigbee.tuya_smart_human_presense_sensor: Unhandled Key ${key}`);
+            }
+        },
+    },
     // #endregion
 
     // #region Ignore converters

package/devices/fantem.js

@@ -20,9 +20,9 @@ module.exports = [
         exposes: [e.light_brightness(),
             e.action(['on', 'off', 'brightness_move_down', 'brightness_move_up', 'brightness_stop']),
             exposes.enum('control_mode', ea.STATE_SET, ['ext_switch', 'remote', 'both']).withDescription('Control mode'),
-            exposes.enum('ext_switch_type', ea.STATE_SET, ['unknown', 'toggle_sw', 'momentary_sw', 'rotary_sw', 'auto_config'])
+            exposes.enum('switch_type', ea.STATE_SET, ['unknown', 'toggle', 'momentary', 'rotary', 'auto_config'])
                 .withDescription('External switch type'),
-            exposes.numeric('ext_switch_status', ea.STATE).withDescription('External switch status')
+            exposes.numeric('switch_status', ea.STATE).withDescription('External switch status')
                 .withValueMin(-10000).withValueMax(10000),
             exposes.enum('load_detection_mode', ea.STATE_SET, ['none', 'first_power_on', 'every_power_on'])
                 .withDescription('Load detection mode'),
@@ -43,30 +43,33 @@ module.exports = [
             // https://github.com/Koenkk/zigbee2mqtt/issues/9057#issuecomment-1007742130
             await endpoint.read('genBasic', ['manufacturerName', 'zclVersion', 'appVersion', 'modelId', 'powerSource', 0xfffe]);
             await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'genLevelCtrl']);
-            await reporting.onOff(endpoint);
         },
     },
     {
-        fingerprint: [{modelID: 'TS0202', manufacturerName: '_TZ3210_rxqls8v0'}, {modelID: 'TS0202', manufacturerName: '_TZ3210_zmy9hjay'}],
+        fingerprint: [{modelID: 'TS0202', manufacturerName: '_TZ3210_rxqls8v0'},
+            {modelID: 'TS0202', manufacturerName: '_TZ3210_zmy9hjay'}],
         model: 'ZB003-X',
         vendor: 'Fantem',
         description: '4 in 1 multi sensor',
         fromZigbee: [fz.battery, fz.ignore_basic_report, fz.illuminance, fz.ZB003X, fz.ZB003X_attr, fz.ZB003X_occupancy],
         toZigbee: [tz.ZB003X],
-        exposes: [e.occupancy(), e.tamper(), e.battery(), e.illuminance(), e.illuminance_lux().withUnit('lx'), e.temperature(),
-            e.humidity(), exposes.numeric('reporting_time', ea.STATE_SET).withDescription('Reporting interval in minutes')
-                .withValueMin(0).withValueMax(1440),
-            exposes.numeric('temperature_calibration', ea.STATE_SET).withDescription('Temperature calibration')
+        exposes: [e.occupancy(), e.tamper(), e.illuminance_lux(), e.illuminance(), e.temperature(), e.humidity(),
+            e.battery(), e.battery_voltage(),
+            exposes.numeric('battery2', ea.STATE).withUnit('%').withDescription('Remaining battery 2 in %'),
+            exposes.numeric('illuminance_calibration', ea.STATE_SET).withDescription('Illuminance calibration in lux')
                 .withValueMin(-20).withValueMax(20),
+            exposes.numeric('temperature_calibration', ea.STATE_SET).withDescription('Temperature calibration (-2.0...2.0)')
+                .withValueMin(-2).withValueMax(2).withValueStep(0.1),
             exposes.numeric('humidity_calibration', ea.STATE_SET).withDescription('Humidity calibration')
-                .withValueMin(-50).withValueMax(50),
-            exposes.numeric('illuminance_calibration', ea.STATE_SET).withDescription('Illuminance calibration')
-                .withValueMin(-10000).withValueMax(10000),
+                .withValueMin(-15).withValueMax(15),
+            exposes.binary('reporting_enable', ea.STATE_SET, true, false).withDescription('Enable reporting'),
+            exposes.numeric('reporting_time', ea.STATE_SET).withDescription('Reporting interval in minutes')
+                .withValueMin(0).withValueMax(1440).withValueStep(5),
+            exposes.binary('led_enable', ea.STATE_SET, true, false).withDescription('Enable LED'),
             exposes.binary('pir_enable', ea.STATE_SET, true, false).withDescription('Enable PIR sensor'),
-            exposes.binary('led_enable', ea.STATE_SET, true, false).withDescription('Enabled LED'),
-            exposes.binary('reporting_enable', ea.STATE_SET, true, false).withDescription('Enabled reporting'),
             exposes.enum('sensitivity', ea.STATE_SET, ['low', 'medium', 'high']).withDescription('PIR sensor sensitivity'),
             // eslint-disable-next-line
-            exposes.enum('keep_time', ea.STATE_SET, ['0', '30', '60', '120', '240']).withDescription('PIR keep time in seconds')],
+            exposes.enum('keep_time', ea.STATE_SET, ['0', '30', '60', '120', '240', '480'])
+                .withDescription('PIR keep time in seconds')],
     },
 ];

package/devices/heiman.js

@@ -469,7 +469,7 @@ module.exports = [
         exposes: [e.vibration(), e.battery_low(), e.tamper(), e.battery()],
     },
     {
-        fingerprint: [{modelID: 'Vibration-EF_3.0', manufacturerName: 'HEIMAN'}],
+        fingerprint: [{modelID: 'Vibration-EF_3.0', manufacturerName: 'HEIMAN'}, {modelID: 'Vibration-EF-3.0', manufacturerName: 'HEIMAN'}],
         model: 'HS1VS-EF',
         vendor: 'HEIMAN',
         description: 'Vibration sensor',

package/devices/lonsonho.js

@@ -210,7 +210,7 @@ module.exports = [
             exposes.numeric('calibration_time', ea.STATE).withUnit('S').withDescription('Calibration time')],
     },
     {
-        fingerprint: [{modelID: 'TS110E', manufacturerName: '_TZ3210_zxbtub8r'}],
+        fingerprint: [{modelID: 'TS110E', manufacturerName: '_TZ3210_zxbtub8r'}, {modelID: 'TS110E', manufacturerName: '_TZ3210_ngqk6jia'}],
         model: 'TS110E_1gang',
         vendor: 'Lonsonho',
         description: 'Zigbee smart dimmer module 1 gang with neutral',

package/devices/moes.js

@@ -15,11 +15,11 @@ module.exports = [
         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],
+        fromZigbee: [fz.on_off, fz.tuya_switch_power_outage_memory, fz.ts011f_plug_child_mode],
+        toZigbee: [tz.on_off, tz.tuya_switch_power_outage_memory, tz.ts011f_plug_child_mode],
         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')],
+                .withDescription('Recover state after power outage'), e.child_lock()],
         endpoint: (device) => {
             return {'l1': 1, 'l2': 2};
         },

package/devices/neo.js

@@ -12,18 +12,18 @@ module.exports = [
         model: 'NAS-AB02B0',
         vendor: 'Neo',
         description: 'Temperature & humidity sensor and alarm',
-        fromZigbee: [fz.neo_t_h_alarm, fz.ignore_basic_report],
+        fromZigbee: [fz.neo_t_h_alarm, fz.ignore_basic_report, fz.ignore_tuya_set_time],
         toZigbee: [tz.neo_t_h_alarm],
         exposes: [
             e.temperature(), e.humidity(), exposes.binary('humidity_alarm', ea.STATE_SET, true, false), e.battery_low(),
             exposes.binary('temperature_alarm', ea.STATE_SET, true, false),
             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(1000),
-            exposes.numeric('temperature_min', ea.STATE_SET).withUnit('°C').withValueMin(-10).withValueMax(35),
-            exposes.numeric('temperature_max', ea.STATE_SET).withUnit('°C').withValueMin(-10).withValueMax(35),
-            exposes.numeric('humidity_min', ea.STATE_SET).withUnit('%').withValueMin(0).withValueMax(100),
-            exposes.numeric('humidity_max', ea.STATE_SET).withUnit('%').withValueMin(0).withValueMax(100),
+            exposes.numeric('duration', ea.STATE_SET).withUnit('second').withValueMin(0).withValueMax(1800),
+            exposes.numeric('temperature_min', ea.STATE_SET).withUnit('°C').withValueMin(-20).withValueMax(80),
+            exposes.numeric('temperature_max', ea.STATE_SET).withUnit('°C').withValueMin(-20).withValueMax(80),
+            exposes.numeric('humidity_min', ea.STATE_SET).withUnit('%').withValueMin(1).withValueMax(100),
+            exposes.numeric('humidity_max', ea.STATE_SET).withUnit('%').withValueMin(1).withValueMax(100),
             exposes.enum('volume', ea.STATE_SET, ['low', 'medium', 'high']),
             exposes.enum('power_type', ea.STATE, ['battery_full', 'battery_high', 'battery_medium', 'battery_low', 'usb']),
         ],
@@ -62,16 +62,25 @@ module.exports = [
         model: 'NAS-PD07',
         vendor: 'Neo',
         description: 'Motion, temperature & humidity sensor',
-        fromZigbee: [fz.neo_nas_pd07],
+        fromZigbee: [fz.neo_nas_pd07, fz.ignore_tuya_set_time],
         toZigbee: [tz.neo_nas_pd07],
         onEvent: tuya.onEventSetTime,
         exposes: [e.occupancy(), e.humidity(), e.temperature(), e.tamper(), e.battery_low(),
             exposes.enum('power_type', ea.STATE, ['battery_full', 'battery_high', 'battery_medium', 'battery_low', 'usb']),
             exposes.enum('alarm', ea.STATE, ['over_temperature', 'over_humidity', 'below_min_temperature', 'below_min_humdity', 'off'])
                 .withDescription('Temperature/humidity alarm status'),
-            exposes.numeric('temperature_min', ea.STATE_SET).withUnit('°C').withValueMin(-40).withValueMax(40),
-            exposes.numeric('temperature_max', ea.STATE_SET).withUnit('°C').withValueMin(-40).withValueMax(40),
-            exposes.numeric('humidity_min', ea.STATE_SET).withUnit('%').withValueMin(0).withValueMax(100),
-            exposes.numeric('humidity_max', ea.STATE_SET).withUnit('%').withValueMin(0).withValueMax(100)],
+            exposes.numeric('temperature_min', ea.STATE_SET).withUnit('°C').withValueMin(-20).withValueMax(80),
+            exposes.numeric('temperature_max', ea.STATE_SET).withUnit('°C').withValueMin(-20).withValueMax(80),
+            exposes.binary('temperature_scale', ea.STATE_SET, '°C', '°F').withDescription('Temperature scale (°F/°C)'),
+            exposes.numeric('humidity_min', ea.STATE_SET).withUnit('%').withValueMin(1).withValueMax(100),
+            exposes.numeric('humidity_max', ea.STATE_SET).withUnit('%').withValueMin(1).withValueMax(100),
+            // exposes.binary('unknown_111', ea.STATE_SET, 'ON', 'OFF').withDescription('Unknown datapoint 111 (default: ON)'),
+            // exposes.binary('unknown_112', ea.STATE_SET, 'ON', 'OFF').withDescription('Unknown datapoint 112 (default: ON)')
+        ],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await endpoint.read('genBasic', ['manufacturerName', 'zclVersion', 'appVersion', 'modelId', 'powerSource', 0xfffe]);
+            await endpoint.command('manuSpecificTuya', 'mcuVersionRequest', {'seq': 0x0002});
+        },
     },
 ];

package/devices/nue_3a.js

@@ -286,7 +286,7 @@ module.exports = [
         extend: extend.light_onoff_brightness_colortemp_color(),
     },
     {
-        zigbeeModel: ['LXN60-LS27-Z30'],
+        zigbeeModel: ['LXN60-LS27-Z30', 'FEB56-ZCW2CLX1.0'],
         model: 'WL-SD001-9W',
         vendor: 'Nue / 3A',
         description: '9W RGB LED downlight',

package/devices/philips.js

@@ -2579,6 +2579,15 @@ module.exports = [
         extend: hueExtend.light_onoff_brightness_colortemp({colorTempRange: [153, 454]}),
         ota: ota.zigbeeOTA,
     },
+    {
+        zigbeeModel: ['929003046201_01', '929003046201_02', '929003046201_03'],
+        model: '929003046201',
+        vendor: 'Philips',
+        description: 'Hue White Ambiance Runner triple spotlight',
+        meta: {turnsOffAtBrightness1: true},
+        extend: hueExtend.light_onoff_brightness_colortemp({colorTempRange: [153, 454]}),
+        ota: ota.zigbeeOTA,
+    },
     {
         zigbeeModel: ['5309331P6', '5309330P6', '929003046301_03', '929003046301_02'],
         model: '5309331P6',

package/devices/saswell.js

@@ -16,6 +16,7 @@ module.exports = [
             {modelID: 'TS0601', manufacturerName: '_TZE200_c88teujp'},
             {modelID: 'TS0601', manufacturerName: '_TZE200_yw7cahqs'},
             {modelID: 'TS0601', manufacturerName: '_TZE200_azqp6ssj'},
+            {modelID: 'TS0601', manufacturerName: '_TZE200_bvu2wnxz'},
             {modelID: 'TS0601', manufacturerName: '_TZE200_zuhszj9s'},
             {modelID: 'TS0601', manufacturerName: '_TZE200_9gvruqf5'},
             {modelID: 'TS0601', manufacturerName: '_TZE200_zr9c0day'},

package/devices/tuya.js

@@ -13,7 +13,7 @@ const utils = require('../lib/utils');
 const TS011Fplugs = ['_TZ3000_5f43h46b', '_TZ3000_cphmq0q7', '_TZ3000_dpo1ysak', '_TZ3000_ew3ldmgx', '_TZ3000_gjnozsaz',
     '_TZ3000_jvzvulen', '_TZ3000_mraovvmm', '_TZ3000_nfnmi125', '_TZ3000_ps3dmato', '_TZ3000_w0qqde0g', '_TZ3000_u5u4cakc',
     '_TZ3000_rdtixbnu', '_TZ3000_typdpbpg', '_TZ3000_kx0pris5', '_TZ3000_amdymr7l', '_TZ3000_z1pnpsdo', '_TZ3000_ksw8qtmt',
-    '_TZ3000_nzkqcvvs', '_TZ3000_1h2x4akh'];
+    '_TZ3000_nzkqcvvs', '_TZ3000_1h2x4akh', '_TZ3000_9vo5icau'];
 
 const tzLocal = {
     TS0504B_color: {
@@ -1413,7 +1413,8 @@ module.exports = [
         model: 'TS011F_plug_3',
         description: 'Smart plug (with power monitoring by polling)',
         vendor: 'TuYa',
-        whiteLabel: [{vendor: 'VIKEFON', model: 'TS011F'}, {vendor: 'BlitzWolf', model: 'BW-SHP15'}],
+        whiteLabel: [{vendor: 'VIKEFON', model: 'TS011F'}, {vendor: 'BlitzWolf', model: 'BW-SHP15'},
+            {vendor: 'Avatto', model: 'MIUCOT10Z'}],
         ota: ota.zigbeeOTA,
         fromZigbee: [fz.on_off, fz.electrical_measurement, fz.metering, fz.ignore_basic_report, fz.tuya_switch_power_outage_memory,
             fz.ts011f_plug_indicator_mode, fz.ts011f_plug_child_mode],
@@ -2247,4 +2248,60 @@ module.exports = [
         fromZigbee: [fz.tuya_remote],
         toZigbee: [],
     },
+    {
+        fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_ikvncluo'}],
+        model: 'TS0601_smart_human_presense_sensor',
+        vendor: 'TuYa',
+        description: 'Smart Human presence sensor',
+        fromZigbee: [fz.tuya_smart_human_presense_sensor],
+        toZigbee: [tz.tuya_smart_human_presense_sensor],
+        exposes: [
+            e.illuminance_lux(), e.presence(),
+            exposes.numeric('target_distance', ea.STATE).withDescription('Distance to target').withUnit('m'),
+            exposes.numeric('radar_sensitivity', ea.STATE_SET).withValueMin(0).withValueMax(9).withValueStep(1)
+                .withDescription('sensitivity of the radar'),
+            exposes.numeric('minimum_range', ea.STATE_SET).withValueMin(0).withValueMax(9.5).withValueStep(0.15)
+                .withDescription('Minimum range').withUnit('m'),
+            exposes.numeric('maximum_range', ea.STATE_SET).withValueMin(0).withValueMax(9.5).withValueStep(0.15)
+                .withDescription('Maximum range').withUnit('m'),
+            exposes.numeric('detection_delay', ea.STATE_SET).withValueMin(0).withValueMax(10).withValueStep(0.1)
+                .withDescription('Detection delay').withUnit('s'),
+            exposes.numeric('fading_time', ea.STATE_SET).withValueMin(0).withValueMax(1500).withValueStep(1)
+                .withDescription('Fading time').withUnit('s'),
+            // exposes.text('cli', ea.STATE).withDescription('not recognize'),
+            exposes.enum('self_test', ea.STATE, Object.values(tuya.tuyaHPSCheckingResult))
+                .withDescription('Self_test, possible resuts: checking, check_success, check_failure, others, comm_fault, radar_fault.'),
+        ],
+    },
+    {
+        fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_whkgqxse'}],
+        model: 'JM-TRH-ZGB-V1',
+        vendor: 'TuYa',
+        description: 'Temperature & humidity sensor with clock',
+        fromZigbee: [fz.nous_lcd_temperature_humidity_sensor, fz.ignore_tuya_set_time],
+        toZigbee: [tz.nous_lcd_temperature_humidity_sensor],
+        onEvent: tuya.onEventSetLocalTime,
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genBasic']);
+        },
+        exposes: [
+            e.temperature(), e.humidity(), e.battery(),
+            exposes.numeric('report_interval', ea.STATE_SET).withUnit('min').withValueMin(5).withValueMax(60).withValueStep(5)
+                .withDescription('Report interval'),
+            exposes.enum('temperature_unit_convert', ea.STATE_SET, ['celsius', 'fahrenheit']).withDescription('Current display unit'),
+            exposes.enum('temperature_alarm', ea.STATE, ['canceled', 'lower_alarm', 'upper_alarm'])
+                .withDescription('Temperature alarm status'),
+            exposes.numeric('max_temperature', ea.STATE_SET).withUnit('°C').withValueMin(-20).withValueMax(60)
+                .withDescription('Alarm temperature max'),
+            exposes.numeric('min_temperature', ea.STATE_SET).withUnit('°C').withValueMin(-20).withValueMax(60)
+                .withDescription('Alarm temperature min'),
+            exposes.enum('humidity_alarm', ea.STATE, ['canceled', 'lower_alarm', 'upper_alarm'])
+                .withDescription('Humidity alarm status'),
+            exposes.numeric('max_humidity', ea.STATE_SET).withUnit('%').withValueMin(0).withValueMax(100)
+                .withDescription('Alarm humidity max'),
+            exposes.numeric('min_humidity', ea.STATE_SET).withUnit('%').withValueMin(0).withValueMax(100)
+                .withDescription('Alarm humidity min'),
+        ],
+    },
 ];

package/devices/xiaomi.js

@@ -844,15 +844,17 @@ module.exports = [
         model: 'WSDCGQ12LM',
         vendor: 'Xiaomi',
         description: 'Aqara T1 temperature, humidity and pressure sensor',
-        fromZigbee: [fz.xiaomi_basic, fz.temperature, fz.humidity, fz.pressure],
+        fromZigbee: [fz.aqara_opple, fz.temperature, fz.humidity, fz.pressure, fz.battery],
         toZigbee: [],
+        exposes: [e.temperature(), e.humidity(), e.pressure(), e.battery(), e.battery_voltage()],
         meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
             const binds = ['msTemperatureMeasurement', 'msRelativeHumidity', 'msPressureMeasurement'];
             await reporting.bind(endpoint, coordinatorEndpoint, binds);
+            await endpoint.read('genPowerCfg', ['batteryVoltage']);
         },
-        exposes: [e.battery(), e.temperature(), e.humidity(), e.pressure(), e.battery_voltage()],
+        ota: ota.zigbeeOTA,
     },
     {
         zigbeeModel: ['lumi.sensor_motion'],
@@ -1958,6 +1960,7 @@ module.exports = [
         model: 'WXKG16LM',
         vendor: 'Xiaomi',
         description: 'Aqara wireless remote switch E1 (single rocker)',
+        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
         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']),

package/lib/tuya.js

@@ -358,11 +358,14 @@ const dataPoints = {
     moesSmaxTempSet: 108,
     moesSminTempSet: 109,
     // Neo T&H
+    neoOccupancy: 101,
     neoPowerType: 101,
     neoMelody: 102,
     neoDuration: 103,
+    neoTamper: 103,
     neoAlarm: 104,
     neoTemp: 105,
+    neoTempScale: 106,
     neoHumidity: 106,
     neoMinTemp: 107,
     neoMaxTemp: 108,
@@ -370,6 +373,7 @@ const dataPoints = {
     neoMaxHumidity: 110,
     neoUnknown2: 112,
     neoTempAlarm: 113,
+    neoTempHumidityAlarm: 113,
     neoHumidityAlarm: 114,
     neoUnknown3: 115,
     neoVolume: 116,
@@ -613,8 +617,12 @@ const dataPoints = {
     nousTempUnitConvert: 9,
     nousMaxTemp: 10,
     nousMinTemp: 11,
+    nousMaxHumi: 12,
+    nousMinHumi: 13,
     nousTempAlarm: 14,
+    nousHumiAlarm: 15,
     nousTempSensitivity: 19,
+    nousReportInterval: 17,
     // TUYA / HUMIDITY/ILLUMINANCE/TEMPERATURE SENSOR
     thitBatteryPercentage: 3,
     thitIlluminanceLux: 7,
@@ -667,6 +675,17 @@ const dataPoints = {
     connecteTempProgram: 105,
     connecteOpenWindow: 106,
     connecteMaxProtectTemp: 107,
+    // TuYa Smart Human Presense Sensor
+    tshpsPresenceState: 1,
+    tshpscSensitivity: 2,
+    tshpsMinimumRange: 3,
+    tshpsMaximumRange: 4,
+    tshpsTargetDistance: 9,
+    tshpsDetectionDelay: 101,
+    tshpsFadingTime: 102,
+    tshpsIlluminanceLux: 104,
+    tshpsCLI: 103, // not recognize
+    tshpsSelfTest: 6, // not recognize
 };
 
 const thermostatWeekFormat = {
@@ -833,6 +852,14 @@ const moesSwitch = {
         3: 'freeze',
     },
 };
+const tuyaHPSCheckingResult = {
+    0: 'checking',
+    1: 'check_success',
+    2: 'check_failure',
+    3: 'others',
+    4: 'comm_fault',
+    5: 'radar_fault',
+};
 
 // Return `seq` - transaction ID for handling concrete response
 async function sendDataPoints(entity, dpValues, cmd, seq=undefined) {
@@ -991,4 +1018,5 @@ module.exports = {
     tuyaRadar,
     ZMLookups,
     moesSwitch,
+    tuyaHPSCheckingResult,
 };

package/lib/xiaomi.js

@@ -158,7 +158,9 @@ const numericAttributes2Payload = (msg, meta, model, options, dataObject) => {
             }
             break;
         case '3':
-            if (!['WXCJKG11LM', 'WXCJKG12LM', 'WXCJKG13LM'].includes(model.model)) {
+            if (['WSDCGQ12LM'].includes(model.model)) {
+                // This temperature value is ignored because with greater accuracy it is reported in key №100
+            } else if (!['WXCJKG11LM', 'WXCJKG12LM', 'WXCJKG13LM'].includes(model.model)) {
                 payload.temperature = calibrateAndPrecisionRoundOptions(value, options, 'temperature'); // 0x03
             }
             break;
@@ -200,7 +202,7 @@ const numericAttributes2Payload = (msg, meta, model, options, dataObject) => {
                 // We don't know what the value means for these devices.
                 // https://github.com/Koenkk/zigbee2mqtt/issues/11126
                 // https://github.com/Koenkk/zigbee2mqtt/issues/12279
-            } else if (['WSDCGQ01LM', 'WSDCGQ11LM'].includes(model.model)) {
+            } else if (['WSDCGQ01LM', 'WSDCGQ11LM', 'WSDCGQ12LM'].includes(model.model)) {
                 // https://github.com/Koenkk/zigbee2mqtt/issues/798
                 // Sometimes the sensor publishes non-realistic vales, filter these
                 const temperature = parseFloat(value) / 100.0;
@@ -242,7 +244,7 @@ const numericAttributes2Payload = (msg, meta, model, options, dataObject) => {
                 payload[`state_${mapping}`] = value === 1 ? 'ON' : 'OFF';
             } else if (['RTCGQ12LM', 'RTCGQ14LM'].includes(model.model)) {
                 payload.illuminance = calibrateAndPrecisionRoundOptions(value, options, 'illuminance');
-            } else if (['WSDCGQ01LM', 'WSDCGQ11LM'].includes(model.model)) {
+            } else if (['WSDCGQ01LM', 'WSDCGQ11LM', 'WSDCGQ12LM'].includes(model.model)) {
                 // https://github.com/Koenkk/zigbee2mqtt/issues/798
                 // Sometimes the sensor publishes non-realistic vales, filter these
                 const humidity = parseFloat(value) / 100.0;
@@ -260,6 +262,9 @@ const numericAttributes2Payload = (msg, meta, model, options, dataObject) => {
                 payload.state_right = value === 1 ? 'ON' : 'OFF';
             } else if (['WSDCGQ01LM', 'WSDCGQ11LM'].includes(model.model)) {
                 payload.pressure = calibrateAndPrecisionRoundOptions(value/100.0, options, 'pressure');
+            } else if (['WSDCGQ12LM'].includes(model.model)) {
+                // This pressure value is ignored because it is less accurate than reported in the 'scaledValue' attribute
+                // of the 'msPressureMeasurement' cluster
             } else if (['RTCZCGQ11LM'].includes(model.model)) {
                 if (meta.device.applicationVersion < 50) {
                     payload.presence_event = {0: 'enter', 1: 'leave', 2: 'left_enter', 3: 'right_leave', 4: 'right_enter',

package/package.json

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