zigbee-herdsman-converters 14.0.635 → 14.0.637

package/devices/develco.js

@@ -516,20 +516,23 @@ module.exports = [
             return {default: 35};
         },
         configure: async (device, coordinatorEndpoint, logger) => {
-            const endpoint1 = device.getEndpoint(35);
-            await reporting.bind(endpoint1, coordinatorEndpoint, ['genPowerCfg']);
-            await reporting.batteryVoltage(endpoint1, {min: constants.repInterval.HOUR, max: 43200, change: 100});
-            await endpoint1.read('genPowerCfg', ['batteryVoltage']);
-            await endpoint1.read('genBasic', ['develcoLedControl'], manufacturerOptions);
-            await endpoint1.read('ssIasZone', ['develcoAlarmOffDelay'], manufacturerOptions);
+            const endpoint35 = device.getEndpoint(35);
+            await reporting.bind(endpoint35, coordinatorEndpoint, ['genPowerCfg']);
+            await reporting.batteryVoltage(endpoint35, {min: constants.repInterval.HOUR, max: 43200, change: 100});
+            try {
+                await endpoint35.read('ssIasZone', ['develcoAlarmOffDelay'], manufacturerOptions);
+                await endpoint35.read('genBasic', ['develcoLedControl'], manufacturerOptions);
+            } catch (error) {/* some reports of timeouts on reading these */}
 
-            const endpoint2 = device.getEndpoint(38);
-            await reporting.bind(endpoint2, coordinatorEndpoint, ['msTemperatureMeasurement']);
-            await reporting.temperature(endpoint2);
+            const endpoint38 = device.getEndpoint(38);
+            await reporting.bind(endpoint38, coordinatorEndpoint, ['msTemperatureMeasurement']);
+            await reporting.temperature(endpoint38,
+                {min: constants.repInterval.MINUTE, max: constants.repInterval.MINUTES_10, change: 100});
 
-            const endpoint3 = device.getEndpoint(39);
-            await reporting.bind(endpoint3, coordinatorEndpoint, ['msIlluminanceMeasurement']);
-            await reporting.illuminance(endpoint3);
+            const endpoint39 = device.getEndpoint(39);
+            await reporting.bind(endpoint39, coordinatorEndpoint, ['msIlluminanceMeasurement']);
+            await reporting.illuminance(endpoint39,
+                {min: constants.repInterval.MINUTE, max: constants.repInterval.MINUTES_10, change: 500});
         },
     },
     {

package/devices/hive.js

@@ -344,7 +344,7 @@ module.exports = [
         },
         exposes: [
             exposes.climate().withSetpoint('occupied_heating_setpoint', 5, 32, 0.5).withLocalTemperature()
-                .withSystemMode(['off', 'auto', 'heat']).withRunningState(['idle', 'heat']).withEndpoint('heat'),
+                .withSystemMode(['off', 'auto', 'heat', 'emergency_heating']).withRunningState(['idle', 'heat']).withEndpoint('heat'),
             exposes.binary('temperature_setpoint_hold', ea.ALL, true, false)
                 .withDescription('Prevent changes. `false` = run normally. `true` = prevent from making changes.' +
                     ' Must be set to `false` when system_mode = off or `true` for heat').withEndpoint('heat'),
@@ -396,7 +396,7 @@ module.exports = [
         },
         exposes: [
             exposes.climate().withSetpoint('occupied_heating_setpoint', 5, 32, 0.5).withLocalTemperature()
-                .withSystemMode(['off', 'auto', 'heat']).withRunningState(['idle', 'heat']).withEndpoint('heat'),
+                .withSystemMode(['off', 'auto', 'heat', 'emergency_heating']).withRunningState(['idle', 'heat']).withEndpoint('heat'),
             exposes.binary('temperature_setpoint_hold', ea.ALL, true, false)
                 .withDescription('Prevent changes. `false` = run normally. `true` = prevent from making changes.' +
                     ' Must be set to `false` when system_mode = off or `true` for heat').withEndpoint('heat'),

package/devices/namron.js

@@ -1,5 +1,6 @@
+const herdsman = require('zigbee-herdsman');
 const exposes = require('../lib/exposes');
-const fz = {...require('../converters/fromZigbee'), legacy: require('../lib/legacy').fromZigbee};
+const fz = require('../converters/fromZigbee');
 const tz = require('../converters/toZigbee');
 const constants = require('../lib/constants');
 const reporting = require('../lib/reporting');
@@ -8,6 +9,90 @@ const extend = require('../lib/extend');
 const ea = exposes.access;
 const e = exposes.presets;
 
+const sunricherManufacturer = {manufacturerCode: herdsman.Zcl.ManufacturerCode.SHENZHEN_SUNRICH};
+
+const fzLocal = {
+    namron_panelheater: {
+        cluster: 'hvacThermostat',
+        type: ['attributeReport', 'readResponse'],
+        convert: (model, msg, publish, options, meta) => {
+            const result = {};
+            const data = msg.data;
+            if (data.hasOwnProperty(0x1000)) { // OperateDisplayBrightnesss
+                result.display_brightnesss = data[0x1000];
+            }
+            if (data.hasOwnProperty(0x1001)) { // DisplayAutoOffActivation
+                const lookup = {0: 'deactivated', 1: 'activated'};
+                result.display_auto_off = lookup[data[0x1001]];
+            }
+            if (data.hasOwnProperty(0x1004)) { // PowerUpStatus
+                const lookup = {0: 'manual', 1: 'last_state'};
+                result.power_up_status = lookup[data[0x1004]];
+            }
+            if (data.hasOwnProperty(0x1009)) { // WindowOpenCheck
+                const lookup = {0: 'enable', 1: 'disable'};
+                result.window_open_check = lookup[data[0x1009]];
+            }
+            if (data.hasOwnProperty(0x100A)) { // Hysterersis
+                result.hysterersis = data[0x100A];
+            }
+            return result;
+        },
+    },
+};
+
+const tzLocal = {
+    namron_panelheater: {
+        key: [
+            'display_brightnesss', 'display_auto_off',
+            'power_up_status', 'window_open_check', 'hysterersis',
+        ],
+        convertSet: async (entity, key, value, meta) => {
+            if (key === 'display_brightnesss') {
+                const payload = {0x1000: {value: value, type: herdsman.Zcl.DataType.enum8}};
+                await entity.write('hvacThermostat', payload, sunricherManufacturer);
+            } else if (key === 'display_auto_off') {
+                const lookup = {'deactivated': 0, 'activated': 1};
+                const payload = {0x1001: {value: lookup[value], type: herdsman.Zcl.DataType.enum8}};
+                await entity.write('hvacThermostat', payload, sunricherManufacturer);
+            } else if (key === 'power_up_status') {
+                const lookup = {'manual': 0, 'last_state': 1};
+                const payload = {0x1004: {value: lookup[value], type: herdsman.Zcl.DataType.enum8}};
+                await entity.write('hvacThermostat', payload, sunricherManufacturer);
+            } else if (key==='window_open_check') {
+                const lookup = {'enable': 0, 'disable': 1};
+                const payload = {0x1009: {value: lookup[value], type: herdsman.Zcl.DataType.enum8}};
+                await entity.write('hvacThermostat', payload, sunricherManufacturer);
+            } else if (key==='hysterersis') {
+                const payload = {0x100A: {value: value, type: 0x20}};
+                await entity.write('hvacThermostat', payload, sunricherManufacturer);
+            }
+        },
+        convertGet: async (entity, key, meta) => {
+            switch (key) {
+            case 'display_brightnesss':
+                await entity.read('hvacThermostat', [0x1000], sunricherManufacturer);
+                break;
+            case 'display_auto_off':
+                await entity.read('hvacThermostat', [0x1001], sunricherManufacturer);
+                break;
+            case 'power_up_status':
+                await entity.read('hvacThermostat', [0x1004], sunricherManufacturer);
+                break;
+            case 'window_open_check':
+                await entity.read('hvacThermostat', [0x1009], sunricherManufacturer);
+                break;
+            case 'hysterersis':
+                await entity.read('hvacThermostat', [0x100A], sunricherManufacturer);
+                break;
+
+            default: // Unknown key
+                throw new Error(`Unhandled key toZigbee.namron_panelheater.convertGet ${key}`);
+            }
+        },
+    },
+};
+
 module.exports = [
     {
         zigbeeModel: ['3308431'],
@@ -502,4 +587,109 @@ module.exports = [
             await endpoint.read('hvacThermostat', [0x2001, 0x2002], options);
         },
     },
+    {
+        zigbeeModel: ['5401392', '5401396', '5401393', '5401397', '5401394', '5401398', '5401395', '5401399'],
+        model: '540139X',
+        vendor: 'Namron',
+        description: 'Panel heater 400/600/800/1000 W',
+        fromZigbee: [fz.thermostat, fz.metering, fz.electrical_measurement, fzLocal.namron_panelheater, fz.namron_hvac_user_interface],
+        toZigbee: [tz.thermostat_occupied_heating_setpoint, tz.thermostat_local_temperature_calibration, tz.thermostat_system_mode,
+            tz.thermostat_running_state, tz.thermostat_local_temperature, tzLocal.namron_panelheater, tz.namron_thermostat_child_lock],
+        exposes: [e.power(), e.current(), e.voltage(), e.energy(),
+            exposes.climate()
+                .withSetpoint('occupied_heating_setpoint', 5, 35, 0.5)
+                .withLocalTemperature()
+                // Unit also supports Auto, but i havent added support the scheduler yet
+                // so the function is not listed for now, as this doesn´t allow you the set the temperature
+                .withSystemMode(['off', 'heat'])
+                .withLocalTemperatureCalibration(-3, 3, 0.1)
+                .withRunningState(['idle', 'heat']),
+            // Namron proprietary stuff
+            exposes.binary('child_lock', ea.ALL, 'LOCK', 'UNLOCK')
+                .withDescription('Enables/disables physical input on the device'),
+            exposes.numeric('hysterersis', ea.ALL)
+                .withUnit('°C')
+                .withValueMin(5).withValueMax(50).withValueStep(0.1)
+                .withDescription('Hysterersis setting, range is 5-50, unit is 0.1oC,  Default: 5.'),
+            exposes.numeric('display_brightnesss', ea.ALL)
+                .withValueMin(1).withValueMax(7).withValueStep(1)
+                .withDescription('Adjust brightness of display values 1(Low)-7(High)'),
+            exposes.enum('display_auto_off', ea.ALL, ['deactivated', 'activated'])
+                .withDescription('Enable / Disable display auto off'),
+            exposes.enum('power_up_status', ea.ALL, ['manual', 'last_state'])
+                .withDescription('The mode after a power reset.  Default: Previous Mode. See instructions for information about manual'),
+            exposes.enum('window_open_check', ea.ALL, ['enable', 'disable'])
+                .withDescription('Turn on/off window check mode'),
+        ],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            const binds = [
+                'genBasic', 'genIdentify', 'hvacThermostat', 'seMetering', 'haElectricalMeasurement', 'genAlarms',
+                'genTime', 'hvacUserInterfaceCfg',
+            ];
+
+            // Reporting
+
+            // Metering
+            await reporting.readEletricalMeasurementMultiplierDivisors(endpoint);
+            await reporting.readMeteringMultiplierDivisor(endpoint);
+            await reporting.rmsVoltage(endpoint, {min: 10, change: 20}); // Voltage - Min change of 2v
+            await reporting.rmsCurrent(endpoint, {min: 10, change: 10}); // A - z2m displays only the first decimals, so change of 10 (0,01)
+            await reporting.activePower(endpoint, {min: 10, change: 15}); // W - Min change of 1,5W
+            await reporting.currentSummDelivered(endpoint, {min: 300}); // Report KWH every 5min
+
+            // Thermostat reporting
+            await reporting.thermostatTemperature(endpoint);
+            await reporting.thermostatOccupiedHeatingSetpoint(endpoint);
+            await reporting.thermostatTemperature(endpoint);
+            await reporting.thermostatKeypadLockMode(endpoint);
+            // LocalTemp is spammy, reports 0.01C diff by default, min change is now 0.5C
+            await reporting.thermostatTemperature(endpoint, {min: 0, change: 50});
+
+            // Namron proprietary stuff
+            const options = {manufacturerCode: 0x1224};
+
+            // display_brightnesss
+            await endpoint.configureReporting('hvacThermostat', [{
+                attribute: {ID: 0x1000, type: 0x30},
+                minimumReportInterval: 0,
+                maximumReportInterval: constants.repInterval.HOUR,
+                reportableChange: null}],
+            options);
+            // display_auto_off
+            await endpoint.configureReporting('hvacThermostat', [{
+                attribute: {ID: 0x1001, type: 0x30},
+                minimumReportInterval: 0,
+                maximumReportInterval: constants.repInterval.HOUR,
+                reportableChange: null}],
+            options);
+            // power_up_status
+            await endpoint.configureReporting('hvacThermostat', [{
+                attribute: {ID: 0x1004, type: 0x30},
+                minimumReportInterval: 0,
+                maximumReportInterval: constants.repInterval.HOUR,
+                reportableChange: null}],
+            options);
+            // window_open_check
+            await endpoint.configureReporting('hvacThermostat', [{
+                attribute: {ID: 0x1009, type: 0x30},
+                minimumReportInterval: 0,
+                maximumReportInterval: constants.repInterval.HOUR,
+                reportableChange: null}],
+            options);
+            // hysterersis
+            await endpoint.configureReporting('hvacThermostat', [{
+                attribute: {ID: 0x100A, type: 0x20},
+                minimumReportInterval: 0,
+                maximumReportInterval: constants.repInterval.HOUR,
+                reportableChange: null}],
+            options);
+
+            await endpoint.read('hvacThermostat', ['systemMode', 'runningState', 'occupiedHeatingSetpoint']);
+            await endpoint.read('hvacUserInterfaceCfg', ['keypadLockout']);
+            await endpoint.read('hvacThermostat', [0x1000, 0x1001, 0x1004, 0x1009, 0x100A], options);
+
+            await reporting.bind(endpoint, coordinatorEndpoint, binds);
+        },
+    },
 ];

package/devices/philips.js

@@ -687,7 +687,7 @@ module.exports = [
         extend: hueExtend.light_onoff_brightness_colortemp_color(),
     },
     {
-        zigbeeModel: ['4090531P9', '929003053601'],
+        zigbeeModel: ['4090531P9', '929003053601', '929003053501'],
         model: '4090531P9',
         vendor: 'Philips',
         description: 'Hue Flourish white and color ambiance ceiling light with Bluetooth',
@@ -1505,6 +1505,13 @@ module.exports = [
         description: 'Hue white PAR38 outdoor',
         extend: hueExtend.light_onoff_brightness(),
     },
+    {
+        zigbeeModel: ['LWS001'],
+        model: '9290018189',
+        vendor: 'Philips',
+        description: 'Hue white PAR38 outdoor',
+        extend: hueExtend.light_onoff_brightness(),
+    },
     {
         zigbeeModel: ['LLC010'],
         model: '7199960PH',

package/devices/sunricher.js

@@ -180,7 +180,7 @@ module.exports = [
         },
     },
     {
-        zigbeeModel: ['Micro Smart Dimmer', 'SM311', 'HK-SL-RDIM-A'],
+        zigbeeModel: ['Micro Smart Dimmer', 'SM311', 'HK-SL-RDIM-A', 'HK-SL-DIM-EU-A'],
         model: 'ZG2835RAC',
         vendor: 'Sunricher',
         description: 'ZigBee knob smart dimmer',

package/devices/tuya.js

@@ -930,6 +930,7 @@ module.exports = [
             {modelID: 'TS0503B', manufacturerName: '_TZ3210_trm3l2aw'},
             {modelID: 'TS0503B', manufacturerName: '_TZ3210_95txyzbx'},
             {modelID: 'TS0503B', manufacturerName: '_TZ3210_odlghna1'},
+            {modelID: 'TS0503B', manufacturerName: '_TZB210_nfzrlz29'},
             {modelID: 'TS0503B', manufacturerName: '_TZ3220_wp1k8xws'},
             {modelID: 'TS0503B', manufacturerName: '_TZ3210_wp1k8xws'}],
         model: 'TS0503B',
@@ -1027,7 +1028,9 @@ module.exports = [
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
             await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg']);
-            await reporting.batteryPercentageRemaining(endpoint);
+            try {
+                await reporting.batteryPercentageRemaining(endpoint);
+            } catch (error) {/* Fails for some https://github.com/Koenkk/zigbee2mqtt/issues/13708*/}
         },
     },
     {
@@ -1953,6 +1956,7 @@ module.exports = [
             {modelID: 'TS0601', manufacturerName: '_TZE200_lllliz3p'}, /* model: 'TV02-Zigbee', vendor: 'TuYa' */
             {modelID: 'TS0601', manufacturerName: '_TZE200_mudxchsu'}, /* model: 'TV05-ZG curve', vendor: 'TuYa' */
             {modelID: 'TS0601', manufacturerName: '_TZE200_7yoranx2'}, /* model: 'TV01-ZB', vendor: 'Moes' */
+            {modelID: 'TS0601', manufacturerName: '_TZE200_kds0pmmv'}, /* model: 'TV01-ZB', vendor: 'Moes' */
         ],
         model: 'TV02-Zigbee',
         vendor: 'TuYa',
@@ -2225,6 +2229,23 @@ module.exports = [
                 .withDescription('Plug LED indicator mode'), e.child_lock()],
         onEvent: tuya.onEventMeasurementPoll,
     },
+    {
+        fingerprint: tuya.fingerprint('TS0601', ['_TZE200_ntcy3xu1']),
+        model: 'TS0601_smoke_1',
+        vendor: 'TuYa',
+        description: 'Smoke sensor',
+        fromZigbee: [tuya.fzDataPoints],
+        toZigbee: [tuya.tzDataPoints],
+        configure: tuya.configureMagicPacket,
+        exposes: [e.smoke(), e.tamper(), e.battery_low()],
+        meta: {
+            tuyaDatapoints: [
+                [1, 'smoke', tuya.valueConverter.true0ElseFalse],
+                [4, 'tamper', tuya.valueConverter.raw],
+                [14, 'battery_low', tuya.valueConverter.true0ElseFalse],
+            ],
+        },
+    },
     {
         zigbeeModel: ['5p1vj8r'],
         fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_t5p1vj8r'}, {modelID: 'TS0601', manufacturerName: '_TZE200_uebojraa'}],
@@ -2236,7 +2257,7 @@ module.exports = [
         exposes: [e.smoke(), e.battery()],
     },
     {
-        fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_5d3vhjro'}, {modelID: 'TS0601', manufacturerName: '_TZE200_ntcy3xu1'}],
+        fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_5d3vhjro'}],
         model: 'SA12IZL',
         vendor: 'TuYa',
         description: 'Smart smoke alarm',
@@ -2250,6 +2271,35 @@ module.exports = [
             exposes.binary('silence_siren', ea.STATE_SET, true, false).withDescription('Silence the siren')],
         onEvent: tuya.onEventsetTime,
     },
+    {
+        fingerprint: tuya.fingerprint('TS0601', ['_TZE200_lsanae15', '_TZE200_bkkmqmyo', '_TZE200_eaac7dkw']),
+        model: 'TS0601_din_1',
+        vendor: 'TuYa',
+        description: 'Zigbee DIN energy meter',
+        fromZigbee: [tuya.fzDataPoints],
+        toZigbee: [tuya.tzDataPoints],
+        configure: tuya.configureMagicPacket,
+        exposes: [tuya.exposes.switch, e.ac_frequency(), e.energy(), e.power(), e.power_factor(), e.voltage(), e.current()],
+        meta: {
+            tuyaDatapoints: [
+                [1, 'energy', tuya.valueConverter.divideBy100],
+                [6, null, tuya.valueConverter.phaseA], // voltage and current
+                [16, 'state', tuya.valueConverter.onOff],
+                [103, 'power', tuya.valueConverter.raw],
+                [105, 'ac_frequency', tuya.valueConverter.divideBy100],
+                [111, 'power_factor', tuya.valueConverter.divideBy10],
+                // Ignored for now; we don't know what the values mean
+                [109, null, null], // reactive_power in VArh, ignored for now
+                [101, null, null], // total active power (translated from chinese) - same as energy dp 1??
+                [102, null, null], // Reverse active power (translated from chinese), produced power? (e.g. if solar panels are connected)
+                [9, null, null], // Fault - we don't know the possible values here
+                [110, null, null], // total reactive power (translated from chinese) - value is 0.03kvar, we already have kvarh on dp 109
+                [17, null, null], // Alarm set1 - value seems garbage "AAAAAAAAAAAAAABkAAEOAACqAAAAAAAKAAAAAAAA"
+                [18, null, null], // 18 - Alarm set2 - value seems garbage "AAUAZAAFAB4APAAAAAAAAAA="
+            ],
+        },
+        whiteLabel: [{vendor: 'Hiking', model: 'DDS238-2'}, {vendor: 'TuYa', model: 'RC-MCB'}],
+    },
     {
         fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_byzdayie'},
             {modelID: 'TS0601', manufacturerName: '_TZE200_fsb6zw01'},
@@ -2265,19 +2315,6 @@ module.exports = [
         },
         exposes: [e.switch().setAccess('state', ea.STATE_SET), e.voltage(), e.power(), e.current(), e.energy()],
     },
-    {
-        fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_bkkmqmyo'}],
-        model: 'DDS238-2',
-        vendor: 'TuYa',
-        description: 'Zigbee smart energy meter',
-        fromZigbee: [fzLocal.tuya_dinrail_switch2],
-        toZigbee: [tz.tuya_switch_state],
-        configure: async (device, coordinatorEndpoint, logger) => {
-            const endpoint = device.getEndpoint(1);
-            await reporting.bind(endpoint, coordinatorEndpoint, ['genBasic']);
-        },
-        exposes: [e.switch().setAccess('state', ea.STATE_SET), e.energy(), e.power()],
-    },
     {
         fingerprint: [{modelID: 'TS1101', manufacturerName: '_TZ3000_xfs39dbf'}],
         model: 'TS1101_dimmer_module_1ch',

package/devices/xiaomi.js

@@ -1419,7 +1419,7 @@ module.exports = [
             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, ['']).withDescription('Starts the self-test process (checking the indicator ' +
+            exposes.enum('selftest', ea.SET, ['selftest']).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('buzzer', ea.SET, ['mute', 'alarm']).withDescription('The buzzer can be muted and alarmed manually. ' +
@@ -1459,7 +1459,7 @@ module.exports = [
         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_GET).withUnit('dB/m').withDescription('Value of smoke concentration in dB/m'),
-            exposes.enum('selftest', ea.SET, ['']).withDescription('Starts the self-test process (checking the indicator ' +
+            exposes.enum('selftest', ea.SET, ['selftest']).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('buzzer', ea.SET, ['mute', 'alarm']).withDescription('The buzzer can be muted and alarmed manually. ' +

package/devices/ynoa.js

@@ -6,6 +6,13 @@ const e = exposes.presets;
 const extend = require('..//lib/extend');
 
 module.exports = [
+    {
+        zigbeeModel: ['ZBT-CCTLight-GU100001'],
+        model: '8718801528273',
+        vendor: 'Ynoa',
+        description: 'Smart LED GU10 CCT',
+        extend: extend.light_onoff_brightness_colortemp({colorTempRange: [153, 454]}),
+    },
     {
         zigbeeModel: ['ZBT-DIMSwitch-D0000'],
         model: '8718801528334',

package/lib/tuya.js

@@ -1145,6 +1145,7 @@ const tuyaExposes = {
         'min_brightness', ea.STATE_SET).setAccess('max_brightness', ea.STATE_SET),
     countdown: exposes.numeric('countdown', ea.STATE_SET).withValueMin(0).withValueMax(43200).withValueStep(1).withUnit('s')
         .withDescription('Countdown to turn device off after a certain time'),
+    switch: e.switch().setAccess('state', ea.STATE_SET),
 };
 
 const skip = {
@@ -1195,10 +1196,19 @@ const valueConverter = {
     onOff: valueConverterBasic.lookup({'ON': true, 'OFF': false}),
     powerOnBehavior: valueConverterBasic.lookup({'off': 0, 'on': 1, 'previous': 2}),
     lightType: valueConverterBasic.lookup({'led': 0, 'incandescent': 1, 'halogen': 2}),
-    countdown: valueConverterBasic.raw(),
+    countdown: valueConverterBasic.raw,
     scale0_254to0_1000: valueConverterBasic.scale(0, 254, 0, 1000),
     scale0_1to0_1000: valueConverterBasic.scale(0, 1, 0, 1000),
     divideBy100: valueConverterBasic.divideBy(100),
+    divideBy10: valueConverterBasic.divideBy(10),
+    raw: valueConverterBasic.raw(),
+    phaseA: {
+        from: (v) => {
+            const buffer = Buffer.from(v, 'base64');
+            return {voltage: (buffer[14] | buffer[13] << 8) / 10, current: (buffer[12] | buffer[11] << 8) / 1000};
+        },
+    },
+    true0ElseFalse: {from: (v) => v === 0},
 };
 
 const tzDataPoints = {
@@ -1234,7 +1244,7 @@ const fzDataPoints = {
     cluster: 'manuSpecificTuya',
     type: ['commandDataResponse', 'commandDataReport'],
     convert: (model, msg, publish, options, meta) => {
-        const result = {};
+        let result = {};
         if (!model.meta || !model.meta.tuyaDatapoints) throw new Error('No datapoints map defined');
         const datapoints = model.meta.tuyaDatapoints;
         for (const dpValue of msg.data.dpValues) {
@@ -1242,7 +1252,11 @@ const fzDataPoints = {
             const dpEntry = datapoints.find((d) => d[0] === dpId);
             if (dpEntry) {
                 const value = getDataValue(dpValue);
-                result[dpEntry[1]] = dpEntry[2].from(value);
+                if (dpEntry[1]) {
+                    result[dpEntry[1]] = dpEntry[2].from(value);
+                } else if (dpEntry[2]) {
+                    result = {...result, ...dpEntry[2].from(value)};
+                }
             } else {
                 meta.logger.warn(`Datapoint ${dpId} not defined for '${meta.device.manufacturerName}' ` +
                     `with data ${JSON.stringify(dpValue)}`);
@@ -1257,8 +1271,8 @@ module.exports = {
     skip,
     configureMagicPacket,
     fingerprint,
-    valueConverterBasic,
     valueConverter,
+    valueConverterBasic,
     tzDataPoints,
     fzDataPoints,
     sendDataPoint,

package/lib/utils.js

@@ -121,10 +121,12 @@ function postfixWithEndpointName(value, msg, definition, meta) {
     if (definition.meta && definition.meta.multiEndpoint) {
         const endpointName = definition.hasOwnProperty('endpoint') ?
             getKey(definition.endpoint(meta.device), msg.endpoint.ID) : msg.endpoint.ID;
-        return `${value}_${endpointName}`;
-    } else {
-        return value;
+
+        // NOTE: endpointName can be undefined if we have a definition.endpoint and the endpoint is
+        //       not listed.
+        if (endpointName) return `${value}_${endpointName}`;
     }
+    return value;
 }
 
 function getKey(object, value, fallback, convertTo) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zigbee-herdsman-converters",
-  "version": "14.0.635",
+  "version": "14.0.637",
   "description": "Collection of device converters to be used with zigbee-herdsman",
   "main": "index.js",
   "files": [
@@ -38,7 +38,7 @@
     "buffer-crc32": "^0.2.13",
     "https-proxy-agent": "^5.0.1",
     "tar-stream": "^2.2.0",
-    "zigbee-herdsman": "^0.14.62"
+    "zigbee-herdsman": "^0.14.63"
   },
   "devDependencies": {
     "eslint": "*",