marilib-pkg 0.6.0__py3-none-any.whl → 0.7.0rc1__py3-none-any.whl

marilib/model.py

@@ -5,7 +5,7 @@ from datetime import datetime, timedelta
 from enum import IntEnum
 import rich
 
-from marilib.mari_protocol import Frame
+from marilib.mari_protocol import Frame, MetricsProbePayload
 from marilib.protocol import Packet, PacketFieldMetadata
 
 # schedules taken from: https://github.com/DotBots/mari-evaluation/blob/main/simulations/radio-schedule.ipynb
@@ -52,6 +52,10 @@ EMPTY_SCHEDULE_DATA = {
 MARI_TIMEOUT_NODE_IS_ALIVE = 3  # seconds
 MARI_TIMEOUT_GATEWAY_IS_ALIVE = 3  # seconds
 
+# MARI_PROBE_STATS_EPOCH_DURATION_ASN = 565 * 20 # about 10 seconds
+MARI_PROBE_STATS_EPOCH_DURATION_ASN = 565 * 60  # about 30 seconds
+# MARI_PROBE_STATS_EPOCH_DURATION_ASN = 565 * 2 # about 1 second
+
 
 @dataclass
 class TestState:
@@ -117,12 +121,12 @@ class NodeStatsReply(Packet):
 class FrameLogEntry:
     frame: Frame
     ts: datetime = field(default_factory=lambda: datetime.now())
-    is_test_packet: bool = False
 
 
 @dataclass
-class LatencyStats:
+class MetricsStats:
     latencies: deque = field(default_factory=lambda: deque(maxlen=50))
+    # TODO: Add PDR stats
 
     def add_latency(self, rtt_seconds: float):
         self.latencies.append(rtt_seconds * 1000)
@@ -143,6 +147,8 @@ class LatencyStats:
     def max_ms(self) -> float:
         return max(self.latencies) if self.latencies else 0.0
 
+    # TODO: Add PDR stats
+
 
 @dataclass
 class FrameStats:
@@ -154,40 +160,49 @@ class FrameStats:
     cumulative_sent_non_test: int = 0
     cumulative_received_non_test: int = 0
 
-    def add_sent(self, frame: Frame, is_test_packet: bool):
+    def add_sent(self, frame: Frame):
         """Adds a sent frame, prunes old entries, and updates counters."""
         self.cumulative_sent += 1
+        if not frame.is_test_packet:
+            self.cumulative_sent_non_test += 1  # NOTE: do we need this?
 
-        if not is_test_packet:
-            self.cumulative_sent_non_test += 1
+        entry = FrameLogEntry(frame=frame)
+        self.sent.append(entry)
 
-            entry = FrameLogEntry(frame=frame, is_test_packet=is_test_packet)
-            self.sent.append(entry)
-            while self.sent and (entry.ts - self.sent[0].ts).total_seconds() > self.window_seconds:
-                self.sent.popleft()
+        # remove old entries
+        while self.sent and (entry.ts - self.sent[0].ts).total_seconds() > self.window_seconds:
+            self.sent.popleft()
 
-    def add_received(self, frame: Frame, is_test_packet: bool):
+    def add_received(self, frame: Frame):
         """Adds a received frame and prunes old entries."""
         self.cumulative_received += 1
+        if not frame.is_test_packet:
+            self.cumulative_received_non_test += 1  # NOTE: do we need this?
+
+        entry = FrameLogEntry(frame=frame)
+        self.received.append(entry)
 
-        if not is_test_packet:
-            self.cumulative_received_non_test += 1
-            entry = FrameLogEntry(frame=frame, is_test_packet=is_test_packet)
-            self.received.append(entry)
-            while (
-                self.received
-                and (entry.ts - self.received[0].ts).total_seconds() > self.window_seconds
-            ):
-                self.received.popleft()
+        # remove old entries
+        while (
+            self.received and (entry.ts - self.received[0].ts).total_seconds() > self.window_seconds
+        ):
+            self.received.popleft()
 
     def sent_count(self, window_secs: int = 0, include_test_packets: bool = True) -> int:
         if window_secs == 0:
             return self.cumulative_sent if include_test_packets else self.cumulative_sent_non_test
 
         now = datetime.now()
-        # Windowed count is always for non-test packets.
-        entries = [e for e in self.sent if now - e.ts < timedelta(seconds=window_secs)]
-        return len(entries)
+        if include_test_packets:
+            return len([e for e in self.sent if now - e.ts < timedelta(seconds=window_secs)])
+        else:
+            return len(
+                [
+                    e
+                    for e in self.sent
+                    if now - e.ts < timedelta(seconds=window_secs) and not e.frame.is_test_packet
+                ]
+            )
 
     def received_count(self, window_secs: int = 0, include_test_packets: bool = True) -> int:
         if window_secs == 0:
@@ -198,14 +213,21 @@ class FrameStats:
             )
 
         now = datetime.now()
