iobroker.smartfriends 1.3.2 → 1.3.3

package/README.md

@@ -33,6 +33,12 @@ 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.3.3 (2026-01-18)
+
+- (Black-Thunder) Special characters in device definitions (e.g. "<>") are now correctly handled
+- (Black-Thunder) Boolean values in device definitions are now correctly handled
+- (Black-Thunder) Numeric sensor values are no longer rounded
+
 ### 1.3.2 (2026-01-13)
 
 - (Black-Thunder) Creation of adapter objects was fixed

package/io-package.json

@@ -1,8 +1,21 @@
 {
   "common": {
     "name": "smartfriends",
-    "version": "1.3.2",
+    "version": "1.3.3",
     "news": {
+      "1.3.3": {
+        "en": "Special characters in device definitions (e.g. \"<>\") are now correctly handled\nBoolean values in device definitions are now correctly handled\nNumeric sensor values are no longer rounded",
+        "de": "Sonderzeichen in Gerätedefinitionen (z.B. \"<>\") werden nun korrekt verarbeitet\nBoolesche Werte in Gerätedefinitionen werden nun korrekt verarbeitet\nNumerische Sensorwerte werden nicht mehr gerundet",
+        "ru": "Специальные символы в определениях устройств (например, \"<>\") теперь правильно обработаны\nБулевы значения в определениях устройств теперь правильно обрабатываются\nЧисленные значения датчиков больше не округляются",
+        "pt": "Os caracteres especiais nas definições do dispositivo (por exemplo, \"<>\") são agora correctamente manuseados\nOs valores booleanos nas definições do dispositivo são agora correctamente manuseados\nOs valores dos sensores numéricos já não são arredondados",
+        "nl": "Speciale tekens in apparaatdefinities (bijv. \"<>\") worden nu correct behandeld\nBooleaanse waarden in apparaatdefinities worden nu correct behandeld\nNumerieke sensorwaarden zijn niet meer afgerond",
+        "fr": "Les caractères spéciaux dans les définitions de l'appareil (p. ex. «<>») sont maintenant correctement traités\nLes valeurs booléennes dans les définitions des appareils sont maintenant correctement gérées\nLes valeurs des capteurs numériques ne sont plus arrondies",
+        "it": "I caratteri speciali nelle definizioni dei dispositivi (ad esempio \" <>\") sono ora gestiti correttamente\nI valori booleani nelle definizioni dei dispositivi sono ora gestiti correttamente\nI valori del sensore numerico non sono più arrotondati",
+        "es": "Los caracteres especiales en las definiciones de dispositivos (por ejemplo, \"directo\") se manejan correctamente\nLos valores booleanos en las definiciones de dispositivos ahora se manejan correctamente\nLos valores numéricos del sensor ya no están redondeados",
+        "pl": "Specjalne znaki w definicjach urządzeń (np. \"< >\") są teraz prawidłowo obsługiwane\nWartości boolean w definicjach urządzeń są teraz prawidłowo obsługiwane\nNumeryczne wartości czujników nie są już zaokrąglone",
+        "uk": "Спеціальні символи у визначенні пристрою (наприклад, \"<>\") тепер правильно обробляються\nБололеві значення у визначенні пристроїв тепер правильно обробляються\nЧисельні значення датчика більше не закруглені",
+        "zh-cn": "设备定义中的特殊字符( 如“ QQ” ) 现在被正确处理\n设备定义中的布尔值现在被正确处理\n数值不再四舍五入"
+      },
       "1.3.2": {
         "en": "Creation of adapter objects was fixed",
         "de": "Erstellung von Adapterobjekten wurde korrigiert",
@@ -80,19 +93,6 @@
         "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": {

package/lib/SchellenbergBridge.js

@@ -151,62 +151,68 @@ class SchellenbergBridge {
 			const createdMasters = [];
 
 			// 1️⃣ Child-Devices nach MasterID gruppieren
-			const devicesByMaster = {};
-			for (const device of deviceInfos) {
+			const deviceInfosByMaster = {};
+			for (const deviceInfo of deviceInfos) {
 				// Definition dynamisch zuweisen
-				device.definition = this.deviceDefinitions.find(d => d.deviceDesignation === device.deviceDesignation);
-				if (!device.definition) {
+				deviceInfo.definition = this.deviceDefinitions.find(
+					d => d.deviceDesignation === deviceInfo.deviceDesignation,
+				);
+
+				if (!deviceInfo.definition) {
 					this.adapter.log.debug(
-						`Skipping device ${device.deviceName} (${device.deviceDesignation}) – no definition found`,
+						`Skipping device ${deviceInfo.deviceName} (${deviceInfo.deviceDesignation}) – no definition found`,
 					);
 					continue;
 				}
 
-				const masterId = device.masterDeviceID || device.deviceID;
-				if (!devicesByMaster[masterId]) {
-					devicesByMaster[masterId] = [];
+				const masterId = deviceInfo.masterDeviceID || deviceInfo.deviceID;
+				if (!deviceInfosByMaster[masterId]) {
+					deviceInfosByMaster[masterId] = [];
 				}
-				devicesByMaster[masterId].push(device);
+				deviceInfosByMaster[masterId].push(deviceInfo);
 			}
 
 			// 2️⃣ MasterDevices anlegen
-			for (const [masterId, childDevices] of Object.entries(devicesByMaster)) {
-				const masterName = (childDevices[0].masterDeviceName || childDevices[0].deviceName).replace(
+			for (const [masterId, childDeviceInfos] of Object.entries(deviceInfosByMaster)) {
+				const masterName = (childDeviceInfos[0].masterDeviceName || childDeviceInfos[0].deviceName).replace(
 					/\${|}/g,
 					"",
 				);
 				const masterDevice = new SchellenbergMasterDevice(this.adapter, masterId, masterName, []);
 
 				// 3️⃣ Child-Devices unter Master anlegen
-				for (const child of childDevices) {
+				for (const childDeviceInfo of childDeviceInfos) {
 					// Nur Devices mit definierbaren States
 					this.adapter.log.debug(
-						`Getting device capabilites from definition: ${JSON.stringify(child.definition)}`,
+						`Getting device capabilites from definition: ${JSON.stringify(childDeviceInfo.definition)}`,
 					);
-					const capabilities = getDeviceCapabilities(child.definition);
+					const capabilities = getDeviceCapabilities(childDeviceInfo.definition);
 
 					if (!capabilities.shouldBeCreated) {
 						this.adapter.log.debug(
-							`Skipping device ${child.deviceName} (${child.deviceDesignation}) – no definable states found`,
+							`Skipping device ${childDeviceInfo.deviceName} (${childDeviceInfo.deviceDesignation}) – no definable states found`,
 						);
 						continue;
 					} else {
 						this.adapter.log.debug(
-							`Device ${child.deviceID}: kind=${child.definition.deviceType.kind}, capabilities=${JSON.stringify(capabilities)}`,
+							`Device ${childDeviceInfo.deviceID}: kind=${childDeviceInfo.definition.deviceType.kind}, capabilities=${JSON.stringify(capabilities)}`,
 						);
 					}
 
-					const schellenbergDevice = await this.deviceManager.createDevice({
-						id: child.deviceID,
-						name: child.deviceName.replace(/\${|}/g, ""),
-						deviceType: child.deviceTypClient ?? child.definition.deviceType?.kind ?? "unknown",
-						designation: child.deviceDesignation,
-						definition: child.definition,
+					const childDevice = await this.deviceManager.createDevice({
+						id: childDeviceInfo.deviceID,
+						name: childDeviceInfo.deviceName.replace(/\${|}/g, ""),
+						deviceType:
+							childDeviceInfo.deviceTypClient ?? childDeviceInfo.definition.deviceType?.kind ?? "unknown",
+						designation: childDeviceInfo.deviceDesignation,
+						definition: childDeviceInfo.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})`);
+					masterDevice.childDevices.push(childDevice);
+					this.adapter.log.info(
+						`Device created: ${childDeviceInfo.deviceName} (ID: ${childDeviceInfo.deviceID})`,
+					);
 				}
 
 				if (masterDevice.childDevices?.length !== 0) {

package/lib/devices/DeviceCapabilityRegistry.js

@@ -34,15 +34,13 @@ const SensorKinds = {
 		unit: "°C",
 		defaultMin: -90,
 		defaultMax: 60,
-		defaultStep: 0.5,
 	},
 	luminanceDetector: {
-		role: "value.brightness ",
+		role: "value.brightness",
 		desc: "Measured brightness",
 		unit: "lux",
 		defaultMin: 0,
 		defaultMax: 150000,
-		defaultStep: 1,
 	},
 	volume: {
 		role: "value.rain",
@@ -50,7 +48,6 @@ const SensorKinds = {
 		unit: "mm",
 		defaultMin: 0,
 		defaultMax: 350,
-		defaultStep: 1,
 	},
 	batteryLevel: {
 		role: "value.battery",
@@ -58,7 +55,6 @@ const SensorKinds = {
 		unit: "%",
 		defaultMin: 0,
 		defaultMax: 100,
-		defaultStep: 1,
 	},
 	// some devices are defined as "kind": "default", so this is a fallback
 	// generic sensor kind for different types of sensors (e.g. atmospheric pressure, wind speed, etc.)
@@ -76,23 +72,28 @@ const SensorKinds = {
  */
 const EnumStateKinds = {
 	failureStatus: {
+		type: "number",
 		role: "value",
 		desc: "Error code of the device",
 	},
 	smokeDetector: {
+		type: "number",
 		role: "sensor.alarm.fire",
 		desc: "Smoke detector state",
 	},
 	signal: {
 		kind: "rssi", // rename to make the purpose of the state clearer
+		type: "number",
 		role: "value",
 		desc: "Signal strength (RSSI)",
 	},
 	floodDetector: {
+		type: "number",
 		role: "sensor.alarm.flood",
 		desc: "Flood detector state",
 	},
 	genericEnum: {
+		type: "number",
 		role: "value",
 		desc: "Enumerated state",
 	},

package/lib/devices/DeviceKindCapabilities.js

@@ -35,13 +35,7 @@ function getDeviceCapabilities(definition) {
 	// Analog sensors
 	let sensorConfig = null;
 	if (type === "sensor" && model === "analog") {
-		if (SensorKinds[kind]) {
-			// Known sensor kind
-			sensorConfig = SensorKinds[kind];
-		} else if (kind === "default") {
-			// Generic fallback fo default kind
-			sensorConfig = SensorKinds.genericSensor;
-		}
+		sensorConfig = SensorKinds[kind] ?? SensorKinds.genericSensor;
 	}
 
 	// Enum sensors (textOptions)
@@ -53,7 +47,16 @@ function getDeviceCapabilities(definition) {
 		deviceType.textOptions.some(opt => opt && typeof opt === "object" && "name" in opt)
 	) {
 		const enumKind = resolveEnumKind(definition, deviceType);
-		enumStateConfig = EnumStateKinds[enumKind] ?? EnumStateKinds.genericEnum;
+		const baseEnumConfig = EnumStateKinds[enumKind] ?? EnumStateKinds.genericEnum;
+
+		const isBooleanEnum =
+			deviceType.textOptions.length === 2 && deviceType.textOptions.every(opt => typeof opt.value === "boolean");
+
+		enumStateConfig = {
+			...baseEnumConfig,
+			type: isBooleanEnum ? "boolean" : "number",
+			kind: baseEnumConfig.kind ?? enumKind,
+		};
 	}
 
 	if (levelConfig) {
@@ -84,10 +87,11 @@ function getDeviceCapabilities(definition) {
 			unit: sensorConfig.unit,
 			min: deviceType.min ?? sensorConfig.defaultMin,
 			max: deviceType.max ?? sensorConfig.defaultMax,
-			step: deviceType.step ?? sensorConfig.defaultStep,
+			// leave out step for sensors as this leads to rounded values in ioBroker
 		});
 	} else if (enumStateConfig) {
 		Object.assign(configObj, {
+			type: enumStateConfig.type ?? "number",
 			kind: enumStateConfig.kind ?? configObj.kind,
 			role: enumStateConfig.role,
 			desc: enumStateConfig.desc,

package/lib/devices/DeviceManager.js

@@ -17,8 +17,22 @@ class DeviceManager {
 	async createDevice(deviceInfo) {
 		try {
 			const device = new SchellenbergDevice(this.adapter);
-			Object.assign(device, deviceInfo);
+
+			// Set raw data
+			device.id = deviceInfo.id;
+			device.name = deviceInfo.name;
+			device.deviceType = deviceInfo.deviceType;
+			device.designation = deviceInfo.designation;
+
+			// Set normalized definition
+			device.SetDefinition(deviceInfo.definition);
+			this.log.debug(
+				`Normalized device definition for ${deviceInfo.id}: ${JSON.stringify(device.normalizedDefinition)}`,
+			);
+
+			// Create and save device states
 			await device.CreateAndSave(deviceInfo.masterPrefix);
+
 			this.devices.set(deviceInfo.id, device);
 			return device;
 		} catch (error) {

package/lib/devices/SchellenbergDevice.js

@@ -1,12 +1,14 @@
 "use strict";
 
+const { normalizeDeviceDefinition, decodeUnicodeString } = require("../helpers/DeviceDefinitions");
 const { getDeviceCapabilities } = require("./DeviceKindCapabilities");
 const commonDefines = require("../helpers/CommonDefines");
 
 class SchellenbergDevice {
 	constructor(adapter) {
 		this.adapter = adapter;
-		this.definition = null;
+		this.rawDefinition = null;
+		this.normalizedDefinition = null;
 
 		// Info
 		this.id = -1;
@@ -15,10 +17,15 @@ class SchellenbergDevice {
 		this.designation = "";
 	}
 
+	SetDefinition(definition) {
+		this.rawDefinition = definition;
+		this.normalizedDefinition = normalizeDeviceDefinition(definition, this.adapter.FORBIDDEN_CHARS) ?? definition;
+	}
+
 	// 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);
+		// Dynamically from device.definition
+		const capabilities = getDeviceCapabilities(this.normalizedDefinition);
 
 		let devicePrefix = masterPrefix
 			? `${masterPrefix}.${this.id}`
@@ -27,11 +34,10 @@ class SchellenbergDevice {
 		devicePrefix = devicePrefix.replace(this.adapter.FORBIDDEN_CHARS, "");
 
 		// Umlauts are Unicode-escaped and need to be parsed here
-		const rawName = this.name.replace(/\${|}/g, "");
 		await this.adapter.setObjectNotExistsAsync(devicePrefix, {
 			type: "channel",
 			common: {
-				name: JSON.parse(`"${rawName.replace(/\\\\/g, "\\")}"`),
+				name: decodeUnicodeString(this.name),
 			},
 			native: {},
 		});
@@ -131,16 +137,16 @@ class SchellenbergDevice {
 	}
 
 	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();
+		if (!this.normalizedDefinition) {
+			this.adapter.log.warn(`Device ${this.id}: no normalized definition available`);
+			return;
+		}
 
-			await this.adapter.setObjectNotExistsAsync(`${statePrefix}${stateId}`, {
+		for (const stateDef of this.normalizedDefinition.deviceType.switchingValues) {
+			await this.adapter.setObjectNotExistsAsync(`${statePrefix}${stateDef.name}`, {
 				type: "state",
 				common: {
-					name: stateId,
+					name: stateDef.name,
 					type: "boolean",
 					role: "button",
 					read: false,
@@ -205,7 +211,6 @@ class SchellenbergDevice {
 				write: false,
 				min: sensorConfigObj.min,
 				max: sensorConfigObj.max,
-				step: sensorConfigObj.step,
 				unit: sensorConfigObj.unit,
 				def: 0,
 			},
@@ -219,7 +224,7 @@ class SchellenbergDevice {
 			common: {
 				name: enumConfigObj.kind,
 				desc: enumConfigObj.desc,
-				type: "number",
+				type: enumConfigObj.type,
 				role: enumConfigObj.role,
 				read: true,
 				write: false,
@@ -251,29 +256,29 @@ class SchellenbergDevice {
 	}
 
 	async updateValue(value) {
-		// value: Instanz von DeviceValue
+		// value: Instance of DeviceValue
 		if (value.deviceID !== this.id) {
-			// Diese Instanz betrifft nicht dieses Device
+			// This instance does not concern this device
 			return;
 		}
 
 		let controlPrefix = "";
 		let infoPrefix = "";
 		if (value.masterDeviceID != this.id) {
-			// Child-Device unter einem Master-Device
+			// Child devive under a 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
+			// Standalone device
 			controlPrefix = `${commonDefines.AdapterDatapointIDs.Devices}.${this.id}.${commonDefines.AdapterDatapointIDs.Control}.`;
 			infoPrefix = `${commonDefines.AdapterDatapointIDs.Devices}.${this.id}.${commonDefines.AdapterDatapointIDs.Info}.`;
 		}
 
-		// Dynamisch aus device.definition
-		const capabilities = getDeviceCapabilities(this.definition);
+		// Dynamisch aus device.normalizedDefinition
+		const capabilities = getDeviceCapabilities(this.normalizedDefinition);
 
 		if (capabilities.hasSwitchingValues) {
-			// SwitchingValues ignorieren, liefern keine Updates zurück
+			// Ignore SwitchingValues as they don't report their state changes
 			this.adapter.log.debug(`Device ${this.id}: switchingValue update ignored (value=${value.value})`);
 			return;
 		}

package/lib/devices/SchellenbergMasterDevice.js

@@ -1,27 +1,27 @@
 const commonDefines = require("../helpers/CommonDefines");
+const { decodeUnicodeString } = require("../helpers/DeviceDefinitions");
 
 class SchellenbergMasterDevice {
 	constructor(adapter, masterId, name, devices) {
 		this.adapter = adapter;
 		this.id = masterId;
 		this.name = name;
-		this.childDevices = devices; // Array von SchellenbergDevice
+		this.childDevices = devices; // Array of SchellenbergDevice
 	}
 
 	async createMasterFolder() {
 		const masterPrefix = `${commonDefines.AdapterDatapointIDs.Devices}.${this.id.replace(this.adapter.FORBIDDEN_CHARS, "")}`;
 
 		// Umlauts are Unicode-escaped and need to be parsed here
-		const rawName = this.name.replace(/\${|}/g, "");
 		await this.adapter.setObjectNotExistsAsync(masterPrefix, {
 			type: "channel",
-			common: { name: JSON.parse(`"${rawName.replace(/\\\\/g, "\\")}"`) },
+			common: { name: decodeUnicodeString(this.name) },
 			native: {},
 		});
 
-		// Child Devices anlegen
+		// Create child devices
 		for (const child of this.childDevices) {
-			await child.CreateAndSave(masterPrefix); // MasterPrefix übergeben
+			await child.CreateAndSave(masterPrefix);
 		}
 	}
 }

package/lib/helpers/DeviceDefinitions.js

@@ -0,0 +1,100 @@
+"use strict";
+
+const SWITCHING_VALUE_ALIASES = {
+	"<>": "toggle",
+};
+
+export function normalizeDeviceDefinition(definition, forbiddenChars) {
+	if (!definition?.deviceType) {
+		return null;
+	}
+
+	const deviceType = definition.deviceType;
+
+	const normalized = {
+		...definition,
+		deviceType: {
+			...deviceType,
+		},
+	};
+
+	// --- switchingValues ---
+	if (Array.isArray(deviceType.switchingValues)) {
+		normalized.deviceType.switchingValues = deviceType.switchingValues
+			.map(switchingValue => {
+				const safeName = sanitizeIdPart(switchingValue.name ?? switchingValue.value, forbiddenChars);
+				if (!safeName) {
+					return null;
+				}
+
+				return {
+					...switchingValue,
+					name: safeName,
+				};
+			})
+			.filter(Boolean);
+	}
+
+	// --- enum textOptions ---
+	if (Array.isArray(deviceType.textOptions)) {
+		normalized.deviceType.textOptions = deviceType.textOptions
+			.map(opt => {
+				const safeName = sanitizeIdPart(opt.name ?? opt.value, forbiddenChars);
+				if (!safeName) {
+					return null;
+				}
+
+				return {
+					...opt,
+					name: safeName,
+				};
+			})
+			.filter(Boolean);
+	}
+
+	return normalized;
+}
+
+export function sanitizeIdPart(value, forbiddenChars) {
+	if (value === undefined || value === null) {
+		return null;
+	}
+
+	let str = String(value);
+
+	// Alias BEFORE decode
+	const preAlias = str.trim();
+	if (SWITCHING_VALUE_ALIASES[preAlias]) {
+		str = SWITCHING_VALUE_ALIASES[preAlias];
+	}
+
+	// Decode Unicode-escaped strings \uXXXX
+	str = decodeUnicodeString(str);
+
+	// Alias AFTER decode
+	const postAlias = str.trim();
+	if (SWITCHING_VALUE_ALIASES[postAlias]) {
+		str = SWITCHING_VALUE_ALIASES[postAlias];
+	}
+
+	const sanitized = str
+		.toLowerCase()
+		.replace(/\${|}/g, "") // ${On} → On
+		.replace(forbiddenChars, "");
+
+	return sanitized.length > 0 ? sanitized : null;
+}
+
+export function decodeUnicodeString(str) {
+	if (typeof str !== "string") {
+		return str;
+	}
+
+	// Nothing to decode
+	if (!str.includes("\\u")) {
+		return str;
+	}
+
+	// Replace literal \uXXXX sequences with real Unicode characters
+	return str.replace(/\\u([0-9a-fA-F]{4})/g, (_, hex) => String.fromCharCode(parseInt(hex, 16)));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iobroker.smartfriends",
-  "version": "1.3.2",
+  "version": "1.3.3",
   "description": "smartfriends",
   "author": {
     "name": "Black-Thunder",