@@ -17,8 +17,8 @@ The **`TIMEOUT`** option (default **3** seconds) is the deadline for:
 - opening the link (connect), and
 - each individual register read or write attempt.
 
-Each FC03 group is always attempted **`RETRY_ATTEMPTS` (3)** times, so a missing reply can take up
-to **9** seconds (`TIMEOUT` × 3) before that group fails.
+Each FC03 group is attempted **`READ_ATTEMPTS`** times (default **3**), so a missing reply can take
+up to **`TIMEOUT × READ_ATTEMPTS`** seconds before that group fails.
 
 It is **not** a cap on an entire sensor batch or poll cycle. `Sunsynk.read_sensors()` may issue many
 FC03 groups in one call; each group gets its own deadline.
@@ -50,10 +50,10 @@ all `for_unit()` handles on that port). **0** disables the gap.
 
 Library callers that omit `message_spacing` still get `DEFAULT_MESSAGE_SPACING` (0.05). On
 **timeout**, `Sunsynk.read_holding_registers()` logs, increments **`timeouts`**, and retries up to
-**`RETRY_ATTEMPTS` (3)** before raising **`ExceptionGroup`**. **Serial** links also call
-`ModbusConnection.disconnect()` (not `close()`) so the next FC03 reconnects with an empty receive
-buffer. TCP, UDP, and Solarman do not flush on timeout. Other read errors still flush. tmodbus
-already disconnects on desync (bad function code / header mismatch).
+**`read_attempts`** (add-on **`READ_ATTEMPTS`**, default **3**) before raising **`ExceptionGroup`**.
+**Serial** links also call `ModbusConnection.disconnect()` (not `close()`) so the next FC03
+reconnects with an empty receive buffer. TCP, UDP, and Solarman do not flush on timeout. Other read
+errors still flush. tmodbus already disconnects on desync (bad function code / header mismatch).
 
 ---
 
@@ -125,7 +125,7 @@ between commands on slow devices) and is the main pacing mitigation for #672 on
 ```text
 AInverter.read_sensors()
   → Sunsynk.read_sensors()     # groups sensors, one FC03 per group
-    → Sunsynk.read_holding_registers()  # RETRY_ATTEMPTS, then ExceptionGroup
+    → Sunsynk.read_holding_registers()  # read_attempts, then ExceptionGroup
       → unit.read_holding_registers()
         → modbus-connection TmodbusUnit  # connect + Pacer (50ms) + tmodbus RTU
 ```
@@ -199,10 +199,10 @@ Solarman does **not** use modbus-connection or tmodbus. It uses
 
 - **`TIMEOUT`** maps to **`socket_timeout`** on the Solarman client (connect and reads).
 - FC03 retries live on **`Sunsynk.read_holding_registers`** (shared with serial/TCP): up to
-  **`RETRY_ATTEMPTS` (5)**, then **`ExceptionGroup`**. No sleep between tries.
+  **`read_attempts`** (default **3**), then **`ExceptionGroup`**. No sleep between tries.
 - **`TimeoutError`** / **`GatewayTargetError`**: log, increment **`timeouts`**, disconnect/flush,
   retry.
-- Other read errors: same loop; log includes `(retry n/5)`.
+- Other read errors: same loop; log includes `[attempt n/READ_ATTEMPTS]`.
 - **`SolarmanUnit`** is a single attempt and **disconnects** on error so the next retry reconnects.
 
 There is **no** `message_spacing` knob on Solarman; pacing is whatever the dongle and
@@ -232,7 +232,7 @@ No shared `ModbusConnection`; one Solarman client per inverter port entry.
 | Library                        | modbus-connection + tmodbus                    | PySolarmanV5Async                    |
 | Add-on `TIMEOUT`               | Per connect / FC03 / FC16 attempt              | `socket_timeout`                     |
 | Default gap after each reply   | **`READ_MESSAGE_SPACING`** (default **0.05s**) | —                                    |
-| Driver retry on `TimeoutError` | Yes (`RETRY_ATTEMPTS`, then `ExceptionGroup`)  | Yes (same, on `Sunsynk`)             |
+| Driver retry on `TimeoutError` | Yes (`read_attempts`, then `ExceptionGroup`)   | Yes (same, on `Sunsynk`)             |
 | Add-on batch retry             | Yes (`read_sensors_retry`)                     | Yes (same)                           |
 | Multi-inverter same PORT       | One connection, `for_unit(MODBUS_ID)`          | Not supported (one dongle per entry) |
 
