iobroker.smartfriends 1.0.1 → 1.1.0-alpha.0

package/README.md

@@ -33,6 +33,10 @@ 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.0 (2025-12-23)
+
+- (Black-Thunder) Refactored device handling: dynamic states, removed type whitelist, grouped devices under master ID
+
 ### 1.0.1 (2025-12-20)
 
 - (Black-Thunder) Increased robustness when communicating with the gateway

package/io-package.json

@@ -1,115 +1,118 @@
 {
-  "common": {
-    "name": "smartfriends",
-    "version": "1.0.1",
-    "news": {
-      "1.0.1": {
-        "en": "Increased robustness when communicating with the gateway\nAdded new option to ignore certificate errors",
-        "de": "Erhöhte Robustheit bei der Kommunikation mit dem Gateway\nNeue Option hinzugefügt, um Zertifikatsfehler zu ignorieren",
-        "ru": "Повышенная надежность при общении с шлюзом\nДобавлена новая возможность игнорировать ошибки сертификата",
-        "pt": "Maior robustez ao se comunicar com o gateway\nAdicionada nova opção para ignorar erros de certificado",
-        "nl": "Verhoogde robuustheid bij het communiceren met de gateway\nNieuwe optie toegevoegd om certificaatfouten te negeren",
-        "fr": "Une robustesse accrue lors de la communication avec la passerelle\nAjout d'une nouvelle option pour ignorer les erreurs de certificat",
-        "it": "Maggiore robustezza quando si comunica con il gateway\nAggiunta nuova opzione per ignorare gli errori del certificato",
-        "es": "Mayor robustez al comunicarse con la puerta de entrada\nNueva opción para ignorar errores de certificado",
-        "pl": "Większa odporność podczas komunikacji z bramą\nDodano nową opcję do ignorowania błędów certyfikatu",
-        "uk": "Підвищена надійність при спілкуванні з шлюзом\nДодано новий варіант ігнорувати помилки сертифіката",
-        "zh-cn": "与网关沟通时的强度提高\n添加新选项以忽略证书错误"
-      },
-      "1.0.0": {
-        "en": "initial release",
-        "de": "Erstveröffentlichung",
-        "ru": "Начальная версия",
-        "pt": "lançamento inicial",
-        "nl": "Eerste uitgave",
-        "fr": "Première version",
-        "it": "Versione iniziale",
-        "es": "Versión inicial",
-        "pl": "Pierwsze wydanie",
-        "zh-cn": "首次出版",
-        "uk": "початковий випуск"
-      }
-    },
-    "titleLang": {
-      "en": "SmartFriends",
-      "de": "SmartFriends",
-      "ru": "SmartFriends",
-      "pt": "SmartFriends",
-      "nl": "SmartFriends",
-      "fr": "SmartFriends",
-      "it": "SmartFriends",
-      "es": "SmartFriends",
-      "pl": "SmartFriends",
-      "zh-cn": "SmartFriends",
-      "uk": "SmartFriends"
-    },
-    "desc": {
-      "en": "Local control of SmartFriends gateways and connected devices without cloud access.",
-      "de": "Lokale Steuerung von SmartFriends-Gateways und angeschlossenen Geräten ohne Cloud-Anbindung.",
-      "ru": "Локальное управление шлюзами SmartFriends и подключёнными устройствами без облака.",
-      "pt": "Controle local de gateways SmartFriends e dispositivos conectados sem uso de nuvem.",
-      "nl": "Lokale aansturing van SmartFriends-gateways en aangesloten apparaten zonder cloud.",
-      "fr": "Contrôle local des passerelles SmartFriends et des appareils connectés sans cloud.",
-      "it": "Controllo locale dei gateway SmartFriends e dei dispositivi collegati senza cloud.",
-      "es": "Control local de gateways SmartFriends y dispositivos conectados sin nube.",
-      "pl": "Lokalne sterowanie bramkami SmartFriends i podłączonymi urządzeniami bez chmury.",
-      "zh-cn": "无需云服务即可本地控制 SmartFriends 网关及其连接的设备。",
-      "uk": "Локальне керування шлюзами SmartFriends і підключеними пристроями без хмари."
-    },
-    "authors": [
-      "Black-Thunder <glwars@aol.de>"
-    ],
-    "keywords": [
-      "home automation",
-      "smartfriends",
-      "schellenberg"
-    ],
-    "licenseInformation": {
-      "license": "MIT",
-      "type": "free"
-    },
-    "platform": "Javascript/Node.js",
-    "icon": "smartfriends.png",
-    "enabled": false,
-    "extIcon": "https://raw.githubusercontent.com/Black-Thunder/ioBroker.smartfriends/master/admin/smartfriends.png",
-    "readme": "https://github.com/Black-Thunder/ioBroker.smartfriends/blob/master/README.md",
-    "loglevel": "info",
-    "mode": "daemon",
-    "type": "iot-systems",
-    "compact": true,
-    "connectionType": "local",
-    "dataSource": "poll",
-    "adminUI": {
-      "config": "json"
-    },
-    "dependencies": [
-      {
-        "js-controller": ">=6.0.11"
-      }
-    ],
-    "globalDependencies": [
-      {
-        "admin": ">=7.6.17"
-      }
-    ],
-    "tier": 2
-  },
-  "encryptedNative": [
-    "smartFriendsPassword"
-  ],
-  "protectedNative": [
-    "smartFriendsPassword"
-  ],
-  "native": {
-    "smartFriendsPort": 4300,
-    "smartFriendsIP": "",
-    "smartFriendsUsername": "",
-    "smartFriendsPassword": "",
-    "smartFriendsCSymbol": "D19033i",
-    "smartFriendsShcVersion": "3.7.4",
-    "smartFriendsShApiVersion": "3.4",
-    "ignoreSslErrors": false
-  },
-  "objects": [],
-  "instanceObjects": []
+	"common": {
+		"name": "smartfriends",
+		"version": "1.1.0-alpha.0",
+		"news": {
+			"1.1.0-alpha.0": {
+				"en": "Refactored device handling: dynamic states, removed type whitelist, grouped devices under master ID",
+				"de": "Überarbeitete Geräteverwaltung: dynamische Zustände, entfernte Typ-Whitelist, gruppierte Geräte unter Master-ID",
+				"ru": "Рефакторированная обработка устройств: динамические состояния, удаленный белый список типов, сгруппированные устройства под идентификатором Master ID",
+				"pt": "Manipulação do dispositivo refatorado: estados dinâmicos, lista branca do tipo removido, dispositivos agrupados sob ID mestre",
+				"nl": "Refactored device handling: dynamische toestanden, verwijderd type whitelist, gegroepeerde apparaten onder master ID",
+				"fr": "Manipulation de l'appareil refacturé : états dynamiques, liste blanche de type enlevé, dispositifs groupés sous Master ID",
+				"it": "Movimentazione del dispositivo refattore: stati dinamici, tipo rimosso whitelist, dispositivi raggruppati sotto master ID",
+				"es": "Manejo de dispositivo refactorizado: estados dinámicos, lista blanca de tipo eliminado, dispositivos agrupados bajo ID maestro",
+				"pl": "Przekształcona obsługa urządzenia: stany dynamiczne, usunięty biały typ, zgrupowane urządzenia pod master ID",
+				"uk": "Рефакторний пристрій обробки: динамічні стани, видалений тип білий список, вбудовані пристрої під магістр ID",
+				"zh-cn": "重构设备处理: 动态状态, 删除类型白名单, 主 ID 下分组设备"
+			},
+			"1.0.1": {
+				"en": "Increased robustness when communicating with the gateway\nAdded new option to ignore certificate errors",
+				"de": "Erhöhte Robustheit bei der Kommunikation mit dem Gateway\nNeue Option hinzugefügt, um Zertifikatsfehler zu ignorieren",
+				"ru": "Повышенная надежность при общении с шлюзом\nДобавлена новая возможность игнорировать ошибки сертификата",
+				"pt": "Maior robustez ao se comunicar com o gateway\nAdicionada nova opção para ignorar erros de certificado",
+				"nl": "Verhoogde robuustheid bij het communiceren met de gateway\nNieuwe optie toegevoegd om certificaatfouten te negeren",
+				"fr": "Une robustesse accrue lors de la communication avec la passerelle\nAjout d'une nouvelle option pour ignorer les erreurs de certificat",
+				"it": "Maggiore robustezza quando si comunica con il gateway\nAggiunta nuova opzione per ignorare gli errori del certificato",
+				"es": "Mayor robustez al comunicarse con la puerta de entrada\nNueva opción para ignorar errores de certificado",
+				"pl": "Większa odporność podczas komunikacji z bramą\nDodano nową opcję do ignorowania błędów certyfikatu",
+				"uk": "Підвищена надійність при спілкуванні з шлюзом\nДодано новий варіант ігнорувати помилки сертифіката",
+				"zh-cn": "与网关沟通时的强度提高\n添加新选项以忽略证书错误"
+			},
+			"1.0.0": {
+				"en": "initial release",
+				"de": "Erstveröffentlichung",
+				"ru": "Начальная версия",
+				"pt": "lançamento inicial",
+				"nl": "Eerste uitgave",
+				"fr": "Première version",
+				"it": "Versione iniziale",
+				"es": "Versión inicial",
+				"pl": "Pierwsze wydanie",
+				"zh-cn": "首次出版",
+				"uk": "початковий випуск"
+			}
+		},
+		"titleLang": {
+			"en": "SmartFriends",
+			"de": "SmartFriends",
+			"ru": "SmartFriends",
+			"pt": "SmartFriends",
+			"nl": "SmartFriends",
+			"fr": "SmartFriends",
+			"it": "SmartFriends",
+			"es": "SmartFriends",
+			"pl": "SmartFriends",
+			"zh-cn": "SmartFriends",
+			"uk": "SmartFriends"
+		},
+		"desc": {
+			"en": "Local control of SmartFriends gateways and connected devices without cloud access.",
+			"de": "Lokale Steuerung von SmartFriends-Gateways und angeschlossenen Geräten ohne Cloud-Anbindung.",
+			"ru": "Локальное управление шлюзами SmartFriends и подключёнными устройствами без облака.",
+			"pt": "Controle local de gateways SmartFriends e dispositivos conectados sem uso de nuvem.",
+			"nl": "Lokale aansturing van SmartFriends-gateways en aangesloten apparaten zonder cloud.",
+			"fr": "Contrôle local des passerelles SmartFriends et des appareils connectés sans cloud.",
+			"it": "Controllo locale dei gateway SmartFriends e dei dispositivi collegati senza cloud.",
+			"es": "Control local de gateways SmartFriends y dispositivos conectados sin nube.",
+			"pl": "Lokalne sterowanie bramkami SmartFriends i podłączonymi urządzeniami bez chmury.",
+			"zh-cn": "无需云服务即可本地控制 SmartFriends 网关及其连接的设备。",
+			"uk": "Локальне керування шлюзами SmartFriends і підключеними пристроями без хмари."
+		},
+		"authors": ["Black-Thunder <glwars@aol.de>"],
+		"keywords": ["home automation", "smartfriends", "schellenberg"],
+		"licenseInformation": {
+			"license": "MIT",
+			"type": "free"
+		},
+		"platform": "Javascript/Node.js",
+		"icon": "smartfriends.png",
+		"enabled": false,
+		"extIcon": "https://raw.githubusercontent.com/Black-Thunder/ioBroker.smartfriends/master/admin/smartfriends.png",
+		"readme": "https://github.com/Black-Thunder/ioBroker.smartfriends/blob/master/README.md",
+		"loglevel": "info",
+		"mode": "daemon",
+		"type": "iot-systems",
+		"compact": true,
+		"connectionType": "local",
+		"dataSource": "poll",
+		"adminUI": {
+			"config": "json"
+		},
+		"dependencies": [
+			{
+				"js-controller": ">=6.0.11"
+			}
+		],
+		"globalDependencies": [
+			{
+				"admin": ">=7.6.17"
+			}
+		],
+		"tier": 2
+	},
+	"encryptedNative": ["smartFriendsPassword"],
+	"protectedNative": ["smartFriendsPassword"],
+	"native": {
+		"smartFriendsPort": 4300,
+		"smartFriendsIP": "",
+		"smartFriendsUsername": "",
+		"smartFriendsPassword": "",
+		"smartFriendsCSymbol": "D19033i",
+		"smartFriendsShcVersion": "3.7.4",
+		"smartFriendsShApiVersion": "3.4",
+		"ignoreSslErrors": false
+	},
+	"objects": [],
+	"instanceObjects": []
 }

