Fix Tesla/Powerwall data handling and improve robustness of control loop

packages/modules/devices/tesla/tesla/counter.py

@@ -1,5 +1,6 @@
 #!/usr/bin/env python3
 import logging
+import math
 from requests import HTTPError
 
 from modules.common.abstract_device import AbstractCounter
@@ -21,29 +22,138 @@
         self.store = get_counter_value_store(self.component_config.id)
         self.fault_state = FaultState(ComponentInfo.from_component_config(self.component_config))
 
+    @staticmethod
+    def _safe_float(val, default: float = 0.0) -> float:
+        try:
+            if val is None:
+                return default
+            return float(val)
+        except (TypeError, ValueError):
+            return default
+
+    @staticmethod
+    def _nearly_zero(x: float, eps: float = 1e-9) -> bool:
+        return abs(x) < eps
+
+    def _calc_currents_and_pf_from_pqu(
+        self, voltages: list[float], p_list: list[float], q_list: list[float]
+    ) -> tuple[list[float], list[float]]:
+        """
+        Calculates signed currents (A) and signed power factors per phase from P/Q/U.
+
+        Convention:
+          - sign of current follows sign of active power P (import +, export -)
+          - PF = P / S (signed)
+          - S = sqrt(P^2 + Q^2)
+          - I = S / U (signed via P)
+        """
+        currents: list[float] = [0.0, 0.0, 0.0]
+        pfs: list[float] = [0.0, 0.0, 0.0]
+
+        for i in range(3):
+            u = self._safe_float(voltages[i], 0.0)
+            p = self._safe_float(p_list[i], 0.0)
+            q = self._safe_float(q_list[i], 0.0)
+
+            if self._nearly_zero(u):
+                currents[i] = 0.0
+                pfs[i] = 0.0
+                continue
+
+            s = math.sqrt(p * p + q * q)
+
+            if self._nearly_zero(s):
+                currents[i] = 0.0
+                pfs[i] = 0.0
+                continue
+
+            pfs[i] = p / s
+            i_mag = s / u
+            currents[i] = i_mag if p >= 0 else -i_mag
+
+        return currents, pfs
+
     def update(self, client: PowerwallHttpClient, aggregate):
         # read firmware version
-        status = client.get_json("/api/status")
-        log.debug('Firmware: ' + status["version"])
+        # - only once after startup (no firmware known yet)
+        # - and whenever a new auth cookie was negotiated (startup or reauth)
+        need_status = False
+        if getattr(client, "cookie_renewed", False):
+            need_status = True
+        elif not getattr(self.store, "firmware", ""):
+            need_status = True
+
+        if need_status:
+            try:
+                status = client.get_json("/api/status", fail_fast=False)
+                self.store.firmware = status.get("version", "")
+                log.debug("Firmware: %s", self.store.firmware)
+            except Exception:
+                # /api/status is non-critical and must not trigger fail-fast
+                pass
+
         try:
-            # read additional info if firmware supports
             meters_site = client.get_json("/api/meters/site")
+            cached = meters_site[0]["Cached_readings"]
+
+            # --- voltages / powers / reactive powers (per phase) ---
+            voltages = [self._safe_float(cached.get(f"v_l{phase}n")) for phase in range(1, 4)]
+            p_list = [self._safe_float(cached.get(f"real_power_{ph}")) for ph in ["a", "b", "c"]]
+            q_list = [self._safe_float(cached.get(f"reactive_power_{ph}")) for ph in ["a", "b", "c"]]
+
+            # --- currents from API (often all 0 on Neurio/Tesla) ---
+            api_currents = [self._safe_float(cached.get(f"i_{ph}_current")) for ph in ["a", "b", "c"]]
+
+            # --- energy counters: use aggregate site values as sole source ---
+            imported = self._safe_float(aggregate["site"]["energy_imported"])
+            exported = self._safe_float(aggregate["site"]["energy_exported"])
+
+            # --- local fallback for Tesla/Neurio setups with missing phase currents ---
+            calculated_currents, power_factors = self._calc_currents_and_pf_from_pqu(
+                voltages=voltages,
+                p_list=p_list,
+                q_list=q_list,
+            )
+
+
+            if all(self._nearly_zero(i) for i in api_currents):
+                currents = calculated_currents
+                log.debug(
+                    "Tesla/Neurio phase currents missing (all 0). "
+                    "Calculated currents locally from P/Q and U."
+                )
+            else:
+                currents = api_currents
+                log.debug("Using phase currents from Tesla/Neurio API.")
+
+            freq = self._safe_float(aggregate["site"].get("frequency", 50.0), 50.0)
+
+            serial = cached.get("serial_number")
+            serial_number = str(serial) if serial else None
+
             powerwall_state = CounterState(
-                imported=aggregate["site"]["energy_imported"],
-                exported=aggregate["site"]["energy_exported"],
-                power=aggregate["site"]["instant_power"],
-                voltages=[meters_site[0]["Cached_readings"]["v_l" + str(phase) + "n"] for phase in range(1, 4)],
-                currents=[meters_site[0]["Cached_readings"]["i_" + phase + "_current"] for phase in ["a", "b", "c"]],
-                powers=[meters_site[0]["Cached_readings"]["real_power_" + phase] for phase in ["a", "b", "c"]]
+                imported=imported,
+                exported=exported,
+                power=self._safe_float(aggregate["site"]["instant_power"]),
+                voltages=voltages,
+                currents=currents,
+                powers=p_list,
+                power_factors=power_factors,
+                frequency=round(freq, 2),
+                serial_number=serial_number,
             )
