Add CPU/memory sensors and polling interval control (#504)

Adds extended diagnostics and polling control improvements to the TP-Link Deco integration.

### Added
- CPU usage sensors (raw and smoothed)
- Memory usage sensors (raw and smoothed)
- Configurable polling interval (10 / 30 / 60 / 120 seconds)
- Select entity to control polling interval from the Home Assistant UI

### Improvements
- Fixed config entry reload handling when changing options
- Improved stability of polling and API interaction

### Existing functionality
- Pause / resume polling via services
- Polling control switch

This improves both usability and stability, while adding useful diagnostics for monitoring Deco performance.

Author: dkwolf1

custom_components/tplink_deco/__init__.py

@@ -259,9 +259,20 @@ async def handle_resume_polling(service: ServiceCall) -> None:
 async def async_unload_entry(hass: HomeAssistant, config_entry: ConfigEntry) -> bool:
     """Handle removal of an entry."""
     _LOGGER.debug("async_unload_entry: Config entry %s", config_entry.entry_id)
-    data = hass.data[DOMAIN][config_entry.entry_id]
+
+    domain_data = hass.data.get(DOMAIN, {})
+    data = domain_data.get(config_entry.entry_id)
+
+    if data is None:
+        _LOGGER.debug(
+            "async_unload_entry: No stored data for config entry %s",
+            config_entry.entry_id,
+        )
+        return True
+
     deco_coordinator = data.get(COORDINATOR_DECOS_KEY)
     clients_coordinator = data.get(COORDINATOR_CLIENTS_KEY)
+
     if deco_coordinator is not None:
         await deco_coordinator.async_close()
     if clients_coordinator is not None:
@@ -275,24 +286,19 @@ async def async_unload_entry(hass: HomeAssistant, config_entry: ConfigEntry) ->
             ]
         )
     )
+
     if unloaded:
-        hass.data[DOMAIN].pop(config_entry.entry_id)
+        hass.data[DOMAIN].pop(config_entry.entry_id, None)
         hass.services.async_remove(DOMAIN, SERVICE_PAUSE_POLLING)
         hass.services.async_remove(DOMAIN, SERVICE_RESUME_POLLING)
-    return unloaded
 
-
-async def async_reload_entry(hass: HomeAssistant, config_entry: ConfigEntry) -> None:
-    """Reload config entry."""
-    _LOGGER.debug("async_reload_entry: Config entry %s", config_entry)
-    await async_unload_entry(hass, config_entry)
-    await async_setup_entry(hass, config_entry)
+    return unloaded
 
 
 async def update_listener(hass: HomeAssistant, config_entry: ConfigEntry) -> None:
     """Update options."""
     _LOGGER.debug("update_listener: Reloading %s", config_entry.entry_id)
-    await async_reload_entry(hass, config_entry)
+    await hass.config_entries.async_reload(config_entry.entry_id)
 
 
 async def async_migrate_entry(hass, config_entry: ConfigEntry):

custom_components/tplink_deco/api.py

@@ -212,6 +212,27 @@ async def async_reboot_decos(self, deco_macs) -> dict:
         check_data_error_code(context, data)
         _LOGGER.debug("Rebooted decos %s", deco_macs)
 
+    # Return performance data (CPU / memory)
+    async def async_get_performance(self) -> dict:
+        return await self._async_call_with_retry(self._async_get_performance)
+
+    async def _async_get_performance(self) -> dict:
+        await self.async_login_if_needed()
+
+        context = "Get Performance"
+        performance_payload = {"operation": "read"}
+
+        response_json = await self._async_post(
+            context,
+            f"{self._host}/cgi-bin/luci/;stok={self._stok}/admin/network",
+            params={"form": "performance"},
+            data=self._encode_payload(performance_payload),
+        )
+
+        data = self._decrypt_data(context, response_json["data"])
+        check_data_error_code(context, data)
+        return data
+
     # Return list of clients. Default lists clients for all decos.
     async def async_list_clients(self, deco_mac="default") -> dict:
         return await self._async_call_with_retry(self._async_list_clients, deco_mac)

custom_components/tplink_deco/config_flow.py

@@ -52,6 +52,10 @@ def _get_schema(data: dict[str:Any]):
         data = {}
     schema = _get_auth_schema(data)
     scan_interval = data.get(CONF_SCAN_INTERVAL, DEFAULT_SCAN_INTERVAL)
