iobroker.zigbee2mqtt 0.2.0 → 2.1.0

package/lib/check.js

@@ -0,0 +1,36 @@
+function checkConfig(config, log) {
+	const checkAPIOptions = {
+		legacy_api_enabled: config.advanced.legacy_api != false,
+		legacy_availability_payload_enabled: config.advanced.legacy_availability_payload != false,
+		device_legacy_enabled: config.device_options.legacy != false
+	};
+
+	if (Object.values(checkAPIOptions).filter(x => x == true).length > 0) {
+		log.error('===================================================');
+		log.error('===================================================');
+		if (checkAPIOptions.legacy_api_enabled == true) {
+			log.error('Legacy api is activated, so the adapter can not work correctly!!!');
+			log.error('Please add the following lines to your Zigbee2MQTT configuration.yaml:');
+			log.error('legacy_api: false');
+			log.error('');
+		}
+		if (checkAPIOptions.legacy_availability_payload_enabled == true) {
+			log.error('Legacy Availability Payload is activated, thus the adapter cannot represent the availability of the devices!!!');
+			log.error('Please add the following lines to your Zigbee2MQTT configuration.yaml:');
+			log.error('legacy_availability_payload: false');
+			log.error('');
+		}
+		if (checkAPIOptions.device_legacy_enabled == true) {
+			log.error('Device Legacy Payload is activated, therefore the adapter may process the states of the devices correctly!!!');
+			log.error('Please add the following lines to your Zigbee2MQTT configuration.yaml:');
+			log.error('device_options:');
+			log.error(' legacy: false');
+		}
+		log.error('===================================================');
+		log.error('===================================================');
+	}
+}
+
+module.exports = {
+	checkConfig: checkConfig,
+};

package/lib/colors.js

@@ -453,6 +453,8 @@ function NamedColorToRGB(name) {
 	return { r: 0, g: 128, b: 255 };
 }
 
-exports.NamedColorToRGB = NamedColorToRGB;
-exports.NamedCOlorToRGBString = NamedColorToRGBstring;
-exports.ParseColor = ParseColor;
+module.exports = {
+	NamedColorToRGB,
+	NamedColorToRGBstring,
+	ParseColor,
+};

package/lib/deviceController.js

