zigbee-herdsman-converters 14.0.674 → 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/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

@@ -2455,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';

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);
         },
     },
     {
@@ -3593,4 +3660,58 @@ module.exports = [
             ],
         },
     },
+    {
+        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

@@ -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'],

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();
     }
 }
 
@@ -1176,6 +1180,16 @@ const tuyaExposes = {
     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 = {
@@ -1263,6 +1277,7 @@ const valueConverter = {
     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) => {
@@ -1276,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');

package/package.json

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