iobroker.zigbee 1.10.14 → 2.0.1

package/lib/zigbeecontroller.js

@@ -11,8 +11,12 @@ const DeviceAvailabilityExt = require('./zbDeviceAvailability');
 const DeviceConfigureExt = require('./zbDeviceConfigure');
 const DeviceEventExt = require('./zbDeviceEvent');
 const DelayedActionExt = require('./zbDelayedAction');
+const Groups = require('./groups');
+
 const utils = require('./utils');
 const { waitForDebugger } = require('inspector');
+const { table } = require('console');
+const { extract } = require('tar');
 const groupConverters = [
     zigbeeHerdsmanConverters.toZigbee.light_onoff_brightness,
     zigbeeHerdsmanConverters.toZigbee.light_color_colortemp,
@@ -68,6 +72,7 @@ class ZigbeeController extends EventEmitter {
             new DeviceEventExt(this, {}),
             new DelayedActionExt(this, {}),
         ];
+        this.herdsmanTimeoutRegexp = new RegExp(/(\d+)ms/);
     }
 
     configure(options) {
@@ -129,6 +134,7 @@ class ZigbeeController extends EventEmitter {
             this.herdsman.on('deviceJoined', this.handleDeviceJoined.bind(this));
             this.herdsman.on('deviceLeave', this.handleDeviceLeave.bind(this));
             this.herdsman.on('message', this.handleMessage.bind(this));
+            this.herdsman.on('permitJoinChanged', this.handlePermitJoinChanged.bind(this));
 
             await this.herdsman.start();
 
@@ -147,10 +153,16 @@ class ZigbeeController extends EventEmitter {
                 i--;
             }
 
-            this.debug(`Zigbee network parameters: panID=${debNetworkParam.panID} channel=${debNetworkParam.channel} extendedPanID=${extPanIDDebug}`);
+            this.info(`Zigbee network parameters: panID=${debNetworkParam.panID} channel=${debNetworkParam.channel} extendedPanID=${extPanIDDebug}`);
         } catch (e) {
+            try {
+                await this.herdsman.stop();
+            }
+            catch (error) {
+                this.warn(`Starting zigbee-herdsman problem : ${error && error.message ? error.message : 'no error message'}`)
+            }
             this.sendError(e);
-            this.error(`Starting zigbee-herdsman problem : ${JSON.stringify(e.message)}`);
+            this.error(`Starting zigbee-herdsman problem : ${(e && e.message ? e.message : 'no error message')}`);
             throw 'Error herdsman start';
         }
         // Check if we have to turn off the LED
@@ -197,38 +209,55 @@ class ZigbeeController extends EventEmitter {
         // Call extensions
         this.callExtensionMethod('onZigbeeStarted', []);
 
-        // Log zigbee clients on startup
-        const devices = await this.getClients();
-        if (devices.length > 0) {
-            this.info(`Currently ${devices.length} devices are joined:`);
-        } else {
-            this.info(`Currently no devices.`);
-        }
+        const deviceIterator = this.getClientIterator();
+        let deviceCount = 0;
+        try {
+            for (const device of deviceIterator) {
+                deviceCount++;
+                const entity = await this.resolveEntity(device);
+                if (!entity) {
+                    this.warn('failed to resolve Entity for ' + device.ieeeAddr);
+                    continue;
+                }
+                this.adapter.getObject(device.ieeeAddr.substr(2), (err, obj) => {
+                    if (obj && obj.common && obj.common.deactivated) {
+                        this.callExtensionMethod('deregisterDevicePing', [device, entity]);
+                    } else {
+                        this.callExtensionMethod('registerDevicePing', [device, entity]);
+                    }
+                });
+                // ensure that objects for all found clients are present
 
-        for (const device of devices) {
-            const entity = await this.resolveEntity(device);
-            this.adapter.getObject(device.ieeeAddr.substr(2), (err, obj) => {
-                if (obj && obj.common && obj.common.deactivated) {
-                    this.callExtensionMethod('deregisterDevicePing', [device, entity]);
-                } else {
-                    this.callExtensionMethod('registerDevicePing', [device, entity]);
+                if (entity.mapped) {
+                    this.emit('new', entity);
                 }
-            });
-            // ensure that objects for all found clients are present
+                this.info(
+                    (entity.device.ieeeAddr) +
+                    ` (addr ${entity.device.networkAddress}): ` +
+                    (entity.mapped ?
+                        `${entity.mapped.model} - ${entity.mapped.vendor} ${entity.mapped.description} ` :
+                        `Unsupported (model ${entity.device.modelID})`) +
+                    `(${entity.device.type})`
+                );
+            }
 
-            if (entity.mapped) {
-                this.emit('new', entity);
+            // Log zigbee clients on startup
+            // const devices = await this.getClients();
+            if (deviceCount > 0) {
+                this.info(`Currently ${deviceCount} devices are joined:`);
+            } else {
+                this.info(`Currently no devices.`);
             }
-            this.info(
-                (entity.device.ieeeAddr) +
-                ` (addr ${entity.device.networkAddress}): ` +
-                (entity.mapped ?
-                    `${entity.mapped.model} - ${entity.mapped.vendor} ${entity.mapped.description} ` :
-                    `Not supported (model ${entity.device.modelID})`) +
-                `(${entity.device.type})`
-            );
         }
-
+        catch (error) {
+            this.error('error iterating devices : '+ (error && error.message ? error.message: 'no reason given'));
+        }
+        try {
+            this.getGroups();
+        }
+        catch (error) {
+            this.error('error iterating groups : '+ (error && error.message ? error.message: 'no reason given'));
+        }
         this.emit('ready');
     }
 
@@ -256,6 +285,12 @@ class ZigbeeController extends EventEmitter {
         this.adapter.sendError(error, message);
     }
 
+    filterHerdsmanError(message) {
+        if (typeof message != 'string' || message == '') return 'no error message';
+        if (message.match(this.herdsmanTimeoutRegexp)) return 'Timeout';
+        return message;
+    }
+
     callExtensionMethod(method, parameters) {
         const result = [];
         for (const extension of this.extensions) {
@@ -288,10 +323,24 @@ class ZigbeeController extends EventEmitter {
         }
     }
 
+    getClientIterator(all) {
+        if (this.herdsman.database) {
+            return this.herdsman.getDevicesIterator( function(device) { return (all? true: device.type !== 'Coordinator')});
+        } else {
+            return [].values();
+        }
+    }
+
     async getGroups() {
         try {
             if (this.herdsman) {
-                return await this.herdsman.getGroups();
+                const rv = [];
+                const groupIterator =  this.herdsman.getGroupsIterator();
+                for (const g of groupIterator) {
+                    const members = await this.getGroupMembersFromController(g.groupID);
+                    rv.push({ id: g.groupID, size: (members ? members.length : 0), stateName: 'group_'+g.groupID});
+                }
+                return rv;
             } else {
                 return null;
             }
@@ -314,32 +363,55 @@ class ZigbeeController extends EventEmitter {
 
     async getGroupByID(id) {
         try {
-            return this.herdsman.getGroupByID(id);
+            const rv = this.herdsman.getGroupByID(id);
+            return rv;
         } catch (error) {
             this.sendError(error);
+            // this.error('error getting group for ' + id + ' ' + (error && error.message ? error.message : 'without message'));
             return undefined;
         }
     }
 
     async verifyGroupExists(id) {
-        const nid = typeof id === 'number' ? id : parseInt(id);
-        let group = await this.herdsman.getGroupByID(nid);
-        if (!group) {
-            group = await this.herdsman.createGroup(nid);
-            group.toZigbee = groupConverters;
-            group.model = 'group';
-            this.debug(`verifyGroupExists: created group ${nid}`);
-        } else {
-            this.debug(`verifyGroupExists: group ${nid} exists`);
+        try {
+            const nid = typeof id === 'number' ? id : parseInt(id);
+            let group = await this.herdsman.getGroupByID(nid);
+            if (!group) {
+                group = await this.herdsman.createGroup(nid);
+                group.toZigbee = groupConverters;
+                group.model = 'group';
+                this.debug(`verifyGroupExists: created group ${nid}`);
+            } else {
+                this.debug(`verifyGroupExists: group ${nid} exists`);
+            }
+            return group
         }
+        catch (error) {
+            this.error(`verifyGroupExists: ${error && error.message ? error.message : 'unspecified error'}`);
+        }
+    }
+
+    async rebuildGroupIcon(grp) {
+        const g = (typeof grp === 'number') ? this.herdsman.getGroupByID(grp) : grp;
+        if (typeof g === 'object' && g.groupID)
+        {
+            const members = await this.getGroupMembersFromController(g.groupID);
+            return `img/group_${members.length}.png`
+        }
+        return 'img/group_x.png';
     }
 
     async addPairingCode(code) {
         this.debug(`calling addPairingCode with ${code}`);
         if (code) {
-            await this.herdsman.addInstallCode(code);
-            this.info(`added code ${code} for pairing`);
-            return true;
+            try {
+                await this.herdsman.addInstallCode(code);
+                this.info(`added code ${code} for pairing`);
+                return true;
+            }
+            catch (error) {
+                this.error(`addPairingCode: ${error && error.message ? error.message : 'unspecified error'}`);
+            }
         }
         return false;
     }
@@ -347,7 +419,7 @@ class ZigbeeController extends EventEmitter {
     async getGroupMembersFromController(id) {
         const members = [];
         try {
-            const group = await this.getGroupByID(id);
+            const group = await this.getGroupByID(Number(id));
             if (group) {
                 const groupMembers = group.members;
                 for (const member of groupMembers) {
@@ -369,7 +441,7 @@ class ZigbeeController extends EventEmitter {
         } catch (error) {
             this.sendError(error);
             if (error) {
-                this.error(`getGroupMembersFromController: error is  ${JSON.stringify(error)} ${JSON.stringify(new Error().stack)}`);
+                this.error(`getGroupMembersFromController: ${(error && error.message ? error.message : 'no error message')} ${(error && error.stack ? error.stack : 'no call stack')}`);
             } else {
                 this.error('unidentified error in getGroupMembersFromController');
             }
@@ -378,22 +450,78 @@ class ZigbeeController extends EventEmitter {
     }
 
     getDevice(key) {
-        return this.herdsman.getDeviceByIeeeAddr(key);
+        try {
+            return this.herdsman.getDeviceByIeeeAddr(key);
+        }
+        catch (error) {
+            this.error(`getDeviceByIeeeAddr: ${(error && error.message ? error.message : 'no error message')}`);
+            return undefined;
+        }
     }
 
     getDevicesByType(type) {
-        return this.herdsman.getDevicesByType(type);
+        try {
+            return this.herdsman.getDevicesByType(type);
+        }
+        catch (error) {
+            this.error(`getDevicesByType: ${(error && error.message ? error.message : 'no error message')}`);
+            return undefined;
+        }
     }
 
     getDeviceByNetworkAddress(networkAddress) {
-        return this.herdsman.getDeviceByNetworkAddress(networkAddress);
+        try {
+            return this.herdsman.getDeviceByNetworkAddress(networkAddress);
+        }
+        catch (error) {
+            this.error(`getDeviceByNetworkAddress: ${(error && error.message ? error.message : 'no error message')}`);
+            return undefined;
+        }
     }
 
-    async resolveEntity(key, ep) {
-        // assert(typeof key === 'string' || key.constructor.name === 'Device', `Wrong type '${typeof key}'`);
-
+    async analyzeKey(key) {
+        const rv = {
+            kind: 'device',
+            key: key,
+            message: 'success'
+        }
+        if (typeof key === 'object') return rv;
+        if (typeof key === 'number') {
+            rv.kind = 'group';
+            return rv;
+        }
         if (typeof key === 'string') {
             if (key === 'coordinator') {
+                rv.kind = 'coordinator'
+                return rv;
+            };
+            const kp = key.split('_');
+            if (kp[0] === 'group' && kp.length > 1) {
+                rv.kind = 'group';
+                rv.key = Number(kp[1]);
+                return rv;
+            }
+            if (key.startsWith('0x')) {
+                rv.kind = 'ieee'
+                return rv;
+            };
+            if (key.trim().length === 16) {
+                rv.key = `0x${key.trim()}`
+                rv.kind = 'ieee';
+                return rv;
+            };
+        }
+        rv.message = 'failed';
+        return rv;
+    }
+
+    async resolveEntity(key, ep) {
+        // this.warn('resolve entity with key of tyoe ' + typeof (key));
+        try {
+            const _key = await this.analyzeKey(key);
+            if (_key.message !== 'success') return undefined;
+
+            if (_key.kind == 'coordinator') {
                 const coordinator = this.herdsman.getDevicesByType('Coordinator')[0];
                 return {
                     type: 'device',
@@ -401,83 +529,86 @@ class ZigbeeController extends EventEmitter {
                     endpoint: coordinator.getEndpoint(1),
                     name: 'Coordinator',
                 };
-            } else {
-                const device = await this.herdsman.getDeviceByIeeeAddr(key);
-                if (device) {
-                    const mapped = await zigbeeHerdsmanConverters.findByDevice(device);
-                    const endpoints = mapped && mapped.endpoint ? mapped.endpoint(device) : null;
-                    let endpoint;
-                    if (endpoints && ep != undefined && endpoints[ep]) {
-                        endpoint = device.getEndpoint(endpoints[ep]);
-                    } else if (endpoints && endpoints['default']) {
-                        endpoint = device.getEndpoint(endpoints['default']);
+            }
+            if (_key.kind === 'group') {
+                let group = await this.herdsman.getGroupByID(_key.key);
+                if (!group) group = await this.herdsman.createGroup(_key.key);
+                group.toZigbee = groupConverters;
+                group.model = 'group';
+                return {
+                    type: 'group',
+                    mapped: group,
+                    group,
+                    name: `Group ${_key.key}`,
+                };
+
+            }
+            if (_key.kind === 'ieee') _key.key = await this.herdsman.getDeviceByIeeeAddr(_key.key);
+            const device = _key.key;
+            if (device) {
+                const mapped = await zigbeeHerdsmanConverters.findByDevice(device);
+                const endpoints = mapped && mapped.endpoint ? mapped.endpoint(device) : null;
+                let endpoint;
+                if (endpoints && ep != undefined && endpoints[ep]) {
+                    endpoint = device.getEndpoint(endpoints[ep]);
+                } else if (endpoints && endpoints['default']) {
+                    endpoint = device.getEndpoint(endpoints['default']);
+                } else {
+                    const epNum = parseInt(ep);
+                    if (!isNaN(epNum)) {
+                        endpoint = device.getEndpoint(epNum);
                     } else {
-                        const epNum = parseInt(ep);
-                        if (!isNaN(epNum)) {
-                            endpoint = device.getEndpoint(epNum);
-                        } else {
-                            endpoint = device.endpoints[0];
-                        }
+                        endpoint = device.endpoints[0];
                     }
-                    return {
-                        type: 'device',
-                        device,
-                        mapped,
-                        endpoint,
-                        endpoints: device.endpoints,
-                        name: key,
-                    };
                 }
+                return {
+                    type: 'device',
+                    device,
+                    mapped,
+                    endpoint,
+                    endpoints: device.endpoints,
+                    name: device._ieeeAddr,
+                };
             }
-        } else if (typeof key === 'number') {
-            let group = await this.herdsman.getGroupByID(key);
-            if (!group) group = await this.herdsman.createGroup(key);
-            group.toZigbee = groupConverters;
-            group.model = 'group';
-            return {
-                type: 'group',
-                mapped: group,
-                group,
-                name: `Group ${key}`,
-            };
-        } else {
-            let mapped;
-            try {
-                mapped = await zigbeeHerdsmanConverters.findByDevice(key);
-            } catch (err) {
-                this.error(`zigbeeHerdsmanConverters findByDevice ${key.ieeeAddr}`);
-            }
-
-            return {
-                type: 'device',
-                device: key,
-                mapped: mapped,
-                name: key.type === 'Coordinator' ? 'Coordinator' : key.ieeeAddr,
-            };
         }
+        catch (error)
+        {
+            this.error('Resolve entity error: ' + (error && error.message ? error.message : 'no reason given'))
+        }
+        return undefined;
     }
 
     async incMsgHandler(message) {
-        this.debug('incoming msg', message);
-        const device = await this.herdsman.getDeviceByIeeeAddr(message.srcaddr);
-        if (!device) {
-            this.debug('Message without device!');
-            return;
+        try {
+            this.debug('incoming msg', message);
+            const device = await this.herdsman.getDeviceByIeeeAddr(message.srcaddr);
+            if (!device) {
+                this.debug('Message without device!');
+                return;
+            }
+            // We can't handle devices without modelId.
+            if (!device.modelId) {
+                this.debug('Message without modelId!');
+                return;
+            }
+            this.event('msg', device.ieeeAddr, message, {
+                modelId: device.modelId
+            });
         }
-        // We can't handle devices without modelId.
-        if (!device.modelId) {
-            this.debug('Message without modelId!');
-            return;
+        catch (error) {
+            this.error('incMsgHandler: ' + (error && error.message ? error.message : 'no error message'));
         }
-        this.event('msg', device.ieeeAddr, message, {
-            modelId: device.modelId
-        });
     }
 
     // Stop controller
     async stop() {
         // Call extensions
-        await this.callExtensionMethod('stop', []);
+        try {
+            await this.callExtensionMethod('stop', []);
+        }
+        catch (error) {
+            this.error('unable to call extension Method stop: ' + (error && error.message ? error.message : 'no error message'));
+        }
 
         try {
             await this.permitJoin(0);
@@ -503,55 +634,46 @@ class ZigbeeController extends EventEmitter {
 
     // Permit join
     async permitJoin(permitTime, devid, failure) {
-        let permitDev;
-        if (isFunction(devid) && !isFunction(failure)) {
-            failure = devid;
-        } else {
-            if (devid != '') {
-                permitDev = this.getDevice(devid);
-            } else {
-                permitDev = '';
-            }
-        }
-
-        if (permitTime) {
-            this.info('Zigbee: allowing new devices to join.');
-        } else {
-            this.info('Zigbee: disabling joining new devices.');
+        try {
+            this._permitJoinTime = permitTime;
+            await this.herdsman.permitJoin(permitTime);
+        } catch (e) {
+            this.sendError(e);
+            this.error(`Failed to open the network: ${e.stack}`);
         }
+    }
 
+    async handlePermitJoinChanged(data)
+    {
         try {
-            if (permitTime && !this.herdsman.getPermitJoin()) {
-                clearInterval(this._permitJoinInterval);
-                this._permitJoinTime = permitTime;
-                await this.herdsman.permitJoin(true, permitDev, this._permitJoinTime);
-                this._permitJoinInterval = setInterval(async () => {
-                    this.emit('pairing', 'Pairing time left', this._permitJoinTime);
-                    if (this._permitJoinTime === 0) {
-                        this.info('Zigbee: stop joining');
-                        clearInterval(this._permitJoinInterval);
-                        await this.herdsman.permitJoin(false);
-                    }
-                    this._permitJoinTime -= 1;
-                }, 1000);
-            } else if (this.herdsman.getPermitJoin()) {
-                if (permitTime) {
-                    this.info('Joining already permitted');
-                } else {
-                    clearInterval(this._permitJoinInterval);
-                    await this.herdsman.permitJoin(false, permitDev);
+            this.debug(`Event handlePermitJoinChanged received with ${JSON.stringify(data)}`);
+            if (data.permitted) {
+                if (!this._permitJoinInterval) {
+                    this.emit('pairing',`Pairing possible for ${this._permitJoinTime} seconds`)
+                    this.info(`Opening zigbee Network for ${this._permitJoinTime} seconds`)
+                    this._permitJoinInterval = setInterval(async () => {
+                        this.emit('pairing', 'Pairing time left', this._permitJoinTime);
+                        this._permitJoinTime -= 1;
+                    }, 1000);
                 }
             }
-        } catch (e) {
-            this.sendError(e);
-            this.error(`Failed to open the network: ${e.stack}`);
+            else {
+                this.info(`Closing Zigbee network, ${this._permitJoinTime} seconds remaining`)
+                clearInterval(this._permitJoinInterval);
+                this._permitJoinInterval = null;
+                // this.emit('pairing', 'Pairing time left', 0);
+                this.emit('pairing', 'Closing network.',0);
+            }
+        }
+        catch (error) {
+            this.error(`Error in handlePermitJoinChanged:  ${error.message}`);
         }
     }
 
     // Remove device
     async remove(deviceID, force, callback) {
         try {
-            const device = await this.herdsman.getDeviceByIeeeAddr(deviceID);
+            const device = this.herdsman.getDeviceByIeeeAddr(deviceID);
             if (device) {
                 try {
                     await device.removeFromNetwork();
@@ -569,7 +691,7 @@ class ZigbeeController extends EventEmitter {
                 }
 
                 try {
-                    await device.removeFromDatabase();
+                    device.removeFromDatabase();
                 } catch (error) {
                     this.sendError(error);
                     // skip error
@@ -605,7 +727,7 @@ class ZigbeeController extends EventEmitter {
             );
         } catch (error) {
             this.sendError(error);
-            this.error(`Failed to handleDeviceLeave ${error.stack}`);
+            this.error(`Failed to handleDeviceLeave ${error && error.message ? error.message : 'no error message given'}`);
         }
     }
 
@@ -654,46 +776,51 @@ class ZigbeeController extends EventEmitter {
             this.warn(`Blocked interview for '${message.ieeeAddr}' because the network is closed`);
             return;
         }
-        const entity = await this.resolveEntity(message.device || message.ieeeAddr);
-        const friendlyName = entity.name;
-        if (message.status === 'successful') {
-            this.info(`Successfully interviewed '${friendlyName}', device has successfully been paired`);
-
-            if (entity.mapped) {
-                const {vendor, description, model} = entity.mapped;
-                this.info(
-                    `Device '${friendlyName}' is supported, identified as: ${vendor} ${description} (${model})`
-                );
-
-                const log = {friendly_name: friendlyName, model, vendor, description, supported: true};
-                this.emit('pairing', 'Interview successful', JSON.stringify(log));
-                entity.device.modelID = entity.device._modelID;
-                this.emit('new', entity);
-                // send to extensions again (for configure)
-                this.callExtensionMethod(
-                    'onZigbeeEvent',
-                    [message, entity ? entity.mapped : null],
-                );
+        try {
+            const entity = await this.resolveEntity(message.device || message.ieeeAddr);
+            const friendlyName = entity.name;
+            if (message.status === 'successful') {
+                this.info(`Successfully interviewed '${friendlyName}', device has successfully been paired`);
+
+                if (entity.mapped) {
+                    const {vendor, description, model} = entity.mapped;
+                    this.info(
+                        `Device '${friendlyName}' is supported, identified as: ${vendor} ${description} (${model})`
+                    );
+
+                    const log = {friendly_name: friendlyName, model, vendor, description, supported: true};
+                    this.emit('pairing', 'Interview successful', JSON.stringify(log));
+                    entity.device.modelID = entity.device._modelID;
+                    this.emit('new', entity);
+                    // send to extensions again (for configure)
+                    this.callExtensionMethod(
+                        'onZigbeeEvent',
+                        [message, entity ? entity.mapped : null],
+                    );
+                } else {
+                    this.debug(
+                        `Device '${friendlyName}' with Zigbee model '${message.device.modelID}' is NOT supported, ` +
+                        `please follow https://www.zigbee2mqtt.io/how_tos/how_to_support_new_devices.html`
+                    );
+                    const frName = {friendly_name: friendlyName, supported: false};
+                    this.emit('pairing', 'Interview successful', JSON.stringify(frName));
+                    entity.device.modelID = entity.device._modelID;
+                    this.emit('new', entity);
+                }
+            } else if (message.status === 'failed') {
+                this.error(`Failed to interview '${friendlyName}', device has not successfully been paired. Try again !!!!!!!!!! `);
+                //this.error(`Failed to interview '${friendlyName}', device has not successfully been paired. Try again !!!!!!!!!! ${message.error}`);
+                this.emit('pairing', 'Interview failed', friendlyName);
             } else {
-                this.debug(
-                    `Device '${friendlyName}' with Zigbee model '${message.device.modelID}' is NOT supported, ` +
-                    `please follow https://www.zigbee2mqtt.io/how_tos/how_to_support_new_devices.html`
-                );
-                const frName = {friendly_name: friendlyName, supported: false};
-                this.emit('pairing', 'Interview successful', JSON.stringify(frName));
-                entity.device.modelID = entity.device._modelID;
-                this.emit('new', entity);
-            }
-        } else if (message.status === 'failed') {
-            this.error(`Failed to interview '${friendlyName}', device has not successfully been paired. Try again !!!!!!!!!! `);
-            //this.error(`Failed to interview '${friendlyName}', device has not successfully been paired. Try again !!!!!!!!!! ${message.error}`);
-            this.emit('pairing', 'Interview failed', friendlyName);
-        } else {
-            if (message.status === 'started') {
-                this.info(`Starting interview of '${friendlyName}'`);
-                this.emit('pairing', 'Interview started', friendlyName);
+                if (message.status === 'started') {
+                    this.info(`Starting interview of '${friendlyName}'`);
+                    this.emit('pairing', 'Interview started', friendlyName);
+                }
             }
         }
+        catch (error) {
+            this.error('handleDeviceInterview: ' + (error && error.message ? error.message : 'no error message'));
+        }
     }
 
     async handleMessage(data) {
@@ -716,20 +843,25 @@ class ZigbeeController extends EventEmitter {
 
     async getMap(callback) {
         try {
+            this.info('Collecting Map Data');
             const devices = this.herdsman.getDevices(true);
             const lqis = [];
             const routing = [];
-
-            for (const device of devices.filter((d) => d.type !== 'EndDevice')) {
-                const resolved = await this.resolveEntity(device);
+            const errors = [];
+
+            await Promise.all(devices.filter((d) => d.type !== 'EndDevice').map(async device =>
+            {
+                let resolved = await this.resolveEntity(device, 0);
+                if (!resolved) {
+                    resolved = { name:'unresolved device', device:device }
+                    this.warn('resolve Entity failed for ' + device.ieeeAddr)
+                }
                 let result;
 
                 try {
                     result = await device.lqi();
                 } catch (error) {
-                    this.sendError(error);
-                    error && this.debug(`Failed to execute LQI for '${resolved.name}'. ${safeJsonStringify(error.stack)}`);
-
+                    errors.push(`Failed to execute LQI for '${resolved ? resolved.name : 'unresolved device'} (${resolved ? resolved.device.modelID : 'unknown'}') : ${this.filterHerdsmanError(error.message)}.`);
                     lqis.push({
                         parent: 'undefined',
                         networkAddress: 0,
@@ -745,7 +877,7 @@ class ZigbeeController extends EventEmitter {
                     for (const dev of result.neighbors) {
                         if (dev !== undefined && dev.ieeeAddr !== '0xffffffffffffffff') {
                             lqis.push({
-                                parent: resolved.device.ieeeAddr,
+                                parent: (resolved ? resolved.device.ieeeAddr : undefined),
                                 networkAddress: dev.networkAddress,
                                 ieeeAddr: dev.ieeeAddr,
                                 lqi: dev.linkquality,
@@ -757,18 +889,14 @@ class ZigbeeController extends EventEmitter {
                     }
                 }
 
-                this.debug(`LQI succeeded for '${resolved.name}'`);
-
                 try {
                     result = await device.routingTable();
                 } catch (error) {
-                    this.sendError(error);
                     if (error) {
-                        this.debug(`Failed to execute routing table for '${resolved.name}'. ${safeJsonStringify(error.stack)}`);
+                        errors.push(`Failed to collect routing table for '${resolved ? resolved.name : 'unresolved device'} (${resolved ? resolved.device.modelID : 'unknown'}') : ${this.filterHerdsmanError(error.message)}`);
                     }
                 }
 
-                this.debug(`Routing for '${resolved.name}': ${safeJsonStringify(result)}`);
                 if (result !== undefined) {
                     if (result.table !== undefined) {
                         for (const dev of result.table) {
@@ -781,17 +909,24 @@ class ZigbeeController extends EventEmitter {
                         }
                     }
                 }
-                this.debug(`Routing table succeeded for '${resolved.name}'`);
             }
-            this.debug(`Get map succeeded ${safeJsonStringify(lqis)}`);
+            ));
 
-            callback && callback({lqis, routing});
+            callback && callback({lqis, routing, errors});
+            if (errors.length) {
+                this.warn(`Map Data collection complete with ${errors.length} issues:`);
+                for (const msg of errors)
+                    this.warn(msg);
+            }
+            else
+                this.info('Map data collection complete');
         } catch (error) {
             this.sendError(error);
-            this.debug(`Failed to get map: ${safeJsonStringify(error.stack)}`);
+            this.error(`Failed to get map: ${safeJsonStringify(error.stack)}`);
         }
     }
 
+
     async publish(deviceID, cid, cmd, zclData, cfg, ep, type, callback, zclSeqNum) {
         const entity = await this.resolveEntity(deviceID, ep);
         const device = entity.device;
@@ -815,38 +950,35 @@ class ZigbeeController extends EventEmitter {
             cfg = {};
         }
 
-        if (type === 'foundation') {
-            cfg.disableDefaultResponse = true;
+        try {
 
-            if (cmd === 'read' && !Array.isArray(zclData)) {
-                /*                // needs to be iterable (string[] | number [])
-                zclData[Symbol.iterator] = function* () {
-                    let k;
-                    for (k in this) {
-                        yield k;
-                    }
-                };
-*/
-            }
-            let result;
-            if (cmd === 'configReport') {
-                result = await endpoint.configureReporting(cid, zclData, cfg);
+            if (type === 'foundation') {
+                cfg.disableDefaultResponse = true;
+                let result;
+                if (cmd === 'configReport') {
+                    result = await endpoint.configureReporting(cid, zclData, cfg);
+                } else {
+                    if (cmd === 'read' && !Array.isArray(zclData))
+                        result = await endpoint[cmd](cid, Object.keys(zclData), cfg);
+                    else
+                        result = await endpoint[cmd](cid, zclData, cfg);
+                }
+                callback && callback(undefined, result);
+            } else if (type === 'functionalResp') {
+                cfg.disableDefaultResponse = false;
+                const result = await endpoint.commandResponse(cid, cmd, zclData, cfg, zclSeqNum);
+                callback && callback(undefined, result);
             } else {
-                if (cmd === 'read' && !Array.isArray(zclData))
-                    result = await endpoint[cmd](cid, Object.keys(zclData), cfg);
-                else
-                    result = await endpoint[cmd](cid, zclData, cfg);
+                cfg.disableDefaultResponse = false;
+                const result = await endpoint.command(cid, cmd, zclData, cfg);
+                callback && callback(undefined, result);
             }
-            callback && callback(undefined, result);
-        } else if (type === 'functionalResp') {
-            cfg.disableDefaultResponse = false;
-            const result = await endpoint.commandResponse(cid, cmd, zclData, cfg, zclSeqNum);
-            callback && callback(undefined, result);
-        } else {
-            cfg.disableDefaultResponse = false;
-            const result = await endpoint.command(cid, cmd, zclData, cfg);
-            callback && callback(undefined, result);
         }
+        catch (error)
+        {
+            this.log.error(`error sending ${type} ${cmd} to endpoint: ${(error && error.message ? error.message : 'no error message')} ${(error && error.stack ? error.stack : 'no call stack')}`)
+        }
+
     }
 
     async addDevToGroup(devId, groupId, epid) {
@@ -906,6 +1038,7 @@ class ZigbeeController extends EventEmitter {
             entity = await this.resolveEntity(devId);
             const group = await this.resolveEntity(groupId);
 
+            /*
             const members = await this.getGroupMembersFromController(groupId);
             const memberIDs = [];
             for (const member of members) {
@@ -914,7 +1047,7 @@ class ZigbeeController extends EventEmitter {
 
             this.debug(`removeDevFromGroup - entity: ${utils.getEntityInfo(entity)}`);
             this.debug(`removeDevFromGroup ${groupId} with ${memberIDs.length} members ${safeJsonStringify(memberIDs)}`);
-
+            */
             if (epid != undefined) {
                 for (const ep of entity.endpoints) {
                     this.debug(`checking ep ${ep.ID} of ${devId} (${epid})`);
@@ -927,6 +1060,7 @@ class ZigbeeController extends EventEmitter {
                 await entity.endpoint.removeFromGroup(group.mapped);
                 this.info(`removing endpoint ${entity.endpoint.ID} of ${devId} from group ${groupId}`);
             }
+
         } catch (error) {
             this.sendError(error);
             this.error(`Exception when trying remove ${devId} (ep ${epid ? epid : (entity ? entity.endpoint.ID : '')}) from group ${devId}`, error);
@@ -957,16 +1091,21 @@ class ZigbeeController extends EventEmitter {
         target = !target ? this.getCoordinator() : target;
 
         this.debug(`Binding ${log}`);
-        ep.bind(cluster, target, error => {
-            if (error) {
-                this.sendError(error);
-                this.error(`Failed to bind ${log} - (${error})`);
-            } else {
-                this.debug(`Successfully bound ${log}`);
-            }
+        try {
+            ep.bind(cluster, target, error => {
+                if (error) {
+                    this.sendError(error);
+                    this.error(`Failed to bind ${log} - (${error})`);
+                } else {
+                    this.debug(`Successfully bound ${log}`);
+                }
 
-            callback(error);
-        });
+                callback(error);
+            });
+        }
+        catch (error) {
+            callback(error)
+        }
     }
 
     unbind(ep, cluster, target, callback) {
@@ -974,15 +1113,20 @@ class ZigbeeController extends EventEmitter {
         target = !target ? this.getCoordinator() : target;
 
         this.debug(`Unbinding ${log}`);
-        ep.unbind(cluster, target, (error) => {
-            if (error) {
-                this.error(`Failed to unbind ${log} - (${error})`);
-            } else {
-                this.debug(`Successfully unbound ${log}`);
-            }
+        try {
+            ep.unbind(cluster, target, (error) => {
+                if (error) {
+                    this.error(`Failed to unbind ${log} - (${error})`);
+                } else {
+                    this.debug(`Successfully unbound ${log}`);
+                }
 
-            callback(error);
-        });
+                callback(error);
+            });
+        }
+        catch (error) {
+            callback (error)
+        }
     }
 
     reset(mode, callback) {