iobroker.zigbee 2.0.2 → 2.0.3

package/lib/statescontroller.js

@@ -1,9 +1,9 @@
 'use strict';
 
-const EventEmitter = require('events').EventEmitter;
+const safeJsonStringify = require('./json');
+const { EventEmitter } = require('events');
 const statesMapping = require('./devices');
-const getAdId = require('./utils').getAdId;
-const getZbId = require('./utils').getZbId;
+const { getAdId, getZbId } = require('./utils');
 const fs = require('fs');
 const axios = require('axios');
 const localConfig = require('./localConfig');
@@ -14,7 +14,8 @@ const localConfig = require('./localConfig');
 const { exec } = require('child_process');
 const { tmpdir } = require('os');
 const path = require('path');
-const { numberWithinRange } = require('zigbee-herdsman-converters/lib/utils');
+const { throwDeprecation } = require('process');
+const zigbeeHerdsmanConvertersUtils = require('zigbee-herdsman-converters/lib/utils');
 
 
 class StatesController extends EventEmitter {
@@ -32,6 +33,7 @@ class StatesController extends EventEmitter {
         this.ImagesToDownload = [];
         this.stashedErrors = {};
         this.stashedUnknownModels = [];
+        this.debugMessages = { nodevice:{ in:[], out: []} };
     }
 
     info(message, data) {
@@ -85,6 +87,10 @@ class StatesController extends EventEmitter {
         return rv;
     }
 
+    debugMessagesById() {
+        return this.debugMessages;
+    }
+
     async AddModelFromHerdsman(device, model) {
         // this.warn('addModelFromHerdsman ' + JSON.stringify(model) + ' ' + JSON.stringify(this.localConfig.getOverrideWithKey(model, 'legacy', true)));
         if (this.localConfig.getOverrideWithKey(model, 'legacy', true)) {
@@ -152,6 +158,7 @@ class StatesController extends EventEmitter {
         if (!this.adapter.zbController || !this.adapter.zbController.connected()) {
             return;
         }
+        const debugId = Date.now();
         if (state && !state.ack) {
             if (id.endsWith('pairingCountdown') || id.endsWith('pairingMessage') || id.endsWith('connection')) {
                 return;
@@ -166,16 +173,18 @@ class StatesController extends EventEmitter {
                 return;
             }
 
-            if (this.checkDebugDevice(id))
-                this.warn(`ELEVATED O01: User state change of state ${id} with value ${state.val} (ack: ${state.ack}) from ${state.from}`);
-
-            this.debug(`User stateChange ${id} ${JSON.stringify(state)}`);
             const devId = getAdId(this.adapter, id); // iobroker device id
             let deviceId = getZbId(id); // zigbee device id
+
+            if (this.checkDebugDevice(id)) {
+                const message = `User state change of state ${id} with value ${state.val} (ack: ${state.ack}) from ${state.from}`;
+                this.emit('device_debug', { ID:debugId, data: { ID: deviceId, flag:'01' }, message:message});
+            } else
+                this.debug(`User stateChange ${id} ${JSON.stringify(state)}`);
             // const stateKey = id.split('.')[3];
             const arr = /zigbee.[0-9].[^.]+.(\S+)/gm.exec(id);
             if (arr[1] === undefined) {
-                this.warn(`unable to extract id from state ${id}`);
+                //this.warn(`unable to extract id from state ${id}`);
                 return;
             }
             const stateKey = arr[1];
@@ -199,7 +208,7 @@ class StatesController extends EventEmitter {
 
                     }
                     this.collectOptions(id.split('.')[2], model, options =>
-                        this.publishFromState(deviceId, model, stateKey, state, options));
+                        this.publishFromState(deviceId, model, stateKey, state, options, debugId));
                 }
             });
         }
@@ -305,29 +314,38 @@ class StatesController extends EventEmitter {
         }, (stateDesc.compositeTimeout ? stateDesc.compositeTimeout : 100) * factor);
     }
 
