iobroker.zigbee 2.0.3 → 2.0.4

package/lib/zigbeecontroller.js

@@ -179,7 +179,7 @@ class ZigbeeController extends EventEmitter {
                 this.warn(`Network parameters on Coordinator: panID=${debNetworkParam.panID} channel=${debNetworkParam.channel} extendedPanID=${extPanIDDebug}`);
             }
             catch (error) {
-                this.info(`Unable to obtain herdsman settings`)
+                this.warn(`Unable to obtain herdsman settings`)
             }
             try {
                 await this.herdsman.stop();
@@ -747,11 +747,7 @@ class ZigbeeController extends EventEmitter {
             this.debug('handleDeviceLeave', message);
             const entity = await this.resolveEntity(message.device || message.ieeeAddr);
             const friendlyName = entity ? entity.name : message.ieeeAddr;
-            if (this.adapter.stController.checkDebugDevice(friendlyName)) {
-                this.emit('device_debug', {ID: Date.now(), data: {flag:'dl', states:[{id: '--', value:'--', payload:message}], IO:true},message:`Device '${friendlyName}' has left the network`});
-            }
-            else
-                this.info(`Device '${friendlyName}' left the network`);
+            this.debug(`Device '${friendlyName}' left the network`);
             this.emit('leave', message.ieeeAddr);
             // Call extensions
             this.callExtensionMethod(
@@ -768,10 +764,7 @@ class ZigbeeController extends EventEmitter {
         this.debug('handleDeviceAnnounce', message);
         const entity = await this.resolveEntity(message.device || message.ieeeAddr);
         const friendlyName = entity.name;
-        if (this.adapter.stController.checkDebugDevice(friendlyName)) {
-            this.emit('device_debug', {ID: Date.now(), data: {flag:'da', states:[{id: '--', value:'--', payload:message}] , IO:true} ,message:`Device '${friendlyName}' announced itself`});
-        }
-        else if (this.warnOnDeviceAnnouncement) {
+        if (this.warnOnDeviceAnnouncement) {
             this.warn(`Device '${friendlyName}' announced itself`);
         } else {
             this.info(`Device '${friendlyName}' announced itself`);
@@ -890,7 +883,7 @@ class ZigbeeController extends EventEmitter {
                 let resolved = await this.resolveEntity(device, 0);
                 if (!resolved) {
                     resolved = { name:'unresolved device', device:device }
-                    this.debug('resolve Entity failed for ' + device.ieeeAddr)
+                    this.warn('resolve Entity failed for ' + device.ieeeAddr)
                 }
                 let result;
 
@@ -950,9 +943,9 @@ class ZigbeeController extends EventEmitter {
 
             callback && callback({lqis, routing, errors});
             if (errors.length) {
-                this.debug(`Map Data collection complete with ${errors.length} issues:`);
+                this.warn(`Map Data collection complete with ${errors.length} issues:`);
                 for (const msg of errors)
-                    this.debug(msg);
+                    this.warn(msg);
             }
             else
                 this.info('Map data collection complete');

package/main.js

@@ -36,7 +36,6 @@ 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 = [];
@@ -80,9 +79,6 @@ 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),
@@ -119,19 +115,6 @@ 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')) {
@@ -227,15 +210,12 @@ 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.stController.onZigbeeEvent.bind(this.stController));
-        this.zbController.on('msg', this.stController.onZigbeeEvent.bind(this.stController));
+        this.zbController.on('event', this.onZigbeeEvent.bind(this));
+        this.zbController.on('msg', this.onZigbeeEvent.bind(this));
         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();
     }
@@ -530,6 +510,7 @@ class Zigbee extends utils.Adapter {
         for (const device of devicesFromDB) {
             const entity = await this.zbController.resolveEntity(device);
             if (entity) {
+                // this.log.warn('sync dev states for ' + (entity.mapped ? entity.mapped.model : entity.device.modelID));
                 const model = entity.mapped ? entity.mapped.model : entity.device.modelID;
                 this.stController.updateDev(device.ieeeAddr.substr(2), model, model, () =>
                     this.stController.syncDevStates(device, model));
@@ -572,6 +553,154 @@ 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);
     }
@@ -592,18 +721,15 @@ class Zigbee extends utils.Adapter {
         });
     }
 
-    async publishFromState(deviceId, model, stateModel, stateList, options, debugID) {
+    async publishFromState(deviceId, model, stateModel, stateList, options) {
         let isGroup = false;
         const has_elevated_debug = this.stController.checkDebugDevice(deviceId)
 
         if (has_elevated_debug)
         {
             const stateNames = [];
-            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});
+            stateList.forEach( state => stateNames.push(state.id));
+            this.log.warn(`ELEVATED O03: Publishing to ${deviceId} of model ${model} ${stateNames.join(', ')}`);
         }
         else
             this.log.debug(`publishFromState : ${deviceId} ${model} ${safeJsonStringify(stateList)}`);
@@ -618,10 +744,7 @@ class Zigbee extends utils.Adapter {
 
             if (!mappedModel) {
                 this.log.debug(`No mapped model for ${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});
-                }
+                if (has_elevated_debug) this.log.error(`ELEVATED OE01: No mapped model ${deviceId} (model ${model})`)
                 return;
             }
 
@@ -638,20 +761,13 @@ 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, 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 payload = {device: deviceId.replace('0x', ''), payload: json_value};
                         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) {
-                        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);
+                        this.log.warn(`send_payload: ${value} does not parse as JSON Object : ${error.message}`);
                         return;
                     }
                     return;
@@ -659,10 +775,8 @@ 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));
 
@@ -682,11 +796,8 @@ class Zigbee extends utils.Adapter {
                         }
                         if (mappedModel) {
                             this.query_device_block.push(deviceId);
-                            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});
-                            }
+                            if (has_elevated_debug)
+                                this.log.warn(`ELEVATED O06: Device query for '${entity.device.ieeeAddr}/${entity.device.endpoints[0].ID}' triggered`);
                             else
                                 this.log.debug(`Device query for '${entity.device.ieeeAddr}' started`);
                             for (const converter of mappedModel.toZigbee) {
@@ -696,9 +807,7 @@ class Zigbee extends utils.Adapter {
                                             await converter.convertGet(entity.device.endpoints[0], ckey, {});
                                         } catch (error) {
                                             if (has_elevated_debug) {
-                                                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 });
+                                                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'}`);
                                             }
                                             else
                                                 this.log.info(`failed to read state ${JSON.stringify(ckey)} of ${entity.device.ieeeAddr}/${entity.device.endpoints[0].ID} after device query`);
@@ -706,11 +815,8 @@ class Zigbee extends utils.Adapter {
                                     }
                                 }
                             }
-                            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});
-                            }
+                            if (has_elevated_debug)
+                                this.log.warn(`ELEVATED O07: Device query for '${entity.device.ieeeAddr}/${entity.device.endpoints[0].ID}' complete`);
                             else
                                 this.log.info(`Device query for '${entity.device.ieeeAddr}' done`);
                             const idToRemove = deviceId;
