iobroker.zigbee 2.0.1 → 2.0.3

package/main.js

@@ -36,6 +36,7 @@ const zigbeeHerdsmanPackage = require('zigbee-herdsman/package.json')
 const vm = require('vm');
 const util = require('util');
 const dmZigbee  = require('./lib/devicemgmt.js');
+const DeviceDebug = require('./lib/DeviceDebug');
 
 const createByteArray = function (hexString) {
     const bytes = [];
@@ -79,6 +80,9 @@ class Zigbee extends utils.Adapter {
         this.stController.on('changed', this.publishFromState.bind(this));
 
         this.deviceManagement = new dmZigbee(this);
+        this.deviceDebug =  new DeviceDebug(this),
+        this.deviceDebug.on('log', this.onLog.bind(this));
+
 
         this.plugins = [
             new SerialListPlugin(this),
@@ -115,6 +119,19 @@ class Zigbee extends utils.Adapter {
         }
     }
 
+    warn(message) {
+        this.log.warn(message);
+    }
+    debug(message) {
+        this.log.debug(message);
+    }
+    error(message) {
+        this.log.error(message);
+    }
+    info(message) {
+        this.log.info(message);
+    }
+
     sendError(error, message) {
         try {
             if (this.supportsFeature && this.supportsFeature('PLUGINS')) {
@@ -210,12 +227,15 @@ class Zigbee extends utils.Adapter {
         this.zbController.on('new', this.newDevice.bind(this));
         this.zbController.on('leave', this.leaveDevice.bind(this));
         this.zbController.on('pairing', this.onPairing.bind(this));
-        this.zbController.on('event', this.onZigbeeEvent.bind(this));
-        this.zbController.on('msg', this.onZigbeeEvent.bind(this));
+        this.zbController.on('event', this.stController.onZigbeeEvent.bind(this.stController));
+        this.zbController.on('msg', this.stController.onZigbeeEvent.bind(this.stController));
         this.zbController.on('publish', this.publishToState.bind(this));
         this.zbController.configure(zigbeeOptions);
         await this.callPluginMethod('configure', [zigbeeOptions]);
 
+        // elevated debug handling
+        this.deviceDebug.start(this.stController, this.zbController);
+
         this.reconnectCounter = 1;
         this.doConnect();
     }
@@ -304,6 +324,9 @@ class Zigbee extends utils.Adapter {
                 //fs.writeFileSync(mN+'.tmp3', modifiedCode)
                 converterLoaded &= this.SandboxRequire(sandbox,[...modifiedCode.matchAll(/import\s+\{(.+)\}\s+from\s+(\S+);/gm)]);
                 modifiedCode = modifiedCode.replace(/import\s+\{.+\}\s+from\s+\S+;/gm, '');
+
+                converterLoaded &= this.SandboxRequire(sandbox,[...modifiedCode.matchAll(/import\s+(.+)\s+from\s+(\S+);/gm)]);
+                modifiedCode = modifiedCode.replace(/import\s+.+\s+from\s+\S+;/gm, '');
                 //fs.writeFileSync(mN+'.tmp4', modifiedCode)
                 converterLoaded &= this.SandboxRequire(sandbox,[...modifiedCode.matchAll(/const\s+\{(.+)\}\s+=\s+require\((.+)\)/gm)]);
                 modifiedCode = modifiedCode.replace(/const\s+\{.+\}\s+=\s+require\(.+\)/gm, '');
@@ -312,7 +335,12 @@ class Zigbee extends utils.Adapter {
                 modifiedCode = modifiedCode.replace(/const\s+\S+\s+=\s+require\(.+\)/gm, '');
                 //fs.writeFileSync(mN+'.tmp6', modifiedCode)
 
-                //fs.writeFileSync(mN+'.tmp', modifiedCode)
+                for(const component of modifiedCode.matchAll(/const (.+):(.+)=/gm)) {
+                    modifiedCode = modifiedCode.replace(component[0], `const ${component[1]} = `);
+                }
+                modifiedCode = modifiedCode.replace(/export .+;/gm, '');
+
+                fs.writeFileSync(mN+'.tmp', modifiedCode)
 
                 if (converterLoaded) {
                     try {
@@ -345,10 +373,27 @@ class Zigbee extends utils.Adapter {
             const toAdd = {...definition};
             delete toAdd['homeassistant'];
             try {
-                zigbeeHerdsmanConverters.addDefinition(toAdd);
+                if (zigbeeHerdsmanConverters.hasOwnProperty('addExternalDefinition')) {
+                    zigbeeHerdsmanConverters.addExternalDefinition(toAdd);
+                    this.log.info('added external converter using addExternalDefinition')
+                }
+                else if (zigbeeHerdsmanConverters.hasOwnProperty('addDefinition')) {
+                    zigbeeHerdsmanConverters.addDefinition(toAdd);
+                    this.log.info('added external converter using addDefinition')
+                }
+
+                /*
+                for (const zigbeeModel of toAdd.zigbeeModel)
+                {
+                    try {
+                        zigbeeHerdsmanConverters.addToExternalDefinitionsLookup(zigbeeModel, toAdd.toAdd);
+                    } catch (e) {
+                        this.log.error(`unable to apply external converter ${JSON.stringify(toAdd)} for device ${zigbeeModel}: ${e && e.message ? e.message : 'no error message available'}`);
+                    }
+                }
+                    */
             } catch (e) {
-                this.log.error(`unable to apply external converter ${JSON.stringify(toAdd)}`);
-                this.log.error(`${e}`);
+                this.log.error(`unable to apply external converter for ${JSON.stringify(toAdd.model)}: ${e && e.message ? e.message : 'no error message available'}`);
             }
         }
     }
@@ -359,15 +404,15 @@ class Zigbee extends utils.Adapter {
             const DebugIdentify = require('./debugidentify');
             debugversion = DebugIdentify.ReportIdentifier();
         } catch {
-            debugversion = ' npm ...';
+            debugversion = 'npm ...';
         }
 
         // installed version
         let gitVers = '';
         try {
-            this.log.info(`Starting Zigbee ${debugversion}`);
+            this.log.info(`Starting Adapter ${debugversion}`);
 
-            await this.getForeignObject(`system.adapter.${this.namespace}`, (err, obj) => {
+            this.getForeignObject(`system.adapter.${this.namespace}`,async (err, obj) => {
                 if (!err && obj && obj.common.installedFrom && obj.common.installedFrom.includes('://')) {
                     const instFrom = obj.common.installedFrom;
                     gitVers = gitVers + instFrom.replace('tarball', 'commit');
@@ -375,9 +420,9 @@ class Zigbee extends utils.Adapter {
                     gitVers = obj.common.installedFrom;
                 }
                 this.log.info(`Installed Version: ${gitVers} (Converters ${zigbeeHerdsmanConvertersPackage.version} Herdsman ${zigbeeHerdsmanPackage.version})`);
+                await this.zbController.start();
             });
 
-            await this.zbController.start();
         } catch (error) {
             this.setState('info.connection', false, true);
             this.log.error(`Failed to start Zigbee`);
@@ -434,7 +479,7 @@ class Zigbee extends utils.Adapter {
             const configExtPanId = this.config.extPanID ? `0x${this.config.extPanID.toLowerCase()}` : '0xdddddddddddddddd';
             let networkExtPanId = (await this.zbController.herdsman.getNetworkParameters()).extendedPanID;
             let needChange = false;
-            this.log.debug(`Config value ${configExtPanId} : Network value ${networkExtPanId}`);
+            this.log.info(`Config value ${configExtPanId} : Network value ${networkExtPanId}`);
             const adapterType = this.config.adapterType || 'zstack';
             if (adapterType === 'zstack') {
                 if (configExtPanId !== networkExtPanId) {
@@ -480,9 +525,8 @@ class Zigbee extends utils.Adapter {
         }
 
         await this.setState('info.connection', true, true);
-
-        const devicesFromDB = this.zbController.getClientIterator(false);
         this.stController.CleanupRequired(false);
+        const devicesFromDB = this.zbController.getClientIterator(false);
         for (const device of devicesFromDB) {
             const entity = await this.zbController.resolveEntity(device);
             if (entity) {
@@ -490,6 +534,7 @@ class Zigbee extends utils.Adapter {
                 this.stController.updateDev(device.ieeeAddr.substr(2), model, model, () =>
                     this.stController.syncDevStates(device, model));
             }
+            else (this.log.warn('resolveEntity returned no entity'));
         }
         await this.callPluginMethod('start', [this.zbController, this.stController]);
     }
@@ -527,154 +572,6 @@ class Zigbee extends utils.Adapter {
         });
     }
 
-    async onZigbeeEvent(type, entity, message) {
-        this.log.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.stController.checkDebugDevice(devId);
-
-        if (has_elevated_debug) {
-            const shortMessage = {};
-            for(const propertyName in message) {
-                shortMessage[propertyName] = message[propertyName];
-            }
-            shortMessage.device = device.ieeeAddr;
-            shortMessage.meta = undefined;
-            shortMessage.endpoint = (message.endpoint.ID ? message.endpoint.ID: -1);
-            this.log.warn(`ELEVATED I00: Zigbee Event of Type ${type} from device ${safeJsonStringify(device.ieeeAddr)}, incoming event: ${safeJsonStringify(shortMessage)}`);
-        }
-        // this assigment give possibility to use iobroker logger in code of the converters, via meta.logger
-        meta.logger = this.log;
-
-        await this.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;
-                        }
-                    }
-                }
-            }
-        }
-
-        // always publish link_quality and battery
-        if (message.linkquality) { // send battery with
-            this.publishToState(devId, model, {linkquality: message.linkquality});
-            if (isBattKey) {
-                this.publishToState(devId, model, {voltage: _voltage});
-                const  battProz = zigbeeHerdsmanConvertersUtils.batteryVoltageToPercentage(_voltage,entity.mapped.meta.battery.voltageToPercentage);
-                this.publishToState(devId, model, {battery: battProz});
-            }
-            if (isMessure) {
-                this.publishToState(devId, model, {temperature: _temperature});
-                this.publishToState(devId, model, {humidity: _humidity});
-            }
-        }
-
-        // publish raw event to "from_zigbee"
-        // some cleanup
-        const msgForState = Object.assign({}, message);
-        delete msgForState['device'];
-        delete msgForState['endpoint'];
-
-        msgForState['endpoint_id'] = message.endpoint.ID;
-        this.publishToState(devId, model, {msg_from_zigbee: safeJsonStringify(msgForState)});
-
-        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') {
-                this.log.debug(`No converter available for '${mappedModel.model}' '${devId}' with cluster '${cluster}' and type '${type}'`);
-                if (has_elevated_debug)
-                    this.log.warn(`ELEVATED IE00: No converter available for '${mappedModel.model}' '${devId}' with cluster '${cluster}' and type '${type}'`);
-            }
-            return;
-        }
-
-        meta.state = { state: '' };   // for tuya
-
-        this.processConverters(converters, devId, model, mappedModel, message, meta)
-            .catch((error) => {
-                //   'Error: Expected one of: 0, 1, got: 'undefined''
-                if (cluster !== '64529') {
-                    this.log.error(`Error while processing converters DEVICE_ID: '${devId}' cluster '${cluster}' type '${type}'`);
-                }
-            });
-    }
-
-    async processConverters(converters, devId, model, mappedModel, message, meta) {
-        for (const converter of converters) {
-            const publish = (payload) => {
-                this.log.debug(`Publish ${safeJsonStringify(payload)} to ${safeJsonStringify(devId)}`);
-                if (typeof payload === 'object') {
-                    this.publishToState(devId, model, payload);
-                }
-            };
-
-            const options = await new Promise((resolve, reject) => {
-                this.stController.collectOptions(devId, model, (options) => {
-                    resolve(options);
-                });
-            });
-
-            const payload = await new Promise((resolve, reject) => {
-                const payloadConv = converter.convert(mappedModel, message, publish, options, meta);
-                if (typeof payloadConv === 'object') {
-                    resolve(payloadConv);
-                }
-            });
-
-            publish(payload);
-        }
-    }
-
-
-
     publishToState(devId, model, payload) {
         this.stController.publishToState(devId, model, payload);
     }
@@ -695,15 +592,18 @@ class Zigbee extends utils.Adapter {
         });
     }
 
-    async publishFromState(deviceId, model, stateModel, stateList, options) {
+    async publishFromState(deviceId, model, stateModel, stateList, options, debugID) {
         let isGroup = false;
         const has_elevated_debug = this.stController.checkDebugDevice(deviceId)
 
         if (has_elevated_debug)
         {
             const stateNames = [];
-            stateList.forEach( state => stateNames.push(state.id));
-            this.log.warn(`ELEVATED O03: Publishing to ${deviceId} of model ${model} ${stateNames.join(', ')}`);
+            for (const state of stateList) {
+                stateNames.push(state.stateDesc.id);
+            }
+            const message = `Publishing to ${deviceId} of model ${model} with ${stateNames.join(', ')}`;
+            this.emit('device_debug', { ID:debugID, data: { ID: deviceId, flag: '03', IO:false }, message: message});
         }
         else
             this.log.debug(`publishFromState : ${deviceId} ${model} ${safeJsonStringify(stateList)}`);
@@ -718,7 +618,10 @@ class Zigbee extends utils.Adapter {
 
             if (!mappedModel) {
                 this.log.debug(`No mapped model for ${model}`);
-                if (has_elevated_debug) this.log.error(`ELEVATED OE01: No mapped model ${deviceId} (model ${model})`)
+                if (has_elevated_debug) {
+                    const message=`No mapped model ${deviceId} (model ${model})`;
+                    this.emit('device_debug', { ID:debugID, data: { error: 'NOMODEL' , IO:false }, message: message});
+                }
                 return;
             }
 
@@ -735,13 +638,20 @@ class Zigbee extends utils.Adapter {
                 if (stateDesc.id === 'send_payload') {
                     try {
                         const json_value = JSON.parse(value);
-                        const payload = {device: deviceId.replace('0x', ''), payload: json_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 }});
+
                         const result = await this.sendPayload(payload);
                         if (result.hasOwnProperty('success') && result.success) {
                             this.acknowledgeState(deviceId, model, stateDesc, value);
                         }
+                        else {
+                            this.error('Error in SendPayload: '+result.error.message);
+                        }
                     } catch (error) {
-                        this.log.warn(`send_payload: ${value} does not parse as JSON Object : ${error.message}`);
+                        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;
@@ -749,8 +659,10 @@ class Zigbee extends utils.Adapter {
 
                 if (stateDesc.isOption || stateDesc.compositeState) {
                     // acknowledge state with given value
-                    if (has_elevated_debug)
+                    if (has_elevated_debug) {
                         this.log.warn('ELEVATED OC: changed state: ' + JSON.stringify(changedState));
+                        this.emit('device_debug', { ID:debugID, data: { flag: 'cc', states:[{id:stateDesc.id, value:value, payload:'none (OC State)'}] , IO:false }});
+                    }
                     else
                         this.log.debug('changed composite state: ' + JSON.stringify(changedState));
 
@@ -770,8 +682,11 @@ class Zigbee extends utils.Adapter {
                         }
                         if (mappedModel) {
                             this.query_device_block.push(deviceId);
-                            if (has_elevated_debug)
-                                this.log.warn(`ELEVATED O06: Device query for '${entity.device.ieeeAddr}/${entity.device.endpoints[0].ID}' triggered`);
+                            if (has_elevated_debug) {
+                                const message  = `Device query for '${entity.device.ieeeAddr}/${entity.device.endpoints[0].ID}' triggered`;
+                                //this.log.warn(`ELEVATED O06: ${message}`);
+                                this.emit('device_debug', { ID:debugID, data: { flag: 'qs' ,states:[{id:stateDesc.id, value:value, payload:'none for device query'}], IO:false }, message:message});
+                            }
                             else
                                 this.log.debug(`Device query for '${entity.device.ieeeAddr}' started`);
                             for (const converter of mappedModel.toZigbee) {
@@ -781,7 +696,9 @@ class Zigbee extends utils.Adapter {
                                             await converter.convertGet(entity.device.endpoints[0], ckey, {});
                                         } catch (error) {
                                             if (has_elevated_debug) {
-                                                this.log.warn(`ELEVATED OE02.1 Failed to read state '${JSON.stringify(ckey)}'of '${entity.device.ieeeAddr}/${entity.device.endpoints[0].ID}' from query with '${error && error.message ? error.message : 'no error message'}`);
+                                                const message = `Failed to read state '${JSON.stringify(ckey)}'of '${entity.device.ieeeAddr}/${entity.device.endpoints[0].ID}' from query with '${error && error.message ? error.message : 'no error message'}`;
+                                                this.log.warn(`ELEVATED OE02.1 ${message}`);
+                                                this.emit('device_debug', { ID:debugID, data: { error: 'NOTREAD' , IO:false }, message:message });
                                             }
                                             else
                                                 this.log.info(`failed to read state ${JSON.stringify(ckey)} of ${entity.device.ieeeAddr}/${entity.device.endpoints[0].ID} after device query`);
@@ -789,8 +706,11 @@ class Zigbee extends utils.Adapter {
                                     }
                                 }
                             }
-                            if (has_elevated_debug)
-                                this.log.warn(`ELEVATED O07: Device query for '${entity.device.ieeeAddr}/${entity.device.endpoints[0].ID}' complete`);
+                            if (has_elevated_debug) {
+                                const message = `ELEVATED O07: Device query for '${entity.device.ieeeAddr}/${entity.device.endpoints[0].ID}' complete`;
+                                //this.log.warn(`ELEVATED O07: ${message}`);
+                                this.emit('device_debug', { ID:debugID, data: { flag: 'qe' , IO:false }, message:message});
+                            }
                             else
                                 this.log.info(`Device query for '${entity.device.ieeeAddr}' done`);
                             const idToRemove = deviceId;
@@ -814,38 +734,51 @@ class Zigbee extends utils.Adapter {
                     this.log.debug(`Type of toZigbee is '${typeof c}', Contains key ${(c.hasOwnProperty('key')?JSON.stringify(c.key):'false ')}`)
                     if (!c.hasOwnProperty('key'))
                     {
-                        if (c.hasOwnProperty('convertSet') && converter === undefined)
+                        if (converter === undefined)
                         {
                             converter = c;
-                            if (has_elevated_debug)
-                                this.log.warn(`ELEVATED O04.${msg_counter}: Setting converter to keyless converter for ${deviceId} of type ${model}`)
+                            if (has_elevated_debug) {
+                                const message = `Setting converter to keyless converter for ${deviceId} of type ${model}`;
+                                this.emit('device_debug', { ID:debugID, data: { flag: `s4.${msg_counter}` , IO:false }, message:message});
+                            }
                             else
-                                this.log.debug(`Setting converter to keyless converter for ${deviceId} of type ${model}`)
+                                this.log.debug(`Setting converter to keyless converter for ${deviceId} of type ${model}`);
                             msg_counter++;
                         }
                         else
                         {
                             if (has_elevated_debug)
-                                this.log.warn(`ELEVATED O04.${msg_counter}: ignoring keyless converter for ${deviceId} of type ${model}`)
+                            {
+                                const message = `ignoring keyless converter for ${deviceId} of type ${model}`;
+                                this.emit('device_debug', { ID:debugID, data: { flag: `i4.${msg_counter}` , IO:false} , message:message});
+                            }
                             else
-                                this.log.debug(`ignoring keyless converter for ${deviceId} of type ${model}`)
+                                this.log.debug(`ignoring keyless converter for ${deviceId} of type ${model}`);
                             msg_counter++;
                         }
                         continue;
                     }
                     if (c.key.includes(stateDesc.prop) || c.key.includes(stateDesc.setattr) || c.key.includes(stateDesc.id))
                     {
-                        if (has_elevated_debug)
-                            this.log.warn(`ELEVATED O04.${msg_counter}: ${(converter===undefined?'Setting':'Overriding')}' converter to converter with key(s)'${JSON.stringify(c.key)}}`)
+                        const message = `${(converter===undefined?'Setting':'Overriding')}' converter to converter with key(s)'${JSON.stringify(c.key)}}`;
+                        if (has_elevated_debug) {
+                            this.emit('device_debugug', { ID:debugID, data: { flag: `${converter===undefined ? 's' : 'o'}4.${msg_counter}` , IO:false }, message:message});
+
+                        }
                         else
-                            this.log.debug(`${(converter===undefined?'Setting':'Overriding')}' converter to converter with key(s)'${JSON.stringify(c.key)}}`)
+                            this.log.debug(message);
                         converter = c;
                         msg_counter++;
                     }
                 }
                 if (converter === undefined) {
-                    this.log.error(`No converter available for '${model}' with key '${stateDesc.id}' `);
-                    this.sendError(`No converter available for '${model}' with key '${stateDesc.id}' `);
+                    const message = `No converter available for '${model}' with key '${stateDesc.id}' `;
+                    if (has_elevated_debug) {
+                        this.emit('device_debug', { ID:debugID, data: { error: 'NOCONV',states:[{id:stateDesc.id, value:value, payload:'no converter'}] , IO:false }, message:message});
+                    }
+                    else {
+                        this.log.warn(message);
+                    }
                     return;
                 }
 
@@ -864,10 +797,12 @@ class Zigbee extends utils.Adapter {
 
                 const epName = stateDesc.epname !== undefined ? stateDesc.epname : (stateDesc.prop || stateDesc.id);
                 const key = stateDesc.setattr || stateDesc.prop || stateDesc.id;
-                if (has_elevated_debug)
-                    this.log.warn(`ELEVATED O04: convert ${key}, ${safeJsonStringify(preparedValue)}, ${safeJsonStringify(preparedOptions)} for device ${deviceId} with Endpoint ${epName}`);
+                const message = `convert ${key}, ${safeJsonStringify(preparedValue)}, ${safeJsonStringify(preparedOptions)} for device ${deviceId} with Endpoint ${epName}`;
+                if (has_elevated_debug) {
+                    this.emit('device_debug', { ID:debugID, data: { flag: '04', payload: {key:key, ep: stateDesc.epname, value:preparedValue, options:preparedOptions}, IO:false }, message:message});
+                }
                 else
-                    this.log.debug(`convert ${key}, ${safeJsonStringify(preparedValue)}, ${safeJsonStringify(preparedOptions)}`);
+                    this.log.debug(message);
 
                 let target;
                 if (model === 'group') {
@@ -897,6 +832,10 @@ class Zigbee extends utils.Adapter {
                         meta.message.state = preparedValue;
                     }
                 }
+                if (has_elevated_debug) {
+                    //this.log.warn('epname is ' + epName + ' or ' + stateDesc.epname);
+                    this.emit('device_debug', { ID:debugID, data: { states:[{id:stateDesc.id, value:value, payload:preparedValue, ep:stateDesc.epname}] , IO:false }});
+                }
 
                 if (preparedOptions !== undefined) {
                     if (preparedOptions.hasOwnProperty('state')) {
@@ -906,33 +845,52 @@ class Zigbee extends utils.Adapter {
 
                 try {
                     const result = await converter.convertSet(target, key, preparedValue, meta);
-                    if (has_elevated_debug)
-                        this.log.warn(`ELEVATED O05: convert result ${safeJsonStringify(result)} for device ${deviceId}`);
+                    const message = `convert result ${safeJsonStringify(result)} for device ${deviceId}`;
+                    if (has_elevated_debug) {
+                        this.emit('device_debug', { ID:debugID, data: { flag: 'SUCCESS' , IO:false }, message:message});
+                    }
                     else
-                        this.log.debug(`convert result ${safeJsonStringify(result)}`);
+                        this.log.debug(message);
                     if (result !== undefined) {
-                        if (stateModel && !isGroup) {
+                        if (stateModel && !isGroup && !stateDesc.noack) {
                             this.acknowledgeState(deviceId, model, stateDesc, value);
                         }
                         // process sync state list
                         this.processSyncStatesList(deviceId, model, syncStateList);
                     }
-                    else
-                        if (has_elevated_debug)
-                            this.log.error(`ELEVATED OE2: Error convert result for ${key} with ${safeJsonStringify(preparedValue)} is undefined on device ${deviceId}.`);
-
+                    else {
+                        if (has_elevated_debug) {
+                            const message = `Convert does not return a result result for ${key} with ${safeJsonStringify(preparedValue)} on device ${deviceId}.`;
+                            this.emit('device_debug', { ID:debugID, data: { flag: '06' , IO:false }, message:message});
+                        }
+                    }
                 } catch (error) {
-                    if (has_elevated_debug)
-                        this.log.error(`ELEVATED OE3: caught error ${safeJsonStringify(error)} when setting value for device ${deviceId}.`);
+                    if (has_elevated_debug) {
+                        const message = `caught error ${safeJsonStringify(error)} when setting value for device ${deviceId}.`;
+                        this.emit('device_debug', { ID:debugID, data: { error: 'EXSET' , IO:false },message:message});
+                    }
                     this.filterError(`Error ${error.code} on send command to ${deviceId}.` +
                         ` Error: ${error.stack}`, `Send command to ${deviceId} failed with`, error);
                 }
             });
         } catch (err) {
-            this.log.error(`No entity for ${deviceId} : ${err && err.message ? err.message : 'no error message'}`);
+            const message = `No entity for ${deviceId} : ${err && err.message ? err.message : 'no error message'}`;
+            this.emit('device_debug', { ID:debugID, data: { error: 'EXPUB' , IO:false }, message:message});
         }
     }
 
+
+    extractEP(key, endpoints) {
+        try {
+            if (endpoints) for (const ep of Object.keys(endpoints)) {
+                if (key.endsWith('_'+ep)) return { setattr: key.replace('_'+ep, ''), epname:ep }
+            }
+        }
+        catch {
+            return {};
+        }
+        return {};
+    }
     // This function is introduced to explicitly allow user level scripts to send Commands
     // directly to the zigbee device. It utilizes the zigbee-herdsman-converters to generate
     // the exact zigbee message to be sent and can be used to set device options which are
@@ -946,7 +904,6 @@ class Zigbee extends utils.Adapter {
     // endpoint: optional: the endpoint to send the data to, if supported.
     //
     async sendPayload(payload) {
-        this.log.debug(`publishToDevice called with ${safeJsonStringify(payload)}`);
         let payloadObj = {};
         if (typeof payload === 'string') {
             try {
@@ -961,7 +918,7 @@ class Zigbee extends utils.Adapter {
             }
         } else if (typeof payload === 'object') {
             payloadObj = payload;
-        }
+        } else return { success: false, error: 'illegal type of payload: ' + typeof payload};
 
         if (payloadObj.hasOwnProperty('device') && payloadObj.hasOwnProperty('payload')) {
             try {
@@ -986,16 +943,24 @@ class Zigbee extends utils.Adapter {
                     this.sendError(`Illegal payload type for ${safeJsonStringify(payloadObj.device)}`);
                     return {success: false, error: `Illegal payload type for ${safeJsonStringify(payloadObj.device)}`};
                 }
+                const endpoints = mappedModel && mappedModel.endpoint ? mappedModel.endpoint(entity.device) : null;
                 for (const key in payloadObj.payload) {
                     if (payloadObj.payload[key] != undefined) {
                         const datatype = typeof payloadObj.payload[key];
+                        const epobj = this.extractEP(key, endpoints);
+                        if (payloadObj.endpoint) {
+                            epobj.epname = payloadObj.endpoint;
+                            delete epobj.setattr;
+                        }
                         stateList.push({
                             stateDesc: {
                                 id: key,
                                 prop: key,
                                 role: 'state',
                                 type: datatype,
-                                epname: payloadObj.endpoint,
+                                noack:true,
+                                epname: epobj.epname,
+                                setattr: epobj.setattr,
                             },
                             value: payloadObj.payload[key],
                             index: 0,
@@ -1004,8 +969,7 @@ class Zigbee extends utils.Adapter {
                     }
                 }
                 try {
-                    this.log.debug(`Calling publish to state for ${safeJsonStringify(payloadObj.device)} with ${safeJsonStringify(stateList)}`);
-                    await this.publishFromState(`0x${payload.device}`, '', undefined, stateList, payload.options);
+                    await this.publishFromState(`0x${payload.device}`, payload.model, payload.stateModel, stateList, payload.options, Date.now());
                     return {success: true};
                 } catch (error) {
                     this.log.error(`Error ${error.code} on send command to ${payload.device}.` + ` Error: ${error.stack} ` + `Send command to ${payload.device} failed with ` + error);
@@ -1023,6 +987,7 @@ class Zigbee extends utils.Adapter {
 
     newDevice(entity) {
         this.log.debug(`New device event: ${safeJsonStringify(entity)}`);
+        this.stController.AddModelFromHerdsman(entity.device, entity.mapped.model)
         const dev = entity.device;
         if (dev) {
             this.getObject(dev.ieeeAddr.substr(2), (err, obj) => {