iobroker.zigbee 1.6.0 → 1.6.12

package/lib/statescontroller.js

@@ -4,6 +4,7 @@ const EventEmitter = require('events').EventEmitter;
 const statesMapping = require('./devices');
 const getAdId = require('./utils').getAdId;
 const getZbId = require('./utils').getZbId;
+var knownUndefinedDevices = {};
 
 
 class StatesController extends EventEmitter {
@@ -55,8 +56,20 @@ class StatesController extends EventEmitter {
                 });
             }
         });
-
+        this.adapter.setObject('info.undefinedDevices', {
+            'type': 'state',
+            'common': {
+                'name': 'Recorded undefined devices',
+                'role': '',
+                'type': 'string',
+                'read': true,
+                'write': false,
+            },
+            'native': {},
+        });
+        this.adapter.setStateAsync(`info.undefinedDevices`, JSON.stringify(knownUndefinedDevices), true);
     }
+
     onStateChange(id, state){
         if (!this.adapter.zbController || !this.adapter.zbController.connected()) return;
         if (this.debugDevices === undefined) this.getDebugDevices();
@@ -116,20 +129,25 @@ class StatesController extends EventEmitter {
             return;
         }
         let cnt = 0;
-        const len = states.length;
-        states.forEach(statedesc => {
-            const id = this.adapter.namespace + '.' + devId + '.' + statedesc.id;
-            this.adapter.getState(id, (err, state) => {
-                cnt = cnt + 1;
-                if (!err && state) {
-                    result[statedesc.id] = state.val;
-                }
-                if (cnt === len) {
-                    callback(result);
-                }
+        try {
+            const len = states.length;
+            states.forEach(statedesc => {
+                const id = this.adapter.namespace + '.' + devId + '.' + statedesc.id;
+                this.adapter.getState(id, (err, state) => {
+                    cnt = cnt + 1;
+                    if (!err && state) {
+                        result[statedesc.id] = state.val;
+                    }
+                    if (cnt === len) {
+                        callback(result);
+                    }
+                });
             });
-        });
-        if (!len) callback(result);
+            if (!len) callback(result);
+         } catch (error) {
+            this.sendError(error);
+            this.error(`Error collectOptions for ${devId}. Error: ${error.stack}`);
+         }
     }
 
     async getDevStates(deviceId, model) {
@@ -141,7 +159,15 @@ class StatesController extends EventEmitter {
             } else {
                 stateModel = statesMapping.findModel(model);
                 if (!stateModel) {
-                    this.error('Device ' + deviceId + ' "' + model + '" not described in statesMapping.');
+                    if (knownUndefinedDevices[deviceId])
+                    {
+                        knownUndefinedDevices[deviceId]++;
+                    }
+                    else {
+                        knownUndefinedDevices[deviceId] = 1;
+                        this.error('Device ' + deviceId + ' "' + model + '" not described in statesMapping.');
+                    }
+                    this.adapter.setStateAsync(`info.undefinedDevices`, JSON.stringify(knownUndefinedDevices), true);
                     states = statesMapping.commonStates;
                 } else {
                     states = stateModel.states;
@@ -343,13 +369,10 @@ class StatesController extends EventEmitter {
                     // only change object when any common property has changed
                     if (hasChanges) {
                         this.adapter.extendObject(id, {type: 'state', common: new_common, native: {} }, () => {
-                            value !== undefined && this.adapter.setState(id, value, true);
+                            value !== undefined && this.setState_typed(id, value, true, (stobj) ? stobj.common.type : new_common.type);
                         });
                     } else if (value !== undefined) {
-                        if (typeof(value) !== 'object') {
-                            this.adapter.setState(id, value, true);
-                        } else this.warn('set state with object for id :' + JSON.stringify(id) + ' '+ JSON.stringify(value));
-
+                        this.setState_typed(id, value, true, stobj.common.type);
                     }
 
                 });
@@ -359,6 +382,44 @@ class StatesController extends EventEmitter {
         });
     }
 
+    setState_typed(id, value, ack, type, callback)
+    {
+        // never set a null or undefined value
+        if (value === null || value === undefined) return;
+        if (!type) {
+            this.debug("SetState_typed called without type");
+            // identify datatype, recursively call this function with set datatype
+            this.adapter.getObject(id, (err, obj) => {
+                if (obj && obj.common)
+                   this.setState_typed(id, value, ack, obj.common.type, callback);
+                else {
+                    this.setState_typed(id, value, ack, 'noobj', callback);
+                }
+            });
+            return;
+        }
+        if (typeof value != type) {
+            this.debug("SetState_typed : converting " + JSON.stringify(value) + " for " + id + " from " + typeof value + " to " + type);
+            switch (type) {
+                case 'number':
+                    value = parseFloat(value);
+                    if (isNaN (value)) value = 0;
+                    break;
+                case 'string':
+                case 'text': value = JSON.stringify(value); break;
+                case 'boolean':
+                    if (typeof value == 'number') {
+                        value = (value != 0);
+                        break;
+                    }
+                    const sval = JSON.stringify(value).toLowerCase().trim();
+                    value = (sval == 'true' || sval == 'yes' || sval == 'on');
+                    break;
+            }
+        }
+        this.adapter.setState(id, value, ack, callback);
+    }
+
     updateDev(dev_id, dev_name, model, callback) {
         const id = '' + dev_id;
         const modelDesc = statesMapping.findModel(model);
@@ -432,6 +493,7 @@ class StatesController extends EventEmitter {
         for (const addressPart of this.debugDevices) {
             if (typeof(devId) == 'string' && devId.indexOf(addressPart) > -1)
             {
+                if (payload.hasOwnProperty('msg_from_zigbee')) break;
                 this.warn(`ELEVATED publishToState: message received '${JSON.stringify(payload)}' from device ${devId} type '${model}'`);
                 has_debug = true;
                 break;
@@ -454,10 +516,10 @@ class StatesController extends EventEmitter {
                     value = payload[statedesc.prop || statedesc.id];
                 }
                 // checking value
-                if (value === undefined) continue;
+                if (value === undefined || value === null) continue;
                 let stateID = statedesc.id;
 
-                if (has_debug) {
+                if (has_debug && statedesc.id != 'msg_from_zigbee') {
                     this.warn(`ELEVATED publishToState: value generated '${JSON.stringify(value)}' from device ${devId} for '${statedesc.name}'`);
                 }
 

package/lib/utils.js

@@ -114,6 +114,24 @@ const forceEndDevice = flatten(
 const xiaomiManufacturerID = [4151, 4447];
 const ikeaTradfriManufacturerID = [4476];
 
+function sanitizeImageParameter(parameter) {
+    const replaceByDash = [/\?/g, /&/g, /[^a-z\d\-_./:]/gi, /[/]/gi];
+    let sanitized = parameter;
+    replaceByDash.forEach((r) => sanitized = sanitized.replace(r, '-'));
+    return sanitized;
+}
+
+function getDeviceIcon(definition) {
+    let icon = definition.icon;
+    if (icon) {
+        icon = icon.replace('${model}', sanitizeImageParameter(definition.model));
+    }
+    if (!icon) {
+        icon = `https://www.zigbee2mqtt.io/images/devices/${sanitizeImageParameter(definition.model)}.jpg`;
+    }
+    return icon;
+}
+
 exports.secondsToMilliseconds   = (seconds) => seconds * 1000;
 exports.bulbLevelToAdapterLevel = bulbLevelToAdapterLevel;
 exports.adapterLevelToBulbLevel = adapterLevelToBulbLevel;
@@ -130,3 +148,4 @@ exports.isXiaomiDevice          = (device) => {
             (!device.manufacturerName || !device.manufacturerName.startsWith('Trust'));
 };
 exports.isIkeaTradfriDevice     = (device) => ikeaTradfriManufacturerID.includes(device.manufacturerID);
+exports.getDeviceIcon            = getDeviceIcon;

package/lib/zbBaseExtension.js

@@ -5,6 +5,7 @@
 class BaseExtension {
     constructor(zigbee, options) {
         this.zigbee = zigbee;
+        this.name = 'BaseExtension';
     }
 
     info(message, data) {
@@ -12,15 +13,15 @@ class BaseExtension {
     }
 
     error(message, data) {
-        this.zigbee.error(message, data);
+        this.zigbee.error(this.name + ':' + message, data);
     }
 
     warn(message, data) {
-        this.zigbee.warn(message, data);
+        this.zigbee.warn(this.name + ':' + message, data);
     }
 
     debug(message, data) {
-        this.zigbee.debug(message, data);
+        this.zigbee.debug(this.name + ':' + message, data);
     }
 
     sendError(error, message) {

package/lib/zbDelayedAction.js

@@ -8,6 +8,7 @@ class DelayedAction extends BaseExtension {
 
         this.actions = {};
         this.zigbee.delayAction = this.delayAction.bind(this);
+        this.name = "DelayedAction";
     }
 
     setOptions(options) {

package/lib/zbDeviceAvailability.js

@@ -50,6 +50,7 @@ class DeviceAvailability extends BaseExtension {
         this.startDevicePingQueue = []; // simple fifo array for starting device pings
         this.startDevicePingTimeout = null; // handle for the timeout which empties the queue
         this.startDevicePingDelay = 200; // 200 ms delay between starting the ping timeout
+        this.name = "DeviceAvailability";
     }
 
     setOptions(options) {
@@ -265,7 +266,7 @@ class DeviceAvailability extends BaseExtension {
         //    }
         }
     }
-    
+
     onZigbeeEvent(data) {
         const device = data.device;
         if (!device) {

package/lib/zbDeviceConfigure.js

@@ -18,6 +18,7 @@ class DeviceConfigure extends BaseExtension {
 
         this.configuring = new Set();
         this.attempts = {};
+        this.name = "DeviceConfigure";
     }
 
     setOptions(options) {
@@ -119,13 +120,8 @@ class DeviceConfigure extends BaseExtension {
             if (!this.attempts.hasOwnProperty(device.ieeeAddr)) {
                 this.attempts[device.ieeeAddr] = 0;
             }
-
-            this.info(`Configuring ${device.ieeeAddr} ${device.modelID}`);
             try {
-                await mappedDevice.configure(device, this.coordinatorEndpoint);
-                this.info(`DeviceConfigure successful ${device.ieeeAddr} ${device.modelID}`);
-                device.meta.configured = zigbeeHerdsmanConverters.getConfigureKey(mappedDevice);
-                device.save();
+                await this.doConfigure(device, mappedDevice);
             } catch (error) {
                 this.sendError(error);
                 this.warn(
@@ -134,7 +130,6 @@ class DeviceConfigure extends BaseExtension {
                 );
                 this.attempts[device.ieeeAddr]++;
             }
-
             this.configuring.delete(device.ieeeAddr);
         } catch (error) {
             this.sendError(error);
@@ -143,6 +138,15 @@ class DeviceConfigure extends BaseExtension {
             );
         }
     }
+
+    async doConfigure(device, mappedDevice) {
+        this.info(`Configuring ${device.ieeeAddr} ${device.modelID}`);
+        const coordinatorEndpoint = await this.zigbee.getDevicesByType('Coordinator')[0].endpoints[0];
+        await mappedDevice.configure(device, coordinatorEndpoint);
+        device.meta.configured = zigbeeHerdsmanConverters.getConfigureKey(mappedDevice);
+        device.save();
+        this.info(`DeviceConfigure successful ${device.ieeeAddr} ${device.modelID}`);
+    }
 }
 
 module.exports = DeviceConfigure;

package/lib/zbDeviceEvent.js

@@ -4,6 +4,12 @@ const BaseExtension = require('./zbBaseExtension');
 const zigbeeHerdsmanConverters = require('zigbee-herdsman-converters');
 
 class DeviceEvent extends BaseExtension {
+    constructor(zigbee, options) {
+        super(zigbee, options);
+        this.name = "DeviceEvent";
+    }
+
+
     async onZigbeeStarted() {
         for (const device of await this.zigbee.getClients()) {
             this.callOnEvent(device, 'start', {});

package/lib/zigbeecontroller.js

@@ -105,11 +105,11 @@ class ZigbeeController extends EventEmitter {
             this.debug('zigbee-herdsman started');
             this.herdsman_started = true;
             this.info(`Coordinator firmware version: ${JSON.stringify(await this.herdsman.getCoordinatorVersion())}`);
-                        
+
             // debug info from herdsman getNetworkParameters
             const debNetworkParam = JSON.parse(JSON.stringify(await this.herdsman.getNetworkParameters()));
             const extendedPanIDDebug = (typeof debNetworkParam.extendedPanID == 'string') ? debNetworkParam.extendedPanID.replace('0x','') : debNetworkParam.extendedPanID;
-            
+
             let extPanIDDebug = '';
             for (let i = extendedPanIDDebug.length - 1; i >= 0; i--) {
                 extPanIDDebug += extendedPanIDDebug[i-1];
@@ -117,8 +117,8 @@ class ZigbeeController extends EventEmitter {
                 i--;
             }
 
-            this.debug(`Zigbee network parameters: panID=${debNetworkParam.panID} channel=${debNetworkParam.channel} extendedPanID=${extPanIDDebug}`);                          
-                                   
+            this.debug(`Zigbee network parameters: panID=${debNetworkParam.panID} channel=${debNetworkParam.channel} extendedPanID=${extPanIDDebug}`);
+
         } catch (e) {
             this.sendError(e);
             this.error('Starting zigbee-herdsman problem : ' + JSON.stringify(e.message));
@@ -148,6 +148,9 @@ class ZigbeeController extends EventEmitter {
                 case '19':
                     powerText = 'high';
                     break;
+                case '20':
+                    powerText = 'high+';
+                    break;                    
                 default:
                     powerText = 'normal';
             }
@@ -217,13 +220,14 @@ class ZigbeeController extends EventEmitter {
     }
 
     callExtensionMethod(method, parameters) {
+        const result = [];
         for (const extension of this.extensions) {
             if (extension[method]) {
                 try {
                     if (parameters !== undefined) {
-                        extension[method](...parameters);
+                        result.push(extension[method](...parameters));
                     } else {
-                        extension[method]();
+                        result.push(extension[method]());
                     }
                 } catch (error) {
                     this.sendError(error);
@@ -231,6 +235,7 @@ class ZigbeeController extends EventEmitter {
                 }
             }
         }
+        return Promise.all(result);
     }
 
     async getClients(all) {
@@ -248,9 +253,11 @@ class ZigbeeController extends EventEmitter {
 
     async getGroups() {
         try {
-            return this.herdsman.getGroups();
+            const rv = await this.herdsman.getGroups();
+            return rv;
         } catch (error) {
             this.sendError(error);
+            this.error(JSON.stringify(error));
             return undefined;
         }
     }
@@ -280,11 +287,11 @@ class ZigbeeController extends EventEmitter {
             const group = await this.getGroupByID(id);
             if (group) {
                 const groupmembers = group.members;
-
                 for (const member of groupmembers) {
+                    const epid = (member.ID ? member.ID:-1);
                     const nwk = member.deviceNetworkAddress;
                     const device = this.getDeviceByNetworkAddress(nwk);
-                    if (device && device.ieeeAddr) members.push( { device:device.ieeeAddr, model:device.modelID } );
+                    if (device && device.ieeeAddr) members.push( { ieee:device.ieeeAddr, model:device.modelID, epid:epid, ep:member } );
                 }
             }
             else {
@@ -525,6 +532,13 @@ class ZigbeeController extends EventEmitter {
         const entity = await this.resolveEntity(message.device || message.ieeeAddr);
         const friendlyName = entity.name;
         this.warn(`Device '${friendlyName}' announced itself`);
+
+        if (entity && entity.mapped) {
+            this.callExtensionMethod(
+                'onZigbeeEvent',
+                [ {'device': message.device, 'type': 'deviceAnnounce'}, (entity ? entity.mapped : null)]);
+        }
+
         this.emit('pairing', `Device '${friendlyName}' announced itself`);
         if (!this.herdsman.getPermitJoin()) this.callExtensionMethod('registerDevicePing', [message.device, entity]);
         // if has modelID so can create device
@@ -534,6 +548,7 @@ class ZigbeeController extends EventEmitter {
         }
     }
 
+
     async handleDeviceJoined(message) {
         this.debug('handleDeviceJoined', message);
         //const entity = await this.resolveEntity(message.device || message.ieeeAddr);
@@ -686,7 +701,7 @@ class ZigbeeController extends EventEmitter {
         }
     }
 
-    async publish(deviceID, cid, cmd, zclData, cfg, ep, type, callback) {
+    async publish(deviceID, cid, cmd, zclData, cfg, ep, type, callback, zclSeqNum) {
         const entity = await this.resolveEntity(deviceID, ep);
         const device = entity.device;
         const endpoint = entity.endpoint;
@@ -727,20 +742,57 @@ class ZigbeeController extends EventEmitter {
                 result = await endpoint[cmd](cid, zclData, cfg);
             }
             if (callback) callback(undefined, result);
-        } else {
+        }
+        else if(type === 'functionalResp'){
+              cfg.disableDefaultResponse = false;
+              const result = await endpoint.commandResponse(cid, cmd, zclData, cfg, zclSeqNum);
+              if (callback) callback(undefined, result);
+        }
+        else {
             cfg.disableDefaultResponse = false;
             const result = await endpoint.command(cid, cmd, zclData, cfg);
             if (callback) callback(undefined, result);
         }
     }
 
-    async addDevToGroup(devId, groupId) {
+    async addDevToGroup(devId, groupId, epid) {
         try {
             const entity = await this.resolveEntity(devId);
             const group = await this.resolveEntity(groupId);
-            this.debug(`entity: ${safeJsonStringify(entity)}`);
-            this.debug(`group: ${safeJsonStringify(group)}`);
-            await entity.endpoint.addToGroup(group.mapped);
+            this.debug(`addDevFromGroup - entity: ${safeJsonStringify(entity)}`);
+            this.debug(`addDevFromGroup - group: ${safeJsonStringify(group)}`);
+            if (epid != undefined) {
+              for (const ep of entity.endpoints) {
+                if (ep.ID == epid && (ep.inputClusters.includes(4) || ep.outputClusters.includes(4)))
+                {
+                  this.debug(`adding endpoint ${ep.ID} (${epid}) to group ${groupId}`)
+                  await(ep.addToGroup(group.mapped));
+                }
+              }
+
+            }
+            else
+            {
+                if (entity.endpoint.inputClusters.includes(4))
+                {
+                    this.debug(`adding endpoint ${entity.endpoint.ID} to group`)
+                    await entity.endpoint.addToGroup(group.mapped);
+                }
+                else {
+                    let added = false;
+                    for (const ep of entity.endpoints)
+                    {
+                        if (ep.inputClusters.includes(4))
+                        {
+                            this.debug(`adding endpoint ${ep.ID} to group`)
+                            await ep.addToGroup(group.mapped);
+                            added = true;
+                            break;
+                        }
+                    }
+                    if (!added) throw ('cluster genGroups not supported');
+                }
+            }
         } catch (error) {
             this.sendError(error);
             this.error(`Exception when trying to Add ${devId}  to group ${groupId}`, error);
@@ -749,11 +801,38 @@ class ZigbeeController extends EventEmitter {
         return {};
     }
 
+    async removeDevFromGroup(devId, groupId, epid) {
+      try {
+          const entity = await this.resolveEntity(devId);
+          const group = await this.resolveEntity(groupId);
+          this.debug(`removeDevFromGroup - entity: ${safeJsonStringify(entity)}`);
+          this.debug(`removeDevFromGroup - group: ${safeJsonStringify(group)}`);
+          if (epid != undefined) {
+            for (const ep of entity.endpoints) {
+              if (ep.ID == epid && (ep.inputClusters.includes(4) || ep.outputClusters.includes(4)))
+              {
+                this.debug(`removing endpoint ${ep.ID} (${epid}) group ${groupId}`)
+                await(ep.removeFromGroup(group.mapped))
+              }
+            }
+          } else await entity.endpoint.removeFromGroup(group.mapped);
+      } catch (error) {
+          this.sendError(error);
+          this.error(`Exception when trying remove ${devId} (ep ${epid?epid:entity.endpoint.ID}) from group ${devId}`, error);
+          return { error: `Failed to remove dev ${devId} (ep ${epid?epid:entity.endpoint.ID}) from group ${devId}`};
+      }
+      return {};
+    }
+
     async removeDevFromAllGroups(devId) {
         try {
             const entity = await this.resolveEntity(devId);
             this.debug(`entity: ${safeJsonStringify(entity)}`);
-            await entity.endpoint.removeFromAllGroups();
+            for (const ep of entity.endpoints) {
+              if (ep.inputClusters.includes(4) || ep.outputClusters.includes(4))
+                await ep.removefromAllGroups();
+            }
+            //await entity.endpoint.removeFromAllGroups();
         } catch (error) {
             this.sendError(error);
             this.error(`Exception when trying remove ${devId} from all groups`, error);

package/main.js

@@ -30,6 +30,7 @@ const StatesController = require('./lib/statescontroller');
 const ExcludePlugin = require('./lib/exclude');
 const zigbeeHerdsmanConverters = require('zigbee-herdsman-converters');
 const vm = require('vm');
+const util = require('util');
 
 const createByteArray = function (hexString) {
     const bytes = [];
@@ -158,14 +159,15 @@ class Zigbee extends utils.Adapter {
                 this.log.error(`${message}: Code ${error.code} (${ecode.message})`);
                 this.sendError(error, `${message}: Code ${error.code} (${ecode.message})`);
                 break;
-            default: 
+            default:
                 this.log.error(`${message}: Code ${error.code} (malformed error)`);
                 this.sendError(error, `${message}: Code ${error.code} (malformed error)`);
         }
     }
 
-    debugLog (data) {
-        this.log.debug(data.slice(data.indexOf('zigbee-herdsman')));
+    debugLog (data, ...args) {
+        const message = (args) ? util.format(data, ...args) : data;
+        this.log.debug(message.slice(message.indexOf('zigbee-herdsman')));
     }
 
     async onReady() {
@@ -304,6 +306,7 @@ class Zigbee extends utils.Adapter {
 
     async onZigbeeAdapterReady() {
         if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
+        this.log.warn("config :" + JSON.stringify(this.config));
         this.log.info(`Zigbee started`);
         // https://github.com/ioBroker/ioBroker.zigbee/issues/668
         const extPanIdFix = this.config.extPanIdFix ? this.config.extPanIdFix : false;
@@ -315,25 +318,31 @@ class Zigbee extends utils.Adapter {
             const adapterType = this.config.adapterType || 'zstack';
             if (adapterType === 'zstack') {
                 if (configExtPanId != networkExtPanId) {
-                    // try to read from nvram
-                    const result = await this.zbController.herdsman.adapter.znp.request(
-                        1, // Subsystem.SYS
-                        'osalNvRead',
-                        {
-                            id: 45, // EXTENDED_PAN_ID
-                            len: 0x08,
-                            offset: 0x00,
-                        },
-                        null, [
-                            0, // ZnpCommandStatus.SUCCESS
-                            2, // ZnpCommandStatus.INVALID_PARAM
-                        ]
-                    );
-                    const nwExtPanId = '0x'+result.payload.value.reverse().toString('hex');
-                    this.log.debug(`Config value ${configExtPanId} : nw value ${nwExtPanId}`);
-                    if (configExtPanId != nwExtPanId) {
-                        networkExtPanId = nwExtPanId;
-                        needChange = true;
+                    try {
+                        // try to read from nvram
+                        const result = await this.zbController.herdsman.adapter.znp.request(
+                            1, // Subsystem.SYS
+                            'osalNvRead',
+                            {
+                                id: 45, // EXTENDED_PAN_ID
+                                len: 0x08,
+                                offset: 0x00,
+                            },
+                            null, [
+                                0, // ZnpCommandStatus.SUCCESS
+                                2, // ZnpCommandStatus.INVALID_PARAM
+                            ]
+                        );
+                        const nwExtPanId = '0x'+result.payload.value.reverse().toString('hex');
+                        this.log.debug(`Config value ${configExtPanId} : nw value ${nwExtPanId}`);
+                        if (configExtPanId != nwExtPanId) {
+                            networkExtPanId = nwExtPanId;
+                            needChange = true;
+                        }
+                    } catch (e) {
+                        this.log.error(`Unable to apply ExtPanID changes: ${e}`);
+                        this.sendError(e, `Unable to apply ExtPanID changes`);
+                        needChange = false;
                     }
                 } else {
                     needChange = true;
@@ -423,7 +432,7 @@ class Zigbee extends utils.Adapter {
         delete msgForState['endpoint'];
         msgForState['endpoint_id'] = message.endpoint.ID;
         this.publishToState(devId, model, {msg_from_zigbee: safeJsonStringify(msgForState)});
-        
+
         if (!entity.mapped) {
             return;
         }
@@ -489,6 +498,10 @@ class Zigbee extends utils.Adapter {
         const entity = await this.zbController.resolveEntity(deviceId);
         this.log.debug(`entity: ${safeJsonStringify(entity)}`);
         const mappedModel = entity.mapped;
+        if (!mappedModel) {
+            this.log.debug(`No mapped model for ${model}`);
+            return;
+        }
         this.log.debug('Mapped Model: ' +  JSON.stringify(mappedModel));
 
         stateList.forEach(async(changedState) => {
@@ -579,13 +592,15 @@ class Zigbee extends utils.Adapter {
             try {
                 const result = await converter.convertSet(target, key, preparedValue, meta);
                 this.log.debug(`convert result ${safeJsonStringify(result)}`);
-                if (stateModel && !isGroup)
-                    this.acknowledgeState(deviceId, model, stateDesc, value);
-                // process sync state list
-                this.processSyncStatesList(deviceId, model, syncStateList);
-                if (isGroup) {
-                    await this.callPluginMethod('queryGroupMemberState', [deviceId, stateDesc]);
-                    this.acknowledgeState(deviceId, model, stateDesc, value);
+                if (result !== undefined) {
+                    if (stateModel && !isGroup)
+                        this.acknowledgeState(deviceId, model, stateDesc, value);
+                    // process sync state list
+                    this.processSyncStatesList(deviceId, model, syncStateList);
+                    if (isGroup) {
+                        await this.callPluginMethod('queryGroupMemberState', [deviceId, stateDesc]);
+                        this.acknowledgeState(deviceId, model, stateDesc, value);
+                    }
                 }
             } catch(error) {
                 this.filterError(`Error ${error.code} on send command to ${deviceId}.`+
@@ -757,8 +772,8 @@ class Zigbee extends utils.Adapter {
     getZigbeeOptions() {
         // file path for db
         let dbDir = path.join(utils.getAbsoluteInstanceDataDir(this), '');
-        dbDir = dbDir.replace('.', '_');        
-        
+        dbDir = dbDir.replace('.', '_');
+
         if (this.systemConfig && !fs.existsSync(dbDir)) {
             try {
                 fs.mkdirSync(dbDir);