iobroker.zigbee 2.0.0 → 2.0.2

package/lib/utils.js

@@ -106,11 +106,13 @@ function flatten(arr) {
         flat.concat(Array.isArray(toFlatten) ? flatten(toFlatten) : toFlatten), []);
 }
 
-const forceEndDevice = flatten(
+const forceEndDevice = ['QBKG03LM', 'QBKG04LM', 'ZNMS13LM', 'ZNMS12LM'];
+
+/*flatten(
     ['QBKG03LM', 'QBKG04LM', 'ZNMS13LM', 'ZNMS12LM']
         .map(model => zigbeeHerdsmanConverters.findByModel(model))
         .map(mappedModel => mappedModel.zigbeeModel));
-
+*/
 // Xiaomi uses 4151 and 4447 (lumi.plug) as manufacturer ID.
 const xiaomiManufacturerID = [4151, 4447];
 const ikeaTradfriManufacturerID = [4476];
@@ -157,7 +159,7 @@ exports.decimalToHex            = decimalToHex;
 exports.getZbId                 = getZbId;
 exports.getAdId                 = getAdId;
 exports.getModelRegEx           = getModelRegEx;
-exports.isRouter                = device => device.type === 'Router' && !forceEndDevice.includes(device.modelID);
+exports.isRouter                = device => (device.type === 'Router' || (typeof device.powerSource == 'string' && device.powerSource.startsWith('Mains'))) && !forceEndDevice.includes(device.modelID);
 exports.isBatteryPowered        = device => device.powerSource && device.powerSource === 'Battery';
 exports.isXiaomiDevice          = device =>
     device.modelID !== 'lumi.router' &&

package/lib/zbDeviceAvailability.js

@@ -6,13 +6,7 @@ const utils = require('./utils');
 
 // Some EndDevices should be pinged
 // e.g. E11-G13 https://github.com/Koenkk/zigbee2mqtt/issues/775#issuecomment-453683846
-const forcedPingable = [
-    zigbeeHerdsmanConverters.findByModel('E11-G13'),
-    zigbeeHerdsmanConverters.findByModel('53170161'),
-    zigbeeHerdsmanConverters.findByModel('V3-BTZB'),
-    zigbeeHerdsmanConverters.findByModel('SPZB0001'),
-    zigbeeHerdsmanConverters.findByModel('014G2461')
-];
+const forcedPingable = ['E11-G13','53170161','V3-BTZB','SPZB0001','014G2461'];
 
 // asgothian: 29.12.2020: Removed color and color_temp from readable
 // state candidates as most states do not provide a getter to ikea_transform
@@ -49,9 +43,10 @@ class DeviceAvailability extends BaseExtension {
         });
         this.startDevicePingQueue = []; // simple fifo array for starting device pings
         this.startDevicePingTimeout = null; // handle for the timeout which empties the queue
-        this.startDevicePingDelay = 200; // 200 ms delay between starting the ping timeout
+        this.startDevicePingDelay = 500; // 200 ms delay between starting the ping timeout
         this.name = 'DeviceAvailability';
         this.elevate_debug = false;
+        this.isStarted = false;
     }
 
     setOptions(options) {
@@ -74,6 +69,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))) {
                 return true;
@@ -90,6 +86,7 @@ class DeviceAvailability extends BaseExtension {
     }
 
     async registerDevicePing(device, entity) {
+        if (!this.isStarted) return;
         this.debug(`register device Ping for ${JSON.stringify(device.ieeeAddr)}`);
         this.forcedNonPingable[device.ieeeAddr] = false;
         //        this.warn(`Called registerDevicePing for '${device}' of '${entity}'`);
@@ -104,6 +101,7 @@ class DeviceAvailability extends BaseExtension {
             }
         });
         this.number_of_registered_devices++;
