Merge master (921179b) into release/4.4.0

Author: Pho3niX90

custom_components/solis_modbus/config_flow.py

@@ -33,7 +33,6 @@
     POLL_PROFILE_FULL,
     POLL_PROFILES,
 )
-from .data.enums import InverterType
 from .data.solis_config import CONNECTION_METHOD, SOLIS_INVERTERS, InverterConfig, inverter_options_from_config
 from .serial_proxy import SerialProxyClient, is_serial_proxy
 
@@ -348,7 +347,7 @@ async def _validate_config(self, user_input):
 
         conn_type = user_input.get(CONF_CONNECTION_TYPE, CONN_TYPE_SERIAL)
         device_id = user_input.get("slave", 1)
-        probe_register = 3041 if inverter_config.type in [InverterType.GRID, InverterType.STRING] else 35000
+        probe_register = inverter_config.probe_register
 
         if conn_type == CONN_TYPE_TCP:
             host, port = user_input["host"], user_input.get("port", 502)

custom_components/solis_modbus/data/solis_config.py

@@ -78,6 +78,11 @@ def _rebuild_features(self) -> None:
             feats.append(InverterFeature.TCP)
         self.features: list[InverterFeature] = feats
 
+    @property
+    def probe_register(self) -> int:
+        """An input register every inverter of this type answers, for checking a unit responds."""
+        return 3041 if self.type in [InverterType.GRID, InverterType.STRING] else 35000
+
     def clone_with_options(self, options: InverterOptions, connection: str) -> InverterConfig:
         """Copy this model definition with user-chosen options (does not mutate SOLIS_INVERTERS templates)."""
         return InverterConfig(

custom_components/solis_modbus/data_retrieval.py

@@ -12,11 +12,12 @@
 from custom_components.solis_modbus.helpers import (
     cache_get,
     cache_save,
+    iter_controllers,
     mark_platform_entities_unavailable_for_base_sensors,
     notify_register_update,
 )
 
-from .const import DOMAIN
+from .const import CONN_TYPE_SERIAL, DOMAIN
 from .data.enums import PollSpeed
 from .modbus_controller import RECOVERABLE_REGISTER_READ_EXCEPTIONS, ModbusController
 from .sensors.solis_base_sensor import SolisSensorGroup, cluster_sensors_by_contiguous_registers
@@ -33,6 +34,10 @@
 # as night: inverters drop off at dusk and wake well after the sun is up.
 _NIGHT_GRACE = timedelta(hours=1)
 
+# How long a serial inverter must go unanswered from startup before we check
+# whether it answers at unit 1 instead of its configured slave ID.
+_SLAVE_PROBE_AFTER = timedelta(minutes=1)
+
 
 class DataRetrieval:
     def __init__(
@@ -51,6 +56,11 @@ def __init__(
         # None = unknown (an issue may survive from before a restart), so the first
         # night-time pass still clears it; afterwards we skip redundant deletes.
         self._issue_raised: bool | None = None
+        # Set once the slave ID check is settled (see _check_serial_slave_id).
+        self._slave_id_checked = False
+        # Set once its issue is raised: stop probing, but keep checking whether to clear it.
+        self._slave_id_issue_raised = False
+        self._polling_since: float | None = None
         self.poll_lock = asyncio.Lock()
         self.connection_check = False
         self.first_poll = True
@@ -196,6 +206,9 @@ async def async_stop(self):
         # the datalogger is offline — otherwise it keeps spinning after unload).
         self._stopping = True
         self._update_connection_issue(False)
+        if self._entry_id is not None:
+            # A reload re-raises it if it still applies.
+            ir.async_delete_issue(self.hass, DOMAIN, f"serial_slave_id_{self._entry_id}")
 
         # Clean up the startup listener only if it hasn't fired yet
         if self._startup_unsub:
@@ -276,6 +289,53 @@ def _update_connection_issue(self, unreachable: bool) -> None:
             ir.async_delete_issue(self.hass, DOMAIN, issue_id)
             self._issue_raised = False
 
+    async def _check_serial_slave_id(self) -> None:
+        """Raise a repair issue when a serial inverter only answers at unit 1.
+
+        Serial requests used to go to unit 1 whatever slave ID was configured, so
+        an entry with the wrong slave ID kept working. Now that requests go to the
+        configured slave, such an entry gets no data. While the configured slave
+        has never answered, see whether unit 1 does.
+        """
+        if self._slave_id_checked or self._entry_id is None:
+            return
+        controller = self.controller
+        issue_id = f"serial_slave_id_{self._entry_id}"
+        if controller.connection_type != CONN_TYPE_SERIAL or controller.device_id == 1 or controller.has_answered:
+            # Also clears the issue once the entry is reconfigured or its slave answers.
+            ir.async_delete_issue(self.hass, DOMAIN, issue_id)
+            self._slave_id_checked = True
+            return
+        if any(other is not controller and other.connection_id == controller.connection_id and other.device_id == 1 for other in iter_controllers(self.hass)):
+            # Unit 1 is another inverter configured on this bus; an answer proves nothing.
+            # Not settled: that entry may be removed later.
+            ir.async_delete_issue(self.hass, DOMAIN, issue_id)
+            self._slave_id_issue_raised = False
+            return
+        if self._slave_id_issue_raised:
+            return
+        if self._polling_since is None or time.monotonic() - self._polling_since < _SLAVE_PROBE_AFTER.total_seconds():
+            return
+        if not await controller.async_unit_answers(1):
+            # Nothing at unit 1 either (asleep, wiring, ...); check again next time.
+            return
+        self._slave_id_issue_raised = True
+        _LOGGER.warning(
+            "(%s.%s) No answer from slave ID %s, but a device answers at slave ID 1. If that is this inverter, reconfigure the entry with slave ID 1.",
+            controller.host,
+            controller.slave,
+            controller.device_id,
+        )
+        ir.async_create_issue(
+            self.hass,
+            DOMAIN,
+            issue_id,
+            is_fixable=False,
+            severity=ir.IssueSeverity.ERROR,
+            translation_key="serial_slave_id",
+            translation_placeholders={"port": str(controller.connection_id), "slave": str(controller.device_id)},
+        )
+
     async def check_connection(self, now=None):
         """Ensure the Modbus controller is connected, retrying on failure.
 
@@ -297,6 +357,8 @@ async def check_connection(self, now=None):
         # until a manual reload. Use try/finally so it is always reset.
         self.connection_check = True
         try:
+            await self._check_serial_slave_id()
+
             # Emit controller status (dispatcher — not persisted to recorder)
             notify_register_update(self.hass, self.controller, 90005, self.controller.enabled)
 
@@ -363,6 +425,7 @@ async def poll_controller(self, event=None):
         if event is not None:
             self._startup_unsub = None
 
+        self._polling_since = time.monotonic()
         await self.check_connection()
 
         # Start periodic polling

custom_components/solis_modbus/modbus_controller.py

@@ -138,6 +138,9 @@ def __init__(
         # Modbus Write Queue
         self.write_queue = asyncio.Queue()
         self._last_modbus_success = datetime.now(UTC)
+        # Whether this inverter has answered a read since startup (unlike
+        # _last_modbus_success, which starts at "now").
+        self.has_answered = False
 
     async def process_write_queue(self):
         """Process queued Modbus write requests sequentially.
@@ -191,12 +194,7 @@ async def _execute_write_holding_register(self, register, value):
                 int_value = int(value)
                 int_register = register if is_number(register) else int(register)
 
-                # Different pymodbus APIs for TCP vs Serial
-                if self.connection_type == CONN_TYPE_TCP:
-                    result = await self.client.write_register(address=int_register, value=int_value, device_id=self.device_id)
-                else:
-                    self.client.slave = self.device_id
-                    result = await self.client.write_register(address=int_register, value=int_value)
+                result = await self.client.write_register(address=int_register, value=int_value, device_id=self.device_id)
                 _LOGGER.debug(
                     f"({self.host}.{self.device_id}) Write Holding Register register = {int_register}, value = {value}, int_value = {int_value}: {result}"
                 )
@@ -232,12 +230,7 @@ async def _execute_write_holding_registers(self, start_register, values):
                 await self.inter_frame_wait(is_write=True)  # Delay before write
 
                 try:
-                    # Different pymodbus APIs for TCP vs Serial
-                    if self.connection_type == CONN_TYPE_TCP:
-                        result = await self.client.write_registers(address=start_register, values=values, device_id=self.device_id)
-                    else:
-                        self.client.slave = self.device_id
-                        result = await self.client.write_registers(address=start_register, values=values)
+                    result = await self.client.write_registers(address=start_register, values=values, device_id=self.device_id)
                     _LOGGER.debug(
                         f"({self.host}.{self.device_id}) Write Holding Register block for {len(values)} registers starting at register = {start_register}"
                     )
@@ -296,11 +289,7 @@ async def _async_read_input_register_raw_detailed(self, register: int, count: in
             await self.inter_frame_wait()
 
             try:
-                if self.connection_type == CONN_TYPE_TCP:
-                    result = await self.client.read_input_registers(address=register, count=count, device_id=self.device_id)
-                else:
-                    self.client.slave = self.device_id
-                    result = await self.client.read_input_registers(address=register, count=count)
+                result = await self.client.read_input_registers(address=register, count=count, device_id=self.device_id)
 
                 _LOGGER.debug("(%s.%s) Read Input Registers: register = %s, count = %s", self.host, self.device_id, register, count)
 
@@ -311,6 +300,7 @@ async def _async_read_input_register_raw_detailed(self, register: int, count: in
                     return None, exc
 
                 self._last_modbus_success = datetime.now(UTC)
+                self.has_answered = True
                 return result.registers, None
             except Exception as e:
                 # Log the exception, close connection, and return error
@@ -364,11 +354,7 @@ async def _async_read_holding_register_raw_detailed(self, register: int, count:
             await self.inter_frame_wait()
 
             try:
-                if self.connection_type == CONN_TYPE_TCP:
-                    result = await self.client.read_holding_registers(address=register, count=count, device_id=self.device_id)
-                else:
-                    self.client.slave = self.device_id
-                    result = await self.client.read_holding_registers(address=register, count=count)
+                result = await self.client.read_holding_registers(address=register, count=count, device_id=self.device_id)
 
                 _LOGGER.debug("(%s.%s) Read Holding Registers: register = %s, count = %s", self.host, self.device_id, register, count)
 
@@ -379,6 +365,7 @@ async def _async_read_holding_register_raw_detailed(self, register: int, count:
                     return None, exc
 
                 self._last_modbus_success = datetime.now(UTC)
+                self.has_answered = True
                 return result.registers, None
             except Exception as e:
                 # Log the exception, close connection, and return error
@@ -431,6 +418,25 @@ def _log_skipped_read(self, kind: str, register: int, count: int) -> None:
         # watchdog in DataRetrieval owns recovery, so stay quiet here.
         _LOGGER.debug("(%s.%s) Skipping %s register read at %s (count=%s): not connected", self.host, self.device_id, kind, register, count)
 
+    async def async_unit_answers(self, device_id: int) -> bool:
+        """Return whether some unit on this link answers a read of the probe register.
+
+        Unlike the register reads, an answer doesn't count as this inverter
+        answering (has_answered, last_modbus_success): it may be another unit.
+        """
+        if not await self.connect():
+            return False
+        register = self.inverter_config.probe_register
+        async with self.poll_lock:
+            await self.inter_frame_wait()
+            try:
+                result = await self.client.read_input_registers(address=register, count=1, device_id=device_id)
+            except Exception as e:
+                _LOGGER.debug("(%s.%s) No answer from unit %s at register %s: %s", self.host, self.device_id, device_id, register, e)
+                self._safe_close()
+                return False
+        return not result.isError()
+
     async def connect(self):
         """Establishes a connection to the Modbus device.
 

custom_components/solis_modbus/serial_proxy.py

@@ -76,9 +76,6 @@ def __init__(
         # retries is accepted for pymodbus compatibility; modbus-connection
         # doesn't retry, and the controller's own recovery handles failures.
         self.port = port
-        # The controller sets this on serial clients; requests use it unless
-        # they pass device_id.
-        self.slave = 1
         self._connection = ModbusConnection(
             ModbusSerialParams(device=port, baudrate=baudrate, bytesize=bytesize, parity=parity, stopbits=stopbits),
             timeout=timeout,
@@ -132,27 +129,27 @@ async def _await_teardown(self) -> None:
             # Shielded: a cancelled request must not cancel the teardown.
             await asyncio.shield(task)
 
-    async def _unit(self, device_id: int | None):
+    async def _unit(self, device_id: int):
         await self._await_teardown()
-        return self._connection.for_unit(self.slave if device_id is None else device_id)
+        return self._connection.for_unit(device_id)
 
-    async def read_input_registers(self, address: int, *, count: int = 1, device_id: int | None = None) -> SerialProxyResult:
+    async def read_input_registers(self, address: int, *, count: int = 1, device_id: int = 1) -> SerialProxyResult:
         """Read input registers (FC04)."""
         unit = await self._unit(device_id)
         try:
             return SerialProxyResult(list(await unit.read_input_registers(address, count)))
         except ModbusExceptionError as err:
             return SerialProxyResult(error=err)
 
-    async def read_holding_registers(self, address: int, *, count: int = 1, device_id: int | None = None) -> SerialProxyResult:
+    async def read_holding_registers(self, address: int, *, count: int = 1, device_id: int = 1) -> SerialProxyResult:
         """Read holding registers (FC03)."""
         unit = await self._unit(device_id)
         try:
             return SerialProxyResult(list(await unit.read_holding_registers(address, count)))
         except ModbusExceptionError as err:
             return SerialProxyResult(error=err)
 
-    async def write_register(self, address: int, value: int, *, device_id: int | None = None) -> SerialProxyResult:
+    async def write_register(self, address: int, value: int, *, device_id: int = 1) -> SerialProxyResult:
         """Write one holding register (FC06); the result echoes the value, as pymodbus's does."""
         unit = await self._unit(device_id)
         try:
@@ -161,7 +158,7 @@ async def write_register(self, address: int, value: int, *, device_id: int | Non
             return SerialProxyResult(error=err)
         return SerialProxyResult([value])
 
-    async def write_registers(self, address: int, values: list[int], *, device_id: int | None = None) -> SerialProxyResult:
+    async def write_registers(self, address: int, values: list[int], *, device_id: int = 1) -> SerialProxyResult:
         """Write consecutive holding registers (FC16)."""
         unit = await self._unit(device_id)
         try:

custom_components/solis_modbus/translations/af.json

@@ -192,6 +192,10 @@
     "datalogger_unreachable": {
       "title": "Solis datalogger onbereikbaar",
       "description": "Geen suksesvolle Modbus-lesing vanaf {host} sedert {last_success} nie. Die WiFi-datalogger slaap dalk, is afgeskakel of in 'n half-oop toestand; die integrasie probeer aanhoudend weer met terugval. Skakel die datalogger se krag af en aan as dit voortduur."
+    },
+    "serial_slave_id": {
+      "title": "Solis-omsetter antwoord nie by slaaf-ID {slave} nie",
+      "description": "Die omsetter op {port} antwoord nie by sy gekonfigureerde Modbus-slaaf-ID {slave} nie, maar 'n toestel op die bus antwoord by slaaf-ID 1. Ouer weergawes van hierdie integrasie het elke seriële (RS485) versoek na slaaf-ID 1 gestuur, ongeag die gekonfigureerde ID, so hierdie opstelling het dalk tot nou gewerk. As die omsetter by slaaf-ID 1 is, herkonfigureer die integrasie-inskrywing en stel die slaaf-ID op 1."
     }
   }
 }

custom_components/solis_modbus/translations/de.json

@@ -192,6 +192,10 @@
     "datalogger_unreachable": {
       "title": "Solis-Datenlogger nicht erreichbar",
       "description": "Kein erfolgreicher Modbus-Lesevorgang von {host} seit {last_success}. Der WiFi-Datenlogger schläft möglicherweise, ist ausgeschaltet oder in einem halboffenen Zustand; die Integration versucht es weiterhin mit Backoff. Bei anhaltendem Problem den Datenlogger stromlos machen."
+    },
+    "serial_slave_id": {
+      "title": "Solis-Wechselrichter antwortet nicht unter Slave-ID {slave}",
+      "description": "Der Wechselrichter an {port} antwortet nicht unter seiner konfigurierten Modbus-Slave-ID {slave}, aber ein Gerät am Bus antwortet unter Slave-ID 1. Ältere Versionen dieser Integration haben jede serielle (RS485) Anfrage unabhängig von der konfigurierten ID an Slave-ID 1 gesendet, daher hat diese Konfiguration bisher möglicherweise funktioniert. Wenn der Wechselrichter Slave-ID 1 hat, den Integrationseintrag neu konfigurieren und die Slave-ID auf 1 setzen."
     }
   }
 }

custom_components/solis_modbus/translations/en.json

@@ -192,6 +192,10 @@
     "datalogger_unreachable": {
       "title": "Solis datalogger unreachable",
       "description": "No successful Modbus read from {host} since {last_success}. The WiFi datalogger may be asleep, powered off or in a half-open state; the integration keeps retrying with backoff. Power-cycle the datalogger if this persists."
+    },
+    "serial_slave_id": {
+      "title": "Solis inverter not answering at slave ID {slave}",
+      "description": "The inverter on {port} doesn't answer at its configured Modbus slave ID {slave}, but a device on the bus answers at slave ID 1. Older versions of this integration sent every serial (RS485) request to slave ID 1 whatever ID was configured, so this setup may have worked until now. If the inverter is at slave ID 1, reconfigure the integration entry and set the slave ID to 1."
     }
   }
 }

custom_components/solis_modbus/translations/es.json

@@ -192,6 +192,10 @@
     "datalogger_unreachable": {
       "title": "Datalogger de Solis inaccesible",
       "description": "Sin lecturas Modbus correctas desde {host} desde {last_success}. El datalogger WiFi puede estar dormido, apagado o en estado semiabierto; la integración sigue reintentando con espera progresiva. Reinicie la alimentación del datalogger si persiste."
+    },
+    "serial_slave_id": {
+      "title": "El inversor Solis no responde en el ID de esclavo {slave}",
+      "description": "El inversor en {port} no responde en su ID de esclavo Modbus configurado {slave}, pero un dispositivo del bus responde en el ID de esclavo 1. Las versiones anteriores de esta integración enviaban todas las peticiones serie (RS485) al ID de esclavo 1, fuera cual fuera el ID configurado, así que esta configuración puede haber funcionado hasta ahora. Si el inversor está en el ID de esclavo 1, reconfigure la entrada de la integración y ponga el ID de esclavo en 1."
     }
   }
 }