iobroker.zigbee 2.0.1 → 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 {
@@ -31,6 +32,8 @@ class StatesController extends EventEmitter {
         this.timeoutHandleUpload = null;
         this.ImagesToDownload = [];
         this.stashedErrors = {};
+        this.stashedUnknownModels = [];
+        this.debugMessages = { nodevice:{ in:[], out: []} };
     }
 
     info(message, data) {
@@ -71,8 +74,35 @@ class StatesController extends EventEmitter {
     }
 
     getStashedErrors() {
-        if (!this.stashedErrors) return [];
-        return Object.values(this.stashedErrors);
+        const rv = [];
+        if (Object.keys(this.stashedErrors).length > 0)
+        {
+            rv.push('<p><b>Stashed Messages</b></p>')
+            rv.push(Object.values(this.stashedErrors).join('<br>'));
+        }
+        if (this.stashedUnknownModels.length > 0) {
+            rv.push('<p><b>Devices whithout Model definition</b></p>')
+            rv.push()
+        }
+        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)) {
+            //this.warn('legacy for ' + model);
+            await this.addLegacyDevice(model);
+        }
+        else {
+            const pre = statesMapping.devices.length;
+            await statesMapping.addExposeToDevices(device, this, model);
+            const post = statesMapping.devices.length;
+            //this.warn('expose for ' + model + ' '+ pre + '->'+post);
+        }
     }
 
     async getDebugDevices(callback) {
@@ -128,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;
@@ -142,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];
@@ -175,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));
                 }
             });
         }
@@ -228,7 +261,13 @@ class StatesController extends EventEmitter {
             } else {
                 stateModel = statesMapping.findModel(model);
                 if (!stateModel) {
-                    this.info(`Device ${deviceId} "${model}" not present in statesMapping - relying on exposes for device definition.`);
+                    // try to get the model from the exposes
+                    if (!this.stashedErrors.hasOwnProperty(`${deviceId}.nomodel`))
+                    {
+                        this.warn(`Device ${deviceId} "${model}" not found.`);
+                        this.stashedErrors[`${deviceId}.nomodel`] = `Device ${deviceId} "${model}" not found.`;
+                    }
+
                     states = statesMapping.commonStates;
                 } else {
                     states = stateModel.states;
@@ -275,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}];
@@ -314,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'));
                 }
 
             });
@@ -329,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) {
@@ -383,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);
@@ -615,6 +664,11 @@ class StatesController extends EventEmitter {
         //this.warn('devices are' + modelarr2.join(','));
     }
 
+    async addLegacyDevice(model) {
+        statesMapping.setLegacyDevices([model]);
+        statesMapping.getByModel();
+    }
+
     async getDefaultGroupIcon(id) {
         const regexResult = id.match(new RegExp(/group_(\d+)/));
         if (!regexResult) return '';
@@ -720,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 {
@@ -738,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}`)
                                 });
                             })
                         }
@@ -807,7 +860,12 @@ class StatesController extends EventEmitter {
     async getExposes() {
         await this.localConfig.init();
         await this.applyLegacyDevices();
-        statesMapping.fillStatesWithExposes();
+        try {
+            statesMapping.fillStatesWithExposes(this);
+        }
+        catch (error) {
+            this.error(`Error applying exposes: ${error && error.message ? error.message : 'no error message'} ${error && error.stack ? error.stack : ''}`);
+        }
     }
 
     async elevatedMessage(device, message, isError) {
@@ -821,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, !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/utils.js

@@ -106,11 +106,13 @@ function flatten(arr) {
         flat.concat(Array.isArray(toFlatten) ? flatten(toFlatten) : toFlatten), []);
 }
 
-const forceEndDevice = flatten(
+const forceEndDevice = ['QBKG03LM', 'QBKG04LM', 'ZNMS13LM', 'ZNMS12LM'];
+
+/*flatten(
     ['QBKG03LM', 'QBKG04LM', 'ZNMS13LM', 'ZNMS12LM']
         .map(model => zigbeeHerdsmanConverters.findByModel(model))
         .map(mappedModel => mappedModel.zigbeeModel));
-
+*/
 // Xiaomi uses 4151 and 4447 (lumi.plug) as manufacturer ID.
 const xiaomiManufacturerID = [4151, 4447];
 const ikeaTradfriManufacturerID = [4476];

package/lib/zbDeviceAvailability.js

@@ -6,13 +6,7 @@ const utils = require('./utils');
 
 // Some EndDevices should be pinged
 // e.g. E11-G13 https://github.com/Koenkk/zigbee2mqtt/issues/775#issuecomment-453683846
-const forcedPingable = [
-    zigbeeHerdsmanConverters.findByModel('E11-G13'),
-    zigbeeHerdsmanConverters.findByModel('53170161'),
-    zigbeeHerdsmanConverters.findByModel('V3-BTZB'),
-    zigbeeHerdsmanConverters.findByModel('SPZB0001'),
-    zigbeeHerdsmanConverters.findByModel('014G2461')
-];
+const forcedPingable = ['E11-G13','53170161','V3-BTZB','SPZB0001','014G2461'];
 
 // asgothian: 29.12.2020: Removed color and color_temp from readable
 // state candidates as most states do not provide a getter to ikea_transform
@@ -184,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`);
@@ -192,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`);
                 }
             }
         }