zigbee-herdsman-converters 14.0.673 → 14.0.675

package/devices/develco.js

@@ -638,7 +638,8 @@ module.exports = [
                 ['electricity', 'gas', 'water', 'kamstrup-kmp', 'linky', 'IEC62056-21', 'DSMR-2.3', 'DSMR-4.0'])
                 .withDescription('Operating mode/probe'),
             exposes.numeric('current_summation', ea.SET)
-                .withDescription('Current summation value sent to the display. e.g. 570 = 0,570 kWh').withValueMin(0).withValueMax(10000),
+                .withDescription('Current summation value sent to the display. e.g. 570 = 0,570 kWh').withValueMin(0)
+                .withValueMax(268435455),
             exposes.binary('check_meter', ea.STATE, true, false)
                 .withDescription('Is true if communication problem with meter is experienced'),
         ],

package/devices/ledvance.js

@@ -66,6 +66,14 @@ module.exports = [
         extend: extend.ledvance.light_onoff_brightness_colortemp_color({colorTempRange: [153, 370]}),
         ota: ota.ledvance,
     },
+    {
+        zigbeeModel: ['PAR16 RGBW T'],
+        model: '4058075729186',
+        vendor: 'LEDVANCE',
+        description: 'SMART+ Spot PAR16 28 GU10 Multicolor',
+        extend: extend.ledvance.light_onoff_brightness_colortemp_color({colorTempRange: [153, 370]}),
+        ota: ota.ledvance,
+    },
     {
         zigbeeModel: ['PAR16S TW'],
         model: 'AC33905',
@@ -170,6 +178,14 @@ module.exports = [
         extend: extend.ledvance.light_onoff_brightness_colortemp({colorTempRange: [153, 370]}),
         ota: ota.ledvance,
     },
+    {
+        zigbeeModel: ['P40 TW T'],
+        model: '4058075729124',
+        vendor: 'LEDVANCE',
+        description: 'SMART+ CL P40 E14 Tunable white',
+        extend: extend.ledvance.light_onoff_brightness_colortemp({colorTempRange: [153, 370]}),
+        ota: ota.ledvance,
+    },
     {
         zigbeeModel: ['CLA60 RGBW JP'],
         model: 'SMARTZBA60RGBW',
@@ -255,6 +271,19 @@ module.exports = [
             await reporting.onOff(endpoint);
         },
     },
+    {
+        zigbeeModel: ['PLUG UK T'],
+        model: '4058075729285',
+        vendor: 'LEDVANCE',
+        description: 'SMART+ Plug UK',
+        extend: extend.switch(),
+        ota: ota.ledvance,
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff']);
+            await reporting.onOff(endpoint);
+        },
+    },
     {
         zigbeeModel: ['PLUG OUTDOOR EU T'],
         model: '4058075729308',

package/devices/lidl.js

@@ -395,10 +395,13 @@ module.exports = [
         },
     },
     {
-        fingerprint: [{modelID: 'TS011F', manufacturerName: '_TZ3000_ynmowqk2'}],
-        model: 'HG08673-FR',
+        fingerprint: [
+            {modelID: 'TS011F', manufacturerName: '_TZ3000_j1v25l17'}, // EU
+            {modelID: 'TS011F', manufacturerName: '_TZ3000_ynmowqk2'}, // FR
+        ],
+        model: 'HG08673',
         vendor: 'Lidl',
-        description: 'Silvercrest smart plug FR with power monitoring',
+        description: 'Silvercrest smart plug with power monitoring (EU, FR)',
         ota: ota.zigbeeOTA,
         fromZigbee: [fz.on_off, fzLocal.electrical_measurement_skip_duplicate, fzLocal.metering_skip_duplicate, fz.ignore_basic_report,
             fz.tuya_switch_power_outage_memory, fz.ts011f_plug_indicator_mode, fz.ts011f_plug_child_mode],

package/devices/lonsonho.js

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

package/devices/owon.js

@@ -7,6 +7,15 @@ const e = exposes.presets;
 const ea = exposes.access;
 
 const fzLocal = {
+    temperature: {
+        ...fz.temperature,
+        convert: (model, msg, publish, options, meta) => {
+            // https://github.com/Koenkk/zigbee2mqtt/issues/15173
+            if (msg.data.measuredValue < 32770) {
+                return fz.temperature.convert(model, msg, publish, options, meta);
+            }
+        },
+    },
     PC321_metering: {
         cluster: 'seMetering',
         type: ['attributeReport', 'readResponse'],
@@ -76,6 +85,7 @@ const fzLocal = {
         },
     },
 };
+
 module.exports = [
     {
         zigbeeModel: ['WSP404'],
@@ -177,7 +187,7 @@ module.exports = [
         model: 'THS317-ET',
         vendor: 'OWON',
         description: 'Temperature sensor',
-        fromZigbee: [fz.temperature, fz.battery],
+        fromZigbee: [fzLocal.temperature, fz.battery],
         toZigbee: [],
         exposes: [e.battery(), e.temperature()],
         configure: async (device, coordinatorEndpoint, logger) => {
@@ -280,4 +290,19 @@ module.exports = [
             await endpoint2.read('msOccupancySensing', ['occupancy']);
         },
     },
+    {
+        zigbeeModel: ['PIR323-PTH'],
+        model: 'PIR323-PTH',
+        vendor: 'OWON',
+        description: 'Multi-sensor',
+        fromZigbee: [fz.battery, fz.ignore_basic_report, fz.ias_occupancy_alarm_1, fz.temperature, fz.humidity, fz.occupancy_timeout],
+        toZigbee: [],
+        exposes: [e.occupancy(), e.battery_low(), e.temperature(), e.humidity()],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(2);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['msTemperatureMeasurement', 'msRelativeHumidity']);
+            device.powerSource = 'Battery';
+            device.save();
+        },
+    },
 ];

package/devices/philips.js

@@ -742,6 +742,13 @@ module.exports = [
         description: 'Hue White and Color Ambiance BR30 with bluetooth',
         extend: hueExtend.light_onoff_brightness_colortemp_color(),
     },
+    {
+        zigbeeModel: ['LCB002'],
+        model: '046677577957',
+        vendor: 'Philips',
+        description: 'Hue White and Color Ambiance BR30 with bluetooth',
+        extend: hueExtend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 500]}),
+    },
     {
         zigbeeModel: ['LWB004'],
         model: '433714',
@@ -2448,6 +2455,13 @@ module.exports = [
         description: 'Hue Play gradient lightstrip 65',
         extend: hueExtend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 500]}),
     },
