Merge pull request #307 from Pho3niX90/feature/december_v4

Require inverter serial, unify device identifiers, add reconfigure flow

Author: Pho3niX90

custom_components/solis_modbus/__init__.py

@@ -13,14 +13,13 @@
     DOMAIN, CONTROLLER, TIME_ENTITIES,
     CONN_TYPE_TCP, CONN_TYPE_SERIAL, CONF_SERIAL_PORT,
     CONF_BAUDRATE, CONF_BYTESIZE, CONF_PARITY, CONF_STOPBITS,
-    CONF_CONNECTION_TYPE, DEFAULT_BAUDRATE, DEFAULT_BYTESIZE,
+    CONF_CONNECTION_TYPE, CONF_INVERTER_SERIAL, DEFAULT_BAUDRATE, DEFAULT_BYTESIZE,
     DEFAULT_PARITY, DEFAULT_STOPBITS
 )
 from .data.enums import InverterFeature
 from .data.solis_config import SOLIS_INVERTERS, InverterConfig, InverterType
 from .data_retrieval import DataRetrieval
 from .helpers import get_controller, set_controller
-from homeassistant.helpers import entity_registry as er
 from .modbus_controller import ModbusController
 from .sensors.solis_base_sensor import SolisSensorGroup, SolisBaseSensor
 from .sensors.solis_derived_sensor import SolisDerivedSensor
@@ -43,24 +42,6 @@
     }
 )
 
-async def async_migrate_unique_ids(hass: HomeAssistant, entry: ConfigEntry, host: str, port: int):
-    """Migrate legacy unique_ids (missing port) to new format."""
-    if port == 502:
-        return
-
-    _LOGGER.debug(f"Checking for unique_id migration for host {host}, port {port}")
-    registry = er.async_get(hass)
-    entries = er.async_entries_for_config_entry(registry, entry.entry_id)
-
-    old_prefix = f"{DOMAIN}_{host}_"
-    new_prefix = f"{DOMAIN}_{host}_{port}_"
-
-    for entity in entries:
-        if entity.unique_id.startswith(old_prefix) and not entity.unique_id.startswith(new_prefix):
-            new_unique_id = entity.unique_id.replace(old_prefix, new_prefix, 1)
-            _LOGGER.warning(f"Migrating entity {entity.entity_id} unique_id from {entity.unique_id} to {new_unique_id}")
-            registry.async_update_entity(entity.entity_id, new_unique_id=new_unique_id)
-
 
 async def async_setup(hass: HomeAssistant, entry: ConfigEntry):
     """Set up the Modbus integration."""
@@ -129,14 +110,24 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry):
     # Merge data and options (options take priority)
     config = {**entry.data, **entry.options}
     slave = config.get("slave", 1)
+    inverter_serial = config.get(CONF_INVERTER_SERIAL)
+
+    if not inverter_serial:
+        hass.components.persistent_notification.async_create(
+            "Solis Modbus: Inverter Serial is missing. Please reconfigure the integration.",
+            title="Solis Modbus Configuration Issue",
+            notification_id="solis_modbus_missing_serial",
+        )
+        raise ConfigEntryError("Inverter Serial is missing")
 
     # Determine connection type (default to TCP for backwards compatibility with old configs)
     connection_type = config.get(CONF_CONNECTION_TYPE, CONN_TYPE_TCP if "host" in config else CONN_TYPE_SERIAL)
 
     # Get connection-specific parameters
+    host = config.get("host")
+    port = config.get("port", 502)
+
     if connection_type == CONN_TYPE_TCP:
-        host = config.get("host")
-        port = config.get("port", 502)
         connection_id = f"{host}:{port}"
     else:  # Serial
         serial_port = config.get(CONF_SERIAL_PORT, "/dev/ttyUSB0")
@@ -163,19 +154,15 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry):
     hass.data[DOMAIN][entry.entry_id] = entry
     _LOGGER.info(f"Loaded Solis Modbus Integration ({connection_type}) with Model: {config.get('model')}")
 
