iobroker.smartfriends 1.1.0-alpha.1 → 1.2.0-alpha.0

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,7 +33,11 @@ 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.1.0-alpha.1 (2025-12-28)
+### 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
 - (Black-Thunder) Handle device value updates now correctly
@@ -55,7 +59,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-alpha.1",
+    "version": "1.2.0-alpha.0",
     "news": {
+      "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",
+        "ru": "Рефакторированная обработка устройств: динамические состояния, удаленный белый список типов, сгруппированные устройства под идентификатором Master ID\nОбновления стоимости устройства теперь правильно",
+        "pt": "Manipulação do dispositivo refatorado: estados dinâmicos, lista branca do tipo removido, dispositivos agrupados sob ID mestre\nGerenciar as atualizações de valor do dispositivo agora corretamente",
+        "nl": "Refactored device handling: dynamische toestanden, verwijderd type whitelist, gegroepeerde apparaten onder master ID\nHandle apparaat waarde updates nu correct",
+        "fr": "Manipulation de l'appareil refacturé : états dynamiques, liste blanche de type enlevé, dispositifs groupés sous Master ID\nGérer les mises à jour de la valeur du périphérique maintenant correctement",
+        "it": "Movimentazione del dispositivo refattore: stati dinamici, tipo rimosso whitelist, dispositivi raggruppati sotto master ID\nMantenere gli aggiornamenti del valore del dispositivo ora correttamente",
+        "es": "Manejo de dispositivo refactorizado: estados dinámicos, lista blanca de tipo eliminado, dispositivos agrupados bajo ID maestro\nActualizaciones de valor del dispositivo manual ahora correctamente",
+        "pl": "Przekształcona obsługa urządzenia: stany dynamiczne, usunięty biały typ, zgrupowane urządzenia pod master ID\nUchwyt aktualizacji wartości urządzenia teraz poprawnie",
+        "uk": "Рефакторний пристрій обробки: динамічні стани, видалений тип білий список, вбудовані пристрої під магістр ID\nОновлення значення ручного пристрою тепер правильно",
+        "zh-cn": "重构设备处理: 动态状态, 删除类型白名单, 主 ID 下分组设备\n现在正确处理设备值更新"
+      },
       "1.1.0-alpha.1": {
         "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) {
@@ -170,25 +171,30 @@ 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
+					const capabilities = getDeviceCapabilities(child.definition);
+					this.adapter.log.debug(
+						`Device ${child.deviceID}: kind=${child.definition.deviceType.kind}, capabilities=${JSON.stringify(capabilities)}`,
+					);
 
-					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;
 					}
 
 					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,
@@ -258,11 +264,6 @@ class SchellenbergBridge {
 			`Message received: ${parsedResponse.responseMessage} (code: ${parsedResponse.responseCode})`,
 		);
 
-		if (parsedResponse.currentTimestamp) {
-			this.adapter.log.debug(`Updated timestamp to ${parsedResponse.currentTimestamp}`);
-			this.lastTimestamp = parsedResponse.currentTimestamp;
-		}
-
 		this.handleResponseCode(parsedResponse);
 	}
 

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,78 @@
+"use strict";
+
+const { LevelKinds, SensorKinds, AlarmKinds } = require("./DeviceCapabilityRegistry");
+
+/**
+ * Resolves capabilities from a SmartFriends device definition
+ */
+function getDeviceCapabilities(definition) {
+	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/package.json

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