iobroker.zigbee 1.8.0 → 1.8.3

package/lib/utils.js

@@ -24,7 +24,7 @@ function bulbLevelToAdapterLevel(bulbLevel) {
     // - Bulb level range [2...254] is linearly mapped to adapter level range [1...100].
     if (bulbLevel >= 2) {
         // Perform linear mapping of range [2...254] to [1...100]
-        return Math.round((bulbLevel - 2) * 99 / 252) + 1;
+        return (Math.round((bulbLevel - 2) * 99 / 252) + 1);
     } else {
         // The bulb is considered off. Even a bulb level of "1" is considered as off.
         return 0;
@@ -42,7 +42,7 @@ function adapterLevelToBulbLevel(adapterLevel) {
     // Please read the comments there regarding the rules applied here for mapping the values.
     if (adapterLevel) {
         // Perform linear mapping of range [1...100] to [2...254]
-        return Math.round((adapterLevel - 1) * 252 / 99) + 2;
+        return (Math.round((adapterLevel - 1) * 252 / 99) + 2);
     } else {
         // Switch the bulb off. Some bulbs need "0" (IKEA), others "1" (HUE), and according to the
         // ZigBee docs "1" is the "minimum possible level"... we choose "0" here which seems to work.
@@ -53,7 +53,7 @@ function adapterLevelToBulbLevel(adapterLevel) {
 function bytesArrayToWordArray(ba) {
     const wa = [];
     for (let i = 0; i < ba.length; i++) {
-        wa[(i / 2) | 0] |= ba[i] << (8 * (i % 2));
+        wa[(i / 2) | 0] |= ba[i] << (8*(i % 2));
     }
     return wa;
 }
@@ -91,25 +91,24 @@ function decimalToHex(decimal, padding) {
 
 function getZbId(adapterDevId) {
     const idx = adapterDevId.indexOf('group');
-    if (idx > 0) {
-        return adapterDevId.substr(idx+6);
-    }
-    return `0x${adapterDevId.split('.')[2]}`;
+    if (idx > 0) return adapterDevId.substr(idx+6);
+    return '0x' + adapterDevId.split('.')[2];
 }
 
 function getAdId(adapter, id) {
-    return `${adapter.namespace}.${id.split('.')[2]}`; // iobroker device id
+    return adapter.namespace + '.' + id.split('.')[2]; // iobroker device id
 }
 
 function flatten(arr) {
-    return arr.reduce((flat, toFlatten) =>
-        flat.concat(Array.isArray(toFlatten) ? flatten(toFlatten) : toFlatten), []);
+    return arr.reduce((flat, toFlatten) => {
+        return flat.concat(Array.isArray(toFlatten) ? flatten(toFlatten) : toFlatten);
+    }, []);
 }
 
 const forceEndDevice = flatten(
     ['QBKG03LM', 'QBKG04LM', 'ZNMS13LM', 'ZNMS12LM']
-        .map(model => zigbeeHerdsmanConverters.devices.find((d) => d.model === model))
-        .map(mappedModel => mappedModel.zigbeeModel));
+        .map((model) => zigbeeHerdsmanConverters.devices.find((d) => d.model === model))
+        .map((mappedModel) => mappedModel.zigbeeModel));
 
 // Xiaomi uses 4151 and 4447 (lumi.plug) as manufacturer ID.
 const xiaomiManufacturerID = [4151, 4447];
@@ -118,7 +117,7 @@ const ikeaTradfriManufacturerID = [4476];
 function sanitizeImageParameter(parameter) {
     const replaceByDash = [/\?/g, /&/g, /[^a-z\d\-_./:]/gi, /[/]/gi];
     let sanitized = parameter;
-    replaceByDash.forEach(r => sanitized = sanitized.replace(r, '-'));
+    replaceByDash.forEach((r) => sanitized = sanitized.replace(r, '-'));
     return sanitized;
 }
 
@@ -133,7 +132,7 @@ function getDeviceIcon(definition) {
     return icon;
 }
 
-exports.secondsToMilliseconds   = seconds => seconds * 1000;
+exports.secondsToMilliseconds   = (seconds) => seconds * 1000;
 exports.bulbLevelToAdapterLevel = bulbLevelToAdapterLevel;
 exports.adapterLevelToBulbLevel = adapterLevelToBulbLevel;
 exports.bytesArrayToWordArray   = bytesArrayToWordArray;
@@ -142,11 +141,11 @@ exports.miredKelvinConversion   = miredKelvinConversion;
 exports.decimalToHex            = decimalToHex;
 exports.getZbId                 = getZbId;
 exports.getAdId                 = getAdId;
-exports.isRouter                = device => device.type === 'Router' && !forceEndDevice.includes(device.modelID);
-exports.isBatteryPowered        = device => device.powerSource && device.powerSource === 'Battery';
-exports.isXiaomiDevice          = device =>
-    device.modelID !== 'lumi.router' &&
-    xiaomiManufacturerID.includes(device.manufacturerID) &&
-    (!device.manufacturerName || !device.manufacturerName.startsWith('Trust'));
-exports.isIkeaTradfriDevice     = device => ikeaTradfriManufacturerID.includes(device.manufacturerID);
-exports.getDeviceIcon           = getDeviceIcon;
+exports.isRouter                = (device) => device.type === 'Router' && !forceEndDevice.includes(device.modelID);
+exports.isBatteryPowered        = (device) => device.powerSource && device.powerSource === 'Battery';
+exports.isXiaomiDevice          = (device) => {
+    return device.modelID !== 'lumi.router' && xiaomiManufacturerID.includes(device.manufacturerID) &&
+            (!device.manufacturerName || !device.manufacturerName.startsWith('Trust'));
+};
+exports.isIkeaTradfriDevice     = (device) => ikeaTradfriManufacturerID.includes(device.manufacturerID);
+exports.getDeviceIcon            = getDeviceIcon;

package/lib/zbBaseExtension.js

@@ -14,18 +14,18 @@ class BaseExtension {
     }
 
     error(message, data) {
-        this.zigbee.error(`${this.name}:${message}`, data);
+        this.zigbee.error(this.name + ':' + message, data);
     }
 
     warn(message, data) {
-        this.zigbee.warn(`${this.name}:${message}`, data);
+        this.zigbee.warn(this.name + ':' + message, data);
     }
 
     debug(message, data) {
         if (this.elevate_debug)
-            this.zigbee.warn(`DE ${this.name}:${message}`, data);
+            this.zigbee.warn('DE ' + this.name + ':' + message, data);
         else
-            this.zigbee.debug(`${this.name}:${message}`, data);
+            this.zigbee.debug(this.name + ':' + message, data);
     }
 
     sendError(error, message) {

package/lib/zbDelayedAction.js

@@ -8,11 +8,12 @@ class DelayedAction extends BaseExtension {
 
         this.actions = {};
         this.zigbee.delayAction = this.delayAction.bind(this);
-        this.name = 'DelayedAction';
+        this.name = "DelayedAction";
     }
 
     setOptions(options) {
-        return typeof options === 'object';
+        if (typeof(options) != 'object') return false;
+        return true;
     }
 
 
@@ -29,7 +30,11 @@ class DelayedAction extends BaseExtension {
         //     return false;
         // }
 
-        return device.interviewing !== true;
+        if (device.interviewing === true) {
+            return false;
+        }
+
+        return true;
     }
 
     async onZigbeeStarted() {
@@ -92,7 +97,10 @@ class DelayedAction extends BaseExtension {
             }
             const foundDev = await this.zigbee.getDevice(device.ieeeAddr);
             if (!foundDev) {
-                this.debug(`No found device ${device.ieeeAddr} ${device.modelID}, for doAction`);
+                this.debug(
+                    `No found device ${device.ieeeAddr} ${device.modelID}, ` +
+                        `for doAction`
+                );
                 delete this.actions[device.ieeeAddr];
                 return;
             }
@@ -112,7 +120,7 @@ class DelayedAction extends BaseExtension {
                 try {
                     // do action
                     await actionDef.action(device);
-                    this.info(`Do action successfully ${device.ieeeAddr} ${device.modelID}`);
+                    this.info(`Do action succesfully ${device.ieeeAddr} ${device.modelID}`);
                     toDelete.push(actionDef);
                 } catch (error) {
                     this.sendError(error);

package/lib/zbDeviceAvailability.js

@@ -44,77 +44,65 @@ class DeviceAvailability extends BaseExtension {
         // force publish availability for new devices
         this.zigbee.on('new', (entity) => {
             // wait for 1s for creating device states
-            setTimeout(() =>
-                this.publishAvailability(entity.device, true, true), 1000);
+            setTimeout(() => {
+                this.publishAvailability(entity.device, true, true);
+            }, 1000);
         });
         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.name = 'DeviceAvailability';
+        this.name = "DeviceAvailability";
         this.elevate_debug = false;
     }
 
     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);
-        }
+        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);
         return true;
     }
 
     isPingable(device) {
         if (this.active_ping)
         {
-            if (this.forced_ping && forcedPingable.find(d => d && d.hasOwnProperty('zigbeeModel') && d.zigbeeModel.includes(device.modelID))) {
+            if (this.forced_ping && forcedPingable.find((d) => d && d.hasOwnProperty('zigbeeModel') && d.zigbeeModel.includes(device.modelID))) {
                 return true;
             }
 
-            return utils.isRouter(device) && !utils.isBatteryPowered(device);
+            const result = utils.isRouter(device) && !utils.isBatteryPowered(device);
+            return result;
         }
         return false;
     }
 
     async getAllPingableDevices() {
         const clients = await this.zigbee.getClients();
-        return clients.filter(d => this.isPingable(d));
+        return clients.filter((d) => this.isPingable(d));
     }
 
     async registerDevicePing(device, entity) {
-        this.debug(`register device Ping for ${JSON.stringify(device.ieeeAddr)}`);
+        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;
-        }
+        if (!this.isPingable(device)) return;
         // ensure we do not already have this device in the queue
-        // TODO: Following does not work, may be `if (this.startDevicePingQueue.find(item => item && item.device === device)) { return; }`
         this.startDevicePingQueue.forEach(item => {
-            if (item && item.device == device) {
+            if (item && item.device == device)
                 return;
-            }
         });
         this.number_of_registered_devices++;
         this.availability_timeout = Math.max(Math.min(this.number_of_registered_devices * AverageTimeBetweenPings,MaxAvailabilityTimeout ),MinAvailabilityTimeout);
-        this.startDevicePingQueue.push({device, entity});
-        if (this.startDevicePingTimeout == null) {
-            this.startDevicePingTimeout = setTimeout(async() =>
-                await this.startDevicePing(), this.startDevicePingDelay);
-        }
+        this.startDevicePingQueue.push({device:device, entity:entity});
+        if (this.startDevicePingTimeout == null)
+            this.startDevicePingTimeout = setTimeout(async() => {
+                await this.startDevicePing();
+            }, this.startDevicePingDelay);
     }
 
     async deregisterDevicePing(device) {
-        this.info(`deregister device Ping for deactivated device ${JSON.stringify(device.ieeeAddr)}`);
+        this.info('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]);
@@ -126,8 +114,9 @@ class DeviceAvailability extends BaseExtension {
         this.startDevicePingTimeout = null;
         const item = this.startDevicePingQueue.shift();
         if (this.startDevicePingQueue.length >0) {
-            this.startDevicePingTimeout = setTimeout(async() =>
-                await this.startDevicePing(), this.startDevicePingDelay);
+            this.startDevicePingTimeout = setTimeout(async() => {
+                await this.startDevicePing();
+            }, this.startDevicePingDelay);
         }
         if (item && item.hasOwnProperty('device')) {
             this.handleIntervalPingable(item.device, item.entity);
@@ -142,13 +131,15 @@ class DeviceAvailability extends BaseExtension {
         const clients = await this.zigbee.getClients();
         //        this.warn('onZigbeeStarted called');
         for (const device of clients) {
+
             if (this.isPingable(device)) {
                 //                this.setTimerPingable(device);
             } else {
                 //                this.warn(`Setting '${device.ieeeAddr}'  as available - battery driven`);
                 this.publishAvailability(device, true);
-                this.timers[device.ieeeAddr] = setInterval(() =>
-                    this.handleIntervalNotPingable(device), utils.secondsToMilliseconds(this.availability_timeout));
+                this.timers[device.ieeeAddr] = setInterval(() => {
+                    this.handleIntervalNotPingable(device);
+                },utils.secondsToMilliseconds(this.availability_timeout));
             }
         }
     }
@@ -163,8 +154,8 @@ class DeviceAvailability extends BaseExtension {
         if (this.isPingable(device)) {
             let pingCount = this.ping_counters[device.ieeeAddr];
             if (pingCount === undefined) {
-                this.ping_counters[device.ieeeAddr] = {failed: 0, reported: 0};
-                pingCount = {failed: 0, reported: 0};
+                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
@@ -194,22 +185,26 @@ class DeviceAvailability extends BaseExtension {
                 this.ping_counters[device.ieeeAddr].failed = 0;
             } catch (error) {
                 this.publishAvailability(device, false);
-                if (pingCount.failed++ <= this.max_ping) {
+                if (pingCount.failed++ <= this.max_ping)
+                {
                     if (pingCount.failed < 2 && pingCount.reported < this.max_ping) {
                         this.warn(`Failed to ping ${ieeeAddr} ${device.modelID}`);
                         pingCount.reported++;
-                    } else {
+                    }
+                    else {
                         this.debug(`Failed to ping ${ieeeAddr} ${device.modelID} on ${pingCount} consecutive attempts`);
                     }
                     this.setTimerPingable(device, pingCount.failed);
                     this.ping_counters[device.ieeeAddr]= pingCount;
-                } else {
+                }
+                else {
                     this.warn(`Stopping to ping ${ieeeAddr} ${device.modelID} after ${pingCount.failed} ping attempts`);
                 }
             }
         }
     }
 
+
     async handleIntervalNotPingable(device) {
         const entity = await this.zigbee.resolveEntity(device.ieeeAddr);
         if (!entity || !device.lastSeen) {
@@ -229,8 +224,9 @@ class DeviceAvailability extends BaseExtension {
         if (this.timers[device.ieeeAddr]) {
             clearTimeout(this.timers[device.ieeeAddr]);
         }
-        this.timers[device.ieeeAddr] = setTimeout(async() =>
-            await this.handleIntervalPingable(device), utils.secondsToMilliseconds(this.availability_timeout * factor));
+        this.timers[device.ieeeAddr] = setTimeout(async() => {
+            await this.handleIntervalPingable(device);
+        }, utils.secondsToMilliseconds(this.availability_timeout * factor));
     }
 
     async stop() {
@@ -238,7 +234,7 @@ class DeviceAvailability extends BaseExtension {
             clearTimeout(timer);
         }
         const clients = await this.zigbee.getClients();
-        clients.forEach(device => this.publishAvailability(device, false));
+        clients.forEach((device) => this.publishAvailability(device, false));
     }
 
     async onReconnect(device) {
@@ -294,7 +290,8 @@ class DeviceAvailability extends BaseExtension {
             const pc = this.ping_counters[device.ieeeAddr];
             if (pc == undefined) {
                 this.ping_counters[device.ieeeAddr] = { failed:0, reported:0 };
-            } else {
+            }
+            else {
                 this.ping_counters[device.ieeeAddr].failed++;
             }
 

package/lib/zbDeviceConfigure.js

@@ -10,17 +10,20 @@ const forcedConfigureOnEachStart = [
     zigbeeHerdsmanConverters.devices.find((d) => d.model === 'ZK03840')
 ];
 
+
+
 class DeviceConfigure extends BaseExtension {
     constructor(zigbee, options) {
         super(zigbee, options);
 
         this.configuring = new Set();
         this.attempts = {};
-        this.name = 'DeviceConfigure';
+        this.name = "DeviceConfigure";
     }
 
     setOptions(options) {
-        return typeof options === 'object';
+        if (typeof(options) != 'object') return false;
+        return true;
     }
 
     shouldConfigure(device, mappedDevice) {
@@ -34,8 +37,11 @@ class DeviceConfigure extends BaseExtension {
             zigbeeHerdsmanConverters.getConfigureKey(mappedDevice)) {
             return false;
         }
+        if (device.interviewing === true) {
+            return false;
+        }
 
-        return device.interviewing !== true;
+        return true;
     }
 
     async onZigbeeStarted() {
@@ -47,7 +53,7 @@ class DeviceConfigure extends BaseExtension {
 
                 if (forcedConfigureOnEachStart.find((d) => d && d.hasOwnProperty('zigbeeModel') && d.zigbeeModel.includes(device.modelID))) {
                     this.debug(`DeviceConfigure ${device.ieeeAddr} ${device.modelID} forced by adapter config`);
-                    device.meta.configured = -1; // Force a reconfiguration for this device
+                    device.meta.configured = -1; // Force a reconfigure for this device
                 }
                 if (this.shouldConfigure(device, mappedDevice)) {
                     this.debug(`DeviceConfigure ${device.ieeeAddr} ${device.modelID} needed`);
@@ -58,7 +64,9 @@ class DeviceConfigure extends BaseExtension {
             }
         } catch (error) {
             this.sendError(error);
-            this.error(`Failed to DeviceConfigure.onZigbeeStarted (${error.stack})`);
+            this.error(
+                `Failed to DeviceConfigure.onZigbeeStarted (${error.stack})`,
+            );
         }
     }
 
@@ -70,7 +78,9 @@ class DeviceConfigure extends BaseExtension {
             }
         } catch (error) {
             this.sendError(error);
-            this.error(`Failed to DeviceConfigure.onZigbeeEvent (${error.stack})`);
+            this.error(
+                `Failed to DeviceConfigure.onZigbeeEvent (${error.stack})`,
+            );
         }
     }
 
@@ -85,7 +95,9 @@ class DeviceConfigure extends BaseExtension {
             }
         } catch (error) {
             this.sendError(error);
-            this.error(`Failed to DeviceConfigure.onDeviceRemove (${error.stack})`);
+            this.error(
+                `Failed to DeviceConfigure.onDeviceRemove (${error.stack})`,
+            );
         }
     }
 

package/lib/zbDeviceEvent.js

@@ -6,9 +6,10 @@ const zigbeeHerdsmanConverters = require('zigbee-herdsman-converters');
 class DeviceEvent extends BaseExtension {
     constructor(zigbee, options) {
         super(zigbee, options);
-        this.name = 'DeviceEvent';
+        this.name = "DeviceEvent";
     }
 
+
     async onZigbeeStarted() {
         for (const device of await this.zigbee.getClients()) {
             this.callOnEvent(device, 'start', {});
@@ -16,8 +17,8 @@ class DeviceEvent extends BaseExtension {
     }
 
     setOptions(options) {
-        return typeof options === 'object';
-
+        if (typeof(options) != 'object') return false;
+        return true;
     }
 
     onZigbeeEvent(data, mappedDevice) {