iobroker.zigbee 3.0.3 → 3.1.2

package/lib/statescontroller.js

@@ -35,6 +35,7 @@ class StatesController extends EventEmitter {
         this.stashedUnknownModels = [];
         this.debugMessages = { nodevice:{ in:[], out: []} };
         this.debugActive = true;
+        this.deviceQueryBlock = [];
     }
 
     info(message, data) {
@@ -81,6 +82,8 @@ class StatesController extends EventEmitter {
     }
 
     async AddModelFromHerdsman(device, model) {
+        const namespace = `${this.adapter.name}.admin`;
+
         // this.warn('addModelFromHerdsman ' + JSON.stringify(model) + ' ' + JSON.stringify(this.localConfig.getOverrideWithKey(model, 'legacy', true)));
         if (this.localConfig.getOverrideWithTargetAndKey(model, 'legacy', true)) {
             this.debug('Applying legacy definition for ' + model);
@@ -97,52 +100,56 @@ class StatesController extends EventEmitter {
                 const srcIcon = (modelDesc ? modelDesc.icon : '');
                 const model_modif = model.replace(/\//g, '-');
                 const pathToAdminIcon = `img/${model_modif}.png`;
-
-                const namespace = `${this.adapter.name}.admin`;
+                // source is a web address
                 if (srcIcon.startsWith('http')) {
-                    this.adapter.fileExists(namespace, srcIcon, async(err, result) => {
-                        if (result) {
-                            this.debug(`icon ${modelDesc.icon} found - no copy needed`);
-                            return;
-                        }
-                        try {
-                            this.downloadIconToAdmin(srcIcon, pathToAdminIcon)
-                            modelDesc.icon = pathToAdminIcon;
-                        } catch (e) {
-                            this.warn(`ERROR : icon not found at ${srcIcon}`);
-                        }
-                        return;
-                    });
+                    try {
+                        //if (modelDesc) modelDesc.icon = pathToAdminIcon;
+                        this.downloadIconToAdmin(srcIcon, pathToAdminIcon)
+                    } catch (err) {
+                        this.warn(`ERROR : unable to download ${srcIcon}: ${err && err.message ? err.message : 'no reason given'}`);
+                    }
                     return;
                 }
+                // source is inline basee64
                 const base64Match = srcIcon.match(/data:image\/(.+);base64,/);
                 if (base64Match) {
                     this.warn(`base 64 Icon matched, trying to save it to disk as ${pathToAdminIcon}`);
-                    modelDesc.icon = pathToAdminIcon;
+                    if (modelDesc) modelDesc.icon = pathToAdminIcon;
                     this.adapter.fileExists(namespace, pathToAdminIcon, async (err,result) => {
                         if (result) {
                             this.warn(`no need to save icon to ${pathToAdminIcon}`);
                             return;
                         }
-                        this.warn(`Saving base64 data to ${pathToAdminIcon}`)
-                        const buffer = new Buffer(srcIcon.replace(base64Match[0],''), 'base64');
-                        this.adapter.writeFile(pathToAdminIcon, buffer);
-                        this.warn('write file complete.');
+                        const msg = `Saving base64 Data to ${pathToAdminIcon}`
+                        try {
+                            const buffer = Buffer.from(srcIcon.replace(base64Match[0],''), 'base64');
+                            this.adapter.writeFile(namespace, pathToAdminIcon, buffer, (err) => {
+                                if (err) {
+                                    this.warn(`${msg} -- failed: ${err && err.message ? err.message : 'no reason given'}`);
+                                    return;
+                                }
+                                this.info(`${msg} -- success`);
+                            });
+                        }
+                        catch (err) {
+                            this.warn(`${msg} -- failed: ${err && err.message ? err.message : 'no reason given'}`)
+                        }
                     });
                     return;
                 }
+                // path is absolute
                 if (modelDesc) modelDesc.icon = pathToAdminIcon;
                 this.adapter.fileExists(namespace, pathToAdminIcon, async(err, result) => {
                     if (result) {
-                        this.debug(`icon ${modelDesc.icon} found - no copy needed`);
+                        this.debug(`icon ${modelDesc ? modelDesc.icon : 'unknown icon'} found - no copy needed`);
                         return;
                     }
                     // try 3 options for source file
                     let src = srcIcon; // as given
                     const locations=[];
                     if (!fs.existsSync(src)) {
-                        locations.push(src);
                         src = path.normalize(this.adapter.expandFileName(src));
+                        locations.push(src);
                     } // assumed relative to data folder
                     if (!fs.existsSync(src)) {
                         locations.push(src);
@@ -158,36 +165,46 @@ class StatesController extends EventEmitter {
                     }
                     fs.readFile(src, (err, data) => {
                         if (err) {
-                            this.error('unable to read ' + src + ' : '+ (err.message? err.message:' no message given'))
+                            this.warn(`unable to read ${src}: ${(err.message? err.message:' no message given')}`);
                             return;
                         }
                         if (data) {
                             this.adapter.writeFile(namespace, pathToAdminIcon, data, (err) => {
                                 if (err) {
-                                    this.error('error writing file ' + path + JSON.stringify(err))
+                                    this.error(`error writing file ${path}: ${err.message ? err.message : 'no reason given'}`);
                                     return;
                                 }
                                 this.info('Updated image file ' + pathToAdminIcon);
                             });
+                            return;
                         }
+                        this.error(`fs.readFile failed - neither error nor data is returned!`);
                     });
                 });
             }
         }
     }
 
+    async updateDebugDevices(debugDevices) {
+        if (debugDevices != undefined)
+            this.debugDevices = debugDevices;
+        this.adapter.zbController.callExtensionMethod('setLocalVariable', ['debugDevices', this.debugDevices]);
+
+    }
+
     async getDebugDevices(callback) {
         if (this.debugDevices === undefined) {
             this.debugDevices = [];
             const state = await this.adapter.getStateAsync(`${this.adapter.namespace}.info.debugmessages`);
             if (state) {
                 if (typeof state.val === 'string' && state.val.length > 2) {
-                    this.debugDevices = state.val.split(';');
+                    this.updateDebugDevices(state.val.split(';'));
                 }
                 this.info(`debug devices set to ${JSON.stringify(this.debugDevices)}`);
                 if (callback) callback(this.debugDevices);
             }
         } else {
+            this.updateDebugDevices();
             // this.info(`debug devices was already set to ${JSON.stringify(this.debugDevices)}`);
             callback(this.debugDevices)
         }
@@ -195,15 +212,20 @@ class StatesController extends EventEmitter {
 
     async toggleDeviceDebug(id) {
         const arr = /zigbee.[0-9].([^.]+)/gm.exec(id);
+        if (!arr) {
+            this.warn(`unable to toggle debug for device ${id}: there was no mat (${JSON.stringify(arr)}) `);
+            return this.debugDevices;
+        }
         if (arr[1] === undefined) {
             this.warn(`unable to extract id from state ${id}`);
-            return [];
+            return this.debugDevices;
         }
         const stateKey = arr[1];
         if (this.debugDevices === undefined) this.debugDevices = await this.getDebugDevices()
         const idx = this.debugDevices.indexOf(stateKey);
         if (idx < 0) this.debugDevices.push(stateKey);
         else this.debugDevices.splice(idx, 1);
+        this.updateDebugDevices()
         await this.adapter.setStateAsync(`${this.adapter.namespace}.info.debugmessages`, this.debugDevices.join(';'), true);
         this.info('debug devices set to ' + JSON.stringify(this.debugDevices));
         return this.debugDevices;
@@ -243,12 +265,13 @@ class StatesController extends EventEmitter {
                 } else {
                     this.debugDevices = [];
                 }
+                this.updateDebugDevices();
                 this.info('debug devices set to ' + JSON.stringify(this.debugDevices));
                 return;
             }
 
             const devId = getAdId(this.adapter, id); // iobroker device id
-            let deviceId = getZbId(id); // zigbee device id
+            const 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}`;
@@ -272,15 +295,24 @@ class StatesController extends EventEmitter {
                         if (this.debugActive) this.debug('State Change detected on deactivated Device - ignored');
                         return;
                     }
-                    if (model === 'group') {
-                        const match = deviceId.match(/group_(\d+)/gm);
-                        if (match) {
-                            deviceId = parseInt(match[1]);
-                            this.publishFromState(deviceId, model, stateKey, state, {});
+                    // check for group (model is group, deviceId is numerical, and not Nan or 0)
+                    /*
+                    if (model === 'group' && typeof deviceId == 'number' && Boolean(deviceId)) {
+                        const options = this.localConfig.getOptions(`group_${deviceId}`);
+                        options.isActive == (obj.common !== null);
+                        this.publishFromState(deviceId, model, stateKey, state, options, debugId);
+                        return;
+                    }
+                    */
+                    // handle send_payload here
+                    if (model && model.id === 'device_query') {
+                        if (this.query_device_block.indexOf(deviceId) > -1 && !state.source.includes('.admin.')) {
+                            this.info(`Device query for '${deviceId}' blocked - device query timeout has not elapsed yet.`);
                             return;
                         }
-
+                        this.emit('device_query', { deviceId, debugId });
                     }
+
                     this.collectOptions(id.split('.')[2], model, true,  options =>
                         this.publishFromState(deviceId, model, stateKey, state, options, debugId));
                 }
@@ -295,7 +327,7 @@ class StatesController extends EventEmitter {
                 callback(result);
                 return;
             }
-            // find model states for options and get it values. No options for groups !!!
+            // find model states for options and get it values.
             const devStates = await this.getDevStates('0x' + devId, model);
             if (devStates == null || devStates == undefined || devStates.states == null || devStates.states == undefined) {
                 callback(result);
@@ -372,7 +404,7 @@ class StatesController extends EventEmitter {
         }
     }
 
-    async triggerComposite(_deviceId, model, stateDesc, interactive) {
+    async triggerComposite(_deviceId, stateDesc, interactive) {
         const deviceId = (_deviceId.replace('0x', ''));
         const idParts = stateDesc.id.split('.').slice(-2);
         const key = `${deviceId}.${idParts[0]}`;
@@ -400,20 +432,26 @@ class StatesController extends EventEmitter {
         }, (stateDesc.compositeTimeout ? stateDesc.compositeTimeout : 100) * factor);
     }
 
-    async publishFromState(deviceId, model, stateKey, state, options, debugId) {
+
+    handleLinkedFunctResult(lfArr, devId, state) {
+        if (this.handleOption(devId, state.stateDesc)) return;
+        lfArr.push(state);
+    }
+
+    async publishFromState(deviceId, model, stateKey, state, options, debugID) {
         if (this.debugActive) this.debug(`Change state '${stateKey}' at device ${deviceId} type '${model}'`);
-        const elevated = this.checkDebugDevice(deviceId);
+        const has_elevated_debug = this.checkDebugDevice(typeof deviceId == 'number' ? `group_${deviceId}` : deviceId);
 
-        if (elevated)  {
+        if (has_elevated_debug)  {
             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});
+            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) {
+            if (has_elevated_debug) {
                 const message = (`no device states for device ${deviceId} type '${model}'`);
-                this.emit('device_debug', { ID:debugId, data: { error: 'NOSTATES' , IO:false }, message:message});
+                this.emit('device_debug', { ID:debugID, data: { error: 'NOSTATES' , IO:false }, message:message});
             }
             return;
         }
@@ -422,33 +460,80 @@ class StatesController extends EventEmitter {
         const stateModel = devStates.stateModel;
         if (!stateDesc) {
             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});
+            if (has_elevated_debug) 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) {
+            if (has_elevated_debug) {
                 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});
+                this.emit('device_debug', { ID:debugID, data: { states:[{id:state.ID, value:'--', payload:'error', ep:stateDesc.epname}],error: 'NOVAL' , IO:false }, message:message});
+            }
+            return;
+        }
+
+        // send_payload can never be a linked state !;
+        if (stateDesc.id === 'send_payload') {
+            try {
+                const json_value = JSON.parse(value);
+                const payload = {device: deviceId.replace('0x', ''), payload: json_value, model:model, stateModel:stateModel};
+                if (has_elevated_debug) this.emit('device_debug', { ID:debugID, data: { flag: '04' ,payload:value ,states:[{id:stateDesc.id, value:json_value, payload:'none'}], IO:false }});
+
+                this.emit('send_payload', payload, debugID);
+            } catch (error) {
+                const message = `send_payload: ${value} does not parse as JSON Object : ${error.message}`;
+                if (has_elevated_debug) this.emit('device_debug', { ID:debugID, data: { error: 'EXSEND' ,states:[{id:stateDesc.id, value:value, payload:error.message}], IO:false }, message:message});
+                else this.error(message);
+                return;
+            }
+            return;
+        }
+
+        if (stateDesc.id === 'device_query') {
+            const interactive = (state.from.includes('.admin'));
+            if (!interactive && this.deviceQueryBlock.includes(deviceId)) {
+                this.warn(`device_query blocked due to excessive triggering - retrigger > 10 seconds after previous trigger has completed.`);
+                return;
             }
+            this.deviceQueryBlock.push[deviceId];
+            const id = deviceId;
+            this.emit('device_query', deviceId, debugID, has_elevated_debug, (devId) =>{
+                setTimeout(() => { const idx = this.deviceQueryBlock.indexOf(id);
+                    if (idx > -1) this.deviceQueryBlock.splice(idx);
+                }, 10000)
+
+            } )
+            return;
+        }
+
+        // composite states can never be linked states;
+        if (stateDesc.compositeState && stateDesc.compositeTimeout) {
+            this.triggerComposite(deviceId, stateDesc, state.from.includes('.admin.'));
             return;
         }
-        let stateList = [{stateDesc: stateDesc, value: value, index: 0, timeout: 0, source:state.from}];
+
+        const stateList = [{stateDesc: stateDesc, value: value, index: 0, timeout: 0, source:state.from}];
+
         if (stateModel && stateModel.linkedStates) {
             stateModel.linkedStates.forEach(linkedFunct => {
                 try {
                     if (typeof linkedFunct === 'function') {
                         const res = linkedFunct(stateDesc, value, options, this.adapter.config.disableQueue);
                         if (res) {
-                            stateList = stateList.concat(res);
+                            if (res.hasOwnProperty('stateDesc')) { // we got a single state back
+                                if (! res.stateDesc.isOption) stateList.push(res);
+                            }
+                            else {
+                                res.forEach((ls) => { if (!ls.stateDesc.isOption) stateList.push(res)} );
+                            }
                         }
                     } else {
                         this.warn(`publish from State - LinkedState is not a function ${JSON.stringify(linkedFunct)}`);
                     }
                 } catch (e) {
                     this.sendError(e);
-                    if (elevated) this.emit('device_debug', { ID:debugId, data: { states:[{id:state.ID, value:state.val, payload:'unknown'}], error: 'EXLINK' , IO:false }});
+                    if (has_elevated_debug) 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'));
                 }
 
@@ -464,7 +549,8 @@ class StatesController extends EventEmitter {
                 readAfterWriteStates = readAfterWriteStates.concat(readAfterWriteStateDesc.id));
         }
 
-        this.emit('changed', deviceId, model, stateModel, stateList, options, debugId);
+        if (stateList.length > 0)
+            this.emit('changed', deviceId, model, stateModel, stateList, options, debugID, has_elevated_debug );
     }
 
     async renameDevice(id, newName) {
@@ -481,7 +567,6 @@ class StatesController extends EventEmitter {
     }
 
     verifyDeviceName(id, model ,name) {
-        const savedId = id.replace(`${this.adapter.namespace}.`, '');
         return this.localConfig.NameForId(id, model, name);
     }
 
@@ -503,7 +588,7 @@ class StatesController extends EventEmitter {
             }
 
         } catch (error) {
-            this.adapter.log.info(`Cannot delete Object ${devId}: ${error && error.message ? error.message : 'without error message'}`);
+            this.adapter.log.warn(`Cannot delete Object ${devId}: ${error && error.message ? error.message : 'without error message'}`);
         }
     }
 
@@ -576,35 +661,8 @@ class StatesController extends EventEmitter {
                 const stateId = devId + '.' + name;
                 const new_name = obj.common.name;
                 if (common) {
-                    if (common.name !== undefined) {
-                        new_common.name = common.name;
-                    }
-                    if (common.type !== undefined) {
-                        new_common.type = common.type;
-                    }
-                    if (common.unit !== undefined) {
-                        new_common.unit = common.unit;
-                    }
-                    if (common.states !== undefined) {
-                        new_common.states = common.states;
-                    }
-                    if (common.read !== undefined) {
-                        new_common.read = common.read;
-                    }
-                    if (common.write !== undefined) {
-                        new_common.write = common.write;
-                    }
-                    if (common.role !== undefined) {
-                        new_common.role = common.role;
-                    }
-                    if (common.min !== undefined) {
-                        new_common.min = common.min;
-                    }
-                    if (common.max !== undefined) {
-                        new_common.max = common.max;
-                    }
-                    if (common.icon !== undefined) {
-                        new_common.icon = common.icon;
+                    for (const key in common) {
+                        if (common[key] !== undefined) new_common[key] = common[key];
                     }
                 }
                 // check if state exist
@@ -697,7 +755,7 @@ class StatesController extends EventEmitter {
                 if (this.debugActive) this.debug(`UpdateState: Device is deactivated ${devId} ${JSON.stringify(obj)}`);
             }
         } else {
-            if (this.debugActive) this.debug(`UpdateState: missing device ${devId} ${JSON.stringify(obj)}`);
+            if (this.debugActive) this.debug(`UpdateState: missing device ${devId}`);
         }
     }
 
@@ -760,15 +818,25 @@ class StatesController extends EventEmitter {
         statesMapping.getByModel();
     }
 
-    async getDefaultGroupIcon(id) {
-        const regexResult = id.match(new RegExp(/group_(\d+)/));
-        if (!regexResult) return '';
-        const groupID = Number(regexResult[1]);
-        const group = await this.adapter.zbController.getGroupMembersFromController(groupID)
-        if (typeof group == 'object')
-            return `img/group_${Math.max(Math.min(group.length, 7), 0)}.png`
-        else
-            return 'img/group_x.png'
+
+    async getDefaultGroupIcon(id, members) {
+        let groupID = 0;
+        if (typeof id == 'string') {
+            const regexResult = id.match(new RegExp(/group_(\d+)/));
+            if (!regexResult) return '';
+            groupID = Number(regexResult[1]);
+        } else if (typeof id == 'number') {
+            groupID = id;
+        }
+        if (groupID <= 0) return;
+        if (typeof members != 'number') {
+            const group = await this.adapter.zbController.getGroupMembersFromController(groupID)
+            if (typeof group == 'object')
+                return `img/group_${Math.max(Math.min(group.length, 7), 0)}.png`
+            else
+                return 'img/group_x.png'
+        }
+        return `img/group_${Math.max(Math.min(members, 7), 0)}.png`
     }
 
     async updateDev(dev_id, dev_name, model, callback) {
@@ -777,7 +845,9 @@ class StatesController extends EventEmitter {
         if (this.debugActive) this.debug(`UpdateDev called with ${dev_id}, ${dev_name}, ${model}, ${__dev_name}`);
         const id = '' + dev_id;
         const modelDesc = statesMapping.findModel(model);
-        const modelIcon = (model == 'group' ? await this.getDefaultGroupIcon(dev_id) : modelDesc && modelDesc.icon ? modelDesc.icon : 'img/unknown.png');
+        const modelIcon = (model == 'group' ?
+            await this.getDefaultGroupIcon(dev_id) :
+            modelDesc && modelDesc.icon ? modelDesc.icon : 'img/unknown.png');
         let icon = this.localConfig.IconForId(dev_id, model, modelIcon);
 
         // download icon if it external and not undefined
@@ -786,6 +856,8 @@ class StatesController extends EventEmitter {
         } else {
             const model_modif = model.replace(/\//g, '-');
             const pathToAdminIcon = `img/${model_modif}.png`;
+//            await this.fetchIcon(icon, '')
+
 
             if (icon.startsWith('http')) {
                 try {
@@ -824,39 +896,69 @@ class StatesController extends EventEmitter {
         });
     }
 
+    async streamToBuffer(readableStream) {
+        return new Promise((resolve, reject) => {
+            const chunks = [];
+            readableStream.on('data', data => {
+                if (typeof data === 'string') {
+                    // Convert string to Buffer assuming UTF-8 encoding
+                    chunks.push(Buffer.from(data, 'utf-8'));
+                } else if (data instanceof Buffer) {
+                    chunks.push(data);
+                } else {
+                    // Convert other data types to JSON and then to a Buffer
+                    const jsonData = JSON.stringify(data);
+                    chunks.push(Buffer.from(jsonData, 'utf-8'));
+                }
+            });
+            readableStream.on('end', () => {
+                resolve(Buffer.concat(chunks));
+            });
+            readableStream.on('error', (err) => {
+                this.error(`error getting buffer from stream: ${err && err.message ? err.message : 'no reason given'}`);
+                reject;
+            });
+        });
+    }
+
+    async fetchIcon(url, image_path) {
+        const response = await fetch(url);
+        const data = await this.streamToBuffer(response.body);
+        fs.writeFileSync('/opt/iobroker/iobroker-data/zigbee_0/test.png', response.data);
+    }
+
     async downloadIcon(url, image_path) {
         try {
-            if (!fs.existsSync(image_path)) {
-                this.ImagesToDownload.push(url);
-                return new Promise((resolve, reject) => {
-                    this.info(`downloading ${url} to ${image_path}`);
-                    axios({
-                        method: 'get',
-                        url: url,
-                        responseType: 'stream'  // Dies ist wichtig, um den Stream direkt zu erhalten
-                    }).then(response => {
-                        const writer = fs.createWriteStream(image_path);
-                        response.data.pipe(writer);
-                        writer.on('finish', resolve);
-                        writer.on('error', reject);
-                    }).catch(err => {
-                        // reject(err);
-                        this.warn(`ERROR : icon path not found ${image_path}`);
-                    }).finally(() => {
-                        const idx = this.ImagesToDownload.indexOf(url);
-                        if (idx > -1) {
-                            this.ImagesToDownload.splice(idx, 1);
+            const namespace = `${this.adapter.name}.admin`;
+            this.ImagesToDownload.push(url);
+            return new Promise((resolve, reject) => {
+                this.info(`downloading ${url} to ${image_path}`);
+                axios({
+                    method: 'get',
+                    url: url,
+                    responseType: 'stream'  // Dies ist wichtig, um den Stream direkt zu erhalten
+                }).then(async response => {
+                    const data = await this.streamToBuffer(response.data);
+                    this.adapter.writeFile(namespace, image_path, data, (err) => {
+                        if (err) {
+                            this.error(`error writing ${image_path} to admin: ${err.message ? err.message : 'no message given'}`);
+                            reject;
                         }
-
+                        this.info(`downloaded ${url} to ${image_path}.`)
+                        resolve;
                     });
+                }).catch(err => {
+                    this.warn(`error downloading icon ${err && err.message ? err.message : 'no message given'}`);
+                }).finally(() => {
+                    const idx = this.ImagesToDownload.indexOf(url);
+                    if (idx > -1) {
+                        this.ImagesToDownload.splice(idx, 1);
+                    }
                 });
-            }
-            else {
-                this.info(`not downloading ${image_path} - file exists`)
-            }
+            });
         }
         catch (error) {
-            this.error('downloadIcon ', error);
+            this.error('error in downloadIcon:  ', error && error.message ? error.message : 'no message given');
         }
     }
 
@@ -864,33 +966,8 @@ class StatesController extends EventEmitter {
         const namespace = `${this.adapter.name}.admin`;
         this.adapter.fileExists(namespace, target, async (err,result) => {
             if (result) return;
-            const src = `${tmpdir()}/${path.basename(target)}`;
-            //const msg = `downloading ${url} to ${src}`;
             if (this.ImagesToDownload.indexOf(url) ==-1) {
-                await this.downloadIcon(url, src)
-                try {
-                    fs.readFile(src, (err, data) => {
-                        if (err) {
-                            this.error('unable to read ' + src + ' : '+ (err && err.message? err.message:' no message given'))
-                            return;
-                        }
-                        if (data) {
-                            this.adapter.writeFile(namespace, target, data, (err) => {
-                                if (err) {
-                                    this.error('error writing file ' + target + JSON.stringify(err))
-                                    return;
-                                }
-                                this.info(`copied ${src} to ${target}.`)
-                                fs.rm(src, (err) => {
-                                    if (err) this.warn(`error removing ${src} : ${JSON.stringify(err)}`);
-                                });
-                            })
-                        }
-                    })
-                }
-                catch (error) {
-                    this.error('fs.readfile error : ', error);
-                }
+                await this.downloadIcon(url, target);
             }
         });
     }
@@ -1065,8 +1142,10 @@ class StatesController extends EventEmitter {
                     else if (this.debugActive) 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 if (this.debugActive) this.debug(message);
+                if (!has_published) {
+                    if (has_elevated_debug) this.emit('device_debug', { ID:debugId, data:{ error:'NOVAL', IO:true }, message:message});
+                    else if (this.debugActive) this.debug(message);
+                }
             }
             else {
                 const message = `ELEVATED IE05 - NOSTATE: No states matching the payload ${JSON.stringify(payload)} for device ${devId}`;
@@ -1079,6 +1158,27 @@ class StatesController extends EventEmitter {
         }
     }
 
+    postProcessConvertedFromZigbeeMessage(definition, payload, options, device) {
+    // Apply calibration/precision options
+        for (const [key, value] of Object.entries(payload)) {
+            const definitionExposes = Array.isArray(definition.exposes) ? definition.exposes : definition.exposes(device, {});
+            const expose = definitionExposes.find((e) => e.property === key);
+
+            if (!expose) return;
+
+            if (expose &&
+            expose.name in zigbeeHerdsmanConvertersUtils.calibrateAndPrecisionRoundOptionsDefaultPrecision &&
+            value !== '' &&
+            typeof value === 'number') {
+                try {
+                    payload[key] = zigbeeHerdsmanConvertersUtils.calibrateAndPrecisionRoundOptions(value, options, expose.name);
+                } catch (error) {
+                    this.warn(`Failed to apply calibration to '${expose.name}': ${error && error.message ? error.message: 'no reason given'}`);
+                }
+            }
+        }
+    }
+
     async processConverters(converters, devId, model, mappedModel, message, meta, debugId) {
         for (const converter of converters) {
             const publish = (payload, dID) => {
@@ -1100,6 +1200,10 @@ class StatesController extends EventEmitter {
                 }
             });
 
+            if (Object.keys(payload).length > 0 && Object.keys(options).length > 0) {
+                this.postProcessConvertedFromZigbeeMessage(mappedModel, payload, options, null);
+            }
+
             publish(payload, debugId);
         }
     }
@@ -1117,6 +1221,10 @@ class StatesController extends EventEmitter {
 
         const has_elevated_debug = this.checkDebugDevice(devId);
         const debugId = Date.now();
+        if (entity.device.interviewing) {
+            this.warn(`zigbee event for ${device.ieeeAddr} received during interview!`);
+            return;
+        }
 
         // raw message data for logging and msg_from_zigbee
         const msgForState = Object.assign({}, message);
@@ -1194,7 +1302,7 @@ class StatesController extends EventEmitter {
             return;
         }
 
-        let converters = mappedModel.fromZigbee.filter(c => c && c.cluster === cluster && (
+        let converters = [...mappedModel.fromZigbee,...mappedModel.toZigbee].filter(c => c && c.cluster === cluster && (
             Array.isArray(c.type) ? c.type.includes(type) : c.type === type));
 
 
@@ -1204,7 +1312,7 @@ class StatesController extends EventEmitter {
         }
 
         if (!converters.length) {
-            if (type !== 'readResponse') {
+            if (type !== 'readResponse' && type !== 'commandQueryNextImageRequest') {
                 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 if (this.debugActive) this.debug(message);