iobroker.zigbee2mqtt 2.1.0 → 2.2.0

package/lib/statesController.js

@@ -3,136 +3,136 @@ const incStatsQueue = [];
 const timeOutCache = {};
 
 class StatesController {
-	constructor(adapter, deviceCache, groupCache, logCustomizations) {
-		this.adapter = adapter;
-		this.groupCache = groupCache;
-		this.deviceCache = deviceCache;
-		this.logCustomizations = logCustomizations;
-	}
-
-	async processDeviceMessage(messageObj) {
-		// Is payload present?
-		if (messageObj.payload == '') {
-			return;
-		}
-
-		const device = this.groupCache.concat(this.deviceCache).find(x => x.id == messageObj.topic);
-		if (device) {
-			try {
-				this.setDeviceState(messageObj, device);
-			} catch (error) {
-				this.adapter.log.error(error);
-			}
-		} else {
-			incStatsQueue[incStatsQueue.length] = messageObj;
-			this.adapter.log.debug(`Device: ${messageObj.topic} not found, queue state in incStatsQueue!`);
-		}
-	}
-
-	async setDeviceState(messageObj, device) {
-		if (this.logCustomizations.debugDevices.includes(device.ieee_address)) {
-			this.adapter.log.warn(`--->>> fromZ2M -> ${device.ieee_address} states: ${JSON.stringify(messageObj)}`);
-		}
-
-		for (const [key, value] of Object.entries(messageObj.payload)) {
-			let states;
-			if (key == 'action') {
-				states = device.states.filter(x => (x.prop && x.prop == key));
-			} else {
-				states = device.states.filter(x => (x.prop && x.prop == key) || x.id == key);
-			}
-
-			for (const state of states) {
-				if (!state) {
-					continue;
-				}
-
-				const stateName = `${device.ieee_address}.${state.id}`;
-
-				try {
-					if (state.isEvent) {
-						if (state.getter) {
-							await this.setStateWithTimeoutAsync(stateName, state.getter(messageObj.payload), 300);
-						} else {
-							await this.setStateWithTimeoutAsync(stateName, value, 300);
-						}
-					} else {
-						if (state.getter) {
-							await this.setStateChangedAsync(stateName, state.getter(messageObj.payload));
-						} else {
-							await this.setStateChangedAsync(stateName, value);
-						}
-					}
-				} catch (err) {
-					incStatsQueue[incStatsQueue.length] = messageObj;
-					this.adapter.log.debug(`Can not set ${stateName}, queue state in incStatsQueue!`);
-				}
-			}
-		}
-	}
-
-	async setStateAsync(stateName, value) {
-		if (value !== undefined) {
-			await this.adapter.setStateAsync(stateName, value, true);
-		}
-	}
-
-	async setStateChangedAsync(stateName, value) {
-		if (value !== undefined) {
-			await this.adapter.setStateChangedAsync(stateName, value, true);
-		}
-	}
-
-	async setStateWithTimeoutAsync(stateName, value, timeout) {
-		if (value !== undefined) {
-			await this.adapter.setStateAsync(stateName, value, true);
-			if (timeOutCache[stateName]) {
-				clearTimeout(timeOutCache[stateName]);
-			}
-			timeOutCache[stateName] = setTimeout(() => {
-				this.adapter.setStateAsync(stateName, !value, true);
-			}, timeout);
-		}
-	}
-
-	async processQueue() {
-		const oldIncStatsQueue = [];
-		utils.moveArray(incStatsQueue, oldIncStatsQueue);
-		while (oldIncStatsQueue.length > 0) {
-			this.processDeviceMessage(oldIncStatsQueue.shift());
-		}
-	}
-
-	async subscribeWritableStates() {
-		await this.adapter.unsubscribeObjectsAsync('*');
-		for (const device of this.groupCache.concat(this.deviceCache)) {
-			for (const state of device.states) {
-				if (state.write == true) {
-					this.adapter.subscribeStatesAsync(`${device.ieee_address}.${state.id}`);
-				}
-			}
-		}
-		this.adapter.subscribeStatesAsync('info.debugmessages');
-		this.adapter.subscribeStatesAsync('info.logfilter');
-	}
-
-	async setAllAvailableToFalse() {
-		for (const device of this.deviceCache) {
-			for (const state of device.states) {
-				if (state.id == 'available') {
-					await this.adapter.setStateChangedAsync(`${device.ieee_address}.${state.id}`, false, true);
-				}
-			}
-		}
-	}
-
-	async allTimerClear() {
-		for (const timer in timeOutCache) {
-			clearTimeout(timeOutCache[timer]);
-		}
-	}
+    constructor(adapter, deviceCache, groupCache, logCustomizations) {
+        this.adapter = adapter;
+        this.groupCache = groupCache;
+        this.deviceCache = deviceCache;
+        this.logCustomizations = logCustomizations;
+    }
+
+    processDeviceMessage(messageObj) {
+        // Is payload present?
+        if (messageObj.payload == '') {
+            return;
+        }
+
+        const device = this.groupCache.concat(this.deviceCache).find(x => x.id == messageObj.topic);
+        if (device) {
+            try {
+                this.setDeviceStateSafely(messageObj, device);
+            } catch (error) {
+                this.adapter.log.error(error);
+            }
+        } else {
+            incStatsQueue[incStatsQueue.length] = messageObj;
+            this.adapter.log.debug(`Device: ${messageObj.topic} not found, queue state in incStatsQueue!`);
+        }
+    }
+
+    async setDeviceStateSafely(messageObj, device) {
+        if (this.logCustomizations.debugDevices.includes(device.ieee_address)) {
+            this.adapter.log.warn(`--->>> fromZ2M -> ${device.ieee_address} states: ${JSON.stringify(messageObj)}`);
+        }
+
+        for (const [key, value] of Object.entries(messageObj.payload)) {
+            let states;
+            if (key == 'action') {
+                states = device.states.filter(x => (x.prop && x.prop == key));
+            } else {
+                states = device.states.filter(x => (x.prop && x.prop == key) || x.id == key);
+            }
+
+            for (const state of states) {
+                if (!state) {
+                    continue;
+                }
+
+                const stateName = `${device.ieee_address}.${state.id}`;
+
+                try {
+                    if (state.isEvent) {
+                        if (state.getter) {
+                            await this.setStateWithTimeoutAsync(stateName, state.getter(messageObj.payload), 300);
+                        } else {
+                            await this.setStateWithTimeoutAsync(stateName, value, 300);
+                        }
+                    } else {
+                        if (state.getter) {
+                            await this.setStateChangedSafelyAsync(stateName, state.getter(messageObj.payload));
+                        } else {
+                            await this.setStateChangedSafelyAsync(stateName, value);
+                        }
+                    }
+                } catch (err) {
+                    incStatsQueue[incStatsQueue.length] = messageObj;
+                    this.adapter.log.debug(`Can not set ${stateName}, queue state in incStatsQueue!`);
+                }
+            }
+        }
+    }
+
+    async setStateSafelyAsync(stateName, value) {
+        if (value !== undefined) {
+            await this.adapter.setStateAsync(stateName, value, true);
+        }
+    }
+
+    async setStateChangedSafelyAsync(stateName, value) {
+        if (value !== undefined) {
+            await this.adapter.setStateChangedAsync(stateName, value, true);
+        }
+    }
+
+    async setStateWithTimeoutAsync(stateName, value, timeout) {
+        if (value !== undefined) {
+            await this.adapter.setStateAsync(stateName, value, true);
+            if (timeOutCache[stateName]) {
+                clearTimeout(timeOutCache[stateName]);
+            }
+            timeOutCache[stateName] = setTimeout(() => {
+                this.adapter.setStateAsync(stateName, !value, true);
+            }, timeout);
+        }
+    }
+
+    processQueue() {
+        const oldIncStatsQueue = [];
+        utils.moveArray(incStatsQueue, oldIncStatsQueue);
+        while (oldIncStatsQueue.length > 0) {
+            this.processDeviceMessage(oldIncStatsQueue.shift());
+        }
+    }
+
+    async subscribeWritableStates() {
+        await this.adapter.unsubscribeObjectsAsync('*');
+        for (const device of this.groupCache.concat(this.deviceCache)) {
+            for (const state of device.states) {
+                if (state.write == true) {
+                    this.adapter.subscribeStatesAsync(`${device.ieee_address}.${state.id}`);
+                }
+            }
+        }
+        this.adapter.subscribeStatesAsync('info.debugmessages');
+        this.adapter.subscribeStatesAsync('info.logfilter');
+    }
+
+    async setAllAvailableToFalse() {
+        for (const device of this.deviceCache) {
+            for (const state of device.states) {
+                if (state.id == 'available') {
+                    await this.adapter.setStateChangedAsync(`${device.ieee_address}.${state.id}`, false, true);
+                }
+            }
+        }
+    }
+
+    async allTimerClear() {
+        for (const timer in timeOutCache) {
+            clearTimeout(timeOutCache[timer]);
+        }
+    }
 }
 
 module.exports = {
-	StatesController
+    StatesController
 };