@@ -243,7 +243,8 @@ User-facing keys from [multi-options](../www/docs/reference/multi-options.md) (a
 
 | Option                          | Role                                                                                          |
 | ------------------------------- | --------------------------------------------------------------------------------------------- |
-| `TIMEOUT`                       | Per-attempt deadline in **seconds** (default **3**); each FC03 read is tried **3** times      |
+| `TIMEOUT`                       | Per-attempt deadline in **seconds** (default **3**)                                           |
+| `READ_ATTEMPTS`                 | Tries per FC03/FC16 group (default **3**, max **5**); worst case `TIMEOUT × READ_ATTEMPTS`    |
 | `READ_MESSAGE_SPACING`          | Seconds to wait after each successful Modbus reply (default **0.05**; **0** disables)         |
 | `READ_SENSORS_BATCH_SIZE`       | Max registers per FC03 group (smaller → more requests, less time per request)                 |
 | `READ_ALLOW_GAP`                | Extra registers allowed between addresses so groups merge (fewer requests)                    |
 
@@ -4,11 +4,11 @@
 
 ## Unreleased
 
-- **`TIMEOUT`** is now **3** seconds per connect and each register **attempt**. Each
-  holding-register read (FC03) and write (FC16) is always tried **3** times (**3s × 3**), so a
-  missing reply can take up to **9** seconds before that operation fails. On timeout, **serial**
-  links disconnect so the next attempt reconnects with an empty buffer; TCP and Solarman do not.
-  Other I/O errors still flush.
+- **`READ_ATTEMPTS`** (default **3**, max **5**) – tries per FC03 read and FC16 write. Worst-case
+  wait per group is **`TIMEOUT × READ_ATTEMPTS`**.
+- **`TIMEOUT`** is now **3** seconds per connect and each register **attempt**. On timeout,
+  **serial** links disconnect so the next attempt reconnects with an empty buffer; TCP and Solarman
+  do not. Other I/O errors still flush.
 - Add a 50ms `connect_delay` for serial
 - Remove Gen L1/L2/L3 current sensors & check for duplicates. #676
 
 
@@ -36,6 +36,7 @@ options:
   READ_ALLOW_GAP: 2
   READ_SENSORS_BATCH_SIZE: 20
   READ_MESSAGE_SPACING: 0.05
+  READ_ATTEMPTS: 3
   TIMEOUT: 3
   STALE_INVERTER_AFTER_SECONDS: 120
   STALE_INVERTER_SKIP_SECONDS: 600
@@ -66,6 +67,7 @@ schema:
   READ_ALLOW_GAP: int(1,50)
   READ_SENSORS_BATCH_SIZE: int(1,100)
   READ_MESSAGE_SPACING: float(0,2)?
+  READ_ATTEMPTS: int(1,5)?
   TIMEOUT: int(1,15)?
   STALE_INVERTER_AFTER_SECONDS: int(1,1000)?
   STALE_INVERTER_SKIP_SECONDS: int(60,86400)?
 
@@ -44,6 +44,12 @@ configuration:
 
       Default **0.05**. Increase on flaky RS485 / USB-FTDI links. **0** disables the gap.
       Raising TIMEOUT only waits longer for a missing reply; it does not add this pause.
+  READ_ATTEMPTS:
+    name: Read attempts
+    description: |
+      How many times to try each holding-register read or write.
+
+      Default **3**. Worst-case wait per group is TIMEOUT × READ_ATTEMPTS.
   STALE_INVERTER_AFTER_SECONDS:
     name: Stale inverter after (seconds)
     description: |
@@ -72,8 +78,8 @@ configuration:
     description: |
       Seconds to wait for each connect and register read/write attempt.
 
-      Default **3**. Each holding-register read is always tried 3 times, so a missing
-      reply can take up to 9 seconds before that group fails. Max **15**.
+      Default **3**. Each holding-register read is tried READ_ATTEMPTS times (default 3),
+      so a missing reply can take up to TIMEOUT × READ_ATTEMPTS seconds. Max **15**.
   MQTT_CUSTOM:
     name: Custom MQTT
     description: |
 
@@ -82,6 +82,7 @@ def create_sunsynk(opt: Options, iopt: InverterOptions) -> Sunsynk:
             unit=unit,
             port=port,
             timeout=opt.timeout,
+            read_attempts=opt.read_attempts,
             read_sensors_batch_size=opt.read_sensors_batch_size,
             allow_gap=opt.read_allow_gap,
         )
