fix: add WriteMultipleRegisters (0x10) transport + write confirmation

Author: jmewing

api/__init__.py

@@ -51,7 +51,7 @@ async def get_response(self, path: str, scope: Scope) -> Any:
 # Single source of truth for the lux-mon version. The footer reads this via
 # /api/version, and FastAPI's version field derives from it. bump-version.sh
 # updates this one constant.
-LUXMON_VERSION = "2.5.11"
+LUXMON_VERSION = "2.5.12"
 
 app = FastAPI(title="lux-mon API", version=LUXMON_VERSION)
 
@@ -1545,7 +1545,7 @@ def api_holding_put(name: str, body: HoldingUpdate):
     if not ok:
         raise HTTPException(502, f"Failed to write {name}: {msg}")
     logger.info("Wrote holding register %s (address %d) = %d", name, reg, raw_value)
-    return {"name": name, "address": reg, "raw": raw_value, "written": True}
+    return {"name": name, "address": reg, "raw": raw_value, "written": True, "message": msg}
 
 
 @app.get("/api/quick-charge/status")

api/static/index.html

@@ -1022,15 +1022,21 @@ <h4 style="margin-bottom:0.5rem;">${g.title}</h4>
   try {
     // Write sequentially (not in parallel) — the dongle rejects bursts of
     // simultaneous write connections, which surfaced as intermittent 502s.
+    let written = 0;
     for (const [name, value] of Object.entries(values)) {
       const r = await fetch(API + '/api/holding/' + encodeURIComponent(name), {
         method:'PUT', headers:{'Content-Type':'application/json'}, body:JSON.stringify({value: Number(value)})
       });
-      if (!r.ok) throw new Error(name + ': ' + r.statusText);
+      if (!r.ok) {
+        let detail = r.statusText;
+        try { const j = await r.json(); if (j.detail) detail = j.detail; } catch (e) {}
+        throw new Error(name + ': ' + detail);
+      }
+      written++;
     }
-    msg.textContent = 'Schedule saved.'; msg.style.color = 'var(--green-color)';
+    msg.textContent = `Value set — ${written} register${written === 1 ? '' : 's'} written.`; msg.style.color = 'var(--green-color)';
   } catch (e) {
-    msg.textContent = 'Error saving schedule: ' + e.message; msg.style.color = 'var(--red-color)';
+    msg.textContent = 'Error setting value: ' + e.message; msg.style.color = 'var(--red-color)';
   }
 }
 
@@ -1359,7 +1365,7 @@ <h4 style="margin-bottom:0.5rem;">${g.title}</h4>
         body: JSON.stringify({ value })
       });
     } catch (e) {
-      showAutoMsg(`Failed to write ${displayName}: ${e.message}`);
+      showAutoMsg(`Error setting value for ${displayName}: ${e.message}`);
       return;
     }
   }
@@ -1379,7 +1385,7 @@ <h4 style="margin-bottom:0.5rem;">${g.title}</h4>
       }
     }
   }
-  showAutoMsg('Values written' + (minutes ? ` and automations disabled for ${minutes} min` : '') + '.');
+  showAutoMsg('Values set' + (minutes ? ` and automations disabled for ${minutes} min` : '') + '.');
   await loadAutomationState();
   await loadActiveAutomationValues();
   renderAutomations();

collector/automation.py

@@ -56,8 +56,10 @@
     HOLDING_BY_NAME,
     HOLDING_REGISTERS,
     MODBUS_READ_HOLD,
+    MODBUS_WRITE_MULTI,
     MODBUS_WRITE_SINGLE,
     build_read_request,
+    build_write_multi_request,
     build_write_request,
     find_frames,
 )
