improved integration with telem viz

ground/src/telemetry.rs

@@ -4,7 +4,7 @@ use futures::TryFutureExt;
 use futures::future::join_all;
 use log::{error, trace};
 use nautilus_common::on_drop::on_drop;
-use nautilus_common::telemetry::{SwitchBank, Telemetry, TelemetryMessage};
+use nautilus_common::telemetry::{CommsState, SwitchBank, Telemetry, TelemetryMessage};
 use nautilus_common::udp::UdpRecvPostcardError;
 use nautilus_common::udp::tokio::AsyncUdpSocketExt;
 use std::net::SocketAddr;
@@ -12,7 +12,7 @@ use std::sync::Arc;
 use tokio::net::UdpSocket;
 use tokio::sync::{RwLock, RwLockWriteGuard};
 use tokio::task::yield_now;
-use tokio::{join, pin, select};
+use tokio::{join, pin, select, try_join};
 use tokio_util::sync::CancellationToken;
 
 pub struct TelemetryHandler<'a> {
@@ -61,7 +61,7 @@ impl<'a> TelemetryHandler<'a> {
                     () = self.cancel.cancelled() => {},
                     incoming = self.udp.recv_postcard::<Telemetry>(&mut buffer) => {
                         match incoming {
-                            Ok((tlm, addr)) => {
+                            Ok((tlm, addr, _)) => {
                                 trace!("{tlm:?}");
 
                                 let flight_addr_update = async {
@@ -107,16 +107,38 @@ impl<'a> TelemetryHandler<'a> {
 struct TelemetryContext {
     bank_a: Vec<TelemetryHandle<bool>>,
     bank_b: Vec<TelemetryHandle<bool>>,
+    tx_packets: TelemetryHandle<u32>,
+    rx_packets: TelemetryHandle<u32>,
+    tx_bytes: TelemetryHandle<u32>,
+    rx_bytes: TelemetryHandle<u32>,
+    tx_errors: TelemetryHandle<u32>,
+    rx_errors: TelemetryHandle<u32>,
 }
 
 impl TelemetryContext {
     async fn new(tlm: &TelemetryHandler<'_>) -> Self {
         let bank_a =
-            join_all((0..16).map(|i| tlm.tlm.register::<bool>(format!("switch.bank_a.{i}")))).await;
+            join_all((0..16).map(|i| tlm.tlm.register(format!("switch.bank_a.{i}")))).await;
         let bank_b =
-            join_all((0..16).map(|i| tlm.tlm.register::<bool>(format!("switch.bank_b.{i}")))).await;
+            join_all((0..16).map(|i| tlm.tlm.register(format!("switch.bank_b.{i}")))).await;
 
-        Self { bank_a, bank_b }
+        let tx_packets = tlm.tlm.register("comms.tx_packets").await;
+        let rx_packets = tlm.tlm.register("comms.rx_packets").await;
+        let tx_bytes = tlm.tlm.register("comms.tx_bytes").await;
+        let rx_bytes = tlm.tlm.register("comms.rx_bytes").await;
+        let tx_errors = tlm.tlm.register("comms.tx_errors").await;
+        let rx_errors = tlm.tlm.register("comms.rx_errors").await;
+
+        Self {
+            bank_a,
+            bank_b,
+            tx_packets,
+            rx_packets,
+            tx_bytes,
+            rx_bytes,
+            tx_errors,
+            rx_errors,
+        }
     }
 
     async fn step(&mut self, tlm: Telemetry) {
@@ -137,6 +159,25 @@ impl TelemetryContext {
                 }))
                 .await;
             }
+            TelemetryMessage::CommsState(CommsState {
+                tx_packets,
+                rx_packets,
+                tx_bytes,
+                rx_bytes,
+                tx_errors,
+                rx_errors,
+            }) => {
+                if let Err(e) = try_join!(
+                    self.tx_packets.publish(tx_packets, tlm.timestamp),
+                    self.rx_packets.publish(rx_packets, tlm.timestamp),
+                    self.tx_bytes.publish(tx_bytes, tlm.timestamp),
+                    self.rx_bytes.publish(rx_bytes, tlm.timestamp),
+                    self.tx_errors.publish(tx_errors, tlm.timestamp),
+                    self.rx_errors.publish(rx_errors, tlm.timestamp),
+                ) {
+                    error!("Failed to publish comms telemetry: {e}");
+                }
+            }
         }
     }
 }