package/lib/SchellenbergBridge.js

@@ -1,25 +1,17 @@
 "use strict";
 
-//--------------------------------------------------
-//Copyright 2020 Pascâl Hartmann
-//See LICENSE File
-//--------------------------------------------------
-//Handles incoming messages from a SmartSocket and
-//emits Events defined in helpers/Events
-//This is an exmaple Class that implements the DataDelegateInterface which is required by the Socket
-//Implement an App in this Fashion
-//--------------------------------------------------
-
 const maxRetries = 3; // number of connection retries when connection was lost
 const reconnectInterval = 10 * 1000; // time (in ms) after which a single new reconnection try should be made
 const retryInterval = 30 * 60 * 1000; // time (in ms) after which new reconnection tries should be made
 
+const commonDefines = require("./helpers/CommonDefines");
 const CommandFactory = require("./comunication/CommandFactory");
 const AllNewDeviceInfos = require("./comunication/comModel/responseBody/AllNewDeviceInfos");
 const JSONResponse = require("./comunication/comModel/JSONResponse");
 const SmartSocketFactory = require("./comunication/SmartSocketFactory");
 const CommonDefines = require("./helpers/CommonDefines");
-const DeviceManager = require("./DeviceManager");
+const DeviceManager = require("./devices/DeviceManager");
+const { SchellenbergMasterDevice } = require("./devices/SchellenbergMasterDevice");
 
 class SchellenbergBridge {
 	constructor(adapter) {
@@ -39,6 +31,7 @@ class SchellenbergBridge {
 		this.retryCounter = 0;
 		this.stopRenewal = false;
 		this.deviceManager = new DeviceManager(this.adapter);
+		this.deviceDefinitions = [];
 	}
 
 	async Connect() {
@@ -72,48 +65,128 @@ class SchellenbergBridge {
 			);
 			const response = await this.socket.sendAndRecieveCommand(command, this.loginResponse.sessionID);
 
-			if (response?.response) {
-				const parsedResponse = AllNewDeviceInfos.default.fromObject(response.response);
-				await this.processAllNewDeviceInfos(parsedResponse);
+			if (!response?.response) {
+				return;
 			}
+
+			const allNewDeviceInfosParsed = AllNewDeviceInfos.default.fromObject(response.response);
+			this.processCompatibilityConfiguration(allNewDeviceInfosParsed);
+			await this.processAllNewDeviceInfos(allNewDeviceInfosParsed);
+			this.processInitialDeviceValues(allNewDeviceInfosParsed);
 		} catch (err) {
 			this.adapter.log.error(`Connection failed: ${err.message}`);
 			this.handleDisconnect();
 		}
 	}
 
+	updateTimestamp(parsed) {
+		if (parsed.currentTimestamp) {
+			this.lastTimestamp = parsed.currentTimestamp;
+			this.adapter.log.debug(`Updated timestamp to ${this.lastTimestamp}`);
+		}
+	}
+
+	processCompatibilityConfiguration(parsed) {
+		if (this.deviceDefinitions?.length) {
+			return;
+		}
+
+		const standards = parsed.newCompatibilityConfiguration?.compatibleRadioStandards ?? [];
+		this.deviceDefinitions = [];
+
+		for (const standard of standards) {
+			for (const def of standard.compatibleDevices ?? []) {
+				if (def.deviceDesignation) {
+					this.deviceDefinitions.push(def);
+				}
+			}
+		}
+
+		this.adapter.log.debug(`Loaded ${this.deviceDefinitions.length} device definitions`);
+	}
+
+	processInitialDeviceValues(parsed) {
+		const values = parsed.newDeviceValues?.values ?? [];
+
+		for (const value of values) {
+			this.handleDeviceValue(value);
+		}
+	}
+
+	handleDeviceValue(deviceValue) {
+		if (!deviceValue || deviceValue.deviceID == null) {
+			this.adapter.log.debug("Invalid device value received, ignoring.");
+			return;
+		}
+
+		this.adapter.log.debug(`Device value update: deviceID=${deviceValue.deviceID}, value=${deviceValue.value}`);
+
+		this.deviceManager.updateDeviceValue(deviceValue);
+	}
+
 	async processAllNewDeviceInfos(response) {
 		try {
-			const newDeviceInfos = response.newDeviceInfos.values;
-			let knownDevices = 0;
+			const deviceInfos = response.newDeviceInfos?.values ?? [];
+			const createdMasters = [];
+
+			// 1️⃣ Child-Devices nach MasterID gruppieren
+			const devicesByMaster = {};
+			for (const device of deviceInfos) {
+				// Definition dynamisch zuweisen
+				device.definition = this.deviceDefinitions.find(d => d.deviceDesignation === device.deviceDesignation);
+				if (!device.definition) {
+					this.adapter.log.debug(
+						`Skipping device ${device.deviceName} (${device.deviceDesignation}) – no definition found`,
+					);
+					continue;
+				}
 
-			this.adapter.log.debug(`Received all devices:\r\n${JSON.stringify(newDeviceInfos)}`);
+				const masterId = device.masterDeviceID || device.deviceID;
+				if (!devicesByMaster[masterId]) {
+					devicesByMaster[masterId] = [];
+				}
+				devicesByMaster[masterId].push(device);
+			}
 
-			for (const device of response.newDeviceInfos.values) {
-				if (
-					device.deviceTypClient &&
-					(device.deviceTypClient.includes(CommonDefines.KnownDeviceTypes.AwningEngine.type) ||
-						device.deviceTypClient.includes(CommonDefines.KnownDeviceTypes.RollingShutter.type))
-				) {
-					knownDevices++;
-					await this.deviceManager.createDevice({
-						id: device.deviceID,
-						name: device.deviceName,
-						deviceType: device.deviceTypClient,
-						designation: device.deviceDesignation,
+			// 2️⃣ MasterDevices anlegen
+			for (const [masterId, childDevices] of Object.entries(devicesByMaster)) {
+				const masterName = childDevices[0].masterDeviceName || childDevices[0].deviceName;
+				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;
+
+					if (!hasSwitching && !isPosition) {
+						this.adapter.log.debug(
+							`Skipping device ${child.deviceName} (${child.deviceDesignation}) – no definable control states found`,
+						);
+						continue;
+					}
+
+					const schellenbergDevice = await this.deviceManager.createDevice({
+						id: child.deviceID,
+						name: child.deviceName,
+						deviceType: child.deviceTypClient ?? child.definition.deviceType?.kind ?? "unknown",
+						designation: child.deviceDesignation,
+						definition: child.definition,
+						masterPrefix: `${commonDefines.AdapterDatapointIDs.Devices}.${masterId}`, // States unter Master-Ordner
 					});
-					this.adapter.log.info(
-						`Device created: ${device.deviceName} (Type: ${device.deviceTypClient}, Device ID: ${device.deviceID})`,
-					);
-				} else {
-					this.adapter.log.debug(
-						`Unsupported device type received: ${device.deviceName} (Type: ${device.deviceTypClient}, Device ID: ${device.deviceID}). Ignoring...`,
-					);
+
+					masterDevice.childDevices.push(schellenbergDevice);
+					this.adapter.log.info(`Device created: ${child.deviceName} (ID: ${child.deviceID})`);
+				}
+
+				if (masterDevice.childDevices?.length !== 0) {
+					await masterDevice.createMasterFolder();
+					createdMasters.push(masterDevice);
 				}
 			}
 
 			this.adapter.log.info(
-				`Processed ${newDeviceInfos.length} device(s) and added ${knownDevices} supported device(s). Adapter successfully started.`,
+				`Processed ${deviceInfos.length} device(s), created ${createdMasters.length} master device(s).`,
 			);
 		} catch (error) {
 			this.adapter.log.error(`Error processing devices: ${error.message}`);
@@ -272,7 +345,7 @@ class SchellenbergBridge {
 
 	async handleLoginMessage(response) {
 		if (response.sessionID && response.hardware && response.macAddress && response.shsVersion) {
-			this.adapter.log.debug("Connection and login to gateway successful.");
+			this.adapter.log.debug(`Connection and login to gateway ${response.hardware} successful.`);
 			this.loginResponse = response;
 			this.retryCounter = 0;
 
@@ -309,14 +382,17 @@ class SchellenbergBridge {
 	}
 
 	handleUpdate(response) {
-		if (response.responseMessage) {
-			switch (response.responseMessage) {
-				case "newDeviceValue":
-					break;
-				case "newDeviceInfo":
-					break;
-				default:
-					break;
+		// new device values
+		if (response.newDeviceValues?.values?.length) {
+			for (const value of response.newDeviceValues.values) {
+				this.handleDeviceValue(value);
+			}
+		}
+
+		// new device infos (optional, für später)
+		if (response.newDeviceInfos?.values?.length) {
+			for (const device of response.newDeviceInfos.values) {
+				this.adapter.log.debug(`New device info received for deviceID=${device.deviceID}`);
 			}
 		}
 	}

package/lib/comunication/comModel/responseBody/NewCompatibilityConfiguration.js

@@ -6,11 +6,16 @@
 //--------------------------------------------------
 
 class NewCompatibilityConfiguration {
-	constructor(compatibilityConfigurationVersion) {
+	constructor(compatibilityConfigurationVersion, compatibleRadioStandards = []) {
 		this.compatibilityConfigurationVersion = compatibilityConfigurationVersion;
+		this.compatibleRadioStandards = compatibleRadioStandards;
 	}
+
 	static fromObject(object) {
-		return new NewCompatibilityConfiguration(object.compatibilityConfigurationVersion);
+		return new NewCompatibilityConfiguration(
+			object.compatibilityConfigurationVersion,
+			object.compatibleRadioStandards ?? [],
+		);
 	}
 }
 exports.default = NewCompatibilityConfiguration;

package/lib/devices/DeviceManager.js

@@ -0,0 +1,125 @@
+const { SchellenbergDevice } = require("./SchellenbergDevice");
+const commonDefines = require("../helpers/CommonDefines");
+const commandFactory = require("../comunication/CommandFactory");
+
+class DeviceManager {
+	constructor(adapter) {
+		this.adapter = adapter;
+		this.devices = new Map();
+		this.log = adapter.log;
+		this.bridge = null;
+	}
+
+	setBridge(bridge) {
+		this.bridge = bridge;
+	}
+
+	async createDevice(deviceInfo) {
+		try {
+			const device = new SchellenbergDevice(this.adapter);
+			Object.assign(device, deviceInfo);
+			await device.CreateAndSave(deviceInfo.masterPrefix);
+			this.devices.set(deviceInfo.id, device);
+			return device;
+		} catch (error) {
+			this.log.error(`Failed to create device ${deviceInfo.id}: ${error.message}`);
+			throw error;
+		}
+	}
+
+	getDevice(id) {
+		return this.devices.get(id);
+	}
+
+	getAllDevices() {
+		return Array.from(this.devices.values());
+	}
+
+	async updateDevice(id, data) {
+		const device = this.getDevice(id);
+		if (device) {
+			Object.assign(device, data);
+			await device.Update();
+			this.log.debug(`Device updated: ${id}`);
+		} else {
+			this.log.warn(`Device not found for update: ${id}`);
+		}
+	}
+
+	async deleteDevice(id) {
+		const device = this.getDevice(id);
+		if (device) {
+			await device.Delete();
+			this.devices.delete(id);
+			this.log.debug(`Device deleted: ${id}`);
+		}
+	}
+
+	async handleStateChange(id, state) {
+		try {
+			if (!state || state.ack) {
+				return;
+			}
+
+			const devicePrefix = `${this.adapter.namespace}.${commonDefines.AdapterDatapointIDs.Devices}.`;
+			const path = id.replace(devicePrefix, "");
+			const parts = path.split(".");
+
+			let childId;
+			if (parts.length === 1) {
+				// nur ein Device, kein Master
+				childId = parts[0];
+			} else if (parts.length >= 2) {
+				// Master + Child
+				childId = parts[1];
+			} else {
+				this.adapter.log.warn(`Invalid state path: ${id}`);
+				return;
+			}
+
+			const obj = await this.adapter.getObjectAsync(id);
+
+			const commandValue = typeof state.val === "number" ? state.val : obj?.native?.commandValue;
+
+			if (commandValue == null) {
+				this.adapter.log.warn(`No commandValue defined for ${id}`);
+				return;
+			}
+
+			this.adapter.log.debug(`Control triggered: device=${childId}, command=${commandValue} (state=${id})`);
+
+			await this.sendDeviceCommand(childId, commandValue);
+
+			await this.adapter.setStateAsync(id, false, true);
+		} catch (error) {
+			this.log.error(`Error in handleStateChange: ${error.responseMessage}`);
+		}
+	}
+
+	async sendDeviceCommand(deviceId, value) {
+		try {
+			if (!this.bridge) {
+				throw new Error("Bridge not initialized");
+			}
+
+			this.log.debug(`Sending value '${value}' to device ${deviceId}...`);
+
+			await this.bridge.sendAndReceiveCommand(commandFactory.default.createSetDeviceValueCmd(deviceId, value));
+		} catch (error) {
+			this.log.error(`Error in sendDeviceCommand: ${error.responseMessage}`);
+			throw error;
+		}
+	}
+
+	updateDeviceValue(deviceValue) {
+		const device = this.devices?.get(deviceValue.deviceID);
+		if (!device) {
+			this.adapter.log.debug(`Received value for unknown device ${deviceValue.deviceID}, ignoring.`);
+			return;
+		}
+
+		device.updateValue(deviceValue);
+	}
+}
+
+module.exports = DeviceManager;

package/lib/{SchellenbergDevice.js → devices/SchellenbergDevice.js}

@@ -1,29 +1,29 @@
 "use strict";
 
-const commonDefines = require("./helpers/CommonDefines");
+const commonDefines = require("../helpers/CommonDefines");
 
 class SchellenbergDevice {
 	constructor(adapter) {
 		this.adapter = adapter;
-		this.platform = null;
+		this.definition = null;
 
 		// Info
 		this.id = -1;
 		this.name = "";
 		this.deviceType = "";
 		this.designation = "";
-
-		// Control
-		this.power = false;
 	}
 
 	// Creates all necessery states and channels and writes the values into the DB
-	async CreateAndSave() {
-		const devicePrefix = `${commonDefines.AdapterDatapointIDs.Devices}.${this.id}`;
+	async CreateAndSave(masterPrefix) {
+		const devicePrefix = masterPrefix
+			? `${masterPrefix}.${this.id}`
+			: `${commonDefines.AdapterDatapointIDs.Devices}.${this.id}`;
+
 		await this.adapter.setObjectNotExistsAsync(devicePrefix, {
 			type: "channel",
 			common: {
-				name: `Device ${this.id} (${this.name})`,
+				name: this.name,
 			},
 			native: {},
 		});
@@ -85,6 +85,7 @@ class SchellenbergDevice {
 
 		//#region CONTROL
 		let controlPrefix = `${devicePrefix}.${commonDefines.AdapterDatapointIDs.Control}`;
+
 		await this.adapter.setObjectNotExistsAsync(controlPrefix, {
 			type: "channel",
 			common: {
@@ -95,98 +96,42 @@ class SchellenbergDevice {
 
 		controlPrefix += ".";
 
-		switch (this.deviceType) {
-			case commonDefines.KnownDeviceTypes.AwningEngine.type:
-				await this.adapter.setObjectNotExistsAsync(controlPrefix + commonDefines.AdapterStateIDs.MoveDown, {
+		// Dynamisch aus device.definition
+		if (this.definition?.deviceType?.switchingValues) {
+			for (const stateDef of this.definition.deviceType.switchingValues) {
+				const stateId = stateDef.name.replace(/\${|}/g, "").toLowerCase(); // ${On} → On
+				await this.adapter.setObjectNotExistsAsync(`${controlPrefix}${stateId}`, {
 					type: "state",
 					common: {
-						name: "Move downwards",
+						name: stateId,
 						type: "boolean",
-						role: "button.start",
+						role: "button",
 						read: false,
 						write: true,
 						def: false,
-						desc: "Move downwards, lower sunblind",
 					},
-					native: {},
-				});
-
-				await this.adapter.setObjectNotExistsAsync(controlPrefix + commonDefines.AdapterStateIDs.MoveUp, {
-					type: "state",
-					common: {
-						name: "Move upwards",
-						type: "boolean",
-						role: "button.start",
-						read: false,
-						write: true,
-						def: false,
-						desc: "Move upwards, retract sunblind",
+					native: {
+						commandValue: stateDef.value,
 					},
-					native: {},
 				});
-
-				await this.adapter.setObjectNotExistsAsync(controlPrefix + commonDefines.AdapterStateIDs.MoveStop, {
-					type: "state",
-					common: {
-						name: "Stop movement",
-						type: "boolean",
-						role: "button.stop",
-						read: false,
-						write: true,
-						def: false,
-						desc: "Stop movement, leave sunblind at current position",
-					},
-					native: {},
-				});
-				break;
-			case commonDefines.KnownDeviceTypes.RollingShutter.type:
-				await this.adapter.setObjectNotExistsAsync(controlPrefix + commonDefines.AdapterStateIDs.Close, {
-					type: "state",
-					common: {
-						name: "Close shutter",
-						type: "boolean",
-						role: "button.start",
-						read: false,
-						write: true,
-						def: false,
-						desc: "Close shutter",
-					},
-					native: {},
-				});
-
-				await this.adapter.setObjectNotExistsAsync(controlPrefix + commonDefines.AdapterStateIDs.Open, {
-					type: "state",
-					common: {
-						name: "Open shutter",
-						type: "boolean",
-						role: "button.start",
-						read: false,
-						write: true,
-						def: false,
-						desc: "Open shutter",
-					},
-					native: {},
-				});
-
-				await this.adapter.setObjectNotExistsAsync(controlPrefix + commonDefines.AdapterStateIDs.MoveStop, {
-					type: "state",
-					common: {
-						name: "Stop movement",
-						type: "boolean",
-						role: "button.stop",
-						read: false,
-						write: true,
-						def: false,
-						desc: "Stop shutter movement",
-					},
-					native: {},
-				});
-				break;
-			default:
-				this.adapter.log.error(
-					`No controls known for device type '${this.deviceType}' - Report this to the developer!`,
-				);
-				break;
+			}
+		} else if (this.definition.deviceType.kind === commonDefines.AdapterStateIDs.Position) {
+			await this.adapter.setObjectNotExistsAsync(`${controlPrefix}${commonDefines.AdapterStateIDs.Position}`, {
+				type: "state",
+				common: {
+					name: commonDefines.AdapterStateIDs.Position,
+					type: "number",
+					role: "level.blind",
+					read: true,
+					write: true,
+					min: this.definition.deviceType.min ?? 0,
+					max: this.definition.deviceType.max ?? 100,
+					step: this.definition.deviceType.step ?? 1,
+					unit: "%",
+					def: 0,
+				},
+				native: {},
+			});
 		}
 		//#endregion
 
@@ -213,6 +158,32 @@ class SchellenbergDevice {
 
 		this.adapter.log.debug(`Updated device data for device ${this.id} (${this.name})`);
 	}
+
+	async updateValue(value) {
+		// value: Instanz von DeviceValue
+		if (value.deviceID !== this.id) {
+			// Diese Instanz betrifft nicht dieses Device
+			return;
+		}
+
+		let controlPrefix = "";
+		if (value.masterDeviceID != this.id) {
+			// Child-Device unter einem Master-Device
+			controlPrefix = `${commonDefines.AdapterDatapointIDs.Devices}.${value.masterDeviceID}.${this.id}.${commonDefines.AdapterDatapointIDs.Control}.`;
+		} else {
+			// Einzelnes Device
+			controlPrefix = `${commonDefines.AdapterDatapointIDs.Devices}.${this.id}.${commonDefines.AdapterDatapointIDs.Control}.`;
+		}
+
+		if (this.definition?.deviceType?.switchingValues) {
+			// 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}`);
+		}
+	}
 }
 
 exports.SchellenbergDevice = SchellenbergDevice;

package/lib/devices/SchellenbergMasterDevice.js

@@ -0,0 +1,26 @@
+const commonDefines = require("../helpers/CommonDefines");
+
+class SchellenbergMasterDevice {
+	constructor(adapter, masterId, name, devices) {
+		this.adapter = adapter;
+		this.id = masterId;
+		this.name = name;
+		this.childDevices = devices; // Array von SchellenbergDevice
+	}
+
+	async createMasterFolder() {
+		const masterPrefix = `${commonDefines.AdapterDatapointIDs.Devices}.${this.id}`;
+		await this.adapter.setObjectNotExistsAsync(masterPrefix, {
+			type: "channel",
+			common: { name: this.name },
+			native: {},
+		});
+
+		// Child Devices anlegen
+		for (const child of this.childDevices) {
+			await child.CreateAndSave(masterPrefix); // MasterPrefix übergeben
+		}
+	}
+}
+
+exports.SchellenbergMasterDevice = SchellenbergMasterDevice;

package/lib/helpers/CommonDefines.js

@@ -18,23 +18,5 @@ exports.AdapterStateIDs = Object.freeze({
 	TypeClient: "typeClient",
 	Designation: "designation",
 	// devices.XXX.control
-	MoveUp: "moveUp",
-	Open: "open",
-	MoveDown: "moveDown",
-	Close: "close",
-	MoveStop: "moveStop",
-});
-
-exports.KnownDeviceTypes = Object.freeze({
-	AwningEngine: { name: "Markisenantrieb Plus", type: "${Awning}" },
-	RollingShutter: { name: "Gurtantrieb", type: "${RollingShutter}" },
-});
-
-exports.DeviceCommands = Object.freeze({
-	MoveDown: { name: "MoveDown", value: 1 },
-	Open: { name: "Open", value: 1 },
-	MoveUp: { name: "MoveUp", value: 2 },
-	Close: { name: "Close", value: 2 },
-	MoveStop: { name: "MoveStop", value: 0 },
-	UNDEF: { name: "UndefinedCommand", value: -1 },
+	Position: "position",
 });

package/main.js

@@ -8,7 +8,7 @@
 const utils = require("@iobroker/adapter-core");
 const schellenbergBridge = require("./lib/SchellenbergBridge");
 const commonDefines = require("./lib/helpers/CommonDefines");
-const DeviceManager = require("./lib/DeviceManager");
+const DeviceManager = require("./lib/devices/DeviceManager");
 
 let SchellenbergBridge = null;
 

package/package.json

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

package/lib/DeviceManager.js

@@ -1,121 +0,0 @@
-const { SchellenbergDevice } = require("./SchellenbergDevice");
-const commonDefines = require("./helpers/CommonDefines");
-const commandFactory = require("./comunication/CommandFactory");
-
-class DeviceManager {
-	constructor(adapter) {
-		this.adapter = adapter;
-		this.devices = new Map();
-		this.log = adapter.log;
-		this.bridge = null;
-
-		// Bind all methods that use 'this' context
-		this.handleStateChange = this.handleStateChange.bind(this);
-		this.sendDeviceCommand = this.sendDeviceCommand.bind(this);
-		this.mapControlCommand = this.mapControlCommand.bind(this);
-		this.createDevice = this.createDevice.bind(this);
-		this.updateDevice = this.updateDevice.bind(this);
-		this.deleteDevice = this.deleteDevice.bind(this);
-	}
-
-	setBridge(bridge) {
-		this.bridge = bridge;
-	}
-
-	async createDevice(deviceInfo) {
-		try {
-			const device = new SchellenbergDevice(this.adapter);
-			Object.assign(device, deviceInfo);
-			await device.CreateAndSave();
-			this.devices.set(deviceInfo.id, device);
-			return device;
-		} catch (error) {
-			this.log.error(`Failed to create device ${deviceInfo.id}: ${error.message}`);
-			throw error;
-		}
-	}
-
-	getDevice(id) {
-		return this.devices.get(id);
-	}
-
-	getAllDevices() {
-		return Array.from(this.devices.values());
-	}
-
-	async updateDevice(id, data) {
-		const device = this.getDevice(id);
-		if (device) {
-			Object.assign(device, data);
-			await device.Update();
-			this.log.debug(`Device updated: ${id}`);
-		} else {
-			this.log.warn(`Device not found for update: ${id}`);
-		}
-	}
-
-	async deleteDevice(id) {
-		const device = this.getDevice(id);
-		if (device) {
-			await device.Delete();
-			this.devices.delete(id);
-			this.log.debug(`Device deleted: ${id}`);
-		}
-	}
-
-	async handleStateChange(id, state) {
-		try {
-			if (!state || state.ack || state.val === false) {
-				return;
-			}
-
-			let deviceId = id.replace(`${this.adapter.namespace}.${commonDefines.AdapterDatapointIDs.Devices}.`, "");
-			deviceId = deviceId.substring(0, deviceId.indexOf("."));
-
-			const controlOption = id.substring(id.lastIndexOf(".") + 1, id.length);
-			const controlCommand = this.mapControlCommand(controlOption);
-
-			if (deviceId && controlCommand !== commonDefines.DeviceCommands.UNDEF) {
-				await this.sendDeviceCommand(deviceId, controlCommand, id);
-			}
-		} catch (error) {
-			this.log.error(`Error in handleStateChange: ${error.message}`);
-		}
-	}
-
-	mapControlCommand(controlOption) {
-		const commandMap = {
-			[commonDefines.AdapterStateIDs.MoveDown]: commonDefines.DeviceCommands.MoveDown,
-			[commonDefines.AdapterStateIDs.Close]: commonDefines.DeviceCommands.Close,
-			[commonDefines.AdapterStateIDs.MoveUp]: commonDefines.DeviceCommands.MoveUp,
-			[commonDefines.AdapterStateIDs.Open]: commonDefines.DeviceCommands.Open,
-			[commonDefines.AdapterStateIDs.MoveStop]: commonDefines.DeviceCommands.MoveStop,
-		};
-
-		const command = commandMap[controlOption];
-		if (!command) {
-			this.log.error(`Unsupported control option: ${controlOption} - Please report this to the developer!`);
-			return commonDefines.DeviceCommands.UNDEF;
-		}
-		return command;
-	}
-
-	async sendDeviceCommand(deviceId, controlCommand, stateId) {
-		try {
-			if (!this.bridge) {
-				throw new Error("Bridge not initialized");
-			}
-
-			this.log.debug(`Sending command '${controlCommand.name}' to device ${deviceId}...`);
-			await this.bridge.sendAndReceiveCommand(
-				commandFactory.default.createSetDeviceValueCmd(deviceId, controlCommand.value),
-			);
-			await this.adapter.setState(stateId, false, true);
-		} catch (error) {
-			this.log.error(`Error in sendDeviceCommand: ${error.message}`);
-			throw error;
-		}
-	}
-}
-
-module.exports = DeviceManager;