-        except (KeyError, HTTPError):
+
+        except (KeyError, HTTPError, IndexError, TypeError) as e:
             log.debug(
-                "Firmware seems not to provide detailed phase measurements. Fallback to total power only.")
+                "Firmware seems not to provide detailed phase measurements. Fallback to total power only. (%s)",
+                str(e),
+            )
             powerwall_state = CounterState(
-                imported=aggregate["site"]["energy_imported"],
-                exported=aggregate["site"]["energy_exported"],
-                power=aggregate["site"]["instant_power"]
+                imported=self._safe_float(aggregate["site"]["energy_imported"]),
+                exported=self._safe_float(aggregate["site"]["energy_exported"]),
+                power=self._safe_float(aggregate["site"]["instant_power"]),
             )
+
         self.store.set(powerwall_state)
 
 

packages/modules/devices/tesla/tesla/device.py

@@ -2,7 +2,7 @@
 import logging
 import requests
 from requests import HTTPError
-from typing import Iterable, Union
+from typing import Iterable, Union, Optional
 
 from modules.common.abstract_device import DeviceDescriptor
 from modules.common.component_context import SingleComponentUpdateContext
@@ -17,13 +17,20 @@
 log = logging.getLogger(__name__)
 
 
-def __update_components(client: PowerwallHttpClient,
-                        components: Iterable[Union[TeslaBat, TeslaCounter, TeslaInverter]]):
+def __update_components(
+    client: PowerwallHttpClient,
+    components: Iterable[Union[TeslaBat, TeslaCounter, TeslaInverter]],
+):
     aggregate = client.get_json("/api/meters/aggregates")
+
     for component in components:
         with SingleComponentUpdateContext(component.fault_state):
             component.update(client, aggregate)
 
