iobroker.zigbee 1.7.5 → 1.8.0

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,24 +91,25 @@ 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) => {
-        return flat.concat(Array.isArray(toFlatten) ? flatten(toFlatten) : toFlatten);
-    }, []);
+    return arr.reduce((flat, toFlatten) =>
+        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];
@@ -117,7 +118,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;
 }
 
@@ -132,7 +133,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;
@@ -141,11 +142,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) => {
-    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;
+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;

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,12 +8,11 @@ class DelayedAction extends BaseExtension {
 
         this.actions = {};
         this.zigbee.delayAction = this.delayAction.bind(this);
-        this.name = "DelayedAction";
+        this.name = 'DelayedAction';
     }
 
     setOptions(options) {
-        if (typeof(options) != 'object') return false;
-        return true;
+        return typeof options === 'object';
     }
 
 
@@ -30,11 +29,7 @@ class DelayedAction extends BaseExtension {
         //     return false;
         // }
 
-        if (device.interviewing === true) {
-            return false;
-        }
-
-        return true;
+        return device.interviewing !== true;
     }
 
     async onZigbeeStarted() {
@@ -97,10 +92,7 @@ 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;
             }
@@ -120,7 +112,7 @@ class DelayedAction extends BaseExtension {
                 try {
                     // do action
                     await actionDef.action(device);
-                    this.info(`Do action succesfully ${device.ieeeAddr} ${device.modelID}`);
+                    this.info(`Do action successfully ${device.ieeeAddr} ${device.modelID}`);
                     toDelete.push(actionDef);
                 } catch (error) {
                     this.sendError(error);

package/lib/zbDeviceAvailability.js

@@ -44,65 +44,77 @@ 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;
             }
 
-            const result = utils.isRouter(device) && !utils.isBatteryPowered(device);
-            return result;
+            return utils.isRouter(device) && !utils.isBatteryPowered(device);
         }
         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:device, entity:entity});
-        if (this.startDevicePingTimeout == null)
-            this.startDevicePingTimeout = setTimeout(async() => {
-                await this.startDevicePing();
-            }, this.startDevicePingDelay);
+        this.startDevicePingQueue.push({device, 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]);
@@ -114,9 +126,8 @@ 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);
@@ -131,15 +142,13 @@ 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));
             }
         }
     }
@@ -154,8 +163,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
@@ -185,26 +194,22 @@ 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) {
@@ -224,9 +229,8 @@ 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() {
@@ -234,7 +238,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) {
@@ -290,8 +294,7 @@ 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,20 +10,17 @@ 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) {
-        if (typeof(options) != 'object') return false;
-        return true;
+        return typeof options === 'object';
     }
 
     shouldConfigure(device, mappedDevice) {
@@ -37,11 +34,8 @@ class DeviceConfigure extends BaseExtension {
             zigbeeHerdsmanConverters.getConfigureKey(mappedDevice)) {
             return false;
         }
-        if (device.interviewing === true) {
-            return false;
-        }
 
-        return true;
+        return device.interviewing !== true;
     }
 
     async onZigbeeStarted() {
@@ -53,7 +47,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 reconfigure for this device
+                    device.meta.configured = -1; // Force a reconfiguration for this device
                 }
                 if (this.shouldConfigure(device, mappedDevice)) {
                     this.debug(`DeviceConfigure ${device.ieeeAddr} ${device.modelID} needed`);
@@ -64,9 +58,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.stack})`);
         }
     }
 
@@ -78,9 +70,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.stack})`);
         }
     }
 
@@ -95,9 +85,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.stack})`);
         }
     }
 
@@ -142,10 +130,17 @@ class DeviceConfigure extends BaseExtension {
     async doConfigure(device, mappedDevice) {
         this.info(`Configuring ${device.ieeeAddr} ${device.modelID}`);
         const coordinatorEndpoint = await this.zigbee.getDevicesByType('Coordinator')[0].endpoints[0];
-        await mappedDevice.configure(device, coordinatorEndpoint);
-        device.meta.configured = zigbeeHerdsmanConverters.getConfigureKey(mappedDevice);
-        device.save();
-        this.info(`DeviceConfigure successful ${device.ieeeAddr} ${device.modelID}`);
+        try {
+            await mappedDevice.configure(device, coordinatorEndpoint);
+            device.meta.configured = zigbeeHerdsmanConverters.getConfigureKey(mappedDevice);
+            device.save();
+            this.info(`DeviceConfigure successful ${device.ieeeAddr} ${device.modelID}`);
+        } catch (error) {
+            this.sendError(error);
+            this.error(
+                `Failed to DeviceConfigure.configure ${device.ieeeAddr} ${device.modelID} (${error.stack})`,
+            );
+        }
     }
 }
 

package/lib/zbDeviceEvent.js

@@ -6,10 +6,9 @@ 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', {});
@@ -17,8 +16,8 @@ class DeviceEvent extends BaseExtension {
     }
 
     setOptions(options) {
-        if (typeof(options) != 'object') return false;
-        return true;
+        return typeof options === 'object';
+
     }
 
     onZigbeeEvent(data, mappedDevice) {