iobroker.zigbee 1.6.6 → 1.6.15

package/lib/statescontroller.js

@@ -4,6 +4,9 @@ const EventEmitter = require('events').EventEmitter;
 const statesMapping = require('./devices');
 const getAdId = require('./utils').getAdId;
 const getZbId = require('./utils').getZbId;
+const fs = require('fs');
+var savedDeviceNames = {};
+var knownUndefinedDevices = {};
 
 
 class StatesController extends EventEmitter {
@@ -13,6 +16,21 @@ class StatesController extends EventEmitter {
         this.adapter.on('stateChange', this.onStateChange.bind(this));
         this.query_device_block = [];
         this.debugDevices = undefined;
+        let fn = adapter.expandFileName('dev_names.json');
+        this.dev_names_fn = fn.replace('.', '_');
+        this.retTimeoutHandle = null;
+        fs.readFile(this.dev_names_fn, (err, data) => {
+            if (!err) {
+                try 
+                {
+                    savedDeviceNames = JSON.parse(data);
+                } 
+                catch 
+                {
+                    savedDeviceNames = {};
+                };
+            }
+        });
     }
 
     info(message, data) {
@@ -35,6 +53,18 @@ class StatesController extends EventEmitter {
         this.adapter.sendError(error, message);
     }
 
+    retainDeviceNames()
+    {
+        clearTimeout(this.retTimeoutHandle);
+        this.retTimeoutHanlde = setTimeout(()=> {
+            fs.writeFile(this.dev_names_fn, JSON.stringify(savedDeviceNames, null, 2), (err) => {
+                if (err)
+                    this.error('error saving device names: ' + JSON.Stringify(err));
+                else
+                    this.debug('saved device names');
+        });},5000);
+    }
+
     getDebugDevices() {
         this.debugDevices = [];
         this.adapter.getState(this.adapter.namespace + '.info.debugmessages', (err, state) => {
@@ -55,8 +85,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();
@@ -91,6 +133,10 @@ class StatesController extends EventEmitter {
                 if (obj) {
                     const model = obj.common.type;
                     if (!model) return;
+                    if (obj.common.deactivated) {
+                        this.debug('State Change detected on deactivated Device - ignored');
+                        return;
+                    }
                     if (model === 'group') {
                         deviceId = parseInt(deviceId.replace('0xgroup_', ''));
                     }
@@ -116,20 +162,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 +192,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;
@@ -221,9 +280,28 @@ class StatesController extends EventEmitter {
     }
 
     renameDevice(id, newName) {
+        this.storeDeviceName(id, newName);
         this.adapter.extendObject(id, {common: {name: newName}});
     }
 
+    setDeviceActivated(id, active) {
+      this.adapter.extendObject(id, {common: {deactivated: active }})
+    }
+
+    storeDeviceName(id, name) {
+      savedDeviceNames[id.replace(`${this.adapter.namespace}.`, '')] = name;
+      this.retainDeviceNames();
+    }
+
+    verifyDeviceName(id, name) {
+      const savedId = id.replace(`${this.adapter.namespace}.`, '');
+      if (!savedDeviceNames.hasOwnProperty(savedId)) {
+        savedDeviceNames[savedId] = name;
+        this.retainDeviceNames();
+      }
+      return savedDeviceNames[savedId];
+    }
+
     deleteDeviceStates(devId, callback) {
         this.adapter.getStatesOf(devId, (err, states) => {
             if (!err && states) {
@@ -236,6 +314,15 @@ class StatesController extends EventEmitter {
             });
         });
     }
+
+    async deleteDeviceStatesAsync(devId) {
+      const states = await this.adapter.getStatesOf(devId);
+      if (states) {
+          await this.adapter.deleteState(devId, null, state._id);
+      }
+      await this.adapter.deleteDevice(devId);
+    }
+
     // eslint-disable-next-line no-unused-vars
     async deleteOrphanedDeviceStates(ieeeAddr, model, force, callback) {
         const devStates = await this.getDevStates(ieeeAddr, model);
@@ -254,7 +341,7 @@ class StatesController extends EventEmitter {
                         statename = arr[1];
                     }
                     if (commonStates.find((statedesc) => statename === statedesc.id) === undefined &&
-                        devStates.states.find((statedesc) => statename === statedesc.id) === undefined && statename != 'groups') {
+                        devStates.states.find((statedesc) => statename === statedesc.id) === undefined) {
                         if (state.common.hasOwnProperty('custom') && !force) {
                             this.info(`keeping disconnected state ${JSON.stringify(statename)} of  ${devId} `);
                         } else {
@@ -278,88 +365,127 @@ class StatesController extends EventEmitter {
     updateState(devId, name, value, common) {
         this.adapter.getObject(devId, (err, obj) => {
             if (obj) {
-                const new_common = {name: name};
-                const id = devId + '.' + name;
-                const new_name = obj.common.name;
-                if (common) {
-                    if (common.name !== undefined) {
-                        new_common.name = common.name;
-                    }
-                    if (common.type !== undefined) {
-                        new_common.type = common.type;
-                    }
-                    if (common.unit !== undefined) {
-                        new_common.unit = common.unit;
-                    }
-                    if (common.states !== undefined) {
-                        new_common.states = common.states;
-                    }
-                    if (common.read !== undefined) {
-                        new_common.read = common.read;
-                    }
-                    if (common.write !== undefined) {
-                        new_common.write = common.write;
-                    }
-                    if (common.role !== undefined) {
-                        new_common.role = common.role;
-                    }
-                    if (common.min !== undefined) {
-                        new_common.min = common.min;
-                    }
-                    if (common.max !== undefined) {
-                        new_common.max = common.max;
-                    }
-                    if (common.icon !== undefined) {
-                        new_common.icon = common.icon;
+                if (!obj.common.deactivated) {
+                    const new_common = {name: name};
+                    const id = devId + '.' + name;
+                    const new_name = obj.common.name;
+                    if (common) {
+                        if (common.name !== undefined) {
+                            new_common.name = common.name;
+                        }
+                        if (common.type !== undefined) {
+                            new_common.type = common.type;
+                        }
+                        if (common.unit !== undefined) {
+                            new_common.unit = common.unit;
+                        }
+                        if (common.states !== undefined) {
+                            new_common.states = common.states;
+                        }
+                        if (common.read !== undefined) {
+                            new_common.read = common.read;
+                        }
+                        if (common.write !== undefined) {
+                            new_common.write = common.write;
+                        }
+                        if (common.role !== undefined) {
+                            new_common.role = common.role;
+                        }
+                        if (common.min !== undefined) {
+                            new_common.min = common.min;
+                        }
+                        if (common.max !== undefined) {
+                            new_common.max = common.max;
+                        }
+                        if (common.icon !== undefined) {
+                            new_common.icon = common.icon;
+                        }
                     }
-                }
-                // check if state exist
-                this.adapter.getObject(id, (err, stobj) => {
-                    let hasChanges = false;
-                    if (stobj) {
-                        // update state - not change name and role (user can it changed)
-                        if (stobj.common.name)
-                            delete new_common.name;
-                        else
-                            new_common.name = new_name + ' ' + new_common.name;
-                        delete new_common.role;
-
-                        // check whether any common property is different
-                        if (stobj.common) {
-                            for (const property in new_common) {
-                                if (stobj.common.hasOwnProperty(property)) {
-                                    if (stobj.common[property] === new_common[property]) {
-                                        delete new_common[property];
-                                    } else {
-                                        hasChanges = true;
+                    // check if state exist
+                    this.adapter.getObject(id, (err, stobj) => {
+                        let hasChanges = false;
+                        if (stobj) {
+                            // update state - not change name and role (user can it changed)
+                            if (stobj.common.name)
+                                delete new_common.name;
+                            else
+                                new_common.name = new_name + ' ' + new_common.name;
+                            delete new_common.role;
+
+                            // check whether any common property is different
+                            if (stobj.common) {
+                                for (const property in new_common) {
+                                    if (stobj.common.hasOwnProperty(property)) {
+                                        if (stobj.common[property] === new_common[property]) {
+                                            delete new_common[property];
+                                        } else {
+                                            hasChanges = true;
+                                        }
                                     }
                                 }
                             }
+                        } else {
+                            hasChanges = true;
                         }
-                    } else {
-                        hasChanges = true;
-                    }
-
-                    // 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);
-                        });
-                    } 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));
 
-                    }
+                        // only change object when any common property has changed
+                        if (hasChanges) {
+                            this.adapter.extendObject(id, {type: 'state', common: new_common, native: {} }, () => {
+                                value !== undefined && this.setState_typed(id, value, true, (stobj) ? stobj.common.type : new_common.type);
+                            });
+                        } else if (value !== undefined) {
+                            this.setState_typed(id, value, true, stobj.common.type);
+                        }
 
-                });
+                    });
+                }
+                else this.debug(`UpdateState: Device is deactivated ${devId} ${JSON.stringify(obj)}`);
             } else {
-                this.debug(`Wrong device ${devId} ${JSON.stringify(obj)}`);
+                this.debug(`UpdateState: missing device ${devId} ${JSON.stringify(obj)}`);
             }
         });
     }
 
+    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 __dev_name = this.verifyDeviceName(dev_id, dev_name);
         const id = '' + dev_id;
         const modelDesc = statesMapping.findModel(model);
         let icon = (modelDesc && modelDesc.icon) ? modelDesc.icon : 'img/unknown.png';
@@ -368,7 +494,7 @@ class StatesController extends EventEmitter {
         this.adapter.setObjectNotExists(id, {
             type: 'device',
             // actually this is an error, so device.common has no attribute type. It must be in native part
-            common: {name: dev_name, type: model, icon: icon},
+            common: {name: __dev_name, type: model, icon: icon},
             native: {id: dev_id}
         }, () => {
             // update type and icon
@@ -377,15 +503,13 @@ class StatesController extends EventEmitter {
     }
 
     async syncDevStates(dev, model) {
-        const devId = dev.ieeeAddr.substr(2),
-            hasGroups = dev.type === 'Router';
+        const devId = dev.ieeeAddr.substr(2);
         // devId - iobroker device id
         const devStates = await this.getDevStates(dev.ieeeAddr, model);
         if (!devStates) {
             return;
         }
-        const states = statesMapping.commonStates.concat(devStates.states)
-            .concat((hasGroups) ? [statesMapping.groupsState] : []);
+        const states = statesMapping.commonStates.concat(devStates.states);
 
         for (const stateInd in states) {
             if (!states.hasOwnProperty(stateInd)) continue;
@@ -432,6 +556,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 +579,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/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

@@ -39,6 +39,7 @@ class DeviceAvailability extends BaseExtension {
         this.state = {};
         this.active_ping = true;
         this.forced_ping = true;
+        this.forcedNonPingable = {};
         this.number_of_registered_devices = 0;
         // force publish availability for new devices
         this.zigbee.on('new', (entity) => {
@@ -50,6 +51,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) {
@@ -80,6 +82,8 @@ class DeviceAvailability extends BaseExtension {
     }
 
     async registerDevicePing(device, entity) {
+        this.debug('register device Ping for ' + JSON.stringify(device.ieeeAddr));
+        this.forcedNonPingable[device.ieeeAddr] = false;
         //        this.warn(`Called registerDevicePing for '${device}' of '${entity}'`);
         if (!this.isPingable(device)) return;
         // ensure we do not already have this device in the queue
@@ -96,6 +100,14 @@ class DeviceAvailability extends BaseExtension {
             }, this.startDevicePingDelay);
     }
 
+    async deregisterDevicePing(device) {
+        this.info('deregister device Ping for deactivated device ' + JSON.stringify(device.ieeeAddr));
+        this.forcedNonPingable[device.ieeeAddr] = true;
+        if (this.timers[device.ieeeAddr]) {
+            clearTimeout(this.timers[device.ieeeAddr]);
+        }
+    }
+
     async startDevicePing() {
         //        this.warn(JSON.stringify(this));
         this.startDevicePingTimeout = null;
@@ -265,10 +277,10 @@ class DeviceAvailability extends BaseExtension {
         //    }
         }
     }
-    
+
     onZigbeeEvent(data) {
         const device = data.device;
-        if (!device) {
+        if (!device || this.forcedNonPingable[device.ieeeAddr]) {
             return;
         }
 

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', {});