+        this.debug(`registering device Ping (${this.number_of_registered_devices}) for ${device.ieeeAddr} (${device.modelID})`);
         this.availability_timeout = Math.max(Math.min(this.number_of_registered_devices * AverageTimeBetweenPings, MaxAvailabilityTimeout), MinAvailabilityTimeout);
         this.startDevicePingQueue.push({device, entity});
         if (this.startDevicePingTimeout == null) {
@@ -113,7 +111,7 @@ class DeviceAvailability extends BaseExtension {
     }
 
     async deregisterDevicePing(device) {
-        this.info(`deregister device Ping for deactivated device ${JSON.stringify(device.ieeeAddr)}`);
+        this.debug(`deregister device Ping for deactivated device ${JSON.stringify(device.ieeeAddr)}`);
         this.forcedNonPingable[device.ieeeAddr] = true;
         if (this.timers[device.ieeeAddr]) {
             clearTimeout(this.timers[device.ieeeAddr]);
@@ -122,6 +120,7 @@ class DeviceAvailability extends BaseExtension {
 
     async startDevicePing() {
         //        this.warn(JSON.stringify(this));
+        if (!this.isStarted) return;
         this.startDevicePingTimeout = null;
         const item = this.startDevicePingQueue.shift();
         if (this.startDevicePingQueue.length > 0) {
@@ -140,6 +139,7 @@ class DeviceAvailability extends BaseExtension {
         // triggered by the 'new device' event to ensure that they are handled
         // identically on reconnect, disconnect and new pair (as)
         const clients = await this.zigbee.getClients();
+        this.isStarted = true;
         //        this.warn('onZigbeeStarted called');
         for (const device of clients) {
             if (this.isPingable(device)) {
@@ -154,10 +154,11 @@ class DeviceAvailability extends BaseExtension {
     }
 
     async handleIntervalPingable(device, entity) {
+        if (!this.isStarted) return;
         const ieeeAddr = device.ieeeAddr;
         const resolvedEntity = entity ? entity : await this.zigbee.resolveEntity(ieeeAddr);
         if (!resolvedEntity) {
-            this.debug(`Stop pinging '${ieeeAddr}' ${device.modelID}, device is not known anymore`);
+            this.warn(`Stop pinging '${ieeeAddr}' ${device.modelID}, device is not known anymore`);
             return;
         }
         if (this.isPingable(device)) {
@@ -166,29 +167,11 @@ class DeviceAvailability extends BaseExtension {
                 this.ping_counters[device.ieeeAddr] = {failed: 0, reported: 0};
                 pingCount = {failed: 0, reported: 0};
             }
-
-            // first see if we can "ping" the device by reading a Status
-            try {
-                for (const key of toZigbeeCandidates) {
-                    const converter = resolvedEntity.mapped.toZigbee.find((tz) => tz.key.includes(key));
-                    if (converter) {
-                        await converter.convertGet(device.endpoints[0], key, {});
-                        this.debug(`Successful read state '${key}' of '${device.ieeeAddr}' in stead of pinging`);
-                        this.setTimerPingable(device, 1);
-                        this.ping_counters[device.ieeeAddr].failed = 0;
-                        return;
-                    }
-                }
-            } catch (error) {
-                this.sendError(error);
-                this.debug(`Exception in readState of '${device.ieeeAddr}' - error : '${(error && error.message ? error.message : 'no error message')}'`);
-                // intentionally empty: Just present to ensure we cause no harm
-                // when reading the state fails. => fall back on standard Ping function
-            }
             try {
+                //this.warn(`Pinging '${ieeeAddr}' (${device.modelID})`)
                 await device.ping();
                 this.publishAvailability(device, true);
-                this.debug(`Successfully pinged ${ieeeAddr} ${device.modelID}`);
+                //this.warn(`Successfully pinged ${ieeeAddr} (${device.modelID})`);
                 this.setTimerPingable(device, 1);
                 this.ping_counters[device.ieeeAddr].failed = 0;
             } catch (error) {
@@ -210,6 +193,7 @@ class DeviceAvailability extends BaseExtension {
     }
 
     async handleIntervalNotPingable(device) {
+        if (!this.isStarted) return;
         const entity = await this.zigbee.resolveEntity(device.ieeeAddr);
         if (!entity || !device.lastSeen) {
             return;
@@ -224,6 +208,7 @@ class DeviceAvailability extends BaseExtension {
     }
 
     setTimerPingable(device, factor) {
+        if (!this.isStarted) return;
         if (factor === undefined || factor < 1) {
             factor = 1;
         }
@@ -235,6 +220,7 @@ class DeviceAvailability extends BaseExtension {
     }
 
     async stop() {
+        this.isStarted = false;
         for (const timer of Object.values(this.timers)) {
             clearTimeout(timer);
         }

package/lib/zbDeviceConfigure.js

@@ -3,17 +3,14 @@
 const zigbeeHerdsmanConverters = require('zigbee-herdsman-converters');
 const BaseExtension = require('./zbBaseExtension');
 
-const forcedConfigureOnEachStart = [
-    zigbeeHerdsmanConverters.findByModel('V3-BTZB'),
-    zigbeeHerdsmanConverters.findByModel('014G2461'),
-    zigbeeHerdsmanConverters.findByModel('SPZB0001'),
-    zigbeeHerdsmanConverters.findByModel('ZK03840')
-];
+const forcedConfigureOnEachStart = ['V3-BTZB','014G2461','SPZB0001','ZK03840'];
 
 class DeviceConfigure extends BaseExtension {
     constructor(zigbee, options) {
         super(zigbee, options);
 
+        this.delayedConfigure = {};
+
         this.configuring = new Set();
         this.attempts = {};
         this.name = 'DeviceConfigure';
@@ -35,9 +32,36 @@ class DeviceConfigure extends BaseExtension {
             return false;
         }
 
-        return device.interviewing !== true;
+        return (device.interviewing !== true && this.checkDelayedConfigure(device.ieeeAddr)>0);
+    }
+
+    checkDelayedConfigure(device, num) {
+        if (!this.delayedConfigure.hasOwnProperty(device.ieeeAddr)) {
+            if (num && num > 0) {
+                this.delayedConfigure[device.ieeeAddr] = { maxAttempts:num };
+                return num;
+            }
+            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;
+    }
+
+    delayedConfigureAttempt(device, status) {
+        if (status) {
+            delete this.delayedConfigure[device.ieeeAddr];
+            return 0;
+        }
+        return this.checkDelayedConfigure(device, 10);
     }
 
+
     async onZigbeeStarted() {
         try {
             this.coordinatorEndpoint = await this.zigbee.getDevicesByType('Coordinator')[0].endpoints[0];
@@ -58,7 +82,7 @@ class DeviceConfigure extends BaseExtension {
             }
         } catch (error) {
             this.sendError(error);
-            this.error(`Failed to DeviceConfigure.onZigbeeStarted (${error.stack})`);
+            this.error(`Failed to DeviceConfigure.onZigbeeStarted (${error && error.message ? error.message : 'no error message'})`);
         }
     }
 
@@ -70,7 +94,7 @@ class DeviceConfigure extends BaseExtension {
             }
         } catch (error) {
             this.sendError(error);
-            this.error(`Failed to DeviceConfigure.onZigbeeEvent (${error.stack})`);
+            this.error(`Failed to DeviceConfigure.onZigbeeEvent (${error && error.message ? error.message : 'no error message'})`);
         }
     }
 
@@ -85,7 +109,7 @@ class DeviceConfigure extends BaseExtension {
             }
         } catch (error) {
             this.sendError(error);
-            this.error(`Failed to DeviceConfigure.onDeviceRemove (${error.stack})`);
+            this.error(`Failed to DeviceConfigure.onDeviceRemove (${error && error.message ? error.message : 'no error message'})`);
         }
     }
 
@@ -100,23 +124,11 @@ class DeviceConfigure extends BaseExtension {
     async configure(device, mappedDevice) {
         try {
             if (mappedDevice !== undefined && device !== undefined) {
-                if (this.configuring.has(device.ieeeAddr) || this.attempts[device.ieeeAddr] >= 5) {
-                    return false;
-                }
-
-                this.configuring.add(device.ieeeAddr);
-
-                if (!this.attempts.hasOwnProperty(device.ieeeAddr)) {
-                    this.attempts[device.ieeeAddr] = 0;
-                }
-
                 try {
-                    await this.doConfigure(device, mappedDevice);
-                    //       this.configuring.delete(device.ieeeAddr);
+                    await this.doConfigure(device, mappedDevice)
                 } catch (error) {
                     this.sendError(error);
-                    this.warn(`DeviceConfigure failed ${device.ieeeAddr} ${device.modelID} attempt ${this.attempts[device.ieeeAddr] + 1} (${error.stack})`);
-                    this.attempts[device.ieeeAddr]++;
+                    this.warn(`DeviceConfigure failed ${device.ieeeAddr} ${device.modelID}`);
                 }
             }
         } catch (error) {
@@ -130,23 +142,38 @@ class DeviceConfigure extends BaseExtension {
         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);
+                //await mappedDevice.configure(device, coordinatorEndpoint, this);
 
                 device.meta.configured = zigbeeHerdsmanConverters.getConfigureKey(mappedDevice);
                 device.save();
                 this.info(`DeviceConfigure successful ${device.ieeeAddr} ${device.modelID}`);
+                this.delayedConfigureAttempt(device, true);
+                return '';
             }
         } catch (error) {
             // https://github.com/Koenkk/zigbee2mqtt/issues/14857
             if (error.stack.includes('UNSUPPORTED_ATTRIBUTE')) {
                 // do nothing
             } else {
-                this.sendError(error);
-                this.warn(` ${device.ieeeAddr} ${device.modelID} Failed to configure. When device works is all fine when not wake up the device and check again`);
-                this.debug(` --> ${error.stack} `);
+                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`;
+                } 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'} `
+                }
+
+
             }
         }
+        return 'no return value specified';
     }
 }
 

package/lib/zbDeviceEvent.js

@@ -36,22 +36,11 @@ class DeviceEvent extends BaseExtension {
 
     async callOnEvent(device, type, data, mappedDevice) {
         if (!mappedDevice) {
-            try {
-                mappedDevice = await zigbeeHerdsmanConverters.findByDevice(device);
-            }
-            catch (error) {
-                this.log.error(`onEvent: unable to find mapped device for ${JSON.stringify(device)} `);
-                return;
-            }
+            mappedDevice = await zigbeeHerdsmanConverters.findByDevice(device);
         }
 
         if (mappedDevice && mappedDevice.onEvent) {
-            try {
-                mappedDevice.onEvent(type, data, device,mappedDevice.options,'{}');
-            }
-            catch (error) {
-                this.log.error(`onEvent for ${JSON.stringify(device)} failed with error ${error.message}`);
-            }
+            mappedDevice.onEvent(type, data, device,mappedDevice.options,'{}');
         }
     }
 }