iobroker.zigbee 2.0.4 → 3.0.0

package/lib/utils.js

@@ -1,7 +1,5 @@
 'use strict';
 
-const zigbeeHerdsmanConverters = require('zigbee-herdsman-converters');
-
 /**
  * Converts a bulb level of range [0...254] to an adapter level of range [0...100]
  * @param {number} the bulb level of range [0...254]
@@ -125,18 +123,13 @@ function sanitizeImageParameter(parameter) {
 }
 
 function getDeviceIcon(definition) {
-    let icon = definition.icon;
+    const icon = definition.icon;
     if (icon) {
-        icon = icon.replace('${model}', sanitizeImageParameter(definition.model));
-    }
-    //    if (!icon) {
-    //        icon = `https://www.zigbee2mqtt.io/images/devices/${sanitizeImageParameter(definition.model)}.jpg`;
-    //    }
-    if (!icon) {
-        icon = `https://www.zigbee2mqtt.io/images/devices/${sanitizeImageParameter(definition.model)}.png`;
+        return icon;
     }
-    return icon;
+    return `https://www.zigbee2mqtt.io/images/devices/${sanitizeImageParameter(definition.model)}.png`;
 }
+
 function getModelRegEx( model) {
     const stripModel = (model) ? model.replace(/\0.*$/g, '').trim() : '';
     return stripModel;
@@ -149,6 +142,40 @@ function getEntityInfo(entity) {
     return `getEntityInfo: Illegal Entity ${JSON.stringify(entity)}`;
 }
 
+
+function byteArrayToString(data) {
+    if (data) {
+        return data.map(function (x) {
+            x = x + 0x100;  // twos complement
+            x = x.toString(16); // to hex
+            x = ('00'+x).substr(-2); // zero-pad to 8-digits
+            return x
+        }).join('');
+    }
+    else return '';
+}
+
+function getNetAddress(address) {
+    const TcpData = address.match(/[tT][cC][pP]:\/\/(.+)/);
+    if (TcpData) {
+        const hostarr = TcpData[1].split(':');
+        return { strAddress :`tcp://${hostarr.length > 1 ? hostarr[0]+':'+hostarr[1] : hostarr[0]}`, host:hostarr[0], port:(hostarr.length > 1 ? hostarr[1] : undefined) };
+    }
+    return {};
+}
+
+function reverseByteString(source) {
+    if (source && typeof source == 'string') {
+        const rv = [];
+        for (let i=0;i<source.length;i+=2)
+            rv.push(source.slice(i,i+2))
+        return rv.reverse().join('');
+    }
+    return '';
+}
+
+
+
 exports.secondsToMilliseconds   = seconds => seconds * 1000;
 exports.bulbLevelToAdapterLevel = bulbLevelToAdapterLevel;
 exports.adapterLevelToBulbLevel = adapterLevelToBulbLevel;
@@ -168,3 +195,6 @@ exports.isXiaomiDevice          = device =>
 exports.isIkeaTradfriDevice     = device => ikeaTradfriManufacturerID.includes(device.manufacturerID);
 exports.getDeviceIcon           = getDeviceIcon;
 exports.getEntityInfo           = getEntityInfo;
+exports.getNetAddress           = getNetAddress;
+exports.byteArrayToString       = byteArrayToString;
+exports.reverseByteString       = reverseByteString;

package/lib/zbDeviceAvailability.js

@@ -178,7 +178,7 @@ class DeviceAvailability extends BaseExtension {
                 this.publishAvailability(device, false);
                 if (pingCount.failed++ <= this.max_ping) {
                     if (pingCount.failed < 2 && pingCount.reported < this.max_ping) {
-                        this.warn(`Failed to ping ${ieeeAddr} ${device.modelID}`);
+                        this.info(`Failed to ping ${ieeeAddr} ${device.modelID}`);
                         pingCount.reported++;
                     } else {
                         this.debug(`Failed to ping ${ieeeAddr} ${device.modelID} on ${pingCount} consecutive attempts`);
@@ -186,7 +186,7 @@ class DeviceAvailability extends BaseExtension {
                     this.setTimerPingable(device, pingCount.failed);
                     this.ping_counters[device.ieeeAddr] = pingCount;
                 } else {
-                    this.warn(`Stopping to ping ${ieeeAddr} ${device.modelID} after ${pingCount.failed} ping attempts`);
+                    this.info(`Stopping to ping ${ieeeAddr} ${device.modelID} after ${pingCount.failed} ping attempts`);
                 }
             }
         }

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;
+    async handleConfigureQueue() {
+        if (this.deviceConfigureQueue.length < 1) {
+            this.info('Handled all devices Queued for configuration.')
+            clearInterval(this.configureIntervall);
+            this.configureIntervall == null;
+            return;
         }
-        if (!mappedDevice || !mappedDevice.configure) {
-            return false;
-        }
-        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;
+        }
+        if (!mappedDevice || !mappedDevice.configure) {
+            return false;
         }
-        return this.checkDelayedConfigure(device, 10);
+        // 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,39 +152,69 @@ 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.attempts++;
+                        com.timestamp = Date.now();
+                        if ( com.count < 0) {
+                            delete this.configureOnMessageAttempts[device.ieeeAddr];
+                            this.info(`Configure on message abandoned for ${device.ieeeAddr} ${mappedDevice.model} after failing ${com.attempts} times.`)
+                        }
+                        else this.info(`Timeout trying to configure ${device.ieeeAddr} ${mappedDevice.model} (${com.count}).`)
+                    }
+                    else {
+                        this.info(`Timeout trying to configure ${device.ieeeAddr} ${mappedDevice.model} (starting CoM).`)
+                        this.configureOnMessageAttempts[device.ieeeAddr] = {
+                            count: 5,
+                            timestamp: 0,
+                            attempts: 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;
                 }
 
 
             }
         }
         return 'no return value specified';
+
+
+    }
+
+    async stop() {
+        clearInterval(this.configureIntervall);
+        this.configureOnMessageAttempts = {};
     }
 }