iobroker.miele-local 0.3.45 → 0.3.47

package/README.md

@@ -237,6 +237,16 @@ engineering work of the projects `MieleRESTServer` (akappner),
 	### **WORK IN PROGRESS**
 -->
 
+### 0.3.47
+- (SmarthomeElektroniker) A command under `control.*` that cannot be executed (control disabled, appliance not connected, HTTP error, connection error) is now acknowledged (`val=false`, `ack=true`) with the reason in the state comment `c` and a matching quality `q`. Until now it stayed unacknowledged - one `control.powerOn` stood there for 52 days
+- (SmarthomeElektroniker) Unacknowledged commands left over from before a restart are closed on start and are **not** sent to the appliance
+- (SmarthomeElektroniker) `remainingMinutes`/`remainingHHMM` are 0 while the appliance is off, finished or not connected (status 1/7/255), and no end time is calculated. A G5840 reported a remaining time of 0:01 while switched off
+- (SmarthomeElektroniker) A lost connection to an appliance and its return are logged once at info level (until now only at debug)
+- (SmarthomeElektroniker) The IP fallback search ("Search the subnet for the new IP if a device drops out") also runs in the background when mDNS discovery is off - exactly the Docker bridge setup it is meant for. It only probes appliances that currently fail, and searches every /24 network that has a missing appliance, not only the network of the first configured IP
+
+### 0.3.46
+- (SmarthomeElektroniker) Only the running appliance is polled at the short interval ("Poll interval (active)"); idle appliances keep the idle interval. Until now all appliances were polled at the short interval as soon as one was running - fewer requests to the Miele modules, which serve only one connection at a time
+
 ### 0.3.45
 - (SmarthomeElektroniker) The last German state ID is gone: `eco.quelle` is now `eco.source`, its value is always English. Existing installations are migrated on start
 - (SmarthomeElektroniker) `statusText`, `programText`, `programPhaseText`, `programTypeText` and `dryingStepText` follow the "German names" option - with the option off they are English (until now they were always German)

package/README_de.md

@@ -245,6 +245,16 @@ Reverse-Engineering-Arbeit der Projekte `MieleRESTServer` (akappner),
 	### **WORK IN PROGRESS**
 -->
 
+### 0.3.47
+- Ein Befehl unter `control.*`, der nicht ausgeführt werden kann (Steuerung aus, Gerät nicht verbunden, HTTP-Fehler, Verbindungsfehler), wird jetzt bestätigt (`val=false`, `ack=true`), der Grund steht im Kommentar `c` des Datenpunkts, dazu eine passende Qualität `q`. Bisher blieb er unbestätigt stehen – ein `control.powerOn` stand so 52 Tage da.
+- Unbestätigte Befehle von vor einem Neustart werden beim Start geschlossen und **nicht** an das Gerät gesendet.
+- `remainingMinutes`/`remainingHHMM` sind 0, solange das Gerät aus, fertig oder nicht verbunden ist (Status 1/7/255), und es wird kein Programmende berechnet. Eine G5840 meldete ausgeschaltet eine Restzeit von 0:01.
+- Verbindungsverlust zu einem Gerät und seine Rückkehr stehen je einmal im Log (Stufe info, bisher nur debug).
+- Die IP-Suche bei Ausfall („Bei Ausfall die neue IP im Subnetz suchen“) läuft auch dann im Hintergrund, wenn die mDNS-Suche aus ist – also genau im Docker-Bridge-Betrieb, für den sie gedacht ist. Sie fragt nur Geräte, deren Abfrage gerade scheitert, und durchsucht jedes /24-Netz mit einem fehlenden Gerät, nicht nur das Netz der ersten eingetragenen IP.
+
+### 0.3.46
+- Nur das laufende Gerät wird im kurzen Takt abgefragt („Abfrageintervall (aktiv)“), Geräte in Ruhe behalten den Ruhetakt. Bisher wurden alle Geräte im kurzen Takt abgefragt, sobald eines lief – weniger Anfragen an die Miele-Module, die nur eine Verbindung gleichzeitig bedienen.
+
 ### 0.3.45
 - Die letzte deutsche Datenpunkt-ID ist weg: `eco.quelle` heißt jetzt `eco.source`, der Wert ist immer englisch. Vorhandene Installationen ziehen beim Start um.
 - `statusText`, `programText`, `programPhaseText`, `programTypeText` und `dryingStepText` folgen der Option „Deutsche Namen“ - ist sie aus, sind die Texte englisch (bisher immer deutsch).

package/io-package.json

