Merge pull request #60 from meshcore-dev/2.1.5

awolden · web-flow · commit 029b99dfcbeb · 2025-09-21T13:36:57.000-07:00
2.1.5
diff --git a/custom_components/meshcore/const.py b/custom_components/meshcore/const.py
@@ -56,7 +56,7 @@
 CONF_REPEATER_UPDATE_INTERVAL: Final = "update_interval"
 CONF_REPEATER_TELEMETRY_ENABLED: Final = "telemetry_enabled"
 DEFAULT_REPEATER_UPDATE_INTERVAL: Final = 900  # 15 minutes in seconds
-MAX_REPEATER_FAILURES_BEFORE_LOGIN: Final = 3  # After this many failures, try login
+MAX_REPEATER_FAILURES_BEFORE_LOGIN: Final = 5  # After this many failures, try login
 
 # Client tracking constants
 CONF_TRACKED_CLIENTS: Final = "tracked_clients"
@@ -77,8 +77,6 @@
 REPEATER_BACKOFF_BASE: Final = 2  # Base multiplier for exponential backoff
 REPEATER_BACKOFF_MAX_MULTIPLIER: Final = 120  # Maximum backoff multiplier (10 minutes when * 5 seconds)
 
-# Login refresh interval for telemetry-enabled repeaters
-REPEATER_LOGIN_REFRESH_INTERVAL: Final = 10800  # 3 hours in seconds
 
 # Generic battery voltage to percentage lookup table
 BATTERY_CURVE: Final = [
diff --git a/custom_components/meshcore/coordinator.py b/custom_components/meshcore/coordinator.py
@@ -13,6 +13,7 @@
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
 from meshcore.events import EventType
+from meshcore.packets import BinaryReqType
 
 from .const import (
     CONF_NAME,
@@ -35,7 +36,6 @@
     CONF_SELF_TELEMETRY_ENABLED,
     CONF_SELF_TELEMETRY_INTERVAL,
     DEFAULT_SELF_TELEMETRY_INTERVAL,
-    REPEATER_LOGIN_REFRESH_INTERVAL,
 )
 from .meshcore_api import MeshCoreAPI
 
@@ -173,19 +173,14 @@ async def _update_repeater(self, repeater_config):
             # Get the current failure count
             failure_count = self._repeater_consecutive_failures.get(pubkey_prefix, 0)
             
-            # Check if we need to login (initial login, periodic refresh, or after failures)
+            # Check if we need to login (initial login or after failures)
             last_login_time = self._repeater_login_times.get(pubkey_prefix)
-            current_time = self._current_time()
             needs_initial_login = last_login_time is None
-            needs_periodic_refresh = (last_login_time is not None and 
-                                    current_time - last_login_time >= REPEATER_LOGIN_REFRESH_INTERVAL)
             needs_failure_recovery = failure_count >= MAX_REPEATER_FAILURES_BEFORE_LOGIN
             
-            if needs_initial_login or needs_periodic_refresh or needs_failure_recovery:
+            if needs_initial_login or needs_failure_recovery:
                 if needs_initial_login:
                     self.logger.info(f"Attempting initial login to repeater {repeater_name}")
-                elif needs_periodic_refresh:
-                    self.logger.info(f"Attempting periodic login refresh to repeater {repeater_name} (last login: {last_login_time})")
                 else:
                     self.logger.info(f"Attempting login to repeater {repeater_name} after {failure_count} failures")
                 
@@ -211,7 +206,7 @@ async def _update_repeater(self, repeater_config):
             
             # Request status from the repeater
             self.logger.debug(f"Sending status request to repeater: {repeater_name} ({pubkey_prefix})")
-            await self.api.mesh_core.commands.send_statusreq(contact)
+            await self.api.mesh_core.commands.send_binary_req(contact, BinaryReqType.STATUS)
             result = await self.api.mesh_core.wait_for_event(
                 EventType.STATUS_RESPONSE,
                 attribute_filters={"pubkey_prefix": pubkey_prefix},
@@ -224,12 +219,23 @@ async def _update_repeater(self, repeater_config):
                 # Increment failure count and apply backoff
                 new_failure_count = failure_count + 1
                 self._repeater_consecutive_failures[pubkey_prefix] = new_failure_count
-                self._apply_repeater_backoff(pubkey_prefix, new_failure_count)
+                
+                # Reset path after 5 failures if there's an established path
+                if new_failure_count == 5 and contact and contact.get("out_path_len", 0) != -1:
+                    try:
+                        await self.api.mesh_core.commands.reset_path(pubkey_prefix)
+                        self.logger.info(f"Reset path for repeater {repeater_name} after 5 failures")
+                    except Exception as ex:
+                        self.logger.warning(f"Failed to reset path for repeater {repeater_name}: {ex}")
+                
+                update_interval = repeater_config.get(CONF_REPEATER_UPDATE_INTERVAL, DEFAULT_REPEATER_UPDATE_INTERVAL)
+                self._apply_repeater_backoff(pubkey_prefix, new_failure_count, update_interval)
             elif result.payload.get('uptime', 0) == 0:
                 self.logger.warn(f"Malformed status response from repeater {repeater_name}: {result.payload}")
                 new_failure_count = failure_count + 1
                 self._repeater_consecutive_failures[pubkey_prefix] = new_failure_count
-                self._apply_repeater_backoff(pubkey_prefix, new_failure_count)
+                update_interval = repeater_config.get(CONF_REPEATER_UPDATE_INTERVAL, DEFAULT_REPEATER_UPDATE_INTERVAL)
+                self._apply_repeater_backoff(pubkey_prefix, new_failure_count, update_interval)
             else:
                 self.logger.debug(f"Successfully updated repeater {repeater_name}")
                 # Reset failure count on success
@@ -248,23 +254,23 @@ async def _update_repeater(self, repeater_config):
             # Increment failure count and apply backoff
             new_failure_count = self._repeater_consecutive_failures.get(pubkey_prefix, 0) + 1
             self._repeater_consecutive_failures[pubkey_prefix] = new_failure_count
-            self._apply_repeater_backoff(pubkey_prefix, new_failure_count)
+            update_interval = repeater_config.get(CONF_REPEATER_UPDATE_INTERVAL, DEFAULT_REPEATER_UPDATE_INTERVAL)
+            self._apply_repeater_backoff(pubkey_prefix, new_failure_count, update_interval)
         finally:
             # Remove this task from active tasks
             if pubkey_prefix in self._active_repeater_tasks:
                 self._active_repeater_tasks.pop(pubkey_prefix)
 
-    def _apply_backoff(self, pubkey_prefix: str, failure_count: int, update_type: str = "repeater") -> None:
+    def _apply_backoff(self, pubkey_prefix: str, failure_count: int, update_interval: int, update_type: str = "repeater") -> None:
         """Apply exponential backoff delay for failed updates.
         
-        Uses DEFAULT_UPDATE_TICK as base since that's how often we check for updates.
-        
         Args:
             pubkey_prefix: The node's public key prefix
             failure_count: Number of consecutive failures
+            update_interval: The configured update interval to cap the backoff at
             update_type: Type of update ("repeater" or "telemetry")
         """
-        backoff_delay = min(REPEATER_BACKOFF_BASE ** failure_count, REPEATER_BACKOFF_MAX_MULTIPLIER)
+        backoff_delay = min(REPEATER_BACKOFF_BASE ** failure_count, update_interval)
         next_update_time = self._current_time() + backoff_delay
         
         if update_type == "telemetry":
@@ -274,11 +280,12 @@ def _apply_backoff(self, pubkey_prefix: str, failure_count: int, update_type: st
         
         self.logger.debug(f"Applied backoff for {update_type} {pubkey_prefix}: "
                          f"failure_count={failure_count}, "
-                         f"delay={backoff_delay}s")
+                         f"delay={backoff_delay}s, "
+                         f"interval_cap={update_interval}s")
 
-    def _apply_repeater_backoff(self, pubkey_prefix: str, failure_count: int) -> None:
+    def _apply_repeater_backoff(self, pubkey_prefix: str, failure_count: int, update_interval: int) -> None:
         """Apply exponential backoff delay for failed repeater updates."""
-        self._apply_backoff(pubkey_prefix, failure_count, "repeater")
+        self._apply_backoff(pubkey_prefix, failure_count, update_interval, "repeater")
 
     async def _update_node_telemetry(self, contact, pubkey_prefix: str, node_name: str, update_interval: int):
         """Update telemetry for a node (repeater or client).
@@ -296,7 +303,7 @@ async def _update_node_telemetry(self, contact, pubkey_prefix: str, node_name: s
         
         try:
             self.logger.debug(f"Sending telemetry request to node: {node_name} ({pubkey_prefix})")
-            await self.api.mesh_core.commands.send_telemetry_req(contact)
+            await self.api.mesh_core.commands.send_binary_req(contact, BinaryReqType.TELEMETRY)
             telemetry_result = await self.api.mesh_core.wait_for_event(
                 EventType.TELEMETRY_RESPONSE,
                 attribute_filters={"pubkey_prefix": pubkey_prefix},
@@ -314,14 +321,32 @@ async def _update_node_telemetry(self, contact, pubkey_prefix: str, node_name: s
                 # Increment failure count and apply backoff
                 new_failure_count = failure_count + 1
                 self._telemetry_consecutive_failures[pubkey_prefix] = new_failure_count
-                self._apply_backoff(pubkey_prefix, new_failure_count, "telemetry")
+                
+                # Reset path after 5 failures if there's an established path
+                if new_failure_count == 5 and contact and contact.get("out_path_len", 0) != -1:
+                    try:
+                        await self.api.mesh_core.commands.reset_path(pubkey_prefix)
+                        self.logger.info(f"Reset path for node {node_name} after 5 telemetry failures")
+                    except Exception as ex:
+                        self.logger.warning(f"Failed to reset path for node {node_name}: {ex}")
+                
+                self._apply_backoff(pubkey_prefix, new_failure_count, update_interval, "telemetry")
                 
         except Exception as ex:
             self.logger.warn(f"Exception requesting telemetry from node {node_name}: {ex}")
             # Increment failure count and apply backoff
             new_failure_count = failure_count + 1
             self._telemetry_consecutive_failures[pubkey_prefix] = new_failure_count
-            self._apply_backoff(pubkey_prefix, new_failure_count, "telemetry")
+            
+            # Reset path after 5 failures if there's an established path
+            if new_failure_count == 5 and contact and contact.get("out_path_len", 0) != -1:
+                try:
+                    await self.api.mesh_core.commands.reset_path(pubkey_prefix)
+                    self.logger.info(f"Reset path for node {node_name} after 5 telemetry failures")
+                except Exception as reset_ex:
+                    self.logger.warning(f"Failed to reset path for node {node_name}: {reset_ex}")
+            
+            self._apply_backoff(pubkey_prefix, new_failure_count, update_interval, "telemetry")
         finally:
             # Remove this task from active telemetry tasks
             if pubkey_prefix in self._active_telemetry_tasks:
diff --git a/custom_components/meshcore/device_tracker.py b/custom_components/meshcore/device_tracker.py
@@ -54,8 +54,8 @@ async def _handle_gps_telemetry_event(self, event: Event):
         if not event.payload or "lpp" not in event.payload:
             _LOGGER.debug("No LPP data in telemetry event")
             return
-            
-        pubkey_prefix = event.payload.get("pubkey_pre", "")
+
+        pubkey_prefix = event.payload.get("pubkey_prefix", "")
         lpp_data = event.payload.get("lpp", [])
         
         # If no pubkey_prefix, this might be self telemetry
diff --git a/custom_components/meshcore/manifest.json b/custom_components/meshcore/manifest.json
@@ -5,8 +5,8 @@
   "dependencies": ["logbook"],
   "codeowners": ["@awolden"],
   "loggers": ["custom_components.meshcore"],
-  "requirements": ["meshcore>=2.1.6", "meshcore-cli>=0.0.0"],
+  "requirements": ["meshcore>=2.1.7", "meshcore-cli>=0.0.0"],
   "iot_class": "local_polling",
-  "version": "2.1.4",
+  "version": "2.1.5",
   "config_flow": true
 }
diff --git a/custom_components/meshcore/sensor.py b/custom_components/meshcore/sensor.py
@@ -28,6 +28,7 @@
     DOMAIN,
     ENTITY_DOMAIN_SENSOR,
     CONF_REPEATER_SUBSCRIPTIONS,
+    CONF_TRACKED_CLIENTS,
     NodeType,
 )
 from .utils import get_node_type_str
@@ -44,6 +45,23 @@
 UTILIZATION_SUFFIX = "_utilization"
 RATE_SUFFIX = "_rate"
 
+# Path tracking sensors for repeaters and clients
+PATH_SENSORS = [
+    SensorEntityDescription(
+        key="out_path",
+        name="Routing Path",
+        icon="mdi:map-marker-path",
+        native_unit_of_measurement=None,
+    ),
+    SensorEntityDescription(
+        key="out_path_len",
+        name="Path Length",
+        icon="mdi:counter",
+        native_unit_of_measurement="hops",
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+]
+
 
 # Define sensors for the main device
 SENSORS = [
@@ -437,6 +455,38 @@ async def async_setup_entry(
                     entities.append(sensor)
                 except Exception as ex:
                     _LOGGER.error(f"Error creating repeater sensor {description.key}: {ex}")
+            
+            # Add path tracking sensors for this repeater
+            for path_description in PATH_SENSORS:
+                try:
+                    sensor = MeshCorePathSensor(
+                        coordinator,
+                        path_description,
+                        repeater,
+                        "repeater"
+                    )
+                    entities.append(sensor)
+                except Exception as ex:
+                    _LOGGER.error(f"Error creating path sensor {path_description.key} for repeater: {ex}")
+
+    # Add path sensors for tracked clients
+    client_subscriptions = entry.data.get(CONF_TRACKED_CLIENTS, [])
+    if client_subscriptions:
+        for client in client_subscriptions:
+            _LOGGER.info(f"Creating path sensors for client: {client.get('name')} ({client.get('pubkey_prefix')})")
+            
+            # Add path tracking sensors for this client
+            for path_description in PATH_SENSORS:
+                try:
+                    sensor = MeshCorePathSensor(
+                        coordinator,
+                        path_description,
+                        client,
+                        "client"
+                    )
+                    entities.append(sensor)
+                except Exception as ex:
+                    _LOGGER.error(f"Error creating path sensor {path_description.key} for client: {ex}")
     
     async_add_entities(entities)
 
@@ -576,6 +626,101 @@ def device_info(self):
     def native_value(self) -> Any:
         return self._native_value
 
+class MeshCorePathSensor(CoordinatorEntity, SensorEntity):
+    """Sensor for tracking node routing path with CONTACTS event updates."""
+    
+    def __init__(
+        self,
+        coordinator: DataUpdateCoordinator,
+        description: SensorEntityDescription,
+        node_config: dict,
+        node_type: str,
+    ) -> None:
+        """Initialize the path tracking sensor."""
+        super().__init__(coordinator)
+        self.entity_description = description
+        self.node_name = node_config.get("name", "Unknown")
+        self.node_type = node_type
+
+        # Use the provided pubkey_prefix
+        self.pubkey_prefix = node_config.get("pubkey_prefix", "")
+        self.public_key_short = self.pubkey_prefix[:6] if self.pubkey_prefix else ""
+
+        # Generate a unique device_id for this node using pubkey_prefix
+        self.device_id = f"{coordinator.config_entry.entry_id}_{node_type}_{self.pubkey_prefix}"
+
+        # Set friendly name
+        self._attr_name = description.name
+
+        # Build device name with pubkey
+        device_name = f"MeshCore {node_type.title()}: {self.node_name} ({self.public_key_short})"
+        
+        # Set unique ID
+        self._attr_unique_id = f"{self.device_id}_{description.key}_{self.public_key_short}_{self.node_name}"
+        
+        # Set entity ID
+        self.entity_id = format_entity_id(
+            ENTITY_DOMAIN_SENSOR,
+            self.pubkey_prefix[:10],
+            description.key,
+            self.node_name
+        )
+
+        # Set device info to create a separate device for this node
+        device_info = {
+            "identifiers": {(DOMAIN, self.device_id)},
+            "name": device_name,
+            "manufacturer": "MeshCore",
+            "model": f"Mesh {node_type.title()}",
+            "via_device": (DOMAIN, coordinator.config_entry.entry_id),  # Link to the main device
+        }
+            
+        self._attr_device_info = DeviceInfo(**device_info)
+        self._native_value = None
+        
+    async def async_added_to_hass(self):
+        """Register event handlers when entity is added to hass."""
+        await super().async_added_to_hass()
+        
+        # Only set up listener if MeshCore instance is available
+        if not self.coordinator.api.mesh_core:
+            _LOGGER.warning(f"No MeshCore instance available for path tracking: {self.node_name}")
+            return
+            
+        # Only set up if we have a pubkey_prefix
+        if not self.pubkey_prefix:
+            _LOGGER.warning(f"No pubkey_prefix available for node {self.node_name}, can't track path")
+            return
+
+        meshcore = self.coordinator.api.mesh_core
+        
+        def handle_contacts_event(event: Event):
+            """Handle CONTACTS event to update path information."""
+            if event.type != EventType.CONTACTS:
+                return
+                
+            # Find our contact using the helper method
+            contact = meshcore.get_contact_by_key_prefix(self.pubkey_prefix)
+            if contact:
+                # Update the sensor based on the description key
+                if self.entity_description.key == "out_path":
+                    self._native_value = contact.get("out_path", "")
+                elif self.entity_description.key == "out_path_len":
+                    path_len = contact.get("out_path_len", -1)
+                    self._native_value = path_len if path_len != -1 else None
+        
+        # Subscribe to CONTACTS events
+        meshcore.dispatcher.subscribe(
+            EventType.CONTACTS,
+            handle_contacts_event
+        )
+        
+        _LOGGER.debug(f"Set up path tracking for {self.node_type} {self.node_name} ({self.pubkey_prefix})")
+
+    @property
+    def native_value(self) -> Any:
+        return self._native_value
+
 class MeshCoreRepeaterSensor(CoordinatorEntity, SensorEntity):
     """Sensor for repeater statistics with event-based updates."""
     
diff --git a/custom_components/meshcore/telemetry_sensor.py b/custom_components/meshcore/telemetry_sensor.py
@@ -159,7 +159,7 @@ async def _handle_telemetry_event(self, event: Event):
             _LOGGER.debug("No LPP data in telemetry event")
             return
             
-        pubkey_prefix = event.payload.get("pubkey_pre", "")
+        pubkey_prefix = event.payload.get("pubkey_prefix", "")
         lpp_data = event.payload.get("lpp", [])
         
         # If no pubkey_prefix, this might be self telemetry
diff --git a/docs/docs/remote-device-tracking.md b/docs/docs/remote-device-tracking.md
diff --git a/docs/docs/sensors.md b/docs/docs/sensors.md
