iobroker.zigbee 3.2.5 → 3.3.0

package/lib/utils.js

@@ -126,6 +126,7 @@ function zbIdorIeeetoAdId(adapter, source, withNamespace) {
 function adIdtoZbIdorIeee(adapter, source) {
     const s = `${source}`.replace(`${adapter.namespace}.`, '');
     if (s.startsWith('group')) return Number(s.substring(6));
+    if (s.startsWith('0x')) return s;
     if (s.length === 16 && Number(`0x${s}`)) return `0x${s}`;
     return 'illegal'
 }
@@ -140,7 +141,7 @@ const ikeaTradfriManufacturerID = [4476];
 
 function sanitizeImageParameter(parameter) {
     const replaceByDash = [/\?/g, /&/g, /[^a-z\d\-_./:]/gi, /[/]/gi];
-    let sanitized = parameter;
+    let sanitized = parameter || 'illegalParameter';
     replaceByDash.forEach(r => sanitized = sanitized.replace(r, '-'));
     return sanitized;
 }
@@ -154,7 +155,7 @@ function getDeviceIcon(definition) {
 }
 
 function getModelRegEx( model) {
-    const stripModel = (model) ? model.replace(/\0.*$/g, '').trim() : '';
+    const stripModel = (model && typeof model == 'string') ? model.replace(/\0.*$/g, '').trim() : '';
     return stripModel;
 }
 
@@ -214,8 +215,6 @@ function removeFromArray(arr, toRemove) {
     return removed;
 }
 
-
-
 exports.secondsToMilliseconds   = seconds => seconds * 1000;
 exports.bulbLevelToAdapterLevel = bulbLevelToAdapterLevel;
 exports.adapterLevelToBulbLevel = adapterLevelToBulbLevel;

package/lib/zbBaseExtension.js

@@ -28,6 +28,10 @@ class BaseExtension {
             this.zigbee.debug(`${this.name}:${message}`, data);
     }
 
+    pairingMessage(message) {
+        this.zigbee.emit('pairing', `${this.name}:${message}`)
+    }
+
     sendError(error, message) {
         this.zigbee.sendError(error, message);
     }

package/lib/zbDeviceAvailability.js

@@ -33,7 +33,7 @@ class DeviceAvailability extends BaseExtension {
         this.availability_timeout = 300; //  wait 5 min for live check
         this.timers = {};
         this.ping_counters = {};
-        this.max_ping = 3;
+        this.max_ping = 2;
         this.state = {};
         this.forcedNonPingable = {};
         this.number_of_registered_devices = 0;
@@ -51,9 +51,9 @@ class DeviceAvailability extends BaseExtension {
         this.elevate_debug = false;
         this.isStarted = false;
         this.active_ping = config.pingCluster != 'off';
-        this.max_ping = 5;
         this.availability_timeout = Math.max(60, typeof config.pingTimeout == 'number' ? config.pingTimeout : 300);
         this.startReadDelay = config.readAllAtStart ? Math.max(500, Math.min(10000, config.startReadDelay * 1000)) : 0;
+        this.readAtAnnounce = config.readAtAnnounce;
         this.debugDevices = [];
         this.pingCluster = pingClusters[config.pingCluster] ? pingClusters[config.pingCluster] : {};
         this.availableTime = config.availableUpdateTime ? config.availableUpdateTime : Number.MAX_SAFE_INTEGER;
@@ -80,7 +80,7 @@ class DeviceAvailability extends BaseExtension {
     isPingable(device) {
 
         if (this.active_ping) {
-            if (this.forced_ping && forcedPingable.find(d => d && d.hasOwnProperty('zigbeeModel') && d.zigbeeModel.includes(device.modelID))) {
+            if (forcedPingable.find(d => d && device?.zigbeeModel?.includes(device.modelID))) {
                 return true;
             }
 
@@ -176,6 +176,13 @@ class DeviceAvailability extends BaseExtension {
         }
     }
 
+    async onDeviceRemove(device) {
+        if (this.timers[device.ieeeAddr]) {
+            clearTimeout(this.timers[device.ieeeAddr]);
+        }
+        delete this.timers[device.ieeeAddr];
+    }
+
     async handleIntervalPingable(device, entity) {
         if (!this.isStarted) return;
         if (!this.active_ping) {
@@ -239,7 +246,7 @@ class DeviceAvailability extends BaseExtension {
                 this.publishAvailability(device, false, false, has_elevated_debug ? debugID : undefined);
                 if (pingCount.failed++ <= this.max_ping) {
                     const message = `Failed to ping ${ieeeAddr} ${device.modelID} for ${JSON.stringify(pingCount)} attempts`
-                    if (pingCount.failed < 2 && pingCount.reported < this.max_ping) {
+                    if (pingCount.reported < this.max_ping) {
                         if (!has_elevated_debug)
                             this.info(message);
                         pingCount.reported++;
@@ -348,9 +355,9 @@ class DeviceAvailability extends BaseExtension {
         }
     }
 
-    async onZigbeeEvent(data) {
+    async onZigbeeEvent(data, mappedDevice) {
         const device = data.device;
-        if (!device || this.forcedNonPingable[device.ieeeAddr]) {
+        if (!device) {
             return;
         }
 
@@ -360,26 +367,12 @@ class DeviceAvailability extends BaseExtension {
             // When a zigbee message from a device is received we know the device is still alive.
             // => reset the timer.
             this.setTimerPingable(device, 1);
-            const pc = this.ping_counters[device.ieeeAddr];
-            if (pc == undefined) {
-                this.ping_counters[device.ieeeAddr] = {failed: 0, reported: 0};
-            } else {
-                this.ping_counters[device.ieeeAddr].failed++;
-            }
+            this.ping_counters[device.ieeeAddr] = {failed: 0, reported: 0};
 
             const online = this.state.hasOwnProperty(device.ieeeAddr) && this.state[device.ieeeAddr];
             if (online && data.type === 'deviceAnnounce' && !utils.isIkeaTradfriDevice(device)) {
-                const entity = await this.zigbee.resolveEntity(device);
-                if (entity && entity.mapped) {
-                    /**
-                     * In case the device is powered off AND on within the availability timeout,
-                     * zigbee2qmtt does not detect the device as offline (device is still marked online).
-                     * When a device is turned on again the state could be out of sync.
-                     * https://github.com/Koenkk/zigbee2mqtt/issues/1383#issuecomment-489412168
-                     * endDeviceAnnce is typically send when a device comes online.
-                     *
-                     * This isn't needed for TRADFRI devices as they already send the state themself.
-                     */
+                // We only try to read the states if readAtAnnounce and resend_states is not active
+                if (mappedDevice && !this.readAtAnnounce && !device.options?.resend_states) {
                     this.onReconnect(device);
                 }
             }

package/lib/zbDeviceConfigure.js

@@ -37,17 +37,30 @@ class DeviceConfigure extends BaseExtension {
         this.doConfigure(configureItem.dev, configureItem.mapped);
     }
 
-    PushDeviceToQueue(device, mappedDevice) {
+    PushDeviceToQueue(device, mappedDevice, priority) {
         const id = device.ieeeAddr;
-        for (const candidate of this.deviceConfigureQueue) {
-            if (candidate.id == id) {
-                this.debug('no duplicate entry in queue');
+
+        const item = this.deviceConfigureQueue.find((candidate) => candidate.id === id);
+        if (item) {
+            this.debug('preventing dupicate entries in configure queue');
+            if (priority) {
+                const idx = this.deviceConfigureQueue.indexOf(item);
+                if (idx > -1) this.deviceConfigureQueue.splice(idx, 1);
+            }
+            else {
                 return;
             }
         }
-        this.deviceConfigureQueue.push({ id: device.ieeeAddr, dev:device, mapped:mappedDevice });
-        if (this.configureIntervall) return;
-        this.configureIntervall = setInterval(async () => await this.handleConfigureQueue(), 5000);
+        if (priority) {
+            // priority means its a new device, we want to configure it NOW
+            this.pairingMessage(`configuring ${id}`);
+            this.doConfigure(device, mappedDevice);
+        }
+        else {
+            this.deviceConfigureQueue.push({ id: device.ieeeAddr, dev:device, mapped:mappedDevice });
+            if (this.configureIntervall) return;
+            this.configureIntervall = setInterval(async () => await this.handleConfigureQueue(), 5000);
+        }
     }
 
     shouldConfigure(device, mappedDevice) {
@@ -105,7 +118,7 @@ class DeviceConfigure extends BaseExtension {
             }
             // check if the event is a 'deviceInterview successful' Event
             if (data.type == 'deviceJoined' || data.type == 'deviceInterview' && data.status == 'successful') {
-                this.PushDeviceToQueue(device, mappedDevice);
+                this.PushDeviceToQueue(device, mappedDevice, true); // with priority => we want it configured immediately
             }
 
         } catch (error) {

package/lib/zigbeecontroller.js

@@ -78,7 +78,18 @@ class ZigbeeController extends EventEmitter {
         this.deviceQueryActive = [];
         this.storedOptions = undefined;
         this.isConfigured = false;
+        this.disabledDevices = new Set();
+    }
 
+    setDeviceEnable(id, enable) {
+        try {
+            const ieee = `0x${id.split('.').pop()}`;
+            if (enable) this.disabledDevices.add(ieee); else this.disabledDevices.delete(ieee);
+            return this.disabledDevices.has(ieee);
+        }
+        catch {
+            return false;
+        }
     }
 
 
@@ -99,7 +110,7 @@ class ZigbeeController extends EventEmitter {
             return _port;
         }
         catch (error) {
-            console.warn(`unable to access ${port}`)
+            this.warn(`unable to access ${port}`)
             return '';
         }
     }
@@ -240,8 +251,8 @@ class ZigbeeController extends EventEmitter {
                 const networkParameters = `Network parameters on Coordinator: panID=${debNetworkParam.panID} channel=${debNetworkParam.channel} extendedPanID=${this.reverseIEEE(extendedPanIDDebug)}`;
                 this.emit('pairing',configParameters)
                 this.emit('pairing',networkParameters);
-                this.warn(configParameters)
-                this.warn(networkParameters);
+                this.info(configParameters)
+                this.info(networkParameters);
             }
             catch (error) {
                 this.emit('pairing',`Unable to obtain herdsman settings`);
@@ -867,9 +878,10 @@ class ZigbeeController extends EventEmitter {
                     message = error.message;
 
             }
-            this.warn(`Failed to remove ${deviceID ? 'device ' + deviceID : 'unspecified device'}: ${message}`);
-            callback && callback(`Failed to remove ${deviceID ? 'device ' + deviceID : 'unspecified device'}: ${message}`);
+            const msg = `Failed to remove ${deviceID ? 'device ' + deviceID : 'unspecified device'}: ${message}`;
+            if (callback) callback(msg); else return { status:false, error:msg};
         }
+        if (!callback) return {status:true};
     }
 
     // Zigbee events
@@ -907,19 +919,19 @@ class ZigbeeController extends EventEmitter {
             this.emit('device_debug', {ID: Date.now(), data: {flag:'da', states:[{id: '--', value:'--', payload:message}] , IO:true} ,message:`Device '${friendlyName}' announced itself`});
         }
 
-        if (entity.device && entity.device.modelID && entity.device.interviewState != 'SUCCESSFUL') {
-            this.info(`ignoring device announcement for ${entity.device.modelID} due to interview state ${entity.device.interviewState}`);
-            this.emit('pairing', `device interview state is ${entity.device.interviewState}`)
+        if (this.herdsman.getPermitJoin() && (entity?.device?.interviewState != 'SUCCESSFUL')) {
+            this.info(`ignoring device announcement for ${entity?.device?.modelID ? entity?.device?.modelID : 'unknown model'} due to interview state ${entity?.device?.interviewState} while the network is open.`);
+            this.emit('pairing', `ignoring device announcement while interview state is ${entity?.device?.interviewState}`);
             return;
         }
 
+
         if (this.warnOnDeviceAnnouncement) {
             this.warn(`Device '${friendlyName}' announced itself${this.readAtAnnounce ? ', trying to read its status' : ''}`);
         } else {
             this.info(`Device '${friendlyName}' announced itself${this.readAtAnnounce ? ', trying to read its status' : ''}`);
         }
 
-        const networkOpen = this.herdsman.getPermitJoin();
         /*
         if (networkOpen && entity.device && entity.device.modelID && entity.device.interviewState != 'IN_PROGRESS')
         {
@@ -936,6 +948,7 @@ class ZigbeeController extends EventEmitter {
                 }
                 else
                     if (this.readAtAnnounce) await this.doDeviceQuery(message.device || message.ieeeAddr, Date.now(), false);
+
                 this.callExtensionMethod(
                     'onZigbeeEvent',
                     [{'device': message.device, 'type': 'deviceAnnounce', options: entity.options || {}}, entity ? entity.mapped : null]);
@@ -955,61 +968,62 @@ class ZigbeeController extends EventEmitter {
     }
 
     async handleDeviceInterview(message) {
-        if (this.debugActive) this.debug('handleDeviceInterview', message);
+        if (this.debugActive) this.debug('handleDeviceInterview',JSON.stringify(message));
         // safeguard: We do not allow to start an interview if the network is not opened
         if (message.status === 'started' && !this.herdsman.getPermitJoin()) {
-            this.warn(`Blocked interview for '${message.ieeeAddr}' because the network is closed`);
+            this.warn(`Ignored interview for '${message.ieeeAddr}' because the network is closed`);
             return;
         }
         try {
             const entity = await this.resolveEntity(message.device || message.ieeeAddr);
             const friendlyName = entity.name;
-            if (message.status === 'successful') {
-                this.info(`Successfully interviewed '${friendlyName}', device has successfully been paired`);
-
-                if (entity.mapped) {
-                    const {vendor, description, model} = entity.mapped;
-                    this.info(
-                        `Device '${friendlyName}' is supported, identified as: ${vendor} ${description} (${model})`
-                    );
-
-                    const log = {friendly_name: friendlyName, model, vendor, description, supported: true};
-                    this.emit('pairing', 'Interview successful', JSON.stringify(log));
-                    //entity.device.modelID = entity.device._modelID;
-                    this.callExtensionMethod(
-                        'onZigbeeEvent',
-                        [{...message,type:'deviceInterview', options: entity.options || {}}, entity.mapped],
-                    );
-                    this.emit('new', entity);
-                    // send to extensions again (for configure)
-                } else {
-                    if (this.debugActive) this.debug(
-                        `Device '${friendlyName}' with Zigbee model '${message.device.modelID}' is NOT supported, ` +
-                        `please follow https://www.zigbee2mqtt.io/how_tos/how_to_support_new_devices.html`
-                    );
-                    const frName = {friendly_name: friendlyName, supported: false};
-                    this.emit('pairing', 'Interview successful', JSON.stringify(frName));
-                    //entity.device.modelID = entity.device._modelID;
+            const onZigbeeEventparameters = [message, entity.mapped ? entity.mapped: null];
+
+            switch (message.status) {
+                case 'successful': {
+                    this.info(`Successfully interviewed '${friendlyName}', device has successfully been paired`);
+                    const msgArr = [];
+
+                    if (entity.mapped) {
+                        const {vendor, description, model} = entity.mapped;
+                        this.info(
+                            `Device '${friendlyName}' is supported, identified as: ${vendor} ${description} (${model})`
+                        );
+                        msgArr.push(`firendly name: ${friendlyName}`);
+                        if (model) msgArr.push(`model: ${model}`); else msgArr.push(`model: unknown`);
+
+                        if (vendor) msgArr.push(`vendor: ${vendor}`);
+                        if (description) msgArr.push(`description: ${description}`);
+                        msgArr.push('supported:true');
+                        onZigbeeEventparameters[0]={...message,type:'deviceInterview', options: entity.options || {}};
+                    } else {
+                        if (this.debugActive) this.debug(
+                            `Device '${friendlyName}' with Zigbee model '${message.device.modelID}' is NOT supported, ` +
+                            `please follow https://www.zigbee2mqtt.io/how_tos/how_to_support_new_devices.html`
+                        );
+                    }
+                    this.emit('pairing', 'Interview successful', msgArr.join(', '));
                     this.emit('new', entity);
+                    break;
                 }
-            } else if (message.status === 'failed') {
-                this.error(`Failed to interview '${friendlyName}', device has not successfully been paired. Try again !!!!!!!!!! `);
-                //this.error(`Failed to interview '${friendlyName}', device has not successfully been paired. Try again !!!!!!!!!! ${message.error}`);
-                this.emit('pairing', 'Interview failed', friendlyName);
-                this.callExtensionMethod(
-                    'onZigbeeEvent',
-                    [message, entity ? entity.mapped : null],
-                );
-            } else {
-                if (message.status === 'started') {
-                    this.callExtensionMethod(
-                        'onZigbeeEvent',
-                        [message, entity ? entity.mapped : null],
-                    );
-                    this.info(`Starting interview of '${friendlyName}'`);
-                    this.emit('pairing', 'Interview started', friendlyName);
+                case 'failed': {
+                    this.error(`Failed to interview '${friendlyName}', device has not successfully been paired. Try again !!!!!!!!!! `);
+                    this.emit('pairing', 'Interview failed', friendlyName);
+                    break;
+                }
+                default: {
+                    if (message.status === 'started') {
+                        this.info(`Starting interview of '${friendlyName}'`);
+                        this.emit('pairing', 'Interview started', friendlyName);
+                    }
+
                 }
             }
+
+            this.callExtensionMethod(
+                'onZigbeeEvent',
+                onZigbeeEventparameters,
+            );
         }
         catch (error) {
             this.error('handleDeviceInterview: ' + (error && error.message ? error.message : 'no error message'));
@@ -1040,25 +1054,67 @@ class ZigbeeController extends EventEmitter {
 
     async getMap(callback) {
         try {
+            const MapData = { lqi:{}, routing:{}, sdev:[], edev:[], ddev: []};
             this.info('Collecting Map Data');
             const devices = this.herdsman.getDevices(true);
             const lqis = [];
             const routing = [];
             const errors = [];
 
-            await Promise.all(devices.filter((d) => d.type !== 'EndDevice').map(async device =>
+            const mappables = devices.filter((d) => d.type !== 'EndDevice');
+            let cnt = mappables.length;
+            this.emit('pairing', `Map Devices left:${cnt}`)
+            for (const device of mappables)
             {
+                cnt--;
+                if (this.disabledDevices.has(device.ieeeAddr)) {
+                    MapData.ddev.push(device.ieeeAddr);
+                    lqis.push({
+                        parent: 'undefined',
+                        networkAddress: 0,
+                        ieeeAddr: device.ieeeAddr,
+                        lqi: 'undefined',
+                        relationship: 0,
+                        depth: 0,
+                        status: 'disabled',
+                    });
+                    continue;
+                }
                 let resolved = await this.resolveEntity(device, 0);
                 if (!resolved) {
                     resolved = { name:'unresolved device', device:device }
                     if (this.debugActive) this.debug('resolve Entity failed for ' + device.ieeeAddr)
                 }
-                let result;
+
+                let attemptRouting = true;
 
                 try {
-                    result = await device.lqi();
+                    const result = await device.lqi();
+                    MapData.sdev.push(`lqi ${device.ieeeAddr}`);
+                    MapData.lqi[device.ieeeAddr] = result;
+                    const r_arr = Array.isArray(result) ? result : result?.neighbors;
+                    if (r_arr) {
+                        for (const dev of r_arr) {
+                            const ieeeAddr = dev.ieeeAddr || dev.eui64;
+                            if (dev !== undefined && ieeeAddr !== '0xffffffffffffffff') {
+                                const lq = (dev.linkquality == undefined) ? dev.lqi== undefined ? 0 : dev.lqi : dev.linkquality
+                                lqis.push({
+                                    parent: (resolved ? resolved.device.ieeeAddr : undefined),
+                                    networkAddress: dev.networkAddress || dev.nwkAddress,
+                                    ieeeAddr: ieeeAddr,
+                                    lqi: lq,
+                                    relationship: dev.relationship,
+                                    depth: dev.depth,
+                                    status: lq > 0 ? 'online' : 'offline',
+                                });
+                            }
+                        }
+                    }
                 } catch (error) {
-                    errors.push(`Failed to execute LQI for '${resolved ? resolved.name : 'unresolved device'} (${resolved ? resolved.device.modelID : 'unknown'}') : ${this.filterHerdsmanError(error.message)}.`);
+                    MapData.edev.push(device.ieeeAddr);
+                    const eReason = this.filterHerdsmanError(error.message);
+                    errors.push(`Failed to execute LQI for '${resolved ? resolved.name : 'unresolved device'} (${resolved ? resolved.device.modelID : 'unknown'}') : ${eReason}.`);
+                    attemptRouting = eReason != 'Timeout'
                     lqis.push({
                         parent: 'undefined',
                         networkAddress: 0,
@@ -1070,48 +1126,37 @@ class ZigbeeController extends EventEmitter {
                     });
                 }
 
-                if (result !== undefined) {
-                    for (const dev of result.neighbors) {
-                        if (dev !== undefined && dev.ieeeAddr !== '0xffffffffffffffff') {
-                            lqis.push({
-                                parent: (resolved ? resolved.device.ieeeAddr : undefined),
-                                networkAddress: dev.networkAddress,
-                                ieeeAddr: dev.ieeeAddr,
-                                lqi: dev.linkquality,
-                                relationship: dev.relationship,
-                                depth: dev.depth,
-                                status: dev.linkquality > 0 ? 'online' : 'offline',
-                            });
-                        }
-                    }
-                }
-
-                try {
-                    result = await device.routingTable();
-                } catch (error) {
-                    if (error) {
-                        errors.push(`Failed to collect routing table for '${resolved ? resolved.name : 'unresolved device'} (${resolved ? resolved.device.modelID : 'unknown'}') : ${this.filterHerdsmanError(error.message)}`);
-                    }
-                }
-
-                if (result !== undefined) {
-                    if (result.table !== undefined) {
-                        for (const dev of result.table) {
+                if (attemptRouting) try {
+                    const result = await device.routingTable();
+                    const r_arr = Array.isArray(result) ? result : result?.table;
+                    MapData.routing[device.ieeeAddr] = result;
+                    if (r_arr !== undefined) {
+                        for (const dev of r_arr) {
                             routing.push({
                                 source: resolved.device.ieeeAddr,
                                 destination: dev.destinationAddress,
-                                nextHop: dev.nextHop,
+                                nextHop: dev.nextHop ? dev.nextHop: dev.nextHopAddress,
                                 status: dev.status,
                             });
                         }
                     }
+                } catch (error) {
+                    MapData.edev.push(`routing ${device.ieeeAddr}`);
+                    if (error) {
+                        errors.push(`Failed to collect routing table for '${resolved?.name || 'unresolved device'} (${resolved?.device?.modelID || 'unknown'}') : ${this.filterHerdsmanError(error.message)}`);
+                    }
                 }
+                else errors.push(`Omitted collecting routing table for '${resolved?.name || 'unresolved device'} (${resolved?.device?.modelID ||'unknown'}') : LQI timed out`);
+                this.emit('pairing', `Map Devices left: ${cnt}`);
             }
-            ));
+            this.emit('pairing', 'Map data collection complete');
+
+            const fs = require('fs');
+            fs.writeFileSync(this.adapter.expandFileName('mapdata.json'), JSON.stringify(MapData));
 
             callback && callback({lqis, routing, errors});
             if (errors.length) {
-                if (this.debugActive) this.debug(`Map Data collection complete with ${errors.length} issues:`);
+                this.info(`Map Data collection complete with ${errors.length} issues:`);
                 for (const msg of errors)
                     if (this.debugActive) this.debug(msg);
             }
@@ -1387,6 +1432,7 @@ class ZigbeeController extends EventEmitter {
                         if (error.code === 25 && retry > 0) {
                             this.warn(`Error ${error.code} on send command to ${deviceId}. (${retry} tries left.), Error: ${error.message}`);
                             retry--;
+                            await new Promise(resolve => setTimeout(resolve, 200));
                         }
                         else {
                             retry = 0;
@@ -1641,7 +1687,7 @@ class ZigbeeController extends EventEmitter {
 
     async removeDevFromGroup(devId, groupId, epid) {
         if (this.debugActive) this.debug(`removeDevFromGroup with ${devId}, ${groupId}, ${epid}`);
-        let entity;
+        let entity; // needed to have access to entity outside in the catch path.
         try {
             entity = await this.resolveEntity(devId);
             const group = await this.resolveEntity(groupId);