-    # Migrate unique_ids if needed (TCP only)
-    if connection_type == CONN_TYPE_TCP:
-        await async_migrate_unique_ids(hass, entry, host, port)
-
     poll_interval_fast = config.get("poll_interval_fast", 5)
     poll_interval_normal = config.get("poll_interval_normal", 15)
     poll_interval_slow = config.get("poll_interval_slow", 30)
     inverter_model = config.get("model")
-    identification = config.get("identification", None)
 
     if inverter_model is None:
         old_type = config.get("type", "hybrid")
-        inverter_model = "S6-EH3P" if old_type == "hybrid" else ("WAVESHARE" if old_type == "hybrid-waveshare" else "S6-GR1P")
+        inverter_model = "S6-EH3P" if old_type == "hybrid" else (
+            "WAVESHARE" if old_type == "hybrid-waveshare" else "S6-GR1P")
 
     inverter_config: InverterConfig = next(
         (inv for inv in SOLIS_INVERTERS if inv.model == inverter_model), None
@@ -213,12 +200,12 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry):
     controller_params = {
         "hass": hass,
         "device_id": slave,
-        "identification": identification,
         "fast_poll": poll_interval_fast,
         "normal_poll": poll_interval_normal,
         "slow_poll": poll_interval_slow,
         "inverter_config": inverter_config,
-        "connection_type": connection_type
+        "connection_type": connection_type,
+        "serial_number": inverter_serial
     }
 
     if connection_type == CONN_TYPE_TCP:
@@ -245,7 +232,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry):
             continue  # Skip this group
 
         # If it passes the check, add to sensor groups
-        controller._sensor_groups.append(SolisSensorGroup(hass=hass, definition=group, controller=controller, identification=identification))
+        controller._sensor_groups.append(SolisSensorGroup(hass=hass, definition=group, controller=controller))
 
     controller._derived_sensors = [
         SolisBaseSensor(
@@ -261,13 +248,11 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry):
             hidden=entity.get("hidden", False),
             multiplier=entity.get("multiplier", 1),
             category=entity.get("category", None),
-            identification=entity.get("identification", None),
-            unique_id=f"{DOMAIN}_{identification}_{entity['unique']}" if identification else f"{DOMAIN}_{connection_id.replace(':', '_').replace('/', '_')}{f'_{slave}' if slave != 1 else ''}_{entity['unique']}"
+            unique_id=f"{DOMAIN}_{controller.serial_number}_{entity['unique']}" if controller.serial_number else f"{DOMAIN}_{connection_id.replace(':', '_').replace('/', '_')}{f'_{slave}' if slave != 1 else ''}_{entity['unique']}"
         )
         for entity in sensors_derived
     ]
 
-
     set_controller(hass, controller)
 
     _LOGGER.debug(f"Config entry setup for {connection_type} connection: {connection_id}, slave {slave}")

custom_components/solis_modbus/config_flow.py

@@ -1,18 +1,19 @@
-import voluptuous as vol
+import asyncio
 import logging
+
+import voluptuous as vol
 from homeassistant import config_entries
 from homeassistant.config_entries import OptionsFlowWithConfigEntry
 
 from . import ModbusController
 from .const import (
     DOMAIN, CONN_TYPE_TCP, CONN_TYPE_SERIAL, CONF_SERIAL_PORT,
     CONF_BAUDRATE, CONF_BYTESIZE, CONF_PARITY, CONF_STOPBITS,
-    CONF_CONNECTION_TYPE, DEFAULT_BAUDRATE, DEFAULT_BYTESIZE,
+    CONF_CONNECTION_TYPE, CONF_INVERTER_SERIAL, DEFAULT_BAUDRATE, DEFAULT_BYTESIZE,
     DEFAULT_PARITY, DEFAULT_STOPBITS
 )
 from .data.enums import InverterType
 from .data.solis_config import SOLIS_INVERTERS, InverterConfig, CONNECTION_METHOD
