separate update-interval's for extended Vehicle & Meter data

Author: marq24

custom_components/evcc_intg/__init__.py

@@ -67,7 +67,9 @@
     CONF_INCLUDE_EVCC,
     CONF_USE_WS,
     CONF_EXTENDED_VEHICLE_DATA,
+    CONF_EXTENDED_VEHICLE_DATA_INTERVAL,
     CONF_EXTENDED_METER_DATA,
+    CONF_EXTENDED_METER_DATA_INTERVAL,
     CONF_PURGE_ALL,
     CONFIG_VERSION,
     CONFIG_MINOR_VERSION,
@@ -323,7 +325,9 @@ def __init__(self, hass: HomeAssistant, http_session: aiohttp.ClientSession, con
         # the interval from the coordinator in the bridge (for the config updates)...
         self._update_interval_in_seconds_from_config_entry = config_entry.data.get(CONF_SCAN_INTERVAL, 30)
         self._request_ext_vehicle_data = config_entry.data.get(CONF_EXTENDED_VEHICLE_DATA, False)
+        self._request_ext_vehicle_data_interval = config_entry.data.get(CONF_EXTENDED_VEHICLE_DATA_INTERVAL, 3600)
         self._request_ext_meter_data = config_entry.data.get(CONF_EXTENDED_METER_DATA, False)
+        self._request_ext_meter_data_interval = config_entry.data.get(CONF_EXTENDED_METER_DATA_INTERVAL, 3600)
 
         self.bridge = EvccApiBridge(host=config_entry.data.get(CONF_HOST, "NOT-CONFIGURED"),
                                     web_session=http_session,

custom_components/evcc_intg/config_flow.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Any
+from typing import Any, Final
 
 import aiohttp
 import voluptuous as vol
@@ -16,19 +16,24 @@
     CONF_USE_WS,
     CONF_PURGE_ALL,
     CONF_EXTENDED_VEHICLE_DATA,
+    CONF_EXTENDED_VEHICLE_DATA_INTERVAL,
     CONF_EXTENDED_METER_DATA,
-    CONFIG_VERSION, CONFIG_MINOR_VERSION
+    CONF_EXTENDED_METER_DATA_INTERVAL,
+    CONFIG_VERSION,
+    CONFIG_MINOR_VERSION
 )
 
 _LOGGER: logging.Logger = logging.getLogger(__package__)
 
-DEFAULT_NAME = "evcc"
-DEFAULT_HOST = "http://your-evcc-ip:7070"
-DEFAULT_SCAN_INTERVAL = 60
-DEFAULT_USE_WS = True
-DEFAULT_INCLUDE_EVCC = False
-DEFAULT_EXTENDED_VEHICLE_DATA = False
-DEFAULT_EXTENDED_METER_DATA = False
+DEFAULT_NAME: Final = "evcc"
+DEFAULT_HOST: Final = "http://your-evcc-ip:7070"
+DEFAULT_SCAN_INTERVAL: Final = 60
+DEFAULT_USE_WS: Final = True
+DEFAULT_INCLUDE_EVCC: Final = False
+DEFAULT_EXTENDED_VEHICLE_DATA: Final = False
+DEFAULT_EXTENDED_VEHICLE_DATA_INTERVAL: Final = 3600
+DEFAULT_EXTENDED_METER_DATA: Final = False
+DEFAULT_EXTENDED_METER_DATA_INTERVAL: Final = 3600
 
 class EvccFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
     """Config flow for evcc_intg."""
@@ -47,7 +52,9 @@ def __init__(self):
         self._default_use_ws = DEFAULT_USE_WS
         self._default_include_evcc = DEFAULT_INCLUDE_EVCC
         self._default_extended_vehicle_data = DEFAULT_EXTENDED_VEHICLE_DATA
+        self._default_extended_vehicle_data_interval = DEFAULT_EXTENDED_VEHICLE_DATA_INTERVAL
         self._default_extended_meter_data = DEFAULT_EXTENDED_METER_DATA
+        self._default_extended_meter_data_interval = DEFAULT_EXTENDED_METER_DATA_INTERVAL
         self._need_purge_all_list = None
 
     async def async_step_reconfigure(self, user_input: dict[str, Any] | None = None) -> ConfigFlowResult:
@@ -59,7 +66,9 @@ async def async_step_reconfigure(self, user_input: dict[str, Any] | None = None)
         self._default_use_ws = entry_data.get(CONF_USE_WS, DEFAULT_USE_WS)
         self._default_include_evcc = entry_data.get(CONF_INCLUDE_EVCC, DEFAULT_INCLUDE_EVCC)
         self._default_extended_vehicle_data = entry_data.get(CONF_EXTENDED_VEHICLE_DATA, DEFAULT_EXTENDED_VEHICLE_DATA)
+        self._default_extended_vehicle_data_interval = entry_data.get(CONF_EXTENDED_VEHICLE_DATA_INTERVAL, DEFAULT_EXTENDED_VEHICLE_DATA_INTERVAL)
         self._default_extended_meter_data = entry_data.get(CONF_EXTENDED_METER_DATA, DEFAULT_EXTENDED_METER_DATA)
+        self._default_extended_meter_data_interval = entry_data.get(CONF_EXTENDED_METER_DATA_INTERVAL, DEFAULT_EXTENDED_METER_DATA_INTERVAL)
         self._need_purge_all_list = [self._default_extended_vehicle_data, self._default_extended_meter_data]
         return await self.async_step_user()
 
@@ -122,7 +131,9 @@ async def async_step_user(self, user_input=None):
             user_input[CONF_USE_WS] = self._default_use_ws
             user_input[CONF_INCLUDE_EVCC] = self._default_include_evcc
             user_input[CONF_EXTENDED_VEHICLE_DATA] = self._default_extended_vehicle_data
+            user_input[CONF_EXTENDED_VEHICLE_DATA_INTERVAL] = self._default_extended_vehicle_data_interval
             user_input[CONF_EXTENDED_METER_DATA] = self._default_extended_meter_data
+            user_input[CONF_EXTENDED_METER_DATA_INTERVAL] = self._default_extended_meter_data_interval
             user_input[CONF_PURGE_ALL] = False
 
         return self.async_show_form(
@@ -133,8 +144,10 @@ async def async_step_user(self, user_input=None):
                 vol.Required(CONF_USE_WS, default=user_input.get(CONF_USE_WS)): bool,
                 vol.Required(CONF_SCAN_INTERVAL, default=user_input.get(CONF_SCAN_INTERVAL)): int,
                 vol.Optional(CONF_PASSWORD, default=user_input.get(CONF_PASSWORD, "")): str,
-                vol.Optional(CONF_EXTENDED_VEHICLE_DATA, default=user_input.get(CONF_EXTENDED_VEHICLE_DATA, DEFAULT_EXTENDED_VEHICLE_DATA)): bool,
-                vol.Optional(CONF_EXTENDED_METER_DATA, default=user_input.get(CONF_EXTENDED_METER_DATA, DEFAULT_EXTENDED_METER_DATA)): bool,
+                vol.Optional(CONF_EXTENDED_VEHICLE_DATA, default=user_input.get(CONF_EXTENDED_VEHICLE_DATA)): bool,
+                vol.Optional(CONF_EXTENDED_VEHICLE_DATA_INTERVAL, default=user_input.get(CONF_EXTENDED_VEHICLE_DATA_INTERVAL)): int,
+                vol.Optional(CONF_EXTENDED_METER_DATA, default=user_input.get(CONF_EXTENDED_METER_DATA)): bool,
+                vol.Optional(CONF_EXTENDED_METER_DATA_INTERVAL, default=user_input.get(CONF_EXTENDED_METER_DATA_INTERVAL)): int,
                 vol.Required(CONF_INCLUDE_EVCC, default=user_input.get(CONF_INCLUDE_EVCC)): bool,
                 vol.Optional(CONF_PURGE_ALL, default=user_input.get(CONF_PURGE_ALL)): bool,
             }),