+        # FAIL-FAST: abort remaining components if any critical request failed in this cycle
+        if client.cycle_failed:
+            break
+
 
 def _authenticate(session: requests.Session, url: str, email: str, password: str):
     """
@@ -33,15 +40,16 @@ def _authenticate(session: requests.Session, url: str, email: str, password: str
         "https://" + url + "/api/login/Basic",
         json={"username": "customer", "email": email, "password": password, "force_sm_off": False},
         verify=False,
-        timeout=5
+        timeout=5,
     )
-    log.debug("Authentication endpoint send cookies %s", str(response.cookies))
+    response.raise_for_status()
+
     return {"AuthCookie": response.cookies["AuthCookie"], "UserRecord": response.cookies["UserRecord"]}
 
 
 def create_device(device_config: Tesla):
-    http_client = None
-    session = None
+    http_client: Optional[PowerwallHttpClient] = None
+    session: Optional[requests.Session] = None
 
     def create_bat_component(component_config: TeslaBatSetup):
         return TeslaBat(component_config)
@@ -52,27 +60,48 @@ def create_counter_component(component_config: TeslaCounterSetup):
     def create_inverter_component(component_config: TeslaInverterSetup):
         return TeslaInverter(component_config)
 
+    def _ensure_initialized():
+        nonlocal http_client, session
+        if session is None or http_client is None:
+            initializer()
+        if session is None or http_client is None:
+            raise Exception("Powerwall device initializer did not create session/http_client")
+
     def update_components(components: Iterable[Union[TeslaBat, TeslaCounter, TeslaInverter]]):
-        log.debug("Beginning update")
         nonlocal http_client, session
+
         address = device_config.configuration.ip_address
         email = device_config.configuration.email
         password = device_config.configuration.password
 
+        _ensure_initialized()
+
+        # Reset per-cycle flags (fail-fast + cookie-renewed marker)
+        http_client.reset_cycle()
+
+        # First run after process start: no cookies -> authenticate once
         if http_client.cookies is None:
             http_client.cookies = _authenticate(session, address, email, password)
+            http_client.mark_cookie_renewed()
             __update_components(http_client, components)
             return
+
+        # Normal operation: reuse cookie. If it fails with 401/403 -> re-auth
         try:
             __update_components(http_client, components)
             return
         except HTTPError as e:
-            if e.response.status_code != 401 and e.response.status_code != 403:
-                raise e
-            log.warning("Login to powerwall with existing cookie failed. Will retry with new cookie...")
+            status = getattr(getattr(e, "response", None), "status_code", None)
+            if status not in (401, 403):
+                raise
+            log.warning(
+                "Login to powerwall with existing cookie failed (status=%s). Will retry with new cookie...",
+                status,
+            )
+
         http_client.cookies = _authenticate(session, address, email, password)
+        http_client.mark_cookie_renewed()
         __update_components(http_client, components)
-        log.debug("Update completed successfully")
 
     def initializer():
         nonlocal http_client, session
@@ -87,7 +116,7 @@ def initializer():
             counter=create_counter_component,
             inverter=create_inverter_component,
         ),
-        component_updater=MultiComponentUpdater(update_components)
+        component_updater=MultiComponentUpdater(update_components),
     )
 
 

packages/modules/devices/tesla/tesla/http_client.py

@@ -1,12 +1,53 @@
+import logging
+
 import requests
+from requests.exceptions import HTTPError, ConnectionError, RequestException, SSLError, Timeout
+
+log = logging.getLogger(__name__)
 
 
 class PowerwallHttpClient:
+    """
+    HTTP client wrapper for Tesla Powerwall Gateway local API calls.
+    """
+
     def __init__(self, host: str, session: requests.Session, cookies):
         self.__base_url = "https://" + host
         self.cookies = cookies
         self.__session = session
 
-    def get_json(self, relative_url: str):
+        # Fail-fast marker for the current polling cycle
+        self.cycle_failed = False
+
+        # Marker: set when a new auth cookie was negotiated (startup or reauth)
+        self.cookie_renewed = False
+
+    def reset_cycle(self):
+        """Reset per update-cycle flags."""
+        self.cycle_failed = False
+        self.cookie_renewed = False
+
+    def mark_cookie_renewed(self):
+        """Mark that cookies have been freshly negotiated (start or reauth)."""
+        self.cookie_renewed = True
+
+    def get_json(self, relative_url: str, *, fail_fast: bool = True):
+        """
+        :param fail_fast:
+            True  -> errors mark this cycle as failed (device aborts remaining components)
+            False -> errors do NOT mark cycle_failed (for non-critical endpoints like /api/status)
+        """
         url = self.__base_url + relative_url
-        return self.__session.get(url, cookies=self.cookies, verify=False, timeout=5).json()
+
+        try:
+            response = self.__session.get(
+                url,
+                cookies=self.cookies,
+                verify=False,
+                timeout=5,
+            )
+            return response.json()
+        except (HTTPError, Timeout, ConnectionError, SSLError, RequestException, ValueError):
+            if fail_fast:
+                self.cycle_failed = True
+            raise

packages/modules/devices/tesla/tesla/tesla.php

@@ -333,7 +333,7 @@ function teslaLogin () {
 								?>
 									<div class="alert alert-success">
 										Anmeldung erfolgreich!<br>
-										Die erhaltenen Token wurden gespeichert. Du kannst diese Seite jetzt schließen.
+										Die erhaltenen Token wurden gespeichert. Sie können diese Seite jetzt schließen.
 									</div>
 								<?php
 							} else {
@@ -354,7 +354,7 @@ function teslaLogin () {
 							}
 							?>
 								<div class="alert alert-success">
-									Gespeicherte Anmeldedaten wurden entfernt. Du kannst diese Seite jetzt schließen.
+									Gespeicherte Anmeldedaten wurden entfernt. Sie können diese Seite jetzt schließen.
 								</div>
 							<?php
 							break;
@@ -369,4 +369,4 @@ function teslaLogin () {
 
 		</div>  <!-- container -->
 	</body>
-</html>
+</html>