@@ -734,51 +840,38 @@ 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 (converter === undefined)
+                        if (c.hasOwnProperty('convertSet') && converter === undefined)
                         {
                             converter = c;
-                            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});
-                            }
+                            if (has_elevated_debug)
+                                this.log.warn(`ELEVATED O04.${msg_counter}: Setting converter to keyless converter for ${deviceId} of type ${model}`)
                             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)
-                            {
-                                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});
-                            }
+                                this.log.warn(`ELEVATED O04.${msg_counter}: ignoring keyless converter for ${deviceId} of type ${model}`)
                             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))
                     {
-                        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});
-
-                        }
+                        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)}}`)
                         else
-                            this.log.debug(message);
+                            this.log.debug(`${(converter===undefined?'Setting':'Overriding')}' converter to converter with key(s)'${JSON.stringify(c.key)}}`)
                         converter = c;
                         msg_counter++;
                     }
                 }
                 if (converter === undefined) {
-                    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);
-                    }
+                    this.log.error(`No converter available for '${model}' with key '${stateDesc.id}' `);
+                    this.sendError(`No converter available for '${model}' with key '${stateDesc.id}' `);
                     return;
                 }
 
@@ -797,12 +890,10 @@ class Zigbee extends utils.Adapter {
 
                 const epName = stateDesc.epname !== undefined ? stateDesc.epname : (stateDesc.prop || stateDesc.id);
                 const key = stateDesc.setattr || stateDesc.prop || stateDesc.id;
-                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});
-                }
+                if (has_elevated_debug)
+                    this.log.warn(`ELEVATED O04: convert ${key}, ${safeJsonStringify(preparedValue)}, ${safeJsonStringify(preparedOptions)} for device ${deviceId} with Endpoint ${epName}`);
                 else
-                    this.log.debug(message);
+                    this.log.debug(`convert ${key}, ${safeJsonStringify(preparedValue)}, ${safeJsonStringify(preparedOptions)}`);
 
                 let target;
                 if (model === 'group') {
@@ -832,10 +923,6 @@ 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')) {
@@ -845,52 +932,33 @@ class Zigbee extends utils.Adapter {
 
                 try {
                     const result = await converter.convertSet(target, key, preparedValue, meta);
-                    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});
-                    }
+                    if (has_elevated_debug)
+                        this.log.warn(`ELEVATED O05: convert result ${safeJsonStringify(result)} for device ${deviceId}`);
                     else
-                        this.log.debug(message);
+                        this.log.debug(`convert result ${safeJsonStringify(result)}`);
                     if (result !== undefined) {
-                        if (stateModel && !isGroup && !stateDesc.noack) {
+                        if (stateModel && !isGroup) {
                             this.acknowledgeState(deviceId, model, stateDesc, value);
                         }
                         // process sync state list
                         this.processSyncStatesList(deviceId, model, syncStateList);
                     }
-                    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});
-                        }
-                    }
+                    else
+                        if (has_elevated_debug)
+                            this.log.error(`ELEVATED OE2: Error convert result for ${key} with ${safeJsonStringify(preparedValue)} is undefined on device ${deviceId}.`);
+
                 } catch (error) {
-                    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});
-                    }
+                    if (has_elevated_debug)
+                        this.log.error(`ELEVATED OE3: caught error ${safeJsonStringify(error)} when setting value for device ${deviceId}.`);
                     this.filterError(`Error ${error.code} on send command to ${deviceId}.` +
                         ` Error: ${error.stack}`, `Send command to ${deviceId} failed with`, error);
                 }
             });
         } catch (err) {
-            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});
+            this.log.error(`No entity for ${deviceId} : ${err && err.message ? err.message : 'no error 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
@@ -904,6 +972,7 @@ 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 {
@@ -918,7 +987,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 {
@@ -943,24 +1012,16 @@ 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,
-                                noack:true,
-                                epname: epobj.epname,
-                                setattr: epobj.setattr,
+                                epname: payloadObj.endpoint,
                             },
                             value: payloadObj.payload[key],
                             index: 0,
@@ -969,7 +1030,8 @@ class Zigbee extends utils.Adapter {
                     }
                 }
                 try {
-                    await this.publishFromState(`0x${payload.device}`, payload.model, payload.stateModel, stateList, payload.options, Date.now());
+                    this.log.debug(`Calling publish to state for ${safeJsonStringify(payloadObj.device)} with ${safeJsonStringify(stateList)}`);
+                    await this.publishFromState(`0x${payload.device}`, '', undefined, stateList, payload.options);
                     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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iobroker.zigbee",
-  "version": "2.0.3",
+  "version": "2.0.4",
   "author": {
     "name": "Kirov Ilya",
     "email": "kirovilya@gmail.com"
@@ -29,7 +29,7 @@
     "uri-js": "^4.4.1",
     "typescript": "^5.6.3",
     "zigbee-herdsman": "3.2.7",
-    "zigbee-herdsman-converters": "23.1.1"
+    "zigbee-herdsman-converters": "21.38.0"
   },
   "description": "Zigbee devices",
   "devDependencies": {