@@ -0,0 +1,234 @@
+const states = require('./states').states;
+const defineDeviceFromExposes = require('./exposes').defineDeviceFromExposes;
+const utils = require('./utils');
+const colors = require('./colors.js');
+const rgb = require('./rgb.js');
+const createCache = {};
+
+class DeviceController {
+	constructor(adapter, deviceCache, groupCache, config) {
+		this.adapter = adapter;
+		this.groupCache = groupCache;
+		this.deviceCache = deviceCache;
+		this.config = config;
+	}
+
+	async createDeviceDefinitions(exposes) {
+		utils.clearArray(this.deviceCache);
+		for (const expose of exposes) {
+			if (expose.definition != null) {
+				// search for scenes in the endpoints and build them into an array
+				let scenes = [];
+				for (const key in expose.endpoints) {
+					if (expose.endpoints[key].scenes) {
+						scenes = scenes.concat(expose.endpoints[key].scenes);
+					}
+				}
+				// if the device is already present in the cache, remove it
+				this.removeDeviceByIeee(this.deviceCache, expose.ieee_address);
+				defineDeviceFromExposes(this.deviceCache, expose.friendly_name, expose.ieee_address, expose.definition, expose.power_source, scenes, this.config);
+			}
+		}
+	}
+
+
+	async defineGroupDevice(groupID, ieee_address, scenes) {
+		const newDevice = {
+			id: groupID,
+			ieee_address: ieee_address,
+			icon: undefined,
+			states: [
+				states.state,
+				states.brightness,
+				//states.color,
+				states.brightness_move,
+				states.colortemp_move,
+			],
+		};
+
+		const color = {
+			id: 'color',
+			prop: 'color',
+			name: 'Color',
+			icon: undefined,
+			role: 'level.color.rgb',
+			write: true,
+			read: true,
+			type: 'string',
+			setter: (value) => {
+				let xy = [0, 0];
+				const rgbcolor = colors.ParseColor(value);
+				xy = rgb.rgb_to_cie(rgbcolor.r, rgbcolor.g, rgbcolor.b);
+				return {
+					x: xy[0],
+					y: xy[1]
+				};
+			},
+			getter: payload => {
+				if (payload.color_mode != 'xy' && this.config.colorTempSyncColor == false) {
+					return undefined;
+				}
+				if (payload.color && payload.color.x && payload.color.y) {
+					const colorval = rgb.cie_to_rgb(payload.color.x, payload.color.y);
+					return '#' + utils.decimalToHex(colorval[0]) + utils.decimalToHex(colorval[1]) + utils.decimalToHex(colorval[2]);
+				} else {
+					return undefined;
+				}
+			},
+		};
+
+		// @ts-ignore
+		newDevice.states.push(color);
+
+		const colortemp = {
+			id: 'colortemp',
+			prop: 'color_temp',
+			name: 'Color temperature',
+			icon: undefined,
+			role: 'level.color.temperature',
+			write: true,
+			read: true,
+			type: 'number',
+			min: this.config.useKelvin == true ? utils.miredKelvinConversion(500) : 150,
+			max: this.config.useKelvin == true ? utils.miredKelvinConversion(150) : 500,
+			unit: this.config.useKelvin == true ? 'K' : 'mired',
+			setter: (value) => {
+				return utils.toMired(value);
+			},
+			getter: (payload) => {
+				if (payload.color_mode != 'color_temp') {
+					return undefined;
+				}
+				if (this.config.useKelvin == true) {
+					return utils.miredKelvinConversion(payload.color_temp);
+				} else {
+					return payload.color_temp;
+				}
+			},
+		};
+
+		// @ts-ignore
+		newDevice.states.push(colortemp);
+
+		// Create buttons for scenes
+		for (const scene of scenes) {
+			const sceneSate = {
+				id: `scene_${scene.id}`,
+				prop: `scene_recall`,
+				name: scene.name,
+				icon: undefined,
+				role: 'button',
+				write: true,
+				read: true,
+				type: 'boolean',
+				setter: (value) => (value) ? scene.id : undefined
+			};
+			// @ts-ignore
+			newDevice.states.push(sceneSate);
+		}
+
+		// if the device is already present in the cache, remove it
+		this.removeDeviceByIeee(this.groupCache, ieee_address);
+		this.groupCache.push(newDevice);
+	}
+
+	async createGroupDefinitions(exposes) {
+		utils.clearArray(this.groupCache);
+		for (const expose of exposes) {
+			await this.defineGroupDevice(expose.friendly_name, `group_${expose.id}`, expose.scenes);
+		}
+	}
+
+	async createOrUpdateDevices() {
+		for (const device of this.groupCache.concat(this.deviceCache)) {
+			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,
+					},
+
+					native: {}
+				};
+
+				if (!device.ieee_address.includes('group_')) {
+					deviceObj.common.statusStates = {
+						onlineId: `${this.adapter.name}.${this.adapter.instance}.${device.ieee_address}.available`
+					};
+				}
+
+				//@ts-ignore
+				await this.adapter.extendObjectAsync(device.ieee_address, deviceObj);
+				createCache[device.ieee_address] = deviceObj;
+			}
+
+			// Here it is checked whether the scenes match the current data from z2m.
+			// If necessary, scenes are automatically deleted from ioBroker.
+			const sceneStates = await this.adapter.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.adapter.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);
+					await this.adapter.extendObjectAsync(`${device.ieee_address}.${state.id}`, {
+						type: 'state',
+						common: iobState,
+						native: {},
+					});
+					createCache[device.ieee_address][state.id] = state.name;
+				}
+			}
+		}
+	}
+
+	async renameDeviceInCache(messageObj) {
+		const renamedDevice = this.groupCache.concat(this.deviceCache).find(x => x.id == messageObj.payload.data.from);
+		if (renamedDevice) {
+			renamedDevice.id = messageObj.payload.data.to;
+		}
+	}
+
+	async processRemoveEvent(messageObj) {
+		if (messageObj.payload && messageObj.payload.type == 'device_leave') {
+			this.adapter.setStateAsync(`${messageObj.payload.data.ieee_address}.available`, false, true);
+			this.adapter.extendObject(`${messageObj.payload.data.ieee_address}`, { common: { name: 'Device removed!', } });
+		}
+	}
+
+	removeDeviceByIeee(devices, ieee_address) {
+		const idx = devices.findIndex(x => x.ieee_address == ieee_address);
+		if (idx > -1) {
+			devices.splice(idx, 1);
+		}
+	}
+
+	async copyAndCleanStateObj(state) {
+		const iobState = { ...state };
+		const blacklistedKeys = [
+			'setter',
+			'setterOpt',
+			'getter',
+			'setattr',
+			'readable',
+			'writable',
+			'isOption',
+			'inOptions',
+			'isEvent',
+		];
+		for (const blacklistedKey of blacklistedKeys) {
+			delete iobState[blacklistedKey];
+		}
+		return iobState;
+	}
+}
+
+module.exports = {
+	DeviceController
+};