custom_components/evcc_intg/const.py

@@ -57,7 +57,9 @@
 CONF_PURGE_ALL: Final = "purge_all_devices"
 CONF_USE_WS= "use_websocket"
 CONF_EXTENDED_VEHICLE_DATA: Final = "extended_vehicle_data"
+CONF_EXTENDED_VEHICLE_DATA_INTERVAL: Final = "extended_vehicle_data_interval"
 CONF_EXTENDED_METER_DATA: Final = "extended_meter_data"
+CONF_EXTENDED_METER_DATA_INTERVAL: Final = "extended_meter_data_interval"
 
 EVCC_JSON_KEY_NAME: Final = "evccName"
 EVCC_JSON_ORIGIN_OBJECT = "originObject"

custom_components/evcc_intg/manifest.json

@@ -11,5 +11,5 @@
   "iot_class": "local_push",
   "issue_tracker": "https://github.com/marq24/ha-evcc/issues",
   "requirements": ["packaging>=21.0"],
-  "version": "2026.5.11"
+  "version": "2026.5.12"
 }

custom_components/evcc_intg/pyevcc_ha/__init__.py

@@ -229,11 +229,17 @@ def __init__(self, host: str, web_session, coordinator: DataUpdateCoordinator =
 
         self._TARIFF_LAST_UPDATE_QUARTER_HOUR = -1
         self._SESSIONS_LAST_UPDATE_HOUR = -1
-        self._CONFIG_LAST_UPDATE = -1
-        if self.coordinator is not None and hasattr(self.coordinator, '_update_interval_in_seconds_from_config_entry'):
-            self._CONFIG_UPDATE_INTERVAL_IN_SECONDS = self.coordinator._update_interval_in_seconds_from_config_entry
+        self._CONFIG_VEHICLE_LAST_UPDATE = -1
+        self._CONFIG_METER_LAST_UPDATE = -1
+        if self.coordinator is not None and hasattr(self.coordinator, '_request_ext_vehicle_data_interval'):
+            self._CONFIG_VEHICLE_UPDATE_INTERVAL_IN_SECONDS = self.coordinator._request_ext_vehicle_data_interval
         else:
-            self._CONFIG_UPDATE_INTERVAL_IN_SECONDS = 60 * 15 # the default update will be every 15 minutes
+            self._CONFIG_VEHICLE_UPDATE_INTERVAL_IN_SECONDS = 60 * 60
+
+        if self.coordinator is not None and hasattr(self.coordinator, '_request_ext_meter_data_interval'):
+            self._CONFIG_METER_UPDATE_INTERVAL_IN_SECONDS = self.coordinator._request_ext_meter_data_interval
+        else:
+            self._CONFIG_METER_UPDATE_INTERVAL_IN_SECONDS = 60 * 60
 
         self._data = {}
 
@@ -270,7 +276,8 @@ def available_fields(self) -> int:
     def clear_data(self, clear_evcc_data: bool = True):
         self._TARIFF_LAST_UPDATE_QUARTER_HOUR = -1
         self._SESSIONS_LAST_UPDATE_HOUR = -1
-        self._CONFIG_LAST_UPDATE = -1
+        self._CONFIG_VEHICLE_LAST_UPDATE = -1
+        self._CONFIG_METER_LAST_UPDATE = -1
         self._ws_LAST_UPDATE = -1
         self._ws_LAST_NEW_DATA_NOTIFY = -1
         if clear_evcc_data:
@@ -298,7 +305,8 @@ async def connect_ws(self):
                             if self._data is None or len(self._data) == 0:
                                 self._TARIFF_LAST_UPDATE_QUARTER_HOUR = -1
                                 self._SESSIONS_LAST_UPDATE_HOUR = -1
-                                self._CONFIG_LAST_UPDATE = -1
+                                self._CONFIG_VEHICLE_LAST_UPDATE = -1
+                                self._CONFIG_METER_LAST_UPDATE = -1
                                 await self.read_all_data()
                         except:
                             _LOGGER.info(f"could not read initial data from evcc@{self.host} - ignoring")
@@ -489,12 +497,20 @@ async def read_all_data(self, request_all:bool=True,
         # additional configuration endpoint data
         if request_all or request_config:
             now_time = time()
-            if self._CONFIG_LAST_UPDATE + self._CONFIG_UPDATE_INTERVAL_IN_SECONDS <= time():
-                _LOGGER.debug(f"going to request 'configuration' data from evcc@{self.host}")
-                json_resp, data_was_fetched = await self.read_config_data(json_resp, log_requests=log_config_requests)
+            request_vehicle_data = self._request_ext_vehicle_data and self._CONFIG_VEHICLE_LAST_UPDATE + self._CONFIG_VEHICLE_UPDATE_INTERVAL_IN_SECONDS <= time()
+            request_meter_data = self._request_ext_meter_data and self._CONFIG_METER_LAST_UPDATE + self._CONFIG_METER_UPDATE_INTERVAL_IN_SECONDS <= time()
+            if request_vehicle_data or request_meter_data:
+                _LOGGER.debug(f"going to request 'configuration' data vehicle: {request_vehicle_data}, meter: {request_meter_data} from evcc@{self.host}")
+                json_resp, data_was_fetched = await self.read_config_data(json_resp,
+                                                                          request_vehicle_data=request_vehicle_data,
+                                                                          request_meter_data=request_meter_data,
+                                                                          log_requests=log_config_requests)
                 if data_was_fetched:
                     self._data_coordinator_update_needed = True
-                    self._CONFIG_LAST_UPDATE = now_time
+                    if request_vehicle_data:
+                        self._CONFIG_VEHICLE_LAST_UPDATE = now_time
+                    if request_meter_data:
+                        self._CONFIG_METER_LAST_UPDATE = now_time
             else:
                 # we must copy the previous existing data to the new json_resp!
                 if self._data is not None and ADDITIONAL_ENDPOINTS_DATA_EVCCCONF in self._data:
@@ -558,7 +574,7 @@ async def read_sessions_data(self, json_resp: dict) -> dict:
 
         return json_resp, session_data_was_fetched
 
-    async def read_config_data(self, json_resp: dict, log_requests:bool=False):
+    async def read_config_data(self, json_resp: dict, request_vehicle_data:bool=False, request_meter_data:bool=False, log_requests:bool=False):
         config_data_was_fetched = False
         if await self.ensure_session_is_authorized():
             if ADDITIONAL_ENDPOINTS_DATA_EVCCCONF not in json_resp:
@@ -571,12 +587,27 @@ async def read_config_data(self, json_resp: dict, log_requests:bool=False):
             a_config = json_resp[ADDITIONAL_ENDPOINTS_DATA_EVCCCONF][EVCCCONF_KEY_CONFIG]
 
             for a_device_type, value_list in a_config.items():
-                if a_device_type == EVCCCONF_DEVICE_TYPES.VEHICLE.value and not self._request_ext_vehicle_data:
-                    _LOGGER.debug(f"skipping vehicle data since 'request_ext_vehicle_data' is set to False")
-                    continue
+                # first we check if we must fetch vehicle or meter data at all... and if not (either cause it's completely
+                # disabled by the user/config, or if the update interval is just not reached yet
+                just_copy_old_data_for_device_type = False
+                if a_device_type == EVCCCONF_DEVICE_TYPES.VEHICLE.value and (not request_vehicle_data or not self._request_ext_vehicle_data):
+                    _LOGGER.debug(f"skipping vehicle data since 'request_ext_vehicle_data' is set to False (or update-interval-not-reached-yet)")
+                    just_copy_old_data_for_device_type = True
+
+                if a_device_type == EVCCCONF_DEVICE_TYPES.METER.value and (not request_meter_data or not self._request_ext_meter_data):
+                    _LOGGER.debug(f"skipping meter data since 'request_ext_meter_data' is set to False (or update-interval-not-reached-yet)")
+                    just_copy_old_data_for_device_type = True
+
+                if just_copy_old_data_for_device_type:
+                    # make sure that the data is initialized (this is requird, when self._data is not set (yet))
+                    if a_device_type not in json_resp[ADDITIONAL_ENDPOINTS_DATA_EVCCCONF][EVCCCONF_KEY_DATA]:
+                        json_resp[ADDITIONAL_ENDPOINTS_DATA_EVCCCONF][EVCCCONF_KEY_DATA][a_device_type] = {}
 
-                if a_device_type == EVCCCONF_DEVICE_TYPES.METER.value and not self._request_ext_meter_data:
-                    _LOGGER.debug(f"skipping meter data since 'request_ext_meter_data' is set to False")
+                    if self._data is not None and ADDITIONAL_ENDPOINTS_DATA_EVCCCONF in self._data:
+                        if EVCCCONF_KEY_DATA in self._data[ADDITIONAL_ENDPOINTS_DATA_EVCCCONF]:
+                            if a_device_type in self._data[ADDITIONAL_ENDPOINTS_DATA_EVCCCONF][EVCCCONF_KEY_DATA]:
+                                object_to_copy = self._data[ADDITIONAL_ENDPOINTS_DATA_EVCCCONF][EVCCCONF_KEY_DATA][a_device_type]
+                                json_resp[ADDITIONAL_ENDPOINTS_DATA_EVCCCONF][EVCCCONF_KEY_DATA][a_device_type] = object_to_copy
                     continue
 
                 for a_device_id in value_list:
@@ -937,7 +968,8 @@ async def _read_config_setup(self, log_requests:bool=False):
 
     async def force_config_update(self):
         _LOGGER.debug(f"force_config_update(): forcing config update")
-        self._CONFIG_LAST_UPDATE = -1
+        self._CONFIG_VEHICLE_LAST_UPDATE = -1
+        self._CONFIG_METER_LAST_UPDATE = -1
         await self.read_all_data(request_all=False, request_config=True)
         if self.coordinator is not None:
             self.coordinator.async_set_updated_data(self._data)

custom_components/evcc_intg/translations/de.json

@@ -13,17 +13,20 @@
           "host": "Deine lokale evcc-Server Addresse (einschließlich des Ports)",
           "password": "Admin Passwort für den evcc-Server (optional)",
           "use_websocket": "WebSocket Verbindung verwenden",
-          "scan_interval": "Aktualisierungsintervall in Sekunden [min: 5sek]",
+          "scan_interval": "Haupt-Aktualisierungsintervall in Sekunden [min: 5sek]",
           "include_evcc": "Allen Namen der Sensoren den Präfix '[evcc]' voranstellen",
           "extended_vehicle_data": "Erweiterte Fahrzeugdaten von der evcc Konfiguration abrufen",
           "extended_meter_data": "Zählerdaten von der evcc Konfiguration abrufen",
           "purge_all_devices": "Alle Geräte (Devices) Löschen und neu Erstellen"
         },
         "data_description": {
-          "scan_interval": "Wenn Du die WebSocket Verbindung aktiviert hast, ist das Aktualisierungsintervall nur für die Zugriffe auf die _optionale_ evcc Konfigurations-API relevant.",
+          "use_websocket": "Die WebSocket Verbindung stellt sicher, dass die Sensoren mehr oder weniger sofort aktualisiert werden, sobald sich in Daten in evcc ändern. Wenn diese Option aktiviert ist, wird das Aktualisierungsintervall ignoriert.",
+          "scan_interval": "Wenn Du die WebSocket Verbindung aktiviert hast, ist das Haupt-Aktualisierungsintervall irrelevant.",
           "password": "Die Angabe Deines evcc Admin-Passwort ist __optional__ und nur für erweiterte Features der Integration notwendig. Wenn Du Dir unsicher bist, lass dieses Feld bitte leer.\nDu kannst das Passwort auch jederzeit nachträglich hinzufügen, wenn Du feststellst, dass Du die erweiterten Funktionen der Integration verwendne möchtest (z.B. Neustart des evcc-Servers via HA).\n\nWenn Du Dein aktuelles Passwort __entfernen__ möchtest, dann mußt Du ein __LEERZEICHEN__ eingeben (sonst erkennt HA keine Änderung)!",
-          "extended_vehicle_data": "Erfordert Zugriff auf die evcc Konfigurations-API (Admin Passwort notwendig). Wenn aktiviert, sammelt die Integration zusätzliche Fahrzeugdaten wie Ladestatus, Reichweite, Kilometerstand oder Ladestand für jedes konfigurierte Fahrzeug.\n**Warnung**: Der Abruf der erweiterten Fahrzeugdaten _kann_ dazu führen, das mit jedem Aktualisierungsinterval, evcc die Daten direkt von Deinem Fahrzeug abruft. Je nach API-Design Deines Fahrzeug-Herstellers kann dies eine Entladung der 12V Batterie zur Folge haben.",
+          "extended_vehicle_data": "Erfordert Zugriff auf die evcc Konfigurations-API (Admin Passwort notwendig). Wenn aktiviert, sammelt die Integration zusätzliche Fahrzeugdaten wie Ladestatus, Reichweite, Kilometerstand oder Ladestand für jedes konfigurierte Fahrzeug.\nNormalerweise (ohne diese aktivierte Option) sind diese Informationen nur dann in der Integration verfügbar, wenn ein Fahrzeug an einen evcc Ladepunkt angeschlossen ist.\n\n**Warnung**: Der Abruf der erweiterten Fahrzeugdaten _kann_ dazu führen, das mit jedem Aktualisierungsinterval, evcc die Daten direkt von Deinem Fahrzeug abruft. Je nach Fahrzeug-Herstellers-API-Design [wie bei der _Hyundai Bluelink (EU)_] kann dies eine Entladung der 12V Batterie zur Folge haben. Ebenso kann ein mögliches API-Request-Limit schneller aufgebraucht sein (z.B. bei Testa). Also AugenAuf!",
+          "extended_vehicle_data_interval": "Wenn die Option '_Erweiterte Fahrzeugdaten von der evcc Konfiguration abrufen_' aktiviert ist, werden diese _zusätzlichen_ Fahrzeugdaten in dem eingestellten Interval aktualisiert. Bitte beachte auch die zusätzliche **Warnung** oben (Default-Wert: 3600 Sekunden = jede Stunde).",
           "extended_meter_data": "Erfordert Zugriff auf die evcc Konfigurations-API (Admin Passwort notwendig). Wenn aktiviert, sammelt die Integration zusätzliche Zählerdaten wie Leistung, Energie, Phasenströme, Phasenspannungen oder Ladestand/Temperaturen für jeden konfigurierten Zähler.",
+          "extended_meter_data_interval": "Wenn die Option '_Zählerdaten von der evcc Konfiguration abrufen_' aktiviert ist, werden die erweiterte Zählerdaten in dem eingestellten Interval aktualisiert (Default-Wert: 3600 Sekunden = jede Stunde).",
           "purge_all_devices": "Dies kann notwendig werden, wenn Du verwaiste Geräte (Einträge) bei Dir in HA hast. Diese Einstellung wird automatisch zurückgesetzt."
         }
       }