package/lib/utils.js

@@ -2,132 +2,132 @@
  * Converts a bulb level of range [0...254] to an adapter level of range [0...100]
  */
 function bulbLevelToAdapterLevel(bulbLevel) {
-	// Convert from bulb levels [0...254] to adapter levels [0...100]:
-	// - Bulb level 0 is a forbidden value according to the ZigBee spec "ZigBee Cluster Library
-	//   (for ZigBee 3.0) User Guide", but some bulbs (HUE) accept this value and interpret this
-	//   value as "switch the bulb off".
-	// - A bulb level of "1" is the "minimum possible level" which should mean "bulb off",
-	//   but there are bulbs that do not switch off (they need "0", some IKEA bulbs are affected).
-	// - No visible difference was seen between bulb level 1 and 2 on HUE LCT012 bulbs.
-	//
-	// Conclusion:
-	// - We map adapter level "0" to the (forbidden) bulb level "0" that seems to switch all
-	//   known bulbs.
-	// - Bulb level "1" is not used, but if received nevertheless, it is converted to
-	//   adapter level "0" (off).
-	// - Bulb level range [2...254] is linearly mapped to adapter level range [1...100].
-	if (bulbLevel >= 2) {
-		// Perform linear mapping of range [2...254] to [1...100]
-		return (Math.round((bulbLevel - 2) * 99 / 252) + 1);
-	} else {
-		// The bulb is considered off. Even a bulb level of "1" is considered as off.
-		return 0;
-	} // else
+    // Convert from bulb levels [0...254] to adapter levels [0...100]:
+    // - Bulb level 0 is a forbidden value according to the ZigBee spec "ZigBee Cluster Library
+    //   (for ZigBee 3.0) User Guide", but some bulbs (HUE) accept this value and interpret this
+    //   value as "switch the bulb off".
+    // - A bulb level of "1" is the "minimum possible level" which should mean "bulb off",
+    //   but there are bulbs that do not switch off (they need "0", some IKEA bulbs are affected).
+    // - No visible difference was seen between bulb level 1 and 2 on HUE LCT012 bulbs.
+    //
+    // Conclusion:
+    // - We map adapter level "0" to the (forbidden) bulb level "0" that seems to switch all
+    //   known bulbs.
+    // - Bulb level "1" is not used, but if received nevertheless, it is converted to
+    //   adapter level "0" (off).
+    // - Bulb level range [2...254] is linearly mapped to adapter level range [1...100].
+    if (bulbLevel >= 2) {
+        // Perform linear mapping of range [2...254] to [1...100]
+        return (Math.round((bulbLevel - 2) * 99 / 252) + 1);
+    } else {
+        // The bulb is considered off. Even a bulb level of "1" is considered as off.
+        return 0;
+    } // else
 }
 
 /**
  * Converts an adapter level of range [0...100] to a bulb level of range [0...254]
  */
 function adapterLevelToBulbLevel(adapterLevel) {
-	// Convert from adapter levels [0...100] to bulb levels [0...254].
-	// This is the inverse of function bulbLevelToAdapterLevel().
-	// Please read the comments there regarding the rules applied here for mapping the values.
-	if (adapterLevel) {
-		// Perform linear mapping of range [1...100] to [2...254]
-		return (Math.round((adapterLevel - 1) * 252 / 99) + 2);
-	} else {
-		// Switch the bulb off. Some bulbs need "0" (IKEA), others "1" (HUE), and according to the
-		// ZigBee docs "1" is the "minimum possible level"... we choose "0" here which seems to work.
-		return 0;
-	} // else
+    // Convert from adapter levels [0...100] to bulb levels [0...254].
+    // This is the inverse of function bulbLevelToAdapterLevel().
+    // Please read the comments there regarding the rules applied here for mapping the values.
+    if (adapterLevel) {
+        // Perform linear mapping of range [1...100] to [2...254]
+        return (Math.round((adapterLevel - 1) * 252 / 99) + 2);
+    } else {
+        // Switch the bulb off. Some bulbs need "0" (IKEA), others "1" (HUE), and according to the
+        // ZigBee docs "1" is the "minimum possible level"... we choose "0" here which seems to work.
+        return 0;
+    } // else
 }
 
 function bytesArrayToWordArray(ba) {
-	const wa = [];
-	for (let i = 0; i < ba.length; i++) {
-		wa[(i / 2) | 0] |= ba[i] << (8 * (i % 2));
-	}
-	return wa;
+    const wa = [];
+    for (let i = 0; i < ba.length; i++) {
+        wa[(i / 2) | 0] |= ba[i] << (8 * (i % 2));
+    }
+    return wa;
 }
 
 // If the value is greater than 1000, kelvin is assumed.
 // If smaller, it is assumed to be mired.
 function toMired(t) {
-	let miredValue = t;
-	if (t > 1000) {
-		miredValue = miredKelvinConversion(t);
-	}
-	return miredValue;
+    let miredValue = t;
+    if (t > 1000) {
+        miredValue = miredKelvinConversion(t);
+    }
+    return miredValue;
 }
 
 function miredKelvinConversion(t) {
-	return Math.round(1000000 / t);
+    return Math.round(1000000 / t);
 }
 
 /**
  * Converts a decimal number to a hex string with zero-padding
  */
 function decimalToHex(decimal, padding) {
-	let hex = Number(decimal).toString(16);
-	padding = typeof (padding) === 'undefined' || padding === null ? padding = 2 : padding;
+    let hex = Number(decimal).toString(16);
+    padding = typeof (padding) === 'undefined' || padding === null ? padding = 2 : padding;
 
-	while (hex.length < padding) {
-		hex = `0${hex}`;
-	}
+    while (hex.length < padding) {
+        hex = `0${hex}`;
+    }
 
-	return hex;
+    return hex;
 }
 
 function getZbId(adapterDevId) {
-	const idx = adapterDevId.indexOf('group');
-	if (idx > 0) return adapterDevId.substr(idx + 6);
-	return '0x' + adapterDevId.split('.')[2];
+    const idx = adapterDevId.indexOf('group');
+    if (idx > 0) return adapterDevId.substr(idx + 6);
+    return '0x' + adapterDevId.split('.')[2];
 }
 
 function getAdId(adapter, id) {
-	return adapter.namespace + '.' + id.split('.')[2]; // iobroker device id
+    return adapter.namespace + '.' + id.split('.')[2]; // iobroker device id
 }
 
 function sanitizeImageParameter(parameter) {
-	const replaceByDash = [/\?/g, /&/g, /[^a-z\d\-_./:]/gi, /[/]/gi];
-	let sanitized = parameter;
-	replaceByDash.forEach((r) => sanitized = sanitized.replace(r, '-'));
-	return sanitized;
+    const replaceByDash = [/\?/g, /&/g, /[^a-z\d\-_./:]/gi, /[/]/gi];
+    let sanitized = parameter;
+    replaceByDash.forEach((r) => sanitized = sanitized.replace(r, '-'));
+    return sanitized;
 }
 
 function getDeviceIcon(definition) {
-	let icon = definition.icon;
-	if (icon) {
-		icon = icon.replace('${model}', sanitizeImageParameter(definition.model));
-	}
-	if (!icon) {
-		icon = `https://www.zigbee2mqtt.io/images/devices/${sanitizeImageParameter(definition.model)}.jpg`;
-	}
-	return icon;
+    let icon = definition.icon;
+    if (icon) {
+        icon = icon.replace('${model}', sanitizeImageParameter(definition.model));
+    }
+    if (!icon) {
+        icon = `https://www.zigbee2mqtt.io/images/devices/${sanitizeImageParameter(definition.model)}.jpg`;
+    }
+    return icon;
 }
 
 function clearArray(array) {
-	while (array.length > 0) {
-		array.pop();
-	}
+    while (array.length > 0) {
+        array.pop();
+    }
 }
 
 function moveArray(source, target) {
-	while (source.length > 0) {
-		target.push(source.shift());
-	}
+    while (source.length > 0) {
+        target.push(source.shift());
+    }
 }
 
 module.exports = {
-	bulbLevelToAdapterLevel,
-	adapterLevelToBulbLevel,
-	bytesArrayToWordArray,
-	toMired,
-	miredKelvinConversion,
-	decimalToHex,
-	getZbId,
-	getAdId,
-	getDeviceIcon,
-	clearArray,
-	moveArray,
+    bulbLevelToAdapterLevel,
+    adapterLevelToBulbLevel,
+    bytesArrayToWordArray,
+    toMired,
+    miredKelvinConversion,
+    decimalToHex,
+    getZbId,
+    getAdId,
+    getDeviceIcon,
+    clearArray,
+    moveArray,
 };

