enode-host 0.1.0__py3-none-any.whl

enode_host/cli.py

@@ -0,0 +1,192 @@
+import argparse
+import asyncio
+import contextlib
+from typing import List, Optional
+
+from .async_socket import run_client, run_server
+from .protocol import (
+    Mode,
+    Toggle,
+    build_past_stream,
+    build_realtime_stream,
+    build_sd_stream_start,
+    build_sd_stream_stop,
+    build_sd_clear,
+    build_set_mode,
+    build_start_daq,
+    build_stop_daq,
+)
+
+
+def build_command_from_tokens(tokens: List[str]) -> Optional[bytes]:
+    if not tokens:
+        return None
+    cmd = tokens[0].lower()
+    if cmd == "start_daq":
+        return build_start_daq()
+    if cmd == "stop_daq":
+        return build_stop_daq()
+    if cmd == "set_mode":
+        if len(tokens) < 2:
+            raise ValueError("set_mode requires realtime|past")
+        mode_token = tokens[1].lower()
+        if mode_token == "realtime":
+            mode = Mode.REALTIME
+        elif mode_token == "past":
+            mode = Mode.PAST
+        else:
+            raise ValueError("set_mode requires realtime|past")
+        return build_set_mode(mode)
+    if cmd == "realtime_stream":
+        if len(tokens) < 2:
+            raise ValueError("realtime_stream requires start|stop")
+        toggle = Toggle.START if tokens[1].lower() == "start" else Toggle.STOP
+        return build_realtime_stream(toggle)
+    if cmd == "past_stream":
+        if len(tokens) < 2:
+            raise ValueError("past_stream requires start|stop")
+        toggle = Toggle.START if tokens[1].lower() == "start" else Toggle.STOP
+        if toggle == Toggle.START:
+            if len(tokens) < 4:
+                raise ValueError("past_stream start requires start_ms end_ms")
+            return build_past_stream(toggle, int(tokens[2]), int(tokens[3]))
+        return build_past_stream(toggle)
+    if cmd == "sd_stream":
+        if len(tokens) < 2:
+            raise ValueError("sd_stream requires start|stop")
+        if tokens[1].lower() == "start":
+            if len(tokens) < 3:
+                raise ValueError("sd_stream start requires hours")
+            return build_sd_stream_start(int(tokens[2]))
+        return build_sd_stream_stop()
+    if cmd == "sd_clear":
+        return build_sd_clear()
+    raise ValueError(f"unknown command: {cmd}")
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="enode-host",
+        description="Host-side tools for interacting with the ESP-IDF firmware.",
+    )
+    parser.add_argument(
+        "--ping",
+        action="store_true",
+        help="Basic sanity check that the CLI is wired up.",
+    )
+
+    subparsers = parser.add_subparsers(dest="command")
+    server_parser = subparsers.add_parser(
+        "server",
+        help="Run a TCP server for ESP-IDF nodes.",
+    )
+    server_parser.add_argument("--host", default="0.0.0.0")
+    server_parser.add_argument("--port", type=int, default=3333)
+    server_parser.add_argument(
+        "--on-connect",
+        nargs=argparse.REMAINDER,
+        help="Send a protocol command immediately after a client connects.",
+    )
+    server_parser.add_argument(
+        "--interactive",
+        action="store_true",
+        help="Read commands from stdin and broadcast to all clients.",
+    )
+
+    gui_parser = subparsers.add_parser(
+        "gui",
+        help="Run the wx GUI backed by the framed server.",
+    )
+    gui_parser.add_argument("--host", default="0.0.0.0")
+    gui_parser.add_argument("--port", type=int, default=3333)
+
+    socket_parser = subparsers.add_parser(
+        "socket",
+        help="Send a message over a TCP socket and print the response.",
+    )
+    socket_parser.add_argument("host")
+    socket_parser.add_argument("port", type=int)
+    socket_parser.add_argument("message")
+    socket_parser.add_argument("--timeout", type=float, default=5.0)
+    return parser
+
+
+def main() -> int:
+    parser = build_parser()
+    args = parser.parse_args()
+
+    if args.ping:
+        print("pong")
+        return 0
+
+    if args.command is None:
+        try:
+            from .gui_framed import run_gui
+        except Exception as exc:
+            import traceback
+            print(f"[gui] failed to start: {exc}")
+            traceback.print_exc()
+            return 2
+        run_gui(host="0.0.0.0", port=3333)
+        return 0
+
+    if args.command == "server":
+        on_connect_payload = None
+        if args.on_connect:
+            on_connect_payload = build_command_from_tokens(args.on_connect)
+
+        if args.interactive:
+            return asyncio.run(run_interactive_server(args.host, args.port, on_connect_payload))
+
+        asyncio.run(run_server(args.host, args.port, on_connect_payload))
+        return 0
+
+    if args.command == "gui":
+        try:
+            from .gui_framed import run_gui
+        except Exception as exc:
+            import traceback
+            print(f"[gui] failed to start: {exc}")
+            traceback.print_exc()
+            return 2
+        run_gui(host=args.host, port=args.port)
+        return 0
+
+    if args.command == "socket":
+        return run_client(args.host, args.port, args.message, args.timeout)
+
+    parser.print_help()
+    return 0
+
+
+async def run_interactive_server(host: str, port: int, on_connect_payload: Optional[bytes]) -> int:
+    queue: asyncio.Queue[bytes] = asyncio.Queue()
+    server_task = asyncio.create_task(run_server(host, port, on_connect_payload, queue))
+
+    try:
+        while True:
+            line = await asyncio.to_thread(input, "cmd> ")
+            if not line:
+                continue
+            stripped = line.strip()
+            if stripped in ("quit", "exit"):
+                break
+            tokens = stripped.split()
+            try:
+                payload = build_command_from_tokens(tokens)
+            except ValueError as exc:
+                print(f"[server] {exc}")
+                continue
+            if payload is None:
+                continue
+            await queue.put(payload)
+    finally:
+        server_task.cancel()
+        with contextlib.suppress(asyncio.CancelledError):
+            await server_task
+
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

