iobroker.smartfriends 1.1.0 → 1.2.0-alpha.1

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 Black-Thunder <glwars@aol.de>
+Copyright (c) 2025-2026 Black-Thunder <glwars@aol.de>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -20,8 +20,7 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 
-
--------------------------------------------------------------------------------
+---
 
 LoPablo/SchellenbergApi (https://github.com/LoPablo/SchellenbergApi)
 

package/README.md

@@ -33,6 +33,15 @@ The adapter establishes a direct connection to the gateway to control and query
 	Placeholder for the next version (at the beginning of the line):
 	### __WORK IN PROGRESS__
 -->
+### 1.2.0-alpha.1 (2026-01-08)
+
+- (Black-Thunder) Timeout for initial device request was increased
+- (Black-Thunder) Devices without defined device type are ignored
+
+### 1.2.0-alpha.0 (2026-01-02)
+
+- (Black-Thunder) Refactored device handling and added support for further device types
+
 ### 1.1.0 (2025-12-28)
 
 - (Black-Thunder) Refactored device handling: dynamic states, removed type whitelist, grouped devices under master ID
@@ -55,7 +64,7 @@ Special thanks und credits to [LoPablo](https://github.com/LoPablo/SchellenbergA
 
 MIT License
 
-Copyright (c) 2025 Black-Thunder <glwars@aol.de>
+Copyright (c) 2025-2026 Black-Thunder <glwars@aol.de>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/io-package.json

@@ -1,8 +1,34 @@
 {
   "common": {
     "name": "smartfriends",
-    "version": "1.1.0",
+    "version": "1.2.0-alpha.1",
     "news": {
+      "1.2.0-alpha.1": {
+        "en": "Timeout for initial device request was increased\nDevices without defined device type are ignored",
+        "de": "Timeout für erste Geräteanfrage wurde erhöht\nGeräte ohne definierten Gerätetyp werden ignoriert",
+        "ru": "Время ожидания первоначального запроса устройства было увеличено\nУстройства без определенного типа устройства игнорируются",
+        "pt": "O tempo limite para a solicitação inicial do dispositivo foi aumentado\nOs dispositivos sem tipo de dispositivo definido são ignorados",
+        "nl": "Tijdslimiet voor het eerste apparaatverzoek werd verhoogd\nApparaten zonder gedefinieerd apparaattype worden genegeerd",
+        "fr": "Le délai pour la demande initiale d'appareil a été augmenté\nLes dispositifs sans type défini sont ignorés",
+        "it": "Timeout per la richiesta iniziale del dispositivo è stato aumentato\nI dispositivi senza tipo di dispositivo definito vengono ignorati",
+        "es": "Se aumentó el tiempo para la solicitud inicial del dispositivo\nLos dispositivos sin tipo de dispositivo definido son ignorados",
+        "pl": "Zwiększono czas na początkowe żądanie urządzenia\nUrządzenia bez określonego typu urządzenia są ignorowane",
+        "uk": "Підвищено запит на початковий пристрій\nПристрої без визначеного типу пристрою ігноруються",
+        "zh-cn": "初始设备请求的超时增加\n没有定义设备类型的设备会被忽略"
+      },
+      "1.2.0-alpha.0": {
+        "en": "Refactored device handling and added support for further device types",
+        "de": "Refactored Device Handling und zusätzliche Unterstützung für weitere Gerätetypen",
+        "ru": "Рефакторированная обработка устройств и дополнительная поддержка для других типов устройств",
+        "pt": "Manipulação do dispositivo refatorizado e suporte adicional para outros tipos de dispositivo",
+        "nl": "Refactored device handling en toegevoegde ondersteuning voor andere apparaattypes",
+        "fr": "Manipulation de l'appareil refactoré et support supplémentaire pour d'autres types d'appareil",
+        "it": "Gestione del dispositivo e supporto aggiunto per ulteriori tipi di dispositivo",
+        "es": "Manejo de dispositivo refactorizado y soporte añadido para nuevos tipos de dispositivos",
+        "pl": "Zmieniona obsługa urządzenia i dodana obsługa dla innych typów urządzeń",
+        "uk": "Рефакторний пристрій обробки та додано підтримку для подальших типів пристроїв",
+        "zh-cn": "对设备类型进行重构处理并添加支持"
+      },
       "1.1.0": {
         "en": "Refactored device handling: dynamic states, removed type whitelist, grouped devices under master ID\nHandle device value updates now correctly",
         "de": "Refactored Device Handling: dynamische Zustände, entfernte Typ Whitelist, gruppierte Geräte unter Master ID\nGerätewert-Updates jetzt korrekt ausschalten",

package/lib/SchellenbergBridge.js

@@ -12,6 +12,7 @@ const SmartSocketFactory = require("./comunication/SmartSocketFactory");
 const CommonDefines = require("./helpers/CommonDefines");
 const DeviceManager = require("./devices/DeviceManager");
 const { SchellenbergMasterDevice } = require("./devices/SchellenbergMasterDevice");
+const { getDeviceCapabilities } = require("./devices/DeviceKindCapabilities");
 
 class SchellenbergBridge {
 	constructor(adapter) {
@@ -63,7 +64,7 @@ class SchellenbergBridge {
 				this.compatibilityConfigurationVersion,
 				this.languageTranslationVersion,
 			);
-			const response = await this.socket.sendAndRecieveCommand(command, this.loginResponse.sessionID);
+			const response = await this.socket.sendAndReceiveCommand(command, this.loginResponse.sessionID);
 
 			if (!response?.response) {
 				return;
@@ -170,25 +171,34 @@ class SchellenbergBridge {
 
 			// 2️⃣ MasterDevices anlegen
 			for (const [masterId, childDevices] of Object.entries(devicesByMaster)) {
-				const masterName = childDevices[0].masterDeviceName || childDevices[0].deviceName;
+				const masterName = (childDevices[0].masterDeviceName || childDevices[0].deviceName).replace(
+					/\${|}/g,
+					"",
+				);
 				const masterDevice = new SchellenbergMasterDevice(this.adapter, masterId, masterName, []);
 
 				// 3️⃣ Child-Devices unter Master anlegen
 				for (const child of childDevices) {
-					// Nur Devices mit definierbaren Control-States
-					const hasSwitching = child.definition.deviceType?.switchingValues?.length;
-					const isPosition = child.definition.deviceType?.kind === commonDefines.AdapterStateIDs.Position;
+					// Nur Devices mit definierbaren States
+					this.adapter.log.debug(
+						`Getting device capabilites from definition: ${JSON.stringify(child.definition)}`,
+					);
+					const capabilities = getDeviceCapabilities(child.definition);
 
-					if (!hasSwitching && !isPosition) {
+					if (!capabilities.shouldBeCreated) {
 						this.adapter.log.debug(
-							`Skipping device ${child.deviceName} (${child.deviceDesignation}) – no definable control states found`,
+							`Skipping device ${child.deviceName} (${child.deviceDesignation}) – no definable states found`,
 						);
 						continue;
+					} else {
+						this.adapter.log.debug(
+							`Device ${child.deviceID}: kind=${child.definition.deviceType.kind}, capabilities=${JSON.stringify(capabilities)}`,
+						);
 					}
 
 					const schellenbergDevice = await this.deviceManager.createDevice({
 						id: child.deviceID,
-						name: child.deviceName,
+						name: child.deviceName.replace(/\${|}/g, ""),
 						deviceType: child.deviceTypClient ?? child.definition.deviceType?.kind ?? "unknown",
 						designation: child.deviceDesignation,
 						definition: child.definition,
@@ -391,7 +401,7 @@ class SchellenbergBridge {
 
 	sendAndReceiveCommand(command) {
 		if (this.socket && this.loginResponse && this.loginResponse.sessionID) {
-			return this.socket.sendAndRecieveCommand(command, this.loginResponse.sessionID);
+			return this.socket.sendAndReceiveCommand(command, this.loginResponse.sessionID);
 		}
 
 		this.adapter.log.error("Login to the gateway was not successful yet. Ignoring command.");

package/lib/comunication/CommandFactory.js

@@ -70,7 +70,7 @@ exports.LoginCommand = LoginCommand;
 
 class allNewInfoCommand extends JSONCommand.default {
 	constructor(timestamp, compatibilityConfigurationVersion, languageTranslationVersion) {
-		super("getAllNewInfos");
+		super("getAllNewInfos", 15000); // higher timeout as this command might take longer to receive a response
 		this.timestamp = timestamp;
 		this.compatibilityConfigurationVersion = compatibilityConfigurationVersion;
 		this.languageTranslationVersion = languageTranslationVersion;

package/lib/comunication/SmartSocket.js

@@ -169,16 +169,24 @@ class SmartSocket {
 	//sends command and waits for receive in the promise queue of the message handler
 	//don't know if the output socket of the gateway is in-order, so maybe there needs
 	//to be some checking
-	sendAndRecieveCommand(command, sessionkey) {
-		const localPromise = new Deferred.default(this.adapter, (resolve, reject) => {
-			if (this.internalSocket && command) {
-				this.adapter.log.debug(`Send and receive JSON: ${command.toString(sessionkey)}`);
-				this.internalSocket.write(command.toString(sessionkey));
-				this.internalSocket.write("\n");
-			} else {
-				reject();
-			}
-		});
+	sendAndReceiveCommand(command, sessionkey) {
+		const timeout = command.timeout ?? 5000; // default timeout is 5 sec
+
+		const localPromise = new Deferred.default(
+			this.adapter,
+			(resolve, reject) => {
+				if (this.internalSocket && command) {
+					this.adapter.log.debug(
+						`Send and receive JSON (timeout: ${timeout}ms): ${command.toString(sessionkey)}`,
+					);
+					this.internalSocket.write(command.toString(sessionkey));
+					this.internalSocket.write("\n");
+				} else {
+					reject();
+				}
+			},
+			timeout,
+		);
 		if (this.dataDelegate) {
 			this.dataDelegate.queueUpPromise(localPromise);
 		}

package/lib/comunication/SmartSocketFactory.js

@@ -35,7 +35,7 @@ class SmartSocketFactory {
 					.then(socket => {
 						if (socket) {
 							socket
-								.sendAndRecieveCommand(CommandFactory.default.createHeloCmd(username))
+								.sendAndReceiveCommand(CommandFactory.default.createHeloCmd(username))
 								.then(responseHelo => {
 									if (responseHelo.response) {
 										const parsedResponseHelo = HeloResponse.default.fromObject(
@@ -52,7 +52,7 @@ class SmartSocketFactory {
 												parsedResponseHelo.sessionSalt,
 											);
 											socket
-												.sendAndRecieveCommand(
+												.sendAndReceiveCommand(
 													CommandFactory.default.createLoginCommand(
 														username,
 														digest,

package/lib/comunication/comModel/JSONCommand.js

@@ -8,13 +8,16 @@
 //--------------------------------------------------
 
 class JSONCommand {
-	constructor(method) {
+	constructor(method, timeoutMs = 5000) {
 		this.command = method;
+		this.timeout = timeoutMs;
 	}
+
 	toString(sessionID) {
 		if (sessionID) {
 			this.sessionID = sessionID;
 		}
+
 		return JSON.stringify(this);
 	}
 }

package/lib/devices/DeviceCapabilityRegistry.js

@@ -0,0 +1,70 @@
+"use strict";
+
+/**
+ * Declarative registry for device kinds that provide
+ * a level-like control (position, brightness, etc.)
+ */
+const LevelKinds = {
+	position: {
+		role: "level.blind",
+		desc: "Position of the device",
+		unit: "%",
+		defaultMin: 0,
+		defaultMax: 100,
+		defaultStep: 1,
+	},
+	brightness: {
+		role: "level.dimmer",
+		desc: "Brightness of the device",
+		unit: "%",
+		defaultMin: 0,
+		defaultMax: 100,
+		defaultStep: 1,
+	},
+};
+
+/**
+ * Declarative registry for device kinds that provide
+ * a sensor state information (temperature, rain, etc.)
+ */
+const SensorKinds = {
+	thermometer: {
+		role: "level.temperature",
+		desc: "Measured temperature",
+		unit: "°C",
+		defaultMin: -90,
+		defaultMax: 60,
+		defaultStep: 0.5,
+	},
+	volume: {
+		role: "value.rain",
+		desc: "Measured rain volume",
+		unit: "mm",
+		defaultMin: 0,
+		defaultMax: 350,
+		defaultStep: 1,
+	},
+	// generic sensor kind for different types of weather sensors (e.g. atmospheric pressure, wind speed, etc.)
+	weather: {
+		role: "value",
+		desc: "Measured value",
+		unit: "",
+	},
+};
+
+/**
+ * Declarative registry for device kinds that provide
+ * an alarm information
+ */
+const AlarmKinds = {
+	failureStatus: {
+		role: "value",
+		desc: "Error code of the device",
+	},
+};
+
+module.exports = {
+	AlarmKinds,
+	LevelKinds,
+	SensorKinds,
+};

package/lib/devices/DeviceKindCapabilities.js

@@ -0,0 +1,90 @@
+"use strict";
+
+const { LevelKinds, SensorKinds, AlarmKinds } = require("./DeviceCapabilityRegistry");
+
+/**
+ * Resolves capabilities from a SmartFriends device definition
+ */
+function getDeviceCapabilities(definition) {
+	if (!definition?.deviceType) {
+		return {
+			shouldBeCreated: false,
+			hasWritableStates: false,
+			hasSwitchingValues: false,
+			hasLevel: false,
+			hasSensor: false,
+			hasAlarm: false,
+			configObj: null,
+		};
+	}
+
+	const deviceType = definition?.deviceType ?? {};
+	const kind = deviceType.kind ?? "unknown";
+	const deviceDesignation = definition?.deviceDesignation?.replace(/\${|}/g, "") ?? kind;
+	const model = deviceType.model ?? "unknown";
+
+	const switchingValues = Array.isArray(deviceType.switchingValues) ? deviceType.switchingValues : [];
+
+	const hasSwitchingValues = switchingValues.length > 0;
+	let configObj = {
+		kind,
+		name: deviceDesignation,
+	};
+
+	const levelConfig = LevelKinds[kind] ?? null;
+	const sensorConfig = (SensorKinds[kind] && model == "analog") ?? null; // only sensor type "analog" contains measurable values
+	const alarmConfig = AlarmKinds[kind] ?? null;
+
+	if (levelConfig) {
+		configObj = {
+			...configObj,
+			role: levelConfig.role,
+			desc: levelConfig.desc,
+			unit: levelConfig.unit,
+			min: deviceType.min ?? levelConfig.defaultMin,
+			max: deviceType.max ?? levelConfig.defaultMax,
+			step: deviceType.step ?? levelConfig.defaultStep,
+		};
+	} else if (sensorConfig) {
+		configObj = {
+			...configObj,
+			role: sensorConfig.role,
+			desc: sensorConfig.desc,
+			unit: sensorConfig.unit,
+			min: deviceType.min ?? sensorConfig.defaultMin,
+			max: deviceType.max ?? sensorConfig.defaultMax,
+			step: deviceType.step ?? sensorConfig.defaultStep,
+		};
+	} else if (alarmConfig) {
+		configObj = {
+			...configObj,
+			role: alarmConfig.role,
+			desc: alarmConfig.desc,
+		};
+
+		// map "textOptions" (if present) into configObj as enumerated states
+		if (deviceType.textOptions && Array.isArray(deviceType.textOptions) && deviceType.textOptions.length > 0) {
+			configObj.states = deviceType.textOptions.reduce((acc, opt) => {
+				acc[opt.value] = `${opt.state} (${opt.name.replace(/\${|}/g, "")})`;
+				return acc;
+			}, {});
+		}
+	}
+
+	return {
+		// state creation decision
+		shouldBeCreated: hasSwitchingValues || !!levelConfig || !!sensorConfig || !!alarmConfig,
+		hasWritableStates: hasSwitchingValues || !!levelConfig,
+		// metadata for builders
+		hasSwitchingValues,
+		hasLevel: !!levelConfig,
+		hasSensor: !!sensorConfig,
+		hasAlarm: !!alarmConfig,
+		// config object for state creation
+		configObj: configObj,
+	};
+}
+
+module.exports = {
+	getDeviceCapabilities,
+};

package/lib/devices/DeviceManager.js

@@ -1,4 +1,4 @@
-const { SchellenbergDevice } = require("./SchellenbergDevice");
+const SchellenbergDevice = require("./SchellenbergDevice");
 const commonDefines = require("../helpers/CommonDefines");
 const commandFactory = require("../comunication/CommandFactory");
 

package/lib/devices/SchellenbergDevice.js

@@ -1,5 +1,6 @@
 "use strict";
 
+const { getDeviceCapabilities } = require("./DeviceKindCapabilities");
 const commonDefines = require("../helpers/CommonDefines");
 
 class SchellenbergDevice {
@@ -16,6 +17,9 @@ class SchellenbergDevice {
 
 	// Creates all necessery states and channels and writes the values into the DB
 	async CreateAndSave(masterPrefix) {
+		// Dynamisch aus device.definition
+		const capabilities = getDeviceCapabilities(this.definition);
+
 		let devicePrefix = masterPrefix
 			? `${masterPrefix}.${this.id}`
 			: `${commonDefines.AdapterDatapointIDs.Devices}.${this.id}`;
@@ -83,65 +87,121 @@ class SchellenbergDevice {
 			},
 			native: {},
 		});
+
+		if (capabilities.hasSensor) {
+			await this.createSensorState(infoPrefix, capabilities.configObj);
+		}
+
+		if (capabilities.hasAlarm) {
+			await this.createAlarmState(infoPrefix, capabilities.configObj);
+		}
 		//#endregion
 
 		//#region CONTROL
-		let controlPrefix = `${devicePrefix}.${commonDefines.AdapterDatapointIDs.Control}`;
+		if (capabilities.hasWritableStates) {
+			let controlPrefix = `${devicePrefix}.${commonDefines.AdapterDatapointIDs.Control}`;
 
-		await this.adapter.setObjectNotExistsAsync(controlPrefix, {
-			type: "channel",
-			common: {
-				name: "Device control",
-			},
-			native: {},
-		});
+			await this.adapter.setObjectNotExistsAsync(controlPrefix, {
+				type: "channel",
+				common: {
+					name: "Device control",
+				},
+				native: {},
+			});
 
-		controlPrefix += ".";
+			controlPrefix += ".";
 
-		// Dynamisch aus device.definition
-		if (this.definition?.deviceType?.switchingValues) {
-			for (const stateDef of this.definition.deviceType.switchingValues) {
-				const stateId = stateDef.name
-					.replace(/\${|}/g, "") // ${On} → On
-					.replace(this.adapter.FORBIDDEN_CHARS, "")
-					.toLowerCase();
-
-				await this.adapter.setObjectNotExistsAsync(`${controlPrefix}${stateId}`, {
-					type: "state",
-					common: {
-						name: stateId,
-						type: "boolean",
-						role: "button",
-						read: false,
-						write: true,
-						def: false,
-					},
-					native: {
-						commandValue: stateDef.value,
-					},
-				});
+			if (capabilities.hasSwitchingValues) {
+				await this.createSwitchStates(controlPrefix);
 			}
-		} else if (this.definition.deviceType.kind === commonDefines.AdapterStateIDs.Position) {
-			await this.adapter.setObjectNotExistsAsync(`${controlPrefix}${commonDefines.AdapterStateIDs.Position}`, {
+
+			if (capabilities.hasLevel) {
+				await this.createLevelState(controlPrefix, capabilities.configObj);
+			}
+		}
+		//#endregion
+
+		this.adapter.log.debug(`Created and saved device ${this.id} (${this.name})`);
+	}
+
+	async createSwitchStates(statePrefix) {
+		for (const stateDef of this.definition.deviceType.switchingValues) {
+			const stateId = stateDef.name
+				.replace(/\${|}/g, "") // ${On} → On
+				.replace(this.adapter.FORBIDDEN_CHARS, "")
+				.toLowerCase();
+
+			await this.adapter.setObjectNotExistsAsync(`${statePrefix}${stateId}`, {
 				type: "state",
 				common: {
-					name: commonDefines.AdapterStateIDs.Position,
-					type: "number",
-					role: "level.blind",
-					read: true,
+					name: stateId,
+					type: "boolean",
+					role: "button",
+					read: false,
 					write: true,
-					min: this.definition.deviceType.min ?? 0,
-					max: this.definition.deviceType.max ?? 100,
-					step: this.definition.deviceType.step ?? 1,
-					unit: "%",
-					def: 0,
+					def: false,
+				},
+				native: {
+					commandValue: stateDef.value,
 				},
-				native: {},
 			});
 		}
-		//#endregion
+	}
 
-		this.adapter.log.debug(`Created and saved device ${this.id} (${this.name})`);
+	async createLevelState(statePrefix, levelConfigObj) {
+		await this.adapter.setObjectNotExistsAsync(`${statePrefix}${levelConfigObj.kind}`, {
+			type: "state",
+			common: {
+				name: levelConfigObj.kind,
+				desc: levelConfigObj.desc,
+				type: "number",
+				role: levelConfigObj.role,
+				read: true,
+				write: true,
+				min: levelConfigObj.min,
+				max: levelConfigObj.max,
+				step: levelConfigObj.step,
+				unit: levelConfigObj.unit,
+				def: 0,
+			},
+			native: {},
+		});
+	}
+
+	async createSensorState(statePrefix, sensorConfigObj) {
+		await this.adapter.setObjectNotExistsAsync(`${statePrefix}${sensorConfigObj.kind}`, {
+			type: "state",
+			common: {
+				name: sensorConfigObj.kind,
+				desc: sensorConfigObj.desc,
+				type: "number",
+				role: sensorConfigObj.role,
+				read: true,
+				write: false,
+				min: sensorConfigObj.min,
+				max: sensorConfigObj.max,
+				step: sensorConfigObj.step,
+				unit: sensorConfigObj.unit,
+				def: 0,
+			},
+			native: {},
+		});
+	}
+
+	async createAlarmState(statePrefix, alarmConfigObj) {
+		await this.adapter.setObjectNotExistsAsync(`${statePrefix}${alarmConfigObj.kind}`, {
+			type: "state",
+			common: {
+				name: alarmConfigObj.kind,
+				desc: alarmConfigObj.desc,
+				type: "number",
+				role: alarmConfigObj.role,
+				read: true,
+				write: false,
+				states: alarmConfigObj.states,
+			},
+			native: {},
+		});
 	}
 
 	// Only writes changed data into the DB
@@ -173,23 +233,44 @@ class SchellenbergDevice {
 		}
 
 		let controlPrefix = "";
+		let infoPrefix = "";
 		if (value.masterDeviceID != this.id) {
 			// Child-Device unter einem Master-Device
 			controlPrefix = `${commonDefines.AdapterDatapointIDs.Devices}.${value.masterDeviceID}.${this.id}.${commonDefines.AdapterDatapointIDs.Control}.`;
+			infoPrefix = `${commonDefines.AdapterDatapointIDs.Devices}.${value.masterDeviceID}.${this.id}.${commonDefines.AdapterDatapointIDs.Info}.`;
 		} else {
 			// Einzelnes Device
 			controlPrefix = `${commonDefines.AdapterDatapointIDs.Devices}.${this.id}.${commonDefines.AdapterDatapointIDs.Control}.`;
+			infoPrefix = `${commonDefines.AdapterDatapointIDs.Devices}.${this.id}.${commonDefines.AdapterDatapointIDs.Info}.`;
 		}
 
-		if (this.definition?.deviceType?.switchingValues) {
+		// Dynamisch aus device.definition
+		const capabilities = getDeviceCapabilities(this.definition);
+
+		if (capabilities.hasSwitchingValues) {
 			// SwitchingValues ignorieren, liefern keine Updates zurück
-		} else if (this.definition?.deviceType?.kind === commonDefines.AdapterStateIDs.Position) {
-			// Für Position → direkt setzen
-			const stateId = `${controlPrefix}${commonDefines.AdapterStateIDs.Position}`;
-			await this.adapter.setStateAsync(stateId, value.value, true);
-			this.adapter.log.debug(`Device ${this.id}: Updated position = ${value.value}`);
+			this.adapter.log.debug(`Device ${this.id}: switchingValue update ignored (value=${value.value})`);
+			return;
 		}
+
+		if (capabilities.hasLevel) {
+			await this.setDeviceStateValue(controlPrefix, capabilities.configObj, value);
+		}
+
+		if (capabilities.hasSensor) {
+			await this.setDeviceStateValue(infoPrefix, capabilities.configObj, value);
+		}
+
+		if (capabilities.hasAlarm) {
+			await this.setDeviceStateValue(infoPrefix, capabilities.configObj, value);
+		}
+	}
+
+	async setDeviceStateValue(statePrefix, configObj, value) {
+		const stateId = `${statePrefix}${configObj.kind}`;
+		await this.adapter.setStateAsync(stateId, value.value, true);
+		this.adapter.log.debug(`Device ${this.id}: Updated ${configObj.kind} = ${value.value}`);
 	}
 }
 
-exports.SchellenbergDevice = SchellenbergDevice;
+module.exports = SchellenbergDevice;

package/lib/helpers/Deferred.js

@@ -10,30 +10,38 @@
 //--------------------------------------------------
 
 class Deferred {
-	constructor(adapter, executor) {
+	constructor(adapter, executor, timeoutMs = 5000) {
 		this.adapter = adapter;
+
 		this.timeout = this.adapter.setTimeout(() => {
 			this.reject("timeout");
-		}, 5000);
+		}, timeoutMs);
+
 		this.promise = new Promise((resolve, reject) => {
 			this._resolveSelf = resolve;
 			this._rejectSelf = reject;
 		});
+
 		executor.call(this, this._resolveSelf, this._rejectSelf);
 	}
+
 	then(onfulfilled, onrejected) {
 		return this.promise.then(onfulfilled, onrejected);
 	}
+
 	catch(onrejected) {
 		return this.promise.then(onrejected);
 	}
+
 	finally(onfinally) {
 		return this.promise.finally(onfinally);
 	}
+
 	resolve(val) {
 		this.adapter.clearTimeout(this.timeout);
 		this._resolveSelf(val);
 	}
+
 	reject(reason) {
 		this.adapter.clearTimeout(this.timeout);
 		this._rejectSelf(reason);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iobroker.smartfriends",
-  "version": "1.1.0",
+  "version": "1.2.0-alpha.1",
   "description": "smartfriends",
   "author": {
     "name": "Black-Thunder",