@@ -93,6 +94,7 @@ def create_sunsynk(opt: Options, iopt: InverterOptions) -> Sunsynk:
             connection=conn,
             port=port,
             timeout=opt.timeout,
+            read_attempts=opt.read_attempts,
             read_sensors_batch_size=opt.read_sensors_batch_size,
             allow_gap=opt.read_allow_gap,
         )
 
@@ -80,6 +80,8 @@ class Options(MQTTOptions):
     """Seconds to wait after each Modbus reply before the next request (0 disables)."""
     schedules: list[Schedule] = field(default_factory=list)
     timeout: int = 3
+    read_attempts: int = 3
+    """FC03/FC16 tries per register group (worst-case wait is TIMEOUT * READ_ATTEMPTS)."""
 
     stale_inverter_after_seconds: int = 60
     """Grace window (seconds) after each successful read: if failures continue past this deadline, enter stale quiet."""
 
@@ -20,8 +20,6 @@
 
 _LOG = logging.getLogger(__name__)
 
-RETRY_ATTEMPTS = 3
-
 
 def _exc_label(err: BaseException) -> str:
     """Type name, plus message when the exception string is empty (TimeoutError)."""
@@ -60,6 +58,7 @@ class Sunsynk:
     port: str = ""
     baudrate: int = 9600
     timeout: int = 3
+    read_attempts: int = 3
     read_sensors_batch_size: int = 20
     allow_gap: int = 2
     timeouts: int = 0
@@ -118,7 +117,7 @@ async def _flush_modbus_connection(self, *, reason: str) -> None:
 
     async def write_register(self, *, address: int, value: int) -> bool:
         """Write to a register - Sunsynk support function code 0x10."""
-        for _ in range(RETRY_ATTEMPTS):
+        for _ in range(self.read_attempts):
             try:
                 await self.unit.write_registers(address, [value])
                 return True
@@ -163,7 +162,7 @@ async def write_sensor(
     async def read_holding_registers(self, start: int, length: int) -> Sequence[int]:
         """Read holding registers (FC03)."""
         errs: list[Exception] = []
-        for attempt in range(RETRY_ATTEMPTS):
+        for attempt in range(self.read_attempts):
             try:
                 return await self.unit.read_holding_registers(start, length)
             except TimeoutError as err:
@@ -175,7 +174,7 @@ async def read_holding_registers(self, start: int, length: int) -> Sequence[int]
                     length,
                     _exc_label(err),
                     attempt + 1,
-                    RETRY_ATTEMPTS,
+                    self.read_attempts,
                 )
                 if self.connection is not None and isinstance(
                     self.connection._params, ModbusSerialParams
@@ -189,7 +188,7 @@ async def read_holding_registers(self, start: int, length: int) -> Sequence[int]
                     length,
                     _exc_label(err),
                     attempt + 1,
-                    RETRY_ATTEMPTS,
+                    self.read_attempts,
                 )
                 await self._flush_modbus_connection(reason=type(err).__name__)
 
 
@@ -28,6 +28,7 @@ def test_init() -> None:
     ist = STATE[0].inv
     assert isinstance(ist, Sunsynk)
     assert ist.port == inv_port