enode_host/config.py

@@ -0,0 +1,8 @@
+# CONFIGURATION
+rawFileLength_sec = 60
+port = 3333
+target_dir = "/home/kykoo/esp/esp-idf-v5.1.1/workspace/22_lvgl_gps_acc_mesh/attempt8/validation/02_mesh_test/"
+target_dir = "/home/kykoo/OneDrive/esp/24_acc_svr_app/shm_v1/validation/data"
+target_dir = "validation/data"
+NNODES = 14
+TIME_WINDOW_LENGTH_SEC = 30

enode_host/constants.py

@@ -0,0 +1,25 @@
+"""Shared constants for enode_host."""
+
+import os
+
+BASE_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
+
+RT_STREAM_DIR = os.path.join(BASE_DIR, "rt-streamed")
+RT_STREAM_HD5_DIR = os.path.join(RT_STREAM_DIR, "hd5")
+RT_STREAM_MERGED_DIR = os.path.join(RT_STREAM_DIR, "merged")
+
+SD_STREAM_DIR = os.path.join(BASE_DIR, "sd-streamed")
+SD_STREAM_BIN_DIR = os.path.join(SD_STREAM_DIR, "bin")
+SD_STREAM_HD5_DIR = os.path.join(SD_STREAM_DIR, "hd5")
+
+PACKET_SIZE = 23
+
+SPEED_COL = "Speed\n(kB/s)"
+RSSI_COL = "RSSI\n(dB)"
+PPS_COL = "PPS\nage"
+LEVEL_COL = "Lv"
+
+PPS_AGE_LIMIT_SEC = 10
+DAQ_AGE_LIMIT_SEC = 2
+PPS_AGE_UPDATE_MS = 1000
+GUI_TIMER_MS = 100

enode_host/framed_mesh.py

