Battery and utilisation stats not reported for node connecte to meshtastic-bot

[Nodeswitch]

Since the latest update, it looks like the utilization stats from the node connected to the bot aren't being reported after the initial start of the container. Examples below from pdyb and stnf, where you can see on pdyb they haven't reported for a while and you can see intermittent stats from stnf, where I've been restarting the container trying to trace back some errors I'm seeing in the logs.

It seems that mtek isn't impacted by this change, where they have a fork of the repo they're working from rather than running the code here directly.

[pskillen]

This will have been caused by #68

The issue is the meshtastic node reports local device metrics once per minute via the API (not via the mesh) but the python API doesn't have a way to distinguish these from the over the air 4-6 hourly metrics.

I had assumed the nodes would still spit out over the air device metrics packets and be heard by other nodes (just like unmanaged nodes) but apparently not.

Need to have a think about how to fix this, because the 1-packet-per-minute reporting was screwing up site wide stats

[Nodeswitch]

Might be worth having to bot connected nodes next to each other to see if they do report and submit the stats for each other. It might be the case that the nodes we have on the latest official firmware just aren't able to reach each other effectively to report on the stats.

Looking through the historical data, at least for myself, there was usually 20 - 30 minutes between the utilisation stats in the graph, which is fine honestly. Every 30 - 60 minutes wouldn't be an issue from my perspective if you were to enable with that kind of timing.

[Nodeswitch]

@pskillen you might know this, so please ignore if that's the case (I may have misinterpreted the issue you mentioned as affecting the bot-associated nodes only being impacted), but it looks like utilisation stats for all nodes aren't being updated on meshflow except from the initial posting data after the bot is started and sends over the data it has to the API for each node the radio is aware of (except for cases where meshtastic-bot instances aren't running the latest official version).

You should be able to test this by checking on a node on meshflow and noting the time the utilisation stats were updated, then restarting the bot on your side and checking back after a couple of minutes. You'll see the last updated time will have changed and it'll generally remain at that timestamp, so checking back in twenty minutes will show "Battery, voltage, channel utilisation — last reported 20 minutes ago", only updating when the bot is restarted.

[Nodeswitch]

One for when you're back at things, not expecting a response any time soon - just posting this while kiddo is having a rare lie in.

After some back and forth, I'm getting the following back relating to missing telemetry. Does this seem fair?

It was initially wanting to submit default 0 values if fields were empty, which I thought was naff, so now it should be set to only submit telemetry data if it actually receives something valid.

If all looks okay, I can test then together a PR for this if you want.

---

The Problem

In on_receive() for mesh telemetry packets (not from self):

Then later:

What's missing:

1. When a TELEMETRY_APP packet arrives from a mesh node, the raw packet is submitted ✓
2. BUT the node record itself is never updated with the extracted telemetry data ✗
3. The node's device_metrics (and any other telemetry fields) remain stale—whatever they were at initial discovery

Contrast with on_node_updated():

mesh_node = MeshNode.from_dict(node)  # ← Extracts telemetry
self.node_db.store_node(mesh_node)     # ← Stores locally
for storage_api in self.storage_apis:
    storage_api.store_node(mesh_node)  # ← **Re-submits node with telemetry to API**

This happens at startup, which is why you see telemetry once. But when telemetry packets arrive later, the node is never re-submitted.

Why Position & Last-Heard Work, But Telemetry Doesn't

• Position: Likely updated via on_node_updated() when the meshtastic library pushes position changes (triggered by GPS updates)
• Last-Heard: Updated at startup and possibly via the library's internal state
• Device Metrics & Other Telemetry: Only submitted as raw packets; the node record is never refreshed with new values

The Fix Needed

Extract telemetry from TELEMETRY_APP packets from mesh nodes, update the node record, and re-submit the node to the API via store_node(). This will ensure that telemetry changes are reflected in both local storage and the API, matching the pattern already established in on_node_updated().

---

It's suggesting adding the following to def on_receive in src/bot.py just before if sender == self.my_id:

        # For mesh telemetry packets carrying deviceMetrics, update the node record and
        # re-submit to API. meshtastic.node.updated only fires at startup (node_info
        # messages), not for over-the-air TELEMETRY_APP packets, so this must be done
        # explicitly. Other telemetry types (e.g. environmentMetrics) have no MeshNode
        # field and are already covered by store_raw_packet above.
        if (
            not skip_self_telemetry
            and portnum_key == "TELEMETRY_APP"
            and has_decoded
            and node is not None
            and isinstance(node, MeshNode)
        ):
            try:
                telemetry = packet.get("decoded", {}).get("telemetry") or {}
                device_metrics_data = telemetry.get("deviceMetrics")
                if device_metrics_data and isinstance(device_metrics_data, dict):
                    # Initialize device_metrics if missing
                    if not hasattr(node, "device_metrics") or node.device_metrics is None:
                        node.device_metrics = MeshNode.DeviceMetrics(
                            logged_time=datetime.now(timezone.utc)
                        )

                    # Update device metrics from telemetry packet
                    dm = node.device_metrics
                    dm.logged_time = datetime.now(timezone.utc)
                    if "batteryLevel" in device_metrics_data:
                        dm.battery_level = device_metrics_data["batteryLevel"]
                    if "voltage" in device_metrics_data:
                        dm.voltage = device_metrics_data["voltage"]
                    if "channelUtilization" in device_metrics_data:
                        dm.channel_utilization = device_metrics_data[
                            "channelUtilization"
                        ]
                    if "airUtilTx" in device_metrics_data:
                        dm.air_util_tx = device_metrics_data["airUtilTx"]
                    if "uptimeSeconds" in device_metrics_data:
                        dm.uptime_seconds = device_metrics_data["uptimeSeconds"]

                    # Store updated node locally and to API
                    self.node_db.store_node(node)
                    for storage_api in self.storage_apis:
                        try:
                            storage_api.store_node(node)
                        except HTTPError as ex:
                            logging.warning(
                                f"Error storing node telemetry to API: {ex.response.text}"
                            )
                        except Exception as ex:
                            logging.warning(f"Error storing node telemetry to API: {ex}")
            except (AttributeError, TypeError) as ex:
                logging.warning(
                    f"Error updating device metrics for node {sender}: {ex}"
                )