+
+    if scan_interval not in [10, 30, 60, 120]:
+        scan_interval = DEFAULT_SCAN_INTERVAL
+
     schema.update(
         {
             vol.Required(
@@ -60,7 +64,7 @@ def _get_schema(data: dict[str:Any]):
             vol.Required(
                 CONF_SCAN_INTERVAL,
                 default=scan_interval,
-            ): vol.All(vol.Coerce(int), vol.Range(min=1)),
+            ): vol.In([10, 30, 60, 120]),
             vol.Required(
                 CONF_CONSIDER_HOME,
                 default=data.get(CONF_CONSIDER_HOME, DEFAULT_CONSIDER_HOME),

custom_components/tplink_deco/const.py

@@ -53,4 +53,4 @@
 SERVICE_PAUSE_POLLING = "pause_polling"
 SERVICE_RESUME_POLLING = "resume_polling"
 # Platforms
-PLATFORMS = ["device_tracker", "sensor", "binary_sensor", "switch"]
+PLATFORMS = ["device_tracker", "sensor", "binary_sensor", "switch", "select"]

custom_components/tplink_deco/coordinator.py

@@ -74,6 +74,10 @@ def __init__(self, mac: str) -> None:
         self.signal_band5 = None
         self.backhaul_speed = None
         self.backhaul_max_speed = None
+        self.cpu_usage = None
+        self.cpu_usage_raw = None
+        self.mem_usage = None
+        self.mem_usage_raw = None
 
     def update(
         self,
@@ -187,6 +191,10 @@ async def _async_update_data(self):
             self.api.async_list_devices
         )
 
+        performance_data = await async_call_and_propagate_config_error(
+            self.api.async_get_performance
+        )
+
         old_decos = self.data.decos
         master_deco = None
         deco_added = False
@@ -203,6 +211,34 @@ async def _async_update_data(self):
             if deco.master:
                 master_deco = deco
 
+        # Zet globale performance data op de master Deco
+        result = performance_data.get("result", {})
+        if master_deco is not None:
+            cpu_raw = result.get("cpu_usage")
+            mem_raw = result.get("mem_usage")
+
+            if cpu_raw is not None:
+                cpu_percent = cpu_raw * 100
+                master_deco.cpu_usage_raw = round(cpu_percent, 1)
+
+                if master_deco.cpu_usage is not None:
+                    master_deco.cpu_usage = round(
+                        (master_deco.cpu_usage * 0.7) + (cpu_percent * 0.3), 1
+                    )
+                else:
+                    master_deco.cpu_usage = round(cpu_percent, 1)
+
+            if mem_raw is not None:
+                mem_percent = mem_raw * 100
+                master_deco.mem_usage_raw = round(mem_percent, 1)
+
+                if master_deco.mem_usage is not None:
+                    master_deco.mem_usage = round(
+                        (master_deco.mem_usage * 0.7) + (mem_percent * 0.3), 1
+                    )
+                else:
+                    master_deco.mem_usage = round(mem_percent, 1)
+
         if deco_added:
             async_dispatcher_send(self.hass, SIGNAL_DECO_ADDED)
 

custom_components/tplink_deco/select.py

@@ -0,0 +1,65 @@
+from homeassistant.components.device_tracker.const import CONF_SCAN_INTERVAL
+from homeassistant.components.select import SelectEntity
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity import DeviceInfo
+from homeassistant.helpers.entity_platform import AddEntitiesCallback
+
+from .const import COORDINATOR_DECOS_KEY
+from .const import DOMAIN
+from .device import create_device_info
+
+POLLING_INTERVAL_OPTIONS = ["10", "30", "60", "120"]
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: ConfigEntry,
+    async_add_entities: AddEntitiesCallback,
+):
+    """Set up select entities."""
+    coordinator = hass.data[DOMAIN][config_entry.entry_id][COORDINATOR_DECOS_KEY]
+    async_add_entities([DecoPollingIntervalSelect(hass, config_entry, coordinator)])
+
+
+class DecoPollingIntervalSelect(SelectEntity):
+    """Select entity to control Deco polling interval."""
+
+    _attr_has_entity_name = True
+    _attr_name = "Polling interval"
+    _attr_icon = "mdi:timer-cog"
+    _attr_options = POLLING_INTERVAL_OPTIONS
+
+    def __init__(self, hass: HomeAssistant, config_entry: ConfigEntry, coordinator):
+        self.hass = hass
+        self.config_entry = config_entry
+        self.coordinator = coordinator
+        self._attr_unique_id = f"{config_entry.entry_id}_polling_interval"
+
+    @property
+    def current_option(self) -> str:
+        """Return current polling interval as string."""
+        value = self.config_entry.data.get(CONF_SCAN_INTERVAL, 30)
+        return str(value)
+
+    @property
+    def device_info(self) -> DeviceInfo | None:
+        """Attach select to the master Deco device."""
+        master_deco = self.coordinator.data.master_deco
+        if master_deco is None:
+            return None
+        return create_device_info(master_deco, master_deco)
+
+    async def async_select_option(self, option: str) -> None:
+        """Change polling interval."""
+        new_value = int(option)
+
+        data = dict(self.config_entry.data)
+        data[CONF_SCAN_INTERVAL] = new_value
+
+        self.hass.config_entries.async_update_entry(
+            self.config_entry,
+            data=data,
+        )
+
+        await self.hass.config_entries.async_reload(self.config_entry.entry_id)

custom_components/tplink_deco/sensor.py

@@ -86,6 +86,42 @@ class TplinkDecoDiagnosticSensorDescription(SensorEntityDescription):
         native_unit_of_measurement=UnitOfDataRate.MEGABITS_PER_SECOND,
         value_fn=lambda deco: deco.backhaul_max_speed,
     ),
+    TplinkDecoDiagnosticSensorDescription(
+        key="cpu_usage",
+        name="CPU usage",
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
+        native_unit_of_measurement="%",
+        state_class=SensorStateClass.MEASUREMENT,
+        value_fn=lambda deco: deco.cpu_usage,
+    ),
+    TplinkDecoDiagnosticSensorDescription(
+        key="cpu_usage_raw",
+        name="CPU usage raw",
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
+        native_unit_of_measurement="%",
+        state_class=SensorStateClass.MEASUREMENT,
+        value_fn=lambda deco: deco.cpu_usage_raw,
+    ),
+    TplinkDecoDiagnosticSensorDescription(
+        key="mem_usage",
+        name="Memory usage",
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
+        native_unit_of_measurement="%",
+        state_class=SensorStateClass.MEASUREMENT,
+        value_fn=lambda deco: deco.mem_usage,
+    ),
+    TplinkDecoDiagnosticSensorDescription(
+        key="mem_usage_raw",
+        name="Memory usage raw",
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
+        native_unit_of_measurement="%",
+        state_class=SensorStateClass.MEASUREMENT,
+        value_fn=lambda deco: deco.mem_usage_raw,
+    ),
 )