+    {
+        zigbeeModel: ['LCX003'],
+        model: '929002422901',
+        vendor: 'Philips',
+        description: 'Hue Play gradient lightstrip 75',
+        extend: hueExtend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 500]}),
+    },
     {
         zigbeeModel: ['929003099301'],
         model: '929003099301',

package/devices/sinope.js

@@ -187,7 +187,7 @@ module.exports = [
             } catch (error) {/* Not all support this */}
 
             try {
-                await endpoint.read('haElectricalMeasurement', ['acPowerMultiplier']);
+                await endpoint.read('haElectricalMeasurement', ['acPowerMultiplier', 'acPowerDivisor']);
                 await reporting.activePower(endpoint, {min: 10, max: 305, change: 1}); // divider 1: 1W
             } catch (error) {
                 endpoint.saveClusterAttributeKeyValue('haElectricalMeasurement', {'acPowerMultiplier': 1, 'acPowerDivisor': 1});

package/devices/third_reality.js

@@ -75,6 +75,7 @@ module.exports = [
         description: 'Wireless motion sensor',
         fromZigbee: [fz.ias_occupancy_alarm_1, fz.battery],
         toZigbee: [],
+        ota: ota.zigbeeOTA,
         exposes: [e.occupancy(), e.battery_low(), e.battery(), e.battery_voltage()],
         configure: async (device, coordinatorEndpoint, logger) => {
             device.powerSource = 'Battery';
@@ -88,6 +89,7 @@ module.exports = [
         description: 'Door sensor',
         fromZigbee: [fz.ias_contact_alarm_1, fz.battery],
         toZigbee: [],
+        ota: ota.zigbeeOTA,
         meta: {battery: {dontDividePercentage: true}},
         exposes: [e.contact(), e.battery_low(), e.battery(), e.battery_voltage()],
         configure: async (device, coordinatorEndpoint, logger) => {
@@ -115,6 +117,7 @@ module.exports = [
         fromZigbee: [fz.cover_position_tilt, fz.battery],
         toZigbee: [tz.cover_state, tz.cover_position_tilt],
         meta: {battery: {dontDividePercentage: false}},
+        ota: ota.zigbeeOTA,
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
             await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg', 'closuresWindowCovering']);
@@ -132,6 +135,7 @@ module.exports = [
         description: 'Smart button',
         fromZigbee: [fz.battery, fz.itcmdr_clicks],
         toZigbee: [],
+        ota: ota.zigbeeOTA,
         exposes: [e.battery(), e.battery_low(), e.battery_voltage(), e.action(['single', 'double', 'long'])],
         configure: async (device, coordinatorEndpoint, logger) => {
             device.powerSource = 'Battery';
@@ -146,5 +150,6 @@ module.exports = [
         fromZigbee: [fz.battery, fz.temperature, fz.humidity],
         toZigbee: [],
         exposes: [e.battery(), e.temperature(), e.humidity(), e.battery_voltage()],
+        ota: ota.zigbeeOTA,
     },
 ];

package/devices/tuya.js

@@ -25,6 +25,50 @@ const TS011Fplugs = ['_TZ3000_5f43h46b', '_TZ3000_cphmq0q7', '_TZ3000_dpo1ysak',
     '_TZ3000_rdfh8cfs', '_TZ3000_yujkchbz', '_TZ3000_fgwhjm9j', '_TZ3000_qeuvnohg', '_TZ3000_rul9yxcc'];
 
 const tzLocal = {
+    TS110E_options: {
+        key: ['min_brightness', 'max_brightness', 'light_type'],
+        convertSet: async (entity, key, value, meta) => {
+            let payload = null;
+            if (key === 'min_brightness' || key == 'max_brightness') {
+                const id = key === 'min_brightness' ? 64515 : 64516;
+                payload = {[id]: {value: utils.mapNumberRange(value, 1, 255, 0, 1000), type: 0x21}};
+            } else if (key === 'light_type') {
+                const lookup = {led: 0, incandescent: 1, halogen: 2};
+                payload = {64514: {value: lookup[value], type: 0x20}};
+            }
+            await entity.write('genLevelCtrl', payload, utils.getOptions(meta.mapped, entity));
+        },
+        convertGet: async (entity, key, meta) => {
+            let id = null;
+            if (key === 'min_brightness') id = 64515;
+            if (key === 'max_brightness') id = 64516;
+            if (key === 'light_type') id = 64514;
+            await entity.read('genLevelCtrl', [id]);
+        },
+    },
+    TS110E_onoff_brightness: {
+        key: ['state', 'brightness'],
+        options: [],
+        convertSet: async (entity, key, value, meta) => {
+            const {message, state} = meta;
+            if (message.state === 'OFF' || (message.hasOwnProperty('state') && !message.hasOwnProperty('brightness'))) {
+                return await tz.on_off.convertSet(entity, key, value, meta);
+            } else if (message.hasOwnProperty('brightness')) {
+                // set brightness
+                if (state.state === 'OFF') {
+                    await entity.command('genOnOff', 'on', {}, utils.getOptions(meta.mapped, entity));
+                }
+
+                const level = utils.mapNumberRange(message.brightness, 0, 254, 0, 1000);
+                await entity.command('genLevelCtrl', 'moveToLevelTuya', {level, transtime: 100}, utils.getOptions(meta.mapped, entity));
+                return {state: {state: 'ON', brightness: message.brightness}};
+            }
+        },
+        convertGet: async (entity, key, meta) => {
+            if (key === 'state') await tz.on_off.convertGet(entity, key, meta);
+            if (key === 'brightness') await entity.read('genLevelCtrl', [61440]);
+        },
+    },
     SA12IZL_silence_siren: {
         key: ['silence_siren'],
         convertSet: async (entity, key, value, meta) => {
@@ -291,6 +335,27 @@ const tzLocal = {
 };
 
 const fzLocal = {
+    TS110E: {
+        cluster: 'genLevelCtrl',
+        type: ['attributeReport', 'readResponse'],
+        convert: (model, msg, publish, options, meta) => {
+            const result = {};
+            if (msg.data.hasOwnProperty('64515')) {
+                result['min_brightness'] = utils.mapNumberRange(msg.data['64515'], 0, 1000, 1, 255);
+            }
+            if (msg.data.hasOwnProperty('64516')) {
+                result['max_brightness'] = utils.mapNumberRange(msg.data['64516'], 0, 1000, 1, 255);
+            }
+            if (msg.data.hasOwnProperty('64514')) {
+                const lookup = {0: 'led', 1: 'incandescent', 2: 'halogen'};
+                result['light_type'] = lookup[msg.data['64514']];
+            }
+            if (msg.data.hasOwnProperty('61440')) {
+                result['brightness'] = utils.mapNumberRange(msg.data['61440'], 0, 1000, 0, 254);
+            }
+            return result;
+        },
+    },
     SA12IZL: {
         cluster: 'manuSpecificTuya',
         type: ['commandDataResponse', 'commandDataReport'],
@@ -826,7 +891,9 @@ module.exports = [
         fromZigbee: extend.switch().fromZigbee.concat([fz.moes_power_on_behavior, fz.tuya_switch_type]),
         exposes: extend.switch().exposes.concat([e.power_on_behavior(), e.switch_type_2()]),
         configure: async (device, coordinatorEndpoint, logger) => {
-            await reporting.bind(device.getEndpoint(1), coordinatorEndpoint, ['genOnOff']);
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff']);
+            await reporting.onOff(endpoint);
         },
     },
     {
@@ -1399,7 +1466,8 @@ module.exports = [
         fingerprint: [{modelID: 'TS0215A', manufacturerName: '_TZ3000_4fsgukof'},
             {modelID: 'TS0215A', manufacturerName: '_TZ3000_wr2ucaj9'},
             {modelID: 'TS0215A', manufacturerName: '_TZ3000_zsh6uat3'},
-            {modelID: 'TS0215A', manufacturerName: '_TZ3000_tj4pwzzm'}],
+            {modelID: 'TS0215A', manufacturerName: '_TZ3000_tj4pwzzm'},
+            {modelID: 'TS0215A', manufacturerName: '_TZ3000_2izubafb'}],
         model: 'TS0215A_sos',
         vendor: 'TuYa',
         description: 'SOS button',
@@ -3335,8 +3403,7 @@ module.exports = [
         exposes: [e.illuminance_lux(), e.brightness_state()],
     },
     {
-        fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_kltffuzl'}, {modelID: 'TS0601', manufacturerName: '_TZE200_fwoorn8y'},
-            {modelID: 'TS0601', manufacturerName: '_TZE200_pay2byax'}],
+        fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_kltffuzl'}, {modelID: 'TS0601', manufacturerName: '_TZE200_fwoorn8y'}],
         model: 'TM001-ZA/TM081',
         vendor: 'TuYa',
         description: 'Door and window sensor',
@@ -3418,18 +3485,7 @@ module.exports = [
         ],
     },
     {
-        fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_qoy0ekbd'},
-            {modelID: 'TS0601', manufacturerName: '_TZE200_znbl8dj5'}],
-        model: 'CX-0726',
-        vendor: 'TuYa',
-        description: 'Temperature & humidity LCD sensor',
-        fromZigbee: [fz.tuya_temperature_humidity_sensor, fz.ignore_tuya_set_time],
-        toZigbee: [],
-        onEvent: tuya.onEventSetLocalTime,
-        exposes: [e.temperature(), e.humidity(), e.battery()],
-    },
-    {
-        fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_3towulqd'}, {modelID: 'TS0601', manufacturerName: '_TZE200_1ibpyhdc'}],
+        fingerprint: tuya.fingerprint('TS0601', ['_TZE200_3towulqd', '_TZE200_1ibpyhdc', '_TZE200_bh3n6gk8']),
         model: 'ZG-204ZL',
         vendor: 'TuYa',
         description: 'Luminance motion sensor',
@@ -3550,4 +3606,112 @@ module.exports = [
                 .withDescription('Turns the onboard LED on or off'),
         ],
     },
+    {
+        fingerprint: tuya.fingerprint('TS0601', ['_TZE200_qoy0ekbd', '_TZE200_znbl8dj5', '_TZE200_a8sdabtg']),
+        model: 'ZG-227ZL',
+        vendor: 'TuYa',
+        description: 'Temperature & humidity LCD sensor',
+        fromZigbee: [tuya.fzDataPoints],
+        toZigbee: [tuya.tzDataPoints],
+        configure: tuya.configureMagicPacket,
+        exposes: [e.temperature(), e.humidity(), tuya.exposes.temperatureUnit(), tuya.exposes.temperatureCalibration(),
+            tuya.exposes.humidityCalibration(), e.battery()],
+        meta: {
+            tuyaDatapoints: [
+                [1, 'temperature', tuya.valueConverter.divideBy10],
+                [2, 'humidity', tuya.valueConverter.raw],
+                [4, 'battery', tuya.valueConverter.raw],
+                [9, 'temperature_unit', tuya.valueConverter.temperatureUnit],
+                [23, 'temperature_calibration', tuya.valueConverter.divideBy10],
+                [24, 'humidity_calibration', tuya.valueConverter.raw],
+            ],
+        },
+    },
+    {
+        fingerprint: tuya.fingerprint('TS0601', ['_TZE200_n8dljorx', '_TZE200_pay2byax']),
+        model: 'ZG-102ZL',
+        vendor: 'TuYa',
+        description: 'Luminance door sensor',
+        fromZigbee: [tuya.fzDataPoints],
+        toZigbee: [tuya.tzDataPoints],
+        configure: tuya.configureMagicPacket,
+        exposes: [e.contact(), e.illuminance().withUnit('lx'), e.battery()],
+        meta: {
+            tuyaDatapoints: [
+                [1, 'contact', tuya.valueConverter.inverse],
+                [101, 'illuminance', tuya.valueConverter.raw],
+                [2, 'battery', tuya.valueConverter.raw],
+            ],
+        },
+    },
+    {
+        fingerprint: tuya.fingerprint('TS0601', ['_TZE200_8isdky6j']),
+        model: 'ZG-225Z',
+        vendor: 'TuYa',
+        description: 'Gas sensor',
+        fromZigbee: [tuya.fzDataPoints],
+        toZigbee: [tuya.tzDataPoints],
+        configure: tuya.configureMagicPacket,
+        exposes: [e.gas(), tuya.exposes.gasValue()],
+        meta: {
+            tuyaDatapoints: [
+                [1, 'gas', tuya.valueConverter.true0ElseFalse],
+                [2, 'gas_value', tuya.valueConverter.raw],
+            ],
+        },
+    },
+    {
+        fingerprint: tuya.fingerprint('TS110E', ['_TZ3210_ngqk6jia']),
+        model: 'TS110E',
+        vendor: 'TuYa',
+        description: '1 channel dimmer',
+        whiteLabel: [{vendor: 'RTX', model: 'QS-Zigbee-D02-TRIAC-LN'}],
+        fromZigbee: [fzLocal.TS110E, fz.moes_power_on_behavior, fz.on_off],
+        toZigbee: [tzLocal.TS110E_onoff_brightness, tzLocal.TS110E_options, tz.moes_power_on_behavior, tz.light_brightness_move],
+        exposes: [
+            e.light_brightness().withMinBrightness().withMaxBrightness(),
+            tuya.exposes.lightType().withAccess(ea.ALL), tuya.exposes.powerOnBehavior().withAccess(ea.ALL)],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'genLevelCtrl']);
+            await reporting.onOff(endpoint);
+        },
+    },
+    {
+        fingerprint: tuya.fingerprint('TS0601', ['_TZE200_nslr42tt']),
+        model: 'TS0601_3_phase_clamp_meter',
+        vendor: 'TuYa',
+        description: '3-phase clamp power meter',
+        fromZigbee: [tuya.fzDataPoints],
+        toZigbee: [tuya.tzDataPoints],
+        configure: tuya.configureMagicPacket,
+        whiteLabel: [{vendor: 'MatSeePlus', model: 'PC321-Z-TY'}],
+        exposes: [
+            e.ac_frequency(), e.temperature(), e.current(), e.power(), e.energy(),
+            tuya.exposes.energyWithPhase('a'), tuya.exposes.energyWithPhase('b'), tuya.exposes.energyWithPhase('c'),
+            tuya.exposes.voltageWithPhase('a'), tuya.exposes.voltageWithPhase('b'), tuya.exposes.voltageWithPhase('c'),
+            tuya.exposes.powerWithPhase('a'), tuya.exposes.powerWithPhase('b'), tuya.exposes.powerWithPhase('c'),
+            tuya.exposes.currentWithPhase('a'), tuya.exposes.currentWithPhase('b'), tuya.exposes.currentWithPhase('c'),
+            tuya.exposes.powerFactorWithPhase('a'), tuya.exposes.powerFactorWithPhase('b'), tuya.exposes.powerFactorWithPhase('c'),
+        ],
+        meta: {
+            tuyaDatapoints: [
+                [132, 'ac_frequency', tuya.valueConverter.raw],
+                [133, 'temperature', tuya.valueConverter.divideBy10],
+                [1, 'energy', tuya.valueConverter.divideBy100],
+                [101, 'energy_a', tuya.valueConverter.divideBy1000],
+                [111, 'energy_b', tuya.valueConverter.divideBy1000],
+                [121, 'energy_c', tuya.valueConverter.divideBy1000],
+                [131, 'current', tuya.valueConverter.divideBy1000],
+                [9, 'power', tuya.valueConverter.raw],
+                [102, 'power_factor_a', tuya.valueConverter.raw],
+                [112, 'power_factor_b', tuya.valueConverter.raw],
+                [122, 'power_factor_c', tuya.valueConverter.raw],
+                [6, null, tuya.valueConverter.phaseVariant2WithPhase('a')],
+                [7, null, tuya.valueConverter.phaseVariant2WithPhase('b')],
+                [8, null, tuya.valueConverter.phaseVariant2WithPhase('c')],
+                [134, 'device_status', tuya.valueConverter.raw],
+            ],
+        },
+    },
 ];

package/devices/xiaomi.js

@@ -131,7 +131,7 @@ const fzLocal = {
                         break;
                     case 0x041502bc: { // feeding report
                         const report = val.toString();
-                        result['feeding_source'] = {1: 'manual', 2: 'remote'}[parseInt(report.slice(0, 2))];
+                        result['feeding_source'] = {0: 'schedule', 1: 'manual', 2: 'remote'}[parseInt(report.slice(0, 2))];
                         result['feeding_size'] = parseInt(report.slice(3, 4));
                         break;
                     }
@@ -2572,6 +2572,7 @@ module.exports = [
             const endpoint = device.getEndpoint(1);
             await endpoint.read('aqaraOpple', [0x040a], {manufacturerCode: 0x115f});
         },
+        ota: ota.zigbeeOTA,
     },
     {
         zigbeeModel: ['aqara.feeder.acn001'],
@@ -2582,7 +2583,7 @@ module.exports = [
         toZigbee: [tzLocal.aqara_feeder],
         exposes: [
             exposes.enum('feed', ea.STATE_SET, ['START']).withDescription('Start feeding'),
-            exposes.enum('feeding_source', ea.STATE, ['manual', 'remote']).withDescription('Feeding source'),
+            exposes.enum('feeding_source', ea.STATE, ['schedule', 'manual', 'remote']).withDescription('Feeding source'),
             exposes.numeric('feeding_size', ea.STATE).withDescription('Feeding size').withUnit('portion'),
             exposes.numeric('portions_per_day', ea.STATE).withDescription('Portions per day'),
             exposes.numeric('weight_per_day', ea.STATE).withDescription('Weight per day').withUnit('g'),

package/lib/tuya.js

@@ -246,22 +246,26 @@ function convertDecimalValueTo2ByteHexArray(value) {
 async function onEventMeasurementPoll(type, data, device, options, electricalMeasurement=true, metering=false) {
     const endpoint = device.getEndpoint(1);
     if (type === 'stop') {
-        clearInterval(globalStore.getValue(device, 'interval'));
-        globalStore.clearValue(device, 'interval');
-    } else if (!globalStore.hasValue(device, 'interval')) {
+        clearTimeout(globalStore.getValue(device, 'measurement_poll'));
+        globalStore.clearValue(device, 'measurement_poll');
+    } else if (!globalStore.hasValue(device, 'measurement_poll')) {
         const seconds = options && options.measurement_poll_interval ? options.measurement_poll_interval : 60;
         if (seconds === -1) return;
-        const interval = setInterval(async () => {
-            try {
-                if (electricalMeasurement) {
-                    await endpoint.read('haElectricalMeasurement', ['rmsVoltage', 'rmsCurrent', 'activePower']);
-                }
-                if (metering) {
-                    await endpoint.read('seMetering', ['currentSummDelivered']);
-                }
-            } catch (error) {/* Do nothing*/}
-        }, seconds*1000);
-        globalStore.putValue(device, 'interval', interval);
+        const setTimer = () => {
+            const timer = setTimeout(async () => {
+                try {
+                    if (electricalMeasurement) {
+                        await endpoint.read('haElectricalMeasurement', ['rmsVoltage', 'rmsCurrent', 'activePower']);
+                    }
+                    if (metering) {
+                        await endpoint.read('seMetering', ['currentSummDelivered']);
+                    }
+                } catch (error) {/* Do nothing*/}
+                setTimer();
+            }, seconds * 1000);
+            globalStore.putValue(device, 'measurement_poll', timer);
+        };
+        setTimer();
     }
 }
 
@@ -1170,6 +1174,22 @@ const tuyaExposes = {
     errorStatus: () => exposes.numeric('error_status', ea.STATE).withDescription('Error status'),
     scheduleAllDays: (access, format) => ['monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday']
         .map((day) => exposes.text(`schedule_${day}`, access).withDescription(`Schedule for ${day}, format: "${format}"`)),
+    temperatureUnit: () => exposes.enum('temperature_unit', ea.STATE_SET, ['celsius', 'fahrenheit']).withDescription('Temperature unit'),
+    temperatureCalibration: () => exposes.numeric('temperature_calibration', ea.STATE_SET).withValueMin(-2.0).withValueMax(2.0)
+        .withValueStep(0.1).withUnit('°C').withDescription('Temperature calibration'),
+    humidityCalibration: () => exposes.numeric('humidity_calibration', ea.STATE_SET).withValueMin(-30).withValueMax(30)
+        .withValueStep(1).withUnit('%').withDescription('Humidity calibration'),
+    gasValue: () => exposes.numeric('gas_value', ea.STATE).withDescription('Measured gas concentration').withUnit('ppm'),
+    energyWithPhase: (phase) => exposes.numeric(`energy_${phase}`, ea.STATE).withUnit('kWh')
+        .withDescription(`Sum of consumed energy (phase ${phase.toUpperCase()})`),
+    voltageWithPhase: (phase) => exposes.numeric(`voltage_${phase}`, ea.STATE).withUnit('V')
+        .withDescription(`Measured electrical potential value (phase ${phase.toUpperCase()})`),
+    powerWithPhase: (phase) => exposes.numeric(`power_${phase}`, ea.STATE).withUnit('W')
+        .withDescription(`Instantaneous measured power (phase ${phase.toUpperCase()})`),
+    currentWithPhase: (phase) => exposes.numeric(`current_${phase}`, ea.STATE).withUnit('A')
+        .withDescription(`Instantaneous measured electrical current (phase ${phase.toUpperCase()})`),
+    powerFactorWithPhase: (phase) => exposes.numeric(`power_factor_${phase}`, ea.STATE).withUnit('%')
+        .withDescription(`Instantaneous measured power factor (phase ${phase.toUpperCase()})`),
 };
 
 const skip = {
@@ -1255,7 +1275,9 @@ const valueConverter = {
     scale0_254to0_1000: valueConverterBasic.scale(0, 254, 0, 1000),
     scale0_1to0_1000: valueConverterBasic.scale(0, 1, 0, 1000),
     divideBy100: valueConverterBasic.divideBy(100),
+    temperatureUnit: valueConverterBasic.lookup({'celsius': 0, 'fahrenheit': 1}),
     divideBy10: valueConverterBasic.divideBy(10),
+    divideBy1000: valueConverterBasic.divideBy(1000),
     raw: valueConverterBasic.raw(),
     phaseVariant1: {
         from: (v) => {
@@ -1269,6 +1291,17 @@ const valueConverter = {
             return {voltage: (buf[1] | buf[0] << 8) / 10, current: (buf[4] | buf[3] << 8) / 1000, power: (buf[7] | buf[6] << 8)};
         },
     },
+    phaseVariant2WithPhase: (phase) => {
+        return {
+            from: (v) => {
+                const buf = Buffer.from(v, 'base64');
+                return {
+                    [`voltage_${phase}`]: (buf[1] | buf[0] << 8) / 10,
+                    [`current_${phase}`]: (buf[4] | buf[3] << 8) / 1000,
+                    [`power_${phase}`]: (buf[7] | buf[6] << 8)};
+            },
+        };
+    },
     threshold: {
         from: (v) => {
             const buffer = Buffer.from(v, 'base64');
@@ -1452,11 +1485,13 @@ const valueConverter = {
             return {system_mode: v === false ? 'heat' : 'off', heating_stop: v === false ? 'OFF' : 'ON'};
         },
     },
+    inverse: {to: (v) => !v, from: (v) => !v},
     onOffNotStrict: {from: (v) => v ? 'ON' : 'OFF', to: (v) => v === 'ON'},
 };
 
 const tzDataPoints = {
     key: [
+        'temperature_unit', 'temperature_calibration', 'humidity_calibration',
         'state', 'brightness', 'min_brightness', 'max_brightness', 'power_on_behavior',
         'countdown', 'light_type', 'silence', 'self_test', 'child_lock', 'open_window', 'open_window_temperature', 'frost_protection',
         'system_mode', 'heating_stop', 'current_heating_setpoint', 'local_temperature_calibration', 'preset', 'boost_timeset_countdown',

package/package.json

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