zigbee-herdsman-converters 14.0.495 → 14.0.498

package/converters/fromZigbee.js

@@ -1652,6 +1652,77 @@ const converters = {
     // #endregion
 
     // #region Non-generic converters
+    namron_thermostat: {
+        cluster: 'hvacThermostat',
+        type: ['attributeReport', 'readResponse'],
+        convert: (model, msg, publish, options, meta) => {
+            const result = {};
+            const data = msg.data;
+            if (data.hasOwnProperty(0x1000)) { // Display brightness
+                const lookup = {0: 'low', 1: 'mid', 2: 'high'};
+                result.lcd_brightness = lookup[data[0x1000]];
+            }
+            if (data.hasOwnProperty(0x1001)) { // Button vibration level
+                const lookup = {0: 'off', 1: 'low', 2: 'high'};
+                result.button_vibration_level = lookup[data[0x1001]];
+            }
+            if (data.hasOwnProperty(0x1002)) { // Floor sensor type
+                const lookup = {1: '10k', 2: '15k', 3: '50k', 4: '100k', 5: '12k'};
+                result.floor_sensor_type = lookup[data[0x1002]];
+            }
+            if (data.hasOwnProperty(0x1003)) { // Sensor
+                const lookup = {0: 'air', 1: 'floor', 2: 'both'};
+                result.sensor = lookup[data[0x1003]];
+            }
+            if (data.hasOwnProperty(0x1004)) { // PowerUpStatus
+                const lookup = {0: 'default', 1: 'last_status'};
+                result.powerup_status = lookup[data[0x1004]];
+            }
+            if (data.hasOwnProperty(0x1005)) { // FloorSensorCalibration
+                result.floor_sensor_calibration = precisionRound(data[0x1005], 2) / 10;
+            }
+            if (data.hasOwnProperty(0x1006)) { // DryTime
+                result.dry_time = data[0x1006];
+            }
+            if (data.hasOwnProperty(0x1007)) { // ModeAfterDry
+                const lookup = {0: 'off', 1: 'manual', 2: 'auto', 3: 'away'};
+                result.mode_after_dry = lookup[data[0x1007]];
+            }
+            if (data.hasOwnProperty(0x1008)) { // TemperatureDisplay
+                const lookup = {0: 'room', 1: 'floor'};
+                result.temperature_display = lookup[data[0x1008]];
+            }
+            if (data.hasOwnProperty(0x1009)) { // WindowOpenCheck
+                result.window_open_check = data[0x1009];
+            }
+            if (data.hasOwnProperty(0x100A)) { // Hysterersis
+                result.hysterersis = data[0x100A];
+            }
+            if (data.hasOwnProperty(0x100B)) { // DisplayAutoOffEnable
+                const lookup = {0: 'enable', 1: 'disable'};
+                result.display_auto_off_enabled = lookup[data[0x100B]];
+            }
+            if (data.hasOwnProperty(0x2001)) { // AlarmAirTempOverValue
+                result.alarm_airtemp_overvalue = data[0x2001];
+            }
+            if (data.hasOwnProperty(0x2002)) { // Away Mode Set
+                result.away_mode = data[0x2002] ? 'ON' : 'OFF';
+            }
+
+            return result;
+        },
+    },
+    namron_hvac_user_interface: {
+        cluster: 'hvacUserInterfaceCfg',
+        type: ['attributeReport', 'readResponse'],
+        convert: (model, msg, publish, options, meta) => {
+            const result = {};
+            if (msg.data.hasOwnProperty('keypadLockout')) { // Set as child lock instead as keypadlockout
+                result.child_lock = msg.data['keypadLockout'] === 0 ? 'UNLOCK' : 'LOCK';
+            }
+            return result;
+        },
+    },
     elko_thermostat: {
         cluster: 'hvacThermostat',
         type: ['attributeReport', 'readResponse'],
@@ -4223,7 +4294,6 @@ 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')};
@@ -4231,15 +4301,17 @@ const converters = {
                 return {humidity: calibrateAndPrecisionRoundOptions(value / 10, options, 'humidity')};
                 // DP22: Smart Air Box: Formaldehyd, Smart Air Housekeeper: co2
             case tuya.dataPoints.tuyaSabFormaldehyd:
-                if (swapPM25CO2.includes(meta.device.manufacturerName)) {
+                if (['_TZE200_dwcarsat', '_TZE200_ryfmq5rl'].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 (swapPM25CO2.includes(meta.device.manufacturerName)) {
+                if (meta.device.manufacturerName === '_TZE200_dwcarsat') {
                     return {pm25: calibrateAndPrecisionRoundOptions(value, options, 'pm25')};
+                } else if (meta.device.manufacturerName === '_TZE200_ryfmq5rl') {
+                    return {formaldehyd: calibrateAndPrecisionRoundOptions(value, options, 'formaldehyd')};
                 } else {
                     return {co2: calibrateAndPrecisionRoundOptions(value, options, 'co2')};
                 }
@@ -4692,7 +4764,7 @@ const converters = {
     },
     tuya_data_point_dump: {
         cluster: 'manuSpecificTuya',
-        type: ['commandDataResponse', 'commandDataReport', 'commandActiveStatusReport'],
+        type: ['commandDataResponse', 'commandDataReport', 'commandActiveStatusReport', 'commandActiveStatusReportAlt'],
         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
@@ -7255,22 +7327,34 @@ const converters = {
     },
     ZB006X_settings: {
         cluster: 'manuSpecificTuya',
-        type: ['commandDataResponse'],
+        type: ['commandActiveStatusReport', 'commandActiveStatusReportAlt'],
         convert: (model, msg, publish, options, meta) => {
             const dpValue = tuya.firstDpValue(msg, meta, 'ZB006X_settings');
             const dp = dpValue.dp;
             const value = tuya.getDataValue(dpValue);
-            if (dp === 103) {
-                meta.logger.debug(`fromZigbee.ZB006X_settings: Found DP #${dp} with data ${JSON.stringify(dpValue)}`);
-                return {ext_switch_type: {0: 'unknown', 1: 'toggle_sw', 2: 'momentary_sw', 3: 'rotary_sw', 4: 'auto_config'}[value]};
-            } else if (dp === 105) {
-                meta.logger.debug(`fromZigbee.ZB006X_settings: Found DP #${dp} with data ${JSON.stringify(dpValue)}`);
+            switch (dp) {
+            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]};
+            case tuya.dataPoints.fantemLoadDetectionMode:
                 return {load_detection_mode: {0: 'none', 1: 'first_power_on', 2: 'every_power_on'}[value]};
-            } else if (dp === 109) {
-                meta.logger.debug(`fromZigbee.ZB006X_settings: Found DP #${dp} with data ${JSON.stringify(dpValue)}`);
-                return {control_mode: {0: 'local', 1: 'remote', 2: 'both'}[value]};
-            } else {
-                meta.logger.warn(`fromZigbee.ZB006X_settings: Unrecognized DP #${dp} with data ${JSON.stringify(dpValue)}`);
+            case tuya.dataPoints.fantemExtSwitchStatus:
+                return {ext_switch_status: value};
+            case tuya.dataPoints.fantemControlMode:
+                return {control_mode: {0: 'ext_switch', 1: 'remote', 2: 'both'}[value]};
+            case 111:
+                // Value 0 is received after each device power-on. No idea what it means.
+                return;
+            case tuya.dataPoints.fantemLoadType:
+                // Not sure if 0 is 'resistive' and 2 is 'resistive_inductive'.
+                // If you see 'unknown', pls. check with Tuya gateway and app and update with label shown in Tuya app.
+                return {load_type: {0: 'unknown', 1: 'resistive_capacitive', 2: 'unknown', 3: 'detecting'}[value]};
+            case tuya.dataPoints.fantemLoadDimmable:
+                return {load_dimmable: {0: 'unknown', 1: 'dimmable', 2: 'not_dimmable'}[value]};
+            default:
+                meta.logger.warn(`fz.ZB006X_settings: Unhandled DP|Value [${dp}|${value}][${JSON.stringify(dpValue)}]`);
             }
         },
     },

package/converters/toZigbee.js

@@ -11,6 +11,7 @@ const libColor = require('../lib/color');
 const exposes = require('../lib/exposes');
 
 const manufacturerOptions = {
+    sunricher: {manufacturerCode: herdsman.Zcl.ManufacturerCode.SHENZHEN_SUNRICH},
     xiaomi: {manufacturerCode: herdsman.Zcl.ManufacturerCode.LUMI_UNITED_TECH, disableDefaultResponse: true},
     osram: {manufacturerCode: herdsman.Zcl.ManufacturerCode.OSRAM},
     eurotronic: {manufacturerCode: herdsman.Zcl.ManufacturerCode.JENNIC},
@@ -3005,6 +3006,127 @@ const converters = {
             await entity.read('closuresWindowCovering', [isPosition ? 'currentPositionLiftPercentage' : 'currentPositionTiltPercentage']);
         },
     },
+    namron_thermostat: {
+        key: [
+            'lcd_brightness', 'button_vibration_level', 'floor_sensor_type', 'sensor', 'powerup_status', 'floor_sensor_calibration',
+            'dry_time', 'mode_after_dry', 'temperature_display', 'window_open_check', 'hysterersis', 'display_auto_off_enabled',
+            'alarm_airtemp_overvalue', 'away_mode',
+        ],
+        convertSet: async (entity, key, value, meta) => {
+            if (key === 'lcd_brightness') {
+                const lookup = {'low': 0, 'mid': 1, 'high': 2};
+                const payload = {0x1000: {value: lookup[value], type: herdsman.Zcl.DataType.enum8}};
+                await entity.write('hvacThermostat', payload, manufacturerOptions.sunricher);
+            } else if (key === 'button_vibration_level') {
+                const lookup = {'off': 0, 'low': 1, 'high': 2};
+                const payload = {0x1001: {value: lookup[value], type: herdsman.Zcl.DataType.enum8}};
+                await entity.write('hvacThermostat', payload, manufacturerOptions.sunricher);
+            } else if (key === 'floor_sensor_type') {
+                const lookup = {'10k': 1, '15k': 2, '50k': 3, '100k': 4, '12k': 5};
+                const payload = {0x1002: {value: lookup[value], type: herdsman.Zcl.DataType.enum8}};
+                await entity.write('hvacThermostat', payload, manufacturerOptions.sunricher);
+            } else if (key === 'sensor') {
+                const lookup = {'air': 0, 'floor': 1, 'both': 2};
+                const payload = {0x1003: {value: lookup[value], type: herdsman.Zcl.DataType.enum8}};
+                await entity.write('hvacThermostat', payload, manufacturerOptions.sunricher);
+            } else if (key==='powerup_status') {
+                const lookup = {'default': 0, 'last_status': 1};
+                const payload = {0x1004: {value: lookup[value], type: herdsman.Zcl.DataType.enum8}};
+                await entity.write('hvacThermostat', payload, manufacturerOptions.sunricher);
+            } else if (key==='floor_sensor_calibration') {
+                const payload = {0x1005: {value: Math.round(value * 10), type: 0x28}}; // INT8S
+                await entity.write('hvacThermostat', payload, manufacturerOptions.sunricher);
+            } else if (key==='dry_time') {
+                const payload = {0x1006: {value: value, type: 0x20}}; // INT8U
+                await entity.write('hvacThermostat', payload, manufacturerOptions.sunricher);
+            } else if (key==='mode_after_dry') {
+                const lookup = {'off': 0, 'manual': 1, 'auto': 2, 'away': 3};
+                const payload = {0x1007: {value: lookup[value], type: herdsman.Zcl.DataType.enum8}};
+                await entity.write('hvacThermostat', payload, manufacturerOptions.sunricher);
+            } else if (key==='temperature_display') {
+                const lookup = {'room': 0, 'floor': 1};
+                const payload = {0x1008: {value: lookup[value], type: herdsman.Zcl.DataType.enum8}};
+                await entity.write('hvacThermostat', payload, manufacturerOptions.sunricher);
+            } else if (key==='window_open_check') {
+                const payload = {0x1009: {value: Math.round(value * 10), type: 0x20}};
+                await entity.write('hvacThermostat', payload, manufacturerOptions.sunricher);
+            } else if (key==='hysterersis') {
+                const payload = {0x100A: {value: Math.round(value * 10), type: 0x20}};
+                await entity.write('hvacThermostat', payload, manufacturerOptions.sunricher);
+            } else if (key==='display_auto_off_enabled') {
+                const lookup = {'enable': 0, 'disabled': 1};
+                const payload = {0x100B: {value: lookup[value], type: herdsman.Zcl.DataType.enum8}};
+                await entity.write('hvacThermostat', payload, manufacturerOptions.sunricher);
+            } else if (key==='alarm_airtemp_overvalue') {
+                const payload = {0x2001: {value: value, type: 0x20}};
+                await entity.write('hvacThermostat', payload, manufacturerOptions.sunricher);
+            } else if (key==='away_mode') {
+                const payload = {0x2002: {value: Number(value==='ON'), type: 0x30}};
+                await entity.write('hvacThermostat', payload, manufacturerOptions.sunricher);
+            }
+        },
+        convertGet: async (entity, key, meta) => {
+            switch (key) {
+            case 'lcd_brightness':
+                await entity.read('hvacThermostat', [0x1000], manufacturerOptions.sunricher);
+                break;
+            case 'button_vibration_level':
+                await entity.read('hvacThermostat', [0x1001], manufacturerOptions.sunricher);
+                break;
+            case 'floor_sensor_type':
+                await entity.read('hvacThermostat', [0x1002], manufacturerOptions.sunricher);
+                break;
+            case 'sensor':
+                await entity.read('hvacThermostat', [0x1003], manufacturerOptions.sunricher);
+                break;
+            case 'powerup_status':
+                await entity.read('hvacThermostat', [0x1004], manufacturerOptions.sunricher);
+                break;
+            case 'floor_sensor_calibration':
+                await entity.read('hvacThermostat', [0x1005], manufacturerOptions.sunricher);
+                break;
+            case 'dry_time':
+                await entity.read('hvacThermostat', [0x1006], manufacturerOptions.sunricher);
+                break;
+            case 'mode_after_dry':
+                await entity.read('hvacThermostat', [0x1007], manufacturerOptions.sunricher);
+                break;
+            case 'temperature_display':
+                await entity.read('hvacThermostat', [0x1008], manufacturerOptions.sunricher);
+                break;
+            case 'window_open_check':
+                await entity.read('hvacThermostat', [0x1009], manufacturerOptions.sunricher);
+                break;
+            case 'hysterersis':
+                await entity.read('hvacThermostat', [0x100A], manufacturerOptions.sunricher);
+                break;
+            case 'display_auto_off_enabled':
+                await entity.read('hvacThermostat', [0x100B], manufacturerOptions.sunricher);
+                break;
+            case 'alarm_airtemp_overvalue':
+                await entity.read('hvacThermostat', [0x2001], manufacturerOptions.sunricher);
+                break;
+            case 'away_mode':
+                await entity.read('hvacThermostat', [0x2002], manufacturerOptions.sunricher);
+                break;
+
+            default: // Unknown key
+                throw new Error(`Unhandled key toZigbee.namron_thermostat.convertGet ${key}`);
+            }
+        },
+
+    },
+    namron_thermostat_child_lock: {
+        key: ['child_lock'],
+        convertSet: async (entity, key, value, meta) => {
+            const keypadLockout = Number(value==='LOCK');
+            await entity.write('hvacUserInterfaceCfg', {keypadLockout});
+            return {readAfterWriteTime: 250, state: {child_lock: value}};
+        },
+        convertGet: async (entity, key, meta) => {
+            await entity.read('hvacUserInterfaceCfg', ['keypadLockout']);
+        },
+    },
     connecte_thermostat: {
         key: [
             'child_lock', 'current_heating_setpoint', 'local_temperature_calibration', 'max_temperature_protection', 'window_detection',
@@ -6373,17 +6495,19 @@ const converters = {
         convertSet: async (entity, key, value, meta) => {
             switch (key) {
             case 'ext_switch_type':
-                await tuya.sendDataPointEnum(entity, 103, {'unknown': 0, 'toggle_sw': 1,
-                    'momentary_sw': 2, 'rotary_sw': 3, 'auto_config': 4}[value]);
+                await tuya.sendDataPointEnum(entity, tuya.dataPoints.fantemExtSwitchType, {'unknown': 0, 'toggle_sw': 1,
+                    'momentary_sw': 2, 'rotary_sw': 3, 'auto_config': 4}[value], 'sendData');
                 break;
             case 'load_detection_mode':
-                await tuya.sendDataPointEnum(entity, 105, {'none': 0, 'first_power_on': 1, 'every_power_on': 2}[value]);
+                await tuya.sendDataPointEnum(entity, tuya.dataPoints.fantemLoadDetectionMode, {'none': 0, 'first_power_on': 1,
+                    'every_power_on': 2}[value], 'sendData');
                 break;
             case 'control_mode':
-                await tuya.sendDataPointEnum(entity, 109, {'local': 0, 'remote': 1, 'both': 2}[value]);
+                await tuya.sendDataPointEnum(entity, tuya.dataPoints.fantemControlMode, {'ext_switch': 0, 'remote': 1,
+                    'both': 2}[value], 'sendData');
                 break;
             default: // Unknown key
-                throw new Error(`toZigbee.ZB006X_settings: Unhandled key ${key}`);
+                throw new Error(`tz.ZB006X_settings: Unhandled key ${key}`);
             }
         },
     },

package/devices/danfoss.js

@@ -45,7 +45,7 @@ module.exports = [
                 .withDescription('Whether or not the unit needs warm water. `false` No Heat Request or `true` Heat Request'),
             exposes.enum('setpoint_change_source', ea.STATE, ['manual', 'schedule', 'externally'])
                 .withDescription('Values observed are `0` (manual), `1` (schedule) or `2` (externally)'),
-            exposes.climate().withSetpoint('occupied_heating_setpoint', 5, 32, 0.5).withLocalTemperature().withPiHeatingDemand()
+            exposes.climate().withSetpoint('occupied_heating_setpoint', 5, 35, 0.5).withLocalTemperature().withPiHeatingDemand()
                 .withSystemMode(['heat']).withRunningState(['idle', 'heat'], ea.STATE),
             exposes.numeric('external_measured_room_sensor', ea.ALL)
                 .withDescription('If `radiator_covered` is `true`: Set at maximum 30 minutes interval but not more often than every ' +

package/devices/fantem.js

@@ -5,6 +5,7 @@ const e = exposes.presets;
 const ea = exposes.access;
 const extend = require('../lib/extend');
 const reporting = require('../lib/reporting');
+const tuya = require('../lib/tuya');
 
 module.exports = [
     {
@@ -13,21 +14,34 @@ module.exports = [
         vendor: 'Fantem',
         description: 'Smart dimmer module without neutral',
         extend: extend.light_onoff_brightness({noConfigure: true}),
-        fromZigbee: [...extend.light_onoff_brightness({noConfigure: true}).fromZigbee, fz.command_on, fz.command_off,
-            fz.command_move, fz.command_stop, fz.ZB006X_settings],
+        fromZigbee: [...extend.light_onoff_brightness({noConfigure: true}).fromZigbee,
+            fz.command_on, fz.command_off, fz.command_move, fz.command_stop, fz.ZB006X_settings],
         toZigbee: [...extend.light_onoff_brightness({noConfigure: true}).toZigbee, tz.ZB006X_settings],
         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'])
                 .withDescription('External switch type'),
+            exposes.numeric('ext_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'),
-            exposes.enum('control_mode', ea.STATE_SET, ['local', 'remote', 'both']).withDescription('Control mode'),
+            // If you see load_type 'unknown', pls. check with Tuya gateway and app and update with label from Tuya app.
+            exposes.enum('load_type', ea.STATE, ['unknown', 'resistive_capacitive', 'unknown', 'detecting'])
+                .withDescription('Load type'),
+            exposes.enum('load_dimmable', ea.STATE, ['unknown', 'dimmable', 'not_dimmable'])
+                .withDescription('Load dimmable'),
+            exposes.enum('power_supply_mode', ea.STATE, ['unknown', 'no_neutral', 'with_neutral'])
+                .withDescription('Power supply mode'),
         ],
         meta: {disableActionGroup: true},
+        onEvent: tuya.onEventSetLocalTime,
         configure: async (device, coordinatorEndpoint, logger) => {
             await extend.light_onoff_brightness().configure(device, coordinatorEndpoint, logger);
             const endpoint = device.getEndpoint(1);
+            // Enables reporting of physical state changes
+            // 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);
         },

package/devices/ikea.js

@@ -796,10 +796,10 @@ module.exports = [
         extend: tradfriExtend.light_onoff_brightness(),
     },
     {
-        zigbeeModel: ['TRADFRIbulbGU10WS345lm', 'TRADFRI bulb GU10 WW 345lm'],
+        zigbeeModel: ['TRADFRIbulbGU10WS345lm', 'TRADFRI bulb GU10 WW 345lm', 'TRADFRIbulbGU10WS380lm'],
         model: 'LED2005R5',
         vendor: 'IKEA',
-        description: 'TRADFRI LED bulb GU10 345 lumen, dimmable, white spectrum',
+        description: 'TRADFRI LED bulb GU10 345/380 lumen, dimmable, white spectrum',
         extend: tradfriExtend.light_onoff_brightness_colortemp(),
     },
     {

package/devices/innr.js

@@ -497,6 +497,18 @@ module.exports = [
         },
         exposes: [e.power(), e.current(), e.voltage().withAccess(ea.STATE), e.switch(), e.energy()],
     },
+    {
+        zigbeeModel: ['SP 110'],
+        model: 'SP 110',
+        vendor: 'Innr',
+        description: 'Smart plug',
+        extend: extend.switch(),
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff']);
+            await reporting.onOff(endpoint);
+        },
+    },
     {
         zigbeeModel: ['SP 220'],
         model: 'SP 220',

package/devices/keen_home.js

@@ -41,7 +41,7 @@ module.exports = [
         exposes: [e.cover_position().setAccess('state', ea.ALL), e.temperature(), e.battery(), e.pressure()],
     },
     {
-        zigbeeModel: ['SV02-410-MP-1.3', 'SV02-412-MP-1.3', 'SV02-610-MP-1.3', 'SV02-612-MP-1.3', 'SV02-410-MP-1.0'],
+        zigbeeModel: ['SV02-410-MP-1.3', 'SV02-412-MP-1.3', 'SV02-610-MP-1.3', 'SV02-612-MP-1.3', 'SV02-410-MP-1.0', 'SV02-410-MP-1.2'],
         model: 'SV02',
         vendor: 'Keen Home',
         description: 'Smart vent',

package/devices/lonsonho.js

@@ -127,7 +127,7 @@ module.exports = [
         },
     },
     {
-        fingerprint: [{modelID: 'TS110F', manufacturerName: '_TZ3000_92chsky7'}],
+        fingerprint: [{modelID: 'TS110F', manufacturerName: '_TZ3000_92chsky7'}, {modelID: 'TS110E', manufacturerName: '_TZ3210_4ubylghk'}],
         model: 'QS-Zigbee-D02-TRIAC-2C-L',
         vendor: 'Lonsonho',
         description: '2 gang smart dimmer switch module without neutral',

package/devices/namron.js

@@ -263,29 +263,68 @@ module.exports = [
         model: '4512737/4512738',
         vendor: 'Namron',
         description: 'Touch termostat',
-        fromZigbee: [fz.thermostat, fz.metering, fz.electrical_measurement, fz.hvac_user_interface],
+        fromZigbee: [fz.thermostat, fz.namron_thermostat, fz.metering, fz.electrical_measurement,
+            fz.namron_hvac_user_interface],
         toZigbee: [tz.thermostat_occupied_heating_setpoint, tz.thermostat_unoccupied_heating_setpoint, tz.thermostat_occupancy,
             tz.thermostat_local_temperature_calibration, tz.thermostat_local_temperature, tz.thermostat_outdoor_temperature,
             tz.thermostat_system_mode, tz.thermostat_control_sequence_of_operation, tz.thermostat_running_state,
-            tz.thermostat_keypad_lockout],
+            tz.namron_thermostat_child_lock, tz.namron_thermostat],
         exposes: [
             e.local_temperature(),
             exposes.numeric('outdoor_temperature', ea.STATE_GET).withUnit('°C')
                 .withDescription('Current temperature measured from the floor sensor'),
-            e.keypad_lockout(),
             exposes.climate()
-                .withSetpoint('occupied_heating_setpoint', 5, 50, 0.01)
+                .withSetpoint('occupied_heating_setpoint', 0, 40, 0.1)
                 .withLocalTemperature()
                 .withLocalTemperatureCalibration(-30, 30, 0.1)
                 .withSystemMode(['off', 'auto', 'heat'])
                 .withRunningState(['idle', 'heat']),
+            exposes.binary('away_mode', ea.ALL, 'ON', 'OFF')
+                .withDescription('Enable/disable away mode'),
+            exposes.binary('child_lock', ea.ALL, 'LOCK', 'UNLOCK')
+                .withDescription('Enables/disables physical input on the device'),
             e.power(), e.current(), e.voltage(), e.energy(),
+            exposes.enum('lcd_brightness', ea.ALL, ['low', 'mid', 'high'])
+                .withDescription('OLED brightness when operating the buttons.  Default: Medium.'),
+            exposes.enum('button_vibration_level', ea.ALL, ['off', 'low', 'high'])
+                .withDescription('Key beep volume and vibration level.  Default: Low.'),
+            exposes.enum('floor_sensor_type', ea.ALL, ['10k', '15k', '50k', '100k', '12k'])
+                .withDescription('Type of the external floor sensor.  Default: NTC 10K/25.'),
+            exposes.enum('sensor', ea.ALL, ['air', 'floor', 'both'])
+                .withDescription('The sensor used for heat control.  Default: Room Sensor.'),
+            exposes.enum('powerup_status', ea.ALL, ['default', 'last_status'])
+                .withDescription('The mode after a power reset.  Default: Previous Mode.'),
+            exposes.numeric('floor_sensor_calibration', ea.ALL)
+                .withUnit('°C')
+                .withValueMin(-3).withValueMax(3).withValueStep(0.1)
+                .withDescription('The tempearatue calibration for the exernal floor sensor, between -3 and 3 in 0.1°C.  Default: 0.'),
+            exposes.numeric('dry_time', ea.ALL)
+                .withUnit('min')
+                .withValueMin(5).withValueMax(100)
+                .withDescription('The duration of Dry Mode, between 5 and 100 minutes.  Default: 5.'),
+            exposes.enum('mode_after_dry', ea.ALL, ['off', 'manual', 'auto', 'away'])
+                .withDescription('The mode after Dry Mode.  Default: Auto.'),
+            exposes.enum('temperature_display', ea.ALL, ['room', 'floor'])
+                .withDescription('The temperature on the display.  Default: Room Temperature.'),
+            exposes.numeric('window_open_check', ea.ALL)
+                .withUnit('°C')
+                .withValueMin(3).withValueMax(8).withValueStep(0.5)
+                .withDescription('The threshold to detect window open, between 3 and 8 in 0.5 °C.  Default: 0 (disabled).'),
+            exposes.numeric('hysterersis', ea.ALL)
+                .withUnit('°C')
+                .withValueMin(5).withValueMax(20).withValueStep(0.1)
+                .withDescription('Hysteresis setting, between 5 and 20 in 0.1 °C.  Default: 5.'),
+            exposes.enum('display_auto_off_enabled', ea.ALL, ['enable', 'disabled']),
+            exposes.numeric('alarm_airtemp_overvalue', ea.ALL)
+                .withUnit('°C')
+                .withValueMin(20).withValueMax(60).withValueStep(1)
+                .withDescription('Room temperature alarm threshold, between 20 and 60 in °C.  0 means disabled.  Default: 45.'),
         ],
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
             const binds = [
-                'genBasic', 'genIdentify', 'genGroups', 'genScenes', 'hvacThermostat',
-                'seMetering', 'haElectricalMeasurement', 'genAlarms', 'msOccupancySensing', 'genTime', 'hvacUserInterfaceCfg',
+                'genBasic', 'genIdentify', 'hvacThermostat', 'seMetering', 'haElectricalMeasurement', 'genAlarms',
+                'msOccupancySensing', 'genTime', 'hvacUserInterfaceCfg',
             ];
             await reporting.bind(endpoint, coordinatorEndpoint, binds);
 
@@ -302,15 +341,130 @@ module.exports = [
                 reportableChange: null,
             }]);
 
+            await endpoint.read('haElectricalMeasurement', ['acVoltageMultiplier', 'acVoltageDivisor', 'acCurrentMultiplier']);
+            await endpoint.read('haElectricalMeasurement', ['acCurrentDivisor']);
+
             await reporting.activePower(endpoint);
-            await reporting.currentSummDelivered(endpoint);
-            await reporting.readMeteringMultiplierDivisor(endpoint);
-            await reporting.rmsCurrent(endpoint);
-            await reporting.rmsVoltage(endpoint);
+            await reporting.rmsCurrent(endpoint, {min: 10, change: 10});
+            await reporting.rmsVoltage(endpoint, {min: 10});
             await reporting.readMeteringMultiplierDivisor(endpoint);
+            await reporting.currentSummDelivered(endpoint);
+
+            // Custom attributes
+            const options = {manufacturerCode: 0x1224};
+
+            // OperateDisplayLcdBrightnesss
+            await endpoint.configureReporting('hvacThermostat', [{
+                attribute: {ID: 0x1000, type: 0x30},
+                minimumReportInterval: 0,
+                maximumReportInterval: constants.repInterval.HOUR,
+                reportableChange: null}],
+            options);
+            // ButtonVibrationLevel
+            await endpoint.configureReporting('hvacThermostat', [{
+                attribute: {ID: 0x1001, type: 0x30},
+                minimumReportInterval: 0,
+                maximumReportInterval: constants.repInterval.HOUR,
+                reportableChange: null}],
+            options);
+            // FloorSensorType
+            await endpoint.configureReporting('hvacThermostat', [{
+                attribute: {ID: 0x1002, type: 0x30},
+                minimumReportInterval: 0,
+                maximumReportInterval: constants.repInterval.HOUR,
+                reportableChange: null}],
+            options);
+            // ControlType
+            await endpoint.configureReporting('hvacThermostat', [{
+                attribute: {ID: 0x1003, type: 0x30},
+                minimumReportInterval: 0,
+                maximumReportInterval: constants.repInterval.HOUR,
+                reportableChange: null}],
+            options);
+            // PowerUpStatus
+            await endpoint.configureReporting('hvacThermostat', [{
+                attribute: {ID: 0x1004, type: 0x30},
+                minimumReportInterval: 0,
+                maximumReportInterval: constants.repInterval.HOUR,
+                reportableChange: null}],
+            options);
+            // FloorSensorCalibration
+            await endpoint.configureReporting('hvacThermostat', [{
+                attribute: {ID: 0x1005, type: 0x28},
+                minimumReportInterval: 0,
+                maximumReportInterval: constants.repInterval.HOUR,
+                reportableChange: 0}],
+            options);
+            // DryTime
+            await endpoint.configureReporting('hvacThermostat', [{
+                attribute: {ID: 0x1006, type: 0x20},
+                minimumReportInterval: 0,
+                maximumReportInterval: constants.repInterval.HOUR,
+                reportableChange: 0}],
+            options);
+            // ModeAfterDry
+            await endpoint.configureReporting('hvacThermostat', [{
+                attribute: {ID: 0x1007, type: 0x30},
+                minimumReportInterval: 0,
+                maximumReportInterval: constants.repInterval.HOUR,
+                reportableChange: null}],
+            options);
+            // TemperatureDisplay
+            await endpoint.configureReporting('hvacThermostat', [{
+                attribute: {ID: 0x1008, type: 0x30},
+                minimumReportInterval: 0,
+                maximumReportInterval: constants.repInterval.HOUR,
+                reportableChange: null}],
+            options);
+            // WindowOpenCheck
+            await endpoint.configureReporting('hvacThermostat', [{
+                attribute: {ID: 0x1009, type: 0x20},
+                minimumReportInterval: 0,
+                maximumReportInterval: constants.repInterval.HOUR,
+                reportableChange: 0}],
+            options);
+
+            // Hysterersis
+            await endpoint.configureReporting('hvacThermostat', [{
+                attribute: {ID: 0x100A, type: 0x20},
+                minimumReportInterval: 0,
+                maximumReportInterval: constants.repInterval.HOUR,
+                reportableChange: 0}],
+            options);
+            // DisplayAutoOffEnable
+            await endpoint.configureReporting('hvacThermostat', [{
+                attribute: {ID: 0x100B, type: 0x30},
+                minimumReportInterval: 0,
+                maximumReportInterval: constants.repInterval.HOUR,
+                reportableChange: null}],
+            options);
+
+            // AlarmAirTempOverValue
+            await endpoint.configureReporting('hvacThermostat', [{
+                attribute: {ID: 0x2001, type: 0x20},
+                minimumReportInterval: 0,
+                maximumReportInterval: constants.repInterval.HOUR,
+                reportableChange: 0}],
+            options);
+            // Away Mode Set
+            await endpoint.configureReporting('hvacThermostat', [{
+                attribute: {ID: 0x2002, type: 0x30},
+                minimumReportInterval: 0,
+                maximumReportInterval: constants.repInterval.HOUR,
+                reportableChange: null}],
+            options);
+
+            // Device does not asks for the time with binding, we need to write time during configure
+            const time = Math.round(((new Date()).getTime() - constants.OneJanuary2000) / 1000);
+            const values = {time: time};
+            endpoint.write('genTime', values);
 
-            // Trigger read
-            await endpoint.read('hvacThermostat', ['systemMode', 'runningState', 'occupied_heating_setpoint']);
+            // Trigger initial read
+            await endpoint.read('hvacThermostat', ['systemMode', 'runningState', 'occupiedHeatingSetpoint']);
+            await endpoint.read('hvacThermostat', [0x1000, 0x1001, 0x1002, 0x1003], options);
+            await endpoint.read('hvacThermostat', [0x1004, 0x1005, 0x1006, 0x1007], options);
+            await endpoint.read('hvacThermostat', [0x1008, 0x1009, 0x100A, 0x100B], options);
+            await endpoint.read('hvacThermostat', [0x2001, 0x2002], options);
         },
     },
 ];

package/devices/niko.js

@@ -5,33 +5,47 @@ const reporting = require('../lib/reporting');
 const e = exposes.presets;
 const ea = exposes.access;
 
-const fzLocal = {
+const local = {
     fz: {
         switch_operation_mode: {
-            cluster: 'manuSpecificNikoSwitchSetup',
+            cluster: 'manuSpecificNiko1',
             type: ['attributeReport', 'readResponse'],
             convert: (model, msg, publish, options, meta) => {
                 const state = {};
-                if (msg.data.hasOwnProperty('operationMode')) {
+                if (msg.data.hasOwnProperty('switchOperationMode')) {
                     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];
+                    state[operationModeProperty] = operationModeMap[msg.data.switchOperationMode];
                 }
                 return state;
             },
         },
         switch_action: {
-            cluster: 'manuSpecificNikoSwitch',
+            cluster: 'manuSpecificNiko2',
             type: ['attributeReport', 'readResponse'],
             convert: (model, msg, publish, options, meta) => {
                 const state = {};
 
-                if (msg.data.hasOwnProperty('action')) {
+                if (msg.data.hasOwnProperty('switchAction')) {
                     // 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];
+                    state[actionProperty] = actionMap[msg.data.switchAction];
+                }
+                return state;
+            },
+        },
+        outlet: {
+            cluster: 'manuSpecificNiko1',
+            type: ['attributeReport', 'readResponse'],
+            convert: (model, msg, publish, options, meta) => {
+                const state = {};
+                if (msg.data.hasOwnProperty('outletChildLock')) {
+                    state['child_lock'] = (msg.data['outletChildLock'] == 0 ? 'LOCK' : 'UNLOCK');
+                }
+                if (msg.data.hasOwnProperty('outletLedState')) {
+                    state['led_enable'] = (msg.data['outletLedState'] == 1);
                 }
                 return state;
             },
@@ -48,12 +62,32 @@ const fzLocal = {
                     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]});
+                    await entity.write('manuSpecificNiko1', {'switchOperationMode': operationModeLookup[value]});
                     return {state: {[operationModeProperty]: value.toLowerCase()}};
                 }
             },
             convertGet: async (entity, key, meta) => {
-                await entity.read('manuSpecificNikoSwitchSetup', ['operationMode']);
+                await entity.read('manuSpecificNiko1', ['switchOperationMode']);
+            },
+        },
+        outlet_child_lock: {
+            key: ['child_lock'],
+            convertSet: async (entity, key, value, meta) => {
+                await entity.write('manuSpecificNiko1', {'outletChildLock': ((value.toLowerCase() === 'lock') ? 0 : 1)});
+                return {state: {child_lock: ((value.toLowerCase() === 'lock') ? 'LOCK' : 'UNLOCK')}};
+            },
+            convertGet: async (entity, key, meta) => {
+                await entity.read('manuSpecificNiko1', ['outletChildLock']);
+            },
+        },
+        outlet_led_enable: {
+            key: ['led_enable'],
+            convertSet: async (entity, key, value, meta) => {
+                await entity.write('manuSpecificNiko1', {'outletLedState': ((value) ? 1 : 0)});
+                return {state: {led_enable: ((value) ? true : false)}};
+            },
+            convertGet: async (entity, key, meta) => {
+                await entity.read('manuSpecificNiko1', ['outletLedState']);
             },
         },
     },
@@ -65,8 +99,11 @@ module.exports = [
         model: '170-33505',
         vendor: 'Niko',
         description: 'Connected socket outlet',
-        fromZigbee: [fz.on_off, fz.electrical_measurement, fz.metering],
-        toZigbee: [tz.on_off, tz.electrical_measurement_power, tz.currentsummdelivered],
+        fromZigbee: [fz.on_off, fz.electrical_measurement, fz.metering, local.fz.outlet],
+        toZigbee: [
+            tz.on_off, tz.electrical_measurement_power, tz.currentsummdelivered,
+            local.tz.outlet_child_lock, local.tz.outlet_led_enable,
+        ],
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
             await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'haElectricalMeasurement', 'seMetering']);
@@ -83,11 +120,16 @@ module.exports = [
 
             await reporting.readMeteringMultiplierDivisor(endpoint);
             await reporting.currentSummDelivered(endpoint, {min: 60, change: 1});
+
+            await endpoint.read('manuSpecificNiko1', ['outletChildLock']);
+            await endpoint.read('manuSpecificNiko1', ['outletLedState']);
         },
         exposes: [
             e.switch(),
             e.power().withAccess(ea.STATE_GET), e.current(), e.voltage(),
             e.energy().withAccess(ea.STATE_GET),
+            exposes.binary('child_lock', ea.ALL, 'LOCK', 'UNLOCK').withDescription('Enables/disables physical input on the device'),
+            exposes.binary('led_enable', ea.ALL, true, false).withDescription('Enable LED'),
         ],
     },
     {
@@ -134,13 +176,13 @@ module.exports = [
         model: '552-721X1',
         vendor: 'Niko',
         description: 'Single connectable switch',
-        fromZigbee: [fz.on_off, fzLocal.fz.switch_operation_mode, fzLocal.fz.switch_action],
-        toZigbee: [tz.on_off, fzLocal.tz.switch_operation_mode],
+        fromZigbee: [fz.on_off, local.fz.switch_operation_mode, local.fz.switch_action],
+        toZigbee: [tz.on_off, local.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']);
+            await endpoint.read('manuSpecificNiko1', ['switchOperationMode']);
         },
         exposes: [
             e.switch(),
@@ -153,8 +195,8 @@ module.exports = [
         model: '552-721X2',
         vendor: 'Niko',
         description: 'Double connectable switch',
-        fromZigbee: [fz.on_off, fzLocal.fz.switch_operation_mode, fzLocal.fz.switch_action],
-        toZigbee: [tz.on_off, fzLocal.tz.switch_operation_mode],
+        fromZigbee: [fz.on_off, local.fz.switch_operation_mode, local.fz.switch_action],
+        toZigbee: [tz.on_off, local.tz.switch_operation_mode],
         endpoint: (device) => {
             return {'l1': 1, 'l2': 2};
         },
@@ -166,8 +208,8 @@ 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']);
+            await ep1.read('manuSpecificNiko1', ['switchOperationMode']);
+            await ep2.read('manuSpecificNiko1', ['switchOperationMode']);
         },
         exposes: [
             e.switch().withEndpoint('l1'), e.switch().withEndpoint('l2'),

package/devices/orvibo.js

@@ -6,6 +6,13 @@ const extend = require('../lib/extend');
 const e = exposes.presets;
 
 module.exports = [
+    {
+        zigbeeModel: ['4a33f5ea766a4c96a962b371ffde9943'],
+        model: 'DS20Z07B',
+        vendor: 'ORVIBO',
+        description: 'Downlight (S series)',
+        extend: extend.light_onoff_brightness_colortemp({colorTempRange: [166, 370]}),
+    },
     {
         zigbeeModel: ['ORVIBO Socket', '93e29b89b2ee45bea5bdbb7679d75d24'],
         model: 'OR-ZB-S010-3C',

package/devices/sinope.js

@@ -259,6 +259,22 @@ module.exports = [
             await reporting.activePower(endpoint, {min: 10, change: 1});
         },
     },
+    {
+        zigbeeModel: ['SP2610ZB'],
+        model: 'SP2610ZB',
+        vendor: 'Sinopé',
+        description: 'Zigbee smart outlet',
+        fromZigbee: [fz.on_off, fz.electrical_measurement],
+        toZigbee: [tz.on_off],
+        exposes: [e.switch(), e.power()],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'haElectricalMeasurement']);
+            await reporting.readEletricalMeasurementMultiplierDivisors(endpoint);
+            await reporting.onOff(endpoint);
+            await reporting.activePower(endpoint, {min: 10, change: 1});
+        },
+    },
     {
         zigbeeModel: ['DM2500ZB'],
         model: 'DM2500ZB',

package/devices/tuya.js

@@ -2174,7 +2174,8 @@ module.exports = [
         ],
     },
     {
-        fingerprint: [{modelID: 'TS004F', manufacturerName: '_TZ3000_4fjiwweb'}, {modelID: 'TS004F', manufacturerName: '_TZ3000_uri7ongn'}],
+        fingerprint: [{modelID: 'TS004F', manufacturerName: '_TZ3000_4fjiwweb'}, {modelID: 'TS004F', manufacturerName: '_TZ3000_uri7ongn'},
+            {modelID: 'TS004F', manufacturerName: '_TZ3000_ixla93vd'}],
         model: 'ERS-10TZBVK-AA',
         vendor: 'TuYa',
         description: 'Smart knob',

package/devices/woox.js

@@ -7,6 +7,75 @@ const extend = require('../lib/extend');
 const e = exposes.presets;
 const ea = exposes.access;
 
+const fzLocal = {
+    R7049_status: {
+        cluster: 'manuSpecificTuya',
+        type: ['commandDataResponse', 'commandDataReport'],
+        convert: (model, msg, publish, options, meta) => {
+            const result = {};
+            for (const dpValue of msg.data.dpValues) {
+                const dp = dpValue.dp; // First we get the data point ID
+                const value = tuya.getDataValue(dpValue); // This function will take care of converting the data to proper JS type
+                switch (dp) {
+                case 1:
+                    result.smoke = Boolean(!value);
+                    break;
+                case 8:
+                    result.test_alarm = value;
+                    break;
+                case 9: {
+                    const testAlarmResult = {0: 'checking', 1: 'check_success', 2: 'check_failure', 3: 'others'};
+                    result.test_alarm_result = testAlarmResult[value];
+                    break;
+                }
+                case 11:
+                    result.fault_alarm = Boolean(value);
+                    break;
+                case 14: {
+                    const batteryLevels = {0: 'low', 1: 'middle', 2: 'high'};
+                    result.battery_level = batteryLevels[value];
+                    break;
+                }
+                case 16:
+                    result.silence_siren = value;
+                    break;
+                case 20: {
+                    const alarm = {0: true, 1: false};
+                    result.alarm = alarm[value];
+                    break;
+                }
+                default:
+                    meta.logger.warn(`zigbee-herdsman-converters:Woox Smoke Detector: NOT RECOGNIZED DP #${
+                        dp} with data ${JSON.stringify(dpValue)}`);
+                }
+            }
+            return result;
+        },
+    },
+};
+
+const tzLocal = {
+    R7049_silenceSiren: {
+        key: ['silence_siren'],
+        convertSet: async (entity, key, value, meta) => {
+            await tuya.sendDataPointBool(entity, 16, value);
+        },
+    },
+    R7049_testAlarm: {
+        key: ['test_alarm'],
+        convertSet: async (entity, key, value, meta) => {
+            await tuya.sendDataPointBool(entity, 8, value);
+        },
+    },
+    R7049_alarm: {
+        key: ['alarm'],
+        convertSet: async (entity, key, value, meta) => {
+            const linkAlarm = {true: 0, false: 1};
+            await tuya.sendDataPointEnum(entity, 20, linkAlarm[value]);
+        },
+    },
+};
+
 module.exports = [
     {
         fingerprint: [{modelID: 'TS0101', manufacturerName: '_TZ3210_eymunffl'}],
@@ -50,10 +119,19 @@ module.exports = [
         model: 'R7049',
         vendor: 'Woox',
         description: 'Smart smoke alarm',
-        fromZigbee: [fz.tuya_woox_smoke, fz.ignore_tuya_set_time],
-        toZigbee: [],
+        meta: {timeout: 30000, disableDefaultResponse: true},
+        fromZigbee: [fzLocal.R7049_status, fz.ignore_tuya_set_time, fz.ignore_time_read],
+        toZigbee: [tzLocal.R7049_silenceSiren, tzLocal.R7049_testAlarm, tzLocal.R7049_alarm],
+        exposes: [e.battery_low(),
+            exposes.binary('smoke', ea.STATE, true, false).withDescription('Smoke alarm status'),
+            exposes.binary('test_alarm', ea.STATE_SET, true, false).withDescription('Test alarm'),
+            exposes.enum('test_alarm_result', ea.STATE, ['checking', 'check_success', 'check_failure', 'others'])
+                .withDescription('Test alarm result'),
+            exposes.enum('battery_level', ea.STATE, ['low', 'middle', 'high']).withDescription('Battery level state'),
+            exposes.binary('alarm', ea.STATE_SET, true, false).withDescription('Alarm enable'),
+            exposes.binary('fault_alarm', ea.STATE, true, false).withDescription('Fault alarm status'),
+            exposes.binary('silence_siren', ea.STATE_SET, true, false).withDescription('Silence siren')],
         onEvent: tuya.onEventsetTime,
-        exposes: [e.smoke(), e.battery_low()],
     },
     {
         fingerprint: [{modelID: 'TS0219', manufacturerName: '_TYZB01_ynsiasng'}],

package/lib/tuya.js

@@ -219,7 +219,8 @@ function convertStringToHexArray(value) {
 // Default is 100 = open, 0 = closed; Devices listed here will use 0 = open, 100 = closed instead
 // Use manufacturerName to identify device!
 // Dont' invert _TZE200_cowvfni3: https://github.com/Koenkk/zigbee2mqtt/issues/6043
-const coverPositionInvert = ['_TZE200_wmcdj3aq', '_TZE200_nogaemzt', '_TZE200_xuzcvlku', '_TZE200_xaabybja', '_TZE200_rmymn92d'];
+const coverPositionInvert = ['_TZE200_wmcdj3aq', '_TZE200_nogaemzt', '_TZE200_xuzcvlku', '_TZE200_xaabybja', '_TZE200_rmymn92d',
+    '_TZE200_gubdgai2'];
 
 // Gets a boolean indicating whether the cover by this manufacturerName needs reversed positions
 function isCoverInverted(manufacturerName) {
@@ -448,16 +449,23 @@ const dataPoints = {
     silvercrestSetColor: 5,
     silvercrestSetEffect: 6,
     // Fantem
+    fantemPowerSupplyMode: 101,
     fantemReportingTime: 102,
+    fantemExtSwitchType: 103,
     fantemTempCalibration: 104,
     fantemHumidityCalibration: 105,
+    fantemLoadDetectionMode: 105,
     fantemLuxCalibration: 106,
+    fantemExtSwitchStatus: 106,
     fantemTemp: 107,
     fantemHumidity: 108,
     fantemMotionEnable: 109,
+    fantemControlMode: 109,
     fantemBattery: 110,
     fantemLedEnable: 111,
     fantemReportingEnable: 112,
+    fantemLoadType: 112,
+    fantemLoadDimmable: 113,
     // Woox
     wooxSwitch: 102,
     wooxBattery: 14,

package/package.json

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