@@ -0,0 +1,237 @@
+import asyncio
+import threading
+from typing import Dict, Optional
+
+from .async_socket import read_frame
+from .protocol import (
+    MsgType,
+    build_command,
+    format_mac,
+    parse_acc_batch,
+    parse_ack,
+    parse_pps,
+    parse_sd_chunk,
+    parse_sd_done,
+    parse_status,
+    parse_gnss,
+)
+
+
+class FramedMesh:
+    def __init__(self, model, host: str = "0.0.0.0", port: int = 3333):
+        self.model = model
+        self.host = host
+        self.port = port
+        self.loop = asyncio.new_event_loop()
+        self.thread = threading.Thread(target=self._run, daemon=True)
+        self.clients: Dict[str, asyncio.StreamWriter] = {}
+        self._last_cmd: Dict[str, str] = {}
+        self._sd_done_events: Dict[str, threading.Event] = {}
+        self._sd_done_lock = threading.Lock()
+        self._stat_lock = threading.Lock()
+        self._data_frames = 0
+        self._data_samples = 0
+        self._pps_frames = 0
+        self._last_stat = 0.0
+        self.thread.start()
+
+    def _run(self) -> None:
+        asyncio.set_event_loop(self.loop)
+        server = self.loop.run_until_complete(
+            asyncio.start_server(self._handle_client, host=self.host, port=self.port)
+        )
+        addrs = ", ".join(str(sock.getsockname()) for sock in server.sockets or [])
+        self._ui_log(f"[gui] framed server listening on {addrs}")
+        try:
+            self.loop.run_forever()
+        finally:
+            server.close()
+            self.loop.run_until_complete(server.wait_closed())
+
+    async def _handle_client(self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter) -> None:
+        peer = writer.get_extra_info("peername")
+        peer_id = f"{peer[0]}:{peer[1]}" if peer else "unknown"
+        self._ui_log(f"[gui] connected {peer_id}")
+        node_id: Optional[int] = None
+
+        try:
+            while True:
+                msg_type, payload = await read_frame(reader)
+                if msg_type == MsgType.STATUS:
+                    status = parse_status(payload)
+                    node_id = self.model.make_node_key(status.node_type, status.node_number)
+                    self.clients[node_id] = writer
+                    self.model.enqueue_conn_report(
+                        nodeID=node_id,
+                        level=status.level,
+                        parent_mac=format_mac(status.parent_mac),
+                        self_mac=format_mac(status.self_mac),
+                        rssi=status.rssi,
+                        acc_model=status.acc_model,
+                        daq_mode=status.daq_mode,
+                        daq_on=status.daq_on,
+                        stream_status=status.stream_status,
+                        notify=False,
+                    )
+                elif msg_type == MsgType.DATA:
+                    batch = parse_acc_batch(payload)
+                    node_id = self.model.make_node_key(batch.node_type, batch.node_number)
+                    self.clients[node_id] = writer
+                    with self._stat_lock:
+                        self._data_frames += 1
+                        self._data_samples += len(batch.samples)
+                    self.model.record_rx_bytes(node_id, len(payload) + 3, kind="data")
+                    self.model.enqueue_acc_batch(node_id, batch.samples)
+                elif msg_type == MsgType.PPS:
+                    try:
+                        pps = parse_pps(payload)
+                    except Exception as exc:
+                        preview = payload[:12].hex()
+                        print(f"[pps] parse failed len={len(payload)} head={preview} err={exc}")
+                        continue
+                    node_id = self.model.make_node_key(pps.node_type, pps.node_number)
+                    self.clients[node_id] = writer
+                    with self._stat_lock:
+                        self._pps_frames += 1
+                    self.model.enqueue_pps(node_id, pps.cc, pps.epoch)
+                elif msg_type == MsgType.SD_STREAM:
+                    chunk = parse_sd_chunk(payload)
+                    node_id = self.model.make_node_key(chunk.node_type, chunk.node_number)
+                    self.model.record_rx_bytes(node_id, len(payload) + 3, kind="sd")
+                    self.model.handle_sd_chunk(node_id, chunk.file_time, chunk.offset, chunk.data)
+                elif msg_type == MsgType.SD_DONE:
+                    done = parse_sd_done(payload)
+                    node_id = self.model.make_node_key(done.node_type, done.node_number)
+                    self.model.handle_sd_done(node_id, done.file_time, done.status)
+                    if done.status == 1:
+                        self._signal_sd_done(node_id)
+                elif msg_type == MsgType.GNSS:
+                    gnss = parse_gnss(payload)
+                    node_id = self.model.make_node_key(gnss.node_type, gnss.node_number)
+                    self.model.update_gnss_position(
+                        node_id, gnss.latitude, gnss.longitude, gnss.fix_mode, gnss.valid
+                    )
+                elif msg_type == MsgType.ACK:
+                    try:
+                        ack = parse_ack(payload)
+                    except Exception as exc:
+                        self._ui_log(f"[ack] parse failed len={len(payload)} err={exc}")
+                    else:
+                        self._ui_log(
+                            f"[ack] type=0x{ack.original_type:02X} status={ack.status} msg={ack.message}"
+                        )
+                        if node_id is not None:
+                            label = self._last_cmd.get(node_id, "cmd")
+                            msg = f"{label} ack:{ack.status}"
+                            if ack.message:
+                                msg = f"{msg} {ack.message}"
+                            self.model._set_node_fields(node_id, **{"CMD": msg})
+            await self._maybe_log_stats()
+        except asyncio.IncompleteReadError:
+            pass
+        finally:
+            if node_id is not None and self.clients.get(node_id) is writer:
+                self.clients.pop(node_id, None)
+            writer.close()
+            await writer.wait_closed()
+            self._ui_log(f"[gui] disconnected {peer_id}")
+
+    async def _maybe_log_stats(self) -> None:
+        now = self.loop.time()
+        if self._last_stat == 0.0:
+            self._last_stat = now
+            return
+        if now - self._last_stat < 1.0:
+            return
+        with self._stat_lock:
+            data_frames = self._data_frames
+            data_samples = self._data_samples
+            pps_frames = self._pps_frames
+            self._data_frames = 0
+            self._data_samples = 0
+            self._pps_frames = 0
+        self._ui_log(f"[rate] data_frames/s={data_frames} samples/s={data_samples} pps/s={pps_frames}")
+        self._last_stat = now
+
+    def _ui_log(self, msg: str) -> None:
+        ui_log = getattr(self.model, "ui_log", None)
+        if callable(ui_log):
+            ui_log(msg)
+        else:
+            print(msg)
+
+    async def _send(self, writer: asyncio.StreamWriter, payload: bytes) -> None:
+        writer.write(payload)
+        await writer.drain()
+
+    def send_command(self, node_id: str, command_payload: bytes, label: str = "cmd") -> bool:
+        writer = self.clients.get(node_id)
+        if writer is None:
+            return False
+        try:
+            self._mark_cmd_sent(node_id, label)
+            future = asyncio.run_coroutine_threadsafe(
+                self._send(writer, command_payload), self.loop
+            )
+            future.result(timeout=2)
+            return True
+        except Exception:
+            self.clients.pop(node_id, None)
+            return False
+
+    def _mark_cmd_sent(self, node_id: str, label: str) -> None:
+        self._last_cmd[node_id] = label
+        self.model._set_node_fields(node_id, **{"CMD": f"{label} sent"})
+
+    def broadcast_command(self, command_payload: bytes, label: str = "cmd") -> int:
+        sent = 0
+        for node_id, writer in list(self.clients.items()):
+            try:
+                self._mark_cmd_sent(node_id, label)
+                future = asyncio.run_coroutine_threadsafe(
+                    self._send(writer, command_payload), self.loop
+                )
+                future.result(timeout=2)
+                sent += 1
+            except Exception:
+                self.clients.pop(node_id, None)
+        return sent
+
+    def _get_sd_event(self, node_id: str) -> threading.Event:
+        with self._sd_done_lock:
+            ev = self._sd_done_events.get(node_id)
+            if ev is None:
+                ev = threading.Event()
+                self._sd_done_events[node_id] = ev
+            return ev
+
+    def _signal_sd_done(self, node_id: str) -> None:
+        ev = self._get_sd_event(node_id)
+        ev.set()
+
+    def stream_sd_sequential(self, command_payload: bytes, label: str = "sd_stream_start", timeout_s: float = 3600.0) -> None:
+        node_ids = sorted(self.clients.keys())
+        if not node_ids:
+            self._ui_log("[sd] no connected nodes for sequential stream")
+            return
+        self._ui_log(f"[sd] sequential start for {len(node_ids)} nodes")
+        for node_id in node_ids:
+            ev = self._get_sd_event(node_id)
+            ev.clear()
+            ok = self.send_command(node_id, command_payload)
+            if not ok:
+                self._ui_log(f"[sd] send failed: {node_id}")
+                self.model._set_node_fields(node_id, **{"CMD": "sd_stream send failed"})
+                continue
+            self._mark_cmd_sent(node_id, label)
+            self._ui_log(f"[sd] streaming {node_id}")
+            if ev.wait(timeout=timeout_s):
+                self._ui_log(f"[sd] done {node_id}")
+            else:
+                self._ui_log(f"[sd] timeout {node_id}")
+                self.model._set_node_fields(node_id, **{"CMD": "sd_stream timeout"})
+        self._ui_log("[sd] sequential complete")
+
+    @staticmethod
+    def build_command_payload(command_id: int, payload: bytes = b"") -> bytes:
+        return build_command(command_id, payload)

