Bump version to v1.0.10 — shared connection TID fix + 3000-range suppression (#351)

- Double-flush receive buffer in shared connection mode: first flush clears bytes
  already in TCP buffer; 30ms pause lets any in-flight RS485 bytes arrive; second
  flush clears them. Eliminates the residual TID mismatches that survived v1.0.9.
- Add skip-on-failure caching to 3000-range register block reads (same pattern as
  VPP 31000+ blocks). First failure logs WARNING once; subsequent failures within
  the 5-minute retry window are suppressed to DEBUG. Eliminates the log flood in
  mixed-model setups where one inverter does not support the 3000-range.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: 0xAHA

README.md

@@ -3,7 +3,7 @@
 # Growatt Modbus Integration for Home Assistant ☀️
 
 ![HACS Badge](https://img.shields.io/badge/HACS-Custom-orange.svg)
-![Version](https://img.shields.io/badge/Version-1.1.0-blue.svg)
+![Version](https://img.shields.io/badge/Version-1.0.10-blue.svg)
 [![GitHub Issues](https://img.shields.io/github/issues/0xAHA/Growatt_ModbusTCP.svg)](https://github.com/0xAHA/Growatt_ModbusTCP/issues)
 [![GitHub Stars](https://img.shields.io/github/stars/0xAHA/Growatt_ModbusTCP.svg?style=social)](https://github.com/0xAHA/Growatt_ModbusTCP)
 

RELEASENOTES.md

@@ -4,6 +4,26 @@
 
 ---
 
+## v1.0.10
+
+Issues: #351
+
+- **Fix: Remaining transaction ID mismatches in shared connection mode (#351):**
+  A single buffer flush after acquiring the lock cleared bytes already in the TCP buffer,
+  but RS485 bytes still in transit through the gateway arrived milliseconds later — after
+  the flush but before the first request, causing the occasional TID mismatch that survived
+  v1.0.9. Fix: double-flush with a 30ms pause between flushes, giving in-flight RS485
+  bytes time to arrive so the second flush catches them.
+
+- **Fix: 3000-range register block warning flood in multi-inverter setups (#351):**
+  In a setup with two different inverter models (e.g. SPH + MOD), the 3000-range register
+  block may be defined for one profile but consistently rejected by the other inverter.
+  Every failed read logged a WARNING every ~70 seconds. Fix: the 3000-range block now uses
+  the same skip-on-failure caching as the VPP 31000+ blocks — the first failure logs a
+  WARNING once, then the block is skipped silently for 5 minutes before retrying.
+
+---
+
 ## v1.1.0
 
 Issues: #322

custom_components/growatt_modbus/coordinator.py

@@ -933,9 +933,13 @@ def _fetch_data_shared(self) -> GrowattData | None:
                 )
                 return None
 
-            # Flush any stale bytes left in the adapter's TCP buffer by the
-            # previous slave's poll (late RS485 responses that arrived after the
-            # lock was released cause transaction ID mismatches on this slave's reads).
+            # Double-flush: the first flush clears bytes already in the TCP buffer.
+            # A 30ms pause then lets any RS485 bytes still in transit through the
+            # gateway arrive, so the second flush catches them too. Without the pause,
+            # in-flight bytes arrive after the flush and cause TID mismatches on the
+            # first read of this slave's poll.
+            hub._flush_receive_buffer()
+            time.sleep(0.030)
             hub._flush_receive_buffer()
 
             self._client._battery_voltage_range = self.config_entry.options.get(

custom_components/growatt_modbus/growatt_modbus.py

@@ -1317,63 +1317,102 @@ def _read_sparse(addr_list: list, fatal: bool = False) -> bool:
             addrs_3000 = sorted([addr for addr in addresses if 3000 <= addr < 4000])
             max_3000_addr = max(addrs_3000)
             count_3000 = (max_3000_addr - 3000) + 1
+            _3000_key = ('3000_block', count_3000)
+            _3000_RETRY_S = 300
+
+            # Skip-on-failure: after the first failure, suppress retries for 5 minutes.
+            # This prevents log flooding when an inverter simply doesn't support this range
+            # (e.g. one model in a two-inverter setup where only one uses 3000-range registers).
+            _3000_prev = self._failed_optional_ranges.get(_3000_key)
+            _3000_skip = False
+            if _3000_prev:
+                _3000_fail_time, _3000_fail_count = _3000_prev
+                if time.time() - _3000_fail_time < _3000_RETRY_S:
+                    logger.debug(
+                        f"Skipping 3000-range block (failed {_3000_fail_count}x, "
+                        f"retry in {int(_3000_RETRY_S - (time.time() - _3000_fail_time))}s)"
+                    )
+                    _3000_skip = True
+                else:
+                    logger.debug(f"Retrying previously failed 3000-range block (3000-{max_3000_addr})")
+
+            if not _3000_skip:
+                _3000_any_fail = False
+                _3000_any_ok = False
+
+                # Check if we need to split the read (max 125 registers per read)
+                if count_3000 > 125:
+                    # Split into contiguous blocks
+                    logger.debug(f"Splitting 3000 range into blocks (total range: 3000-{max_3000_addr}, {count_3000} registers)")
+
+                    blocks = []
+                    current_block = [addrs_3000[0]]
+                    for addr in addrs_3000[1:]:
+                        if addr - current_block[-1] <= 10:  # Group if gap is small
+                            current_block.append(addr)
+                        else:
+                            blocks.append(current_block)
+                            current_block = [addr]
+                    blocks.append(current_block)
 
-            # Check if we need to split the read (max 125 registers per read)
-            if count_3000 > 125:
-                # Split into contiguous blocks
-                logger.debug(f"Splitting 3000 range into blocks (total range: 3000-{max_3000_addr}, {count_3000} registers)")
-
-                blocks = []
-                current_block = [addrs_3000[0]]
-                for addr in addrs_3000[1:]:
-                    if addr - current_block[-1] <= 10:  # Group if gap is small
-                        current_block.append(addr)
-                    else:
-                        blocks.append(current_block)
-                        current_block = [addr]
-                blocks.append(current_block)
-
-                # Read each block separately
-                for block in blocks:
-                    min_addr_block = min(block)
-                    max_addr_block = max(block)
-                    count_block = (max_addr_block - min_addr_block) + 1
-
-                    # Further split if block still exceeds 125 registers
-                    if count_block > 125:
-                        # Read in 125-register chunks
-                        for chunk_start in range(min_addr_block, max_addr_block + 1, 125):
-                            chunk_count = min(125, max_addr_block - chunk_start + 1)
-                            logger.debug(f"Reading 3000 sub-chunk ({chunk_start}-{chunk_start+chunk_count-1}, {chunk_count} registers)")
-                            registers = self.read_input_registers(chunk_start, chunk_count)
+                    # Read each block separately
+                    for block in blocks:
+                        min_addr_block = min(block)
+                        max_addr_block = max(block)
+                        count_block = (max_addr_block - min_addr_block) + 1
+
+                        # Further split if block still exceeds 125 registers
+                        if count_block > 125:
+                            # Read in 125-register chunks
+                            for chunk_start in range(min_addr_block, max_addr_block + 1, 125):
+                                chunk_count = min(125, max_addr_block - chunk_start + 1)
+                                logger.debug(f"Reading 3000 sub-chunk ({chunk_start}-{chunk_start+chunk_count-1}, {chunk_count} registers)")
+                                registers = self.read_input_registers(chunk_start, chunk_count)
+                                if registers is None:
+                                    _3000_any_fail = True
+                                    logger.debug(f"3000 sub-chunk failed ({chunk_start}-{chunk_start+chunk_count-1})")
+                                else:
+                                    _3000_any_ok = True
+                                    for i, value in enumerate(registers):
+                                        self._register_cache[chunk_start + i] = value
+                        else:
+                            logger.debug(f"Reading 3000 sub-range ({min_addr_block}-{max_addr_block}, {count_block} registers)")
+                            registers = self.read_input_registers(min_addr_block, count_block)
                             if registers is None:
-                                logger.warning(f"Failed to read 3000 chunk ({chunk_start}-{chunk_start+chunk_count-1})")
+                                _3000_any_fail = True
+                                logger.debug(f"3000 sub-range failed ({min_addr_block}-{max_addr_block})")
                             else:
+                                _3000_any_ok = True
                                 for i, value in enumerate(registers):
-                                    self._register_cache[chunk_start + i] = value
-                    else:
-                        logger.debug(f"Reading 3000 sub-range ({min_addr_block}-{max_addr_block}, {count_block} registers)")
-                        registers = self.read_input_registers(min_addr_block, count_block)
-                        if registers is None:
-                            logger.warning(f"Failed to read 3000 block ({min_addr_block}-{max_addr_block})")
-                        else:
-                            for i, value in enumerate(registers):
-                                addr = min_addr_block + i
-                                self._register_cache[addr] = value
-                                # Log load_energy registers specifically
-                                if addr in [3075, 3076, 3077, 3078]:
-                                    logger.debug(f"[{self.register_map['name']}@{self.connection_id}] Cached 3000 range: reg {addr} = {value}")
-            else:
-                # Single read is sufficient
-                logger.debug(f"Reading 3000 range (3000-{max_3000_addr}, {count_3000} registers)")
-                registers = self.read_input_registers(3000, count_3000)
-                if registers is None:
-                    logger.warning("Failed to read 3000 register block (extended data may be unavailable)")
-                    # Don't return None - continue with what we have
+                                    addr = min_addr_block + i
+                                    self._register_cache[addr] = value
+                                    if addr in [3075, 3076, 3077, 3078]:
+                                        logger.debug(f"[{self.register_map['name']}@{self.connection_id}] Cached 3000 range: reg {addr} = {value}")
                 else:
-                    # Populate cache
-                    for i, value in enumerate(registers):
-                        self._register_cache[3000 + i] = value
+                    # Single read is sufficient
+                    logger.debug(f"Reading 3000 range (3000-{max_3000_addr}, {count_3000} registers)")
+                    registers = self.read_input_registers(3000, count_3000)
+                    if registers is None:
+                        _3000_any_fail = True
+                    else:
+                        _3000_any_ok = True
+                        for i, value in enumerate(registers):
+                            self._register_cache[3000 + i] = value
+
+                # Update failure tracking based on outcome
+                if _3000_any_fail and not _3000_any_ok:
+                    _prev = self._failed_optional_ranges.get(_3000_key)
+                    _count = (_prev[1] + 1) if _prev else 1
+                    self._failed_optional_ranges[_3000_key] = (time.time(), _count)
+                    if _count == 1:
+                        logger.warning(
+                            f"Failed to read 3000 register block (extended data may be unavailable). "
+                            f"Will suppress and retry in {_3000_RETRY_S}s."
+                        )
+                    else:
+                        logger.debug(f"3000 register block still failing (attempt {_count})")
+                elif _3000_any_ok:
+                    self._failed_optional_ranges.pop(_3000_key, None)
 
         # Read 8000 range if needed - WIT/WIS battery/storage data
         if has_8000_range:

custom_components/growatt_modbus/manifest.json

@@ -12,5 +12,5 @@
     "pymodbus>=3.0.0",
     "pyserial>=3.4"
   ],
-  "version": "1.1.0"
+  "version": "1.0.10"
 }