iobroker.zigbee 3.0.3 → 3.1.2

package/lib/utils.js

@@ -88,11 +88,13 @@ function decimalToHex(decimal, padding) {
 }
 
 function getZbId(adapterDevId) {
-    const idx = adapterDevId.indexOf('group');
-    if (idx > 0) {
-        return adapterDevId.substr(idx + 6);
+    const pieces = adapterDevId.split('.');
+    const piece = pieces.length > 2 ? pieces[2] : adapterDevId;
+    const idx = piece.indexOf('group_');
+    if (idx > -1) {
+        return Number(piece.substr(idx + 6));
     }
-    return `0x${adapterDevId.split('.')[2]}`;
+    return `0x${piece}`;
 }
 
 function getAdId(adapter, id) {
@@ -197,4 +199,4 @@ exports.getDeviceIcon           = getDeviceIcon;
 exports.getEntityInfo           = getEntityInfo;
 exports.getNetAddress           = getNetAddress;
 exports.byteArrayToString       = byteArrayToString;
-exports.reverseByteString       = reverseByteString;
+exports.reverseByteString       = reverseByteString;

package/lib/zbDeviceAvailability.js

@@ -24,7 +24,7 @@ const AverageTimeBetweenPings = 45; // on average, plan for 30 seconds between p
  * This extensions pings devices to check if they are online.
  */
 class DeviceAvailability extends BaseExtension {
-    constructor(zigbee, options) {
+    constructor(zigbee, options, config) {
         super(zigbee, options);
         this.availability_timeout = 300; //  wait 5 min for live check
         this.timers = {};
@@ -44,12 +44,19 @@ 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 = 500; // 200 ms delay between starting the ping timeout
+        this.startReadDelay = 0;
         this.name = 'DeviceAvailability';
         this.elevate_debug = false;
         this.isStarted = false;
+        this.active_ping = !config.disablePing;
+        this.forced_ping = false;
+        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.debugDevices = [];
     }
 
-    setOptions(options) {
+    /* setOptions(options) {
         if (typeof options !== 'object') {
             return false;
         }
@@ -65,7 +72,26 @@ class DeviceAvailability extends BaseExtension {
         if (typeof options.pingCount === 'number') {
             this.max_ping = Math.min(2, options.pingCount);
         }
+        this.startReadDelay = (typeof options.startReadDelay === 'number') ? Math.max(500, Math.min(10000, options.startReadDelay * 1000)) : 0;
+        this.warn(`DA: setting options to ${JSON.stringify(options)} - Read Delay is ${this.startReadDelay}`)
         return true;
+    } */
+    checkDebugDevice(dev) {
+        if (typeof dev != 'string' || dev == '') return false;
+        if (this.debugDevices === undefined) return false;
+        else
+        {
+            for (const addressPart of this.debugDevices) {
+                if (typeof dev === 'string' && dev.includes(addressPart)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    setLocalVariable(name, value) {
+        this[name] = value;
     }
 
     isPingable(device) {
@@ -132,17 +158,27 @@ class DeviceAvailability extends BaseExtension {
         }
     }
 
+    async startNotPingable(device) {
+        this.publishAvailability(device, true);
+        this.timers[device.ieeeAddr] = setInterval(() =>
+            this.handleIntervalNotPingable(device), utils.secondsToMilliseconds(this.availability_timeout));
+    }
+
     async onZigbeeStarted() {
         // As some devices are not checked for availability (e.g. battery powered devices)
         // we mark these device as online by default.
         // NOTE: The start of active pings for pingable devices is done separately,
         // 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();
+        const clients = await this.zigbee.getClientIterator();
+        const readables = [];
+
         this.isStarted = true;
         //        this.warn('onZigbeeStarted called');
+
         for (const device of clients) {
             if (this.isPingable(device)) {
+                readables.push(device);
                 //                this.setTimerPingable(device);
             } else {
                 //                this.warn(`Setting '${device.ieeeAddr}'  as available - battery driven`);
@@ -151,17 +187,28 @@ class DeviceAvailability extends BaseExtension {
                     this.handleIntervalNotPingable(device), utils.secondsToMilliseconds(this.availability_timeout));
             }
         }
+        if (this.startReadDelay > 0 && readables.length > 0) {
+            this.warn(`Triggering device_query on ${readables.length} devices in ${this.startReadDelay / 1000} seconds.`)
+            setTimeout(() => {
+                readables.forEach(device => this.zigbee.doDeviceQuery(device, Date().now, false));
+            }, this.startReadDelay)
+        }
     }
 
     async handleIntervalPingable(device, entity) {
         if (!this.isStarted) return;
+        const has_elevated_debug = this.checkDebugDevice(device.ieeeAddr)
+
         const ieeeAddr = device.ieeeAddr;
         const resolvedEntity = entity ? entity : await this.zigbee.resolveEntity(ieeeAddr);
         if (!resolvedEntity) {
-            this.warn(`Stop pinging '${ieeeAddr}' ${device.modelID}, device is not known anymore`);
+            const msg = `Stop pinging '${ieeeAddr}' ${device.modelID}, device is not known anymore`
+            if (has_elevated_debug) this.warn(`ELEVADED: ${msg}`);
+            else this.info(msg);
             return;
         }
         if (this.isPingable(device)) {
+            const pt = Date.now();
             let pingCount = this.ping_counters[device.ieeeAddr];
             if (pingCount === undefined) {
                 this.ping_counters[device.ieeeAddr] = {failed: 0, reported: 0};
@@ -171,22 +218,25 @@ class DeviceAvailability extends BaseExtension {
                 //this.warn(`Pinging '${ieeeAddr}' (${device.modelID})`)
                 await device.ping();
                 this.publishAvailability(device, true);
-                //this.warn(`Successfully pinged ${ieeeAddr} (${device.modelID})`);
+                if (has_elevated_debug) this.warn(`ELEVATED : Successfully pinged ${ieeeAddr} (${device.modelID}) in ${Date.now()-pt} ms`);
                 this.setTimerPingable(device, 1);
                 this.ping_counters[device.ieeeAddr].failed = 0;
             } catch (error) {
+                if (has_elevated_debug) this.warn(`ELEVATED : Failed to ping ${ieeeAddr} (${device.modelID}) after ${Date.now()-pt} ms${error && error.message ? ' - '+error.message : ''}`);
                 this.publishAvailability(device, false);
                 if (pingCount.failed++ <= this.max_ping) {
+                    const msg = `Failed to ping ${ieeeAddr} ${device.modelID} for ${JSON.stringify(pingCount)} attempts`
                     if (pingCount.failed < 2 && pingCount.reported < this.max_ping) {
-                        this.info(`Failed to ping ${ieeeAddr} ${device.modelID}`);
+                        if (has_elevated_debug) this.warn(`ELEVATED: ${msg}`); else this.info(msg);
                         pingCount.reported++;
                     } else {
-                        this.debug(`Failed to ping ${ieeeAddr} ${device.modelID} on ${pingCount} consecutive attempts`);
+                        this.debug(msg);
                     }
                     this.setTimerPingable(device, pingCount.failed);
                     this.ping_counters[device.ieeeAddr] = pingCount;
                 } else {
-                    this.info(`Stopping to ping ${ieeeAddr} ${device.modelID} after ${pingCount.failed} ping attempts`);
+                    const msg = `Stopping to ping ${ieeeAddr} ${device.modelID} after ${pingCount.failed} ping attempts`;
+                    if (has_elevated_debug) this.warn(`ELEVATED ${msg}`); else this.info(msg);
                 }
             }
         }
@@ -200,11 +250,15 @@ class DeviceAvailability extends BaseExtension {
         }
 
         const ago = Date.now() - entity.device.lastSeen;
-        this.debug(`Non-pingable device ${entity.device.ieeeAddr} ${entity.device.modelID} was last seen '${ago / 1000}' seconds ago.`);
 
         if (ago > Hours25) {
             this.publishAvailability(entity.device, false);
+            const msg = `Non-pingable device ${entity.device.ieeeAddr} ${entity.device.modelID} was last seen over 25 hrs ago - setting it offline.`
+            if (this.checkDebugDevice(device.ieeeAddr)) this.warn(`ELEVATED: ${msg}`); else this.debug(msg);
+            return;
         }
+        const msg = `Non-pingable device ${entity.device.ieeeAddr} ${entity.device.modelID} was last seen '${ago / 1000}' seconds ago.`
+        if (this.checkDebugDevice(device.ieeeAddr)) this.warn(`ELEVATED: ${msg}`); else this.debug(msg);
     }
 
     setTimerPingable(device, factor) {
@@ -236,7 +290,7 @@ class DeviceAvailability extends BaseExtension {
                 for (const key of toZigbeeCandidates) {
                     const converter = entity.mapped.toZigbee.find((tz) => tz.key.includes(key));
                     if (converter && !used.includes(converter)) {
-                        await converter.convertGet(device.endpoints[0], key, {});
+                        await converter.convertGet(device.endpoints[0], key, {device:entity.device});
                         used.push(converter);
                     }
                 }
@@ -266,7 +320,7 @@ class DeviceAvailability extends BaseExtension {
         }
     }
 
-    onZigbeeEvent(data) {
+    async onZigbeeEvent(data) {
         const device = data.device;
         if (!device || this.forcedNonPingable[device.ieeeAddr]) {
             return;
@@ -287,16 +341,19 @@ class DeviceAvailability extends BaseExtension {
 
             const online = this.state.hasOwnProperty(device.ieeeAddr) && this.state[device.ieeeAddr];
             if (online && data.type === 'deviceAnnounce' && !utils.isIkeaTradfriDevice(device)) {
-                /**
-                 * 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.
-                 */
-                this.onReconnect(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.
+                     */
+                    this.onReconnect(device);
+                }
             }
         }
     }

package/lib/zbDeviceEvent.js

@@ -21,7 +21,7 @@ class DeviceEvent extends BaseExtension {
     }
 
     async onZigbeeEvent(data, mappedDevice) {
-        if (data.device) {
+        if (data && data.device && data.type) {
             this.callOnEvent(data.device, data.type, data, mappedDevice);
         }
     }