iobroker.zigbee 3.0.5 → 3.1.4

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/zbDelayedAction.js

@@ -45,10 +45,10 @@ class DelayedAction extends BaseExtension {
 
     onZigbeeEvent(data) {
         try {
-            const device = data.device;
-            // if (this.shouldAction(device, mappedDevice)) {
-            this.doActions(device);
-            // }
+            if (data && data.device) {
+                const device = data.device;
+                this.doActions(device);
+            }
         } catch (error) {
             this.sendError(error);
             this.error(

package/lib/zbDeviceAvailability.js

@@ -1,7 +1,6 @@
 'use strict';
 
 const BaseExtension = require('./zbBaseExtension');
-const zigbeeHerdsmanConverters = require('zigbee-herdsman-converters');
 const utils = require('./utils');
 
 // Some EndDevices should be pinged
@@ -19,20 +18,23 @@ const Hours25 = 1000 * 60 * 60 * 25;
 const MinAvailabilityTimeout = 300; // ping every 5 minutes with few devices
 const MaxAvailabilityTimeout = 1800; // ping every 30 minutes with many devices;
 const AverageTimeBetweenPings = 45; // on average, plan for 30 seconds between pings.
+const pingClusters = {
+    c0a0: {id:'genBasic', attribute:'zclVersion'},
+    c0a5: {id:'genBasic', attribute:'modelId'},
+    c25a0: {id:'genOta', attribute:'upgradeServerId'},
+};
 
 /**
  * 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 = {};
         this.ping_counters = {};
         this.max_ping = 3;
         this.state = {};
-        this.active_ping = true;
-        this.forced_ping = true;
         this.forcedNonPingable = {};
         this.number_of_registered_devices = 0;
         // force publish availability for new devices
@@ -44,28 +46,34 @@ 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.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.debugDevices = [];
+        this.pingCluster = pingClusters[config.pingCluster] ? pingClusters[config.pingCluster] : {};
     }
 
-    setOptions(options) {
-        if (typeof options !== 'object') {
-            return false;
-        }
-        if (options.disableActivePing) {
-            this.active_ping = false;
-        }
-        if (options.disableForcedPing) {
-            this.forced_ping = false;
-        }
-        if (typeof options.pingTimeout === 'number') {
-            this.availability_timeout = Math.min(60, options.pingTimeout);
-        }
-        if (typeof options.pingCount === 'number') {
-            this.max_ping = Math.min(2, options.pingCount);
+    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 true;
+        return false;
+    }
+
+    setLocalVariable(name, value) {
+        this[name] = value;
     }
 
     isPingable(device) {
@@ -89,7 +97,6 @@ class DeviceAvailability extends BaseExtension {
         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}'`);
         if (!this.isPingable(device)) {
             return;
         }
@@ -119,7 +126,6 @@ class DeviceAvailability extends BaseExtension {
     }
 
     async startDevicePing() {
-        //        this.warn(JSON.stringify(this));
         if (!this.isStarted) return;
         this.startDevicePingTimeout = null;
         const item = this.startDevicePingQueue.shift();
@@ -132,61 +138,104 @@ 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');
+        this.debug('onZigbeeStarted called');
+
         for (const device of clients) {
-            if (this.isPingable(device)) {
+            if (this.isPingable(device) && this.active_ping) {
+                readables.push(device);
                 //                this.setTimerPingable(device);
             } else {
-                //                this.warn(`Setting '${device.ieeeAddr}'  as available - battery driven`);
+                this.debug(`Setting '${device.ieeeAddr}'  as available - battery driven or no active availability check`);
                 this.publishAvailability(device, true);
                 this.timers[device.ieeeAddr] = setInterval(() =>
                     this.handleIntervalNotPingable(device), utils.secondsToMilliseconds(this.availability_timeout));
             }
         }
+        if (this.startReadDelay > 0 && readables.length > 0) {
+            this.info(`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;
+        if (!this.active_ping) {
+            return await this.handleIntervalnonPingable();
+        }
+        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};
                 pingCount = {failed: 0, reported: 0};
             }
             try {
-                //this.warn(`Pinging '${ieeeAddr}' (${device.modelID})`)
-                await device.ping();
+                if (!this.pingCluster || !this.pingCluster.hasOwnProperty('id')) {
+                    this.debug(`Pinging '${ieeeAddr}' (${device.modelID}) via ZH Ping`)
+                    await device.ping();
+                }
+                else {
+                    const zclData = {};
+                    zclData[this.pingCluster.attribute] = {};
+                    this.debug(`Pinging '${ieeeAddr}' (${device.modelID}) via ZCL Read with ${this.pingCluster.id}:${this.pingCluster.attribute}`)
+                    await this.zigbee.publish(device, this.pingCluster.id, 'read', zclData, null, undefined, 'foundation');
+                }
                 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 (error && error.message && error.message.includes('UNSUPPORTED_ATTRIBUTE')) {
+                    // this error is acceptable, as it is raised off an answer of the device.
+                    this.publishAvailability(device, true);
+                    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;
+                    return;
+                }
+                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 +249,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 +289,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 +319,7 @@ class DeviceAvailability extends BaseExtension {
         }
     }
 
-    onZigbeeEvent(data) {
+    async onZigbeeEvent(data) {
         const device = data.device;
         if (!device || this.forcedNonPingable[device.ieeeAddr]) {
             return;
@@ -287,16 +340,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/zbDeviceConfigure.js

@@ -90,6 +90,7 @@ class DeviceConfigure extends BaseExtension {
     }
 
     onZigbeeEvent(data, mappedDevice) {
+        if (!mappedDevice || !data.device) return;
         try {
             const device = data.device;
             const com = this.configureOnMessageAttempts[device.ieeeAddr];
@@ -100,7 +101,13 @@ class DeviceConfigure extends BaseExtension {
                     this.info('Configure on Message for ' + device.ieeeAddr);
                     this.doConfigure(device, mappedDevice);
                 }
+                return;
+            }
+            // check if the event is a 'deviceInterview successful' Event
+            if (data.type == 'deviceJoined' || data.type == 'deviceInterview' && data.status == 'successful') {
+                this.PushDeviceToQueue(device, mappedDevice);
             }
+
         } catch (error) {
             this.sendError(error);
             this.error(`Failed to DeviceConfigure.onZigbeeEvent (${error && error.message ? error.message : 'no error message'})`);

package/lib/zbDeviceEvent.js

@@ -2,7 +2,6 @@
 
 const BaseExtension = require('./zbBaseExtension');
 const zigbeeHerdsmanConverters = require('zigbee-herdsman-converters');
-
 class DeviceEvent extends BaseExtension {
     constructor(zigbee, options) {
         super(zigbee, options);
@@ -10,8 +9,10 @@ class DeviceEvent extends BaseExtension {
     }
 
     async onZigbeeStarted() {
-        for (const device of await this.zigbee.getClients()) {
-            await this.callOnEvent(device, 'start', {});
+        for (const device of await this.zigbee.getClientIterator()) {
+            const entity = await this.zigbee.resolveEntity(device);
+
+            await this.callOnEvent(device, 'start', {device, options:entity.options || {}});
         }
     }
 
@@ -21,7 +22,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);
         }
     }
@@ -29,7 +30,7 @@ class DeviceEvent extends BaseExtension {
     async stop() {
         if (this.zigbee.getClients() > 0) {
             for (const device of await this.zigbee.getClients()) {
-                await this.callOnEvent(device, 'stop', {});
+                await this.callOnEvent(device, 'stop', {ieeeAddr:device.ieeeAddr});
             }
         }
     }
@@ -38,9 +39,41 @@ class DeviceEvent extends BaseExtension {
         if (!mappedDevice) {
             mappedDevice = await zigbeeHerdsmanConverters.findByDevice(device);
         }
+        const baseData = {device, deviceExposeChanged: function() { return; }, options: data.options || {}, state: data.state || {}}
+        const eventData = {
+            type,
+        }
 
-        if (mappedDevice && mappedDevice.onEvent) {
-            mappedDevice.onEvent(type, data, device,mappedDevice.options,'{}');
+        switch (type) {
+            case 'start':
+            case 'deviceNetworkAddressChanged':
+            case 'deviceAnnounce':
+            case `deviceJoined`:
+            {
+                eventData.data = baseData;
+                break;
+            }
+            case 'stop':
+                eventData.data = { ieeeAddr:device.ieeeAddr };
+                break;
+            case 'deviceInterview':
+                eventData.data = {...baseData,status: data.status};
+                break;
+            case 'deviceOptionsChanged':
+                // NOTE: This does not currently work. OptionsChange is not yet defined.
+                eventData.data = {...baseData, from:data.from || {}, to:data.to || {}};
+                break;
+        }
+
+
+        if (mappedDevice && mappedDevice.onEvent && eventData.data) {
+            this.warn(`calling onEvent for ${eventData.type} on ${device.ieeeAddr}`);
+            try {
+                mappedDevice.onEvent(eventData);
+            }
+            catch (error) {
+                this.warn(`Error in onEvent: ${error && error.message ? error.message : 'no message'}`);
+            }
         }
     }
 }