-import re
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -34,13 +35,13 @@
 
 # Base schema with common fields (for both TCP and Serial)
 BASE_CONFIG_SCHEMA = {
-    vol.Required(CONF_CONNECTION_TYPE, default=CONN_TYPE_SERIAL): vol.In(CONNECTION_TYPES),
+    vol.Required(CONF_CONNECTION_TYPE, default=CONN_TYPE_TCP): vol.In(CONNECTION_TYPES),
+    vol.Required(CONF_INVERTER_SERIAL): str,
     vol.Required("slave", default=1): int,
     vol.Optional("poll_interval_fast", default=10): vol.All(int, vol.Range(min=10)),
     vol.Optional("poll_interval_normal", default=15): vol.All(int, vol.Range(min=15)),
     vol.Optional("poll_interval_slow", default=30): vol.All(int, vol.Range(min=30)),
     vol.Required("model", default=list(SOLIS_MODELS.keys())[0]): vol.In(SOLIS_MODELS),
-    vol.Optional("identification", default=""): str,
     # Boolean options (Yes/No toggle)
     vol.Required("has_v2", default=True): vol.Coerce(bool),
     vol.Required("has_pv", default=True): vol.Coerce(bool),
@@ -101,15 +102,6 @@
 )
 
 
-def clean_identification(iden: str | None) -> str | None:
-    if not iden or not iden.strip():
-        return None
-    # Replace spaces and disallowed characters with underscores
-    iden = iden.strip().lower()
-    iden = re.sub(r"[^a-z0-9_]", "_", iden)
-    return re.sub(r"_+", "_", iden).strip("_")
-
-
 class ModbusConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
     """Modbus configuration flow."""
 
@@ -137,7 +129,7 @@ async def async_step_user(self, user_input=None):
         return self.async_show_form(
             step_id="user",
             data_schema=vol.Schema({
-                vol.Required(CONF_CONNECTION_TYPE, default=CONN_TYPE_SERIAL): vol.In(CONNECTION_TYPES),
+                vol.Required(CONF_CONNECTION_TYPE, default=CONN_TYPE_TCP): vol.In(CONNECTION_TYPES),
             }),
             errors=errors
         )
@@ -155,12 +147,12 @@ async def async_step_config(self, user_input=None):
         if self._connection_type == CONN_TYPE_TCP:
             # Create TCP schema without connection_type field
             schema_dict = {k: v for k, v in TCP_CONFIG_SCHEMA.items()
-                          if not (hasattr(k, 'schema') and k.schema == CONF_CONNECTION_TYPE)}
+                           if not (hasattr(k, 'schema') and k.schema == CONF_CONNECTION_TYPE)}
             schema = vol.Schema(schema_dict)
         else:
             # Create Serial schema without connection_type field
             schema_dict = {k: v for k, v in SERIAL_CONFIG_SCHEMA.items()
-                          if not (hasattr(k, 'schema') and k.schema == CONF_CONNECTION_TYPE)}
+                           if not (hasattr(k, 'schema') and k.schema == CONF_CONNECTION_TYPE)}
             schema = vol.Schema(schema_dict)
 
         return self.async_show_form(
@@ -169,6 +161,50 @@ async def async_step_config(self, user_input=None):
             errors=errors
         )
 
+    async def async_step_reconfigure(self, user_input=None):
+        """Handle reconfiguration."""
+        errors = {}
+        entry = self.hass.config_entries.async_get_entry(self.context["entry_id"])
+
+        if user_input is not None:
+            data = {**entry.data, **user_input}
+
+            if await self._validate_config(data):
+                return self.async_update_reload_and_abort(
+                    entry, data=data
+                )
+
+            errors["base"] = "Cannot connect to Modbus device. Please check your configuration."
+
+        # Show config form with existing values pre-filled
+        # Determine schema based on existing connection type
+        conn_type = entry.data.get(CONF_CONNECTION_TYPE, CONN_TYPE_TCP)
+
+        if conn_type == CONN_TYPE_TCP:
+            schema_dict = TCP_CONFIG_SCHEMA.copy()
+        else:
+            schema_dict = SERIAL_CONFIG_SCHEMA.copy()
+
+        # Re-create schema with defaults from entry data
+        new_schema = {}
+        for key, value in schema_dict.items():
+            if key in entry.data:
+                # If key exists in data, use it as default
+                new_schema[key] = vol.Required(key, default=entry.data[key]) if isinstance(value,
+                                                                                           vol.Required) else vol.Optional(
+                    key, default=entry.data[key])
+            elif key == CONF_INVERTER_SERIAL and CONF_INVERTER_SERIAL not in entry.data:
+                # If serial is missing (the problem we are solving), make it required without default (or empty string)
+                new_schema[key] = vol.Required(key)
+            else:
+                new_schema[key] = value
+
+        return self.async_show_form(
+            step_id="reconfigure",
+            data_schema=vol.Schema(new_schema),
+            errors=errors
+        )
+
     async def _create_entry_from_input(self, user_input):
         """Create config entry from validated input."""
         conn_type = user_input.get(CONF_CONNECTION_TYPE, CONN_TYPE_SERIAL)