@@ -139,6 +141,62 @@ def _write_holding_register(
                 pass
 
 
+def _write_holding_registers(
+    host: str,
+    port: int,
+    datalog_serial: str,
+    inverter_serial: str,
+    start_register: int,
+    values: List[int],
+    timeout: float = 10.0,
+) -> Tuple[bool, str]:
+    """Send a WriteMultipleRegisters (0x10) request and verify the echo.
+
+    Used by the 7-day scheduling block (registers 500-723), which the inverter
+    only accepts via multi-register writes (no single-register writes).
+    """
+    req = build_write_multi_request(
+        datalog_serial, inverter_serial, start_register, values
+    )
+    sock: Optional[socket.socket] = None
+    try:
+        sock = socket.create_connection((host, port), timeout=timeout)
+        sock.settimeout(timeout)
+        sock.sendall(req)
+
+        deadline = time.time() + timeout
+        buffer = b""
+        while time.time() < deadline:
+            remaining = deadline - time.time()
+            if remaining <= 0:
+                break
+            sock.settimeout(remaining)
+            try:
+                chunk = sock.recv(4096)
+            except socket.timeout:
+                break
+            if not chunk:
+                break
+            buffer += chunk
+            frames = find_frames(buffer)
+            for frame in frames:
+                if frame.is_error:
+                    return False, f"Modbus error response: code {frame.error_code}"
+                if frame.device_function == MODBUS_WRITE_MULTI and frame.register == start_register:
+                    if frame.write_count == len(values):
+                        return True, f"Wrote {len(values)} registers starting at {start_register}"
+                    return True, f"Write accepted (echo count {frame.write_count})"
+        return False, "No valid write response received"
+    except Exception as exc:
+        return False, f"Write failed: {exc}"
+    finally:
+        if sock is not None:
+            try:
+                sock.close()
+            except Exception:
+                pass
+
+
 def _read_holding_register(
     host: str,
     port: int,

collector/protocol.py

@@ -439,6 +439,7 @@ class LuxFrame:
     inverter_serial: str = ""
     register: int = 0
     values: list[int] = field(default_factory=list)
+    write_count: int = 0
     is_error: bool = False
     error_code: int = 0
 
@@ -629,6 +630,66 @@ def build_write_request(
     return bytes(pkt)
 
 
+def build_write_multi_request(
+    datalog_serial: str,
+    inverter_serial: str,
+    start_register: int,
+    values: list[int],
+) -> bytes:
+    """
+    Build a WriteMultipleRegisters (0x10) request packet.
+
+    Modbus data frame layout:
+        addr(1) + func(1) + inv_serial(10) + start_reg(2) + count(2)
+        + byte_count(1) + values(N*2) + crc(2)
+
+    The outer LuxPower packet is variable-length: the data length prefix
+    (bytes 18-19) and the frame length (bytes 4-5) both grow with the number
+    of registers being written.
+
+    Used by the 7-day scheduling block (registers 500-723), which the
+    inverter only accepts via multi-register writes (no single writes).
+    """
+    if not values:
+        raise ValueError("WriteMultipleRegisters requires at least one value")
+    if len(values) > 123:
+        raise ValueError(f"Too many registers for one write: {len(values)} (max 123)")
+    for v in values:
+        if not (0 <= v <= 0xFFFF):
+            raise ValueError(f"Modbus register value out of range: {v}")
+
+    n = len(values)
+    # Modbus data frame: addr(1)+func(1)+serial(10)+reg(2)+count(2)+bytecount(1)+values(2n)+crc(2)
+    data_len = 1 + 1 + 10 + 2 + 2 + 1 + (2 * n) + 2
+    # Outer packet: header(18) + datalen(2) + data(data_len)
+    total = 18 + 2 + data_len
+    frame_len = total - 6
+
+    pkt = bytearray(total)
+    pkt[0:2] = PREFIX
+    struct.pack_into('<H', pkt, 2, 1)          # protocol
+    struct.pack_into('<H', pkt, 4, frame_len)  # frame length
+    pkt[6] = 0x01
+    pkt[7] = TCP_FUNC_TRANSLATED_DATA
+    pkt[8:18] = _serial_to_bytes(datalog_serial)
+    struct.pack_into('<H', pkt, 18, data_len)  # data length
+
+    pkt[20] = 0x00                              # address
+    pkt[21] = MODBUS_WRITE_MULTI                # function 0x10
+    pkt[22:32] = _serial_to_bytes(inverter_serial)
+    struct.pack_into('<H', pkt, 32, start_register)
+    struct.pack_into('<H', pkt, 34, n)          # register count
+    pkt[36] = 2 * n                              # byte count
+    for i, v in enumerate(values):
+        struct.pack_into('<H', pkt, 37 + i * 2, v)
+
+    crc_start = 20
+    crc_end = 37 + 2 * n
+    crc = crc16_modbus(bytes(pkt[crc_start:crc_end]))
+    struct.pack_into('<H', pkt, crc_end, crc)
+    return bytes(pkt)
+
+
 # ── Frame Parser ────────────────────────────────────────────────────
 
 def parse_frame(data: bytes) -> Optional[LuxFrame]:
@@ -712,6 +773,14 @@ def _parse_data_frame(data: bytes, frame: LuxFrame) -> None:
                 if offset + 2 <= len(data) - 2:  # -2 for CRC
                     val = struct.unpack_from('<H', data, offset)[0]
                     frame.values.append(val)
+    elif frame.device_function == MODBUS_WRITE_MULTI:
+        # Write-multiple (0x10) echo: addr + func + serial + start_reg(2)
+        # + count(2) + crc. It echoes the start register and count, NOT the
+        # values. We store the count in a dedicated field so the caller can
+        # confirm the write was accepted.
+        if len(data) >= reg_start + 4 + 2:  # reg + count + crc
+            frame.register = struct.unpack_from('<H', data, reg_start)[0]
+            frame.write_count = struct.unpack_from('<H', data, reg_start + 2)[0]
 
 
 def find_frames(data: bytes) -> list[LuxFrame]: