Add 2.13.0 files

Author: HAEdwin

custom_components/apsystems_ecu_reader/__init__.py

@@ -7,7 +7,14 @@
 from homeassistant.helpers import device_registry as dr
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
 
-from .const import DOMAIN, ECU_MODEL_MAP, DEFAULT_SCAN_INTERVAL, DEFAULT_PORT_RETRIES, SETUP_DELAY_SECONDS, DEFAULT_CACHE_REBOOT
+from .const import (
+    DOMAIN,
+    ECU_MODEL_MAP,
+    DEFAULT_SCAN_INTERVAL,
+    DEFAULT_PORT_RETRIES,
+    SETUP_DELAY_SECONDS,
+    DEFAULT_CACHE_REBOOT,
+)
 from .ecu_api import APsystemsSocket, APsystemsInvalidData
 from .gui_helpers import (
     set_inverter_state,
@@ -28,7 +35,7 @@ class ECUREADER:
     def __init__(
         self, ipaddr: str, wifi_ssid: str, wifi_password: str, show_graphs: bool
     ) -> None:
-    
+
         self.ipaddr = ipaddr
         self.wifi_ssid = wifi_ssid
         self.wifi_password = wifi_password
@@ -49,9 +56,14 @@ async def set_inverter_state(self, inverter_id, state) -> bool:
         """Set the on/off state of an inverter. 1=on, 2=off"""
         return await set_inverter_state(self.ipaddr, inverter_id, state)
 
-    async def set_zero_export(self, state):
+    async def set_zero_export(self, state, power_limit):
         """Set the bridge state for zero export. 0=closed, 1=open"""
-        return await set_zero_export(self.ipaddr, state)
+        return await set_zero_export(self.ipaddr, state, power_limit)
+
+    # called from number.py
+    async def set_power_limit(self, power_limit):
+        """Set the power limit for zero export"""
+        return await set_zero_export(self.ipaddr, 1, power_limit)
 
     # called from button.py
     async def reboot_ecu(self):
@@ -128,7 +140,9 @@ async def async_setup_entry(hass, config):
     if len(hass.data[DOMAIN]) > 1:
         await asyncio.sleep(SETUP_DELAY_SECONDS)
 
-    interval = timedelta(seconds=config.data.get("scan_interval", DEFAULT_SCAN_INTERVAL))
+    interval = timedelta(
+        seconds=config.data.get("scan_interval", DEFAULT_SCAN_INTERVAL)
+    )
     ecu = ECUREADER(
         config.data["ecu_host"],
         config.data.get("wifi_ssid", "ECU-local"),

custom_components/apsystems_ecu_reader/gui_helpers.py

@@ -61,9 +61,13 @@ async def set_inverter_state(ipaddr, inverter_id, state) -> bool:
     return False
 
 
-async def set_zero_export(ipaddr, state):
+async def set_zero_export(ipaddr, state, power_limit=0):
     """Set the bridge state for zero export. 0=closed, 1=open"""
-    action = {"meter_func": "1" if state else "0", "this_func": "1", "power_limit": "0"}
+    action = {
+        "meter_func": "1" if state else "0",
+        "this_func": "1",
+        "power_limit": str(power_limit),
+    }
     headers = {"X-Requested-With": "XMLHttpRequest", "Connection": "keep-alive"}
     url = f"http://{ipaddr}/index.php/meter/set_meter_display_funcs"
 

custom_components/apsystems_ecu_reader/manifest.json

@@ -5,9 +5,11 @@
   "config_flow": true,
   "dependencies": [],
   "documentation": "https://github.com/haedwin/homeassistant-apsystems_ecu_reader",
+  "homeassistant": "2022.2.0",
   "integration_type": "hub",
   "iot_class": "local_polling",
   "issue_tracker": "https://github.com/haedwin/homeassistant-apsystems_ecu_reader/issues",
   "loggers": ["custom_components.apsystems_ecu_reader"],
-  "version": "2.12.1"
+  "requirements": [],
+  "version": "2.13.0"
 }

custom_components/apsystems_ecu_reader/number.py

@@ -5,21 +5,28 @@
 from homeassistant.helpers.entity import EntityCategory
 
 
-from .const import DOMAIN, INVERTER_MODEL_MAP
+from .const import DOMAIN, INVERTER_MODEL_MAP, ECU_MODEL_MAP
 
 
 async def async_setup_entry(hass, config_entry, async_add_entities):
     """Set up the number platform."""
     coordinator = hass.data[DOMAIN][config_entry.entry_id]["coordinator"]
     ecu = hass.data[DOMAIN][config_entry.entry_id]["ecu"]
 
-    # Only compatible with ECU-C and ECU-R-Pro
+    entities = []
+
+    # ECU Power Limit Number - only compatible with ECU-C
+    if ecu.ecu.ecu_id.startswith("215"):
+        entities.append(ECUPowerLimitNumber(coordinator, ecu))
+
+    # Inverter Max Power Numbers - only compatible with ECU-C and ECU-R-Pro
     if ecu.ecu.ecu_id.startswith(("215", "2162")):
-        entities = []
         for inverter_id, inverter_data in coordinator.data.get("inverters", {}).items():
             entities.append(
                 InverterMaxPwrNumber(coordinator, ecu, inverter_id, inverter_data)
             )
+
+    if entities:
         async_add_entities(entities, True)
 
 
@@ -67,6 +74,70 @@ async def async_set_native_value(self, value: float):
         self._attr_native_value = value
         self.async_write_ha_state()
 
+    def set_native_value(self, value: float):
+        """Set the value synchronously (required by NumberEntity)."""
+        # This is called by Home Assistant framework, but we use async version
+        self._attr_native_value = value
+
+    async def async_added_to_hass(self):
+        """Handle entity which value will be restored."""
+        await super().async_added_to_hass()
+        if (last_state := await self.async_get_last_state()) is not None:
+            self._attr_native_value = float(last_state.state)
+
+
+class ECUPowerLimitNumber(CoordinatorEntity, RestoreNumber):
+    """Representation of an ECU Power Limit Number entity."""
+
+    def __init__(self, coordinator, ecu):
+        """Initialize the number entity."""
+        super().__init__(coordinator)
+        self._ecu = ecu
+        self._attr_name = f"ECU {ecu.ecu.ecu_id} Power Limit"
+        self._attr_unique_id = f"{ecu.ecu.ecu_id}_power_limit"
+        self._attr_native_min_value = 0
+        self._attr_native_max_value = 3
+        self._attr_native_step = 0.1
+        self._attr_native_value = 0
+        self._attr_device_class = "power"
+        self._attr_native_unit_of_measurement = "kW"
+        self._attr_mode = "slider"
+
+    @property
+    def device_info(self):
+        """Return the device info."""
+        return {
+            "identifiers": {
+                (DOMAIN, f"ecu_{self._ecu.ecu.ecu_id}"),
+            },
+            "name": f"ECU {self._ecu.ecu.ecu_id}",
+            "manufacturer": "APsystems",
+            "model": ECU_MODEL_MAP.get(self._ecu.ecu.ecu_id[:4], "Unknown Model"),
+        }
+
+    @property
+    def entity_category(self):
+        """Return the category of the entity."""
+        return EntityCategory.CONFIG
+
+    @property
+    def suggested_display_precision(self):
+        """Return the suggested number of decimal places for display."""
+        return 1
+
+    async def async_set_native_value(self, value: float):
+        """Update the current value."""
+        # Convert from kW to watts for the ECU API
+        power_limit_watts = int(value * 1000)
+        await self._ecu.set_power_limit(power_limit_watts)
+        self._attr_native_value = value
+        self.async_write_ha_state()
+
+    def set_native_value(self, value: float):
+        """Set the value synchronously (required by NumberEntity)."""
+        # This is called by Home Assistant framework, but we use async version
+        self._attr_native_value = value
+
     async def async_added_to_hass(self):
         """Handle entity which value will be restored."""
         await super().async_added_to_hass()

custom_components/apsystems_ecu_reader/switch.py

@@ -175,7 +175,18 @@ def __init__(self, coordinator, ecu):
     async def async_turn_on(self, **kwargs):
         """Turn on zero export."""
         try:
-            await self._ecu.set_zero_export(1)
+            # Get the current power limit from the number entity
+            power_limit_entity_id = f"number.ecu_{self._ecu.ecu.ecu_id}_power_limit"
+            power_limit_state = self.hass.states.get(power_limit_entity_id)
+            power_limit = 0
+            if power_limit_state and power_limit_state.state not in (
+                "unknown",
+                "unavailable",
+            ):
+                # Convert from kW display value to watts
+                power_limit = int(float(power_limit_state.state) * 1000)
+
+            await self._ecu.set_zero_export(1, power_limit)
             self._state = True
             self.async_write_ha_state()
         except (ConnectionError, TimeoutError) as e: