iobroker.smartfriends 1.0.1 → 1.1.0-alpha.1

package/README.md

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

package/io-package.json

@@ -1,8 +1,34 @@
 {
   "common": {
     "name": "smartfriends",
-    "version": "1.0.1",
+    "version": "1.1.0-alpha.1",
     "news": {
+      "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",
+        "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.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",

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,148 @@ 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();
+			const msg = err?.responseMessage || err.message || JSON.stringify(err);
+			this.adapter.log.error(`Connection failed: ${msg}`);
+
+			if (err?.response?.errorCode === 50 && err?.response?.remainingBlockDuration) {
+				{
+					this.adapter.log.error(
+						`Login to the gateway is currently blocked. Please try again in ${err?.response?.remainingBlockDuration} second(s)`,
+					);
+				}
+
+				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);
+	}
+
+	handleDeviceInfo(deviceInfo) {
+		if (!deviceInfo || deviceInfo.deviceName || !deviceInfo.deviceDesignation) {
+			this.adapter.log.debug("Invalid device info received, ignoring.");
+			return;
 		}
+
+		this.adapter.log.debug(`New device info received for deviceID=${deviceInfo.deviceID}`);
+		// TODO: implement updates of device info if needed
 	}
 
 	async processAllNewDeviceInfos(response) {
 		try {
-			const newDeviceInfos = response.newDeviceInfos.values;
-			let knownDevices = 0;
-
-			this.adapter.log.debug(`Received all devices:\r\n${JSON.stringify(newDeviceInfos)}`);
-
-			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,
-					});
-					this.adapter.log.info(
-						`Device created: ${device.deviceName} (Type: ${device.deviceTypClient}, Device ID: ${device.deviceID})`,
-					);
-				} else {
+			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(
-						`Unsupported device type received: ${device.deviceName} (Type: ${device.deviceTypClient}, Device ID: ${device.deviceID}). Ignoring...`,
+						`Skipping device ${device.deviceName} (${device.deviceDesignation}) – no definition found`,
 					);
+					continue;
+				}
+
+				const masterId = device.masterDeviceID || device.deviceID;
+				if (!devicesByMaster[masterId]) {
+					devicesByMaster[masterId] = [];
+				}
+				devicesByMaster[masterId].push(device);
+			}
+
+			// 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
+					});
+
+					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}`);
@@ -180,6 +273,7 @@ class SchellenbergBridge {
 			[1]: r => {
 				this.retryCounter = 0;
 				this.resolveNextPromise(r);
+				this.updateTimestamp(r);
 			},
 			[2]: r => this.handleUpdate(r),
 			[5]: r => this.handleSpecificResponseCode(r, 5),
@@ -239,12 +333,12 @@ class SchellenbergBridge {
 		if (this.retryCounter < maxRetries) {
 			this.retryCounter++;
 			this.adapter.log.warn(`Reconnecting (try ${this.retryCounter} of ${maxRetries})...`);
-			setTimeout(() => this.Connect(), reconnectInterval);
+			this.adapter.setTimeout(() => this.Connect(), reconnectInterval);
 		} else {
 			this.adapter.log.warn(
 				`Connection to gateway lost, connection temporarily disabled! Trying again in ${retryInterval / (60 * 1000)} minutes.`,
 			);
-			setTimeout(() => this.Connect(), retryInterval);
+			this.adapter.setTimeout(() => this.Connect(), retryInterval);
 		}
 	}
 
@@ -272,7 +366,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 +403,13 @@ class SchellenbergBridge {
 	}
 
 	handleUpdate(response) {
-		if (response.responseMessage) {
-			switch (response.responseMessage) {
-				case "newDeviceValue":
-					break;
-				case "newDeviceInfo":
-					break;
-				default:
-					break;
+		if (response && response.response && response.responseMessage) {
+			if (response.responseMessage === "newDeviceInfo") {
+				this.updateTimestamp(response);
+				this.handleDeviceInfo(response.response);
+			} else if (response.responseMessage === "newDeviceValue") {
+				this.updateTimestamp(response);
+				this.handleDeviceValue(response.response);
 			}
 		}
 	}
@@ -327,7 +420,7 @@ class SchellenbergBridge {
 		}
 
 		this.adapter.log.warn(`Socket renewal was requested with reason: ${reason}`);
-		setTimeout(() => {
+		this.adapter.setTimeout(() => {
 			this.Connect();
 		}, 1000);
 	}

package/lib/comunication/CommandFactory.js

@@ -6,13 +6,14 @@
 //--------------------------------------------------
 //Uses Command Wrapper to generate JSON-Commands
 
-//exports.setDeviceValueCommand = exports.allNewInfoCommand = exports.loginCommand = exports.heloCommand = void 0;
 const JSONCommand = require("./comModel/JSONCommand.js");
 const JSONHelper = require("./comModel/JSONHelper.js");
+
 class CommandFactory {
 	static createLoginCommand(username, digest, cSymbol, shcVersion, shApiVersion) {
-		return new loginCommand(username, digest, cSymbol, shcVersion, shApiVersion);
+		return new LoginCommand(username, digest, cSymbol, shcVersion, shApiVersion);
 	}
+
 	static createAllNewInfoCmd(timestamp, compatibilityConfigurationVersion, languageTranslationVersion) {
 		return new allNewInfoCommand(
 			JSONHelper.default.dateToString(timestamp),
@@ -20,26 +21,33 @@ class CommandFactory {
 			languageTranslationVersion,
 		);
 	}
+
 	static createSetDeviceValueCmd(inDeviceId, inValue) {
 		return new setDeviceValueCommand(inDeviceId, inValue);
 	}
+
 	static createupdateAllDeviceValues() {
 		return new JSONCommand.default("keepalive");
 	}
+
 	static createGetComptibilityConfigurationCmd() {
 		return new JSONCommand.default("getCompatibilityConfiguration");
 	}
+
 	static createLogoutCmd() {
 		return new JSONCommand.default("logout");
 	}
+
 	static createKeepAliveCmd() {
 		return new JSONCommand.default("keepalive");
 	}
+
 	static createHeloCmd(username) {
 		return new heloCommand(username);
 	}
 }
 exports.default = CommandFactory;
+
 class heloCommand extends JSONCommand.default {
 	constructor(username) {
 		super("helo");
@@ -47,7 +55,8 @@ class heloCommand extends JSONCommand.default {
 	}
 }
 exports.heloCommand = heloCommand;
-class loginCommand extends JSONCommand.default {
+
+class LoginCommand extends JSONCommand.default {
 	constructor(username, digest, cSymbol, shcVersion, shApiVersion) {
 		super("login");
 		this.username = username;
@@ -57,7 +66,8 @@ class loginCommand extends JSONCommand.default {
 		this.shApiVersion = shApiVersion;
 	}
 }
-exports.loginCommand = loginCommand;
+exports.LoginCommand = LoginCommand;
+
 class allNewInfoCommand extends JSONCommand.default {
 	constructor(timestamp, compatibilityConfigurationVersion, languageTranslationVersion) {
 		super("getAllNewInfos");
@@ -67,6 +77,7 @@ class allNewInfoCommand extends JSONCommand.default {
 	}
 }
 exports.allNewInfoCommand = allNewInfoCommand;
+
 class setDeviceValueCommand extends JSONCommand.default {
 	constructor(deviceID, value) {
 		super("setDeviceValue");
@@ -75,49 +86,3 @@ class setDeviceValueCommand extends JSONCommand.default {
 	}
 }
 exports.setDeviceValueCommand = setDeviceValueCommand;
-//TODO: implementation nedded
-//class executeDeviceCmdCmd extends Command{
-//    constructor(){
-//        super('')
-//    }
-//}
-//class newDeviceCmd extends Command{
-//    constructor(){
-//        super('')
-//    }
-//}
-//class changeDeviceCmd extends Command{
-//    constructor(){
-//        super('')
-//    }
-//}
-//class changeRoomCmd extends Command{
-//    constructor(){
-//        super('')
-//    }
-//}
-//class deleteRoomCmd extends Command{
-//    constructor(){
-//        super('')
-//    }
-//}
-//class newSwitchingSequenceCmd extends Command{
-//    constructor(){
-//        super('')
-//    }
-//}
-//class changeSwitchingSequenceCmd extends Command{
-//    constructor(){
-//        super('')
-//    }
-//}
-//class deleteSwitchingSequenceCmd extends Command{
-//    constructor(){
-//        super('')
-//    }
-//}
-//class activateSwitchingSequenceCmd extends Command{
-//    constructor(){
-//        super('')
-//    }
-//}

package/lib/comunication/HashHelper.js

@@ -10,32 +10,21 @@
 //--------------------------------------------------
 
 const crypto = require("crypto");
-const base_64 = require("base-64");
+
 class HashHelper {
 	static calculateDigest(password, salt, sessionSalt) {
 		const hashedPassword = this.getHash("sha256", password, salt);
 		return this.getHash("sha1", hashedPassword, sessionSalt);
 	}
-	// https://stackoverflow.com/questions/3195865 modified because of javascript handling chars differently
-	static string2Bin(str) {
-		const result = [];
-		for (let i = 0; i < str.length; i++) {
-			const p = str.charCodeAt(i);
-			if (p > 128) {
-				result.push(p - 256);
-			} else {
-				result.push(p);
-			}
-		}
-		return result;
-	}
-	static getHash(method, password, salt) {
-		const decode = base_64.decode(salt);
-		const saltArray = this.string2Bin(decode);
-		const passwordArray = this.string2Bin(password);
-		const pasConSalt = passwordArray.concat(saltArray);
-		const cryptHash = crypto.createHash(method).update(new Uint8Array(pasConSalt));
-		return cryptHash.digest("base64");
+
+	static getHash(method, password, saltBase64) {
+		const saltBuffer = Buffer.from(saltBase64, "base64");
+		const passwordBuffer = Buffer.from(password, "utf8");
+
+		const combined = Buffer.concat([passwordBuffer, saltBuffer]);
+
+		return crypto.createHash(method).update(combined).digest("base64");
 	}
 }
+
 exports.default = HashHelper;

package/lib/comunication/SmartSocket.js

@@ -8,7 +8,7 @@
 //events occurring and passing on received data
 //--------------------------------------------------
 
-const Deffered = require("../helpers/Deffered.js");
+const Deferred = require("../helpers/Deferred.js");
 const tls = require("tls");
 const CommandFactory = require("./CommandFactory.js");
 
@@ -110,7 +110,7 @@ class SmartSocket {
 			});
 			this.internalSocket.on("timeout", () => {
 				this.adapter.log.warn("Socket timed out");
-				setTimeout(() => {
+				this.adapter.setTimeout(() => {
 					if (this.dataDelegate) {
 						this.dataDelegate.renewSocket("Timeout");
 					}
@@ -136,14 +136,14 @@ class SmartSocket {
 	}
 
 	startKeepAlive() {
-		this.keepAliveHandler = setInterval(() => {
+		this.keepAliveHandler = this.adapter.setInterval(() => {
 			this.sendJSONCommand(CommandFactory.default.createKeepAliveCmd());
 		}, 5000);
 	}
 
 	stopKeepAlive() {
 		if (this.keepAliveHandler) {
-			clearInterval(this.keepAliveHandler);
+			this.adapter.clearInterval(this.keepAliveHandler);
 		}
 	}
 
@@ -152,7 +152,7 @@ class SmartSocket {
 	//be advised, that a may occurring response is discarded and may result in an error
 	sendJSONCommand(command) {
 		this.adapter.log.debug(`Sending command with method: ${command.command}`);
-		const localPromise = new Deffered.default((resolve, reject) => {
+		const localPromise = new Deferred.default(this.adapter, (resolve, reject) => {
 			if (this.internalSocket && command) {
 				this.adapter.log.debug(`Send JSON: ${command.toString()}`);
 				this.internalSocket.write(command.toString());
@@ -170,7 +170,7 @@ class SmartSocket {
 	//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 Deffered.default((resolve, reject) => {
+		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));

package/lib/comunication/comModel/JSONCommand.js

@@ -8,8 +8,8 @@
 //--------------------------------------------------
 
 class JSONCommand {
-	constructor(methode) {
-		this.command = methode;
+	constructor(method) {
+		this.command = method;
 	}
 	toString(sessionID) {
 		if (sessionID) {

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,31 @@
 "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) {
+		let devicePrefix = masterPrefix
+			? `${masterPrefix}.${this.id}`
+			: `${commonDefines.AdapterDatapointIDs.Devices}.${this.id}`;
+
+		devicePrefix = devicePrefix.replace(this.adapter.FORBIDDEN_CHARS, "");
+
 		await this.adapter.setObjectNotExistsAsync(devicePrefix, {
 			type: "channel",
 			common: {
-				name: `Device ${this.id} (${this.name})`,
+				name: this.name,
 			},
 			native: {},
 		});
@@ -85,6 +87,7 @@ class SchellenbergDevice {
 
 		//#region CONTROL
 		let controlPrefix = `${devicePrefix}.${commonDefines.AdapterDatapointIDs.Control}`;
+
 		await this.adapter.setObjectNotExistsAsync(controlPrefix, {
 			type: "channel",
 			common: {
@@ -95,98 +98,46 @@ class SchellenbergDevice {
 
 		controlPrefix += ".";
 
-		switch (this.deviceType) {
-			case commonDefines.KnownDeviceTypes.AwningEngine.type:
-				await this.adapter.setObjectNotExistsAsync(controlPrefix + commonDefines.AdapterStateIDs.MoveDown, {
-					type: "state",
-					common: {
-						name: "Move downwards",
-						type: "boolean",
-						role: "button.start",
-						read: false,
-						write: true,
-						def: false,
-						desc: "Move downwards, lower sunblind",
-					},
-					native: {},
-				});
+		// 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 + commonDefines.AdapterStateIDs.MoveUp, {
+				await this.adapter.setObjectNotExistsAsync(`${controlPrefix}${stateId}`, {
 					type: "state",
 					common: {
-						name: "Move upwards",
+						name: stateId,
 						type: "boolean",
-						role: "button.start",
+						role: "button",
 						read: false,
 						write: true,
 						def: false,
-						desc: "Move upwards, retract sunblind",
 					},
-					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: {
+						commandValue: stateDef.value,
 					},
-					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 +164,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.replace(this.adapter.FORBIDDEN_CHARS, "")}`;
+		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/lib/helpers/{Deffered.js → Deferred.js}

@@ -10,8 +10,9 @@
 //--------------------------------------------------
 
 class Deferred {
-	constructor(executor) {
-		this.timeout = setTimeout(() => {
+	constructor(adapter, executor) {
+		this.adapter = adapter;
+		this.timeout = this.adapter.setTimeout(() => {
 			this.reject("timeout");
 		}, 5000);
 		this.promise = new Promise((resolve, reject) => {
@@ -30,11 +31,11 @@ class Deferred {
 		return this.promise.finally(onfinally);
 	}
 	resolve(val) {
-		clearTimeout(this.timeout);
+		this.adapter.clearTimeout(this.timeout);
 		this._resolveSelf(val);
 	}
 	reject(reason) {
-		clearTimeout(this.timeout);
+		this.adapter.clearTimeout(this.timeout);
 		this._rejectSelf(reason);
 	}
 }

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.1",
   "description": "smartfriends",
   "author": {
     "name": "Black-Thunder",
@@ -23,8 +23,7 @@
     "node": ">= 20"
   },
   "dependencies": {
-    "@iobroker/adapter-core": "^3.3.2",
-    "base-64": "^1.0.0"
+    "@iobroker/adapter-core": "^3.3.2"
   },
   "devDependencies": {
     "@alcalzone/release-script": "^5.0.0",

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;

package/lib/comunication/DataDelegateInterface.js

@@ -1,7 +0,0 @@
-"use strict";
-
-//--------------------------------------------------
-//Copyright 2020 Pascâl Hartmann
-//See LICENSE File
-//--------------------------------------------------
-Object.defineProperty(exports, "__esModule", { value: true });