zigbee-herdsman-converters 14.0.465 → 14.0.468

package/converters/fromZigbee.js

@@ -3820,7 +3820,12 @@ const converters = {
                 return {deadzone_temperature: value};
             case tuya.dataPoints.moesLocalTemp:
                 temperature = value & 1<<15 ? value - (1<<16) + 1 : value;
-                return {local_temperature: parseFloat((temperature / 10).toFixed(1))};
+                if (meta.device.manufacturerName === '_TZE200_ye5jkfsb') {
+                    // https://github.com/Koenkk/zigbee2mqtt/issues/11980
+                    temperature = temperature / 10;
+                }
+
+                return {local_temperature: parseFloat(temperature.toFixed(1))};
             case tuya.dataPoints.moesTempCalibration:
                 temperature = value;
                 // for negative values produce complimentary hex (equivalent to negative values)
@@ -4193,6 +4198,7 @@ const converters = {
             const dpValue = tuya.firstDpValue(msg, meta, 'tuya_air_quality');
             const dp = dpValue.dp;
             const value = tuya.getDataValue(dpValue);
+            const swapPM25CO2 = ['_TZE200_ryfmq5rl', '_TZE200_dwcarsat'];
             switch (dp) {
             case tuya.dataPoints.tuyaSabTemp:
                 return {temperature: calibrateAndPrecisionRoundOptions(value / 10, options, 'temperature')};
@@ -4200,14 +4206,14 @@ const converters = {
                 return {humidity: calibrateAndPrecisionRoundOptions(value / 10, options, 'humidity')};
                 // DP22: Smart Air Box: Formaldehyd, Smart Air Housekeeper: co2
             case tuya.dataPoints.tuyaSabFormaldehyd:
-                if (meta.device.manufacturerName === '_TZE200_dwcarsat') {
+                if (swapPM25CO2.includes(meta.device.manufacturerName)) {
                     return {co2: calibrateAndPrecisionRoundOptions(value, options, 'co2')};
                 } else {
                     return {formaldehyd: calibrateAndPrecisionRoundOptions(value, options, 'formaldehyd')};
                 }
                 // DP2: Smart Air Box: co2, Smart Air Housekeeper: MP25
             case tuya.dataPoints.tuyaSabCO2:
-                if (meta.device.manufacturerName === '_TZE200_dwcarsat') {
+                if (swapPM25CO2.includes(meta.device.manufacturerName)) {
                     return {pm25: calibrateAndPrecisionRoundOptions(value, options, 'pm25')};
                 } else {
                     return {co2: calibrateAndPrecisionRoundOptions(value, options, 'co2')};
@@ -4580,10 +4586,33 @@ const converters = {
             } else if (meta.device.manufacturerName === '_TZE200_swaamsoy') {
                 // https://github.com/Koenkk/zigbee-herdsman-converters/pull/3004
                 if (dpValue.dp === 2) {
+                    if (value < 10) {
+                        tuya.logUnexpectedDataValue('tuya_dimmer', msg, dpValue, meta, 'brightness', 10, 1000);
+                    }
                     return {brightness: mapNumberRange(value, 10, 1000, 0, 254)};
                 }
-            } else { // TODO: Unknown dp, assumed value type
-                return {brightness: mapNumberRange(value, 10, 1000, 0, 254), level: value};
+            } else if (meta.device.manufacturerName === '_TZE200_3p5ydos3') {
+                if (dpValue.dp === tuya.dataPoints.eardaDimmerLevel) {
+                    return {brightness: mapNumberRange(value, 0, 1000, 0, 254)};
+                } else if (dpValue.dp === tuya.dataPoints.dimmerMinLevel) {
+                    return {min_brightness: mapNumberRange(value, 0, 1000, 1, 255)};
+                } else if (dpValue.dp === tuya.dataPoints.dimmerMaxLevel) {
+                    return {max_brightness: mapNumberRange(value, 0, 1000, 1, 255)};
+                } else {
+                    tuya.logUnexpectedDataPoint('tuya_dimmer', msg, dpValue, meta);
+                }
+            } else {
+                if (dpValue.dp !== tuya.dataPoints.dimmerLevel) {
+                    tuya.logUnexpectedDataPoint('tuya_dimmer', msg, dpValue, meta);
+                }
+                if (dpValue.datatype !== tuya.dataTypes.value) {
+                    tuya.logUnexpectedDataType('tuya_dimmer', msg, dpValue, meta);
+                } else {
+                    if (value < 10) {
+                        tuya.logUnexpectedDataValue('tuya_dimmer', msg, dpValue, meta, 'brightness', 10, 1000);
+                    }
+                    return {brightness: mapNumberRange(value, 10, 1000, 0, 254), level: value};
+                }
             }
         },
     },
@@ -4593,14 +4622,6 @@ 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) {
@@ -4611,11 +4632,7 @@ 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))}`);
-
+                tuya.logDataPoint('tuya_data_point_dump', msg, dpValue, meta);
                 dataStr +=
                     now + ' ' +
                     meta.device.ieeeAddr + ' ' +

package/converters/toZigbee.js

@@ -2584,14 +2584,14 @@ const converters = {
             await entity.write('ssIasZone', {0xFFF1: {value: 0x03010000, type: 0x23}}, options);
         },
     },
-    JTBZ01AQA_gas: {
-        key: ['gas'],
+    aqara_alarm: {
+        key: ['gas', 'smoke'],
         convertGet: async (entity, key, meta) => {
             await entity.read('aqaraOpple', [0x013a], manufacturerOptions.xiaomi);
         },
     },
-    JTBZ01AQA_gas_density: {
-        key: ['gas_density'],
+    aqara_density: {
+        key: ['gas_density', 'smoke_density'],
         convertGet: async (entity, key, meta) => {
             await entity.read('aqaraOpple', [0x013b], manufacturerOptions.xiaomi);
         },
@@ -2608,26 +2608,39 @@ const converters = {
             await entity.read('aqaraOpple', [0x010c], manufacturerOptions.xiaomi);
         },
     },
-    JTBZ01AQA_selftest: {
+    aqara_selftest: {
         key: ['selftest'],
         convertSet: async (entity, key, value, meta) => {
             await entity.write('aqaraOpple', {0x0127: {value: true, type: 0x10}}, manufacturerOptions.xiaomi);
         },
     },
-    JTBZ01AQA_mute_buzzer: {
+    aqara_mute_buzzer: {
         key: ['mute_buzzer'],
         convertSet: async (entity, key, value, meta) => {
-            await entity.write('aqaraOpple', {0x013f: {value: 15360, type: 0x23}}, manufacturerOptions.xiaomi);
+            let attribute = 0x013f;
+            if (['JY-GZ-01AQ'].includes(meta.mapped.model)) attribute = 0x013e;
+            await entity.write('aqaraOpple', {[`${attribute}`]: {value: 15360, type: 0x23}}, manufacturerOptions.xiaomi);
             await entity.write('aqaraOpple', {0x0126: {value: 1, type: 0x20}}, manufacturerOptions.xiaomi);
         },
     },
-    JTBZ01AQA_mute: {
+    aqara_mute: {
         key: ['mute'],
         convertGet: async (entity, key, meta) => {
             await entity.read('aqaraOpple', [0x0126], manufacturerOptions.xiaomi);
         },
     },
-    JTBZ01AQA_linkage_alarm: {
+    JYGZ01AQ_heartbeat_indicator: {
+        key: ['heartbeat_indicator'],
+        convertSet: async (entity, key, value, meta) => {
+            const lookup = {true: 1, false: 0};
+            await entity.write('aqaraOpple', {0x013c: {value: lookup[value], type: 0x20}}, manufacturerOptions.xiaomi);
+            return {state: {heartbeat_indicator: value}};
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read('aqaraOpple', [0x013c], manufacturerOptions.xiaomi);
+        },
+    },
+    aqara_linkage_alarm: {
         key: ['linkage_alarm'],
         convertSet: async (entity, key, value, meta) => {
             const lookup = {true: 1, false: 0};
@@ -3516,7 +3529,7 @@ const converters = {
         },
     },
     tuya_dimmer_level: {
-        key: ['brightness_min', 'brightness', 'brightness_percent', 'level'],
+        key: ['brightness_min', 'min_brightness', 'max_brightness', 'brightness', 'brightness_percent', 'level'],
         convertSet: async (entity, key, value, meta) => {
             // upscale to 1000
             let newValue;
@@ -3531,6 +3544,20 @@ const converters = {
                 } else {
                     throw new Error('Dimmer brightness_min is out of range 0..100');
                 }
+            } else if (key === 'min_brightness') {
+                if (value >= 1 && value <= 255) {
+                    newValue = utils.mapNumberRange(value, 1, 255, 0, 1000);
+                    dp = tuya.dataPoints.dimmerMinLevel;
+                } else {
+                    throw new Error('Dimmer min_brightness is out of range 1..255');
+                }
+            } else if (key === 'max_brightness') {
+                if (value >= 1 && value <= 255) {
+                    newValue = utils.mapNumberRange(value, 1, 255, 0, 1000);
+                    dp = tuya.dataPoints.dimmerMaxLevel;
+                } else {
+                    throw new Error('Dimmer min_brightness is out of range 1..255');
+                }
             } else if (key === 'level') {
                 if (value >= 0 && value <= 1000) {
                     newValue = Math.round(Number(value));
@@ -3543,11 +3570,11 @@ const converters = {
                 } else {
                     throw new Error('Dimmer brightness_percent is out of range 0..100');
                 }
-            } else {
-                if (value >= 0 && value <= 255) {
-                    newValue = utils.mapNumberRange(value, 0, 255, 0, 1000);
+            } else { // brightness
+                if (value >= 0 && value <= 254) {
+                    newValue = utils.mapNumberRange(value, 0, 254, 0, 1000);
                 } else {
-                    throw new Error('Dimmer brightness is out of range 0..255');
+                    throw new Error('Dimmer brightness is out of range 0..254');
                 }
             }
             // Always use same transid as tuya_dimmer_state (https://github.com/Koenkk/zigbee2mqtt/issues/6366)

package/devices/datek.js

@@ -41,39 +41,45 @@ module.exports = [
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
             await reporting.bind(endpoint, coordinatorEndpoint, ['haElectricalMeasurement', 'seMetering', 'msTemperatureMeasurement']);
-            await reporting.readEletricalMeasurementMultiplierDivisors(endpoint);
             await reporting.readMeteringMultiplierDivisor(endpoint);
+            try {
+                await reporting.readEletricalMeasurementMultiplierDivisors(endpoint);
+            } catch (error) {
+                /* fails for some: https://github.com/Koenkk/zigbee2mqtt/issues/11867 */
+            }
             const payload = [{
                 attribute: 'rmsVoltagePhB',
-                minimumReportInterval: 10,
+                minimumReportInterval: 60,
                 maximumReportInterval: 3600,
                 reportableChange: 0,
             },
             {
                 attribute: 'rmsVoltagePhC',
-                minimumReportInterval: 10,
+                minimumReportInterval: 60,
                 maximumReportInterval: 3600,
                 reportableChange: 0,
             },
             {
                 attribute: 'rmsCurrentPhB',
-                minimumReportInterval: 10,
+                minimumReportInterval: 60,
                 maximumReportInterval: 3600,
                 reportableChange: 0,
             },
             {
                 attribute: 'rmsCurrentPhC',
-                minimumReportInterval: 10,
+                minimumReportInterval: 60,
                 maximumReportInterval: 3600,
                 reportableChange: 0,
             }];
             await endpoint.configureReporting('haElectricalMeasurement', payload);
-            await reporting.rmsVoltage(endpoint, {min: 10, max: 3600, change: 0});
-            await reporting.rmsCurrent(endpoint, {min: 10, max: 3600, change: 0});
-            await reporting.instantaneousDemand(endpoint, {min: 10, max: 3600, change: 0});
-            await reporting.currentSummDelivered(endpoint, {min: 10, max: 3600, change: [1, 1]});
+            await reporting.rmsVoltage(endpoint, {min: 60, max: 3600, change: 0});
+            await reporting.rmsCurrent(endpoint, {min: 60, max: 3600, change: 0});
+            await reporting.instantaneousDemand(endpoint, {min: 60, max: 3600, change: 0});
+            await reporting.currentSummDelivered(endpoint, {min: 60, max: 3600, change: [1, 1]});
             await reporting.currentSummReceived(endpoint);
-            await reporting.temperature(endpoint);
+            await reporting.temperature(endpoint, {min: 60, max: 3600, change: 0});
+            device.powerSource = 'DC source';
+            device.save();
         },
         exposes: [e.power(), e.energy(), e.current(), e.voltage(), e.current_phase_b(), e.voltage_phase_b(), e.current_phase_c(),
             e.voltage_phase_c(), e.temperature()],

package/devices/legrand.js

@@ -341,4 +341,22 @@ module.exports = [
             return {left: 2, right: 1};
         },
     },
+    {
+        zigbeeModel: [' Mobile outlet\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000'+
+            '\u0000\u0000\u0000\u0000\u0000\u0000\u0000'],
+        model: 'WNRR15/WNRR20',
+        vendor: 'Legrand',
+        ota: ota.zigbeeOTA,
+        description: 'Outlet with power consumption monitoring',
+        fromZigbee: [fz.identify, fz.on_off, fz.electrical_measurement],
+        toZigbee: [tz.on_off, tz.legrand_settingAlwaysEnableLed, tz.legrand_identify],
+        exposes: [e.switch(), e.action(['identify']), e.power()],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genIdentify', 'genOnOff', 'haElectricalMeasurement']);
+            await reporting.onOff(endpoint);
+            await reporting.readEletricalMeasurementMultiplierDivisors(endpoint);
+            await reporting.activePower(endpoint);
+        },
+    },
 ];

package/devices/lidl.js

@@ -507,6 +507,17 @@ module.exports = [
             device.getEndpoint(1).saveClusterAttributeKeyValue('lightingColorCtrl', {colorCapabilities: 29});
         },
     },
+    {
+        fingerprint: [{modelID: 'TS0505B', manufacturerName: '_TZ3210_z1vlyufu'}],
+        model: '14158704L',
+        vendor: 'Lidl',
+        description: 'Livarno Home LED floor lamp, RGBW',
+        ...extend.light_onoff_brightness_colortemp_color({disableColorTempStartup: true, colorTempRange: [153, 500]}),
+        meta: {applyRedFix: true, enhancedHue: false},
+        configure: async (device, coordinatorEndpoint, logger) => {
+            device.getEndpoint(1).saveClusterAttributeKeyValue('lightingColorCtrl', {colorCapabilities: 29});
+        },
+    },
     {
         fingerprint: [{modelID: 'TS0505B', manufacturerName: '_TZ3000_quqaeew6'}],
         model: 'HG07834A',

package/devices/moes.js

@@ -99,6 +99,7 @@ module.exports = [
     {
         fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_aoclfnxz'},
             {modelID: 'TS0601', manufacturerName: '_TZE200_ztvwu4nk'},
+            {modelID: 'TS0601', manufacturerName: '_TZE200_ye5jkfsb'},
             {modelID: 'TS0601', manufacturerName: '_TZE200_u9bfwha0'}],
         model: 'BHT-002-GCLZB',
         vendor: 'Moes',

package/devices/niko.js

@@ -5,6 +5,60 @@ const reporting = require('../lib/reporting');
 const e = exposes.presets;
 const ea = exposes.access;
 
+const fzLocal = {
+    fz: {
+        switch_operation_mode: {
+            cluster: 'manuSpecificNikoSwitchSetup',
+            type: ['attributeReport', 'readResponse'],
+            convert: (model, msg, publish, options, meta) => {
+                const state = {};
+                if (msg.data.hasOwnProperty('operationMode')) {
+                    const operationModeProperty = `operation_mode${meta.endpoint_name ? `_${meta.endpoint_name}` : ''}`;
+                    const operationModeMap = {0x02: 'control_relay', 0x01: 'decoupled', 0x00: 'unknown'};
+                    state[operationModeProperty] = operationModeMap[msg.data.operationMode];
+                }
+                return state;
+            },
+        },
+        switch_action: {
+            cluster: 'manuSpecificNikoSwitch',
+            type: ['attributeReport', 'readResponse'],
+            convert: (model, msg, publish, options, meta) => {
+                const state = {};
+
+                if (msg.data.hasOwnProperty('action')) {
+                    // NOTE: a single press = two seperate values reported, 16 followed by 64
+                    //       a hold/release cyle = three seperate values, 16, 32, and 48
+                    const actionProperty = `action${meta.endpoint_name ? `_${meta.endpoint_name}` : ''}`;
+                    const actionMap = {16: null, 64: 'single', 32: 'hold', 48: 'release'};
+                    state[actionProperty] = actionMap[msg.data.action];
+                }
+                return state;
+            },
+        },
+    },
+    tz: {
+        switch_operation_mode: {
+            key: ['operation_mode'],
+            convertSet: async (entity, key, value, meta) => {
+                // WARN: while we can technically write 0x00 to the operationMode attribute
+                //       this seems to brick the device and it will need to be rejoined
+                const operationModeLookup = {control_relay: 0x02, decoupled: 0x01};
+                if (!operationModeLookup.hasOwnProperty(value)) {
+                    throw new Error(`operation_mode was called with an invalid value (${value})`);
+                } else {
+                    const operationModeProperty = `operation_mode${meta.endpoint_name ? `_${meta.endpoint_name}` : ''}`;
+                    await entity.write('manuSpecificNikoSwitchSetup', {'operationMode': operationModeLookup[value]});
+                    return {state: {[operationModeProperty]: value.toLowerCase()}};
+                }
+            },
+            convertGet: async (entity, key, meta) => {
+                await entity.read('manuSpecificNikoSwitchSetup', ['operationMode']);
+            },
+        },
+    },
+};
+
 module.exports = [
     {
         zigbeeModel: ['Connected socket outlet'],
@@ -80,15 +134,18 @@ module.exports = [
         model: '552-721X1',
         vendor: 'Niko',
         description: 'Single connectable switch',
-        fromZigbee: [fz.on_off],
-        toZigbee: [tz.on_off],
+        fromZigbee: [fz.on_off, fzLocal.fz.switch_operation_mode, fzLocal.fz.switch_action],
+        toZigbee: [tz.on_off, fzLocal.tz.switch_operation_mode],
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
             await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff']);
             await reporting.onOff(endpoint);
+            await endpoint.read('manuSpecificNikoSwitchSetup', ['operationMode']);
         },
         exposes: [
             e.switch(),
+            e.action(['single', 'hold', 'release']),
+            exposes.enum('operation_mode', ea.ALL, ['control_relay', 'decoupled']),
         ],
     },
     {
@@ -96,8 +153,8 @@ module.exports = [
         model: '552-721X2',
         vendor: 'Niko',
         description: 'Double connectable switch',
-        fromZigbee: [fz.on_off],
-        toZigbee: [tz.on_off],
+        fromZigbee: [fz.on_off, fzLocal.fz.switch_operation_mode, fzLocal.fz.switch_action],
+        toZigbee: [tz.on_off, fzLocal.tz.switch_operation_mode],
         endpoint: (device) => {
             return {'l1': 1, 'l2': 2};
         },
@@ -109,9 +166,15 @@ module.exports = [
             await reporting.bind(ep2, coordinatorEndpoint, ['genOnOff']);
             await reporting.onOff(ep1);
             await reporting.onOff(ep2);
+            await ep1.read('manuSpecificNikoSwitchSetup', ['operationMode']);
+            await ep2.read('manuSpecificNikoSwitchSetup', ['operationMode']);
         },
         exposes: [
             e.switch().withEndpoint('l1'), e.switch().withEndpoint('l2'),
+            e.action(['single', 'hold', 'release']).withEndpoint('l1'),
+            e.action(['single', 'hold', 'release']).withEndpoint('l2'),
+            exposes.enum('operation_mode', ea.ALL, ['control_relay', 'decoupled']).withEndpoint('l1'),
+            exposes.enum('operation_mode', ea.ALL, ['control_relay', 'decoupled']).withEndpoint('l2'),
         ],
     },
 ];

package/devices/orvibo.js

@@ -10,7 +10,7 @@ module.exports = [
         zigbeeModel: ['ORVIBO Socket'],
         model: 'OR-ZB-S010-3C',
         vendor: 'ORVIBO',
-        description: 'Smart Socket',
+        description: 'Smart socket',
         extend: extend.switch(),
     },
     {

package/devices/paul_neuhaus.js

@@ -43,7 +43,7 @@ module.exports = [
     },
     {
         zigbeeModel: ['NLG-RGBW light'],
-        model: 'NLG-RGBW light',
+        model: 'NLG-RGBW__light',
         vendor: 'Paul Neuhaus',
         description: 'Various RGBW lights (e.g. 100.111.57)',
         extend: extend.light_onoff_brightness_colortemp_color(),

package/devices/philips.js

@@ -2714,6 +2714,15 @@ module.exports = [
         meta: {turnsOffAtBrightness1: true},
         ota: ota.zigbeeOTA,
     },
+    {
+        zigbeeModel: ['5060930P7_01', '5060930P7_02', '5060930P7_03', '5060930P7_04'],
+        model: '5060930P7',
+        vendor: 'Philips',
+        description: 'Hue White & Color Ambiance Centris ceiling light (3 spots)',
+        extend: hueExtend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 500]}),
+        meta: {turnsOffAtBrightness1: true},
+        ota: ota.zigbeeOTA,
+    },
     {
         zigbeeModel: ['5060931P7_01', '5060931P7_02', '5060931P7_03', '5060931P7_04'],
         model: '5060931P7',

package/devices/spotmau.js

@@ -10,6 +10,9 @@ module.exports = [
         vendor: 'Spotmau',
         description: 'Smart wall switch - 1 gang',
         extend: extend.switch(),
+        endpoint: (device) => {
+            return {default: 16};
+        },
         configure: async (device, coordinatorEndpoint, logger) => {
             await reporting.bind(device.getEndpoint(16), coordinatorEndpoint, ['genOnOff', 'genBasic']);
         },

package/devices/tuya.js

@@ -450,7 +450,9 @@ module.exports = [
             const endpoint = device.getEndpoint(1);
             await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'genLevelCtrl']);
         },
-        exposes: [e.light_brightness().setAccess('state', ea.STATE_SET).setAccess('brightness', ea.STATE_SET)],
+        exposes: [e.light_brightness().withMinBrightness().withMaxBrightness().setAccess(
+            'state', ea.STATE_SET).setAccess('brightness', ea.STATE_SET).setAccess(
+            'min_brightness', ea.STATE_SET).setAccess('max_brightness', ea.STATE_SET)],
         whiteLabel: [
             {vendor: 'Larkkey', model: 'ZSTY-SM-1DMZG-EU'},
             {vendor: 'Earda', model: 'EDM-1ZAA-EU'},
@@ -703,10 +705,7 @@ module.exports = [
         extend: extend.light_onoff_brightness_colortemp_color(),
     },
     {
-        fingerprint: [
-            {type: 'EndDevice', manufacturerID: 4098, endpoints: [{ID: 1, inputClusters: [], outputClusters: []}]},
-            {manufacturerName: '_TZ2000_a476raq2'},
-        ],
+        fingerprint: [{manufacturerName: '_TZ2000_a476raq2'}],
         zigbeeModel: ['TS0201', 'SNTZ003'],
         model: 'TS0201',
         vendor: 'TuYa',
@@ -715,6 +714,10 @@ module.exports = [
         fromZigbee: [fzLocal.TS0201_battery, fz.temperature, fz.humidity],
         toZigbee: [],
         exposes: [e.battery(), e.temperature(), e.humidity(), e.battery_voltage()],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await endpoint.read('genBasic', ['manufacturerName', 'zclVersion', 'appVersion', 'modelId', 'powerSource', 0xfffe]);
+        },
     },
     {
         fingerprint: [{modelID: 'TS0201', manufacturerName: '_TZ3000_bguser20'}],
@@ -1045,6 +1048,7 @@ module.exports = [
             {modelID: 'TS0601', manufacturerName: '_TZE200_3i3exuay'},
             {modelID: 'TS0601', manufacturerName: '_TZE200_tvrvdj6o'},
             {modelID: 'zo2pocs\u0000', manufacturerName: '_TYST11_fzo2pocs'},
+            {modelID: 'TS0601', manufacturerName: '_TZE200_cf1sl3tj'},
             // Roller blinds:
             {modelID: 'TS0601', manufacturerName: '_TZE200_sbordckq'},
             {modelID: 'TS0601', manufacturerName: '_TZE200_fctwhugx'},
@@ -1073,6 +1077,7 @@ module.exports = [
             {vendor: 'TuYa', model: 'ZD82TN', description: 'Curtain motor'},
             {vendor: 'Moes', model: 'AM43-0.45/40-ES-EB'},
             {vendor: 'Larkkey', model: 'ZSTY-SM-1SRZG-EU'},
+            {vendor: 'Zemismart', model: 'ZM85EL-2Z', description: 'Roman Rod I type curtains track'},
             {vendor: 'Zemismart', model: 'ZM25TQ', description: 'Tubular motor'},
             {vendor: 'Zemismart', model: 'AM43', description: 'Roller blind motor'},
             {vendor: 'Zemismart', model: 'M2805EGBZTN', description: 'Tubular motor'},
@@ -1100,6 +1105,7 @@ module.exports = [
             {modelID: 'TS0601', manufacturerName: '_TZE200_9sfg7gm0'}, // HomeCloud
             {modelID: 'TS0601', manufacturerName: '_TZE200_2atgpdho'}, // HY367
             {modelID: 'TS0601', manufacturerName: '_TZE200_cpmgn2cf'},
+            {modelID: 'TS0601', manufacturerName: '_TZE200_4eeyebrt'}, // Immax 07732B
         ],
         model: 'TS0601_thermostat',
         vendor: 'TuYa',
@@ -1109,6 +1115,7 @@ module.exports = [
             {vendor: 'Moes', model: 'HY369RT'},
             {vendor: 'SHOJZJ', model: '378RT'},
             {vendor: 'Silvercrest', model: 'TVR01'},
+            {vendor: 'Immax', model: '07732B'},
         ],
         meta: {tuyaThermostatPreset: tuya.thermostatPresets, tuyaThermostatSystemMode: tuya.thermostatSystemModes3},
         ota: ota.zigbeeOTA,
@@ -1702,7 +1709,7 @@ module.exports = [
         },
     },
     {
-        zigbeeModel: ['HY0017', '005f0c3'],
+        zigbeeModel: ['HY0017', '005f0c3b'],
         model: 'U86KCJ-ZP',
         vendor: 'TuYa',
         description: 'Smart 6 key scene wall switch',
@@ -2176,7 +2183,8 @@ module.exports = [
         exposes: [e.illuminance_lux(), e.brightness_state()],
     },
     {
-        fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_kltffuzl'}, {modelID: 'TS0601', manufacturerName: '_TZE200_fwoorn8y'}],
+        fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_kltffuzl'}, {modelID: 'TS0601', manufacturerName: '_TZE200_fwoorn8y'},
+            {modelID: 'TS0601', manufacturerName: '_TZE200_pay2byax'}],
         model: 'TM001-ZA/TM081',
         vendor: 'TuYa',
         description: 'Door and window sensor',

package/devices/xiaomi.js

@@ -1170,9 +1170,9 @@ module.exports = [
         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), e.power_outage_count().withAccess(ea.STATE_GET),
+        toZigbee: [tz.aqara_alarm, tz.aqara_density, tz.JTBZ01AQA_gas_sensitivity, tz.aqara_selftest, tz.aqara_mute_buzzer,
+            tz.aqara_mute, tz.aqara_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")'),
@@ -1186,7 +1186,7 @@ module.exports = [
                 'is detected, other detectors with this option enabled will also sound the alarm buzzer'),
             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)'),
-        ],
+            e.power_outage_count().withAccess(ea.STATE_GET)],
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
             await endpoint.read('aqaraOpple', [0x013a], {manufacturerCode: 0x115f});
@@ -1199,6 +1199,40 @@ module.exports = [
         },
         ota: ota.zigbeeOTA,
     },
+    {
+        zigbeeModel: ['lumi.sensor_smoke.acn03'],
+        model: 'JY-GZ-01AQ',
+        vendor: 'Xiaomi',
+        description: 'Aqara smart smoke detector',
+        fromZigbee: [fz.aqara_opple, fz.battery],
+        toZigbee: [tz.aqara_alarm, tz.aqara_density, tz.aqara_selftest, tz.aqara_mute_buzzer, tz.aqara_mute,
+            tz.JYGZ01AQ_heartbeat_indicator, tz.aqara_linkage_alarm],
+        exposes: [e.smoke().withAccess(ea.STATE_GET),
+            exposes.numeric('smoke_density', ea.STATE_GET).withDescription('Value of smoke concentration'),
+            exposes.numeric('smoke_density_dbm', ea.STATE).withUnit('dB/m').withDescription('Value of smoke concentration in dB/m'),
+            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 80 seconds (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.binary('heartbeat_indicator', ea.ALL, true, false).withDescription('When this option is enabled then in ' +
+                'the normal monitoring state, the green indicator light flashes every 60 seconds'),
+            exposes.binary('linkage_alarm', ea.ALL, true, false).withDescription('When this option is enabled and a smoke ' +
+                'is detected, other detectors with this option enabled will also sound the alarm buzzer'),
+            e.temperature(), e.battery()],
+        meta: {battery: {voltageToPercentage: '3V_2850_3000_log'}},
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await endpoint.read('genPowerCfg', ['batteryVoltage']);
+            await endpoint.read('aqaraOpple', [0x013a], {manufacturerCode: 0x115f});
+            await endpoint.read('aqaraOpple', [0x013b], {manufacturerCode: 0x115f});
+            await endpoint.read('aqaraOpple', [0x013c], {manufacturerCode: 0x115f});
+            await endpoint.read('aqaraOpple', [0x0126], {manufacturerCode: 0x115f});
+            await endpoint.read('aqaraOpple', [0x014b], {manufacturerCode: 0x115f});
+        },
+        ota: ota.zigbeeOTA,
+    },
     {
         zigbeeModel: ['lumi.lock.v1'],
         model: 'A6121',

package/lib/exposes.js

@@ -218,6 +218,12 @@ class Light extends Base {
         return this;
     }
 
+    withMaxBrightness() {
+        assert(!this.endpoint, 'Cannot add feature after adding endpoint');
+        this.features.push(new Numeric('max_brightness', access.ALL).withValueMin(1).withValueMax(255).withDescription('Maximum light brightness'));
+        return this;
+    }
+
     withLevelConfig() {
         assert(!this.endpoint, 'Cannot add feature after adding endpoint');
         const levelConfig = new Composite('level_config', 'level_config')

package/lib/tuya.js

@@ -58,6 +58,61 @@ function getDataValue(dpValue) {
     }
 }
 
+function getTypeName(dpValue) {
+    const entry = Object.entries(dataTypes).find(([typeName, typeId]) => typeId === dpValue.datatype);
+    return (entry ? entry[0] : 'unknown');
+}
+
+function getDataPointNames(dpValue) {
+    const entries = Object.entries(dataPoints).filter(([dpName, dpId]) => dpId === dpValue.dp);
+    return entries.map(([dpName, dpId]) => dpName);
+}
+
+function logDataPoint(where, msg, dpValue, meta) {
+    meta.logger.info(`zigbee-herdsman-converters:${where}: Received Tuya DataPoint #${
+        dpValue.dp} from ${meta.device.ieeeAddr} with raw data '${JSON.stringify(dpValue)}': type='${
+        msg.type}', datatype='${getTypeName(dpValue)}', value='${
+        getDataValue(dpValue)}', known DP# usage: ${JSON.stringify(getDataPointNames(dpValue))}`);
+}
+
+function logUnexpectedDataPoint(where, msg, dpValue, meta) {
+    meta.logger.warn(`zigbee-herdsman-converters:${where}: Received unexpected Tuya DataPoint #${
+        dpValue.dp} from ${meta.device.ieeeAddr} with raw data '${JSON.stringify(dpValue)}': type='${
+        msg.type}', datatype='${getTypeName(dpValue)}', value='${
+        getDataValue(dpValue)}', known DP# usage: ${JSON.stringify(getDataPointNames(dpValue))}`);
+}
+
+function logUnexpectedDataType(where, msg, dpValue, meta, expectedDataType) {
+    meta.logger.warn(`zigbee-herdsman-converters:${where}: Received Tuya DataPoint #${
+        dpValue.dp} with unexpected datatype from ${meta.device.ieeeAddr} with raw data '${
+        JSON.stringify(dpValue)}': type='${msg.type}', datatype='${
+        getTypeName(dpValue)}' (instead of '${expectedDataType}'), value='${
+        getDataValue(dpValue)}', known DP# usage: ${JSON.stringify(getDataPointNames(dpValue))}`);
+}
+
+function logUnexpectedDataValue(where, msg, dpValue, meta, valueKind, expectedMinValue=null, expectedMaxValue=null) {
+    if (expectedMinValue === null) {
+        if (expectedMaxValue === null) {
+            meta.logger.warn(`zigbee-herdsman-converters:${where}: Received Tuya DataPoint #${dpValue.dp
+            } with invalid value ${getDataValue(dpValue)} for ${valueKind} from ${meta.device.ieeeAddr}`);
+        } else {
+            meta.logger.warn(`zigbee-herdsman-converters:${where}: Received Tuya DataPoint #${dpValue.dp
+            } with invalid value ${getDataValue(dpValue)} for ${valueKind} from ${meta.device.ieeeAddr
+            } which is higher than the expected maximum of ${expectedMaxValue}`);
+        }
+    } else {
+        if (expectedMaxValue === null) {
+            meta.logger.warn(`zigbee-herdsman-converters:${where}: Received Tuya DataPoint #${dpValue.dp
+            } with invalid value ${getDataValue(dpValue)} for ${valueKind} from ${meta.device.ieeeAddr
+            } which is lower than the expected minimum of ${expectedMinValue}`);
+        } else {
+            meta.logger.warn(`zigbee-herdsman-converters:${where}: Received Tuya DataPoint #${dpValue.dp
+            } with invalid value ${getDataValue(dpValue)} for ${valueKind} from ${meta.device.ieeeAddr
+            } which is outside the expected range from ${expectedMinValue} to ${expectedMaxValue}`);
+        }
+    }
+}
+
 function convertDecimalValueTo4ByteHexArray(value) {
     const hexValue = Number(value).toString(16).padStart(8, '0');
     const chunk1 = hexValue.substr(0, 2);
@@ -229,11 +284,13 @@ const dataPoints = {
     heatingSetpoint: 2,
     coverPosition: 2,
     dimmerLevel: 3,
+    dimmerMinLevel: 3,
     localTemp: 3,
     coverArrived: 3,
     occupancy: 3,
     mode: 4,
     fanMode: 5,
+    dimmerMaxLevel: 5,
     motorDirection: 5,
     config: 5,
     childLock: 7,
@@ -873,6 +930,12 @@ module.exports = {
     sendDataPointStringBuffer,
     firstDpValue,
     getDataValue,
+    getTypeName,
+    getDataPointNames,
+    logDataPoint,
+    logUnexpectedDataPoint,
+    logUnexpectedDataType,
+    logUnexpectedDataValue,
     dataTypes,
     dataPoints,
     dpValueFromIntValue,

package/lib/xiaomi.js

@@ -174,9 +174,11 @@ const numericAttributes2Payload = (msg, meta, model, options, dataObject) => {
             payload.switch_type = {1: 'toggle', 2: 'momentary'}[value];
             break;
         case '11':
-            payload.illuminance = calibrateAndPrecisionRoundOptions(value, options, 'illuminance');
-            // DEPRECATED: remove illuminance_lux here.
-            payload.illuminance_lux = calibrateAndPrecisionRoundOptions(value, options, 'illuminance_lux');
+            if (!['JT-BZ-01AQ/A'].includes(model.model)) {
+                payload.illuminance = calibrateAndPrecisionRoundOptions(value, options, 'illuminance');
+                // DEPRECATED: remove illuminance_lux here.
+                payload.illuminance_lux = calibrateAndPrecisionRoundOptions(value, options, 'illuminance_lux');
+            }
             break;
         case '100':
             if (['QBKG20LM', 'QBKG31LM', 'QBKG39LM', 'QBKG41LM', 'QBCZ15LM', 'LLKZMK11LM', 'QBKG12LM', 'QBKG03LM'].includes(model.model)) {
@@ -300,25 +302,52 @@ const numericAttributes2Payload = (msg, meta, model, options, dataObject) => {
             }
             break;
         case '159':
-            payload.gas_sensitivity = {1: '15%LEL', 2: '10%LEL'}[value]; // JT-BZ-01AQ/A
+            if (['JT-BZ-01AQ/A'].includes(model.model)) {
+                payload.gas_sensitivity = {1: '15%LEL', 2: '10%LEL'}[value];
+            }
             break;
         case '160':
-            payload.gas = value === 1; // JT-BZ-01AQ/A
+            if (['JT-BZ-01AQ/A'].includes(model.model)) {
+                payload.gas = value === 1;
+            } else if (['JY-GZ-01AQ'].includes(model.model)) {
+                payload.smoke = value === 1;
+            }
             break;
         case '161':
-            payload.gas_density = value; // JT-BZ-01AQ/A
+            if (['JT-BZ-01AQ/A'].includes(model.model)) {
+                payload.gas_density = value;
+            } else if (['JY-GZ-01AQ'].includes(model.model)) {
+                payload.smoke_density = value;
+                payload.smoke_density_dbm = {0: 0, 1: 0.085, 2: 0.088, 3: 0.093, 4: 0.095, 5: 0.100, 6: 0.105, 7: 0.110,
+                    8: 0.115, 9: 0.120, 10: 0.125}[value];
+            }
             break;
         case '162':
-            payload.test = value === 1; // JT-BZ-01AQ/A
+            if (['JT-BZ-01AQ/A', 'JY-GZ-01AQ'].includes(model.model)) {
+                payload.test = value === 1;
+            }
             break;
         case '163':
-            payload.mute = value === 1; // JT-BZ-01AQ/A
+            if (['JT-BZ-01AQ/A', 'JY-GZ-01AQ'].includes(model.model)) {
+                payload.mute = value === 1;
+            }
             break;
         case '164':
-            payload.state = value === 1 ? 'preparation' : 'work'; // JT-BZ-01AQ/A
+            if (['JT-BZ-01AQ/A'].includes(model.model)) {
+                payload.state = {0: 'work', 1: 'preparation'}[value];
+            } else if (['JY-GZ-01AQ'].includes(model.model)) {
+                payload.heartbeat_indicator = value === 1;
+            }
+            break;
+        case '165':
+            if (['JY-GZ-01AQ'].includes(model.model)) {
+                payload.linkage_alarm = value === 1;
+            }
             break;
         case '166':
-            payload.linkage_alarm = value === 1; // JT-BZ-01AQ/A
+            if (['JT-BZ-01AQ/A'].includes(model.model)) {
+                payload.linkage_alarm = value === 1;
+            }
             break;
         case '240':
             payload.flip_indicator_light = value === 1 ? 'ON' : 'OFF';
@@ -344,19 +373,40 @@ const numericAttributes2Payload = (msg, meta, model, options, dataObject) => {
             payload.click_mode = {1: 'fast', 2: 'multi'}[value];
             break;
         case '294':
-            payload.mute = value === 1; // JT-BZ-01AQ/A
+            if (['JT-BZ-01AQ/A', 'JY-GZ-01AQ'].includes(model.model)) {
+                payload.mute = value === 1;
+            }
             break;
         case '295':
-            payload.test = value === 1; // JT-BZ-01AQ/A
+            if (['JT-BZ-01AQ/A', 'JY-GZ-01AQ'].includes(model.model)) {
+                payload.test = value === 1;
+            }
             break;
         case '313':
-            payload.state = value === 1 ? 'preparation' : 'work'; // JT-BZ-01AQ/A
+            if (['JT-BZ-01AQ/A'].includes(model.model)) {
+                payload.state = {0: 'work', 1: 'preparation'}[value];
+            }
             break;
         case '314':
-            payload.gas = value === 1; // JT-BZ-01AQ/A
+            if (['JT-BZ-01AQ/A'].includes(model.model)) {
+                payload.gas = value === 1;
+            } else if (['JY-GZ-01AQ'].includes(model.model)) {
+                payload.smoke = value === 1;
+            }
             break;
         case '315':
-            payload.gas_density = value; // JT-BZ-01AQ/A
+            if (['JT-BZ-01AQ/A'].includes(model.model)) {
+                payload.gas_density = value;
+            } else if (['JY-GZ-01AQ'].includes(model.model)) {
+                payload.smoke_density = value;
+                payload.smoke_density_dbm = {0: 0, 1: 0.085, 2: 0.088, 3: 0.093, 4: 0.095, 5: 0.100, 6: 0.105, 7: 0.110,
+                    8: 0.115, 9: 0.120, 10: 0.125}[value];
+            }
+            break;
+        case '316':
+            if (['JY-GZ-01AQ'].includes(model.model)) {
+                payload.heartbeat_indicator = value === 1;
+            }
             break;
         case '322':
             if (['RTCZCGQ11LM'].includes(model.model)) {
@@ -380,7 +430,9 @@ const numericAttributes2Payload = (msg, meta, model, options, dataObject) => {
             }
             break;
         case '331':
-            payload.linkage_alarm = value === 1; // JT-BZ-01AQ/A
+            if (['JT-BZ-01AQ/A', 'JY-GZ-01AQ'].includes(model.model)) {
+                payload.linkage_alarm = value === 1;
+            }
             break;
         case '512':
             if (['ZNCZ15LM', 'QBCZ14LM', 'QBCZ15LM'].includes(model.model)) {

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "zigbee-herdsman-converters",
-  "version": "14.0.465",
+  "version": "14.0.468",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "zigbee-herdsman-converters",
-      "version": "14.0.465",
+      "version": "14.0.468",
       "license": "MIT",
       "dependencies": {
         "axios": "^0.26.1",

package/package.json

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