-    async publishFromState(deviceId, model, stateKey, state, options) {
+    async publishFromState(deviceId, model, stateKey, state, options, debugId) {
         this.debug(`Change state '${stateKey}' at device ${deviceId} type '${model}'`);
         const elevated = this.checkDebugDevice(deviceId);
 
-        if (elevated) this.warn(`ELEVATED O02: Change state '${stateKey}' at device ${deviceId} type '${model}'`);
+        if (elevated)  {
+            const message = (`Change state '${stateKey}' at device ${deviceId} type '${model}'`);
+            this.emit('device_debug', { ID:debugId, data: { ID: deviceId, model: model, flag:'02', IO:false }, message:message});
+        }
 
         const devStates = await this.getDevStates(deviceId, model);
         if (!devStates) {
-            if (elevated) this.error(`ELEVATED OE1: no device states for device ${deviceId} type '${model}'`);
+            if (elevated) {
+                const message = (`no device states for device ${deviceId} type '${model}'`);
+                this.emit('device_debug', { ID:debugId, data: { error: 'NOSTATES' , IO:false }, message:message});
+            }
             return;
         }
         const commonStates = statesMapping.commonStates.find(statedesc => stateKey === statedesc.id);
         const stateDesc = (commonStates === undefined ? devStates.states.find(statedesc => stateKey === statedesc.id) : commonStates);
         const stateModel = devStates.stateModel;
         if (!stateDesc) {
-            this.error(`No state available for '${model}' with key '${stateKey}'`);
+            const message = (`No state available for '${model}' with key '${stateKey}'`);
+            if (elevated) this.emit('device_debug', { ID:debugId, data: { states:[{id:state.ID, value:'unknown', payload:'unknown'}], error: 'NOSTKEY' , IO:false }, message:message});
             return;
         }
 
         const value = state.val;
         if (value === undefined || value === '') {
-            if (elevated)
-                this.error(`ELEVATED OE2: no value for device ${deviceId} type '${model}'`);
+            if (elevated) {
+                const message = (`no value for device ${deviceId} type '${model}'`);
+                this.emit('device_debug', { ID:debugId, data: { states:[{id:state.ID, value:'--', payload:'error', ep:stateDesc.epname}],error: 'NOVAL' , IO:false }, message:message});
+            }
             return;
         }
         let stateList = [{stateDesc: stateDesc, value: value, index: 0, timeout: 0, source:state.from}];
@@ -344,7 +362,8 @@ class StatesController extends EventEmitter {
                     }
                 } catch (e) {
                     this.sendError(e);
-                    this.error('Exception caught in publishfromstate');
+                    if (elevated) this.emit('device_debug', { ID:debugId, data: { states:[{id:state.ID, value:state.val, payload:'unknown'}], error: 'EXLINK' , IO:false }});
+                    this.error('Exception caught in publishfromstate: ' + (e && e.message ? e.message : 'no error message given'));
                 }
 
             });
@@ -359,7 +378,7 @@ class StatesController extends EventEmitter {
                 readAfterWriteStates = readAfterWriteStates.concat(readAfterWriteStateDesc.id));
         }
 
