iobroker.zigbee 2.0.0 → 2.0.2

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,18 @@ class ZigbeeController extends EventEmitter {
             new DeviceEventExt(this, {}),
             new DelayedActionExt(this, {}),
         ];
+        this.herdsmanTimeoutRegexp = new RegExp(/(\d+)ms/);
+        this.herdsmanLogSettings = {}
+    }
+
+
+    ByteArrayToString(data) {
+        return data.map(function (x) {
+            x = x + 0x100 + 1;  // twos complement
+            x = x.toString(16); // to hex
+            x = ('00'+x).substr(-2); // zero-pad to 8-digits
+            return x
+        }).join('');
     }
 
     configure(options) {
@@ -105,8 +121,9 @@ class ZigbeeController extends EventEmitter {
         }
         this.disableLed = options.disableLed;
         this.warnOnDeviceAnnouncement = options.warnOnDeviceAnnouncement;
-
-        this.debug(`Using zigbee-herdsman with settings: ${JSON.stringify(herdsmanSettings)}`);
+        this.herdsmanLogSettings.panID = herdsmanSettings.network.panID;
+        this.herdsmanLogSettings.channel = herdsmanSettings.network.channelList[0];
+        this.herdsmanLogSettings.extendedPanID = this.ByteArrayToString(herdsmanSettings.network.extendedPanID);
         this.herdsman = new ZigbeeHerdsman.Controller(herdsmanSettings, this.adapter.log);
         this.callExtensionMethod('setOptions', [{
             disableActivePing: options.disablePing,
@@ -129,12 +146,12 @@ 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));
 
+            this.info('Starting Zigbee-Herdsman');
             await this.herdsman.start();
-
-            this.debug('zigbee-herdsman started');
             this.herdsmanStarted = true;
-            this.info(`Coordinator firmware version: ${JSON.stringify(await this.herdsman.getCoordinatorVersion())}`);
+            this.info(`Zigbee-Herdsman started successfully with Coordinator firmware version: ${JSON.stringify(await this.herdsman.getCoordinatorVersion())}`);
 
             // debug info from herdsman getNetworkParameters
             const debNetworkParam = JSON.parse(JSON.stringify(await this.herdsman.getNetworkParameters()));
@@ -146,11 +163,32 @@ class ZigbeeController extends EventEmitter {
                 extPanIDDebug += extendedPanIDDebug[i];
                 i--;
             }
-
-            this.debug(`Zigbee network parameters: panID=${debNetworkParam.panID} channel=${debNetworkParam.channel} extendedPanID=${extPanIDDebug}`);
-        } catch (error) {
-            this.sendError(error);
-            this.error(`Starting zigbee-herdsman problem : ${(error && error.message ? error.message : 'no error message')}`);
+            this.debug(`Network parameters: panID=${debNetworkParam.panID} channel=${debNetworkParam.channel} extendedPanID=${extPanIDDebug}`);
+        } catch (e) {
+            try {
+                const debNetworkParam = JSON.parse(JSON.stringify(await this.herdsman.getNetworkParameters()));
+                const extendedPanIDDebug = typeof debNetworkParam.extendedPanID === 'string' ? debNetworkParam.extendedPanID.replace('0x', '') : debNetworkParam.extendedPanID;
+
+                let extPanIDDebug = '';
+                for (let i = extendedPanIDDebug.length - 1; i >= 0; i--) {
+                    extPanIDDebug += extendedPanIDDebug[i - 1];
+                    extPanIDDebug += extendedPanIDDebug[i];
+                    i--;
+                }
+                this.warn(`Network parameters in Config     : panID=${this.herdsmanLogSettings.panID} channel=${this.herdsmanLogSettings.channel} extendedPanID=${this.herdsmanLogSettings.extendedPanID}`)
+                this.warn(`Network parameters on Coordinator: panID=${debNetworkParam.panID} channel=${debNetworkParam.channel} extendedPanID=${extPanIDDebug}`);
+            }
+            catch (error) {
+                this.warn(`Unable to obtain herdsman settings`)
+            }
+            try {
+                await this.herdsman.stop();
+            }
+            catch (error) {
+                this.warn('unable to stop zigbee-herdsman after failed startup');
+            }
+            this.sendError(e);
+            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
@@ -195,40 +233,60 @@ 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++;
+                // get the model description for the known devices
+                const entity = await this.resolveEntity(device);
+                if (!entity) {
+                    this.warn('failed to resolve Entity for ' + device.ieeeAddr);
+                    continue;
+                }
+                //await this.adapter.stController.AddModelFromHerdsman(device, entity.mapped.model);
 
-        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]);
+                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
+
+                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})`
-            );
+            this.callExtensionMethod('onZigbeeStarted', []);
+        }
+        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 +314,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,16 +352,30 @@ 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;
             }
         } catch (error) {
             this.sendError(error);
-            this.error(`error in getGroups: ${(error && error.message ? error.message : 'no error message')} ${(error && error.stack ? error.stack : 'no call stack')}`);
+            this.error(JSON.stringify(error));
             return undefined;
         }
     }
@@ -308,15 +386,17 @@ class ZigbeeController extends EventEmitter {
             group && group.removeFromNetwork();
         } catch (error) {
             this.sendError(error);
-            this.error(`error in removeGroupById: ${(error && error.message ? error.message : 'no error message')} ${(error && error.stack ? error.stack : 'no call stack')}`);
+            this.error(`error in removeGroupById: ${error}`);
         }
     }
 
     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;
         }
     }
@@ -333,12 +413,23 @@ class ZigbeeController extends EventEmitter {
             } 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) {
@@ -357,7 +448,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) {
@@ -391,7 +482,8 @@ class ZigbeeController extends EventEmitter {
         try {
             return this.herdsman.getDeviceByIeeeAddr(key);
         }
-        catch {
+        catch (error) {
+            this.error(`getDeviceByIeeeAddr: ${(error && error.message ? error.message : 'no error message')}`);
             return undefined;
         }
     }
@@ -400,7 +492,8 @@ class ZigbeeController extends EventEmitter {
         try {
             return this.herdsman.getDevicesByType(type);
         }
-        catch {
+        catch (error) {
+            this.error(`getDevicesByType: ${(error && error.message ? error.message : 'no error message')}`);
             return undefined;
         }
     }
@@ -409,82 +502,109 @@ class ZigbeeController extends EventEmitter {
         try {
             return this.herdsman.getDeviceByNetworkAddress(networkAddress);
         }
-        catch {
+        catch (error) {
+            this.error(`getDeviceByNetworkAddress: ${(error && error.message ? error.message : 'no error message')}`);
             return undefined;
         }
     }
 
+    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) {
-        // assert(typeof key === 'string' || key.constructor.name === 'Device', `Wrong type '${typeof key}'`);
+        // this.warn('resolve entity with key of tyoe ' + typeof (key));
         try {
-            if (typeof key === 'string') {
-                if (key === 'coordinator') {
-                    const coordinator = this.herdsman.getDevicesByType('Coordinator')[0];
-                    return {
-                        type: 'device',
-                        device: coordinator,
-                        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']);
-                        } else {
-                            const epNum = parseInt(ep);
-                            if (!isNaN(epNum)) {
-                                endpoint = device.getEndpoint(epNum);
-                            } else {
-                                endpoint = device.endpoints[0];
-                            }
-                        }
-                        return {
-                            type: 'device',
-                            device,
-                            mapped,
-                            endpoint,
-                            endpoints: device.endpoints,
-                            name: key,
-                        };
-                    }
-                }
-            } else if (typeof key === 'number') {
-                let group = await this.herdsman.getGroupByID(key);
-                if (!group) group = await this.herdsman.createGroup(key);
+            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',
+                    device: coordinator,
+                    endpoint: coordinator.getEndpoint(1),
+                    name: 'Coordinator',
+                };
+            }
+            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}`,
+                    name: `Group ${_key.key}`,
                 };