package/lib/exposes.js

@@ -7,6 +7,8 @@ const rgb = require('./rgb');
 const utils = require('./utils');
 const colors = require('./colors');
 
+const blacklistSimulatedBrightness = ['MFKZQ01LM'];
+
 function genState(expose, role, name, desc) {
 	let state;
 	const readable = true; //expose.access > 0;
@@ -36,8 +38,7 @@ function genState(expose, role, name, desc) {
 
 			if (readable) {
 				state.getter = (payload) => (payload[propName] === (expose.value_on || 'ON'));
-			}
-			else {
+			} else {
 				state.getter = (_payload) => (undefined);
 			}
 
@@ -119,7 +120,7 @@ function genState(expose, role, name, desc) {
 	return state;
 }
 
-function createFromExposes(deviceID, ieee_address, definitions, power_source, scenes, useKelvin) {
+function createFromExposes(deviceID, ieee_address, definitions, power_source, scenes, config) {
 	const states = [];
 	// make the different (set and get) part of state is updatable if different exposes is used for get and set
 	// as example:
@@ -159,8 +160,7 @@ function createFromExposes(deviceID, ieee_address, definitions, power_source, sc
 			}
 
 			return states.push(state);
-		}
-		else {
+		} else {
 
 			if ((state.readable) && (!states[stateExists].readable)) {
 				states[stateExists].read = state.read;
@@ -190,8 +190,7 @@ function createFromExposes(deviceID, ieee_address, definitions, power_source, sc
 						}
 						delete states[stateExists].prop;
 					}
-				}
-				else if (state.hasOwnProperty('prop')) {
+				} else if (state.hasOwnProperty('prop')) {
 					states[stateExists].prop = state.prop;
 				}
 				states[stateExists].readable = true;
@@ -218,16 +217,14 @@ function createFromExposes(deviceID, ieee_address, definitions, power_source, sc
 				// or remove it
 				if (((!state.hasOwnProperty('isOption')) || (state.isOptions === false)) && (states[stateExists].hasOwnProperty('isOption'))) {
 					delete states[stateExists].isOption;
-				}
-				else {
+				} else {
 					states[stateExists].isOption = state.isOption;
 				}
 
 				// use new `setattr` or `prop` as `setattr`
 				if (state.hasOwnProperty('setattr')) {
 					states[stateExists].setattr = state.setattr;
-				}
-				else if (state.hasOwnProperty('prop')) {
+				} else if (state.hasOwnProperty('prop')) {
 					states[stateExists].setattr = state.prop;
 				}
 
@@ -320,22 +317,24 @@ function createFromExposes(deviceID, ieee_address, definitions, power_source, sc
 								write: true,
 								read: true,
 								type: 'number',
-								min: undefined, //useKelvin == true ? expose.value_min : utils.miredKelvinConversion(expose.value_min),
-								max: undefined, //useKelvin == true ? expose.value_min : utils.miredKelvinConversion(expose.value_max),
-								unit: useKelvin == true ? 'K' : 'mired',
+								min: config.useKelvin == true ? utils.miredKelvinConversion(prop.value_max) : prop.value_min,
+								max: config.useKelvin == true ? utils.miredKelvinConversion(prop.value_min) : prop.value_max,
+								unit: config.useKelvin == true ? 'K' : 'mired',
 								setter: (value) => {
 									return utils.toMired(value);
 								},
-								setterOpt: (_value, options) => {
-									const hasTransitionTime = options && options.hasOwnProperty('transition_time');
-									const transitionTime = hasTransitionTime ? options.transition_time : 0;
-									return { ...options, transition: transitionTime };
-								},
+								// setterOpt: (_value, options) => {
+								// 	const hasTransitionTime = options && options.hasOwnProperty('transition_time');
+								// 	const transitionTime = hasTransitionTime ? options.transition_time : 0;
+								// 	return { ...options, transition: transitionTime };
+								// },
 								getter: (payload) => {
-									if (useKelvin == true) {
-										return utils.miredKelvinConversion(payload.color_temp);
+									if (payload.color_mode != 'color_temp') {
+										return undefined;
 									}
-									else {
+									if (config.useKelvin == true) {
+										return utils.miredKelvinConversion(payload.color_temp);
+									} else {
 										return payload.color_temp;
 									}
 								},
@@ -368,12 +367,10 @@ function createFromExposes(deviceID, ieee_address, definitions, power_source, sc
 									};
 
 								},
-								setterOpt: (_value, options) => {
-									const hasTransitionTime = options && options.hasOwnProperty('transition_time');
-									const transitionTime = hasTransitionTime ? options.transition_time : 0;
-									return { ...options, transition: transitionTime };
-								},
 								getter: payload => {
+									if (payload.color_mode != 'xy' && config.colorTempSyncColor == false) {
+										return undefined;
+									}
 									if (payload.color && payload.color.hasOwnProperty('x') && payload.color.hasOwnProperty('y')) {
 										const colorval = rgb.cie_to_rgb(payload.color.x, payload.color.y);
 										return '#' + utils.decimalToHex(colorval[0]) + utils.decimalToHex(colorval[1]) + utils.decimalToHex(colorval[2]);
@@ -576,6 +573,10 @@ function createFromExposes(deviceID, ieee_address, definitions, power_source, sc
 							state = statesDefs.temperature;
 							break;
 
+						case 'device_temperature':
+							state = statesDefs.device_temperature;
+							break;
+
 						case 'humidity':
 							state = statesDefs.humidity;
 							break;
@@ -596,6 +597,24 @@ function createFromExposes(deviceID, ieee_address, definitions, power_source, sc
 							state = statesDefs.load_power;
 							break;
 
+						case 'current':
+							state = statesDefs.load_current;
+							break;
+
+						case 'voltage':
+							state = statesDefs.voltage;
+							if (power_source == 'Battery') {
+								state = statesDefs.battery_voltage;
+							}
+							if (expose.unit == 'mV') {
+								state.getter = payload => payload.voltage / 1000;
+							}
+							break;
+
+						case 'energy':
+							state = statesDefs.energy;
+							break;
+
 						default:
 							state = genState(expose);
 							break;
@@ -622,7 +641,6 @@ function createFromExposes(deviceID, ieee_address, definitions, power_source, sc
 							if (hasHold && hasRelease && actionName.includes('release')) continue;
 							// is hold state ?
 							if (hasHold && hasRelease && actionName.includes('hold')) {
-								const releaseActionName = actionName.replace('hold', 'release');
 								state = {
 									id: actionName.replace(/\*/g, ''),
 									prop: 'action',
@@ -631,8 +649,20 @@ function createFromExposes(deviceID, ieee_address, definitions, power_source, sc
 									role: 'button',
 									write: false,
 									read: true,
+									def: false,
 									type: 'boolean',
-									getter: payload => (payload.action === actionName) ? true : (payload.action === releaseActionName) ? false : undefined,
+									getter: (payload) => {
+										if (payload.action === actionName) {
+											return true;
+										}
+										if (payload.action === actionName.replace('hold', 'release')) {
+											return false;
+										}
+										if (payload.action === `${actionName}_release`) {
+											return false;
+										}
+										return undefined;
+									},
 								};
 							} else {
 								state = {
@@ -644,12 +674,30 @@ function createFromExposes(deviceID, ieee_address, definitions, power_source, sc
 									write: false,
 									read: true,
 									type: 'boolean',
-									getter: payload => (payload.action === actionName) ? true : undefined,
+									def: false,
 									isEvent: true,
+									getter: payload => (payload.action === actionName) ? true : undefined,
 								};
 							}
 							pushToStates(state, expose.access);
 						}
+						if (!blacklistSimulatedBrightness.includes(definitions.model)) {
+							pushToStates({
+								id: 'simulated_brightness',
+								prop: 'brightness',
+								name: 'Simulated brightness',
+								icon: undefined,
+								role: 'level.dimmer',
+								write: true,
+								read: true,
+								type: 'number',
+								unit: '%',
+								def: 0,
+								getter: payload => {
+									return utils.bulbLevelToAdapterLevel(payload.brightness);
+								},
+							}, 1);
+						}
 						state = null;
 						break;
 					}
@@ -730,13 +778,14 @@ function createFromExposes(deviceID, ieee_address, definitions, power_source, sc
 						case 'running_mode':
 							pushToStates(statesDefs.climate_running_mode, prop.access);
 							break;
-						default: {
-							if (prop.name.includes('heating_setpoint')) {
-								pushToStates(genState(prop, 'level.temperature'), prop.access);
-							} else {
-								pushToStates(genState(prop), prop.access);
+						default:
+							{
+								if (prop.name.includes('heating_setpoint')) {
+									pushToStates(genState(prop, 'level.temperature'), prop.access);
+								} else {
+									pushToStates(genState(prop), prop.access);
+								}
 							}
-						}
 							break;
 					}
 				}
@@ -769,13 +818,11 @@ function createFromExposes(deviceID, ieee_address, definitions, power_source, sc
 						st.getter = payload => {
 							if ((payload.hasOwnProperty(expose.property)) && (payload[expose.property] !== null) && payload[expose.property].hasOwnProperty(prop.property)) {
 								return !isNaN(payload[expose.property][prop.property]) ? payload[expose.property][prop.property] : undefined;
-							}
-							else {
+							} else {
 								return undefined;
 							}
 						};
-					}
-					else {
+					} else {
 						st.getter = _payload => { return undefined; };
 					}
 					pushToStates(st, prop.access);
@@ -819,15 +866,13 @@ function createFromExposes(deviceID, ieee_address, definitions, power_source, sc
 	return newDevice;
 }
 
-function defineDeviceFromExposes(devices, deviceID, ieee_address, definitions, power_source, scenes, useKelvin) {
-	// if the device is already present in the cache, remove it
-	utils.removeDeviceByIeee(devices, ieee_address);
+function defineDeviceFromExposes(devices, deviceID, ieee_address, definitions, power_source, scenes, config) {
 	if (definitions.hasOwnProperty('exposes')) {
-		const newDevice = createFromExposes(deviceID, ieee_address, definitions, power_source, scenes, useKelvin);
+		const newDevice = createFromExposes(deviceID, ieee_address, definitions, power_source, scenes, config);
 		devices.push(newDevice);
 	}
 }
 
 module.exports = {
 	defineDeviceFromExposes: defineDeviceFromExposes,
-};
+};

package/lib/messages.js

@@ -0,0 +1,39 @@
+async function adapterInfo(config, log) {
+	log.info('================================= Adapter Config =================================');
+	log.info(`|| Zigbee2MQTT Frontend Scheme: ${config.webUIScheme}`);
+	log.info(`|| Zigbee2MQTT Frontend Server: ${config.webUIServer}`);
+	log.info(`|| Zigbee2MQTT Frontend Port: ${config.webUIPort}`);
+	log.info(`|| Zigbee2MQTT Connection Type: ${config.connectionType}`);
+	if (config.connectionType == 'ws') {
+		log.info(`|| Zigbee2MQTT Websocket Server: ${config.wsServerIP}`);
+		log.info(`|| Zigbee2MQTT Websocket Port: ${config.wsServerPort}`);
+		log.info(`|| Zigbee2MQTT Websocket Dummy MQTT-Server: ${config.dummyMqtt ? 'activated' : 'deactivated'}`);
+		if (config.dummyMqtt == true) {
+			log.info(`|| Zigbee2MQTT Dummy MQTT IP-Bind: ${config.mqttServerIPBind}`);
+			log.info(`|| Zigbee2MQTT Dummy MQTT Port: ${config.mqttServerPort}`);
+		}
+	} else if (config.connectionType == 'exmqtt') {
+		log.info(`|| Zigbee2MQTT Externanl MQTT Server: ${config.externalMqttServerIP}`);
+		log.info(`|| Zigbee2MQTT Externanl MQTT Port: ${config.externalMqttServerPort}`);
+	} else if (config.connectionType == 'intmqtt') {
+		log.info(`|| Zigbee2MQTT Internal MQTT IP-Bind: ${config.mqttServerIPBind}`);
+		log.info(`|| Zigbee2MQTT Internal MQTT Port: ${config.mqttServerPort}`);
+	}
+	log.info(`|| Zigbee2MQTT Debug Log: ${config.debugLogEnabled ? 'activated' : 'deactivated'}`);
+	log.info(`|| Proxy Zigbee2MQTT Logs to ioBroker Logs: ${config.proxyZ2MLogs ? 'activated' : 'deactivated'}`);
+	log.info(`|| Use Kelvin: ${config.useKelvin ? 'yes' : 'no'}`);
+	log.info('==================================================================================');
+}
+
+async function zigbee2mqttInfo(payload, log) {
+	log.info('============================ Zigbee2MQTT Information =============================');
+	log.info(`|| Zigbee2MQTT Version: ${payload.version} `);
+	log.info(`|| Coordinator type: ${payload.coordinator.type} Version: ${payload.coordinator.meta.revision} Serial: ${payload.config.serial.port}`);
+	log.info(`|| Network panid ${payload.network.pan_id} channel: ${payload.network.channel} ext_pan_id: ${payload.network.extended_pan_id}`);
+	log.info('==================================================================================');
+}
+
+module.exports = {
+	adapterInfo,
+	zigbee2mqttInfo,
+};

package/lib/mqttServerController.js

@@ -0,0 +1,42 @@
+const core = require('@iobroker/adapter-core');
+const Aedes = require('aedes');
+const net = require('net');
+
+
+class MqttServerController {
+	constructor(adapter) {
+		this.adapter = adapter;
+	}
+
+	async createMQTTServer() {
+		try {
+			const NedbPersistence = require('aedes-persistence-nedb');
+			const db = new NedbPersistence({ path: `${core.getAbsoluteInstanceDataDir(this.adapter)}/mqttData`, prefix: '' });
+			// @ts-ignore
+			const aedes = Aedes({ persistence: db });
+			const mqttServer = net.createServer(aedes.handle);
+			mqttServer.listen(this.adapter.config.mqttServerPort, this.adapter.config.mqttServerIPBind, () => {
+				this.adapter.log.info(`Statring MQTT-Server on IP ${this.adapter.config.mqttServerIPBind} and Port ${this.adapter.config.mqttServerPort}`);
+			});
+		} catch (err) {
+			this.adapter.log.error(err);
+		}
+	}
+
+	async createDummyMQTTServer() {
+		try {
+			// @ts-ignore
+			const aedes = Aedes();
+			const mqttServer = net.createServer(aedes.handle);
+			mqttServer.listen(this.adapter.config.mqttServerPort, this.adapter.config.mqttServerIPBind, () => {
+				this.adapter.log.info(`Statring DummyMQTT-Server on IP ${this.adapter.config.mqttServerIPBind} and Port ${this.adapter.config.mqttServerPort}`);
+			});
+		} catch (err) {
+			this.adapter.log.error(err);
+		}
+	}
+}
+
+module.exports = {
+	MqttServerController
+};