-        this.emit('changed', deviceId, model, stateModel, stateList, options);
+        this.emit('changed', deviceId, model, stateModel, stateList, options, debugId);
     }
 
     async renameDevice(id, newName) {
@@ -413,7 +432,7 @@ class StatesController extends EventEmitter {
                     let statename = state._id;
                     const arr = /zigbee.[0-9].[^.]+.(\S+)/gm.exec(statename);
                     if (arr[1] === undefined) {
-                        this.warn(`unable to extract id from state ${statename}`);
+                        this.debug(`unable to extract id from state ${statename}`);
                         const idx = statename.lastIndexOf('.');
                         if (idx > -1) {
                             statename = statename.slice(idx + 1);
@@ -755,7 +774,7 @@ class StatesController extends EventEmitter {
         this.adapter.fileExists(namespace, target, async (err,result) => {
             if (result) return;
             const src = `${tmpdir()}/${path.basename(target)}`;
-            const msg = `downloading ${url} to ${src}`;
+            //const msg = `downloading ${url} to ${src}`;
             if (this.ImagesToDownload.indexOf(url) ==-1) {
                 await this.downloadIcon(url, src)
                 try {
@@ -773,7 +792,6 @@ class StatesController extends EventEmitter {
                                 this.info(`copied ${src} to ${target}.`)
                                 fs.rm(src, (err) => {
                                     if (err) this.warn(`error removing ${src} : ${JSON.stringify(err)}`);
-                                    else this.info(`removed ${src}`)
                                 });
                             })
                         }
@@ -861,102 +879,257 @@ class StatesController extends EventEmitter {
         this.emit('debugmessage', {id: id, message:message});
     }
 
-    async publishToState(devId, model, payload) {
-        const devStates = await this.getDevStates(`0x${devId}`, model);
+    async publishToState(devId, model, payload, debugId) {
+        try {
+            if (!debugId) debugId = Date.now();
+            const devStates = await this.getDevStates(`0x${devId}`, model);
+
+            const has_elevated_debug = (this.checkDebugDevice(devId) && !payload.hasOwnProperty('msg_from_zigbee'));
+
+            const message = `message received '${JSON.stringify(payload)}' from device ${devId} type '${model}'`;
+            if (has_elevated_debug) this.emit('device_debug', { ID:debugId, data: { deviceID: devId, flag:'01', IO:true }, message:message});
+            else this.debug(message);
+            if (!devStates) {
+                const message = `no device states for device ${devId} type '${model}'`;
+                if (has_elevated_debug)this.emit('device_debug', { ID:debugId, data: { error:'NOSTATE',states:[{ id:'--', value:'--', payload:payload}], IO:true }, message:message});
+                else this.debug(message);
+                return;
+            }
+            // find states for payload
+            let has_published = false;
+            if (devStates.states !== undefined) {
+                try {
+                    const states = statesMapping.commonStates.concat(
+                        devStates.states.filter(statedesc => payload.hasOwnProperty(statedesc.prop || statedesc.id))
+                    );
+
+                    for (const stateInd in states) {
+                        const statedesc = states[stateInd];
+                        let value;
+                        if (statedesc.getter) {
+                            value = statedesc.getter(payload);
+                        } else {
+                            value = payload[statedesc.prop || statedesc.id];
+                        }
+                        // checking value
+                        if (value === undefined || value === null) {
+                            continue;
+                        }
 
-        const has_elevated_debug = (this.checkDebugDevice(devId) && !payload.hasOwnProperty('msg_from_zigbee'));
+                        let stateID = statedesc.id;
+
+                        const message = `value generated '${JSON.stringify(value)}' from device ${devId} for '${statedesc.name}'`;
+                        if (has_elevated_debug) this.emit('device_debug', { ID:debugId, data: { states:[{id:stateID, value:value, payload:payload }],flag:'02', IO:true }, message});
+                        else this.debug(message);
+
+                        const common = {
+                            name: statedesc.name,
+                            type: statedesc.type,
+                            unit: statedesc.unit,
+                            read: statedesc.read,
+                            write: statedesc.write,
+                            icon: statedesc.icon,
+                            role: statedesc.role,
+                            min: statedesc.min,
+                            max: statedesc.max,
+                        };
+
+                        if (typeof value === 'object' && value.hasOwnProperty('stateid')) {
+                            stateID = `${stateID}.${value.stateid}`;
+                            if (value.hasOwnProperty('unit')) {
+                                common.unit = value.unit;
+                            }
+                            common.name = value.name ? value.name : value.stateid;
+                            common.role = value.role ? `value.${value.role}` : 'number';
+                            value = value.value;
+                        }
 
+                        // if needs to return value to back after timeout
+                        if (statedesc.isEvent) {
+                            this.updateStateWithTimeout(devId, statedesc.id, value, common, 300, (typeof value == typeof (!value) ? !value : ''));
+                            if (has_elevated_debug) this.emit('device_debug', { ID:debugId, data: { flag:'SUCCESS', IO:true }});
 
-        if (has_elevated_debug)
-        {
-            this.elevatedMessage(devId, `ELEVATED I01: message received '${JSON.stringify(payload)}' from device ${devId} type '${model}'`, false);
+                        } else {
+                            if (statedesc.prepublish) {
+                                this.collectOptions(devId, model, options =>
+                                    statedesc.prepublish(devId, value, newvalue => {
+                                        this.updateState(devId, stateID, newvalue, common) }, options)
+                                );
+                                if (has_elevated_debug) this.emit('device_debug', { ID:debugId, data: { flag:'SUCCESS', IO:true }});
+                            } else {
+                                this.updateState(devId, stateID, value, common, debugId);
+                                if (has_elevated_debug) this.emit('device_debug', { ID:debugId, data: { flag:'SUCCESS', IO:true }});
+                            }
+                        }
+                        has_published = true;
+                    }
+                } catch (e) {
+                    const message = `unable to enumerate states of ${devId} for payload ${JSON.stringify(payload)}, ${(e ? e.name : 'undefined')} (${(e ? e.message : '')}).`;
+                    if (has_elevated_debug) this.emit('device_debug', { ID:debugId, data:{ error:'ESTATE', IO:true }, message:message});
+                    else this.debug(message);
+                }
+                const message = `No value published for device ${devId}`;
+                if (!has_published && has_elevated_debug) this.emit('device_debug', { ID:debugId, data:{ error:'NOVAL', IO:true }, message:message});
+                else this.debug(message);
+            }
+            else {
+                const message = `ELEVATED IE05 - NOSTATE: No states matching the payload ${JSON.stringify(payload)} for device ${devId}`;
+                if (has_elevated_debug) this.emit('device_debug', { ID:debugId, data:{ error:'NOSTATE', IO:true }, message});
+                else this.debug(message);
+            }
         }
-        if (!devStates) {
-            if (has_elevated_debug)
-                this.elevatedMessage(devId, `ELEVATED IE02: no device states for device ${devId} type '${model}'`, true)
-            return;
+        catch (error) {
+            this.error('Something went horribly wrong: ' + (error && error.message ? error.message : 'no reason given'));
         }
-        // find states for payload
-        let has_published = false;
+    }
 
-        if (devStates.states !== undefined) {
-            try {
-                const states = statesMapping.commonStates.concat(
-                    devStates.states.filter(statedesc => payload.hasOwnProperty(statedesc.prop || statedesc.id))
-                );
-
-                for (const stateInd in states) {
-                    const statedesc = states[stateInd];
-                    let value;
-                    if (statedesc.getter) {
-                        value = statedesc.getter(payload);
-                    } else {
-                        value = payload[statedesc.prop || statedesc.id];
-                    }
-                    // checking value
-                    if (value === undefined || value === null) {
-                        continue;
-                    }
+    async processConverters(converters, devId, model, mappedModel, message, meta, debugId) {
+        for (const converter of converters) {
+            const publish = (payload, dID) => {
+                if (typeof payload === 'object') {
+                    this.publishToState(devId, model, payload,dID);
+                }
+            };
 
-                    let stateID = statedesc.id;
+            const options = await new Promise((resolve, reject) => {
+                this.collectOptions(devId, model, (options) => {
+                    resolve(options);
+                });
+            });
 
-                    if (has_elevated_debug) {
-                        this.elevatedMessage(devId, `ELEVATED I02: value generated '${JSON.stringify(value)}' from device ${devId} for '${statedesc.name}'`, false);
-                    }
+            const payload = await new Promise((resolve, reject) => {
+                const payloadConv = converter.convert(mappedModel, message, publish, options, meta);
+                if (typeof payloadConv === 'object') {
+                    resolve(payloadConv);
+                }
+            });
 
-                    const common = {
-                        name: statedesc.name,
-                        type: statedesc.type,
-                        unit: statedesc.unit,
-                        read: statedesc.read,
-                        write: statedesc.write,
-                        icon: statedesc.icon,
-                        role: statedesc.role,
-                        min: statedesc.min,
-                        max: statedesc.max,
-                    };
-
-                    if (typeof value === 'object' && value.hasOwnProperty('stateid')) {
-                        stateID = `${stateID}.${value.stateid}`;
-                        if (value.hasOwnProperty('unit')) {
-                            common.unit = value.unit;
-                        }
-                        common.name = value.name ? value.name : value.stateid;
-                        common.role = value.role ? `value.${value.role}` : 'number';
-                        value = value.value;
-                    }
+            publish(payload, debugId);
+        }
+    }
 
-                    // if needs to return value to back after timeout
-                    if (statedesc.isEvent) {
-                        this.updateStateWithTimeout(devId, statedesc.id, value, common, 300, (typeof value == typeof (!value) ? !value : ''));
-                    } else {
-                        if (statedesc.prepublish) {
-                            this.collectOptions(devId, model, options =>
-                                statedesc.prepublish(devId, value, newvalue =>
-                                    this.updateState(devId, stateID, newvalue, common), options)
-                            );
-                        } else {
-                            this.updateState(devId, stateID, value, common);
+
+    async onZigbeeEvent(type, entity, message) {
+        this.debug(`Type ${type} device ${safeJsonStringify(entity)} incoming event: ${safeJsonStringify(message)}`);
+
+        const device = entity.device;
+        const mappedModel = entity.mapped;
+        const model = entity.mapped ? entity.mapped.model : entity.device.modelID;
+        const cluster = message.cluster;
+        const devId = device.ieeeAddr.substr(2);
+        const meta = {device};
+
+        const has_elevated_debug = this.checkDebugDevice(devId);
+        const debugId = Date.now();
+
+        // raw message data for logging and msg_from_zigbee
+        const msgForState = Object.assign({}, message);
+        delete msgForState['device'];
+        delete msgForState['endpoint'];
+        msgForState['endpoint_id'] = message.endpoint.ID;
+
+        if (has_elevated_debug) {
+            const message = `Zigbee Event of Type ${type} from device ${device.ieeeAddr}, incoming event: ${safeJsonStringify(msgForState)}`;
+            this.emit('device_debug', { ID:debugId, data: { ID: device.ieeeAddr, payload:safeJsonStringify(msgForState), flag:'01', IO:true }, message:message});
+
+        }
+        // this assigment give possibility to use iobroker logger in code of the converters, via meta.logger
+        meta.logger = this;
+
+        await this.adapter.checkIfModelUpdate(entity);
+
+        let _voltage = 0;
+        let _temperature = 0;
+        let _humidity = 0;
+
+        let isMessure = false;
+        let isBattKey = false;
+
+        if (mappedModel && mappedModel.meta && mappedModel.meta.battery) {
+            const isVoltage = mappedModel.meta.battery.hasOwnProperty('voltageToPercentage');
+
+            if (isVoltage) {
+                const keys = Object.keys(message.data);
+
+                for (const key of keys) {
+                    const value = message.data[key];
+
+                    if (value && value[1]) {
+                        if (key == 65282 && value[1][1]) {
+                            _voltage = value[1][1].elmVal;
+                            isBattKey = true;
+                            break;
+                        }
+                        if (key == 65281) {
+                            _voltage = value[1];
+                            isBattKey = true;
+                            _temperature = value[100];
+                            _temperature = _temperature /100;
+                            _humidity = value[101];
+                            _humidity = _humidity / 100;
+                            isMessure = true;
+                            break;
                         }
                     }
-                    has_published = true;
                 }
-            } catch (e) {
-                this.debug(`No states in device ${devId} : payload ${JSON.stringify(payload)}`);
-                if (has_elevated_debug)
-                    this.elevatedMessage(devId, `ELEVATED IE03: error when enumerating states of ${devId} for payload ${JSON.stringify(payload)}, ${(e ? e.name : 'undefined')} (${(e ? e.message : '')}).`, true);
             }
-            if (!has_published && has_elevated_debug) {
-                this.elevatedMessage(devId, `ELEVATED IE04: No value published for device ${devId}`, true);
+        }
 
+        // always publish link_quality and battery
+        if (message.linkquality) { // send battery with
+            this.publishToState(devId, model, {linkquality: message.linkquality}, debugId);
+            if (isBattKey) {
+                this.publishToState(devId, model, {voltage: _voltage}, debugId);
+                const  battProz = zigbeeHerdsmanConvertersUtils.batteryVoltageToPercentage(_voltage,entity.mapped.meta.battery.voltageToPercentage);
+                this.publishToState(devId, model, {battery: battProz}, debugId);
+            }
+            if (isMessure) {
+                this.publishToState(devId, model, {temperature: _temperature}, debugId);
+                this.publishToState(devId, model, {humidity: _humidity}), debugId;
             }
         }
-        else {
-            if (has_elevated_debug)
-                this.elevatedMessage(devId, `ELEVATED IE05: No states matching the payload ${JSON.stringify(payload)} for device ${devId}`, true);
+
+        // publish raw event to "from_zigbee"
+        // some cleanup
+
+        this.publishToState(devId, model, {msg_from_zigbee: safeJsonStringify(msgForState)}, -1);
+
+        if (!entity.mapped) {
+            return;
+        }
+
+        let converters = mappedModel.fromZigbee.filter(c => c && c.cluster === cluster && (
+            Array.isArray(c.type) ? c.type.includes(type) : c.type === type));
+
+
+        if (!converters.length && type === 'readResponse') {
+            converters = mappedModel.fromZigbee.filter(c => c.cluster === cluster && (
+                Array.isArray(c.type) ? c.type.includes('attributeReport') : c.type === 'attributeReport'));
         }
+
+        if (!converters.length) {
+            if (type !== 'readResponse') {
+                const message = `No converter available for '${mappedModel.model}' '${devId}' with cluster '${cluster}' and type '${type}'`;
+                if (has_elevated_debug) this.emit('device_debug', { ID:debugId, data: { error:'NOCONV', IO:true }, message:message});
+                else this.debug(message);
+            }
+            return;
+        }
+
+        meta.state = { state: '' };   // for tuya
+
+        this.processConverters(converters, devId, model, mappedModel, message, meta, debugId)
+            .catch((error) => {
+                //   'Error: Expected one of: 0, 1, got: 'undefined''
+                if (cluster !== '64529') {
+                    if (has_elevated_debug) this.emit('device_debug', { ID:debugId, data: { error:'EPROC', IO:true }});
+                    this.error(`Error while processing converters DEVICE_ID: '${devId}' cluster '${cluster}' type '${type}'`);
+                }
+            });
     }
 
+
+
 }
 
 module.exports = StatesController;

package/lib/zbDeviceAvailability.js

@@ -178,7 +178,7 @@ class DeviceAvailability extends BaseExtension {
                 this.publishAvailability(device, false);
                 if (pingCount.failed++ <= this.max_ping) {
                     if (pingCount.failed < 2 && pingCount.reported < this.max_ping) {
-                        this.warn(`Failed to ping ${ieeeAddr} ${device.modelID}`);
+                        this.info(`Failed to ping ${ieeeAddr} ${device.modelID}`);
                         pingCount.reported++;
                     } else {
                         this.debug(`Failed to ping ${ieeeAddr} ${device.modelID} on ${pingCount} consecutive attempts`);
@@ -186,7 +186,7 @@ class DeviceAvailability extends BaseExtension {
                     this.setTimerPingable(device, pingCount.failed);
                     this.ping_counters[device.ieeeAddr] = pingCount;
                 } else {
-                    this.warn(`Stopping to ping ${ieeeAddr} ${device.modelID} after ${pingCount.failed} ping attempts`);
+                    this.info(`Stopping to ping ${ieeeAddr} ${device.modelID} after ${pingCount.failed} ping attempts`);
                 }
             }
         }

package/lib/zbDeviceConfigure.js

@@ -14,6 +14,8 @@ class DeviceConfigure extends BaseExtension {
         this.configuring = new Set();
         this.attempts = {};
         this.name = 'DeviceConfigure';
+
+        this.configureKeys = {};
     }
 
     setOptions(options) {
@@ -27,23 +29,24 @@ class DeviceConfigure extends BaseExtension {
         if (!mappedDevice || !mappedDevice.configure) {
             return false;
         }
-        if (device.meta.hasOwnProperty('configured') &&
-            zigbeeHerdsmanConverters.getConfigureKey(mappedDevice)) {
-            return false;
-        }
-
-        return (device.interviewing !== true && this.checkDelayedConfigure(device.ieeeAddr)>0);
+        const delayedAttempts = this.checkDelayedConfigure(device, 0);
+        if (!this.configureKeys.hasOwnProperty(device.ieeeAddr)) this.configureKeys[device.ieeeAddr] = zigbeeHerdsmanConverters.getConfigureKey(mappedDevice);
+        if (delayedAttempts > 0 && !device.interviewing) return true;
+        if (device.meta.hasOwnProperty('configured') && device.meta.configured !== this.configureKeys[device.ieeeAddr]) return true;
+        return (device.interviewing !== true && this.checkDelayedConfigure(device)>0);
     }
 
     checkDelayedConfigure(device, num) {
         if (!this.delayedConfigure.hasOwnProperty(device.ieeeAddr)) {
             if (num && num > 0) {
+                // this.warn('adding dev ' + device.ieeeAddr + ' to delayedConfigure with ' + num + ' attempts');
                 this.delayedConfigure[device.ieeeAddr] = { maxAttempts:num };
                 return num;
             }
             return 0;
         }
         const dc = this.delayedConfigure[device.ieeeAddr];
+        // this.warn('checkDelayedConfigure for ' + device.ieeeAddr + ' with ' + JSON.stringify(dc));
         dc.maxAttempts--;
         if (dc.maxAttempts > 0) return dc.maxAttempts;
         if (num && num > 0) {
@@ -90,6 +93,7 @@ class DeviceConfigure extends BaseExtension {
         try {
             const device = data.device;
             if (this.shouldConfigure(device, mappedDevice)) {
+                this.debug('ShouldConfigure ' + device.ieeeAddr);
                 this.configure(device, mappedDevice);
             }
         } catch (error) {
@@ -98,6 +102,7 @@ class DeviceConfigure extends BaseExtension {
         }
     }
 
+
     onDeviceRemove(device) {
         try {
             if (this.configuring.has(device.ieeeAddr)) {
@@ -141,14 +146,16 @@ class DeviceConfigure extends BaseExtension {
         const coordinatorEndpoint = await this.zigbee.getDevicesByType('Coordinator')[0].endpoints[0];
         try {
             if (mappedDevice) {
-                this.info(`-> Configuring ${device.ieeeAddr} ${device.modelID}`);
-                const promises = [];
-                promises.push(mappedDevice.configure);
-                await Promise.all(promises.map(callback => callback(device, coordinatorEndpoint, mappedDevice)))
-
-                //await mappedDevice.configure(device, coordinatorEndpoint, this);
-
+                if (mappedDevice.configure === undefined) return `No configure available for ${device.ieeeAddr} ${device.modelID}.`;
+                this.info(`Configuring ${device.ieeeAddr} ${device.modelID}`);
+                if (typeof mappedDevice.configure === 'function') await mappedDevice.configure(device, coordinatorEndpoint, this);
+                else {
+                    const promises = [];
+                    promises.push(...mappedDevice.configure);
+                    await Promise.all(promises.map(callback => callback(device, coordinatorEndpoint, mappedDevice)))
+                }
                 device.meta.configured = zigbeeHerdsmanConverters.getConfigureKey(mappedDevice);
+                this.configureKeys[device.ieeeAddr] = device.meta.configured;
                 device.save();
                 this.info(`DeviceConfigure successful ${device.ieeeAddr} ${device.modelID}`);
                 this.delayedConfigureAttempt(device, true);
@@ -162,8 +169,8 @@ class DeviceConfigure extends BaseExtension {
                 if (error && error.message && error.message.match(/(\d+)ms/gm)) {
                     // timeout message - we do want to start the configure chain
                     const num = this.delayedConfigureAttempt(device, false);
-                    this.info(`Delayed configure for ${device.ieeeAddr} ${device.modelID}:  ${num} attempts remaining`)
-                    return `Delayed configure for ${device.ieeeAddr} ${device.modelID}:  ${num} attempts remaining`;
+                    this.warn(`Timeout trying to configure ${device.ieeeAddr} ${device.modelID}:  ${num} attempts remaining`)
+                    return `Configuration timed out ${device.ieeeAddr} ${device.modelID}. The device did not repond in time to the configuration request. Another attempt will be made when the device is awake.`;
                 } else {
                     this.sendError(error);
                     this.warn(`${device.ieeeAddr} ${device.modelID} Failed to configure. --> ${error && error.message ? error.message : ' no error message given'} `);