-        entries = [e for e in self.received if now - e.ts < timedelta(seconds=window_secs)]
+        if include_test_packets:
+            entries = [e for e in self.received if now - e.ts < timedelta(seconds=window_secs)]
+        else:
+            entries = [
+                e
+                for e in self.received
+                if now - e.ts < timedelta(seconds=window_secs) and not e.frame.is_test_packet
+            ]
         return len(entries)
 
     def success_rate(self, window_secs: int = 0) -> float:
-        s = self.sent_count(window_secs, include_test_packets=False)
+        s = self.sent_count(window_secs, include_test_packets=True)
         if s == 0:
             return 1.0
-        r = self.received_count(window_secs, include_test_packets=False)
+        r = self.received_count(window_secs, include_test_packets=True)
         return min(r / s, 1.0)
 
     def received_rssi_dbm(self, window_secs: int = 0) -> float:
@@ -228,22 +250,111 @@ class MariNode:
     address: int
     gateway_address: int
     last_seen: datetime = field(default_factory=lambda: datetime.now())
+    probe_stats: deque[MetricsProbePayload] = field(
+        default_factory=lambda: deque(maxlen=15)
+    )  # NOTE: related to frequency of probe stats
     stats: FrameStats = field(default_factory=FrameStats)
-    latency_stats: LatencyStats = field(default_factory=LatencyStats)
+    metrics_stats: MetricsStats = field(default_factory=MetricsStats)
     last_reported_rx_count: int = 0
     last_reported_tx_count: int = 0
     pdr_downlink: float = 0.0
     pdr_uplink: float = 0.0
+    probe_tx_count: int = 0
+    probe_rx_count: int = 0
 
     @property
     def is_alive(self) -> bool:
         return datetime.now() - self.last_seen < timedelta(seconds=MARI_TIMEOUT_NODE_IS_ALIVE)
 
-    def register_received_frame(self, frame: Frame, is_test_packet: bool):
-        self.stats.add_received(frame, is_test_packet)
+    def save_probe_stats(self, probe_stats: MetricsProbePayload):
+        # save the current probe stats
+        self.probe_stats.append(probe_stats)
+
+    @property
+    def probe_stats_latest(self) -> MetricsProbePayload | None:
+        if not self.probe_stats:
+            return None
+        return self.probe_stats[-1]
+
+    @property
+    def probe_stats_start_epoch(self) -> MetricsProbePayload | None:
+        if len(self.probe_stats) < 2:
+            return None
+        return self.probe_stats[0]
+
+    def probe_increment_tx_count(self) -> int:
+        self.probe_tx_count += 1
+        return self.probe_tx_count
+
+    def probe_increment_rx_count(self) -> int:
+        self.probe_rx_count += 1
+        return self.probe_rx_count
+
+    def stats_pdr_downlink_radio(self) -> float:
+        if not self.probe_stats_latest:
+            return 0
+        return self.probe_stats_latest.pdr_downlink_radio(self.probe_stats_start_epoch)
 
