zigbee-herdsman-converters 14.0.533 → 14.0.536

package/converters/fromZigbee.js

@@ -5267,7 +5267,7 @@ const converters = {
             const value = tuya.getDataValue(dpValue);
             const state = value ? 'ON' : 'OFF';
             if (multiEndpoint) {
-                const lookup = {1: 'l1', 2: 'l2', 3: 'l3', 4: 'l4'};
+                const lookup = {1: 'l1', 2: 'l2', 3: 'l3', 4: 'l4', 5: 'l5', 6: 'l6'};
                 const endpoint = lookup[dp];
                 if (endpoint in model.endpoint(msg.device)) {
                     return {[`state_${endpoint}`]: state};
@@ -7304,9 +7304,9 @@ const converters = {
             const value = tuya.getDataValue(dpValue);
             switch (dp) {
             case 2:
-                return {illuminance_lux: value.toFixed(0)};
+                return {illuminance_lux: value};
             case 4:
-                return {battery: value.toFixed(1)};
+                return {battery: value};
             case 1:
                 return {battery_low: value.toFixed(1)};
             default:

package/converters/toZigbee.js

@@ -3842,7 +3842,7 @@ const converters = {
     tuya_switch_state: {
         key: ['state'],
         convertSet: async (entity, key, value, meta) => {
-            const lookup = {l1: 1, l2: 2, l3: 3, l4: 4};
+            const lookup = {l1: 1, l2: 2, l3: 3, l4: 4, l5: 5, l6: 6};
             const multiEndpoint = utils.getMetaValue(entity, meta.mapped, 'multiEndpoint', 'allEqual', false);
             const keyid = multiEndpoint ? lookup[meta.endpoint_name] : 1;
             await tuya.sendDataPointBool(entity, keyid, value === 'ON');

package/devices/aubess.js

@@ -0,0 +1,21 @@
+const zosung = require('../lib/zosung');
+const fzZosung = zosung.fzZosung;
+const tzZosung = zosung.tzZosung;
+const ez = zosung.presetsZosung;
+
+module.exports = [
+    {
+        fingerprint: [{modelID: 'TS1201', manufacturerName: '_TZ3290_acv1iuslxi3shaaj'}],
+        model: 'ZXZIR-02',
+        vendor: 'AUBESS',
+        description: 'Universal smart IR remote control',
+        fromZigbee: [
+            fzZosung.zosung_send_ir_code_00, fzZosung.zosung_send_ir_code_01, fzZosung.zosung_send_ir_code_02,
+            fzZosung.zosung_send_ir_code_03, fzZosung.zosung_send_ir_code_04, fzZosung.zosung_send_ir_code_05,
+        ],
+        toZigbee: [
+            tzZosung.zosung_ir_code_to_send, tzZosung.zosung_learn_ir_code,
+        ],
+        exposes: [ez.learn_ir_code(), ez.learned_ir_code(), ez.ir_code_to_send()],
+    },
+];

package/devices/danfoss.js

@@ -88,7 +88,7 @@ module.exports = [
                     'Valve Characteristic Lost'),
             exposes.binary('adaptation_run_settings', ea.ALL, true, false)
                 .withDescription('Automatic adaptation run enabled (the one during the night)'),
-            exposes.enum('adaptation_run_control', ea.ALL, ['initate_adaptation', 'cancel_adaptation'])
+            exposes.enum('adaptation_run_control', ea.ALL, ['none', 'initiate_adaptation', 'cancel_adaptation'])
                 .withDescription('Adaptation run control: Initiate Adaptation Run or Cancel Adaptation Run'),
             exposes.numeric('regulation_setpoint_offset', ea.ALL)
                 .withDescription('Regulation SetPoint Offset in range -2.5°C to 2.5°C in steps of 0.1°C. Value 2.5°C = 25.')

package/devices/gledopto.js

@@ -267,7 +267,7 @@ module.exports = [
         vendor: 'Gledopto',
         ota: ota.zigbeeOTA,
         description: 'Zigbee LED Controller RGB+CCT (pro)',
-        whiteLabel: [{vendor: 'Gledopto', model: 'GL-C-001P'}],
+        whiteLabel: [{vendor: 'Gledopto', model: 'GL-C-001P'}, {vendor: 'Gledopto', model: 'GL-C-002P'}],
         extend: gledoptoExtend.light_onoff_brightness_colortemp_color({colorTempRange: [158, 495], noConfigure: true}),
         meta: {disableDefaultResponse: true},
         configure: async (device, coordinatorEndpoint, logger) => {

package/devices/m/303/274ller_licht.js

@@ -8,7 +8,7 @@ const e = exposes.presets;
 module.exports = [
     {
         zigbeeModel: ['tint-ExtendedColor'],
-        model: '404036/45327',
+        model: '404036/45327/45317',
         vendor: 'Müller Licht',
         description: 'Tint LED white+color',
         extend: extend.light_onoff_brightness_colortemp_color({colorTempRange: [153, 556]}),
@@ -157,18 +157,10 @@ module.exports = [
         toZigbee: [],
     },
     {
-        zigbeeModel: ['tint-ColorTemperature'],
-        model: '404037',
+        zigbeeModel: ['tint-ColorTemperature', 'tint-ColorTemperature2'],
+        model: '404037/404038',
         vendor: 'Müller Licht',
-        description: 'Tint retro filament LED-bulb E27, Edison bulb gold, white+ambiance (1800-6500K), dimmable, 5,5W',
-        extend: extend.light_onoff_brightness_colortemp(),
-        toZigbee: extend.light_onoff_brightness_colortemp().toZigbee.concat([tz.tint_scene]),
-    },
-    {
-        zigbeeModel: ['tint-ColorTemperature2'],
-        model: '404038',
-        vendor: 'Müller Licht',
-        description: 'Tint retro filament LED-bulb E27, Globe bulb gold, white+ambiance (1800-6500K), dimmable, 5,5W',
+        description: 'CCT LED-bulb',
         extend: extend.light_onoff_brightness_colortemp({colorTempRange: [153, 555]}),
         toZigbee: extend.light_onoff_brightness_colortemp().toZigbee.concat([tz.tint_scene]),
     },

package/devices/perenio.js

@@ -207,11 +207,12 @@ module.exports = [
         description: 'Door sensor',
         fromZigbee: [fz.ias_contact_alarm_1, fz.battery, fz.ignore_basic_report, fz.ias_contact_alarm_1_report],
         toZigbee: [],
-        exposes: [e.contact(), e.battery()],
+        exposes: [e.contact(), e.battery(), e.battery_voltage()],
         configure: async (device, coordinatorEndpoint, logger) => {
             const endpoint = device.getEndpoint(1);
             await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg']);
             await reporting.batteryPercentageRemaining(endpoint);
+            await reporting.batteryVoltage(endpoint);
         },
     },
     {

package/devices/somgoms.js

@@ -26,7 +26,7 @@ module.exports = [
         exposes: [e.cover_position().setAccess('position', ea.STATE_SET)],
     },
     {
-        zigbeeModel: ['sbordckq'],
+        fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_sbordckq'}],
         model: 'SM-1CTW-EU',
         vendor: 'Somgoms',
         description: 'Curtain switch',

package/devices/sonoff.js

@@ -164,4 +164,16 @@ module.exports = [
         description: 'Zigbee smart plug',
         extend: extend.switch(),
     },
+    {
+        zigbeeModel: ['S40LITE'],
+        model: 'S40ZBTPB',
+        vendor: 'SONOFF',
+        description: '15A Zigbee smart plug',
+        extend: extend.switch(),
+        fromZigbee: [fz.on_off_skip_duplicate_transaction],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            const endpoint = device.getEndpoint(1);
+            await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff']);
+        },
+    },
 ];

package/devices/sunricher.js

@@ -281,7 +281,8 @@ module.exports = [
         },
     },
     {
-        fingerprint: [{modelID: 'GreenPower_2', ieeeAddr: /^0x00000000010.....$/}],
+        fingerprint: [{modelID: 'GreenPower_2', ieeeAddr: /^0x00000000010.....$/},
+            {modelID: 'GreenPower_2', ieeeAddr: /^0x0000000001b.....$/}],
         model: 'SR-ZGP2801K2-DIM',
         vendor: 'Sunricher',
         description: 'Pushbutton transmitter module',

package/devices/third_reality.js

@@ -73,8 +73,11 @@ module.exports = [
         description: 'Wireless motion sensor',
         fromZigbee: [fz.ias_occupancy_alarm_1, fz.battery],
         toZigbee: [],
-        meta: {battery: {dontDividePercentage: true}},
         exposes: [e.occupancy(), e.battery_low(), e.battery(), e.battery_voltage()],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            device.powerSource = 'Battery';
+            device.save();
+        },
     },
     {
         zigbeeModel: ['3RDS17BZ'],
@@ -85,6 +88,10 @@ module.exports = [
         toZigbee: [],
         meta: {battery: {dontDividePercentage: true}},
         exposes: [e.contact(), e.battery_low(), e.battery(), e.battery_voltage()],
+        configure: async (device, coordinatorEndpoint, logger) => {
+            device.powerSource = 'Battery';
+            device.save();
+        },
     },
     {
         zigbeeModel: ['3RSP019BZ'],

package/devices/tuya.js

@@ -14,7 +14,7 @@ const TS011Fplugs = ['_TZ3000_5f43h46b', '_TZ3000_cphmq0q7', '_TZ3000_dpo1ysak',
     '_TZ3000_jvzvulen', '_TZ3000_mraovvmm', '_TZ3000_nfnmi125', '_TZ3000_ps3dmato', '_TZ3000_w0qqde0g', '_TZ3000_u5u4cakc',
     '_TZ3000_rdtixbnu', '_TZ3000_typdpbpg', '_TZ3000_kx0pris5', '_TZ3000_amdymr7l', '_TZ3000_z1pnpsdo', '_TZ3000_ksw8qtmt',
     '_TZ3000_nzkqcvvs', '_TZ3000_1h2x4akh', '_TZ3000_9vo5icau', '_TZ3000_cehuw1lw', '_TZ3000_ko6v90pg', '_TZ3000_f1bapcit',
-    '_TZ3000_cjrngdr3', '_TZ3000_zloso4jk', '_TZ3000_v4mevirn'];
+    '_TZ3000_cjrngdr3', '_TZ3000_zloso4jk', '_TZ3000_r6buo8ba'];
 
 const tzLocal = {
     TS0504B_color: {
@@ -223,6 +223,7 @@ module.exports = [
     {
         fingerprint: [{modelID: 'TS0001', manufacturerName: '_TZ3000_hktqahrq'}, {manufacturerName: '_TZ3000_hktqahrq'},
             {manufacturerName: '_TZ3000_q6a3tepg'}, {modelID: 'TS000F', manufacturerName: '_TZ3000_m9af2l6g'},
+            {modelID: 'TS000F', manufacturerName: '_TZ3000_mx3vgyea'},
             {modelID: 'TS0001', manufacturerName: '_TZ3000_npzfdcof'},
             {modelID: 'TS0001', manufacturerName: '_TZ3000_5ng23zjs'},
             {modelID: 'TS0001', manufacturerName: '_TZ3000_rmjr4ufz'},

package/devices/zemismart.js

@@ -130,7 +130,7 @@ module.exports = [
             'button_6_hold', 'button_6_single', 'button_6_double'])],
     },
     {
-        fingerprint: [{modelID: 'TS011F', manufacturerName: '_TZ3000_zigisuyh'}],
+        fingerprint: [{modelID: 'TS011F', manufacturerName: '_TZ3000_zigisuyh'}, {modelID: 'TS011F', manufacturerName: '_TZ3000_v4mevirn'}],
         model: 'ZIGBEE-B09-UK',
         vendor: 'Zemismart',
         description: 'Zigbee smart outlet universal socket with USB port',
@@ -189,4 +189,33 @@ module.exports = [
         toZigbee: [tz.tuya_cover_control, tz.tuya_cover_options, tz.tuya_data_point_test],
         exposes: [e.cover_position().setAccess('position', ea.STATE_SET)],
     },
+    {
+        fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_9mahtqtg'}],
+        model: 'TB26-6',
+        vendor: 'Zemismart',
+        description: '6-gang smart wall switch',
+        exposes: [e.switch().withEndpoint('l1').setAccess('state', ea.STATE_SET),
+            e.switch().withEndpoint('l2').setAccess('state', ea.STATE_SET),
+            e.switch().withEndpoint('l3').setAccess('state', ea.STATE_SET),
+            e.switch().withEndpoint('l4').setAccess('state', ea.STATE_SET),
+            e.switch().withEndpoint('l5').setAccess('state', ea.STATE_SET),
+            e.switch().withEndpoint('l6').setAccess('state', ea.STATE_SET)],
+        fromZigbee: [fz.ignore_basic_report, fz.tuya_switch],
+        toZigbee: [tz.tuya_switch_state],
+        meta: {multiEndpoint: true},
+        endpoint: (device) => {
+            return {'l1': 1, 'l2': 1, 'l3': 1, 'l4': 1, 'l5': 1, 'l6': 1};
+        },
+        configure: async (device, coordinatorEndpoint, logger) => {
+            await reporting.bind(device.getEndpoint(1), coordinatorEndpoint, ['genOnOff']);
+            if (device.getEndpoint(2)) await reporting.bind(device.getEndpoint(2), coordinatorEndpoint, ['genOnOff']);
+            if (device.getEndpoint(3)) await reporting.bind(device.getEndpoint(3), coordinatorEndpoint, ['genOnOff']);
+            if (device.getEndpoint(4)) await reporting.bind(device.getEndpoint(4), coordinatorEndpoint, ['genOnOff']);
+            if (device.getEndpoint(5)) await reporting.bind(device.getEndpoint(5), coordinatorEndpoint, ['genOnOff']);
+            if (device.getEndpoint(6)) await reporting.bind(device.getEndpoint(6), coordinatorEndpoint, ['genOnOff']);
+            // Reports itself as battery which is not correct: https://github.com/Koenkk/zigbee2mqtt/issues/6190
+            device.powerSource = 'Mains (single phase)';
+            device.save();
+        },
+    },
 ];

package/lib/constants.js

@@ -105,7 +105,8 @@ const danfossAdaptionRunStatus= {
 };
 
 const danfossAdaptionRunControl = {
-    1: 'initate_adaptation',
+    0: 'none',
+    1: 'initiate_adaptation',
     2: 'cancel_adaptation',
 };
 

package/lib/zosung.js

@@ -0,0 +1,241 @@
+'use strict';
+
+const exposes = require('./exposes');
+const ea = exposes.access;
+
+function nextSeq(entity) {
+    entity.seq = ((entity.seq || -1)+1) % 0x10000;
+    return entity.seq;
+}
+
+function messagesGet(entity, seq) {
+    const info = entity.irMessageInfo;
+    if (info.seq!=seq) {
+        throw new Error(`Unexpected sequence value (expected: ${info.seq} current: ${seq}).`);
+    }
+    return info.data;
+}
+function messagesSet(entity, seq, data) {
+    entity.irMessageInfo={seq: seq, data: data};
+}
+
+function messagesClear(entity, seq) {
+    const info = entity.irMessageInfo;
+    if (info.seq!=seq) {
+        throw new Error(`Unexpected sequence value (expected: ${info.seq} current: ${seq}).`);
+    }
+    delete entity.irMessageInfo;
+}
+
+function calcArrayCrc(values) {
+    return Array.from(values.values()).reduce((a, b)=>a+b)%0x100;
+}
+
+function calcStringCrc(str) {
+    return str.split('').map((x)=>x.charCodeAt(0)).reduce((a, b)=>a+b)%0x100;
+}
+
+
+const fzZosung = {
+    zosung_send_ir_code_01: {
+        cluster: 'zosungIRTransmit',
+        type: ['commandZosungSendIRCode01'],
+        convert: (model, msg, publish, options, meta) => {
+            meta.logger.debug(`"IR-Message-Code01" received (msg:${JSON.stringify(msg.data)})`);
+            const seq = msg.data.seq;
+            const irMsg = messagesGet(msg.endpoint, seq);
+            meta.logger.debug(`IRCode to send: ${JSON.stringify(irMsg)} (seq:${seq})`);
+        },
+    },
+    zosung_send_ir_code_02: {
+        cluster: 'zosungIRTransmit',
+        type: ['commandZosungSendIRCode02'],
+        convert: async (model, msg, publish, options, meta) => {
+            meta.logger.debug(`"IR-Message-Code02" received (msg:${JSON.stringify(msg.data)})`);
+            const seq = msg.data.seq;
+            const position = msg.data.position;
+            const irMsg = messagesGet(msg.endpoint, seq);
+            const part = irMsg.substring(position, position+0x32);
+            const sum = calcStringCrc(part);
+            await msg.endpoint.command('zosungIRTransmit', 'zosungSendIRCode03',
+                {
+                    zero: 0,
+                    seq: seq,
+                    position: position,
+                    msgpart: Buffer.from(part),
+                    msgpartcrc: sum,
+                },
+                {disableDefaultResponse: true});
+            meta.logger.debug(`Sent IRCode part: ${part} (sum: ${sum}, seq:${seq})`);
+        },
+    },
+    zosung_send_ir_code_04: {
+        cluster: 'zosungIRTransmit',
+        type: ['commandZosungSendIRCode04'],
+        convert: async (model, msg, publish, options, meta) => {
+            meta.logger.debug(`"IR-Message-Code04" received (msg:${JSON.stringify(msg.data)})`);
+            const seq = msg.data.seq;
+            await msg.endpoint.command('zosungIRTransmit', 'zosungSendIRCode05',
+                {
+                    seq: seq,
+                    zero: 0,
+                },
+                {disableDefaultResponse: true});
+            messagesClear(msg.endpoint, seq);
+            meta.logger.debug(`IRCode has been successfuly sent. (seq:${seq})`);
+        },
+    },
+    zosung_send_ir_code_00: {
+        cluster: 'zosungIRTransmit',
+        type: ['commandZosungSendIRCode00'],
+        convert: async (model, msg, publish, options, meta) => {
+            meta.logger.debug(`"IR-Message-Code00" received (msg:${JSON.stringify(msg.data)})`);
+            const seq = msg.data.seq;
+            const length = msg.data.length;
+            messagesSet(msg.endpoint, seq, {position: 0, buf: Buffer.alloc(length)});
+            await msg.endpoint.command('zosungIRTransmit', 'zosungSendIRCode01',
+                {
+                    zero: 0,
+                    seq: seq,
+                    length: length,
+                    unk1: msg.data.unk1,
+                    unk2: msg.data.unk2,
+                    unk3: msg.data.unk3,
+                    cmd: msg.data.cmd,
+                    unk4: msg.data.unk4,
+                },
+                {disableDefaultResponse: true});
+            meta.logger.debug(`"IR-Message-Code00" response sent.`);
+            await msg.endpoint.command('zosungIRTransmit', 'zosungSendIRCode02',
+                {
+                    seq: msg.data.seq,
+                    position: 0,
+                    maxlen: 0x38,
+                },
+                {disableDefaultResponse: true});
+            meta.logger.debug(`"IR-Message-Code00" transfer started.`);
+        },
+    },
+    zosung_send_ir_code_03: {
+        cluster: 'zosungIRTransmit',
+        type: ['zosungSendIRCode03Resp'],
+        convert: async (model, msg, publish, options, meta) => {
+            meta.logger.debug(`"IR-Message-Code03" received (msg:${JSON.stringify(msg.data)})`);
+            const seq = msg.data.seq;
+            const rcv = messagesGet(msg.endpoint, seq);
+            if (rcv.position==msg.data.position) {
+                const rcvMsgPart = msg.data.msgpart;
+                const sum = calcArrayCrc(rcvMsgPart);
+                const expectedPartCrc = msg.data.msgpartcrc;
+                if (sum==expectedPartCrc) {
+                    const position = rcvMsgPart.copy(rcv.buf, rcv.position);
+                    rcv.position += position;
+                    if (rcv.position<rcv.buf.length) {
+                        await msg.endpoint.command('zosungIRTransmit', 'zosungSendIRCode02',
+                            {
+                                seq: seq,
+                                position: rcv.position,
+                                maxlen: 0x38,
+                            },
+                            {disableDefaultResponse: true});
+                    } else {
+                        await msg.endpoint.command('zosungIRTransmit', 'zosungSendIRCode04',
+                            {
+                                zero0: 0,
+                                seq: seq,
+                                zero1: 0,
+                            },
+                            {disableDefaultResponse: true});
+                    }
+                    meta.logger.debug(`${rcvMsgPart.length} bytes received.`);
+                } else {
+                    meta.logger.error(`Invalid msg part CRC: ${sum} expecting: ${expectedPartCrc}.`);
+                }
+            } else {
+                meta.logger.error(`Unexpected IR code position: ${JSON.stringify(msg.data)}, expecting: ${rcv.position}.`);
+            }
+        },
+    },
+    zosung_send_ir_code_05: {
+        cluster: 'zosungIRTransmit',
+        type: ['zosungSendIRCode05Resp'],
+        convert: async (model, msg, publish, options, meta) => {
+            meta.logger.debug(`"IR-Message-Code05" received (msg:${JSON.stringify(msg.data)})`);
+            const seq = msg.data.seq;
+            const rcv = messagesGet(msg.endpoint, seq);
+            const learnedIRCode = rcv.buf.toString('base64');
+            meta.logger.debug(`Received: ${learnedIRCode}`);
+            messagesClear(msg.endpoint, seq);
+            await msg.endpoint.command('zosungIRControl', 'zosungControlIRCommand00',
+                {
+                    data: Buffer.from(JSON.stringify({'study': 1})),
+                },
+                {disableDefaultResponse: true});
+            return {
+                learned_ir_code: learnedIRCode,
+            };
+        },
+    },
+};
+
+const tzZosung = {
+    zosung_ir_code_to_send: {
+        key: ['ir_code_to_send'],
+        convertSet: async (entity, key, value, meta) => {
+            if (!value) {
+                meta.logger.error(`There is no IR code to send`);
+                return;
+            }
+            const irMsg = JSON.stringify({
+                'key_num': 1,
+                'delay': 300,
+                'key1': {
+                    'num': 1,
+                    'freq': 38000,
+                    'type': 1,
+                    'key_code': value,
+                },
+            });
+            meta.logger.debug(`Sending IR code: ${JSON.stringify(value)}`);
+            const seq = nextSeq(entity);
+            messagesSet(entity, seq, irMsg);
+            await entity.command('zosungIRTransmit', 'zosungSendIRCode00',
+                {
+                    seq: seq,
+                    length: irMsg.length,
+                    unk1: 0x00000000,
+                    unk2: 0xe004,
+                    unk3: 0x01,
+                    cmd: 0x02,
+                    unk4: 0x0000,
+                },
+                {disableDefaultResponse: true});
+            meta.logger.debug(`Sending IR code initiated.`);
+        },
+    },
+    zosung_learn_ir_code: {
+        key: ['learn_ir_code'],
+        convertSet: async (entity, key, value, meta) => {
+            meta.logger.debug(`Starting IR Code Learning...`);
+            await entity.command('zosungIRControl', 'zosungControlIRCommand00',
+                {
+                    data: Buffer.from(JSON.stringify({'study': 0})),
+                },
+                {disableDefaultResponse: true});
+            meta.logger.debug(`IR Code Learning started.`);
+        },
+    },
+};
+
+
+const presetsZosung = {
+    learn_ir_code: () => exposes.switch().withState('learn_ir_code', false, 'Turn on to learn new IR code', ea.SET),
+    learned_ir_code: () => exposes.text('learned_ir_code', ea.STATE).withDescription('The IR code learned by device'),
+    ir_code_to_send: () => exposes.text('ir_code_to_send', ea.SET).withDescription('The IR code to send by device'),
+};
+
+module.exports = {
+    fzZosung,
+    tzZosung,
+    presetsZosung,
+};

package/package.json

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