+    assert ist.read_attempts == 3
     mock_conn.for_unit.assert_called_once_with(1)
     open_conn.assert_called_once_with(
         inv_port, timeout=OPT.timeout, message_spacing=0.05
 
@@ -14,7 +14,7 @@
 
 from sunsynk.connection import DEFAULT_MESSAGE_SPACING, open_connection, url_to_params
 from sunsynk.state import InverterState
-from sunsynk.sunsynk import RETRY_ATTEMPTS, Sunsynk
+from sunsynk.sunsynk import Sunsynk
 
 
 def test_url_to_params() -> None:
@@ -88,8 +88,8 @@ async def test_write_register_timeout(state: InverterState) -> None:
     conn.disconnect = AsyncMock()
     ss = Sunsynk(unit=unit, state=state, connection=conn)
     assert await ss.write_register(address=1, value=1) is False
-    assert ss.timeouts == RETRY_ATTEMPTS
-    assert unit.write_registers.await_count == RETRY_ATTEMPTS
+    assert ss.timeouts == ss.read_attempts
+    assert unit.write_registers.await_count == ss.read_attempts
     conn.disconnect.assert_not_awaited()
 
 
@@ -104,9 +104,9 @@ async def test_read_holding_registers_timeout(state: InverterState) -> None:
     ss = Sunsynk(unit=unit, state=state, connection=conn)
     with pytest.raises(ExceptionGroup, match="Failed to read 1 registers at 1"):
         await ss.read_holding_registers(1, 1)
-    assert ss.timeouts == RETRY_ATTEMPTS
-    assert unit.read_holding_registers.await_count == RETRY_ATTEMPTS
-    assert conn.disconnect.await_count == RETRY_ATTEMPTS
+    assert ss.timeouts == ss.read_attempts
+    assert unit.read_holding_registers.await_count == ss.read_attempts
+    assert conn.disconnect.await_count == ss.read_attempts
 
 
 async def test_read_holding_registers_timeout_tcp_does_not_flush(
@@ -122,7 +122,7 @@ async def test_read_holding_registers_timeout_tcp_does_not_flush(
     ss = Sunsynk(unit=unit, state=state, connection=conn)
     with pytest.raises(ExceptionGroup, match="Failed to read"):
         await ss.read_holding_registers(1, 1)
-    assert ss.timeouts == RETRY_ATTEMPTS
+    assert ss.timeouts == ss.read_attempts
     conn.disconnect.assert_not_awaited()
 
 
@@ -135,7 +135,7 @@ async def test_read_holding_registers_timeout_without_connection(
     ss = Sunsynk(unit=unit, state=state)
     with pytest.raises(ExceptionGroup, match="Failed to read"):
         await ss.read_holding_registers(1, 1)
-    assert ss.timeouts == RETRY_ATTEMPTS
+    assert ss.timeouts == ss.read_attempts
 
 
 async def test_read_holding_registers_timeout_then_success(
@@ -154,6 +154,17 @@ async def test_read_holding_registers_timeout_then_success(
     conn.disconnect.assert_awaited_once()
 
 
+async def test_read_holding_registers_one_attempt(state: InverterState) -> None:
+    """read_attempts=1 raises after a single timeout."""
+    unit = MagicMock()
+    unit.read_holding_registers = AsyncMock(side_effect=TimeoutError)
+    ss = Sunsynk(unit=unit, state=state, read_attempts=1)
+    with pytest.raises(ExceptionGroup, match="Failed to read"):
+        await ss.read_holding_registers(1, 1)
+    assert ss.timeouts == 1
+    assert unit.read_holding_registers.await_count == 1
+
+
 async def test_read_holding_registers_logs_empty_timeout(
     state: InverterState,
     caplog: pytest.LogCaptureFixture,
@@ -182,4 +193,4 @@ async def test_read_holding_registers_gateway_target_flushes(
     with pytest.raises(ExceptionGroup, match="Failed to read 2 registers at 176"):
         await ss.read_holding_registers(176, 2)
     assert ss.timeouts == 0
-    assert conn.disconnect.await_count == RETRY_ATTEMPTS
+    assert conn.disconnect.await_count == ss.read_attempts
@@ -158,10 +158,13 @@ Global. Change these when a gateway or RS485 link is unreliable.
   disables the gap. Increase on flaky RS485 / USB-FTDI links. Not used for `solarman://`. Raising
   `TIMEOUT` does not add this pause.
 
+- <i-mdi-dev-to class="vp-edge-option-icon" /> `READ_ATTEMPTS` – Tries per holding-register read
+  (FC03) and write (FC16). Default **3**, max **5**. Worst-case wait per group is
+  `TIMEOUT × READ_ATTEMPTS`.
+
 - `TIMEOUT` – Seconds for connect and each register read/write attempt (default **3**, max **15**).
-  Each holding-register read is always tried **3** times (up to **9** seconds for a missing reply).
-  Increase on slow links. If timeouts persist, lower `READ_SENSORS_BATCH_SIZE` or increase
-  `READ_MESSAGE_SPACING`.
+  Each group is tried `READ_ATTEMPTS` times. Increase on slow links. If timeouts persist, lower
+  `READ_SENSORS_BATCH_SIZE` or increase `READ_MESSAGE_SPACING`.
 
 ## Schedules