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

examples/frames.py

@@ -11,13 +11,19 @@ Example usage sending to broadcast address via mosquitto_pub:
 while [ 1 ]; do  python examples/frames.py | xxd -r -p | base64 | mosquitto_pub -h localhost -p 1883 -t /mari/00A0/to_edge -l; done
 """
 
-from marilib.mari_protocol import Frame, Header, MARI_BROADCAST_ADDRESS
+from marilib.mari_protocol import Frame, Header, MARI_BROADCAST_ADDRESS, MetricsProbePayload
 from marilib.model import EdgeEvent
+from rich import print
 import sys
 
 destination = sys.argv[1] if len(sys.argv) > 1 else MARI_BROADCAST_ADDRESS
 
 header = Header(destination=destination)
 frame = Frame(header=header, payload=b"NORMAL_APP_DATA")
+print(frame)
 frame_to_send = EdgeEvent.to_bytes(EdgeEvent.NODE_DATA) + frame.to_bytes()
 print(frame_to_send.hex())
+
+probe_payload = MetricsProbePayload()
+print(probe_payload.packet_length, probe_payload)
+print(probe_payload.to_bytes().hex())

examples/mari_cloud.py

@@ -1,15 +1,13 @@
 import time
 
 import click
-from marilib.mari_protocol import MARI_BROADCAST_ADDRESS, MARI_NET_ID_DEFAULT, Frame
+from marilib.mari_protocol import MARI_BROADCAST_ADDRESS, MARI_NET_ID_DEFAULT, DefaultPayload, Frame
 from marilib.marilib_cloud import MarilibCloud
 from marilib.model import EdgeEvent, GatewayInfo, MariNode
 from marilib.communication_adapter import MQTTAdapter
 from marilib.tui_cloud import MarilibTUICloud
 from marilib.logger import MetricsLogger
 
-NORMAL_DATA_PAYLOAD = b"NORMAL_APP_DATA"
-
 
 def on_event(event: EdgeEvent, event_data: MariNode | Frame | GatewayInfo):
     """An event handler for the application."""
@@ -32,6 +30,14 @@ def on_event(event: EdgeEvent, event_data: MariNode | Frame | GatewayInfo):
     default=MARI_NET_ID_DEFAULT,
     help=f"Network ID to use [default: 0x{MARI_NET_ID_DEFAULT:04X}]",
 )
+@click.option(
+    "--send-periodic",
+    "-s",
+    type=float,
+    default=0,
+    show_default=True,
+    help="Send periodic packet every N seconds (0 = disabled)",
+)
 @click.option(
     "--log-dir",
     default="logs",
@@ -39,7 +45,7 @@ def on_event(event: EdgeEvent, event_data: MariNode | Frame | GatewayInfo):
     help="Directory to save metric log files.",
     type=click.Path(),
 )
-def main(mqtt_url: str, network_id: int, log_dir: str):
+def main(mqtt_url: str, network_id: int, send_periodic: float, log_dir: str):
     """A basic example of using the MariLibCloud library."""
 
     mari = MarilibCloud(
@@ -54,12 +60,24 @@ def main(mqtt_url: str, network_id: int, log_dir: str):
     )
 
     try:
+        if send_periodic > 0:
+            normal_traffic_interval = send_periodic
+            last_normal_send_time = 0
+
         while True:
+            current_time = time.monotonic()
+
             mari.update()
-            if mari.nodes:
-                mari.send_frame(MARI_BROADCAST_ADDRESS, NORMAL_DATA_PAYLOAD)
+            if (
+                send_periodic > 0
+                and current_time - last_normal_send_time >= normal_traffic_interval
+            ):
+                if mari.nodes:
+                    mari.send_frame(MARI_BROADCAST_ADDRESS, DefaultPayload().to_bytes())
+                last_normal_send_time = current_time
+
             mari.render_tui()
-            time.sleep(0.5)
+            time.sleep(1)
 
     except KeyboardInterrupt:
         pass

examples/mari_edge.py

@@ -2,15 +2,13 @@ import time
 
 import click
 from marilib.logger import MetricsLogger
-from marilib.mari_protocol import Frame, MARI_BROADCAST_ADDRESS
+from marilib.mari_protocol import Frame, MARI_BROADCAST_ADDRESS, DefaultPayload
 from marilib.model import EdgeEvent, MariNode
 from marilib.communication_adapter import SerialAdapter, MQTTAdapter
 from marilib.serial_uart import get_default_port
 from marilib.tui_edge import MarilibTUIEdge
 from marilib.marilib_edge import MarilibEdge
 
-NORMAL_DATA_PAYLOAD = b"NORMAL_APP_DATA"
-
 
 def on_event(event: EdgeEvent, event_data: MariNode | Frame):
     """An event handler for the application."""
@@ -30,9 +28,8 @@ def on_event(event: EdgeEvent, event_data: MariNode | Frame):
     "--mqtt-url",
     "-m",
     type=str,
-    default="mqtt://localhost:1883",
-    show_default=True,
-    help="MQTT broker to use (default: empty, no cloud)",
+    default=None,
+    help="MQTT broker to use (default: None, no cloud)",
 )
 @click.option(
     "--log-dir",
@@ -59,7 +56,7 @@ def main(port: str | None, mqtt_url: str, log_dir: str):
         while True:
             mari.update()
             if not mari.uses_mqtt and mari.nodes:
-                mari.send_frame(MARI_BROADCAST_ADDRESS, NORMAL_DATA_PAYLOAD)
+                mari.send_frame(MARI_BROADCAST_ADDRESS, DefaultPayload().to_bytes())
             mari.render_tui()
             time.sleep(0.5)
     except KeyboardInterrupt:

examples/mari_edge_stats.py

@@ -4,16 +4,13 @@ import time
 
 import click
 from marilib.logger import MetricsLogger
-from marilib.mari_protocol import MARI_BROADCAST_ADDRESS, Frame
+from marilib.mari_protocol import MARI_BROADCAST_ADDRESS, Frame, DefaultPayload, DefaultPayloadType
 from marilib.marilib_edge import MarilibEdge
 from marilib.model import EdgeEvent, GatewayInfo, MariNode, TestState
 from marilib.serial_uart import get_default_port
 from marilib.tui_edge import MarilibTUIEdge
 from marilib.communication_adapter import SerialAdapter, MQTTAdapter
 
-LOAD_PACKET_PAYLOAD = b"L"
-NORMAL_DATA_PAYLOAD = b"NORMAL_APP_DATA"
-
 
 class LoadTester(threading.Thread):
     def __init__(
@@ -43,7 +40,10 @@ class LoadTester(threading.Thread):
                 nodes_exist = bool(self.mari.gateway.nodes)
 
             if nodes_exist:
-                self.mari.send_frame(MARI_BROADCAST_ADDRESS, LOAD_PACKET_PAYLOAD)
+                self.mari.send_frame(
+                    MARI_BROADCAST_ADDRESS,
+                    DefaultPayload(type_=DefaultPayloadType.METRICS_LOAD).to_bytes(),
+                )
             self._stop_event.wait(self.delay)
 
     def set_rate(self):
@@ -88,6 +88,14 @@ def on_event(event: EdgeEvent, event_data: MariNode | Frame | GatewayInfo):
     show_default=True,
     help="Load percentage to apply (0–100)",
 )
+@click.option(
+    "--send-periodic",
+    "-s",
+    type=float,
+    default=0,
+    show_default=True,
+    help="Send periodic packet every N seconds (0 = disabled)",
+)
 @click.option(
     "--log-dir",
     default="logs",
@@ -95,7 +103,7 @@ def on_event(event: EdgeEvent, event_data: MariNode | Frame | GatewayInfo):
     help="Directory to save metric log files.",
     type=click.Path(),
 )
-def main(port: str | None, mqtt_host: str, load: int, log_dir: str):
+def main(port: str | None, mqtt_host: str, load: int, send_periodic: float, log_dir: str):
     if not (0 <= load <= 100):
         sys.stderr.write("Error: --load must be between 0 and 100.\n")
         return
@@ -109,7 +117,7 @@ def main(port: str | None, mqtt_host: str, load: int, log_dir: str):
     mari = MarilibEdge(
         on_event,
         serial_interface=SerialAdapter(port),
-        mqtt_interface=MQTTAdapter.from_host_port(mqtt_host, is_edge=True) if mqtt_host else None,
+        mqtt_interface=MQTTAdapter.from_url(mqtt_host, is_edge=True) if mqtt_host else None,
         logger=logger,
         main_file=__file__,
         tui=MarilibTUIEdge(test_state=test_state),
@@ -117,15 +125,16 @@ def main(port: str | None, mqtt_host: str, load: int, log_dir: str):
 
     stop_event = threading.Event()
 
-    mari.latency_test_enable()
+    mari.metrics_test_enable()
 
     load_tester = LoadTester(mari, test_state, stop_event)
     if load > 0:
         load_tester.start()
 
     try:
-        normal_traffic_interval = 0.5
-        last_normal_send_time = 0
+        if send_periodic > 0:
+            normal_traffic_interval = send_periodic
+            last_normal_send_time = 0
 
         while not stop_event.is_set():
             current_time = time.monotonic()
@@ -134,18 +143,21 @@ def main(port: str | None, mqtt_host: str, load: int, log_dir: str):
 
             mari.render_tui()
 
-            if current_time - last_normal_send_time >= normal_traffic_interval:
+            if (
+                send_periodic > 0
+                and current_time - last_normal_send_time >= normal_traffic_interval
+            ):
                 if mari.nodes:
-                    mari.send_frame(MARI_BROADCAST_ADDRESS, NORMAL_DATA_PAYLOAD)
+                    mari.send_frame(MARI_BROADCAST_ADDRESS, DefaultPayload().to_bytes())
                 last_normal_send_time = current_time
 
-            time.sleep(0.1)
+            time.sleep(1)
 
     except KeyboardInterrupt:
         pass
     finally:
         stop_event.set()
-        mari.latency_test_disable()
+        mari.metrics_test_disable()
         if load_tester.is_alive():
             load_tester.join()
         mari.close_tui()

examples/raspberry-pi/sense_hat_ui.py

@@ -0,0 +1,244 @@
+# this only works on raspberry pi
+# to install the emulator sense_emu library:
+# - sudo apt-get install python3-gi python3-gi-cairo
+# - pip install sense-emu
+# to install the real sense_hat library:
+# - sudo apt-get install sense-hat
+
+from sense_emu import SenseHat
+import threading
+import time
+
+# ======================= Code for driving the sense hat =======================
+
+s = SenseHat()
+# s.set_rotation(90)
+# ---------- colors ----------
+r = [255, 0, 0]
+w = [255, 255, 255]
+g = [0, 128, 0]
+y = [255, 255, 0]
+b = [0, 0, 255]
+p = [191, 0, 255]
+
+# clear the screen to have a white background
+s.clear(w)
+
+# ---------- config ----------
+nb_max = 102  # maximum number of nodes for this schedule -- will come from marilib
+nb_row = 8  # number of pixels in a row
+bg = w  # background of the bottom 6*6 area
+nb_nodes_per_pixel = nb_max // nb_row
+
+# ---------- shared state ----------
+state_lock = threading.Lock()
+node_changed = threading.Event()
+
+nb_nodes = 0  # current nodes
+prev_pixels = 0  # how many pixels were lit last time
+
+
+# 6x6 font: each row is a 6-bit number (bit 5 = leftmost, bit 0 = rightmost)
+font_6x6 = {
+    " ": [0b000000, 0b000000, 0b000000, 0b000000, 0b000000, 0b000000],
+    "0": [0b011110, 0b100001, 0b100001, 0b100001, 0b100001, 0b011110],
+    "1": [0b001000, 0b011000, 0b001000, 0b001000, 0b001000, 0b111110],
+    "2": [0b011110, 0b100001, 0b000010, 0b000100, 0b001000, 0b111111],
+    "3": [0b011110, 0b100001, 0b000110, 0b000001, 0b100001, 0b011110],
+    "4": [0b000100, 0b001100, 0b010100, 0b100100, 0b111111, 0b000100],
+    "5": [0b111111, 0b100000, 0b111110, 0b000001, 0b100001, 0b011110],
+    "6": [0b011110, 0b100000, 0b111110, 0b100001, 0b100001, 0b011110],
+    "7": [0b111111, 0b000001, 0b000010, 0b000100, 0b001000, 0b010000],
+    "8": [0b011110, 0b100001, 0b011110, 0b100001, 0b100001, 0b011110],
+    "9": [0b011110, 0b100001, 0b100001, 0b111111, 0b000001, 0b011110],
+}
+
+
+def choose_color(multiplier: int):
+    """
+    Choose color of pixels depending on number of nodes  that joined
+    """
+    if multiplier > 8:
+        return w
+    if multiplier <= 3:
+        return g
+    if multiplier < 6:
+        return y
+    if multiplier <= 8:
+        return r
+
+
+def _set_top(x, color):
+    s.set_pixel(x, 0, color)
+
+
+def display_num_nodes():
+    """
+    update the top bar so that every (nb_nodes//nb_row) nodes that joined or left
+    changes the bar by 1 pixel.
+    example: if nb_max of nodes is 66 then 66//8 = 8 so every 8 nodes joining lights up one more pixel
+    and every 8 nodes leaving resets 1 pixel
+    """
+    global prev_pixels
+
+    with state_lock:
+        current_nodes = nb_nodes
+        old_pixels = prev_pixels
+
+    new_pixels = current_nodes // nb_nodes_per_pixel
+    # nodes have joined
+    if new_pixels > old_pixels:
+        # light pixels from old_pixels .. new_pixels-1
+        for i in range(old_pixels, new_pixels):
+            _set_top(i, choose_color(i + 1))
+
+    # nodes left
+    elif new_pixels < old_pixels:
+        # clear pixels from new_pixels .. old_pixels-1
+        for i in range(new_pixels, old_pixels):
+            _set_top(i, bg)
+
+    # update number of pixels
+    with state_lock:
+        prev_pixels = new_pixels
+
+
+def display_num_nodes_thread():
+    """
+    Background thread: wait for node changes and update the top bar.
+    """
+    display_num_nodes()  # initial paint
+    while True:
+        node_changed.wait()
+        node_changed.clear()
+        display_num_nodes()
+
+
+def number_to_columns(rows):
+    """Convert 6 rows of 6-bit ints (a number) to a list of 6 columns of pixels
+    (each column is a list of 6 booleans
+    True=ON, False=OFF)."""
+    cols = []
+    for c in range(6):  # 0..5 (left->right)
+        mask = 1 << (5 - c)
+        col = [(rows[r] & mask) != 0 for r in range(6)]  # top->bottom
+        cols.append(col)
+    return cols
+
+
+def text_to_columns(text):
+    """Convert text to a list of columns with 1 blank column between the numbers."""
+    stream = []
+    for ch in text:
+        rows = font_6x6.get(ch, font_6x6[" "])
+        stream.extend(number_to_columns(rows))
+        stream.append([False] * 6)  # spacing column
+    return stream
+
+
+def display_scrolling_message(text, fg, bg, speed, scrolling_times):
+    """
+    Scroll a 6x6 message across the Sense HAT.
+    Draws ONLY on rows y=2..7 (leaves y=0 and y=1 unchanged).
+    """
+    text = " " + text
+    cols = text_to_columns(text)
+    cols.extend([[False] * 6 for _ in range(8)])  # right padding so it scrolls off
+
+    width = 8
+    for i in range(scrolling_times):
+        for offset in range(len(cols)):
+            for x in range(width):
+                col_index = offset + x
+                col = cols[col_index] if 0 <= col_index < len(cols) else [False] * 6
+
+                # Map 6-tall column onto y = 2..7
+                for y6 in range(6):
+                    y = 2 + y6
+                    s.set_pixel(x, y, fg if col[y6] else bg)
+            time.sleep(speed)
+
+
+def display_static_message(text, fg, bg):
+    """
+    Show a 6x6 message without scrolling.
+    Draws only on rows y=2..7, rows 0 and 1 are not used
+    """
+    cols = text_to_columns(text)
+    width = 8
+    # draw 8 columns
+    for x in range(width):
+        src_index = x - 1  # shift right by 1 column
+        if 0 <= src_index < len(cols):
+            col = cols[src_index]
+        else:
+            col = [False] * 6  # blank when out of bounds
+
+        for y6 in range(6):
+            y = 2 + y6  # vertical position unchanged
+            s.set_pixel(x, y, fg if col[y6] else bg)
+
+
+def message_thread(
+    static_text, scroll_text, fg_static, fg_scroll, bg, scroll_speed, scroll_repeats
+):
+    """
+    alternates:
+      1) draw static message; schedule
+      2) scroll another message: network id (net_id) scroll_repeats times at scroll_speed
+    Loops forever.
+    """
+    while True:
+        display_static_message(static_text, fg_static, bg)
+        time.sleep(3)
+        display_scrolling_message(scroll_text, fg_scroll, bg, scroll_speed, scroll_repeats)
+        time.sleep(0.2)
+
+
+# ========================= functions just for testing =========================
+
+
+def node_join(n: int):
+    """
+    Safely add n nodes and notify the drawer.
+    """
+    global nb_nodes
+    with state_lock:
+        nb_nodes = min(nb_nodes + n, nb_max)
+    node_changed.set()
+
+
+# just for testing
+def node_leave(n: int):
+    """
+    Safely remove n nodes and notify the drawer.
+    """
+    global nb_nodes
+    with state_lock:
+        nb_nodes = max(nb_nodes - n, 0)
+    node_changed.set()
+
+
+# ================================ main function ===============================
+
+if __name__ == "__main__":
+    scroll = True
+    speed = 0.1
+    schedule = 5  # will come from marilib
+    net_id = 1200  # will come from marilib
+    scrolling_times = 3
+
+    threading.Thread(target=display_num_nodes_thread, daemon=True).start()
+
+    threading.Thread(
+        target=message_thread,
+        args=(str(schedule), str(net_id), b, p, w, speed, scrolling_times),
+        daemon=True,
+    ).start()
+
+    # demo
+    while True:
+        time.sleep(0.8)
+        node_join(24)  # +1 bar pixel
+        time.sleep(0.8)
+        node_leave(8)  # -1 bar pixel

marilib/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.6.0"
+__version__ = "0.7.0-rc1"
 
 
 # declare these just to avoid circular imports

marilib/communication_adapter.py

@@ -53,9 +53,10 @@ class SerialAdapter(CommunicationAdapterBase):
         print("[yellow]Disconnect from gateway...[/]")
 
     def send_data(self, data):
-        self.serial.serial.flush()
-        encoded = hdlc_encode(data)
-        self.serial.write(encoded)
+        with self.serial.lock:  # Use the existing lock for thread safety
+            self.serial.serial.flush()
+            encoded = hdlc_encode(data)
+            self.serial.write(encoded)
 
 
 class MQTTAdapter(CommunicationAdapterBase):

marilib/logger.py

@@ -85,11 +85,17 @@ class MetricsLogger:
             "gateway_address",
             "schedule_id",
             "connected_nodes",
-            "tx_total",
-            "rx_total",
-            "tx_rate_1s",
-            "rx_rate_1s",
+            # "tx_total",
+            # "rx_total",
+            # "tx_rate_1s",
+            # "rx_rate_1s",
             "avg_latency_ms",
+            "avg_pdr_downlink_radio",
+            "avg_pdr_uplink_radio",
+            "latest_node_tx_count",
+            "latest_node_rx_count",
+            "latest_gw_tx_count",
+            "latest_gw_rx_count",
         ]
         self._gateway_writer.writerow(gateway_header)
 
@@ -100,17 +106,20 @@ class MetricsLogger:
             "gateway_address",
             "node_address",
             "is_alive",
-            "tx_total",
-            "rx_total",
-            "tx_rate_1s",
-            "rx_rate_1s",
+            # "tx_total",
+            # "rx_total",
+            # "tx_rate_1s",
+            # "rx_rate_1s",
             "success_rate_30s",
             "success_rate_total",
             "pdr_downlink",
             "pdr_uplink",
-            "rssi_dbm_5s",
-            "last_latency_ms",
-            "avg_latency_ms",
+            "rssi_node_dbm",
+            "rssi_gw_dbm",
+            "avg_latency_edge_ms",
+            "avg_latency_cloud_ms",
+            "last_latency_edge_ms",
+            "last_latency_cloud_ms",
         ]
         self._nodes_writer.writerow(nodes_header)
 
@@ -141,11 +150,17 @@ class MetricsLogger:
             f"0x{gateway.info.address:016X}",
             gateway.info.schedule_id,
             len(gateway.nodes),
-            gateway.stats.sent_count(include_test_packets=False),
-            gateway.stats.received_count(include_test_packets=False),
-            gateway.stats.sent_count(1, include_test_packets=False),
-            gateway.stats.received_count(1, include_test_packets=False),
-            f"{gateway.latency_stats.avg_ms:.2f}",
+            # gateway.stats.sent_count(include_test_packets=False),
+            # gateway.stats.received_count(include_test_packets=False),
+            # gateway.stats.sent_count(1, include_test_packets=False),
+            # gateway.stats.received_count(1, include_test_packets=False),
+            f"{gateway.stats_avg_latency_roundtrip_node_edge_ms():.2f}",
+            f"{gateway.stats_avg_pdr_downlink_radio():.2f}",
+            f"{gateway.stats_avg_pdr_uplink_radio():.2f}",
+            gateway.stats_latest_node_tx_count(),
+            gateway.stats_latest_node_rx_count(),
+            gateway.stats_latest_gw_tx_count(),
+            gateway.stats_latest_gw_rx_count(),
         ]
         self._gateway_writer.writerow(row)
 
@@ -161,17 +176,20 @@ class MetricsLogger:
                 f"0x{node.gateway_address:016X}",
                 f"0x{node.address:016X}",
                 node.is_alive,
-                node.stats.sent_count(include_test_packets=False),
-                node.stats.received_count(include_test_packets=False),
-                node.stats.sent_count(1, include_test_packets=False),
-                node.stats.received_count(1, include_test_packets=False),
+                # node.stats.sent_count(include_test_packets=False),
+                # node.stats.received_count(include_test_packets=False),
+                # node.stats.sent_count(1, include_test_packets=False),
+                # node.stats.received_count(1, include_test_packets=False),
                 f"{node.stats.success_rate(30):.2%}",
                 f"{node.stats.success_rate():.2%}",
                 f"{node.pdr_downlink:.2%}",
                 f"{node.pdr_uplink:.2%}",
-                node.stats.received_rssi_dbm(5),
-                f"{node.latency_stats.last_ms:.2f}",
-                f"{node.latency_stats.avg_ms:.2f}",
+                node.stats_rssi_node_dbm(),
+                node.stats_rssi_gw_dbm(),
+                f"{node.stats_avg_latency_roundtrip_node_edge_ms():.2f}",
+                f"{node.stats_avg_latency_roundtrip_node_edge_ms():.2f}",  # FIXME!: should use cloud option
+                f"{node.stats_latest_latency_roundtrip_node_edge_ms():.2f}",
+                f"{node.stats_latest_latency_roundtrip_node_edge_ms():.2f}",  # FIXME!: should use cloud option
             ]
             self._nodes_writer.writerow(row)