iobroker.zwavews 0.1.4 → 0.1.6

package/README.md

@@ -17,6 +17,13 @@
 
 The `zwavews` adapter connects a [`zwave-js-ui`](https://zwave-js.github.io/zwave-js-ui/#/) to ioBroker and creates corresponding data points for devices, values, and statuses. This allows Z-Wave devices to be conveniently used in visualizations, logic, and automations.
 
+### Features
+* **Real-time communication**: Instantly receives updates of device values and statuses via WebSocket or MQTT.
+* **Auto-Discovery**: Automatically creates and updates the device and state structure in ioBroker from the `zwave-js-ui` nodes.
+* **Device Management**: View battery levels, connection status, and detailed device metrics right from the ioBroker interface.
+* **Firmware Updates**: Observe firmware update progress directly via the adapter's logs and states.
+* **State Control**: Send commands and update values natively through the ioBroker object tree.
+* **Support for multiple protocols**: You can connect to `zwave-js-ui` using WebSocket, External MQTT, or an Internal Dummy MQTT server.
 
 ## Adapter Documentation
 
@@ -35,6 +42,12 @@ Activate WS Server Settings in `zwave-js-ui` we use the Home Assistant Settings
 
 
 ## Changelog
+### 0.1.6 (2026-04-23)
+* (arteck) add test
+
+### 0.1.5 (2026-04-21)
+* (arteck) upd devicemanager
+
 ### 0.1.4 (2026-04-16)
 * (arteck) Dependencies have been updated
 * (arteck) add vscode folder

package/io-package.json

@@ -1,8 +1,34 @@
 {
   "common": {
     "name": "zwavews",
-    "version": "0.1.4",
+    "version": "0.1.6",
     "news": {
+      "0.1.6": {
+        "en": "add test",
+        "de": "test hinzufügen",
+        "ru": "добавить тест",
+        "pt": "adicionar teste",
+        "nl": "test toevoegen",
+        "fr": "ajouter un essai",
+        "it": "aggiungere test",
+        "es": "agregar la prueba",
+        "pl": "dodać test",
+        "uk": "додати тест",
+        "zh-cn": "添加测试"
+      },
+      "0.1.5": {
+        "en": "upd devicemanager",
+        "de": "gerätemanager und -manager",
+        "ru": "улучшенный devicemanager",
+        "pt": "gerenciador de dispositivos upd",
+        "nl": "upd apparaatbeheerder",
+        "fr": "gestionnaire d'appareil",
+        "it": "upd devicemanager",
+        "es": "upd devicemanager",
+        "pl": "upd devicemaniger",
+        "uk": "напляскване",
+        "zh-cn": "上调设备管理器"
+      },
       "0.1.4": {
         "en": "Dependencies have been updated\nadd vscode folder",
         "de": "Abhängigkeiten wurden aktualisiert\nvscode ordner hinzufügen",
@@ -67,32 +93,6 @@
         "pl": "ZMIANA BREAKING - nazwa dp jest teraz z podkreśleniem\ndodaj urządzenie Kierownik\nfix dp 's z przestrzenią\nfix dp 's ze specjalnymi znakami",
         "uk": "BREAKING CHANGE - ім'я dp тепер з онлайн\nдодати пристрій Менеджер\nзакріпити dp's з космосом\nфіксувати dp з особливими chars",
         "zh-cn": "断裂变换 - dp 名称现在是下划线\n添加设备 经理\n修补 dp 的空格\n修复 dp 与特殊字符"
-      },
-      "0.0.18": {
-        "en": "add info.sendMessageAllowed object to allow sending the message to zwave-ui-js\nadd new checkbox to set info.sendMessageAllowed immediately after starting the adapter",
-        "de": "add info.sendMessageAllowed object to let send the message to zwave-ui-js\nneue Checkbox hinzufügen, um info.sendMessage einzustellen Sofort nach dem Start des Adapters zugelassen",
-        "ru": "добавить info.sendMessageРазрешенный объект для отправки сообщения на zwave-ui-js\nдобавить новый флажок для установки info.sendMessage Допускается сразу после запуска адаптера",
-        "pt": "add info.sendMessagePermitido objeto para permitir o envio da mensagem para zwave-ui-js\nadicionar nova caixa de seleção para definir info.sendMessage Permitido imediatamente após iniciar o adaptador",
-        "nl": "info.sendMessageToegewezen object om het bericht naar zwave-ui-js te versturen\nnieuwe selectievakje toevoegen om info.sendMessage in te stellen Onmiddellijk na het starten van de adapter toegestaan",
-        "fr": "ajouter info.sendMessageObjet autorisé pour permettre l'envoi du message à zwave-ui-js\najouter une nouvelle case à cocher pour définir info.sendMessage Autorisé immédiatement après le démarrage de l'adaptateur",
-        "it": "aggiungere info.sendMessageAllowed oggetto per consentire l'invio del messaggio a zwave-ui-js\naggiungere nuova casella di controllo per impostare info.sendMessage Consentito subito dopo l'avvio dell'adattatore",
-        "es": "añadir info.sendMessagePropósito permitido enviar el mensaje a zwave-ui-js\nañadir nueva casilla para configurar información.sendMessage Permitido inmediatamente después de iniciar el adaptador",
-        "pl": "dodaj info.sendMessageDopuszczalny obiekt, aby umożliwić wysyłanie wiadomości do zwave- ui- js\ndodaj nową opcję do ustawienia info.sendMessage Dozwolone bezpośrednio po uruchomieniu adaptera",
-        "uk": "додайте інформацію.sendMessageВсього об'єкту, щоб дозволити надсилати повідомлення на zwave-ui-js\nдодати нову прапорець, щоб встановити інформацію.sendMessage Допускається відразу після запуску адаптера",
-        "zh-cn": "添加信息. sendMessage Allowed 对象允许将消息发送到 zwave- ui- js\n添加新复选框以设置信息. sendMessage 启动适配器后立即允许"
-      },
-      "0.0.17": {
-        "en": "fix adapter start\nDependencies have been updated",
-        "de": "befestigungsadapter start\nAbhängigkeiten wurden aktualisiert",
-        "ru": "запуск адаптера\nЗависимости были обновлены",
-        "pt": "corrigir o início do adaptador\nAs dependências foram atualizadas",
-        "nl": "fix adapter start\nAfhankelijkheden zijn bijgewerkt",
-        "fr": "fixer le démarrage de l'adaptateur\nLes dépendances ont été actualisées",
-        "it": "avvio dell'adattatore\nLe dipendenze sono state aggiornate",
-        "es": "adaptador de fijación\nSe han actualizado las dependencias",
-        "pl": "uruchomić adapter\nZaktualizowano zależności",
-        "uk": "запуск адаптера\nЗалежність було оновлено",
-        "zh-cn": "固定适配器启动\n依赖关系已更新"
       }
     },
     "titleLang": {

package/lib/devicemgmt.js

@@ -17,17 +17,26 @@ class dmZwave extends dmUtils.DeviceManagement {
     }
 
     /**
+     * Loads all ZWave devices and reports them to the device manager context.
+     * Called by the dm-utils framework in response to a 'dm:loadDevices' message.
      *
+     * @param {object} context - The DeviceLoadContext (addDevice / setTotalDevices / complete).
      */
-    async listDevices() {
+    async loadDevices(context) {
         const devices = await this.adapter.getDevicesAsync();
-        const arrDevices = [];
+        context.setTotalDevices(devices.length);
+
         for (const i in devices) {
             const status = {};
 
             const nodeId = this.stripIobPrefix(devices[i]._id);
 
-            const device = this.adapter.nodeCache[nodeId].nodeData;
+            const cacheEntry = this.adapter.nodeCache[nodeId];
+            if (!cacheEntry) {
+                this.adapter.log.warn(`listDevices: nodeCache miss for ${nodeId}, skipping.`);
+                continue;
+            }
+            const device = cacheEntry.nodeData;
 
             status.connection = device.ready ? 'connected' : 'disconnected';
 
@@ -58,12 +67,53 @@ class dmZwave extends dmUtils.DeviceManagement {
                     devStatus = 'unknown';
             }
 
+            // Sensordaten aus Multilevel_Sensor laden 
+            const sensorCustomInfo = {
+                id: nodeId,
+                schema: {
+                    type: 'panel',
+                    items: {},
+                },
+            };
+
+            try {
+                const sensorObjects = await this.adapter.getObjectViewAsync('system', 'state', {
+                    startkey: `${devices[i]._id}.Multilevel_Sensor.`,
+                    endkey: `${devices[i]._id}.Multilevel_Sensor.\u9999`,
+                });
+
+                if (sensorObjects && sensorObjects.rows && sensorObjects.rows.length > 0) {
+                    for (const row of sensorObjects.rows) {
+                        const obj = row.value;
+                        if (!obj) {
+                            continue;
+                        }
+                        const stateId = obj._id;
+                        const sensorKey = stateId.replace(/\./g, '_');
+                        const labelParts = stateId.split('.');
+                        const sensorLabel = labelParts[labelParts.length - 1];
+                        const unit = obj.common?.unit ? ` (${obj.common.unit})` : '';
+
+                        sensorCustomInfo.schema.items[sensorKey] = {
+                            type: 'state',
+                            oid: stateId,
+                            foreign: true,
+                            label: `${sensorLabel}${unit}`,
+                            newLine: true,
+                        };
+                    }
+                }
+            } catch (e) {
+                this.adapter.log.warn(`listDevices: Fehler beim Laden der Multilevel_Sensor-Daten für ${nodeId}: ${e.message}`);
+            }
+
+
             const res = {
                 id: nodeId,
                 name: device.name || device.label,
                 icon: devStatus,
-                manufacturer: device.deviceConfig.manufacturer,
-                model: `${device.deviceConfig.label  } ${  device.deviceConfig.description}`,
+                manufacturer: device.deviceConfig?.manufacturer ?? '',
+                model: `${device.deviceConfig?.label ?? ''} ${device.deviceConfig?.description ?? ''}`.trim(),
                 status: status,
                 hasDetails: true,
                 actions: [
@@ -76,17 +126,122 @@ class dmZwave extends dmUtils.DeviceManagement {
                 ],
             };
 
+            // Schalter aus Multilevel_Switch laden
+            try {
+                const switchObjects = await this.adapter.getObjectViewAsync('system', 'state', {
+                    startkey: `${devices[i]._id}.Multilevel_Switch.`,
+                    endkey: `${devices[i]._id}.Multilevel_Switch.\u9999`,
+                });
+
+                if (switchObjects && switchObjects.rows && switchObjects.rows.length > 0) {
+                    // Trennlinie einfügen, wenn bereits Sensordaten vorhanden
+                    if (Object.keys(sensorCustomInfo.schema.items).length > 0) {
+                        sensorCustomInfo.schema.items['_divider_switch'] = {
+                            type: 'divider',
+                            color: 'primary',
+                        };
+                    }
+
+                    // Alle Rows in eine Map sammeln (rawName → {obj, stateId})
+                    const switchMap = {};
+                    for (const row of switchObjects.rows) {
+                        const obj = row.value;
+                        if (!obj) {
+                            continue;
+                        }
+                        const parts = obj._id.split('.');
+                        const rawName = parts[parts.length - 1];
+                        switchMap[rawName] = { obj, stateId: obj._id };
+                    }
+
+                    // Gewünschte Reihenfolge, unbekannte States werden danach angehängt
+                    const order = ['open', 'close', 'currentValue', 'targetValue', 'restorePrevious', 'duration'];
+                    const allKeys = [...order, ...Object.keys(switchMap).filter(k => !order.includes(k))];
 
-            arrDevices.push(res);
+                    allKeys.forEach((rawName, index) => {
+                        if (!switchMap[rawName]) {
+                            return;
+                        }
+                        const { obj, stateId } = switchMap[rawName];
+                        // Nummerierten Prefix damit Admin-UI die Elemente in der richtigen Reihenfolge anzeigt
+                        const switchKey = `_sw${String(index + 1).padStart(2, '0')}_${rawName}`;
+                        const isBoolean = obj.common?.type === 'boolean';
+
+                        // Anzeigenamen umbenennen
+                        let switchLabel;
+                        if (rawName === 'targetValue') {
+                            switchLabel = 'Target';
+                        } else if (rawName === 'currentValue') {
+                            switchLabel = 'Current';
+                        } else {
+                            switchLabel = rawName;
+                        }
+
+                        // currentValue: nur lesebarer numerischer Wert mit %-Einheit
+                        // duration: nur lesebarer numerischer Wert
+                        if (rawName === 'currentValue' && !isBoolean) {
+                            sensorCustomInfo.schema.items[switchKey] = {
+                                type: 'state',
+                                oid: stateId,
+                                foreign: true,
+                                label: switchLabel,
+                                readOnly: true,
+                                unit: '%',
+                                newLine: true,
+                            };
+                        } else if (rawName === 'duration' && !isBoolean) {
+                            sensorCustomInfo.schema.items[switchKey] = {
+                                type: 'state',
+                                oid: stateId,
+                                foreign: true,
+                                label: switchLabel,
+                                readOnly: true,
+                                newLine: true,
+                            };
+                        } else if (isBoolean) {
+                            sensorCustomInfo.schema.items[switchKey] = {
+                                type: 'state',
+                                oid: stateId,
+                                foreign: true,
+                                label: switchLabel,
+                                control: 'switch',
+                                trueTextStyle: { color: 'green' },
+                                falseTextStyle: { color: 'red' },
+                                trueText: 'ON',
+                                falseText: 'OFF',
+                                newLine: true,
+                            };
+                        } else {
+                            sensorCustomInfo.schema.items[switchKey] = {
+                                type: 'state',
+                                oid: stateId,
+                                foreign: true,
+                                label: switchLabel,
+                                control: 'slider',
+                                min: obj.common?.min ?? 0,
+                                max: obj.common?.max ?? 99,
+                                newLine: true,
+                            };
+                        }
+                    });
+                }
+            } catch (e) {
+                this.adapter.log.warn(`listDevices: Fehler beim Laden der Multilevel_Switch-Daten für ${nodeId}: ${e.message}`);
+            }
+
+
+            // Nur customInfo anhängen, wenn Sensor- oder Schalterdaten vorhanden sind
+            if (Object.keys(sensorCustomInfo.schema.items).length > 0) {
+                res.customInfo = sensorCustomInfo;
+            }
+
+
+            context.addDevice(res);
         }
 
         // nach id sortieren (z.B. nodeID_2 vor nodeID_10)
-        arrDevices.sort((a, b) => String(a?.id ?? '').localeCompare(String(b?.id ?? ''), undefined, {
-            numeric: true,
-            sensitivity: 'base',
-        }));
-
-        return arrDevices;
+        // Note: sorting is informational only; context already sent devices
+        context.complete();
     }
 
     /**
@@ -267,6 +422,10 @@ class dmZwave extends dmUtils.DeviceManagement {
                 devStatus = 'unknown';
         }
 
+        // Kalibrierungsknopf prüfen
+        const calibStateId = `${this.adapter.namespace}.${id}.Configuration.Forced_Roller_Shutter_Calibration`;
+        const calibObj = await this.adapter.getObjectAsync(calibStateId).catch(() => null);
+
         return {
             id: String(device.nodeId),
             schema: {
@@ -336,6 +495,34 @@ class dmZwave extends dmUtils.DeviceManagement {
                                 label: 'Max Baud Rate',
                                 readOnly: true,
                             },
+                            ...(calibObj ? {
+                                _divider_calib: {
+                                    type: 'divider',
+                                    color: 'primary',
+                                },
+                                _calib_spacer: {
+                                    type: 'staticText',
+                                    text: '',
+                                    newLine: true,
+                                    xs: 8,
+                                    sm: 9,
+                                    md: 10,
+                                    lg: 10,
+                                    xl: 10,
+                                },
+                                _calib_button: {
+                                    type: 'state',
+                                    oid: calibStateId,
+                                    foreign: true,
+                                    label: 'Kalibrierung starten',
+                                    control: 'button',
+                                    xs: 4,
+                                    sm: 3,
+                                    md: 2,
+                                    lg: 2,
+                                    xl: 2,
+                                },
+                            } : {}),
                         },
                     },
                     _tab_Details: {

package/lib/helper.js

@@ -26,6 +26,33 @@ class Helper {
 
   }
 
+  /**
+   * Normalises any value to a valid ioBroker common.type string.
+   * Valid types: "number" | "string" | "boolean" | "array" | "object" | "mixed" | "file"
+   *
+   * @param {*} value - The raw value whose type should be determined.
+   * @param {string} [hint] - An optional type hint (e.g. from metadata.type).
+   * @returns {string} A valid ioBroker type string.
+   */
+  normalizeType(value, hint) {
+    const VALID = new Set(["number", "string", "boolean", "array", "object", "mixed", "file"]);
+    if (hint && VALID.has(hint)) {
+return hint;
+}
+    if (Array.isArray(value))          {
+return "array";
+}
+    const t = typeof value;
+    if (t === "number")                {
+return "number";
+}
+    if (t === "boolean")               {
+return "boolean";
+}
+    // strings are stored as "mixed" to allow numeric/bool changes later
+    return "mixed";
+  }
+
   /**
    * Creates a ZWave node device and all its value states in ioBroker.
    *
@@ -55,9 +82,9 @@ class Helper {
       await this.createReadyStatus(nodeId);
 
       const valuesOnly = element.values ?? null;
-      delete element.values;
+      const { values: _values, ...elementWithoutValues } = element;
 
-      await this.parse(`${nodeId}.info`, element);
+      await this.parse(`${nodeId}.info`, elementWithoutValues);
 
       if (valuesOnly != null && typeof valuesOnly === "object" && valuesOnly.length > 0) {
         for (const v of valuesOnly) {
@@ -112,7 +139,8 @@ class Helper {
           metadata.value = v.value; // add value for resolution
           const valDp = this.resolveCommandClassValue(metadata) ?? 0;
 
-          let typeDp = metadata.type === "timeout" ? "number" : metadata.type;
+          const rawType = metadata.type === "timeout" ? "number" : metadata.type;
+          let typeDp = this.normalizeType(valDp, rawType);
 
           if (constant.mixedType.includes(nam_id)) {
             typeDp = "mixed";
@@ -189,8 +217,19 @@ class Helper {
 
       if (!this.alreadyCreatedObjects[parsePath]) {
         try {
-          let common = {};
-          if (typeof element === "string" || typeof element === "number") {
+          let common;
+          if (typeof element === "boolean") {
+            common = {
+              id: parsePath,
+              name: parsePath,
+              role: "switch",
+              type: "boolean",
+              write: options.write,
+              read: true,
+              def: false,
+            };
+          } else {
+            // string or number
             common = {
               id: parsePath,
               name: parsePath,
@@ -222,20 +261,19 @@ class Helper {
       return;
     }
 
-    options.channelName = utils.getLastSegment(parsePath);
+    const channelName = utils.getLastSegment(parsePath);
 
     if (!this.alreadyCreatedObjects[parsePath]) {
       try {
           await this.adapter.setObjectNotExistsAsync(parsePath, {
             type: "channel",
             common: {
-              name: options.channelName || ""
+              name: channelName || ""
             },
             native: {},
           });
 
         this.alreadyCreatedObjects[parsePath] = { };
-        delete options.channelName;
       } catch (error) {
         this.adapter.log.error(`parse error ${  parsePath}`);
         this.adapter.log.error(error);
@@ -278,8 +316,8 @@ class Helper {
 
       if (isObj) {
         if (Object.keys(valDP).length > 0) {
-          options.write = false;
-          await this.parse(fullPath, valDP, options);
+          // FIX: options-Objekt nicht mutieren – Spread-Kopie verwenden
+          await this.parse(fullPath, valDP, { ...options, write: false });
         }
         continue;
       }
@@ -300,7 +338,7 @@ class Helper {
 
       if (!this.alreadyCreatedObjects[fullPath]) {
         const objectName = options.descriptions?.[key] || key;
-        let typeDp = typeof valDP === "string" ? "mixed" : (valDP != null ? typeof valDP : "mixed");
+        let typeDp = this.normalizeType(valDP);
 
         if (constant.mixedType.includes(key)) {
           typeDp = "mixed";
@@ -335,10 +373,9 @@ class Helper {
         await this.changeState(fullPath, valDP, change);
 
         if (valDP !== undefined) {
-          if (fullPath.endsWith('ready') ) {
-            valDP = element['status'];
-            if (utils.isNumeric(valDP) && valDP === 3) {
-              fullPath = fullPath.replace(".status", ".ready");
+          if (fullPath.endsWith('ready')) {
+            const statusVal = element['status'];
+            if (utils.isNumeric(statusVal) && statusVal === 3) {
               await this.changeState(fullPath, false);
             }
           }
@@ -375,15 +412,11 @@ class Helper {
 
       for (let i = 0; i < array.length; i++) {
         const arrayElement = array[i];
-     //   const index = (i + 1).toString().padStart(2, "0");
 
         if (typeof arrayElement === "string") {
-          if (key === undefined || key === "") {
-            key = arrayElement;
-          }
-
+          const segKey = (key === undefined || key === "") ? arrayElement : key;
           await this.parse(
-            `${path}.${key}.${arrayElement}`,
+            `${path}.${segKey}`,
             arrayElement,
             options,
           );
@@ -443,6 +476,10 @@ class Helper {
   resolveCommandClassValue(element) {
     const type = element.type;
 
+    if (!type) {
+      return element.value ?? 0;
+    }
+
     if (type === "any" || type === "color") {
       element.type = "mixed";
       return typeof element.value === "object"
@@ -487,10 +524,10 @@ class Helper {
     }
 
     if (type === "number") {
-      if (element?.value) {
+      if (element.value != null) {
         return utils.isNumeric(element.value) ? element.value : 0;
       }
-      return element.value ?? element.min;
+      return element.min ?? 0;
     }
 
     return element.readable === false
@@ -545,18 +582,22 @@ class Helper {
    */
   async updateDevice(nodeId, element, nameChange = true) {
     const obj = await this.adapter.getObjectAsync(nodeId);
-    if (obj) {
-      if (nameChange) {
-        const newName = element.name || element.productLabel || element.manufacturer || element.newValue;
-
-        if (obj.common?.name !== newName) {
-          obj.common = obj.common ?? {};
-          obj.common.name = newName;
-        } else {
-          const newDesc = element.desc;
-          obj.common = obj.common ?? {};
-          obj.common.desc = newDesc;
-        }
+    if (!obj) {
+return;
+}
+
+    obj.common = obj.common ?? {};
+
+    if (nameChange) {
+      const newName = element.name || element.productLabel || element.manufacturer || element.newValue;
+      if (newName !== undefined && obj.common.name !== newName) {
+        obj.common.name = newName;
+        await this.adapter.setObjectAsync(nodeId, obj);
+      }
+    } else {
+      const newDesc = element.desc;
+      if (newDesc !== undefined) {
+        obj.common.desc = newDesc;
         await this.adapter.setObjectAsync(nodeId, obj);
       }
     }
@@ -571,9 +612,9 @@ class Helper {
    */
   async changeState(path, value, change = false) {
     if (change) {
-      this.adapter.setState(path, value, true);
+      await this.adapter.setStateAsync(path, value, true);
     } else {
-      this.adapter.setStateChanged(path, value, true);
+      await this.adapter.setStateChangedAsync(path, value, true);
     }
   }
 

package/lib/messages.js

@@ -11,7 +11,7 @@ async function adapterInfo(config, log) {
   log.info(`|| zwaveWS Frontend Server: ${config.webUIServer}`);
   log.info(`|| zwaveWS Frontend Port: ${config.webUIPort}`);
   log.info(`|| zwaveWS Connection Type: ${config.connectionType}`);
-  if (config.connectionType == "ws") {
+  if (config.connectionType === "ws") {
     log.info(`|| zwaveWS Websocket Scheme: ${config.wsScheme}`);
     log.info(`|| zwaveWS Websocket Server: ${config.wsServerIP}`);
     log.info(`|| zwaveWS Websocket Port: ${config.wsServerPort}`);
@@ -21,11 +21,11 @@ async function adapterInfo(config, log) {
     log.info(
       `|| zwaveWS Websocket Dummy MQTT-Server: ${config.dummyMqtt ? "activated" : "deactivated"}`,
     );
-    if (config.dummyMqtt == true) {
+    if (config.dummyMqtt === true) {
       log.info(`|| zwaveWS Dummy MQTT IP-Bind: ${config.mqttServerIPBind}`);
       log.info(`|| zwaveWS Dummy MQTT Port: ${config.mqttServerPort}`);
     }
-  } else if (config.connectionType == "exmqtt") {
+  } else if (config.connectionType === "exmqtt") {
     log.info(
       `|| zwaveWS Externanl MQTT Server: ${config.externalMqttServerIP}`,
     );
@@ -35,7 +35,7 @@ async function adapterInfo(config, log) {
     log.info(
       `|| zwaveWS Externanl MQTT Credentials: ${config.externalMqttServerCredentials ? "use" : "unused"}`,
     );
-  } else if (config.connectionType == "intmqtt") {
+  } else if (config.connectionType === "intmqtt") {
     log.info(`|| zwaveWS Internal MQTT IP-Bind: ${config.mqttServerIPBind}`);
     log.info(`|| zwaveWS Internal MQTT Port: ${config.mqttServerPort}`);
   }

package/lib/mqttServerController.js

@@ -33,7 +33,7 @@ class MqttServerController {
         this.adapter.config.mqttServerIPBind,
         () => {
           this.adapter.log.info(
-            `Statring MQTT-Server on IP ${this.adapter.config.mqttServerIPBind} and Port ${this.adapter.config.mqttServerPort}`,
+            `Starting MQTT-Server on IP ${this.adapter.config.mqttServerIPBind} and Port ${this.adapter.config.mqttServerPort}`,
           );
         },
       );
@@ -54,7 +54,7 @@ class MqttServerController {
         this.adapter.config.mqttServerIPBind,
         () => {
           this.adapter.log.info(
-            `Statring DummyMQTT-Server on IP ${this.adapter.config.mqttServerIPBind} and Port ${this.adapter.config.mqttServerPort}`,
+            `Starting DummyMQTT-Server on IP ${this.adapter.config.mqttServerIPBind} and Port ${this.adapter.config.mqttServerPort}`,
           );
         },
       );
@@ -67,7 +67,7 @@ class MqttServerController {
    *
    */
   closeServer() {
-    if (mqttServer && !mqttServer.closed()) {
+    if (mqttServer && mqttServer.listening) {
       mqttServer.close();
     }
   }

package/lib/statesController.js

@@ -45,9 +45,10 @@ class StatesController {
   async subscribeAllWritableExistsStates() {
     const writableStates = {};
 
+    const ns = `${this.adapter.namespace}.`;
     const res = await this.adapter.getObjectViewAsync("system", "state", {
-      startkey: "zwaveWS.",
-      endkey: "zwaveWS.\u9999",
+      startkey: ns,
+      endkey: `${ns}\u9999`,
     });
 
     for (const row of res.rows) {