@@ -14,17 +14,18 @@
     single socket (the dongle rejects concurrent/burst connections)
   * automatic reconnect + retry when the dongle drops the connection
 
-IMPORTANT — matches lxp-bridge (LuxPower's own reference) exactly:
+IMPORTANT — matches lxp-bridge (LuxPower's own reference):
 
-  * lxp-bridge default is `heartbeats: false`; it relies on TCP keepalive
-    (60s) to hold the connection, NOT proactive heartbeat packets.
-  * When heartbeats ARE enabled, lxp-bridge is REACTIVE: it only echoes back
-    a heartbeat the dongle sends; it never initiates one.
-
-We deliberately do NOT send proactive heartbeats. Sending unsolicited
-protocol=2 heartbeat packets interleaved with protocol=1 read/write traffic
-causes the dongle to close the connection ("Broken pipe"), which is exactly
-the flakiness we are eliminating.
+  * lxp-bridge sends a Heartbeat (0xC1, protocol=2) after 120s of silence
+    to keep the dongle session alive (inverter.rs: "If no messages received
+    for 120 seconds, send a heartbeat"). We do the same via a background
+    heartbeat thread.
+  * lxp-bridge waits RECONNECT_DELAY_SECS=5 between reconnection attempts;
+    we use the same delay to avoid wedging the dongle's session state with
+    rapid-fire reconnects.
+  * We also detect stale responses: if the dongle returns byte-identical
+    register data across consecutive reads, we force a full reconnect
+    instead of trusting the cached response.
 
 Both the API (reads + writes) and the collector (polling) use this class.
 """
@@ -35,7 +36,7 @@
 import time
 from typing import Callable, Optional
 
-from ..protocol import find_frames
+from ..protocol import find_frames, build_heartbeat
 
 logger = logging.getLogger("luxmon.comm.persistent")
 
@@ -69,16 +70,38 @@ def __init__(
         self._connect_count = 0
         self._tx_count = 0
 
+        # Heartbeat thread: keeps the dongle session alive (lxp-bridge sends
+        # a heartbeat after 120s of silence). Started in start(), stopped in
+        # stop().
+        self._hb_thread: Optional[threading.Thread] = None
+        self._hb_stop = threading.Event()
+        self._hb_interval = 60.0  # check every 60s; send if 120s+ silence
+
+        # Staleness detection: remember the last response signature so we can
+        # detect the dongle serving frozen/cached data (the 9/7 wedge).
+        self._last_resp_sig: Optional[bytes] = None
+        self._stale_count = 0
+        self._stale_threshold = 5  # N identical responses => force reconnect
+
     # ── lifecycle ────────────────────────────────────────────────────────────
 
     def start(self) -> None:
-        """Open the connection."""
+        """Open the connection and start the heartbeat thread."""
         self._connect()
+        self._hb_stop.clear()
+        self._hb_thread = threading.Thread(
+            target=self._heartbeat_loop, name="lux-dongle-heartbeat", daemon=True
+        )
+        self._hb_thread.start()
         logger.info(
             "Persistent dongle connection started (%s:%d)", self.host, self.port
         )
 
     def stop(self) -> None:
+        self._hb_stop.set()
+        if self._hb_thread is not None:
+            self._hb_thread.join(timeout=2.0)
+            self._hb_thread = None
         with self._lock:
             if self._sock is not None:
                 try:
@@ -138,6 +161,65 @@ def _ensure_connected(self) -> None:
                 self._sock = None
         self._connect()
 
+    # ── heartbeat ───────────────────────────────────────────────────────────
+
+    def _heartbeat_loop(self) -> None:
+        """Send a heartbeat after 120s of silence (matches lxp-bridge).
+
+        The dongle expects periodic traffic to keep the session alive. If we
+        go silent too long, the session goes stale and the dongle starts
+        serving cached data (the 9/7 wedge). lxp-bridge sends a Heartbeat
+        (0xC1, protocol=2) after 120s of no received messages; we mirror that.
+        """
+        last_rx = time.time()
+        while not self._hb_stop.wait(self._hb_interval):
+            with self._lock:
+                if self._sock is None:
+                    continue
+                # Track last successful receive time via a lightweight probe.
+                try:
+                    self._sock.settimeout(0.2)
+                    self._sock.recv(1, socket.MSG_PEEK)
+                    self._sock.settimeout(self.timeout)
+                except socket.timeout:
+                    pass  # no pending data — connection alive
+                except OSError:
+                    self._sock = None
+                    continue
+                if time.time() - last_rx >= 120:
+                    try:
+                        hb = build_heartbeat(self.datalog_serial)
+                        self._sock.sendall(hb)
+                        self._tx_count += 1
+                        logger.debug("Sent heartbeat to dongle")
+                    except OSError as exc:
+                        logger.warning("Heartbeat send failed: %s", exc)
+                        self._sock = None
+                    last_rx = time.time()
+
+    # ── staleness detection ──────────────────────────────────────────────────
+
+    def _note_response(self, raw: bytes) -> None:
+        """Track response signatures to detect frozen/cached dongle data."""
+        if raw == self._last_resp_sig:
+            self._stale_count += 1
+            if self._stale_count >= self._stale_threshold:
+                logger.warning(
+                    "Dongle returned identical data %d times — forcing reconnect "
+                    "(possible stale/cached response)",
+                    self._stale_count,
+                )
+                self._stale_count = 0
+                if self._sock is not None:
+                    try:
+                        self._sock.close()
+                    except OSError:
+                        pass
+                    self._sock = None
+        else:
+            self._last_resp_sig = raw
+            self._stale_count = 0
+
     # ── transactions ────────────────────────────────────────────────────────
 
     def transact(
@@ -185,6 +267,10 @@ def transact(
                         buffer += chunk
                         for frame in find_frames(buffer):
                             if match(frame):
+                                # Staleness guard: identical responses across
+                                # consecutive reads => dongle serving cached
+                                # data; force a reconnect.
+                                self._note_response(frame.raw)
                                 return frame
                     # If we got here without a match and the socket is still
                     # alive, the dongle simply didn't answer this request.
@@ -202,7 +288,7 @@ def transact(
                         except OSError:
                             pass
                         self._sock = None
-                time.sleep(0.4 * (attempt + 1))
+                time.sleep(5.0)  # lxp-bridge RECONNECT_DELAY_SECS
             return None
 
 
 
@@ -755,6 +755,48 @@ def build_write_multi_request(
     return bytes(pkt)
 
 
+def build_heartbeat(datalog_serial: str) -> bytes:
+    """
+    Build a Heartbeat (0xC1) packet, matching lxp-bridge's Heartbeat frame.
+
+    lxp-bridge sends this after 120s of silence to keep the dongle session
+    alive. Packet layout (from lxp-bridge packet.rs / TcpFrameFactory):
+        [0-1]   Header: 0xA1 0x1A
+        [2-3]   Protocol: 2 (LE u16)  -- heartbeat uses protocol 2
+        [4-5]   Frame length: 19 (LE u16)  -- 6 header + 13 payload
+        [6]     Unknown: 0x01
+        [7]     TCP function: 0xC1 (Heartbeat)
+        [8-17]  Datalog serial (10 bytes)
+        [18]    Data length: 0 (heartbeat has no data payload)
+    Total packet size: 19 bytes.
+    """
+    pkt = bytearray(19)
+
+    # Header
+    pkt[0:2] = PREFIX
+
+    # Protocol = 2 (heartbeat)
+    struct.pack_into('<H', pkt, 2, 2)
+
+    # Frame length = 13 (19 - 6)
+    struct.pack_into('<H', pkt, 4, 13)
+
+    # Unknown byte
+    pkt[6] = 0x01
+
+    # TCP function: Heartbeat
+    pkt[7] = TCP_FUNC_HEARTBEAT
+
+    # Datalog serial
+    pkt[8:18] = _serial_to_bytes(datalog_serial)
+
+    # Data length = 0 (no payload)
+    pkt[18] = 0
+
+    return bytes(pkt)
+
+
+
 # ── Frame Parser ────────────────────────────────────────────────────
 
 def parse_frame(data: bytes) -> Optional[LuxFrame]:
 
@@ -0,0 +1,45 @@
+#!/usr/bin/env bash
+# lux-mon dongle freeze monitor
+# Detects when the inverter data goes stale (frozen registers) and alerts.
+# Checks: latest snapshot timestamp freshness + register value stability.
+# Usage: lux-mon-freeze-check.sh  (run from cron/heartbeat)
+# Exit 0 = healthy, exit 2 = frozen/stale (alert condition)
+
+DB_USER="luxmon"
+DB_PASS="_X6XHeXOqrQ638Zo6oTA--YcWXpk7wJV"
+DB_NAME="luxmon"
+
+# 1. Latest snapshot freshness (should be < 60s old)
+LATEST_TS=$(docker exec lux-mariadb mysql -u "$DB_USER" -p"$DB_PASS" "$DB_NAME" -N -e \
+  "SELECT ts FROM lux_snapshots ORDER BY id DESC LIMIT 1;" 2>/dev/null)
+if [ -z "$LATEST_TS" ]; then
+  echo "ALERT: no snapshots found in lux_snapshots"
+  exit 2
+fi
+LATEST_EPOCH=$(date -d "$LATEST_TS" +%s 2>/dev/null)
+NOW_EPOCH=$(date +%s)
+AGE=$((NOW_EPOCH - LATEST_EPOCH))
+if [ "$AGE" -gt 120 ]; then
+  echo "ALERT: no fresh snapshots — last write ${AGE}s ago ($LATEST_TS)"
+  exit 2
+fi
+
+# 2. Register stability: compare last 3 snapshots' key registers
+#    (pv1=7, discharge=11, soc=5). If identical across 3 consecutive
+#    snapshots spanning > 60s, data is frozen.
+STABLE=$(docker exec lux-mariadb mysql -u "$DB_USER" -p"$DB_PASS" "$DB_NAME" -N -e "
+SELECT COUNT(DISTINCT CONCAT(JSON_EXTRACT(raw_registers,'$.7'),'|',JSON_EXTRACT(raw_registers,'$.11'),'|',(JSON_EXTRACT(raw_registers,'$.5') & 0xFF)))
+FROM (SELECT raw_registers FROM lux_snapshots ORDER BY id DESC LIMIT 3) t;" 2>/dev/null)
+
+if [ "$STABLE" = "1" ]; then
+  # Check the time span of those 3 snapshots
+  SPAN=$(docker exec lux-mariadb mysql -u "$DB_USER" -p"$DB_PASS" "$DB_NAME" -N -e "
+  SELECT TIMESTAMPDIFF(SECOND, MIN(ts), MAX(ts)) FROM (SELECT ts FROM lux_snapshots ORDER BY id DESC LIMIT 3) t;" 2>/dev/null)
+  if [ "$SPAN" -ge 60 ]; then
+    echo "ALERT: data frozen — last 3 snapshots identical over ${SPAN}s (pv1/discharge/soc unchanged)"
+    exit 2
+  fi
+fi
+
+echo "OK: data fresh (last write ${AGE}s ago), values changing"
+exit 0