iobroker.zigbee 3.1.5 → 3.2.0

package/lib/zigbeecontroller.js

@@ -179,13 +179,13 @@ class ZigbeeController extends EventEmitter {
         try {
             this.emit('pairing', 'stopping zigbee-herdsman');
             await this.herdsman.stop();
-            this.emit('pairing', 'herdsman stopped !');
-            this.herdsmanStarted = false;
         }
         catch (error) {
             this.emit('pairing', `error stopping zigbee-herdsman: ${error && error.message ? error.message : 'no reason given'}`);
         }
         this.isConfigured = false;
+        this.emit('pairing', 'herdsman stopped !');
+        this.herdsmanStarted = false;
         delete this.herdsman;
 
     }
@@ -263,13 +263,13 @@ class ZigbeeController extends EventEmitter {
         // Check if we have to turn off the LED
         try {
             if (this.disableLed) {
-                this.info('Disable LED');
+                this.debug('Disable LED');
                 await this.herdsman.setLED(false);
             } else {
                 await this.herdsman.setLED(true);
             }
         } catch (e) {
-            this.info('Unable to disable LED, unsupported function.');
+            this.debug('Unable to disable LED, unsupported function.');
             this.emit('pairing','Unable to disable LED, unsupported function.');
         }
 
@@ -287,7 +287,7 @@ class ZigbeeController extends EventEmitter {
                 }
                 //await this.adapter.stController.AddModelFromHerdsman(device, entity.mapped.model);
 
-                this.adapter.getObject(device.ieeeAddr.substr(2), (err, obj) => {
+                this.adapter.getObject(utils.zbIdorIeeetoAdId(this.adapter, device.ieeeAddr, false), (err, obj) => {
                     if (obj && obj.common && obj.common.deactivated) {
                         this.callExtensionMethod('deregisterDevicePing', [device, entity]);
                     } else {
@@ -613,11 +613,12 @@ class ZigbeeController extends EventEmitter {
 
             if (_key.kind == 'coordinator') {
                 const coordinator = this.herdsman.getDevicesByType('Coordinator')[0];
-                return {
+                if (coordinator) return {
                     type: 'device',
                     device: coordinator,
                     endpoint: coordinator.getEndpoint(1),
                     name: 'Coordinator',
+                    mapped: { model: 'Coordinator'},
                     options:{}
                 };
             }
@@ -651,16 +652,23 @@ class ZigbeeController extends EventEmitter {
             }
             if (device) {
                 const t = Date.now();
-                const mapped = await zigbeeHerdsmanConverters.findByDevice(device, false);
+                let mapped = undefined;
+                try {
+                    mapped = await zigbeeHerdsmanConverters.findByDevice(device, false);
+                }
+                catch (error) {
+
+                }
                 if (!mapped) {
                     if (device.type === 'Coordinator')
                         return {
                             type: 'device',
                             device: device,
+                            mapped: { model: 'Coordinator'},
                             endpoint: device.getEndpoint(1),
                             name: 'Coordinator',
                         };
-                    this.warn(`Resolve Entity did not manage to find a mapped device for ${device.ieeeAddr} of type ${device.modelID}`);
+                    this.emit('stash_unknown_model', `resoveEntity${device.ieeeAddr}`,`Resolve Entity did not manage to find a mapped device for ${device.ieeeAddr} of type ${device.modelID}`);
                 }
                 const endpoints = mapped && mapped.endpoint ? mapped.endpoint(device) : null;
                 let endpoint;
@@ -736,6 +744,7 @@ class ZigbeeController extends EventEmitter {
                 await this.herdsman.stop();
                 this.herdsmanStarted = false;
                 this.info('zigbecontroller stopped successfully');
+                return;
             }
             else this.info('zigbecontroller stopped successfully - ZH was not running');
         } catch (error) {
@@ -759,12 +768,26 @@ class ZigbeeController extends EventEmitter {
 
     // Permit join
     async permitJoin(permitTime, devid) {
+        if (!this.herdsmanStarted) return false;
         try {
+            const starter = this._permitJoinTime > 0? 'Extending open network':'Opening network';
             this._permitJoinTime = permitTime;
-            await this.herdsman.permitJoin(permitTime);
-            this._permitJoinDevice = (permitTime > 0 && devid ? devid : '');
+            const dId = devid || this._permitJoinDevId
+            if (permitTime > 0) {
+                this.info(`${starter}${dId ? ' on device ' + dId : ''}.`);
+                this.emit('pairing', `${starter}${dId ? 'on device ' + dId : ''}.`);
+                await this.herdsman.permitJoin(permitTime, dId);
+                this._permitJoinDevId = dId;
+            }
+            else {
+                await this.herdsman.permitJoin(0);
+                this.info(`Closing network.`);
+                this.emit('pairing', `Closing network${this._permitJoinDevId ? ' on '+this._permitJoinDevId : ''}.`)
+                this._permitJoinDevId = undefined;
+            }
         } catch (e) {
             this._permitJoinTime = 0;
+            this._permitJoinDevId = undefined;
             this.sendError(e);
             this.error(`Failed to open the network: ${e.stack}`);
             return false;
@@ -779,20 +802,19 @@ class ZigbeeController extends EventEmitter {
             if (data.permitted) {
                 if (!this._permitJoinInterval) {
                     this.emit('pairing',`Pairing possible for ${this._permitJoinTime} seconds`)
-                    this.info(`Opening zigbee Network for ${this._permitJoinTime} seconds`)
+                    this.info(`Opened zigbee Network for ${this._permitJoinTime} seconds`)
                     this._permitJoinInterval = setInterval(async () => {
                         this.emit('pairing', 'Pairing time left', this._permitJoinTime);
                         this._permitJoinTime -= 1;
                     }, 1000);
                 }
             }
-            else {
-                this.info(`Closing Zigbee network, ${this._permitJoinTime} seconds remaining`)
+            else if (this._permitJoinInterval) {
+                const timestr = this._permitJoinTime > 0 ? ` with ${this._permitJoinTime} second${this._permitJoinTime > 1 ? 's':''} remaining.`: '.';
+                this.info(`Closed Zigbee network${timestr}`)
+                this.emit('pairing', `Closed network${timestr}`);
                 clearInterval(this._permitJoinInterval);
                 this._permitJoinInterval = null;
-                // this.emit('pairing', 'Pairing time left', 0);
-                this.emit('pairing', 'Closing network.',0);
-                this._permitJoinDevice = '';
             }
         }
         catch (error) {
@@ -860,7 +882,7 @@ class ZigbeeController extends EventEmitter {
                 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.warn(`Device '${friendlyName}' left the network`);
             this.emit('leave', message.ieeeAddr);
             // Call extensions
             this.callExtensionMethod(
@@ -993,7 +1015,7 @@ class ZigbeeController extends EventEmitter {
 
         const is = data.device.interviewState;
         if (is != 'SUCCESSFUL' && is != 'FAILED') {
-            this.info(`message ${JSON.stringify(data)} received during interview.`)
+            this.debug(`message ${JSON.stringify(data)} received during interview.`)
         }
         const entity = await this.resolveEntity(data.device || data.ieeeAddr);
         const name = (entity && entity._modelID) ? entity._modelID : data.device.ieeeAddr;
@@ -1156,6 +1178,7 @@ class ZigbeeController extends EventEmitter {
         }
         */
     }
+
     // publish via converter
     //
     async publishFromState(deviceId, model, stateModel, stateList, options, debugID, has_elevated_debug) {
@@ -1404,11 +1427,12 @@ class ZigbeeController extends EventEmitter {
             payloadObj = payload;
         } else return { success: false, error: 'illegal type of payload: ' + typeof payload};
 
+
         if (payloadObj.hasOwnProperty('device') && payloadObj.hasOwnProperty('payload')) {
             try {
-                const isDevice = !payload.device.includes('group_');
+                const isDevice = !payloadObj.device.includes('group_');
                 const stateList = [];
-                const devID = isDevice ? `0x${payload.device}` : parseInt(payload.device.replace('group_', ''));
+                const devID = isDevice ? `0x${payloadObj.device}` : parseInt(payloadObj.device.replace('group_', ''));
 
                 const entity = await this.resolveEntity(devID);
                 if (!entity) {

package/main.js

@@ -37,7 +37,7 @@ const dmZigbee  = require('./lib/devicemgmt.js');
 const DeviceDebug = require('./lib/DeviceDebug');
 const dns = require('dns');
 const net = require('net');
-const { getNetAddress } = require('./lib/utils')
+const { getNetAddress, zbIdorIeeetoAdId, adIdtoZbIdorIeee , removeFromArray } = require('./lib/utils');
 
 const createByteArray = function (hexString) {
     const bytes = [];
@@ -231,6 +231,8 @@ class Zigbee extends utils.Adapter {
         this.stController.on('changed', this.zbController.publishFromState.bind(this.zbController));
         this.stController.on('device_query', this.zbController.deviceQuery.bind(this.zbController));
         this.zbController.on('acknowledge_state', this.acknowledgeState.bind(this));
+        this.zbController.on('stash_error', this.stController.stashErrors.bind(this.stController));
+        this.zbController.on('stash_unknown_model', this.stController.stashUnknownModel.bind(this.stController));
 
         this.zbController.configure(zigbeeOptions);
         this.zbController.debugActive = this.debugActive;
@@ -302,6 +304,7 @@ class Zigbee extends utils.Adapter {
 
     * getExternalDefinition() {
 
+
         if (this.config.external === undefined) {
             return;
         }
@@ -353,20 +356,22 @@ class Zigbee extends utils.Adapter {
                     try {
                         this.log.warn('Trying to run sandbox for ' + mN);
                         vm.runInNewContext(modifiedCode, sandbox);
-                        const converter = sandbox.module.exports;
+                        const sandboxResult = sandbox.module.exports;
+                        const converter = Array.isArray(sandboxResult) ? sandboxResult : [sandboxResult];
 
-                        if (Array.isArray(converter)) for (const item of converter) {
-                            this.log.info('Model ' + item.model + ' defined in external converter ' + mN);
+                        for (const item of converter) {
                             if (item.hasOwnProperty('icon')) {
                                 if (!item.icon.toLowerCase().startsWith('http') && !item.useadaptericon)
                                     item.icon = path.join(path.dirname(mN), item.icon);
                             }
-                            yield item;
-                        }
-                        else {
-                            this.log.info('Model ' + converter.model + ' defined in external converter ' + mN);
-                            yield converter;
+                            const rtz = removeFromArray(item.toZigbee);
+                            const rfz = removeFromArray(item.fromZigbee);
+                            const rtzfzmsg = [];
+                            if (rtz) rtzfzmsg.push(`${rtz} unknown entr${rtz>1?'ies' : 'y'} in toZigbee`);
+                            if (rfz) rtzfzmsg.push(`${rfz} unknown entr${rtz>1?'ies' : 'y'} in fromZigbee`);
+                            this.log.info(`Model ${item.model} defined ${rtz+rfz ? 'with '+ rtzfzmsg.join(' and ') + ' ' : ''}in external converter ${mN}`);
                         }
+                        yield converter;
                     }
                     catch (e) {
                         this.log.error(`Unable to apply converter from module: ${mN} - the code does not run: ${e}`);
@@ -381,17 +386,19 @@ class Zigbee extends utils.Adapter {
 
     applyExternalConverters() {
         for (const definition of this.getExternalDefinition()) {
-            const toAdd = {...definition};
-            delete toAdd['homeassistant'];
+            const toAdd = definition;
             try {
-                const t = Date.now();
-                if (zigbeeHerdsmanConverters.hasOwnProperty('addExternalDefinition')) {
-                    zigbeeHerdsmanConverters.addExternalDefinition(toAdd);
-                    this.log.info(`added external converter using addExternalDefinition (${Date.now()-t} ms)`)
-                }
-                else if (zigbeeHerdsmanConverters.hasOwnProperty('addDefinition')) {
-                    zigbeeHerdsmanConverters.addDefinition(toAdd);
-                    this.log.info(`added external converter using addDefinition (${Date.now()-t} ms)`);
+                for (const item of toAdd) {
+                    delete item['homeassistant'];
+                    const t = Date.now();
+                    if (zigbeeHerdsmanConverters.hasOwnProperty('addExternalDefinition')) {
+                        zigbeeHerdsmanConverters.addExternalDefinition(item);
+                        this.log.info(`added external converter using addExternalDefinition (${Date.now()-t} ms)`)
+                    }
+                    else if (zigbeeHerdsmanConverters.hasOwnProperty('addDefinition')) {
+                        zigbeeHerdsmanConverters.addDefinition(item);
+                        this.log.info(`added external converter using addDefinition (${Date.now()-t} ms)`);
+                    }
                 }
             } catch (e) {
                 this.log.error(`unable to apply external converter for ${JSON.stringify(toAdd.model)}: ${e && e.message ? e.message : 'no error message available'}`);
@@ -399,32 +406,39 @@ class Zigbee extends utils.Adapter {
         }
     }
 
-    async testConnect(from, command, message, callback) {
+    async testConnect(message) {
         const response = {};
+        if (this.reconnectTimer) this.clearTimeout(this.reconnectTimer);
+        this.reconnectTimer = null;
+        const zo = message.zigbeeOptions || {};
         if (message.start) {
             try {
-                this.logToPairing(`overriding zigbee options with:`);
-                for (const k of Object.keys(message.zigbeeOptions)) {
-                    this.logToPairing(`${k} : ${message.zigbeeOptions[k]}`)
+                const keys = Object.keys(zo);
+                if (keys) {
+                    this.logToPairing(`overriding zigbee options with:`);
+                    for (const k of keys) {
+                        this.logToPairing(`${k} : ${zo[k]}`)
+                    }
                 }
-                this.zbController.configure(this.getZigbeeOptions(message.zigbeeOptions));
+                this.zbController.configure(this.getZigbeeOptions(zo));
                 response.status = await this.doConnect(true);
                 if (!response.status) response.error = { message: 'Unable to start the Zigbee Network. Please check the previous messages.'}
-                this.sendTo(from, command, response, callback);
+                return response;
             }
             catch (error) {
-                this.sendTo(from, command, { status:false, error }, callback);
+                return { status:false, error };
             }
         }
         else try {
             await this.zbController.stopHerdsman();
-            this.sendTo(from, command, { status:true }, callback);
+            return { status:true };
         } catch (error) {
-            this.sendTo(from, command, { status:true, error }, callback);
+            return { status:true, error };
         }
     }
 
     async doConnect(noReconnect) {
+
         let debugversion = '';
         try {
             const DebugIdentify = require('./debugidentify');
@@ -625,7 +639,7 @@ class Zigbee extends utils.Adapter {
                 const model = entity.mapped ? entity.mapped.model : entity.device.modelID;
                 const idx = devicesFromObjects.indexOf(device.ieeeAddr);
                 if (idx > -1) devicesFromObjects.splice(idx, 1);
-                this.stController.updateDev(device.ieeeAddr.substr(2), model, model, () =>
+                this.stController.updateDev(zbIdorIeeetoAdId(this.adapter, device.ieeeAddr, false), model, model, () =>
                     this.stController.syncDevStates(device, model));
             }
             else (this.log.warn('resolveEntity returned no entity'));
@@ -643,25 +657,29 @@ class Zigbee extends utils.Adapter {
     }
 
 
+    /*
     async checkIfModelUpdate(entity) {
         const model = entity.mapped ? entity.mapped.model : entity.device.modelID;
         const device = entity.device;
-        const devId = device.ieeeAddr.substr(2);
+        const devId = zbIdorIeeetoAdId(this.adapter, device.ieeeAddr, false);//device.ieeeAddr.substr(2);
 
         const obj = await this.getObjectAsync(devId);
         if (obj && obj.common.type !== model) {
-            await this.stController.deleteObj(devId);
+            // await this.stController.deleteObj(devId);
             await this.stController.updateDev(devId, model, model);
             await this.stController.syncDevStates(device, model);
+            await this.stController.deleteOrphanedDeviceStates();
         }
     }
+    */
 
     acknowledgeState(deviceId, model, stateDesc, value) {
-        const stateId = (model === 'group' ?
+        const stateId = `${zbIdorIeeetoAdId(this, deviceId, true)}.${stateDesc.id}`;
+        /*const stateId = (model === 'group' ?
             `${this.namespace}.group_${deviceId}.${stateDesc.id}` :
-            `${this.namespace}.${deviceId.replace('0x', '')}.${stateDesc.id}`);
+            `${this.namespace}.${deviceId.replace('0x', '')}.${stateDesc.id}`); */
         if (value === undefined) try {
-            this.getState(stateId, (err, state) => { if (!err && state.hasOwnProperty('val')) this.setState(stateId,  state.val, true)});
+            this.getState(stateId, (err, state) => { if (!err && state?.hasOwnProperty('val')) this.setState(stateId,  state.val, true)});
         }
         catch (error) {
             this.log.warn(`Error acknowledging ${stateId} without value: ${error && error.message ? error.message : 'no reason given'}`);
@@ -691,13 +709,13 @@ class Zigbee extends utils.Adapter {
         }
         await this.stController.AddModelFromHerdsman(entity.device, model)
         if (dev) {
-            this.getObject(dev.ieeeAddr.substr(2), (err, obj) => {
+            this.getObject(zbIdorIeeetoAdId(this.adapter, dev.ieeeAddr, false), (err, obj) => {
                 if (!obj) {
                     const model = (entity.mapped) ? entity.mapped.model : entity.device.modelID;
                     if (this.debugActive) this.log.debug(`new device ${dev.ieeeAddr} ${dev.networkAddress} ${model} `);
 
                     this.logToPairing(`New device joined '${dev.ieeeAddr}' model ${model}`, true);
-                    this.stController.updateDev(dev.ieeeAddr.substr(2), model, model, () =>
+                    this.stController.updateDev(zbIdorIeeetoAdId(this.adapter, dev.ieeeAddr, false), model, model, () =>
                         this.stController.syncDevStates(dev, model));
                 }
                 else if (this.debugActive) this.log.debug(`Device ${safeJsonStringify(entity)} rejoined, no new device`);
@@ -708,7 +726,7 @@ class Zigbee extends utils.Adapter {
     leaveDevice(ieeeAddr) {
         if (this.debugActive) this.log.debug(`Leave device event: ${ieeeAddr}`);
         if (ieeeAddr) {
-            const devId = ieeeAddr.substr(2);
+            const devId = zbIdorIeeetoAdId(this.adapter, ieeeAddr, false);
             if (this.debugActive) this.log.debug(`Delete device ${devId} from iobroker.`);
             this.stController.deleteObj(devId);
         }
@@ -808,6 +826,7 @@ class Zigbee extends utils.Adapter {
             dbDir: dbDir,
             dbPath: 'shepherd.db',
             backupPath: 'nvbackup.json',
+            localConfigPath: 'LocalOverrides.json',
             disableLed: this.config.disableLed,
             disablePing: (this.config.pingCluster=='off'),
             transmitPower: this.config.transmitPower,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iobroker.zigbee",
-  "version": "3.1.5",
+  "version": "3.2.0",
   "author": {
     "name": "Kirov Ilya",
     "email": "kirovilya@gmail.com"
@@ -29,7 +29,7 @@
     "uri-js": "^4.4.1",
     "typescript": "^5.9.2",
     "zigbee-herdsman": "^6.0.0",
-    "zigbee-herdsman-converters": "25.31.0"
+    "zigbee-herdsman-converters": "^25.37.0"
   },
   "description": "Zigbee devices",
   "devDependencies": {
@@ -39,12 +39,10 @@
     "@alcalzone/release-script-plugin-manual-review": "^3.7.0",
     "@iobroker/testing": "^5.1.1",
     "chai": "^5.2.1",
-    "chai-as-promised": "^7.1.1",
     "eslint": "^9.36.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-prettier": "^5.5.4",
     "mixin-deep": "^2.0.1",
-    "mocha": "^11.7.1",
     "@iobroker/dev-server": "^0.7.8"
   },
   "homepage": "https://github.com/ioBroker/ioBroker.zigbee",