@@ -1,7 +1,7 @@
 {
   "common": {
     "name": "miele-local",
-    "version": "0.3.45",
+    "version": "0.3.47",
     "titleLang": {
       "en": "Miele@local",
       "de": "Miele@local",
@@ -52,6 +52,32 @@
     "readme": "https://github.com/SmarthomeElektroniker/ioBroker.miele-local/blob/main/README.md",
     "loglevel": "info",
     "news": {
+      "0.3.47": {
+        "en": "Commands that cannot be executed are acknowledged with the reason (state comment and quality) instead of staying unacknowledged; pending commands from before a restart are closed without being sent. Remaining time is 0 while an appliance is off or finished. A lost and restored connection is logged once at info level. The IP fallback search also runs without mDNS and in every subnet with a missing appliance",
+        "de": "Nicht ausführbare Befehle werden mit Grund bestätigt (Kommentar und Qualität des Datenpunkts), statt unbestätigt stehen zu bleiben; offene Befehle von vor einem Neustart werden geschlossen, ohne sie zu senden. Restzeit ist 0, solange ein Gerät aus oder fertig ist. Verbindungsverlust und Wiederkehr stehen je einmal im Log (info). Die IP-Suche bei Ausfall läuft auch ohne mDNS und in jedem Subnetz mit einem fehlenden Gerät",
+        "ru": "Невыполнимые команды подтверждаются с указанием причины (комментарий и качество состояния), а не остаются неподтверждёнными; ожидающие команды до перезапуска закрываются без отправки. Оставшееся время равно 0, пока прибор выключен или завершил работу. Потеря и восстановление связи записываются в журнал один раз (info). Поиск IP при сбое работает и без mDNS, во всех подсетях с отсутствующим прибором",
+        "pt": "Comandos que não podem ser executados são confirmados com o motivo (comentário e qualidade do estado) em vez de ficarem por confirmar; comandos pendentes de antes de um reinício são fechados sem serem enviados. O tempo restante é 0 enquanto o aparelho está desligado ou concluído. Perda e recuperação da ligação são registadas uma vez (info). A procura de IP em caso de falha também funciona sem mDNS e em todas as sub-redes com um aparelho em falta",
+        "nl": "Opdrachten die niet uitgevoerd kunnen worden, worden met de reden bevestigd (commentaar en kwaliteit van de state) in plaats van onbevestigd te blijven; openstaande opdrachten van vóór een herstart worden gesloten zonder ze te verzenden. De resttijd is 0 zolang een apparaat uit of klaar is. Verbindingsverlies en herstel worden één keer gelogd (info). Het zoeken naar het IP-adres bij uitval werkt ook zonder mDNS en in elk subnet met een ontbrekend apparaat",
+        "fr": "Les commandes non exécutables sont acquittées avec la raison (commentaire et qualité de l'état) au lieu de rester non acquittées ; les commandes en attente d'avant un redémarrage sont fermées sans être envoyées. Le temps restant vaut 0 tant qu'un appareil est éteint ou terminé. La perte et le retour de la connexion sont journalisés une seule fois (info). La recherche d'IP en cas de panne fonctionne aussi sans mDNS et dans chaque sous-réseau où un appareil manque",
+        "it": "I comandi non eseguibili vengono confermati con il motivo (commento e qualità dello stato) invece di restare non confermati; i comandi in sospeso precedenti a un riavvio vengono chiusi senza essere inviati. Il tempo residuo è 0 finché l'elettrodomestico è spento o ha finito. Perdita e ripristino della connessione vengono registrati una sola volta (info). La ricerca dell'IP in caso di guasto funziona anche senza mDNS e in ogni sottorete con un elettrodomestico mancante",
+        "es": "Los comandos que no se pueden ejecutar se confirman con el motivo (comentario y calidad del estado) en lugar de quedar sin confirmar; los comandos pendientes de antes de un reinicio se cierran sin enviarse. El tiempo restante es 0 mientras el aparato está apagado o ha terminado. La pérdida y la recuperación de la conexión se registran una sola vez (info). La búsqueda de IP ante un fallo funciona también sin mDNS y en cada subred con un aparato ausente",
+        "pl": "Polecenia, których nie można wykonać, są potwierdzane z podaniem przyczyny (komentarz i jakość stanu), zamiast pozostawać niepotwierdzone; oczekujące polecenia sprzed restartu są zamykane bez wysyłania. Pozostały czas wynosi 0, gdy urządzenie jest wyłączone lub zakończyło pracę. Utrata i powrót połączenia są zapisywane w dzienniku jednorazowo (info). Wyszukiwanie IP po awarii działa także bez mDNS i w każdej podsieci z brakującym urządzeniem",
+        "uk": "Команди, які неможливо виконати, підтверджуються із зазначенням причини (коментар і якість стану), а не залишаються непідтвердженими; очікувані команди до перезапуску закриваються без надсилання. Залишковий час дорівнює 0, поки прилад вимкнений або завершив роботу. Втрата та відновлення зв'язку записуються в журнал один раз (info). Пошук IP при збої працює і без mDNS, у кожній підмережі з відсутнім приладом",
+        "zh-cn": "无法执行的命令会附带原因（状态注释和质量）确认，而不再保持未确认；重启前的待处理命令会被关闭且不发送。电器关闭或程序结束时剩余时间为 0。连接丢失与恢复只在日志中记录一次（info）。IP 故障搜索在没有 mDNS 时也会运行，并覆盖每个缺少电器的子网"
+      },
+      "0.3.46": {
+        "en": "Only the running appliance is polled at the short interval, idle appliances keep the idle interval - fewer requests to the Miele modules (until now all appliances were polled at the short interval as soon as one was running)",
+        "de": "Nur das laufende Gerät wird im kurzen Takt abgefragt, Geräte in Ruhe behalten den Ruhetakt - weniger Anfragen an die Miele-Module (bisher wurden alle Geräte im kurzen Takt abgefragt, sobald eines lief)",
+        "ru": "С коротким интервалом опрашивается только работающий прибор, приборы в покое сохраняют интервал покоя - меньше запросов к модулям Miele (раньше все приборы опрашивались с коротким интервалом, как только работал один)",
+        "pt": "Apenas o aparelho em funcionamento é consultado no intervalo curto, aparelhos inativos mantêm o intervalo de repouso - menos pedidos aos módulos Miele (até agora todos eram consultados no intervalo curto assim que um estava a funcionar)",
+        "nl": "Alleen het draaiende apparaat wordt met het korte interval opgevraagd, apparaten in rust houden het rustinterval - minder verzoeken aan de Miele-modules (tot nu toe werden alle apparaten kort opgevraagd zodra er één draaide)",
+        "fr": "Seul l'appareil en marche est interrogé à l'intervalle court, les appareils au repos gardent l'intervalle de repos - moins de requêtes vers les modules Miele (jusqu'ici tous étaient interrogés à l'intervalle court dès qu'un appareil fonctionnait)",
+        "it": "Solo l'elettrodomestico in funzione viene interrogato all'intervallo breve, quelli inattivi mantengono l'intervallo di riposo - meno richieste ai moduli Miele (finora tutti venivano interrogati all'intervallo breve appena uno era in funzione)",
+        "es": "Solo el aparato en marcha se consulta con el intervalo corto, los aparatos en reposo mantienen el intervalo de reposo - menos peticiones a los módulos Miele (hasta ahora todos se consultaban con el intervalo corto en cuanto uno funcionaba)",
+        "pl": "Tylko pracujące urządzenie jest odpytywane w krótkim interwale, urządzenia w spoczynku zachowują interwał spoczynku - mniej zapytań do modułów Miele (dotąd wszystkie były odpytywane krótko, gdy tylko jedno pracowało)",
+        "uk": "З коротким інтервалом опитується лише працюючий прилад, прилади у спокої зберігають інтервал спокою - менше запитів до модулів Miele (досі всі прилади опитувалися з коротким інтервалом, щойно працював один)",
+        "zh-cn": "只有正在运行的电器使用短间隔轮询，空闲电器保持空闲间隔 - 减少对 Miele 模块的请求（此前只要有一台在运行，所有电器都按短间隔轮询）"
+      },
       "0.3.45": {
         "en": "Only English IDs left: eco.quelle -> eco.source, eco.felderJson -> eco.fieldsJson; settings use English keys (collectorActive, leafStates, energyMeters ...), migrated once on start; text states follow the German names option; background loops never overlap",
         "de": "Nur noch englische IDs: eco.quelle -> eco.source, eco.felderJson -> eco.fieldsJson; Einstellungen mit englischen Namen (collectorActive, leafStates, energyMeters ...), beim Start einmalig übernommen; Textdatenpunkte folgen der Option „Deutsche Namen“; Hintergrundschleifen überlappen nicht mehr",
@@ -116,32 +142,6 @@
         "pl": "Poprawiono typy urządzeń (16 mikrofalówka, 67 piekarnik Dialog, 25 podgrzewacz naczyń, pralko-suszarka z programami pralki); nowe typy: robot sprzątający, piekarnik parowy kombi, piekarnik parowy z mikrofalą (418 programów), urządzenia profesjonalne. Podziękowania dla Home Assistant za tabele.",
         "uk": "Виправлено типи пристроїв (16 мікрохвильова піч, 67 піч Dialog, 25 підігрівач посуду, прально-сушильна машина з програмами пральної машини); нові типи: робот-пилосос, комбі-пароварка, пароварка з мікрохвильовою піччю (418 програм), професійні прилади. Подяка Home Assistant за таблиці.",
         "zh-cn": "修正设备类型（16 微波炉、67 Dialog 烤箱、25 暖碟机、洗干一体机使用洗衣机程序）；新增类型：扫地机器人、蒸烤箱、微波蒸箱（418 个程序）、专业设备。感谢 Home Assistant 提供的表格。"
-      },
-      "0.3.40": {
-        "en": "README: hints for a failing login (ad blocker), moving to another system and why mDNS may find nothing; clearer log message when no appliance is found (#12).",
-        "de": "README: Hinweise bei scheiterndem Login (Werbeblocker), zum Umzug auf ein anderes System und warum mDNS nichts findet; deutlichere Logmeldung, wenn kein Gerät gefunden wird (#12).",
-        "ru": "README: подсказки при неудачном входе (блокировщик рекламы), при переносе на другую систему и о том, почему mDNS ничего не находит; более понятное сообщение в журнале, если устройство не найдено (#12).",
-        "pt": "README: dicas para um login falhado (bloqueador de anúncios), para mudar para outro sistema e porque o mDNS pode não encontrar nada; mensagem de registo mais clara quando nenhum aparelho é encontrado (#12).",
-        "nl": "README: tips bij een mislukte login (adblocker), bij verhuizing naar een ander systeem en waarom mDNS niets vindt; duidelijkere logmelding als er geen apparaat wordt gevonden (#12).",
-        "fr": "README : conseils en cas d'échec de connexion (bloqueur de publicités), pour migrer vers un autre système et pourquoi mDNS ne trouve rien ; message de journal plus clair lorsqu'aucun appareil n'est trouvé (#12).",
-        "it": "README: suggerimenti per un login non riuscito (blocco pubblicità), per il trasferimento su un altro sistema e perché mDNS non trova nulla; messaggio di log più chiaro quando non viene trovato alcun apparecchio (#12).",
-        "es": "README: consejos para un inicio de sesión fallido (bloqueador de anuncios), para migrar a otro sistema y por qué mDNS no encuentra nada; mensaje de registro más claro cuando no se encuentra ningún aparato (#12).",
-        "pl": "README: wskazówki przy nieudanym logowaniu (bloker reklam), przy przenoszeniu na inny system i dlaczego mDNS nic nie znajduje; czytelniejszy komunikat w dzienniku, gdy nie znaleziono urządzenia (#12).",
-        "uk": "README: підказки при невдалому вході (блокувальник реклами), при перенесенні на іншу систему та чому mDNS нічого не знаходить; зрозуміліше повідомлення в журналі, якщо пристрій не знайдено (#12).",
-        "zh-cn": "README：登录失败（广告拦截器）、迁移到其他系统以及 mDNS 找不到设备原因的提示；未找到设备时日志信息更清晰 (#12)。"
-      },
-      "0.3.39": {
-        "en": "Unknown program or phase IDs are shown as \"Programm 201\" instead of keeping the text of the previous program. Dishwasher program IDs of the G7771 added (#13).",
-        "de": "Unbekannte Programm- oder Phasennummern erscheinen als „Programm 201“, statt den Text des vorigen Programms stehen zu lassen. Programmnummern des Geschirrspülers G7771 ergänzt (#13).",
-        "ru": "Неизвестные номера программ или фаз отображаются как «Programm 201», а не сохраняют текст предыдущей программы. Добавлены номера программ посудомоечной машины G7771 (#13).",
-        "pt": "IDs de programa ou fase desconhecidos aparecem como \"Programm 201\" em vez de manter o texto do programa anterior. Adicionados os IDs de programa da máquina de lavar loiça G7771 (#13).",
-        "nl": "Onbekende programma- of fasenummers verschijnen als \"Programm 201\" in plaats van de tekst van het vorige programma te laten staan. Programmanummers van de vaatwasser G7771 toegevoegd (#13).",
-        "fr": "Les numéros de programme ou de phase inconnus s'affichent comme « Programm 201 » au lieu de conserver le texte du programme précédent. Numéros de programme du lave-vaisselle G7771 ajoutés (#13).",
-        "it": "I numeri di programma o di fase sconosciuti vengono mostrati come \"Programm 201\" invece di mantenere il testo del programma precedente. Aggiunti i numeri di programma della lavastoviglie G7771 (#13).",
-        "es": "Los números de programa o fase desconocidos se muestran como \"Programm 201\" en lugar de conservar el texto del programa anterior. Añadidos los números de programa del lavavajillas G7771 (#13).",
-        "pl": "Nieznane numery programów lub faz są wyświetlane jako „Programm 201” zamiast pozostawiać tekst poprzedniego programu. Dodano numery programów zmywarki G7771 (#13).",
-        "uk": "Невідомі номери програм або фаз відображаються як «Programm 201», а не зберігають текст попередньої програми. Додано номери програм посудомийної машини G7771 (#13).",
-        "zh-cn": "未知的程序或阶段编号显示为“Programm 201”，不再保留上一个程序的文本。新增 G7771 洗碗机的程序编号 (#13)。"
       }
     },
     "mode": "daemon",

package/lib/befehle.js

@@ -0,0 +1,138 @@
+'use strict';
+
+/*
+ * Steuerbefehle: ausfuehren oder sauber abschliessen (seit 0.3.47).
+ *
+ * Bis 0.3.46 blieb ein Befehl, der an der Freigabe, am Geraet oder an der Verbindung
+ * scheiterte, mit ack=false stehen. Am 16.10.2026 stand so ein control.powerOn = true seit
+ * 52 Tagen unbestaetigt da (gesetzt am 25.08., die Steuerung war damals aus). Wer den
+ * Datenpunkt liest, haelt das fuer einen Befehl, der noch unterwegs ist.
+ *
+ * Jetzt endet jeder Befehl mit val=false und ack=true. Wurde er nicht ausgefuehrt, steht der
+ * Grund im Kommentarfeld c, und die Qualitaet q ordnet ihn ein - sichtbar im Objektbrowser und
+ * fuer Skripte lesbar. Ein spaeterer erfolgreicher Befehl setzt q wieder auf 0.
+ */
+
+/** ioBroker-Qualitaetscodes, die hier vorkommen. */
+const Q = {
+    INSTANZ: 0x11, // general problem by instance
+    NICHT_VERBUNDEN: 0x42, // device not connected
+    GERAETEFEHLER: 0x44, // device reports error
+};
+
+/**
+ * Einen Befehl abschliessen, der nicht ausgefuehrt wurde.
+ *
+ * @param adapter Adapterinstanz (log, setStateAsync)
+ * @param {string} id vollstaendige ID des Steuer-Datenpunkts
+ * @param {string} sub Name des Befehls (fuers Log)
+ * @param {string} grund Fehlermeldung, englisch
+ * @param {number} q ioBroker-Qualitaetscode
+ */
+async function abschliessen(adapter, id, sub, grund, q) {
+    adapter.log.warn(`Command '${sub}' not executed: ${grund}`);
+    try {
+        await adapter.setStateAsync(id, { val: false, ack: true, q, c: `not executed: ${grund}` });
+    } catch (e) {
+        adapter.log.debug(`${id}: could not acknowledge - ${e.message}`);
+    }
+}
+
+/**
+ * Einen Nutzerbefehl unter control.* verarbeiten.
+ *
+ * @param adapter Adapterinstanz (config, devices, log, setStateAsync, getObjectAsync)
+ * @param {{id: string, deviceId: string, sub: string, val: unknown}} befehl der Befehl
+ * @param {{senden: (dev: object, opcode: number) => Promise<number>, nachErfolg?: () => void}} wege
+ *   senden schickt den Befehl und liefert den HTTP-Status; nachErfolg holt den neuen Zustand
+ */
+async function verarbeiten(adapter, befehl, wege) {
+    const { id, deviceId, sub, val } = befehl;
+    const dev = adapter.devices && adapter.devices[deviceId];
+    if (!dev) {
+        return abschliessen(adapter, id, sub, 'device not connected', Q.NICHT_VERBUNDEN);
+    }
+    if (!adapter.config.allowControl) {
+        return abschliessen(adapter, id, sub, 'device control is disabled in the instance settings', Q.INSTANZ);
+    }
+    if (!val) {
+        // false loest nichts aus - nur bestaetigen, damit nichts offen bleibt.
+        await adapter.setStateAsync(id, { val: false, ack: true });
+        return;
+    }
+    const obj = await adapter.getObjectAsync(id);
+    const opcode = obj && obj.native ? obj.native.opcode : null;
+    if (opcode == null) {
+        return abschliessen(adapter, id, sub, 'unknown command', Q.INSTANZ);
+    }
+    let status;
+    try {
+        status = await wege.senden(dev, opcode);
+    } catch (e) {
+        return abschliessen(
+            adapter,
+            id,
+            sub,
+            `${deviceId} - ${e.message} (remote control might not be supported by the firmware)`,
+            Q.NICHT_VERBUNDEN,
+        );
+    }
+    if (status === 200 || status === 204) {
+        adapter.log.info(`Command '${sub}' sent to ${deviceId} (opcode 0x${opcode.toString(16)}).`);
+        await adapter.setStateAsync(id, { val: false, ack: true });
+        if (wege.nachErfolg) {
+            wege.nachErfolg();
+        }
+        return;
+    }
+    return abschliessen(
+        adapter,
+        id,
+        sub,
+        `HTTP ${status} from ${deviceId} (is MobileStart enabled on the device?)`,
+        Q.GERAETEFEHLER,
+    );
+}
+
+/**
+ * Unbestaetigte Steuerbefehle beim Start schliessen - OHNE sie auszufuehren.
+ *
+ * Ein Befehl, der beim Start noch mit ack=false dasteht, stammt aus einer frueheren Laufzeit:
+ * gesetzt, waehrend der Adapter aus war, oder unter 0.3.46 und frueher gescheitert, ohne
+ * zurueckgesetzt zu werden. Ihn jetzt nachzuholen waere gefaehrlich - ein "Start" von vor
+ * Wochen gehoert nicht an eine Maschine, die inzwischen anders beladen ist.
+ *
+ * @param adapter Adapterinstanz (getStatesAsync, setStateAsync, log)
+ * @returns {Promise<number>} Zahl der geschlossenen Befehle
+ */
+async function offeneSchliessen(adapter) {
+    let offen = {};
+    try {
+        offen = (await adapter.getStatesAsync('*.control.*')) || {};
+    } catch (e) {
+        adapter.log.debug(`Pending commands not checked: ${e.message}`);
+        return 0;
+    }
+    let n = 0;
+    for (const [id, st] of Object.entries(offen)) {
+        if (!st || st.ack !== false) {
+            continue;
+        }
+        const seit = st.ts ? new Date(st.ts).toISOString().slice(0, 10) : 'unknown';
+        adapter.log.info(`${id}: unacknowledged command from ${seit} discarded, not sent to the device`);
+        try {
+            await adapter.setStateAsync(id, {
+                val: false,
+                ack: true,
+                q: Q.INSTANZ,
+                c: `not executed: still pending at adapter start (set ${seit})`,
+            });
+            n++;
+        } catch (e) {
+            adapter.log.debug(`${id}: could not acknowledge - ${e.message}`);
+        }
+    }
+    return n;
+}
+
+module.exports = { Q, abschliessen, verarbeiten, offeneSchliessen };

package/lib/discovery.js

@@ -191,4 +191,29 @@ async function scanSubnet(vorlageIp, log = () => {}, opt = {}) {
     return gefunden;
 }
 
-module.exports = { discover, SERVICE, scanSubnet, istMiele };
+/**
+ * Eine Vorlage-Adresse je /24-Netz, in dem eine der Adressen liegt (Reihenfolge bleibt).
+ *
+ * Bis 0.3.46 suchte der Rueckfall nur im Netz der ERSTEN eingetragenen Adresse. Liegen die
+ * Geraete in verschiedenen Netzen - etwa waehrend eines Umzugs ins IoT-Netz -, blieb ein
+ * Geraet im zweiten Netz unauffindbar.
+ *
+ * @param {string[]} ips Adressen, deren Netze durchsucht werden sollen
+ * @returns {string[]} je Netz die erste passende Adresse
+ */
+function subnetzVorlagen(ips) {
+    const netze = new Map();
+    for (const ip of ips || []) {
+        const teile = String(ip || '').split('.');
+        if (teile.length !== 4) {
+            continue;
+        }
+        const netz = teile.slice(0, 3).join('.');
+        if (!netze.has(netz)) {
+            netze.set(netz, ip);
+        }
+    }
+    return [...netze.values()];
+}
+
+module.exports = { discover, SERVICE, scanSubnet, istMiele, subnetzVorlagen };

package/lib/objects.js

@@ -24,6 +24,34 @@ function timeToMinutes(arr) {
     return arr[0] * 60 + arr[1];
 }
 
+/*
+ * Restzeit nur, wenn es ein Programm gibt (seit 0.3.47).
+ *
+ * Die Spuelmaschine G5840 meldete am 16.10.2026 im Zustand "Aus" (Status 1) eine Restzeit
+ * von [0, 1] - Rohwert des Geraets, im signierten GET /State nachgelesen. Durchgereicht
+ * stand im Datenpunkt "0:01", und daraus wurde ein Programmende eine Minute in der Zukunft
+ * berechnet, das nie kam. Ein ausgeschaltetes, fertiges oder nicht verbundenes Geraet hat
+ * keine Restzeit; die Anzeige des Panels ist dann ein Ueberbleibsel.
+ *
+ * Nicht betroffen sind 2 (An), 3 (programmiert) und 4 (wartet auf Start): Dort zeigt das
+ * Geraet die Dauer des gewaehlten Programms, und die ist eine echte Auskunft.
+ */
+const OHNE_RESTZEIT = new Set([1, 7, 255]);
+
+/**
+ * Setzt die Restzeit eines /State-Datensatzes auf 0, wenn das Geraet kein Programm hat.
+ * Gibt den Datensatz unveraendert zurueck, wenn nichts zu tun ist, sonst eine Kopie.
+ *
+ * @param {Record<string, unknown>} state Rohantwort von /State
+ * @returns {Record<string, unknown>} bereinigter Datensatz
+ */
+function restzeitBereinigen(state) {
+    if (!state || !('RemainingTime' in state) || !OHNE_RESTZEIT.has(Number(state.Status))) {
+        return state;
+    }
+    return { ...state, RemainingTime: [0, 0] };
+}
+
 /**
  * [h, min] → "H:MM"-String (wie mielecloudservice), null bei fehlend.
  *
@@ -850,6 +878,8 @@ module.exports = {
     fieldAllowed,
     nameFor,
     timeToMinutes,
+    restzeitBereinigen,
+    OHNE_RESTZEIT,
     temp,
     pathGet,
     TEMP_SENTINEL,

package/lib/takt.js

@@ -0,0 +1,55 @@
+'use strict';
+
+/*
+ * Abfragetakt je Geraet (seit 0.3.46).
+ *
+ * Bis 0.3.45 galt der kurze Takt fuer ALLE Geraete, sobald eines lief: Backte der Ofen, wurden
+ * Wasch- und Spuelmaschine im Minutentakt mitgefragt, obwohl sie aus waren. Ein XKM-Modul bedient
+ * nur eine Verbindung gleichzeitig - jede ueberfluessige Frage nimmt der Miele-App einen
+ * Zeitschlitz weg. Jetzt hat jedes Geraet seinen eigenen Termin: kurz, solange es laeuft, sonst
+ * der Ruhetakt. Die Schleife wacht zum fruehesten Termin auf und fragt nur, wer dran ist.
+ */
+
+/** Kein Wecken in kuerzeren Abstaenden als diesem - auch wenn mehrere Termine dicht liegen. */
+const MIN_WECKABSTAND_MS = 1000;
+
+/**
+ * Abstand bis zur naechsten Abfrage eines Geraets.
+ *
+ * @param {{active?: boolean}} dev Geraeteeintrag
+ * @param {number} aktivMs Takt im Betrieb
+ * @param {number} ruheMs Takt in Ruhe
+ * @returns {number} Millisekunden
+ */
+function abstand(dev, aktivMs, ruheMs) {
+    return dev && dev.active ? aktivMs : ruheMs;
+}
+
+/**
+ * Ist dieses Geraet jetzt dran? Ein Geraet ohne Termin (gerade gefunden) ist sofort dran.
+ *
+ * @param {{naechsteAbfrage?: number}} dev Geraeteeintrag
+ * @param {number} jetzt Zeitpunkt in ms
+ * @returns {boolean} true, wenn es jetzt abgefragt werden soll
+ */
+function istFaellig(dev, jetzt) {
+    return (dev.naechsteAbfrage || 0) <= jetzt;
+}
+
+/**
+ * Wann die Schleife wieder aufwachen soll: zum fruehesten Termin aller Geraete.
+ *
+ * @param {Array<{naechsteAbfrage?: number}>} geraete alle Geraeteeintraege
+ * @param {number} jetzt Zeitpunkt in ms
+ * @param {number} ruheMs Abstand, wenn (noch) kein Geraet bekannt ist
+ * @returns {number} Millisekunden bis zum naechsten Durchgang
+ */
+function weckAbstand(geraete, jetzt, ruheMs) {
+    if (!geraete.length) {
+        return ruheMs;
+    }
+    const fruehester = Math.min(...geraete.map(d => d.naechsteAbfrage || 0));
+    return Math.max(MIN_WECKABSTAND_MS, fruehester - jetzt);
+}
+
+module.exports = { abstand, istFaellig, weckAbstand, MIN_WECKABSTAND_MS };

package/main.js

@@ -11,7 +11,9 @@ const utils = require('@iobroker/adapter-core');
 const paket = require('./package.json');
 const { MieleCrypto } = require('./lib/crypto');
 const { MieleDeviceApi } = require('./lib/api');
-const { discover, scanSubnet, istMiele } = require('./lib/discovery');
+const { discover, scanSubnet, istMiele, subnetzVorlagen } = require('./lib/discovery');
+const befehle = require('./lib/befehle');
+const takt = require('./lib/takt');
 const cloud = require('./lib/cloud');
 const objdef = require('./lib/objects');
 const namen = require('./lib/names');
@@ -336,11 +338,22 @@ class MieleLocal extends utils.Adapter {
         }
 
         // Periodisches Re-Discovery im Hintergrund (z. B. für Geräte, die aus dem Standby aufwachen)
-        if (this.config.autoDiscover !== false) {
+        /*
+         * Auch ohne mDNS, sobald IPs von Hand eingetragen sind und der IP-Rueckfall an ist.
+         *
+         * Bis 0.3.46 hing die ganze Hintergrundsuche an autoDiscover. Genau dort, wo der
+         * Rueckfall gebraucht wird - Docker-Bridge, mDNS aus, IPs von Hand -, lief er deshalb
+         * nur ein einziges Mal beim Start. Ein Geraet, das danach die Adresse wechselte oder
+         * beim Start nicht erreichbar war, kam bis zum naechsten Neustart nicht zurueck.
+         */
+        const handIps = (this.config.devices || []).some(e => (typeof e === 'string' ? e : e && e.ip));
+        if (this.config.autoDiscover !== false || (this.config.ipFallbackScan !== false && handIps)) {
             const discInterval = MieleLocal.intervallMs(this.config.autoDiscoverInterval, 10, 1, 60000);
             this.schleife('discoveryTimer', () => this.discoverDevices(), discInterval);
         }
 
+        // Erst Altlasten schliessen, dann abonnieren - siehe lib/befehle.js offeneSchliessen().
+        await befehle.offeneSchliessen(this);
         await this.subscribeStatesAsync('*.control.*');
 
         // Push-Listener + Enrollment
@@ -458,17 +471,39 @@ class MieleLocal extends utils.Adapter {
          * und Statistik bleiben also dieselben, nur die Adresse ist neu.
          */
         if (this.config.ipFallbackScan !== false && konfigurierte.length) {
-            const erreichbar = await Promise.all(konfigurierte.map(ip => istMiele(ip, 1500)));
-            const vermisst = konfigurierte.filter((_, i) => !erreichbar[i]);
+            // Nur nachsehen, wo die Abfrage gerade scheitert oder noch nie geklappt hat - ein
+            // laufendes Geraet bekommt keine zusaetzliche Anfrage (das Modul bedient nur eine
+            // Verbindung gleichzeitig).
+            const kandidaten = konfigurierte.filter(ip => {
+                if (this.alteIps && this.alteIps.has(ip)) {
+                    return false; // Geraet laeuft schon unter seiner neuen Adresse
+                }
+                const d = Object.values(this.devices).find(x => x.ip === ip);
+                return !d || d.erreichbar === false;
+            });
+            const erreichbar = await Promise.all(kandidaten.map(ip => istMiele(ip, 1500)));
+            const vermisst = kandidaten.filter((_, i) => !erreichbar[i]);
             /*
-             * Hoechstens alle 30 Minuten.
+             * Hoechstens alle 30 Minuten (mit Verlaengerung, siehe unten).
              *
              * Ist ein Geraet schlicht ausgeschaltet - der Backofen ist es die meiste Zeit -,
              * bleibt es "vermisst", und ohne diese Sperre liefe bei jedem Discovery-Lauf ein
              * Subnetz-Scan, der nichts Neues findet.
              */
+            /*
+             * Findet ein Scan nichts Neues, verdoppelt sich die Pause bis auf vier Stunden.
+             *
+             * Ein Geraet, das nach einem WLAN-Ausfall einfach nicht zurueckkommt (Waschmaschine,
+             * 16.10.2026), wuerde sonst die ganze Nacht alle 30 Minuten 254 Adressen abklopfen
+             * und zwei Logzeilen schreiben. Sobald alle wieder antworten oder eine neue Adresse
+             * auftaucht, gilt wieder die kurze Pause.
+             */
+            const pauseMs = this.scanPauseMs || 30 * 60 * 1000;
+            if (!vermisst.length) {
+                this.scanPauseMs = 30 * 60 * 1000;
+            }
             const seitLetztem = Date.now() - (this.letzterScan || 0);
-            if (vermisst.length && seitLetztem < 30 * 60 * 1000) {
+            if (vermisst.length && seitLetztem < pauseMs) {
                 this.log.debug(
                     `${vermisst.length} device(s) not reachable, last subnet scan ` +
                         `${Math.round(seitLetztem / 60000)} min ago - waiting`,
@@ -479,14 +514,24 @@ class MieleLocal extends utils.Adapter {
                     `${vermisst.length} configured device(s) not responding ` +
                         `(${vermisst.join(', ')}) - searching the subnet for the new address`,
                 );
-                const imNetz = await scanSubnet(konfigurierte[0], m => this.log.info(m));
+                // Jedes Subnetz, in dem ein Geraet fehlt - nicht nur das der ersten Adresse.
+                const imNetz = [];
+                for (const vorlage of subnetzVorlagen(vermisst)) {
+                    imNetz.push(...(await scanSubnet(vorlage, m => this.log.info(m))));
+                }
+                let neue = 0;
                 for (const ip of imNetz) {
                     if (!seenIp.has(ip)) {
                         found.push({ ip, techType: '', deviceType: null });
                         seenIp.add(ip);
+                        neue++;
                         this.log.info(`New address found: ${ip}`);
                     }
                 }
+                this.scanPauseMs = neue ? 30 * 60 * 1000 : Math.min(4 * 60 * 60 * 1000, pauseMs * 2);
+                if (!neue) {
+                    this.log.info(`No new address found - next subnet search in ${this.scanPauseMs / 60000} min`);
+                }
             }
         }
 
@@ -495,7 +540,8 @@ class MieleLocal extends utils.Adapter {
         }
 
         for (const f of found) {
-            const alreadyKnown = Object.values(this.devices).some(d => d.ip === f.ip);
+            const alreadyKnown =
+                Object.values(this.devices).some(d => d.ip === f.ip) || (this.alteIps && this.alteIps.has(f.ip));
             if (!alreadyKnown) {
                 try {
                     await this.initDevice(f);
@@ -560,6 +606,15 @@ class MieleLocal extends utils.Adapter {
             // Vor allem anderen: was aus 0.3.37 noch unter deutschen IDs liegt, umziehen.
             await this.idsUmziehen(deviceId);
 
+            const vorher = this.devices[deviceId];
+            if (vorher && vorher.ip !== f.ip) {
+                // Gefunden ueber den IP-Rueckfall: dieselbe Seriennummer unter neuer Adresse.
+                this.alteIps = this.alteIps || new Set();
+                this.alteIps.add(vorher.ip);
+                this.log.info(
+                    `${deviceId}: now at ${f.ip} (was ${vorher.ip}) - please update the IP on the 'Appliances' tab`,
+                );
+            }
             this.devices[deviceId] = { ip: f.ip, route, deviceType, api, active: false };
             /*
              * Die Sammlungsobjekte schon beim Verbinden anlegen, nicht erst am Zyklusende.
@@ -888,6 +943,9 @@ class MieleLocal extends utils.Adapter {
         if ('Status' in state && !(await this.statusPlausibel(deviceId, state.Status))) {
             return;
         }
+        // Restzeit eines ausgeschalteten/fertigen Geraets ist ein Ueberbleibsel - siehe
+        // objects.restzeitBereinigen. Vor dem Dekodieren, damit auch das Programmende stimmt.
+        state = objdef.restzeitBereinigen(state);
         // Fuer die Einschalt-Erkennung: was stand vorher da?
         const statusVorher =
             'Status' in state ? ((await this.getStateAsync(`${deviceId}.state.status`)) || {}).val : null;
@@ -2164,19 +2222,41 @@ class MieleLocal extends utils.Adapter {
         this._histCreated[deviceId] = true;
     }
 
+    /**
+     * Abstand bis zur naechsten Abfrage EINES Geraets: kurz, solange es laeuft, sonst der Ruhetakt.
+     *
+     * Bis 0.3.45 galt der kurze Takt fuer ALLE Geraete, sobald eines lief - backte der Ofen,
+     * wurden Wasch- und Spuelmaschine im Minutentakt mitgefragt, obwohl sie aus waren. Ein
+     * XKM-Modul bedient nur eine Verbindung; jede ueberfluessige Frage nimmt der Miele-App
+     * einen Zeitschlitz weg.
+     *
+     * @param dev Geraeteeintrag aus this.devices
+     */
+    abstandFuer(dev) {
+        return takt.abstand(
+            dev,
+            MieleLocal.intervallMs(this.config.activePollInterval, 5, 1),
+            MieleLocal.intervallMs(this.config.pollInterval, 15, 1),
+        );
+    }
+
     schedulePoll(immediate = false) {
         if (this.pollTimer) {
             this.clearTimeout(this.pollTimer);
         }
-        const anyActive = Object.values(this.devices).some(d => d.active);
-        const interval = anyActive
-            ? MieleLocal.intervallMs(this.config.activePollInterval, 5, 1)
-            : MieleLocal.intervallMs(this.config.pollInterval, 15, 1);
+        // Geweckt wird zur naechsten faelligen Abfrage irgendeines Geraets; pollAll(true) fragt
+        // dann nur die faelligen. Ein Geraet ohne Termin (neu gefunden) ist sofort faellig.
+        const interval = takt.weckAbstand(
+            Object.values(this.devices),
+            Date.now(),
+            MieleLocal.intervallMs(this.config.pollInterval, 15, 1),
+        );
         const run = async () => {
             if (this.stopping) {
                 return;
             }
-            await this.pollAll();
+            // Ein sofortiger Durchgang (nach einem Schreibbefehl) fragt alle, sonst nur die faelligen.
+            await this.pollAll(!immediate);
             this.schedulePoll(false);
         };
         const nextDelayMs = immediate ? 100 : interval;
@@ -2286,7 +2366,7 @@ class MieleLocal extends utils.Adapter {
      * stauten sich am Modul. Jetzt gibt es nie zwei Laeufe derselben Aufgabe gleichzeitig.
      *
      * @param {string} name Feld, in dem der Timer steht (fuer clearTimeout in onUnload)
-     * @param {() => any} aufgabe die Aufgabe; darf ein Promise liefern
+     * @param {() => (void | Promise<void>)} aufgabe die Aufgabe; darf ein Promise liefern
      * @param {number} abstandMs Pause zwischen Ende eines Laufs und Beginn des naechsten
      */
     schleife(name, aufgabe, abstandMs) {
@@ -3180,9 +3260,20 @@ class MieleLocal extends utils.Adapter {
         return 1500;
     }
 
-    async pollAll() {
+    /**
+     * Alle Geraete abfragen - oder nur die, deren Termin gekommen ist (siehe abstandFuer()).
+     *
+     * @param nurFaellige true: Geraete mit spaeterem Termin auslassen
+     */
+    async pollAll(nurFaellige = false) {
         let ok = false;
+        const jetzt = Date.now();
         for (const [deviceId, dev] of Object.entries(this.devices)) {
+            if (nurFaellige && !takt.istFaellig(dev, jetzt)) {
+                // Nicht dran - fuer info.connection zaehlt sein letzter Stand.
+                ok = ok || dev.erreichbar === true;
+                continue;
+            }
             // Zweiter Anlauf, bevor ein Abruf als Fehler gilt. Das XKM-Modul der Geraete legt im
             // laufenden Betrieb sporadisch auf ("read ECONNRESET") oder antwortet kurz mit 404 -
             // am 23.08.2026 an der laufenden Waschmaschine mit 21 % der Abrufe gemessen, waehrend
@@ -3215,6 +3306,29 @@ class MieleLocal extends utils.Adapter {
             if (fehler) {
                 await this.setStateAsync(`${deviceId}.info.connected`, { val: false, ack: true });
             }
+            /*
+             * Den Wechsel einmal melden, nicht jeden Fehlversuch.
+             *
+             * Bis 0.3.46 stand ein Ausfall nur im debug-Log - auf Stufe info sah man nichts,
+             * waehrend die Waschmaschine am 16.10.2026 nach einem WLAN-Ausfall stundenlang
+             * verschwunden blieb. Jede Abfrage einzeln auf info zu heben waere das Gegenteil:
+             * alle zwei Minuten dieselbe Zeile. Also: eine Zeile beim Wegfall, eine bei der
+             * Rueckkehr, dazwischen nur debug.
+             */
+            if (fehler && dev.erreichbar !== false) {
+                this.log.info(
+                    `${deviceId} (${dev.ip}) not reachable: ${fehler.message} - ` +
+                        `still trying every ${Math.round(this.abstandFuer(dev) / 1000)} s`,
+                );
+                dev.wegSeit = Date.now();
+            } else if (!fehler && dev.erreichbar === false) {
+                const min = dev.wegSeit ? Math.round((Date.now() - dev.wegSeit) / 60000) : null;
+                this.log.info(`${deviceId} (${dev.ip}) reachable again${min !== null ? ` after ${min} min` : ''}`);
+                dev.wegSeit = null;
+            }
+            dev.erreichbar = !fehler;
+            // Erst nach applyState: dev.active ist dann auf dem Stand dieser Abfrage.
+            dev.naechsteAbfrage = Date.now() + this.abstandFuer(dev);
             await this.verbucheAbfrage(deviceId, fehler, wiederholt && !fehler);
         }
         await this.setStateAsync('info.connection', { val: ok, ack: true });
@@ -4170,52 +4284,28 @@ class MieleLocal extends utils.Adapter {
         if (idx < 0) {
             return;
         }
-        const deviceId = parts[idx - 1];
-        const sub = parts[idx + 1];
-        const dev = this.devices[deviceId];
-        if (!dev) {
-            return;
-        }
-        if (!this.config.allowControl) {
-            this.log.warn('Device control is disabled in instance settings.');
-            return;
-        }
-        if (!state.val) {
-            return;
-        } // nur bei true auslösen
-
-        const obj = await this.getObjectAsync(id);
-        const opcode = obj && obj.native ? obj.native.opcode : null;
-        if (opcode == null) {
-            return;
-        }
-
-        try {
-            const payload = buildUserRequest(opcode);
-            const status = await dev.api.put(
-                `Devices/${dev.route}/DOP2/${USER_REQ_UNIT}/${USER_REQ_LEAF}?idx1=0&idx2=0`,
-                payload,
-            );
-            if (status === 200 || status === 204) {
-                this.log.info(`Command '${sub}' sent to ${deviceId} (opcode 0x${opcode.toString(16)}).`);
-                await this.setStateAsync(id, { val: false, ack: true });
-                // Polling kurz pausieren, dann gezielt den neuen Zustand holen.
-                this.pausePollUntil = Date.now() + 2500;
-                if (this.pollTimer) {
-                    this.clearTimeout(this.pollTimer);
-                }
-                this.setTimeout(async () => {
-                    await this.pollAll();
-                    this.schedulePoll(false);
-                }, 2600);
-            } else {
-                this.log.warn(`Command '${sub}' to ${deviceId}: HTTP ${status} (is MobileStart enabled on device?).`);
-            }
-        } catch (e) {
-            this.log.warn(
-                `Command '${sub}' to ${deviceId} failed: ${e.message} (remote control might not be supported by firmware).`,
-            );
-        }
+        await befehle.verarbeiten(
+            this,
+            { id, deviceId: parts[idx - 1], sub: parts[idx + 1], val: state.val },
+            {
+                senden: (dev, opcode) =>
+                    dev.api.put(
+                        `Devices/${dev.route}/DOP2/${USER_REQ_UNIT}/${USER_REQ_LEAF}?idx1=0&idx2=0`,
+                        buildUserRequest(opcode),
+                    ),
+                nachErfolg: () => {
+                    // Polling kurz pausieren, dann gezielt den neuen Zustand holen.
+                    this.pausePollUntil = Date.now() + 2500;
+                    if (this.pollTimer) {
+                        this.clearTimeout(this.pollTimer);
+                    }
+                    this.setTimeout(async () => {
+                        await this.pollAll();
+                        this.schedulePoll(false);
+                    }, 2600);
+                },
+            },
+        );
     }
 
     startPush() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iobroker.miele-local",
-  "version": "0.3.45",
+  "version": "0.3.47",
   "description": "Connect modern Miele@Home appliances locally without the internet (MieleH256/DOP2).",
   "author": "Immanuel <github@freitag.online>",
   "license": "MIT",