iobroker.zigbee2mqtt 0.1.0

package/lib/utils.js

@@ -0,0 +1,131 @@
+/**
+ * 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
+}
+
+/**
+ * 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
+}
+
+function bytesArrayToWordArray(ba) {
+	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;
+}
+
+function miredKelvinConversion(t) {
+	return (1000000 / t).toFixed();
+}
+
+/**
+ * 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;
+
+	while (hex.length < padding) {
+		hex = `0${hex}`;
+	}
+
+	return hex;
+}
+
+function getZbId(adapterDevId) {
+	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
+}
+
+function sanitizeImageParameter(parameter) {
+	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;
+}
+
+function removeDeviceByIeee(devices, ieee_address) {
+	const idx = devices.findIndex(x => x.ieee_address == ieee_address);
+	if (idx > -1) {
+		devices.splice(idx, 1);
+	}
+}
+function clearArray(array) {
+	while (array.length > 0) {
+		array.pop();
+	}
+}
+
+exports.bulbLevelToAdapterLevel = bulbLevelToAdapterLevel;
+exports.adapterLevelToBulbLevel = adapterLevelToBulbLevel;
+exports.bytesArrayToWordArray = bytesArrayToWordArray;
+exports.toMired = toMired;
+exports.miredKelvinConversion = miredKelvinConversion;
+exports.decimalToHex = decimalToHex;
+exports.getZbId = getZbId;
+exports.getAdId = getAdId;
+exports.removeDeviceByIeee = removeDeviceByIeee;
+exports.getDeviceIcon = getDeviceIcon;
+exports.clearArray = clearArray;

package/main.js

@@ -0,0 +1,504 @@
+'use strict';
+
+/*
+ * Created with @iobroker/create-adapter v2.2.1
+ */
+
+// The adapter-core module gives you access to the core ioBroker functions
+// you need to create an adapter
+const core = require('@iobroker/adapter-core');
+const WebSocket = require('ws');
+const defineDeviceFromExposes = require('./lib/exposes').defineDeviceFromExposes;
+const defineGroupDevice = require('./lib/groups').defineGroupDevice;
+const clearArray = require('./lib/utils').clearArray;
+let wsClient;
+let adapter;
+let createDevicesOrReady = false;
+const incStatsQueue = [];
+const createCache = {};
+// eslint-disable-next-line prefer-const
+let deviceCache = [];
+// eslint-disable-next-line prefer-const
+let groupCache = [];
+const lastSeenCache = {};
+let ping;
+let pingTimeout;
+let autoRestartTimeout;
+const wsHeartbeatIntervall = 5000;
+const restartTimeout = 1000;
+const deviceAvailableTimeout = 10 * 60; // 10 Minutes
+const batteryDeviceAvailableTimeout = 24 * 60 * 60; // 24 Hours
+const checkAvailableInterval = 30 * 1000; // 10 Seconds
+let debugLogEnabled;
+let proxyZ2MLogsEnabled;
+let checkAvailableTimout;
+
+class Zigbee2mqtt extends core.Adapter {
+
+	constructor(options) {
+		super({
+			...options,
+			name: 'zigbee2mqtt',
+		});
+		this.on('ready', this.onReady.bind(this));
+		this.on('stateChange', this.onStateChange.bind(this));
+		this.on('unload', this.onUnload.bind(this));
+	}
+
+	async onReady() {
+		// Initialize your adapter here
+		adapter = this;
+		this.log.info(`Zigbee2MQTT Frontend Server: ${this.config.server}`);
+		this.log.info(`Zigbee2MQTT Frontend Port: ${this.config.port}`);
+		this.log.info(`Zigbee2MQTT Debug Log: ${this.config.debugLogEnabled ? 'activated' : 'deactivated'}`);
+		this.log.info(`Proxy Zigbee2MQTT Logs to ioBroker Logs: ${this.config.proxyZ2MLogs ? 'activated' : 'deactivated'}`);
+
+		this.setStateAsync('info.connection', false, true);
+		this.createWsClient(this.config.server, this.config.port);
+
+		debugLogEnabled = this.config.debugLogEnabled;
+		proxyZ2MLogsEnabled = this.config.proxyZ2MLogs;
+	}
+
+	async createWsClient(server, port) {
+		try {
+			wsClient = new WebSocket(`ws://${server}:${port}/api`);
+			wsClient.on('open', () => {
+				this.logDebug('Websocket connectet');
+				// Set connection state
+				this.setState('info.connection', true, true);
+				this.log.info('Connect to server over websocket connection.');
+				// Send ping to server
+				this.sendPingToServer();
+				// Start Heartbeat
+				this.wsHeartbeat();
+				// Start CheckAvailableTimer
+				this.checkAvailableTimer();
+			});
+			wsClient.on('pong', () => {
+				//this.logDebug('Receive pong from server');
+				this.wsHeartbeat();
+			});
+			// On Close
+			wsClient.on('close', () => {
+				this.setState('info.connection', false, true);
+				this.log.warn('Websocket disconnectet');
+				clearTimeout(ping);
+				clearTimeout(pingTimeout);
+
+				if (wsClient.readyState === WebSocket.CLOSED) {
+					this.autoRestart();
+				}
+			});
+
+			wsClient.on('message', (message) => { this.messageParse(message); });
+			wsClient.on('error', (err) => { adapter.logDebug(err); });
+		} catch (err) {
+			this.logDebug(err);
+		}
+	}
+
+	async sendPingToServer() {
+		//this.logDebug('Send ping to server');
+		wsClient.ping();
+		ping = setTimeout(() => {
+			this.sendPingToServer();
+		}, wsHeartbeatIntervall);
+	}
+
+	async wsHeartbeat() {
+		clearTimeout(pingTimeout);
+		pingTimeout = setTimeout(() => {
+			this.logDebug('Websocked connection timed out');
+			wsClient.terminate();
+			clearTimeout(checkAvailableTimout);
+		}, wsHeartbeatIntervall + 1000);
+	}
+
+	async autoRestart() {
+		this.log.warn(`Start try again in ${restartTimeout / 1000} seconds...`);
+		autoRestartTimeout = setTimeout(() => {
+			this.onReady();
+		}, restartTimeout);
+	}
+
+	async messageParse(message) {
+		const messageObj = JSON.parse(message);
+
+		switch (messageObj.topic) {
+			case 'bridge/config':
+				break;
+			case 'bridge/info':
+				break;
+			case 'bridge/state':
+				break;
+			case 'bridge/devices':
+				// As long as we are busy creating the devices, the states are written to the queue.
+				createDevicesOrReady = false;
+				await this.createDeviceDefinitions(deviceCache, messageObj.payload);
+				await this.createOrUpdateDevices(deviceCache);
+				createDevicesOrReady = true;
+
+				// Now process all entries in the states queue
+				while (incStatsQueue.length > 0) {
+					this.processDeviceMessage(incStatsQueue.shift());
+				}
+				break;
+			case 'bridge/groups':
+				await this.createGroupDefinitions(groupCache, messageObj.payload);
+				await this.createOrUpdateDevices(groupCache);
+				break;
+			case 'bridge/event':
+				break;
+			case 'bridge/extensions':
+				break;
+			case 'bridge/logging':
+				if (proxyZ2MLogsEnabled == true) {
+					this.proxyZ2MLogs(messageObj);
+				}
+				break;
+			case 'bridge/response/networkmap':
+				break;
+			case 'bridge/response/touchlink/scan':
+				break;
+			case 'bridge/response/touchlink/identify':
+				break;
+			case 'bridge/response/touchlink/factory_reset':
+				break;
+			default:
+				// States
+				{
+					if (!messageObj.topic.includes('/')) {
+						// As long as we are busy creating the devices, the states are written to the queue.
+						if (createDevicesOrReady == false) {
+							incStatsQueue[incStatsQueue.length] = messageObj;
+							break;
+						}
+						this.processDeviceMessage(messageObj);
+					}
+				}
+				break;
+		}
+	}
+
+	async processDeviceMessage(messageObj) {
+		this.logDebug(`processDeviceMessage -> messageObj: ${JSON.stringify(messageObj)}`);
+		// Is payload present?
+		if (messageObj.payload == '') {
+			return;
+		}
+
+		const device = deviceCache.find(x => x.id == messageObj.topic);
+		if (device) {
+			this.logDebug(`processDeviceMessage -> device: ${JSON.stringify(device)}`);
+			try {
+				// The state available must not be considered for the cacheLastSeen
+				// Groups must not be considered for the cacheLastSeen
+				if (messageObj.payload.available == undefined && !device.ieee_address.startsWith('group_')) {
+					await this.cacheLastSeen(device, messageObj);
+				}
+				this.setDeviceState(messageObj, device);
+				this.checkAvailable(device.ieee_address);
+
+			} catch (error) {
+				adapter.log.error(error);
+			}
+		}
+		else {
+			adapter.log.warn(`Device: ${messageObj.topic} not found`);
+		}
+	}
+
+	async cacheLastSeen(device, messageObj) {
+		this.logDebug(`cacheLastSeen -> device: ${JSON.stringify(device)}`);
+		this.logDebug(`cacheLastSeen -> messageObj: ${JSON.stringify(messageObj)}`);
+		if (messageObj.payload.last_seen) {
+			lastSeenCache[device.ieee_address] = new Date(messageObj.payload.last_seen).getTime();
+		} else {
+			lastSeenCache[device.ieee_address] = new Date().getTime();
+		}
+		this.logDebug(`cacheLastSeen -> deviceLastSeenCache: ${JSON.stringify(lastSeenCache)}`);
+	}
+
+	async checkAvailableTimer() {
+		checkAvailableTimout = setTimeout(async () => {
+			await this.checkAvailable(null);
+			this.checkAvailableTimer();
+		}, checkAvailableInterval);
+	}
+
+	async checkAvailable(ieee_address) {
+		this.logDebug(`checkAvailable -> ieee_address: ${ieee_address}`);
+		let checkList = {};
+		if (ieee_address) {
+			checkList[ieee_address] = null;
+		}
+		else {
+			checkList = lastSeenCache;
+		}
+
+		for (const ieee_address in checkList) {
+			const device = deviceCache.find(x => x.ieee_address == ieee_address);
+
+			if (!device) {
+				continue;
+			}
+
+			const isBatteryDevice = device.power_source == 'Battery' ? true : false;
+			const offlineTimeout = isBatteryDevice ? batteryDeviceAvailableTimeout : deviceAvailableTimeout;
+			const diffSec = Math.round((new Date().getTime() - lastSeenCache[ieee_address]) / 1000);
+			const available = diffSec < offlineTimeout;
+
+			this.logDebug(`checkAvailable -> device.id: ${device.id}, available: ${available}, diffSec: ${diffSec}, isBatteryDevice: ${isBatteryDevice}`);
+
+			if (device.available == null || device.available != available) {
+				this.logDebug(`checkAvailable -> device.id: ${device.id}, available: ${available}, diffSec: ${diffSec}, isBatteryDevice: ${isBatteryDevice}`);
+				device.available = available;
+				const messageObj = {
+					topic: device.id,
+					payload: {
+						available: available,
+					}
+				};
+
+				this.processDeviceMessage(messageObj);
+			}
+		}
+	}
+
+	async setDeviceState(messageObj, device) {
+
+		for (const [key, value] of Object.entries(messageObj.payload)) {
+			this.logDebug(`setDeviceState -> key: ${key}`);
+			this.logDebug(`setDeviceState -> value: ${JSON.stringify(value)}`);
+
+			let states;
+			if (key == 'action') {
+				states = device.states.filter(x => (x.prop && x.prop == key) && x.id == value);
+			} else {
+				states = device.states.filter(x => (x.prop && x.prop == key) || x.id == key);
+			}
+			this.logDebug(`setDeviceState -> states: ${JSON.stringify(states)}`);
+
+			for (const state of states) {
+				if (!state) {
+					continue;
+				}
+				const stateName = `${device.ieee_address}.${state.id}`;
+
+				if (state.getter) {
+					this.setState(stateName, state.getter(messageObj.payload), true);
+				}
+				else {
+					this.setState(stateName, value, true);
+				}
+			}
+		}
+	}
+
+	async createDeviceDefinitions(cache, exposes) {
+		clearArray(cache);
+		for (const expose of exposes) {
+			if (expose.definition != null) {
+				await defineDeviceFromExposes(cache, expose.friendly_name, expose.ieee_address, expose.definition, expose.power_source);
+			}
+		}
+	}
+
+	async createGroupDefinitions(cache, exposes) {
+		clearArray(cache);
+		for (const expose of exposes) {
+			await defineGroupDevice(cache, expose.friendly_name, `group_${expose.id}`, expose.scenes);
+		}
+	}
+
+	async createOrUpdateDevices(cache) {
+		for (const device of cache) {
+			const deviceName = device.id == device.ieee_address ? '' : device.id;
+			if (!createCache[device.ieee_address] || createCache[device.ieee_address].common.name != deviceName) {
+				const deviceObj = {
+					type: 'device',
+					common: {
+						name: deviceName,
+						statusStates: {
+							onlineId: `${this.name}.${this.instance}.${device.ieee_address}.available`
+						},
+					},
+
+					native: {}
+				};
+				//@ts-ignore
+				await this.extendObjectAsync(device.ieee_address, deviceObj);
+				createCache[device.ieee_address] = deviceObj;
+			}
+
+			// Special handling for groups, here it is checked whether the scenes match the current data from z2m.
+			// If necessary, scenes are automatically deleted from ioBroker.
+			if (device.ieee_address.startsWith('group_')) {
+				const sceneStates = await this.getStatesAsync(`${device.ieee_address}.scene_*`);
+				const sceneIDs = Object.keys(sceneStates);
+				for (const sceneID of sceneIDs) {
+					const stateID = sceneID.split('.')[3];
+					if (device.states.find(x => x.id == stateID) == null) {
+						this.delObject(sceneID);
+					}
+				}
+			}
+
+			for (const state of device.states) {
+				if (!createCache[device.ieee_address][state.id] || createCache[device.ieee_address][state.id].name != state.name) {
+					const iobState = await this.copyAndCleanStateObj(state);
+					this.logDebug(`Orig. state: ${JSON.stringify(state)}`);
+					this.logDebug(`Cleaned. state: ${JSON.stringify(iobState)}`);
+
+
+
+					await this.extendObjectAsync(`${device.ieee_address}.${state.id}`, {
+						type: 'state',
+						common: iobState,
+						native: {},
+					});
+					createCache[device.ieee_address][state.id] = state.name;
+				}
+			}
+		}
+		this.subscribeWritableStates();
+	}
+
+	async copyAndCleanStateObj(state) {
+		const iobState = { ...state };
+		const blacklistedKeys = [
+			'setter',
+			'setterOpt',
+			'getter',
+			'setattr',
+			'readable',
+			'writable',
+			'isOption',
+			'inOptions'
+		];
+		for (const blacklistedKey of blacklistedKeys) {
+			delete iobState[blacklistedKey];
+		}
+		return iobState;
+	}
+
+	async subscribeWritableStates() {
+		await this.unsubscribeObjectsAsync('*');
+		for (const device of deviceCache) {
+			for (const state of device.states) {
+				if (state.write == true) {
+					this.subscribeStatesAsync(`${device.ieee_address}.${state.id}`);
+				}
+			}
+		}
+	}
+
+	async createZ2MMessage(id, state) {
+
+		const splitedID = id.split('.');
+
+		if (splitedID.length < 4) {
+			this.log.warn(`state ${id} not valid`);
+			return;
+		}
+
+		const ieee_address = splitedID[2];
+		const stateName = splitedID[3];
+
+		const device = deviceCache.find(d => d.ieee_address == ieee_address);
+
+		if (!device) {
+			return;
+		}
+
+		const deviceState = device.states.find(s => s.id == stateName);
+
+		if (!deviceState) {
+			return;
+		}
+
+		let stateVal = state.val;
+		if (deviceState.setter) {
+			stateVal = deviceState.setter(state.val);
+		}
+
+
+		let stateID = deviceState.id;
+		if (deviceState.prop) {
+			stateID = deviceState.prop;
+		}
+
+		let topic = `${device.ieee_address}/set`;
+		if (device.ieee_address.includes('group_')) {
+			topic = `${device.id}/set`;
+		}
+
+		const controlObj = {
+			payload: {
+				[stateID]: stateVal
+			},
+			topic: topic
+		};
+		// set stats with role 'button' always immediately to ack = true, because these are not reported back by Zigbee2MQTT
+		if (deviceState.role == 'button') {
+			this.setState(id, state, true);
+		}
+
+		return JSON.stringify(controlObj);
+	}
+
+	async proxyZ2MLogs(messageObj) {
+		this.logDebug(`proxyZ2MLogs -> messageObj: ${JSON.stringify(messageObj)}`);
+
+		const logLevel = messageObj.payload.level;
+		const logMessage = messageObj.payload.message;
+
+		switch (logLevel) {
+			case 'debug':
+			case 'info':
+			case 'error':
+				this.log[logLevel](logMessage);
+				break;
+			case 'warning':
+				this.log.warn(logMessage);
+				break;
+		}
+	}
+
+	async logDebug(message) {
+		if (debugLogEnabled == true) {
+			this.log.debug(message);
+		}
+	}
+
+	onUnload(callback) {
+		try {
+			clearTimeout(ping);
+			clearTimeout(pingTimeout);
+			clearTimeout(autoRestartTimeout);
+			clearTimeout(checkAvailableTimout);
+			callback();
+		} catch (e) {
+			callback();
+		}
+	}
+
+	async onStateChange(id, state) {
+		if (state && state.ack == false) {
+			const message = await this.createZ2MMessage(id, state);
+			wsClient.send(message);
+		}
+	}
+}
+
+if (require.main !== module) {
+	// Export the constructor in compact mode
+	/**
+	 * @param {Partial<core.AdapterOptions>} [options={}]
+	 */
+	module.exports = (options) => new Zigbee2mqtt(options);
+} else {
+	// otherwise start the instance directly
+	new Zigbee2mqtt();
+}

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "iobroker.zigbee2mqtt",
+  "version": "0.1.0",
+  "description": "Zigbee2MQTT adapter for ioBroker",
+  "author": {
+    "name": "Dennis Rathjen",
+    "email": "dennis.rathjen@outlook.de"
+  },
+  "homepage": "https://github.com/o0shojo0o/ioBroker.zigbee2mqtt",
+  "license": "MIT",
+  "keywords": [
+    "ioBroker",
+    "template",
+    "Smart Home",
+    "home automation"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/o0shojo0o/ioBroker.zigbee2mqtt.git"
+  },
+  "dependencies": {
+    "@alcalzone/release-script-plugin-iobroker": "^3.5.9",
+    "@alcalzone/release-script-plugin-license": "^3.5.9",
+    "@iobroker/adapter-core": "^2.6.6",
+    "ws": "^8.9.0"
+  },
+  "devDependencies": {
+    "@alcalzone/release-script": "^3.5.9",
+    "@iobroker/adapter-dev": "^1.1.0",
+    "@iobroker/testing": "^4.1.0",
+    "@tsconfig/node14": "^1.0.3",
+    "@types/chai": "^4.3.3",
+    "@types/chai-as-promised": "^7.1.5",
+    "@types/mocha": "^10.0.0",
+    "@types/node": "^18.7.23",
+    "@types/proxyquire": "^1.3.28",
+    "@types/sinon": "^10.0.13",
+    "@types/sinon-chai": "^3.2.8",
+    "chai": "^4.3.6",
+    "chai-as-promised": "^7.1.1",
+    "eslint": "^8.24.0",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-plugin-prettier": "^4.2.1",
+    "mocha": "^10.0.0",
+    "prettier": "^2.7.1",
+    "proxyquire": "^2.1.3",
+    "sinon": "^14.0.0",
+    "sinon-chai": "^3.7.0",
+    "typescript": "~4.8.4"
+  },
+  "main": "main.js",
+  "files": [
+    "admin{,/!(src)/**}/!(tsconfig|tsconfig.*|.eslintrc).json",
+    "admin{,/!(src)/**}/*.{html,css,png,svg,jpg,js}",
+    "lib/",
+    "www/",
+    "io-package.json",
+    "LICENSE",
+    "main.js"
+  ],
+  "scripts": {
+    "test:js": "mocha --config test/mocharc.custom.json \"{!(node_modules|test)/**/*.test.js,*.test.js,test/**/test!(PackageFiles|Startup).js}\"",
+    "test:package": "mocha test/package --exit",
+    "test:integration": "mocha test/integration --exit",
+    "test": "npm run test:js && npm run test:package",
+    "check": "tsc --noEmit -p tsconfig.check.json",
+    "lint": "eslint .",
+    "translate": "translate-adapter",
+    "release": "release-script"
+  },
+  "bugs": {
+    "url": "https://github.com/o0shojo0o/ioBroker.zigbee2mqtt/issues"
+  },
+  "readmeFilename": "README.md"
+}