-            } else {
-                let mapped;
-                try {
-                    mapped = await zigbeeHerdsmanConverters.findByDevice(key);
-                } catch (err) {
-                    this.error(`zigbeeHerdsmanConverters findByDevice ${key.ieeeAddr}`);
-                }
 
+            }
+            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 {
+                        endpoint = device.endpoints[0];
+                    }
+                }
                 return {
                     type: 'device',
-                    device: key,
-                    mapped: mapped,
-                    name: key.type === 'Coordinator' ? 'Coordinator' : key.ieeeAddr,
+                    device,
+                    mapped,
+                    endpoint,
+                    endpoints: device.endpoints,
+                    name: device._ieeeAddr,
                 };
             }
         }
-        catch {
-            return undefined;
+        catch (error)
+        {
+            this.error('Resolve entity error: ' + (error && error.message ? error.message : 'no reason given'))
         }
-
+        return undefined;
     }
 
     async incMsgHandler(message) {
@@ -504,15 +624,20 @@ class ZigbeeController extends EventEmitter {
                 modelId: device.modelId
             });
         }
-        catch {
-            return;
+        catch (error) {
+            this.error('incMsgHandler: ' + (error && error.message ? error.message : 'no error message'));
         }
     }
 
     // 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);
@@ -538,55 +663,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();
@@ -604,7 +720,7 @@ class ZigbeeController extends EventEmitter {
                 }
 
                 try {
-                    await device.removeFromDatabase();
+                    device.removeFromDatabase();
                 } catch (error) {
                     this.sendError(error);
                     // skip error
@@ -640,7 +756,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'}`);
         }
     }
 
@@ -689,46 +805,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) {
@@ -751,20 +872,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,
@@ -780,7 +906,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,
@@ -792,18 +918,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) {
@@ -816,17 +938,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;
@@ -849,20 +978,11 @@ class ZigbeeController extends EventEmitter {
         if (cfg == null) {
             cfg = {};
         }
+
         try {
+
             if (type === 'foundation') {
                 cfg.disableDefaultResponse = true;
-                /*
-                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);
@@ -935,7 +1055,7 @@ class ZigbeeController extends EventEmitter {
         } catch (error) {
             this.sendError(error);
             this.error(`Exception when trying to Add ${devId}  to group ${groupId}`, error);
-            return {error: `Failed to add ${devId}  to group ${groupId}: ${(error && error.message ? error.message : 'no error message')} ${(error && error.stack ? error.stack : 'no call stack')}`};
+            return {error: `Failed to add ${devId}  to group ${groupId}: ${JSON.stringify(error)}`};
         }
         return {};
     }
@@ -947,6 +1067,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) {
@@ -955,7 +1076,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})`);
@@ -968,6 +1089,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);
@@ -1011,7 +1133,7 @@ class ZigbeeController extends EventEmitter {
             });
         }
         catch (error) {
-            callback(error);
+            callback(error)
         }
     }
 
@@ -1031,9 +1153,8 @@ class ZigbeeController extends EventEmitter {
                 callback(error);
             });
         }
-        catch (error)
-        {
-            callback(error);
+        catch (error) {
+            callback (error)
         }
     }