Allow to set scan interval, and reconfigure integration (#4)

Author: ArnyminerZ

custom_components/axpert_inverter/__init__.py

@@ -21,11 +21,15 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
 
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Set up Axpert Inverter from a config entry."""
-    device_path = entry.data[CONF_DEVICE_PATH]
+    # Prioritize options over data
+    device_path = entry.options.get(CONF_DEVICE_PATH, entry.data.get(CONF_DEVICE_PATH))
 
     inverter = AxpertInverter(device_path)
     coordinator = AxpertDataUpdateCoordinator(hass, inverter, entry)
 
+    # Listen for options changes
+    entry.async_on_unload(entry.add_update_listener(async_reload_entry))
+
     # Fetch firmware version once at startup
     try:
         coordinator.firmware_version = await hass.async_add_executor_job(inverter.get_firmware_version)
@@ -69,3 +73,7 @@ async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         hass.data[DOMAIN].pop(entry.entry_id)
 
     return unload_ok
+
+async def async_reload_entry(hass: HomeAssistant, entry: ConfigEntry) -> None:
+    """Reload config entry."""
+    await hass.config_entries.async_reload(entry.entry_id)

custom_components/axpert_inverter/config_flow.py

@@ -9,7 +9,9 @@
 from .const import (
     DOMAIN, 
     CONF_DEVICE_PATH, 
+    CONF_SCAN_INTERVAL,
     DEFAULT_DEVICE_PATH,
+    DEFAULT_SCAN_INTERVAL,
 )
 from .axpert import AxpertInverter
 
@@ -26,6 +28,7 @@ async def async_step_user(self, user_input=None) -> FlowResult:
 
         if user_input is not None:
             device_path = user_input.get(CONF_DEVICE_PATH)
+            scan_interval = user_input.get(CONF_SCAN_INTERVAL, DEFAULT_SCAN_INTERVAL)
 
             # Validate connection
             try:
@@ -44,10 +47,16 @@ async def async_step_user(self, user_input=None) -> FlowResult:
             step_id="user",
             data_schema=vol.Schema({
                 vol.Required(CONF_DEVICE_PATH, default=DEFAULT_DEVICE_PATH): str,
+                vol.Optional(CONF_SCAN_INTERVAL, default=DEFAULT_SCAN_INTERVAL): vol.All(vol.Coerce(int), vol.Range(min=1)),
             }),
             errors=errors,
         )
 
+    @staticmethod
+    def async_get_options_flow(config_entry):
+        """Get the options flow for this handler."""
+        return AxpertOptionsFlowHandler()
+
     def _validate_connection(self, path: str):
         """Try to connect to the inverter."""
         inverter = AxpertInverter(path)
@@ -56,11 +65,58 @@ def _validate_connection(self, path: str):
         # Actually in axpert.py we implemented send_command.
         # Let's try get_device_id. If it fails, open might fail or read timeout.
         try:
-             # Just instantiate and try one command
-             # Note: get_device_id might not work on all firmware, QPIGS is safer as main data source.
-             # But let's try QPIGS to be sure we can read data.
-             res = inverter.get_general_status()
-             if not res:
-                 raise Exception("Empty response from QPIGS during validation")
+            # Just instantiate and try one command
+            # Note: get_device_id might not work on all firmware, QPIGS is safer as main data source.
+            # But let's try QPIGS to be sure we can read data.
+            res = inverter.get_general_status()
+            if not res:
+                raise Exception("Empty response from QPIGS during validation")
+        except Exception as e:
+            raise Exception(f"Validation failed: {e}")
+
+class AxpertOptionsFlowHandler(config_entries.OptionsFlow):
+    """Handle options flow for Axpert Inverter."""
+
+    async def async_step_init(self, user_input=None) -> FlowResult:
+        """Manage the options."""
+        errors = {}
+
+        if user_input is not None:
+            device_path = user_input.get(CONF_DEVICE_PATH)
+
+            # We can optionally validate the new path here
+            # But normally we just accept it and let the reload handle connection
+            try:
+                # Basic validation using the executor
+                inverter = AxpertInverter(device_path)
+                await self.hass.async_add_executor_job(self._validate_connection_options, inverter)
+
+                return self.async_create_entry(title="", data=user_input)
+            except Exception as e:
+                _LOGGER.error(f"Failed to connect to new path: {e}")
+                errors["base"] = "cannot_connect"
+
+        current_path = self.config_entry.options.get(
+            CONF_DEVICE_PATH, self.config_entry.data.get(CONF_DEVICE_PATH, DEFAULT_DEVICE_PATH)
+        )
+        current_scan_interval = self.config_entry.options.get(
+            CONF_SCAN_INTERVAL, self.config_entry.data.get(CONF_SCAN_INTERVAL, DEFAULT_SCAN_INTERVAL)
+        )
+
+        return self.async_show_form(
+            step_id="init",
+            data_schema=vol.Schema({
+                vol.Required(CONF_DEVICE_PATH, default=current_path): str,
+                vol.Optional(CONF_SCAN_INTERVAL, default=current_scan_interval): vol.All(vol.Coerce(int), vol.Range(min=1)),
+            }),
+            errors=errors,
+        )
+
+    def _validate_connection_options(self, inverter: AxpertInverter):
+        """Validate connection during options update."""
+        try:
+            res = inverter.get_general_status()
+            if not res:
+                raise Exception("Empty response from QPIGS during validation")
         except Exception as e:
             raise Exception(f"Validation failed: {e}")

custom_components/axpert_inverter/const.py

@@ -4,6 +4,7 @@
 
 # Configuration
 CONF_DEVICE_PATH = "device_path"
+CONF_SCAN_INTERVAL = "scan_interval"
 DEFAULT_DEVICE_PATH = "/dev/hidraw0"
 
 # Default poll interval (seconds)

custom_components/axpert_inverter/coordinator.py

@@ -9,7 +9,7 @@
 )
 
 from .axpert import AxpertInverter
-from .const import DOMAIN, DEFAULT_SCAN_INTERVAL
+from .const import DOMAIN, DEFAULT_SCAN_INTERVAL, CONF_SCAN_INTERVAL
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -20,11 +20,16 @@ def __init__(self, hass: HomeAssistant, inverter: AxpertInverter, entry: ConfigE
         """Initialize."""
         self.inverter = inverter
         self.entry = entry
+        
+        scan_interval = entry.options.get(
+            CONF_SCAN_INTERVAL, entry.data.get(CONF_SCAN_INTERVAL, DEFAULT_SCAN_INTERVAL)
+        )
+        
         super().__init__(
             hass,
             _LOGGER,
             name=DOMAIN,
-            update_interval=timedelta(seconds=DEFAULT_SCAN_INTERVAL),
+            update_interval=timedelta(seconds=scan_interval),
         )
         self.firmware_version = None
         self.model_id = None

custom_components/axpert_inverter/strings.json

@@ -1,4 +1,32 @@
 {
+    "config": {
+        "step": {
+            "user": {
+                "title": "Configure Axpert Inverter",
+                "data": {
+                    "device_path": "Device Path",
+                    "scan_interval": "Polling Interval (seconds)"
+                }
+            }
+        },
+        "error": {
+            "cannot_connect": "Failed to connect to the inverter"
+        }
+    },
+    "options": {
+        "step": {
+            "init": {
+                "title": "Axpert Inverter Options",
+                "data": {
+                    "device_path": "Device Path",
+                    "scan_interval": "Polling Interval (seconds)"
+                }
+            }
+        },
+        "error": {
+            "cannot_connect": "Failed to connect to the inverter"
+        }
+    },
     "entity": {
         "select": {
             "ac_input_range": {

custom_components/axpert_inverter/translations/ca.json

@@ -1,4 +1,32 @@
 {
+    "config": {
+        "step": {
+            "user": {
+                "title": "Configurar Inversor Axpert",
+                "data": {
+                    "device_path": "Ruta del Dispositiu",
+                    "scan_interval": "Interval d'Actualització (segons)"
+                }
+            }
+        },
+        "error": {
+            "cannot_connect": "No s'ha pogut connectar a l'inversor"
+        }
+    },
+    "options": {
+        "step": {
+            "init": {
+                "title": "Opcions de l'Inversor Axpert",
+                "data": {
+                    "device_path": "Ruta del Dispositiu",
+                    "scan_interval": "Interval d'Actualització (segons)"
+                }
+            }
+        },
+        "error": {
+            "cannot_connect": "No s'ha pogut connectar a l'inversor"
+        }
+    },
     "entity": {
         "select": {
             "ac_input_range": {