package/lib/websocketController.js

@@ -7,78 +7,78 @@ let pingTimeout;
 let autoRestartTimeout;
 
 class WebsocketController {
-	constructor(adapter) {
-		this.adapter = adapter;
-	}
+    constructor(adapter) {
+        this.adapter = adapter;
+    }
 
-	async initWsClient(server, port) {
-		try {
-			wsClient = new WebSocket(`ws://${server}:${port}/api`);
+    initWsClient() {
+        try {
+            wsClient = new WebSocket(`ws://${this.adapter.config.wsServerIP}:${this.adapter.config.wsServerPort}/api`);
 
-			wsClient.on('open', () => {
-				// Send ping to server
-				this.sendPingToServer();
-				// Start Heartbeat
-				this.wsHeartbeat();
-			});
+            wsClient.on('open', () => {
+                // Send ping to server
+                this.sendPingToServer();
+                // Start Heartbeat
+                this.wsHeartbeat();
+            });
 
-			wsClient.on('pong', () => {
-				this.wsHeartbeat();
-			});
+            wsClient.on('pong', () => {
+                this.wsHeartbeat();
+            });
 
-			wsClient.on('close', async () => {
-				clearTimeout(pingTimeout);
-				clearTimeout(ping);
+            wsClient.on('close', async () => {
+                clearTimeout(pingTimeout);
+                clearTimeout(ping);
 
-				if (wsClient.readyState === WebSocket.CLOSED) {
-					this.autoRestart();
-				}
-			});
+                if (wsClient.readyState === WebSocket.CLOSED) {
+                    this.autoRestart();
+                }
+            });
 
-			wsClient.on('message', () => { });
+            wsClient.on('message', () => { });
 
-			wsClient.on('error', (err) => { this.adapter.log.debug(err); });
+            wsClient.on('error', (err) => { this.adapter.log.debug(err); });
 
-			return wsClient;
-		} catch (err) {
-			this.adapter.log.error(err);
-		}
-	}
+            return wsClient;
+        } catch (err) {
+            this.adapter.log.error(err);
+        }
+    }
 
-	async send(message) {
-		wsClient.send(message);
-	}
+    send(message) {
+        wsClient.send(message);
+    }
 
-	async sendPingToServer() {
-		//this.logDebug('Send ping to server');
-		wsClient.ping();
-		ping = setTimeout(() => {
-			this.sendPingToServer();
-		}, wsHeartbeatIntervall);
-	}
+    sendPingToServer() {
+        //this.logDebug('Send ping to server');
+        wsClient.ping();
+        ping = setTimeout(() => {
+            this.sendPingToServer();
+        }, wsHeartbeatIntervall);
+    }
 
-	async wsHeartbeat() {
-		clearTimeout(pingTimeout);
-		pingTimeout = setTimeout(() => {
-			this.adapter.log.warn('Websocked connection timed out');
-			wsClient.terminate();
-		}, wsHeartbeatIntervall + 1000);
-	}
+    wsHeartbeat() {
+        clearTimeout(pingTimeout);
+        pingTimeout = setTimeout(() => {
+            this.adapter.log.warn('Websocked connection timed out');
+            wsClient.terminate();
+        }, wsHeartbeatIntervall + 1000);
+    }
 
-	async autoRestart() {
-		this.adapter.log.warn(`Start try again in ${restartTimeout / 1000} seconds...`);
-		autoRestartTimeout = setTimeout(() => {
-			this.adapter.onReady();
-		}, restartTimeout);
-	}
+    async autoRestart() {
+        this.adapter.log.warn(`Start try again in ${restartTimeout / 1000} seconds...`);
+        autoRestartTimeout = setTimeout(() => {
+            this.adapter.startWebsocket();
+        }, restartTimeout);
+    }
 
-	async allTimerClear() {
-		clearTimeout(pingTimeout);
-		clearTimeout(ping);
-		clearTimeout(autoRestartTimeout);
-	}
+    async allTimerClear() {
+        clearTimeout(pingTimeout);
+        clearTimeout(ping);
+        clearTimeout(autoRestartTimeout);
+    }
 }
 
 module.exports = {
-	WebsocketController
+    WebsocketController
 };