Add files via upload

Update 2.4.1

Author: HAEdwin

custom_components/apsystems_ecu_reader/__init__.py

@@ -21,6 +21,7 @@
 
 from .const import DOMAIN
 from .ecu_api import APsystemsSocket, APsystemsInvalidData
+from .gui_helpers import set_inverter_state, set_zero_export, reboot_ecu  # Import the functions
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -39,58 +40,17 @@ def __init__(self, ipaddr, wifi_ssid, wifi_password, show_graphs):
         self.cached_data = {}
 
     # called from switch.py
-    def set_inverter_state(self, inverter_id, state):
+    async def set_inverter_state(self, inverter_id, state):
         """Set the on/off state of an inverter. 1=on, 2=off"""
-        action = {"ids[]": f'{inverter_id}1' if state else f'{inverter_id}2'}
-        headers = {'X-Requested-With': 'XMLHttpRequest', "Connection": "keep-alive"}
-        url = f'http://{self.ipaddr}/index.php/configuration/set_switch_state'
-
-        try:
-            response = requests.post(url, headers=headers, data=action, timeout=15)
-            _LOGGER.debug(
-                "Response from ECU on switching the inverter %s to state %s: %s",
-                inverter_id, 'on' if state else 'off',
-                re.search(r'"message":"([^"]+)"', response.text).group(1)
-            )
+        await set_inverter_state(self.ipaddr, inverter_id, state)
 
-        except (requests.ConnectionError, requests.Timeout, requests.HTTPError) as err:
-            _LOGGER.debug(
-                "Attempt to switch inverter %s failed with error: %s\n\t"
-                "This switch is only compatible with ECU-ID 2162... series and ECU-C models",
-                state, err
-            )
+    async def set_zero_export(self, state):
+        """Set the bridge state for zero export. 0=closed, 1=open"""
+        await set_zero_export(self.ipaddr, state)
 
     async def reboot_ecu(self):
         """ Reboot the ECU (compatible with ECU-ID 2162... series and ECU-C models) """
-        _LOGGER.debug("ecu_id: %s", self.cached_data.get("ecu_id", None))
-        if (
-            (self.cached_data.get("ecu_id", None)[0:3] == "215")
-            or (self.cached_data.get("ecu_id", None)[0:4] == "2162")
-        ):
-            action = {
-                'SSID': self.wifi_ssid,
-                'channel': 0,
-                'method': 2,
-                'psk_wep': '',
-                'psk_wpa': self.wifi_password
-            }
-            headers = {'X-Requested-With': 'XMLHttpRequest'}
-            url = 'http://' + str(self.ipaddr) + '/index.php/management/set_wlan_ap'
-
-            try:
-                async with (
-                    aiohttp.ClientSession() as session,
-                    async_timeout.timeout(15),
-                    session.post(url, headers=headers, data=action) as response
-                ):
-                    return await response.text()
-            except (
-                aiohttp.ClientError,
-                aiohttp.ClientConnectionError,
-                asyncio.TimeoutError,
-            ) as err:
-                return err
-
+        return await reboot_ecu(self.ipaddr, self.wifi_ssid, self.wifi_password, self.cached_data)
 
     async def update(self, port_retries, cache_reboot, show_graphs):
         """ Fetch ECU data or use cached data if querying failed. """

custom_components/apsystems_ecu_reader/binary_sensor.py

@@ -2,24 +2,16 @@
 
 import logging
 
-from homeassistant.components.binary_sensor import (
-    BinarySensorEntity,
-)
+from homeassistant.components.binary_sensor import BinarySensorEntity
 from homeassistant.helpers.entity import EntityCategory
-from homeassistant.helpers.update_coordinator import (
-    CoordinatorEntity,
-)
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
-from .const import (
-    DOMAIN,
-    CACHE_ICON
-)
+from .const import DOMAIN, CACHE_ICON
 
 _LOGGER = logging.getLogger(__name__)
 
 async def async_setup_entry(hass, _, add_entities):
-    """Set up the binary sensor for the APsystems ECU data cache"""
-
+    """Set up the binary sensor for the APsystems ECU data cache."""
     ecu = hass.data[DOMAIN].get("ecu")
     coordinator = hass.data[DOMAIN].get("coordinator")
 
@@ -31,18 +23,14 @@ async def async_setup_entry(hass, _, add_entities):
     ])
 
 class APsystemsECUBinarySensor(CoordinatorEntity, BinarySensorEntity):
-    """Representation of a binary sensor for APsystems ECU"""
+    """Representation of a binary sensor for APsystems ECU."""
 
     def __init__(self, coordinator, ecu, field, label=None, icon=None):
