zigbee-herdsman-converters 14.0.383 → 14.0.387

package/converters/fromZigbee.js

@@ -5177,7 +5177,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 +5200,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';
@@ -7956,6 +7980,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

@@ -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) => {
@@ -6592,6 +6658,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/cleode.js

@@ -1,8 +1,7 @@
 const exposes = require('../lib/exposes');
-const fz = {...require('../converters/fromZigbee'), legacy: require('../lib/legacy').fromZigbee};
-const tz = require('../converters/toZigbee');
 const reporting = require('../lib/reporting');
 const e = exposes.presets;
+const extend = require('../lib/extend');
 
 module.exports = [
     {
@@ -10,9 +9,7 @@ module.exports = [
         model: 'ZPLUG_Boost',
         vendor: 'CLEODE',
         description: 'ZPlug boost',
-        meta: {multiEndpoint: true},
-        fromZigbee: [fz.on_off],
-        toZigbee: [tz.on_off],
+        extend: extend.switch(),
         exposes: [e.switch(), e.power()],
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);

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)',

package/devices/xiaomi.js

@@ -81,11 +81,11 @@ module.exports = [
         model: 'ZNLDP12LM',
         vendor: 'Xiaomi',
         description: 'Aqara smart LED bulb',
-        toZigbee: xiaomiExtend.light_onoff_brightness_colortemp().toZigbee.concat([
+        toZigbee: xiaomiExtend.light_onoff_brightness_colortemp({colorTempRange: [153, 370]}).toZigbee.concat([
             tz.xiaomi_light_power_outage_memory]),
-        fromZigbee: xiaomiExtend.light_onoff_brightness_colortemp().fromZigbee,
+        fromZigbee: xiaomiExtend.light_onoff_brightness_colortemp({colorTempRange: [153, 370]}).fromZigbee,
         // power_on_behavior 'toggle' does not seem to be supported
-        exposes: xiaomiExtend.light_onoff_brightness_colortemp().exposes.concat([
+        exposes: xiaomiExtend.light_onoff_brightness_colortemp({colorTempRange: [153, 370]}).exposes.concat([
             e.power_outage_memory().withAccess(ea.STATE_SET)]),
         ota: ota.zigbeeOTA,
     },
@@ -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/tuya.js

@@ -537,6 +537,20 @@ const dataPoints = {
     evanellLocalTemp: 5,
     evanellBattery: 6,
     evanellChildLock: 8,
+    // ZMAM02 Zemismart RF Courtain Converter
+    AM02Control: 1,
+    AM02PercentControl: 2,
+    AM02PercentState: 3,
+    AM02Mode: 4,
+    AM02ControlBackMode: 5,
+    AM02WorkState: 7,
+    AM02CountdownLeft: 9,
+    AM02TimeTotal: 10,
+    AM02SituationSet: 11,
+    AM02Fault: 12,
+    AM02Border: 16,
+    AM02MotorWorkingMode: 20,
+    AM02AddRemoter: 101,
 };
 
 const thermostatWeekFormat = {
@@ -650,6 +664,40 @@ const tvThermostatPreset = {
     1: 'manual',
     3: 'holiday',
 };
+// Zemismart ZM_AM02 Roller Shade Converter
+const ZMAM02 = {
+    AM02Mode: {
+        0: 'morning',
+        1: 'night',
+    },
+    AM02Control: {
+        0: 'open',
+        1: 'stop',
+        2: 'close',
+        3: 'continue',
+    },
+    AM02Direction: {
+        0: 'forward',
+        1: 'back',
+    },
+    AM02WorkState: {
+        0: 'opening',
+        1: 'closing',
+    },
+    AM02Border: {
+        0: 'up',
+        1: 'down',
+        2: 'down_delete',
+    },
+    AM02Situation: {
+        0: 'fully_open',
+        1: 'fully_close',
+    },
+    AM02MotorMode: {
+        0: 'continuous',
+        1: 'intermittently',
+    },
+};
 
 // Return `seq` - transaction ID for handling concrete response
 async function sendDataPoints(entity, dpValues, cmd, seq=undefined) {
@@ -800,4 +848,5 @@ module.exports = {
     tvThermostatMode,
     tvThermostatPreset,
     tuyaRadar,
+    ZMAM02,
 };