-    def register_sent_frame(self, frame: Frame, is_test_packet: bool):
-        self.stats.add_sent(frame, is_test_packet)
+    def stats_pdr_uplink_radio(self) -> float:
+        if not self.probe_stats_latest:
+            return 0
+        return self.probe_stats_latest.pdr_uplink_radio(self.probe_stats_start_epoch)
+
+    def stats_pdr_uplink_uart(self) -> float:
+        if not self.probe_stats_latest:
+            return 0
+        return self.probe_stats_latest.pdr_uplink_uart(self.probe_stats_start_epoch)
+
+    def stats_pdr_downlink_uart(self) -> float:
+        if not self.probe_stats_latest:
+            return 0
+        return self.probe_stats_latest.pdr_downlink_uart(self.probe_stats_start_epoch)
+
+    def stats_rssi_node_dbm(self) -> float:
+        if not self.probe_stats_latest:
+            return None
+        return self.probe_stats_latest.rssi_at_node_dbm()
+
+    def stats_rssi_gw_dbm(self) -> float:
+        if not self.probe_stats_latest:
+            return None
+        return self.probe_stats_latest.rssi_at_gw_dbm()
+
+    def stats_avg_latency_roundtrip_node_edge_ms(self) -> float:
+        """Average latency between node and edge in milliseconds"""
+        # compute average latency between node and edge, using all probe stats
+        if not self.probe_stats:
+            return 0
+        return sum(p.latency_roundtrip_node_edge_ms() for p in self.probe_stats) / len(
+            self.probe_stats
+        )
+
+    def stats_avg_latency_roundtrip_node_cloud_ms(self) -> float:
+        """Average latency between node and cloud in milliseconds"""
+        if not self.probe_stats:
+            return 0
+        return sum(p.latency_roundtrip_node_cloud_ms() for p in self.probe_stats) / len(
+            self.probe_stats
+        )
+
+    def stats_latest_latency_roundtrip_node_edge_ms(self) -> float:
+        """Last latency between node and edge in milliseconds"""
+        # compute average latency between node and edge, using all probe stats
+        if not self.probe_stats:
+            return 0
+        return self.probe_stats_latest.latency_roundtrip_node_edge_ms()
+
+    def stats_latest_latency_roundtrip_node_cloud_ms(self) -> float:
+        """Last latency between node and cloud in milliseconds"""
+        if not self.probe_stats:
+            return 0
+        return self.probe_stats_latest.latency_roundtrip_node_cloud_ms()
+
+    def register_received_frame(self, frame: Frame):
+        self.stats.add_received(frame)
+
+    def register_sent_frame(self, frame: Frame):
+        self.stats.add_sent(frame)
 
     def as_node_info_cloud(self) -> NodeInfoCloud:
         return NodeInfoCloud(address=self.address, gateway_address=self.gateway_address)
@@ -257,12 +368,16 @@ class GatewayInfo(Packet):
             PacketFieldMetadata(name="network_id", length=2),
             PacketFieldMetadata(name="schedule_id", length=1),
             PacketFieldMetadata(name="schedule_stats", length=4 * 8),  # 4 uint64_t values
+            PacketFieldMetadata(name="asn", length=8),
+            PacketFieldMetadata(name="timer", length=4),
         ]
     )
     address: int = 0
     network_id: int = 0
     schedule_id: int = 0
     schedule_stats: bytes = b""
+    asn: int = 0
+    timer: int = 0
 
     # NOTE: maybe move to a separate class, dedicated to schedule stuff
     def repr_schedule_stats(self):
@@ -298,7 +413,7 @@ class GatewayInfo(Packet):
             )
         elif cell == "U":
             return rich.text.Text(
-                " ", style=f'bold white on {"yellow" if is_used else "light_yellow3"}'
+                "U", style=f'bold white on {"yellow" if is_used else "light_yellow3"}'
             )
 
     def repr_schedule_cells_with_colors(self):
@@ -316,6 +431,10 @@ class GatewayInfo(Packet):
         schedule_data = SCHEDULES.get(self.schedule_id)
         return schedule_data["name"] if schedule_data else "unknown"
 
