Release 1.8.1

Author: hhi

.homeychangelog.json

@@ -1,4 +1,8 @@
 {
+  "1.8.1": {
+    "en": "Improved handling of non-responsive Modbus servers that keep the TCP socket open. Poll timeouts now mark the device unavailable and force a reconnect, while stale Modbus services and sockets are cleaned up during failed connects and reconnects to prevent resource buildup during long outages. Homey visible connection recovery now waits for a valid Modbus snapshot instead of TCP connect alone, and restores availability and connection capabilities before refreshing device values.",
+    "nl": "Verbeterde afhandeling van Modbus-servers die niet meer reageren maar de TCP-socket open houden. Poll-timeouts zetten het apparaat nu op onbeschikbaar en forceren een reconnect, terwijl oude Modbus-services en sockets worden opgeruimd bij mislukte connects en reconnects om resource-opbouw tijdens lange storingen te voorkomen. Zichtbaar verbindingsherstel in Homey wacht nu op een geldige Modbus-snapshot in plaats van alleen een TCP-connect, en herstelt beschikbaarheid en verbindingscapabilities voordat apparaatwaarden worden ververst."
+  },
   "1.8.0": {
     "en": "Backported the adaptive control and building model improvements from the sister Modbus project. Building model learning is now more resilient with sample gating for non-heating and defrost states, per-sample persistence, stronger state validation, covariance safeguards, and excitation diagnostics. Adaptive control now uses a fixed comfort anchor, improved accumulator settlement, additive wind correction, nullable outdoor-temperature handling, and expanded unit/simulation tests.",
     "nl": "De verbeteringen voor adaptieve regeling en gebouwmodel uit het zuster Modbus-project zijn overgenomen. Het gebouwmodel leert nu robuuster met sample-gating voor niet-verwarmen en ontdooien, persistentie per geaccepteerde sample, strengere state-validatie, covariance-bescherming en excitation-diagnostiek. De adaptieve regeling gebruikt nu een vast comfort-anker, betere accumulator-settlement, additieve windcorrectie, expliciete afhandeling van ontbrekende buitentemperatuur en uitgebreide unit-/simulatietests."

.homeycompose/app.json

@@ -1,6 +1,6 @@
 {
   "id": "org.hhi.adlar3-heatpump-modbus",
-  "version": "1.8.0",
+  "version": "1.8.1",
   "compatibility": ">=12.3.0",
   "sdk": 3,
   "platforms": ["local"],

app.json

@@ -1,7 +1,7 @@
 {
   "_comment": "This file is generated. Please edit .homeycompose/app.json instead.",
   "id": "org.hhi.adlar3-heatpump-modbus",
-  "version": "1.8.0",
+  "version": "1.8.1",
   "compatibility": ">=12.3.0",
   "sdk": 3,
   "platforms": [

lib/modbus/modbus-tcp-service.ts

@@ -328,6 +328,8 @@ export class ModbusTcpService extends EventEmitter {
     if (this._connected) {
       this._connected = false;
       this._gracefulClose();
+    } else {
+      this.socket.destroy();
     }
     this.removeAllListeners();
   }

lib/services/modbus-connection-service.ts

@@ -51,6 +51,8 @@ export class ModbusConnectionService<TSnapshot = DataSnapshot> extends EventEmit
   private service: ModbusRuntimeService<TSnapshot> | null = null;
   private connected = false;
   private retryTimer: ReturnType<typeof setTimeout> | null = null;
+  private lastConfig: ModbusConnectionConfig | null = null;
+  private reconnecting = false;
 
   private readonly createService: ModbusConnectionOptions<TSnapshot>['createService'];
   private readonly onData: (snapshot: TSnapshot) => void;
@@ -77,18 +79,35 @@ export class ModbusConnectionService<TSnapshot = DataSnapshot> extends EventEmit
    * Connect to the Modbus device using the provided config.
    */
   async connect(config: ModbusConnectionConfig): Promise<void> {
+    this.lastConfig = config;
     this.logger('ModbusConnectionService: Connecting to', config.host);
 
+    if (this.retryTimer) {
+      this.device.homey.clearTimeout(this.retryTimer);
+      this.retryTimer = null;
+    }
+
+    if (this.service) {
+      const oldService = this.service;
+      this.service = null;
+      this.connected = false;
+      await oldService.destroy().catch((err: Error) => {
+        this.logger('ModbusConnectionService: Error destroying previous service before reconnect:', err.message);
+      });
+    }
+
     const timerProvider: TimerProvider = {
       setTimeout: this.device.homey.setTimeout.bind(this.device.homey),
       setInterval: this.device.homey.setInterval.bind(this.device.homey),
       clearTimeout: this.device.homey.clearTimeout.bind(this.device.homey),
       clearInterval: this.device.homey.clearInterval.bind(this.device.homey),
     };
 
-    this.service = this.createService({ config, timerProvider });
+    const service = this.createService({ config, timerProvider });
+    this.service = service;
 
-    this.service.on('connected', () => {
+    service.on('connected', () => {
+      if (this.service !== service) return;
       this.connected = true;
       this.logger('ModbusConnectionService: Connected');
       const superfast = config.pollSuperfastMs ?? 5_000;
@@ -99,7 +118,7 @@ export class ModbusConnectionService<TSnapshot = DataSnapshot> extends EventEmit
       const slow = config.pollSlowMs ?? 300_000;
       const staggerMs = this._firstConnect ? 300 : 0;
       this._firstConnect = false;
-      this.service!.startPolling({
+      service.startPolling({
         superfast,
         superfastAdaptive,
         superfastAdaptiveMs,
@@ -111,26 +130,31 @@ export class ModbusConnectionService<TSnapshot = DataSnapshot> extends EventEmit
       this.onConnected();
     });
 
-    this.service.on('disconnected', (reason: string) => {
+    service.on('disconnected', (reason: string) => {
+      if (this.service !== service) return;
       this.connected = false;
       this.logger('ModbusConnectionService: Disconnected:', reason);
       this.onDisconnected(reason);
     });
 
-    this.service.on('reconnecting', (attempt: number, delayMs: number) => {
+    service.on('reconnecting', (attempt: number, delayMs: number) => {
+      if (this.service !== service) return;
       this.logger(`ModbusConnectionService: Reconnect attempt #${attempt} in ${delayMs}ms`);
     });
 
-    this.service.on('data', (snapshot: TSnapshot) => {
+    service.on('data', (snapshot: TSnapshot) => {
+      if (this.service !== service) return;
       this.onData(snapshot);
     });
 
-    this.service.on('error', (err: Error, ctx: string) => {
+    service.on('error', (err: Error, ctx: string) => {
+      if (this.service !== service) return;
       this.logger(`ModbusConnectionService: Error [${ctx}]:`, err.message);
       this.onError(err, ctx);
     });
 
-    this.service.on('poll-group-succeeded', (groupName: string) => {
+    service.on('poll-group-succeeded', (groupName: string) => {
+      if (this.service !== service) return;
       this.onPollGroupSucceeded?.(groupName);
     });
 
@@ -141,16 +165,55 @@ export class ModbusConnectionService<TSnapshot = DataSnapshot> extends EventEmit
     }
 
     try {
-      await this.service.connect();
+      await service.connect();
     } catch (err) {
       this.logger('ModbusConnectionService: Initial connect failed, will retry in 30s:', (err as Error).message);
+      if (this.service === service) {
+        this.service = null;
+        this.connected = false;
+      }
+      await service.destroy().catch((destroyErr: Error) => {
+        this.logger('ModbusConnectionService: Error destroying failed service:', destroyErr.message);
+      });
       this.retryTimer = this.device.homey.setTimeout(async () => {
         this.retryTimer = null;
         await this.connect(config);
       }, 30_000);
     }
   }
 
+  async forceReconnect(reason: string): Promise<void> {
+    if (!this.lastConfig) {
+      this.logger('ModbusConnectionService: Cannot force reconnect without previous config');
+      return;
+    }
+    if (this.reconnecting) {
+      this.logger('ModbusConnectionService: Force reconnect already in progress');
+      return;
+    }
+
+    this.reconnecting = true;
+    this.logger(`ModbusConnectionService: Force reconnect (${reason})`);
+
+    if (this.retryTimer) {
+      this.device.homey.clearTimeout(this.retryTimer);
+      this.retryTimer = null;
+    }
+
+    const oldService = this.service;
+    this.service = null;
+    this.connected = false;
+
+    try {
+      if (oldService) {
+        await oldService.destroy();
+      }
+      await this.connect(this.lastConfig);
+    } finally {
+      this.reconnecting = false;
+    }
+  }
+
   /**
    * Write a setpoint to the device.
    */

lib/services/service-coordinator.ts

@@ -391,10 +391,10 @@ export class ServiceCoordinator {
       }
     }
 
-    // ADR-043 Fase 2c: reset naar online alleen als non-fast teller ook schoon is
-    if (this._connectionQuality !== 'online'
-        && this._consecutiveNonFastRequiredFailures === 0) {
-      this._setConnectionQuality('online');
+    // Een geldige fast/superfast snapshot bewijst dat Modbus weer antwoordt.
+    // Herstel Homey beschikbaarheid vóór capability-writes, ook na poll-timeout offline.
+    if (this._connectionQuality !== 'online' || !this._visibleConnectionConnected) {
+      this._markPollRecoveredOnline();
     }
 
     // Forward snapshot to device for capability updates
@@ -463,18 +463,13 @@ export class ServiceCoordinator {
       this.logger('ServiceCoordinator: Disconnect status timer cancelled (reconnected in time)');
     }
 
-    // ADR-042/043: reset failure counters en zet quality op online via _setConnectionQuality
-    // (die roept ook setAvailable() aan)
+    // TCP connect alleen is onvoldoende bewijs dat Modbus weer gezond is:
+    // bridges/servers kunnen de socket accepteren terwijl register reads blijven hangen.
+    // Homey-visible herstel gebeurt daarom pas bij een geldige Modbus snapshot.
     this._consecutiveFastPollFailures = 0;
     this._consecutiveSuperfastPollFailures = 0;
     this._consecutiveNonFastRequiredFailures = 0;
     this._errorCountByContext.clear();
-    this._setConnectionQuality('online');
-    this.energyTracking.setConnectionState(true).catch((e) => {
-      this.logger('ServiceCoordinator: setConnectionState(true) failed', e);
-    });
-    this._setConnectionCapabilities(true, null);
-    this.adaptiveControl.onConnectionRestored();
   }
 
   private _handleDisconnected(reason: string): void {
@@ -640,6 +635,7 @@ export class ServiceCoordinator {
           this._degradedSinceTimer = null;
           this.logger('ServiceCoordinator: Degraded timeout — setting offline');
           this._setConnectionQuality('offline');
+          this._markPollTimeoutOffline();
         }, ServiceCoordinator.DEGRADED_TO_OFFLINE_MS);
       }
     } else {
@@ -650,6 +646,9 @@ export class ServiceCoordinator {
     }
 
     if (quality === 'online') {
+      if (!this._visibleConnectionConnected) {
+        this._setConnectionCapabilities(true, null);
+      }
       // ADR-043 Fase 2d: structurele warning heeft hogere prioriteit dan schone online-status
       if (this._structurallyUnsupportedFast) {
         this.device
@@ -665,6 +664,44 @@ export class ServiceCoordinator {
         .catch(() => {});
     }
     // 'offline' wordt via de bestaande _disconnectStatusTimer afgehandeld
+    // behalve bij poll-timeout zonder socket-disconnect; dat pad gebruikt _markPollTimeoutOffline().
+  }
+
+  private _markPollTimeoutOffline(): void {
+    const wasVisiblyConnected = this._visibleConnectionConnected;
+    this._setConnectionCapabilities(false, 'poll timeout');
+    if (wasVisiblyConnected) {
+      this._incrementDailyDisconnectCount();
+    }
+    this.device
+      .setUnavailable('Modbus reageert niet op polling')
+      .catch(() => {});
+    this.modbusConnection.forceReconnect('poll timeout').catch((err) => {
+      this.logger('ServiceCoordinator: Force reconnect after poll timeout failed', err);
+    });
+  }
+
+  private _markPollRecoveredOnline(): void {
+    this._consecutiveFastPollFailures = 0;
+    this._consecutiveSuperfastPollFailures = 0;
+    this._consecutiveNonFastRequiredFailures = 0;
+    this._errorCountByContext.clear();
+
+    this._setConnectionQuality('online');
+
+    if (!this._visibleConnectionConnected) {
+      this._setConnectionCapabilities(true, null);
+    }
+
+    if (!this._structurallyUnsupportedFast) {
+      this.device.setAvailable().catch(() => {});
+      this.device.setWarning(null).catch(() => {});
+    }
+
+    this.energyTracking.setConnectionState(true).catch((e) => {
+      this.logger('ServiceCoordinator: setConnectionState(true) after poll recovery failed', e);
+    });
+    this.adaptiveControl.onConnectionRestored();
   }
 
   // ── Public API ─────────────────────────────────────────────────────────────

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "org.hhi.adlar3-heatpump-modbus",
-  "version": "1.8.0",
+  "version": "1.8.1",
   "engines": {
     "node": ">=12.16.1"
   },