iobroker.zigbee 2.0.4 → 2.0.5

package/lib/zbDeviceConfigure.js

@@ -12,72 +12,75 @@ class DeviceConfigure extends BaseExtension {
         this.delayedConfigure = {};
 
         this.configuring = new Set();
-        this.attempts = {};
+        this.configureOnMessage = new Set();
+        this.configureOnMessageAttempts = {};
         this.name = 'DeviceConfigure';
+
+        this.MessageStash = [];
+        this.deviceConfigureQueue = [];
+        this.configureIntervall = null;
     }
 
     setOptions(options) {
         return typeof options === 'object';
     }
 
-    shouldConfigure(device, mappedDevice) {
-        if (!device || !mappedDevice) {
-            return false;
-        }
-        if (!mappedDevice || !mappedDevice.configure) {
-            return false;
+    async handleConfigureQueue() {
+        if (this.deviceConfigureQueue.length < 1) {
+            this.info('Handled all devices Queued for configuration.')
+            clearInterval(this.configureIntervall);
+            this.configureIntervall == null;
+            return;
         }
-        if (device.meta.hasOwnProperty('configured') &&
-            zigbeeHerdsmanConverters.getConfigureKey(mappedDevice)) {
-            return false;
-        }
-
-        return (device.interviewing !== true && this.checkDelayedConfigure(device.ieeeAddr)>0);
+        const configureItem = this.deviceConfigureQueue.shift();
+        this.info(`DeviceConfigureQueue configuring ${configureItem.dev.ieeeAddr} ${configureItem.dev.modelID}`)
+        this.doConfigure(configureItem.dev, configureItem.mapped);
     }
 
-    checkDelayedConfigure(device, num) {
-        if (!this.delayedConfigure.hasOwnProperty(device.ieeeAddr)) {
-            if (num && num > 0) {
-                this.delayedConfigure[device.ieeeAddr] = { maxAttempts:num };
-                return num;
+    PushDeviceToQueue(device, mappedDevice) {
+        const id = device.ieeeAddr;
+        for (const candidate of this.deviceConfigureQueue) {
+            if (candidate.id == id) {
+                this.debug('no duplicate entry in queue');
+                return;
             }
-            return 0;
-        }
-        const dc = this.delayedConfigure[device.ieeeAddr];
-        dc.maxAttempts--;
-        if (dc.maxAttempts > 0) return dc.maxAttempts;
-        if (num && num > 0) {
-            dc.maxAttempts = num;
-            return num;
         }
-        return 0;
+        this.deviceConfigureQueue.push({ id: device.ieeeAddr, dev:device, mapped:mappedDevice });
+        if (this.configureIntervall) return;
+        this.configureIntervall = setInterval(async () => await this.handleConfigureQueue(), 5000);
     }
 
-    delayedConfigureAttempt(device, status) {
-        if (status) {
-            delete this.delayedConfigure[device.ieeeAddr];
-            return 0;
+    shouldConfigure(device, mappedDevice) {
+        if (!device || !mappedDevice) {
+            return false;
         }
-        return this.checkDelayedConfigure(device, 10);
+        if (!mappedDevice || !mappedDevice.configure) {
+            return false;
+        }
+        // no configuration if we are interviewing or configuring
+        if (this.configuring.has(device.ieeeAddr) || device.interviewing) return false;
+        const t = Date.now();
+        const cfgkey = zigbeeHerdsmanConverters.getConfigureKey(mappedDevice);
+        const result = device.meta.hasOwnProperty('configured') && device.meta.configured !== cfgkey;
+        this.debug(`should configure for device ${device.ieeeAddr} (${mappedDevice.model}: ${device.meta.hasOwnProperty('configured') ? device.meta.configured: 'none'} -  ${cfgkey} (query took ${Date.now()- t} ms)`);
+        return result;
     }
 
-
     async onZigbeeStarted() {
         try {
             this.coordinatorEndpoint = await this.zigbee.getDevicesByType('Coordinator')[0].endpoints[0];
 
             for (const device of await this.zigbee.getClients()) {
                 const mappedDevice = await zigbeeHerdsmanConverters.findByDevice(device);
-
                 if (forcedConfigureOnEachStart.find((d) => d && d.hasOwnProperty('zigbeeModel') && d.zigbeeModel.includes(device.modelID))) {
-                    this.debug(`DeviceConfigure ${device.ieeeAddr} ${device.modelID} forced by adapter config`);
+                    this.debug(`DeviceConfigure ${device.ieeeAddr} ${mappedDevice ? mappedDevice.model : device.modelID} forced by adapter config`);
                     device.meta.configured = -1; // Force a reconfiguration for this device
                 }
                 if (this.shouldConfigure(device, mappedDevice)) {
-                    this.debug(`DeviceConfigure ${device.ieeeAddr} ${device.modelID} needed`);
-                    await this.configure(device, mappedDevice);
+                    this.info(`DeviceConfigure ${device.ieeeAddr} ${mappedDevice ? mappedDevice.model : device.modelID} needed - Device added to Configuration Queue`);
+                    await this.PushDeviceToQueue(device, mappedDevice);
                 } else {
-                    this.debug(`DeviceConfigure ${device.ieeeAddr} ${device.modelID} not needed`);
+                    this.debug(`DeviceConfigure ${device.ieeeAddr} ${mappedDevice ? mappedDevice.model : device.modelID} not needed`);
                 }
             }
         } catch (error) {
@@ -89,8 +92,14 @@ class DeviceConfigure extends BaseExtension {
     onZigbeeEvent(data, mappedDevice) {
         try {
             const device = data.device;
-            if (this.shouldConfigure(device, mappedDevice)) {
-                this.configure(device, mappedDevice);
+            const com = this.configureOnMessageAttempts[device.ieeeAddr];
+            if (com) {
+                this.info(`checking configure on message :  next attempt in ${30000 - (Date.now() - com.timestamp)} seconds`);
+                if (Date.now() - com.timestamp > 30000 && !this.configuring.has(device.ieeeAddr)) {
+                    com.timestamp = Date.now();
+                    this.info('Configure on Message for ' + device.ieeeAddr);
+                    this.doConfigure(device, mappedDevice);
+                }
             }
         } catch (error) {
             this.sendError(error);
@@ -98,14 +107,15 @@ class DeviceConfigure extends BaseExtension {
         }
     }
 
+
     onDeviceRemove(device) {
         try {
             if (this.configuring.has(device.ieeeAddr)) {
                 this.configuring.delete(device.ieeeAddr);
             }
 
-            if (this.attempts.hasOwnProperty(device.ieeeAddr)) {
-                delete this.attempts[device.ieeeAddr];
+            if (this.configureOnMessageAttempts && this.configureOnMessageAttempts.hasOwnProperty(device.ieeeAddr)) {
+                delete this.configureOnMessageAttempts[device.ieeeAddr];
             }
         } catch (error) {
             this.sendError(error);
@@ -124,16 +134,17 @@ class DeviceConfigure extends BaseExtension {
     async configure(device, mappedDevice) {
         try {
             if (mappedDevice !== undefined && device !== undefined) {
+
                 try {
                     await this.doConfigure(device, mappedDevice)
                 } catch (error) {
                     this.sendError(error);
-                    this.warn(`DeviceConfigure failed ${device.ieeeAddr} ${device.modelID}`);
+                    this.warn(`DeviceConfigure failed ${device.ieeeAddr} ${mappedDevice.model}`);
                 }
             }
         } catch (error) {
             this.sendError(error);
-            this.error(`Failed to DeviceConfigure.configure ${device.ieeeAddr} ${device.modelID} stack: (${error.stack})`);
+            this.error(`Failed to DeviceConfigure.configure ${device.ieeeAddr} ${mappedDevice.model}: ${error && error.message ? error.message : 'no error message'})`);
         }
     }
 
@@ -141,33 +152,51 @@ class DeviceConfigure extends BaseExtension {
         const coordinatorEndpoint = await this.zigbee.getDevicesByType('Coordinator')[0].endpoints[0];
         try {
             if (mappedDevice) {
-                this.info(`-> Configuring ${device.ieeeAddr} ${device.modelID}`);
-                const promises = [];
-                promises.push(mappedDevice.configure);
-                await Promise.all(promises.map(callback => callback(device, coordinatorEndpoint, mappedDevice)))
-
-                //await mappedDevice.configure(device, coordinatorEndpoint, this);
-
+                if (mappedDevice.configure === undefined) return `No configure available for ${device.ieeeAddr} ${mappedDevice.model}.`;
+                this.info(`Configuring ${device.ieeeAddr} ${mappedDevice.model}`);
+                this.configuring.add(device.ieeeAddr);
+                if (typeof mappedDevice.configure === 'function') await mappedDevice.configure(device, coordinatorEndpoint, this);
+                else {
+                    const promises = [];
+                    promises.push(...mappedDevice.configure);
+                    await Promise.all(promises.map(callback => callback(device, coordinatorEndpoint, mappedDevice)))
+                }
                 device.meta.configured = zigbeeHerdsmanConverters.getConfigureKey(mappedDevice);
+                this.configuring.delete(device.ieeeAddr);
+                delete this.configureOnMessageAttempts[device.ieeeAddr];
                 device.save();
-                this.info(`DeviceConfigure successful ${device.ieeeAddr} ${device.modelID}`);
-                this.delayedConfigureAttempt(device, true);
+                this.info(`DeviceConfigure successful ${device.ieeeAddr} ${mappedDevice.model}`);
                 return '';
             }
         } catch (error) {
+            this.configuring.delete(device.ieeeAddr);
             // https://github.com/Koenkk/zigbee2mqtt/issues/14857
             if (error.stack.includes('UNSUPPORTED_ATTRIBUTE')) {
+                this.debug(`Configuration attempt on ${device.ieeeAddr} ${mappedDevice.model} with unsupported Attribute(s) : ${error.message}`)
                 // do nothing
             } else {
                 if (error && error.message && error.message.match(/(\d+)ms/gm)) {
                     // timeout message - we do want to start the configure chain
-                    const num = this.delayedConfigureAttempt(device, false);
-                    this.info(`Delayed configure for ${device.ieeeAddr} ${device.modelID}:  ${num} attempts remaining`)
-                    return `Delayed configure for ${device.ieeeAddr} ${device.modelID}:  ${num} attempts remaining`;
+                    if (this.configureOnMessageAttempts.hasOwnProperty(device.ieeeAddr)) {
+                        const com = this.configureOnMessageAttempts[device.ieeeAddr];
+                        com.count--;
+                        com.timestamp = Date.now();
+                        this.info(`Timeout trying to configure ${device.ieeeAddr} ${mappedDevice.model} (${com.count}).`)
+                        if ( com.count < 0) delete this.configureOnMessage[device.ieeeAddr];
+                    }
+                    else {
+                        this.info(`Timeout trying to configure ${device.ieeeAddr} ${mappedDevice.model} (starting CoM).`)
+                        this.configureOnMessageAttempts[device.ieeeAddr] = {
+                            count: 5,
+                            timestamp: 0,
+                        };
+                    }
+                    return `Configuration timed out ${device.ieeeAddr} ${device.modelID}. The device did not repond in time to the configuration request. Another attempt will be made when the device is awake.`;
                 } else {
                     this.sendError(error);
-                    this.warn(`${device.ieeeAddr} ${device.modelID} Failed to configure. --> ${error && error.message ? error.message : ' no error message given'} `);
-                    return `${device.ieeeAddr} ${device.modelID} Failed to configure. --> ${error && error.message ? error.message : ' no error message given'} `
+                    const msg = `${device.ieeeAddr} ${device.modelID} Failed to configure. --> ${error && error.message ? error.message : ' no error message given'}`
+                    this.warn(msg);
+                    return msg;
                 }
 
 
@@ -175,6 +204,11 @@ class DeviceConfigure extends BaseExtension {
         }
         return 'no return value specified';
     }
+
+    async stop() {
+        clearInterval(this.configureIntervall);
+        this.configureOnMessageAttempts = {};
+    }
 }
 
 module.exports = DeviceConfigure;

package/lib/zigbeecontroller.js

@@ -65,6 +65,7 @@ class ZigbeeController extends EventEmitter {
         super();
         this.adapter = adapter;
         this._permitJoinTime = 0;
+        this.transmitPower = 0;
         this.herdsmanStarted = false;
         this.extensions = [
             new DeviceAvailabilityExt(this, {}),
@@ -74,19 +75,41 @@ class ZigbeeController extends EventEmitter {
         ];
         this.herdsmanTimeoutRegexp = new RegExp(/(\d+)ms/);
         this.herdsmanLogSettings = {}
+
     }
 
 
     ByteArrayToString(data) {
-        return data.map(function (x) {
-            x = x + 0x100 + 1;  // twos complement
-            x = x.toString(16); // to hex
-            x = ('00'+x).substr(-2); // zero-pad to 8-digits
-            return x
-        }).join('');
+        if (data) {
+            return data.map(function (x) {
+                x = x + 0x100 + 1;  // twos complement
+                x = x.toString(16); // to hex
+                x = ('00'+x).substr(-2); // zero-pad to 8-digits
+                return x
+            }).join('');
+        }
+        else return '';
     }
 
     configure(options) {
+
+        if (options.transmitPower != undefined) {
+            this.transmitPower = options.transmitPower;
+        }
+
+        this.powerText = '';
+        if (this.transmitPower !== '0') {
+            const powerLevels = {
+                '-22': 'low',
+                '19': 'high',
+                '20': 'high+'
+            };
+
+            this.powerText = powerLevels[this.transmitPower] || 'normal';
+        }
+
+        this.info(`  --> transmitPower : ${this.powerText}`);
+
         const herdsmanSettings = {
             network: {
                 panID: options.net.panId,
@@ -102,6 +125,7 @@ class ZigbeeController extends EventEmitter {
                 path: options.sp.port,
                 adapter: options.sp.adapter,
             },
+            transmitpower: this.transmitPower,
             adapter: {
                 forceStartWithInconsistentAdapterConfiguration: options.startWithInconsistent
             },
@@ -114,11 +138,6 @@ class ZigbeeController extends EventEmitter {
             herdsmanSettings.network.extenedPanID = options.net.extPanId;
         }
 
-        if (options.transmitPower == undefined) {
-            this.transmitPower = 0;
-        } else {
-            this.transmitPower = options.transmitPower;
-        }
         this.disableLed = options.disableLed;
         this.warnOnDeviceAnnouncement = options.warnOnDeviceAnnouncement;
         this.herdsmanLogSettings.panID = herdsmanSettings.network.panID;
@@ -179,7 +198,7 @@ class ZigbeeController extends EventEmitter {
                 this.warn(`Network parameters on Coordinator: panID=${debNetworkParam.panID} channel=${debNetworkParam.channel} extendedPanID=${extPanIDDebug}`);
             }
             catch (error) {
-                this.warn(`Unable to obtain herdsman settings`)
+                this.info(`Unable to obtain herdsman settings`)
             }
             try {
                 await this.herdsman.stop();
@@ -204,35 +223,6 @@ class ZigbeeController extends EventEmitter {
             this.sendError(e);
         }
 
-        // only for CC1352P and CC26X2R1 transmit power
-        let powerText = 'normal';
-
-        if (this.transmitPower != '0') {
-            switch (this.transmitPower) {
-                case '-22':
-                    powerText = 'low';
-                    break;
-                case '19':
-                    powerText = 'high';
-                    break;
-                case '20':
-                    powerText = 'high+';
-                    break;
-                default:
-                    powerText = 'normal';
-            }
-        }
-
-
-        this.info(`  --> transmitPower : ${powerText}`);
-        try {
-            await this.herdsman.setTransmitPower(this.transmitPower);
-        } catch (e) {
-            this.sendError(e);
-            this.info('Unable to set transmit power, unsupported function.');
-        }
-
-        // Call extensions
 
         const deviceIterator = this.getClientIterator();
         let deviceCount = 0;
@@ -575,6 +565,7 @@ class ZigbeeController extends EventEmitter {
             if (_key.kind === 'ieee') _key.key = await this.herdsman.getDeviceByIeeeAddr(_key.key);
             const device = _key.key;
             if (device) {
+                const t = Date.now();
                 const mapped = await zigbeeHerdsmanConverters.findByDevice(device);
                 const endpoints = mapped && mapped.endpoint ? mapped.endpoint(device) : null;
                 let endpoint;
@@ -747,7 +738,11 @@ class ZigbeeController extends EventEmitter {
             this.debug('handleDeviceLeave', message);
             const entity = await this.resolveEntity(message.device || message.ieeeAddr);
             const friendlyName = entity ? entity.name : message.ieeeAddr;
-            this.debug(`Device '${friendlyName}' left the network`);
+            if (this.adapter.stController.checkDebugDevice(friendlyName)) {
+                this.emit('device_debug', {ID: Date.now(), data: {flag:'dl', states:[{id: '--', value:'--', payload:message}], IO:true},message:`Device '${friendlyName}' has left the network`});
+            }
+            else
+                this.info(`Device '${friendlyName}' left the network`);
             this.emit('leave', message.ieeeAddr);
             // Call extensions
             this.callExtensionMethod(
@@ -764,7 +759,10 @@ class ZigbeeController extends EventEmitter {
         this.debug('handleDeviceAnnounce', message);
         const entity = await this.resolveEntity(message.device || message.ieeeAddr);
         const friendlyName = entity.name;
-        if (this.warnOnDeviceAnnouncement) {
+        if (this.adapter.stController.checkDebugDevice(friendlyName)) {
+            this.emit('device_debug', {ID: Date.now(), data: {flag:'da', states:[{id: '--', value:'--', payload:message}] , IO:true} ,message:`Device '${friendlyName}' announced itself`});
+        }
+        else if (this.warnOnDeviceAnnouncement) {
             this.warn(`Device '${friendlyName}' announced itself`);
         } else {
             this.info(`Device '${friendlyName}' announced itself`);
@@ -883,7 +881,7 @@ class ZigbeeController extends EventEmitter {
                 let resolved = await this.resolveEntity(device, 0);
                 if (!resolved) {
                     resolved = { name:'unresolved device', device:device }
-                    this.warn('resolve Entity failed for ' + device.ieeeAddr)
+                    this.debug('resolve Entity failed for ' + device.ieeeAddr)
                 }
                 let result;
 
@@ -943,9 +941,9 @@ class ZigbeeController extends EventEmitter {
 
             callback && callback({lqis, routing, errors});
             if (errors.length) {
-                this.warn(`Map Data collection complete with ${errors.length} issues:`);
+                this.debug(`Map Data collection complete with ${errors.length} issues:`);
                 for (const msg of errors)
-                    this.warn(msg);
+                    this.debug(msg);
             }
             else
                 this.info('Map data collection complete');