+    @property
+    def max_nodes(self) -> int:
+        return SCHEDULES.get(self.schedule_id, EMPTY_SCHEDULE_DATA)["max_nodes"]
+
     @property
     def network_id_str(self) -> str:
         return f"{self.network_id:04X}"
@@ -334,7 +453,7 @@ class MariGateway:
     info: GatewayInfo = field(default_factory=GatewayInfo)
     node_registry: dict[int, MariNode] = field(default_factory=dict)
     stats: FrameStats = field(default_factory=FrameStats)
-    latency_stats: LatencyStats = field(default_factory=LatencyStats)
+    metrics_stats: MetricsStats = field(default_factory=MetricsStats)
     last_seen: datetime = field(default_factory=lambda: datetime.now())
 
     def __post_init__(self):
@@ -352,6 +471,70 @@ class MariGateway:
     def is_alive(self) -> bool:
         return datetime.now() - self.last_seen < timedelta(seconds=MARI_TIMEOUT_GATEWAY_IS_ALIVE)
 
+    def stats_avg_pdr_downlink_radio(self) -> float:
+        if not self.nodes:
+            return 0.0
+        res = sum(n.stats_pdr_downlink_radio() for n in self.nodes) / len(self.nodes)
+        return res if res >= 0 and res <= 1.0 else 0.0
+
+    def stats_avg_pdr_uplink_radio(self) -> float:
+        if not self.nodes:
+            return 0.0
+        res = sum(n.stats_pdr_uplink_radio() for n in self.nodes) / len(self.nodes)
+        return res if res >= 0 and res <= 1.0 else 0.0
+
+    def stats_avg_pdr_downlink_uart(self) -> float:
+        if not self.nodes:
+            return 0.0
+        res = sum(n.stats_pdr_downlink_uart() for n in self.nodes) / len(self.nodes)
+        return res if res >= 0 and res <= 1.0 else 0.0
+
+    def stats_avg_pdr_uplink_uart(self) -> float:
+        if not self.nodes:
+            return 0.0
+        res = sum(n.stats_pdr_uplink_uart() for n in self.nodes) / len(self.nodes)
+        return res if res >= 0 and res <= 1.0 else 0.0
+
+    def stats_avg_latency_roundtrip_node_edge_ms(self) -> float:
+        if not self.nodes:
+            return 0.0
+        res = sum(n.stats_avg_latency_roundtrip_node_edge_ms() for n in self.nodes) / len(
+            self.nodes
+        )
+        return res if res >= 0 else 0.0
+
+    def stats_avg_latency_roundtrip_node_cloud_ms(self) -> float:
+        if not self.nodes:
+            return 0.0
+        res = sum(n.stats_avg_latency_roundtrip_node_cloud_ms() for n in self.nodes) / len(
+            self.nodes
+        )
+        return res if res >= 0 else 0.0
+
+    def stats_latest_node_tx_count(self) -> int:
+        """Returns sum of tx counts for all nodes"""
+        if not self.nodes:
+            return 0
+        return sum(n.probe_stats_latest.node_tx_count for n in self.nodes if n.probe_stats_latest)
+
+    def stats_latest_node_rx_count(self) -> int:
+        """Returns sum of rx counts for all nodes"""
+        if not self.nodes:
+            return 0
+        return sum(n.probe_stats_latest.node_rx_count for n in self.nodes if n.probe_stats_latest)
+
+    def stats_latest_gw_tx_count(self) -> int:
+        """Returns sum of tx counts for all nodes"""
+        if not self.nodes:
+            return 0
+        return sum(n.probe_stats_latest.gw_tx_count for n in self.nodes if n.probe_stats_latest)
+
+    def stats_latest_gw_rx_count(self) -> int:
+        """Returns sum of rx counts for all nodes"""
+        if not self.nodes:
+            return 0
+        return sum(n.probe_stats_latest.gw_rx_count for n in self.nodes if n.probe_stats_latest)
+
     def update(self):
         """Recurrent bookkeeping. Don't forget to call this periodically on your main loop."""
         self.node_registry = {
@@ -384,10 +567,10 @@ class MariGateway:
             node = self.add_node(addr)
         return node
 
-    def register_received_frame(self, frame: Frame, is_test_packet: bool):
+    def register_received_frame(self, frame: Frame):
         if n := self.get_node(frame.header.source):
-            n.register_received_frame(frame, is_test_packet)
-        self.stats.add_received(frame, is_test_packet)
+            n.register_received_frame(frame)
+        self.stats.add_received(frame)
 
-    def register_sent_frame(self, frame: Frame, is_test_packet: bool):
-        self.stats.add_sent(frame, is_test_packet)
+    def register_sent_frame(self, frame: Frame):
+        self.stats.add_sent(frame)

marilib/pdr.py

@@ -0,0 +1,99 @@
+import threading
+from typing import TYPE_CHECKING
+from rich import print
+
+from marilib.model import NodeStatsReply
+from marilib.mari_protocol import Frame
+from marilib.protocol import ProtocolPayloadParserException
+
+
+if TYPE_CHECKING:
+    from marilib.marilib_edge import MarilibEdge
+
+
+PDR_STATS_REQUEST_PAYLOAD = b"S"
+
+
+class PDRTester:
+    """A thread-based class to periodically test PDR to all nodes."""
+
+    def __init__(self, marilib: "MarilibEdge", interval: float = 15.0):
+        self.marilib = marilib
+        self.interval = interval
+        self._stop_event = threading.Event()
+        self._thread = threading.Thread(target=self._run, daemon=True)
+
+    def start(self):
+        """Starts the PDR testing thread."""
+        print("[yellow]PDR tester started.[/]")
+        self._thread.start()
+
+    def stop(self):
+        """Stops the PDR testing thread."""
+        self._stop_event.set()
+        if self._thread.is_alive():
+            self._thread.join()
+        print("[yellow]PDR tester stopped.[/]")
+
+    def _run(self):
+        """The main loop for the testing thread."""
+        self._stop_event.wait(self.interval)
+
+        while not self._stop_event.is_set():
+            nodes = list(self.marilib.nodes)
+            if not nodes:
+                self._stop_event.wait(self.interval)
+                continue
+
+            for node in nodes:
+                if self._stop_event.is_set():
+                    break
+                self.send_pdr_request(node.address)
+
+                # Spread requests evenly over the interval
+                sleep_duration = self.interval / len(nodes)
+                self._stop_event.wait(sleep_duration)
+
+    def send_pdr_request(self, address: int):
+        """Sends a PDR stats request to a specific address."""
+        self.marilib.send_frame(address, PDR_STATS_REQUEST_PAYLOAD)
+
+    def handle_response(self, frame: Frame) -> bool:
+        """
+        Handles a PDR stats response frame and calculates PDR values.
+        Returns True if the frame was a valid stats reply, False otherwise.
+        """
+        if len(frame.payload) != 8:
+            return False
+
+        try:
+            stats_reply = NodeStatsReply().from_bytes(frame.payload)
+            node = self.marilib.gateway.get_node(frame.header.source)
+
+            if node:
+                # Update with the latest stats reported by the node
+                node.last_reported_rx_count = stats_reply.rx_app_packets
+                node.last_reported_tx_count = stats_reply.tx_app_packets
+
+                # Calculate Downlink PDR
+                sent_count = node.stats.sent_count(include_test_packets=False)
+                if sent_count > 0:
+                    pdr = node.last_reported_rx_count / sent_count
+                    node.pdr_downlink = min(pdr, 1.0)
+                else:
+                    node.pdr_downlink = 0.0
+
+                # Calculate Uplink PDR
+                received_count = node.stats.received_count(include_test_packets=False)
+                if node.last_reported_tx_count > 0:
+                    pdr = received_count / node.last_reported_tx_count
+                    node.pdr_uplink = min(pdr, 1.0)
+                else:
+                    node.pdr_uplink = 0.0
+
+                return True
+
+        except (ValueError, ProtocolPayloadParserException):
+            return False
+
+        return False

marilib/serial_uart.py

@@ -16,7 +16,7 @@ import serial
 from serial.tools import list_ports
 
 SERIAL_PAYLOAD_CHUNK_SIZE = 64
-SERIAL_PAYLOAD_CHUNK_DELAY = 0.002  # 2 ms
+SERIAL_PAYLOAD_CHUNK_DELAY = 0.001  # 2 ms
 SERIAL_DEFAULT_PORT = "/dev/ttyACM0"
 SERIAL_DEFAULT_BAUDRATE = 1_000_000
 
@@ -76,9 +76,10 @@ class SerialInterface(threading.Thread):
         """Write bytes on serial."""
         # Send 64 bytes at a time
         pos = 0
-        while (pos % SERIAL_PAYLOAD_CHUNK_SIZE) == 0 and pos < len(bytes_):
-            self.serial.write(bytes_[pos : pos + SERIAL_PAYLOAD_CHUNK_SIZE])
+        while pos < len(bytes_):
+            chunk_end = min(pos + SERIAL_PAYLOAD_CHUNK_SIZE, len(bytes_))
+            self.serial.write(bytes_[pos:chunk_end])
             self.serial.flush()
-            pos += SERIAL_PAYLOAD_CHUNK_SIZE
-            time.sleep(SERIAL_PAYLOAD_CHUNK_DELAY)
-        # self.serial.flush()
+            pos = chunk_end
+            if pos < len(bytes_):  # Only sleep if there are more chunks
+                time.sleep(SERIAL_PAYLOAD_CHUNK_DELAY)

marilib/tui_cloud.py

@@ -88,9 +88,34 @@ class MarilibTUICloud(MarilibTUI):
         # Row 1: Gateway info
         node_count = f"{len(gateway.nodes)} / {gateway.info.schedule_uplink_cells}"
         schedule_info = f"#{gateway.info.schedule_id} {gateway.info.schedule_name}"
+
+        # --- Latency and PDR Display ---
+        avg_latency_edge = gateway.stats_avg_latency_roundtrip_node_edge_ms()
+        has_latency_info = avg_latency_edge > 0
+
+        # Check if we have PDR info by looking at the gateway averages
+        avg_uart_pdr_up = gateway.stats_avg_pdr_uplink_uart()
+        avg_uart_pdr_down = gateway.stats_avg_pdr_downlink_uart()
+        has_uart_pdr_info = avg_uart_pdr_up > 0 or avg_uart_pdr_down > 0
+
+        avg_radio_pdr_down = gateway.stats_avg_pdr_downlink_radio()
+        avg_radio_pdr_up = gateway.stats_avg_pdr_uplink_radio()
+        has_radio_pdr_info = avg_radio_pdr_down > 0 or avg_radio_pdr_up > 0
+
+        latency_info = f"  |  Latency: {avg_latency_edge:.1f}ms" if has_latency_info else ""
+        pdr_info = "  |  PDR:" if has_uart_pdr_info or has_radio_pdr_info else ""
+        radio_pdr_info = (
+            f"  Radio ↓ {avg_radio_pdr_down:.1%} ↑ {avg_radio_pdr_up:.1%}"
+            if has_radio_pdr_info
+            else ""
+        )
+        uart_pdr_info = (
+            f"  UART ↓ {avg_uart_pdr_down:.1%} ↑ {avg_uart_pdr_up:.1%}" if has_uart_pdr_info else ""
+        )
+
         table.add_row(
             f"[bold cyan]0x{gateway.info.address:016X}[/bold cyan]",
-            f"Nodes: {node_count}  |  Schedule: {schedule_info}",
+            f"Nodes: {node_count}  |  Schedule: {schedule_info}{latency_info}{pdr_info}{radio_pdr_info}{uart_pdr_info}",
         )
 
         # Row 2: Schedule usage