-
         super().__init__(coordinator)
-
         self.coordinator = coordinator
         self._ecu = ecu
         self._field = field
-        self._label = label
-        if not label:
-            self._label = field
+        self._label = label or field
         self._icon = icon
         self._name = f"ECU {self._label}"
         self._state = None
@@ -65,14 +53,13 @@ def icon(self):
 
     @property
     def extra_state_attributes(self):
-
-        attrs = {
-            "ecu_id" : self._ecu.ecu.ecu_id,
-            "firmware" : self._ecu.ecu.firmware,
-            "timezone" : self._ecu.ecu.timezone,
-            "last_update" : self._ecu.ecu.last_update
+        """Return the state attributes of the sensor."""
+        return {
+            "ecu_id": self._ecu.ecu.ecu_id,
+            "firmware": self._ecu.ecu.firmware,
+            "timezone": self._ecu.ecu.timezone,
+            "last_update": self._ecu.ecu.last_update
         }
-        return attrs
 
     @property
     def entity_category(self):

custom_components/apsystems_ecu_reader/config_flow.py

@@ -6,41 +6,73 @@
 from .const import DOMAIN, KEYS
 from .ecu_api import APsystemsSocket, APsystemsInvalidData
 
-
 _LOGGER = logging.getLogger(__name__)
 
+SCAN_INTERVAL = 300
+PORT_RETRIES = 5
+CACHE_REBOOT = 3
+SHOW_GRAPHS = True
+WIFI_SSID = "ECU-WIFI_local"
+WIFI_PASSWORD = "default"
 
 @config_entries.HANDLERS.register(DOMAIN)
-class FlowHandler(config_entries.ConfigFlow):
+class FlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
     """Handle a config flow."""
     VERSION = 1
 
+    def __init__(self):
+        """Initialize the flow handler."""
+        self.ecu_id = None
+        self.user_input = {}
+
     async def async_step_user(self, user_input=None):
         errors = {}
         init_schema = vol.Schema({
-            vol.Required(KEYS[0], default=''): str, # ECU Host
-            vol.Required(KEYS[1], default=300): int, # scan interval
-            vol.Required(KEYS[2], default=5): vol.All(int, vol.Range(min=1, max=10)), # Port retries
-            vol.Required(KEYS[3], default=3): vol.All(int, vol.Range(min=3, max=5)), # Cache reboot
-            vol.Optional(KEYS[4], default=True): bool, # Show graphs
-            vol.Optional(KEYS[5], default="ECU-WIFI_local"): str, # SSID
-            vol.Optional(KEYS[6], default="default"): str, # Password
+            vol.Required(KEYS[0], default=''): str,
+            vol.Required(KEYS[1], default=SCAN_INTERVAL): int,
+            vol.Required(KEYS[2], default=PORT_RETRIES): vol.All(int, vol.Range(1, 10)),
+            vol.Optional(KEYS[4], default=SHOW_GRAPHS): bool,
         })
 
         if user_input:
             ecu_id = await test_ecu_connection(user_input)
             if ecu_id:
-                await self.async_set_unique_id(ecu_id)
+                _LOGGER.debug("ECU connection successful, ECU ID: %s", ecu_id)
+                self.ecu_id = ecu_id
+                self.user_input = user_input
+                if ecu_id.startswith(("215", "2162")):
+                    return await self.async_step_additional_options()
                 return self.async_create_entry(title="APsystems", data=user_input)
             errors["ecu_host"] = "no_ecu_found"
 
-        # Show form because user input is empty.
         return self.async_show_form(
             step_id="user",
             data_schema=init_schema,
             errors=errors
         )
 
+    async def async_step_additional_options(self, user_input=None):
+        """Handle additional options for ECU-R-Pro and ECU-C devices."""
+        errors = {}
+        additional_schema = vol.Schema({
+            vol.Required(KEYS[3], default=CACHE_REBOOT): vol.All(int, vol.Range(3, 5)),
+            vol.Optional(KEYS[5], default=WIFI_SSID): str,
+            vol.Optional(KEYS[6], default=WIFI_PASSWORD): str,
+        })
+
+        if user_input:
+            _LOGGER.debug("Received additional options: %s", user_input)
+            user_input.update(self.user_input)
+            await self.async_set_unique_id(self.ecu_id)
+            return self.async_create_entry(title="APsystems", data=user_input)
+
+        return self.async_show_form(
+            step_id="additional_options",
+            data_schema=additional_schema,
+            errors=errors,
+            description_placeholders={"title": "Additional Configuration"}
+        )
+
     @staticmethod
     @callback
     def async_get_options_flow(config_entry):
@@ -52,34 +84,17 @@ class OptionsFlowHandler(config_entries.OptionsFlow):
 
     def __init__(self, entry: config_entries.ConfigEntry) -> None:
         """Initialize options flow."""
-        super().__init__()
         self.entry = entry
 
     async def async_step_init(self, user_input=None):
         """Manage the options."""
         errors = {}
-        # Get current options
-        current_config = {**self.entry.data}
+        _cfg = {**self.entry.data}
         alter_schema = vol.Schema({
-            vol.Required(KEYS[0], default=current_config.get(KEYS[0])): str,  # ECU Host
-            vol.Required(KEYS[1], default=current_config.get(KEYS[1], 300)): int, # Scan interval
-            vol.Required(
-                KEYS[2],
-                default=current_config.get(KEYS[2], 5)
-            ): vol.All(
-                int,
-                vol.Range(min=1, max=10)
-            ), # Port retries
-            vol.Required(
-                KEYS[3],
-                default=current_config.get(KEYS[3], 3)
-            ): vol.All(
-                int,
-                vol.Range(min=3, max=5)
-            ), # Cache reboot
-            vol.Optional(KEYS[4], default=current_config.get(KEYS[4], True)): bool,  # Show graphs
-            vol.Optional(KEYS[5], default=current_config.get(KEYS[5], "ECU-local")): str,  # SSID
-            vol.Optional(KEYS[6], default=current_config.get(KEYS[6], "default")): str, # Password
+            vol.Required(KEYS[0], default=_cfg.get(KEYS[0])): str,
+            vol.Required(KEYS[1], default=_cfg.get(KEYS[1], SCAN_INTERVAL)): int,
+            vol.Required(KEYS[2], default=_cfg.get(KEYS[2], PORT_RETRIES)): vol.All(int, vol.Range(1, 10)),
+            vol.Optional(KEYS[4], default=_cfg.get(KEYS[4], SHOW_GRAPHS)): bool,
         })
 
         if user_input:
@@ -89,14 +104,42 @@ async def async_step_init(self, user_input=None):
                     self.entry,
                     data={**self.entry.data, **user_input}
                 )