enode_host/gui_framed.py

@@ -0,0 +1,207 @@
+import logging
+import threading
+
+import wx
+
+from .framed_mesh import FramedMesh
+from .cli import build_command_from_tokens
+from .protocol import (
+    Toggle,
+    build_realtime_stream,
+    build_sd_clear,
+    build_sd_stream_start,
+    build_sd_stream_stop,
+    build_set_daq_mode,
+    build_start_daq,
+    build_stop_daq,
+)
+from . import model
+from . import view
+
+logger = logging.getLogger(__name__)
+
+
+class Controller:
+    def __init__(self, host: str, port: int):
+        self.model = model.Model(self)
+        self.view = view.View(self)
+        self.model.ui_log = self.view.append_status_message
+        self.view.Show()
+        self.mesh = FramedMesh(self.model, host=host, port=port)
+
+        self.view.m_button_nodes_update.Bind(wx.EVT_BUTTON, self.on_change_node_nums)
+        self.view.Bind(wx.EVT_MENU, self.on_exit, self.view.m_menu_file_quit)
+        self.view.Bind(wx.EVT_MENU, self.on_merge_rt_files, self.view.m_menu_data_export)
+        self.view.Bind(wx.EVT_MENU, self.on_merge_sd_files, self.view.m_menu_data_merge_sd)
+        self.view.Bind(wx.EVT_MENU, self.on_plot_rt_merged, self.view.m_menu_data_plot_rt)
+        self.view.Bind(wx.EVT_MENU, self.on_plot_sd_merged, self.view.m_menu_data_plot_sd)
+        self.view.Bind(wx.EVT_MENU, self.on_clear_rt_files, self.view.m_menu_data_clear_rt)
+        self.view.Bind(wx.EVT_MENU, self.on_clear_sd_files, self.view.m_menu_data_clear_sd)
+        self.view.Bind(wx.EVT_MENU, self.on_view_clf, self.view.m_menu_view_clf)
+        self.view.m_button1.Bind(wx.EVT_BUTTON, self.on_command_choice_send)
+        self.view.m_textCtrl_cmd.Bind(wx.EVT_TEXT_ENTER, self.on_command_send)
+
+    def on_change_node_nums(self, event):
+        self.model.options["acc_nums_txt"] = self.view.m_textCtrl_acc.GetValue()
+        self.model.options["tmp_nums_txt"] = self.view.m_textCtrl_tmp.GetValue()
+        self.model.options["str_nums_txt"] = self.view.m_textCtrl_str.GetValue()
+        self.model.options["veh_nums_txt"] = self.view.m_textCtrl_veh.GetValue()
+        self.model.parse_node_nums_txt()
+        self.model.save_config()
+        self.model.init_mesh_status_data()
+        self.model.init_other_data()
+        self.view.mesh_status_data_view()
+        self.view.m_grid2.ForceRefresh()
+        self.view.init_plot()
+
+    def on_exit(self, event):
+        self.view.Close()
+
+    def on_merge_rt_files(self, event):
+        threading.Thread(target=self._run_merge_rt_files, daemon=True).start()
+
+    def on_merge_sd_files(self, event):
+        threading.Thread(target=self._run_merge_sd_files, daemon=True).start()
+
+    def on_clear_rt_files(self, event):
+        threading.Thread(target=self._run_clear_rt_files, daemon=True).start()
+
+    def on_clear_sd_files(self, event):
+        threading.Thread(target=self._run_clear_sd_files, daemon=True).start()
+
+    def on_plot_rt_merged(self, event):
+        threading.Thread(target=self._run_plot_rt_merged, daemon=True).start()
+
+    def on_plot_sd_merged(self, event):
+        threading.Thread(target=self._run_plot_sd_merged, daemon=True).start()
+
+    def on_view_clf(self, event):
+        self.model.init_other_data()
+        self.view.init_plot()
+        self.view.figure_update()
+
+    def _broadcast(self, payload: bytes, label: str) -> None:
+        sent = self.mesh.broadcast_command(payload, label=label)
+        logger.info("command sent: %s (to %d clients)", label, sent)
+        self.view.append_status_message(f"[cmd] sent {label} to {sent} clients")
+
+    def on_command_choice_send(self, event):
+        selection = self.view.m_choice_OperationMode.GetStringSelection()
+        if selection == "DAQ Start":
+            self._broadcast(build_start_daq(), "start_daq")
+        elif selection == "DAQ Stop":
+            self._broadcast(build_stop_daq(), "stop_daq")
+        elif selection == "Realtime Stream Start":
+            self._broadcast(build_realtime_stream(Toggle.START), "rt_stream_start")
+        elif selection == "Realtime Stream Stop":
+            self._broadcast(build_realtime_stream(Toggle.STOP), "rt_stream_stop")
+        elif selection == "SD Stream Start":
+            threading.Thread(
+                target=self.mesh.stream_sd_sequential,
+                args=(build_sd_stream_start(0), "sd_stream_start_all"),
+                daemon=True,
+            ).start()
+        elif selection == "SD Stream Stop":
+            self._broadcast(build_sd_stream_stop(), "sd_stream_stop")
+        elif selection == "SD Clear All":
+            self._broadcast(build_sd_clear(), "sd_clear")
+
+    def set_daq_mode(self, node_id: str, mode: int) -> None:
+        payload = build_set_daq_mode(mode)
+        if self.mesh.send_command(node_id, payload, label=f"daq_mode={mode}"):
+            self.view.append_status_message(f"[cmd] daq_mode={mode} -> {node_id}")
+        else:
+            self.view.append_status_message(f"[cmd] failed daq_mode={mode} -> {node_id}")
+
+    def on_command_send(self, event):
+        text = self.view.m_textCtrl_cmd.GetValue().strip()
+        if not text:
+            return
+        self.view.append_status_message(f"> {text}")
+        tokens = text.split()
+        if tokens[0].lower() == "merge_sd_files":
+            self.view.m_textCtrl_cmd.SetValue("")
+            threading.Thread(target=self._run_merge_sd_files, daemon=True).start()
+            return
+        if len(tokens) >= 2 and tokens[0].lower() == "sd_stream" and tokens[1].lower() == "start":
+            hours = 0
+            if len(tokens) >= 3:
+                try:
+                    hours = int(tokens[2])
+                except ValueError:
+                    hours = 0
+            self.view.m_textCtrl_cmd.SetValue("")
+            threading.Thread(
+                target=self.mesh.stream_sd_sequential,
+                args=(build_sd_stream_start(hours), f"sd_stream_start({hours})"),
+                daemon=True,
+            ).start()
+            return
+        try:
+            payload = build_command_from_tokens(tokens)
+        except ValueError as exc:
+            self.view.append_status_message(f"[cmd] {exc}")
+            return
+        if payload is None:
+            return
+        sent = self.mesh.broadcast_command(payload, label=text)
+        self.view.append_status_message(f"[cmd] sent to {sent} clients")
+        self.view.m_textCtrl_cmd.SetValue("")
+
+    def _run_merge_sd_files(self):
+        try:
+            self.model.merge_sd_files()
+        finally:
+            wx.CallAfter(self.view.mesh_status_data_view)
+            wx.CallAfter(self.view.m_grid2.ForceRefresh)
+            wx.CallAfter(self.view.init_plot)
+            wx.CallAfter(self.view.figure_update)
+            wx.CallAfter(self.view.init_merged_plot)
+            wx.CallAfter(self.view.figure_update_merged)
+            wx.CallAfter(self.view.show_merged_plots)
+
+    def _run_merge_rt_files(self):
+        try:
+            self.model.merge_rt_streamed_files()
+        finally:
+            wx.CallAfter(self.view.mesh_status_data_view)
+            wx.CallAfter(self.view.m_grid2.ForceRefresh)
+            wx.CallAfter(self.view.init_plot)
+            wx.CallAfter(self.view.figure_update)
+            wx.CallAfter(self.view.init_merged_plot)
+            wx.CallAfter(self.view.figure_update_merged)
+            wx.CallAfter(self.view.show_merged_plots)
+
+    def _run_clear_rt_files(self):
+        try:
+            self.model.clear_rt_streamed_files()
+        finally:
+            wx.CallAfter(self.view.append_status_message, "[rt-clear] done")
+
+    def _run_clear_sd_files(self):
+        try:
+            self.model.clear_sd_streamed_files()
+        finally:
+            wx.CallAfter(self.view.append_status_message, "[sd-clear] done")
+
+    def _run_plot_rt_merged(self):
+        try:
+            self.model.load_latest_merged_rt()
+        finally:
+            wx.CallAfter(self.view.init_merged_plot)
+            wx.CallAfter(self.view.figure_update_merged)
+            wx.CallAfter(self.view.show_merged_plots)
+
+    def _run_plot_sd_merged(self):
+        try:
+            self.model.load_latest_merged_sd()
+        finally:
+            wx.CallAfter(self.view.init_merged_plot)
+            wx.CallAfter(self.view.figure_update_merged)
+            wx.CallAfter(self.view.show_merged_plots)
+
+
+def run_gui(host: str = "0.0.0.0", port: int = 3333) -> None:
+    app = wx.App()
+    Controller(host=host, port=port)
+    app.MainLoop()