@@ -181,10 +217,10 @@ async def _create_entry_from_input(self, user_input):
             # Multi-step flow - return to config step without connection_type field
             if conn_type == CONN_TYPE_TCP:
                 schema_dict = {k: v for k, v in TCP_CONFIG_SCHEMA.items()
-                              if not (hasattr(k, 'schema') and k.schema == CONF_CONNECTION_TYPE)}
+                               if not (hasattr(k, 'schema') and k.schema == CONF_CONNECTION_TYPE)}
             else:
                 schema_dict = {k: v for k, v in SERIAL_CONFIG_SCHEMA.items()
-                              if not (hasattr(k, 'schema') and k.schema == CONF_CONNECTION_TYPE)}
+                               if not (hasattr(k, 'schema') and k.schema == CONF_CONNECTION_TYPE)}
 
             return self.async_show_form(
                 step_id="config",
@@ -228,7 +264,6 @@ async def _validate_config(self, user_input):
         controller_params = {
             "hass": self.hass,
             "device_id": user_input.get("slave", 1),
-            "identification": clean_identification(user_input.get("identification", None)),
             "fast_poll": user_input.get("poll_interval_fast", 10),
             "normal_poll": user_input.get("poll_interval_normal", 15),
             "slow_poll": user_input.get("poll_interval_slow", 15),
@@ -248,19 +283,25 @@ async def _validate_config(self, user_input):
 
         modbus_controller = ModbusController(**controller_params)
 
-        try:
-            if not await modbus_controller.connect():
-                raise ConnectionError("Failed to connect")
-            if inverter_config.type in [InverterType.GRID, InverterType.STRING]:
-                await modbus_controller.async_read_input_register(3041, 1)
-            else:
-                await modbus_controller.async_read_input_register(35000, 1)
-            return True
-        except Exception as e:
-            _LOGGER.error(f"Connection failed: {str(e)}")
-            return False
-        finally:
-            modbus_controller.close_connection()
+        for attempt in range(5):
+            try:
+                if not await modbus_controller.connect():
+                    raise ConnectionError("Failed to connect")
+                if inverter_config.type in [InverterType.GRID, InverterType.STRING]:
+                    await modbus_controller.async_read_input_register(3041, 1)
+                else:
+                    await modbus_controller.async_read_input_register(35000, 1)
+
+                return True
+            except Exception as e:
+                _LOGGER.warning(f"Connection failed attempt {attempt + 1}/5: {str(e)}")
+                if attempt < 4:
+                    await asyncio.sleep(1)
+            finally:
+                modbus_controller.close_connection()
+
+        _LOGGER.error(f"Connection failed after 5 attempts: {str(controller_params)}")
+        return False
 
     def _get_user_schema(self, user_input=None):
         """Return the appropriate schema based on connection type selection."""

custom_components/solis_modbus/const.py

@@ -25,9 +25,10 @@
 CONF_PARITY = "parity"
 CONF_STOPBITS = "stopbits"
 CONF_CONNECTION_TYPE = "connection_type"
+CONF_INVERTER_SERIAL = "inverter_serial"
 
 # Default serial values (standard for Solis inverters)
 DEFAULT_BAUDRATE = 9600
 DEFAULT_BYTESIZE = 8
 DEFAULT_PARITY = "N"
-DEFAULT_STOPBITS = 1
+DEFAULT_STOPBITS = 1

custom_components/solis_modbus/manifest.json

@@ -10,5 +10,5 @@
   "issue_tracker": "https://github.com/Pho3niX90/solis_modbus/issues",
   "quality_scale": "silver",
   "requirements": ["pymodbus>=3.11.1"],
-  "version": "3.4.1"
+  "version": "3.4.12"
 }