+                if ecu_id.startswith(("215", "2162")):
+                    return await self.async_step_additional_options()
                 return self.async_create_entry(title="APsystems", data={})
             errors["ecu_host"] = "no_ecu_found"
+
         return self.async_show_form(
             step_id="init",
             data_schema=alter_schema,
             errors=errors
         )
 
+    async def async_step_additional_options(self, user_input=None):
+        """Handle additional options."""
+        errors = {}
+        _cfg = {**self.entry.data}
+        additional_schema = vol.Schema({
+            vol.Required(KEYS[3], default=_cfg.get(KEYS[3], CACHE_REBOOT)): vol.All(int, vol.Range(3, 5)),
+            vol.Optional(KEYS[5], default=_cfg.get(KEYS[5], WIFI_SSID)): str,
+            vol.Optional(KEYS[6], default=_cfg.get(KEYS[6], WIFI_PASSWORD)): str,
+        })
+
+        if user_input:
+            _LOGGER.debug("Received additional options: %s", user_input)
+            self.hass.config_entries.async_update_entry(
+                self.entry,
+                data={**self.entry.data, **user_input}
+            )
+            return self.async_create_entry(title="APsystems", data={})
+
+        return self.async_show_form(
+            step_id="additional_options",
+            data_schema=additional_schema,
+            errors=errors,
+            description_placeholders={"title": "Additional Configuration"}
+        )
+
 async def test_ecu_connection(input_data):
     """Test the connection to the ECU and return the ECU ID if successful."""
     try:

custom_components/apsystems_ecu_reader/ecu_api.py

@@ -6,7 +6,7 @@
 import socket
 import logging
 
-from .helper import (
+from .ecu_helpers import (
     aps_datetimestamp,
     aps_str,
     aps_int_from_bytes,
@@ -126,7 +126,6 @@ async def query_ecu(self, port_retries, show_graphs):
         await self.open_socket(port_retries)
         self.ecu_raw_data, status = await self.send_read_from_socket(self.ecu_cmd)
         await self.close_socket()
-        _LOGGER.debug("ECU raw data: %s", self.ecu_raw_data.hex())
         if status or not self.ecu_raw_data:
             raise APsystemsInvalidData(
                 f"querying ECU where status is: {status}"