diff --git a/seismo_lab.py b/seismo_lab.py index 0f757f2..a8b6c35 100644 --- a/seismo_lab.py +++ b/seismo_lab.py @@ -100,30 +100,43 @@ class BridgePanel(tk.Frame): Bridge controls and live log output. Two modes selectable at the top: - - Serial: wraps s3_bridge.py as a subprocess (two COM ports) - - TCP: MITM proxy — listens for an incoming Blastware connection, - forwards all bytes to the real device over IP, captures both - directions to raw .bin files + - Serial: wraps s3_bridge.py as a subprocess (two COM ports). + Single bridge session; use New Capture / Stop Capture to create + labelled raw-file segments on demand. + - TCP: MITM proxy — listens for Blastware on a local port, forwards to + the real device. Each incoming connection is a capture; segments + appear in the history list automatically. - Calls on_bridge_started(raw_bw_path, raw_s3_path, struct_bin_path) when - traffic begins so the parent can wire up the Analyzer in live mode. + Callbacks (all optional except on_bridge_started / on_bridge_stopped): + on_bridge_started(struct_bin_path) — bridge is up + on_bridge_stopped() — bridge stopped + on_capture_started(bw_path, s3_path, label) — a capture segment began + on_capture_complete(bw_path, s3_path, label)— a capture segment finished """ - def __init__(self, parent: tk.Widget, on_bridge_started, on_bridge_stopped, **kw): + def __init__(self, parent: tk.Widget, on_bridge_started, on_bridge_stopped, + on_capture_started=None, on_capture_complete=None, **kw): super().__init__(parent, bg=BG2, **kw) - self._on_started = on_bridge_started - self._on_stopped = on_bridge_stopped + self._on_started = on_bridge_started + self._on_stopped = on_bridge_stopped + self._on_cap_started = on_capture_started + self._on_cap_complete = on_capture_complete # serial state self.process: Optional[subprocess.Popen] = None + self._stdout_q: queue.Queue[str] = queue.Queue() # tcp state self._server: Optional[socket.socket] = None self._tcp_stop_event = threading.Event() - # unified log queue (serial reader thread + TCP pipe threads both push here) - self._log_q: queue.Queue[str] = queue.Queue() + self._tcp_log_q: queue.Queue[str] = queue.Queue() + # shared capture state + self._capturing = False + self._cap_label: Optional[str] = None + self._cap_history: list[dict] = [] # {label, status, bw, s3} # mode self._mode = tk.StringVar(value="serial") self._build() - self._poll_log_q() + self._poll_stdout() + self._poll_tcp_log() # ── build ───────────────────────────────────────────────────────────── @@ -196,16 +209,6 @@ class BridgePanel(tk.Frame): tk.Button(cfg, text="Browse", bg=BG3, fg=FG, relief="flat", cursor="hand2", font=MONO, command=self._choose_dir).grid(row=2, column=5, **pad) - # Row 3: raw capture checkboxes - self._raw_bw_on = tk.BooleanVar(value=True) - self._raw_s3_on = tk.BooleanVar(value=True) - tk.Checkbutton(cfg, text="Capture BW->S3 raw", variable=self._raw_bw_on, - bg=BG2, fg=FG, selectcolor=BG3, activebackground=BG2, - font=MONO).grid(row=3, column=0, columnspan=2, sticky="w", **pad) - tk.Checkbutton(cfg, text="Capture S3->BW raw", variable=self._raw_s3_on, - bg=BG2, fg=FG, selectcolor=BG3, activebackground=BG2, - font=MONO).grid(row=3, column=2, columnspan=2, sticky="w", **pad) - # Buttons + status btn_row = tk.Frame(self, bg=BG2) btn_row.pack(side=tk.TOP, fill=tk.X, padx=4, pady=2) @@ -220,6 +223,18 @@ class BridgePanel(tk.Frame): command=self.stop_bridge, state="disabled") self.stop_btn.pack(side=tk.LEFT, padx=4) + tk.Frame(btn_row, bg=BG2, width=16).pack(side=tk.LEFT) # spacer + + self.cap_btn = tk.Button(btn_row, text="● New Capture", bg=ORANGE, fg="#000000", + relief="flat", padx=10, cursor="hand2", font=MONO_B, + command=self._start_capture, state="disabled") + self.cap_btn.pack(side=tk.LEFT, padx=4) + + self.stop_cap_btn = tk.Button(btn_row, text="■ Stop Capture", bg=BG3, fg=RED, + relief="flat", padx=10, cursor="hand2", font=MONO_B, + command=self._stop_capture, state="disabled") + self.stop_cap_btn.pack(side=tk.LEFT, padx=4) + self.mark_btn = tk.Button(btn_row, text="Add Mark", bg=BG3, fg=FG, relief="flat", padx=10, cursor="hand2", font=MONO, command=self.add_mark, state="disabled") @@ -229,9 +244,34 @@ class BridgePanel(tk.Frame): tk.Label(btn_row, textvariable=self.status_var, bg=BG2, fg=FG_DIM, font=MONO).pack(side=tk.LEFT, padx=10) + # Capture history list + hist_outer = tk.Frame(self, bg=BG2) + hist_outer.pack(side=tk.TOP, fill=tk.X, padx=4, pady=(2, 0)) + + tk.Label(hist_outer, text="Captures:", bg=BG2, fg=FG_DIM, + font=MONO_SM, anchor="w").pack(side=tk.LEFT, padx=(4, 6)) + + hist_inner = tk.Frame(hist_outer, bg=BG2) + hist_inner.pack(side=tk.LEFT, fill=tk.X, expand=True) + + self._hist_lb = tk.Listbox( + hist_inner, bg=BG3, fg=FG, font=MONO_SM, + height=3, relief="flat", selectbackground=BG, + selectforeground=ACCENT, activestyle="none", + highlightthickness=0, + ) + hist_vsb = ttk.Scrollbar(hist_inner, orient="vertical", command=self._hist_lb.yview) + self._hist_lb.configure(yscrollcommand=hist_vsb.set) + hist_vsb.pack(side=tk.RIGHT, fill=tk.Y) + self._hist_lb.pack(side=tk.LEFT, fill=tk.X, expand=True) + self._hist_lb.bind("", self._on_hist_dblclick) + + tk.Label(hist_outer, text="dbl-click to reload", bg=BG2, fg=FG_DIM, + font=MONO_SM, anchor="e").pack(side=tk.RIGHT, padx=6) + # Log output self.log_view = scrolledtext.ScrolledText( - self, height=18, font=MONO_SM, + self, height=14, font=MONO_SM, bg=BG, fg=FG, insertbackground=FG, relief="flat", state="disabled", ) @@ -258,25 +298,21 @@ class BridgePanel(tk.Frame): self.log_view.see(tk.END) self.log_view.configure(state="disabled") - # ── unified log-queue polling (serial subprocess + TCP threads both push here) + def _refresh_hist(self) -> None: + self._hist_lb.delete(0, tk.END) + for entry in self._cap_history: + icon = "\U0001f534" if entry["status"] == "recording" else "✅" + self._hist_lb.insert(tk.END, f" {icon} {entry['label'] or '(unlabeled)'}") + if self._cap_history: + self._hist_lb.see(tk.END) - def _poll_log_q(self) -> None: - try: - while True: - msg = self._log_q.get_nowait() - if msg == "<>": - self._bridge_ended() - self._on_stopped() - elif msg == "<>": - if self._server is not None: - self.status_var.set(f"Listening on :{self.listen_port_var.get()}") - self._on_stopped() - else: - self._append_log(msg) - except queue.Empty: - pass - finally: - self.after(100, self._poll_log_q) + def _on_hist_dblclick(self, _e=None) -> None: + sel = self._hist_lb.curselection() + if not sel: + return + entry = self._cap_history[sel[0]] + if entry["status"] == "done" and entry["bw"] and entry["s3"] and self._on_cap_complete: + self._on_cap_complete(entry["bw"], entry["s3"], entry["label"]) # ── bridge control (delegates to serial or TCP) ─────────────────────── @@ -296,9 +332,42 @@ class BridgePanel(tk.Frame): self.status_var.set("Stopped") self.start_btn.configure(state="normal") self.stop_btn.configure(state="disabled", bg=BG3) + self.cap_btn.configure(state="disabled") + self.stop_cap_btn.configure(state="disabled", bg=BG3) self.mark_btn.configure(state="disabled") + self._capturing = False + self._cap_label = None self._append_log("== Bridge stopped ==\n") + # ── capture lifecycle (shared by serial and TCP) ────────────────────── + + def _on_cap_started_msg(self, bw_path: str, s3_path: str) -> None: + for entry in reversed(self._cap_history): + if entry["status"] == "recording" and entry["bw"] is None: + entry["bw"] = bw_path + entry["s3"] = s3_path + break + self._refresh_hist() + if self._on_cap_started: + self._on_cap_started(bw_path, s3_path, self._cap_label or "") + + def _on_cap_stopped_msg(self, bw_path: str, s3_path: str) -> None: + label = self._cap_label or "capture" + for entry in reversed(self._cap_history): + if entry["status"] == "recording": + entry["status"] = "done" + entry["bw"] = bw_path + entry["s3"] = s3_path + break + self._refresh_hist() + self._capturing = False + self._cap_label = None + self.cap_btn.configure(state="normal") + self.stop_cap_btn.configure(state="disabled", bg=BG3) + self._append_log(f"[CAPTURE] Done: {label!r} — ready in Analyzer\n") + if self._on_cap_complete: + self._on_cap_complete(bw_path, s3_path, label) + # ── serial mode ─────────────────────────────────────────────────────── def _start_serial(self) -> None: @@ -321,14 +390,6 @@ class BridgePanel(tk.Frame): args = [sys.executable, str(BRIDGE_PATH), "--bw", bw, "--s3", s3, "--baud", baud, "--logdir", logdir] - raw_bw_path = raw_s3_path = None - if self._raw_bw_on.get(): - raw_bw_path = os.path.join(logdir, f"raw_bw_{ts}.bin") - args += ["--raw-bw", raw_bw_path] - if self._raw_s3_on.get(): - raw_s3_path = os.path.join(logdir, f"raw_s3_{ts}.bin") - args += ["--raw-s3", raw_s3_path] - struct_bin_path = os.path.join(logdir, f"s3_session_{ts}.bin") try: @@ -348,9 +409,10 @@ class BridgePanel(tk.Frame): self.status_var.set(f"Running — {bw} <-> {s3}") self.start_btn.configure(state="disabled") self.stop_btn.configure(state="normal", bg=RED) - self.mark_btn.configure(state="normal") + self.cap_btn.configure(state="normal") self._append_log(f"== Bridge started [{ts}] ==\n") - self._on_started(raw_bw_path, raw_s3_path, struct_bin_path) + self._append_log(" Click 'New Capture' when ready to record.\n") + self._on_started(struct_bin_path) def _stop_serial(self) -> None: if self.process and self.process.poll() is None: @@ -366,8 +428,79 @@ class BridgePanel(tk.Frame): if not self.process or not self.process.stdout: return for line in self.process.stdout: - self._log_q.put(line) - self._log_q.put("<>") + self._stdout_q.put(line) + self._stdout_q.put("<>") + + def _poll_stdout(self) -> None: + try: + while True: + line = self._stdout_q.get_nowait() + if line == "<>": + self._bridge_ended() + self._on_stopped() + break + + stripped = line.strip() + if stripped.startswith("[CAP_START] ") and "\t" in stripped: + parts = stripped[12:].split("\t", 1) + if len(parts) == 2: + self._on_cap_started_msg(parts[0].strip(), parts[1].strip()) + elif stripped.startswith("[CAP_STOP] ") and "\t" in stripped: + parts = stripped[11:].split("\t", 1) + if len(parts) == 2: + self._on_cap_stopped_msg(parts[0].strip(), parts[1].strip()) + + self._append_log(line) + except queue.Empty: + pass + finally: + self.after(100, self._poll_stdout) + + def _start_capture(self) -> None: + if not self.process or self.process.poll() is not None: + return + label = simpledialog.askstring( + "New Capture", + "Label for this capture\n(e.g. 'copy_event_download').\nLeave blank for timestamp only:", + parent=self, + ) + if label is None: + return + label = label.strip() + try: + self.process.stdin.write(f"CAP_START:{label}\n") + self.process.stdin.flush() + except Exception as e: + messagebox.showerror("Error", f"Failed to start capture:\n{e}") + return + self._capturing = True + self._cap_label = label or datetime.datetime.now().strftime("%H%M%S") + self.cap_btn.configure(state="disabled") + self.stop_cap_btn.configure(state="normal", bg=RED) + self.mark_btn.configure(state="normal") + self._append_log(f"[CAPTURE] Starting: {self._cap_label!r}...\n") + self._cap_history.append({"label": self._cap_label, "status": "recording", + "bw": None, "s3": None}) + self._refresh_hist() + + def _stop_capture(self) -> None: + if self._mode.get() == "tcp": + # TCP: close the server so the current session ends naturally + self._tcp_stop_event.set() + if self._server: + try: + self._server.close() + except OSError: + pass + self._server = None + return + if not self.process or self.process.poll() is not None: + return + try: + self.process.stdin.write("CAP_STOP\n") + self.process.stdin.flush() + except Exception as e: + messagebox.showerror("Error", f"Failed to stop capture:\n{e}") # ── TCP mode ────────────────────────────────────────────────────────── @@ -401,23 +534,21 @@ class BridgePanel(tk.Frame): self._tcp_stop_event.clear() self.start_btn.configure(state="disabled") self.stop_btn.configure(state="normal", bg=RED) - self.mark_btn.configure(state="normal") self.status_var.set(f"Listening on :{listen_port}") ts = datetime.datetime.now().strftime("%Y%m%d_%H%M%S") self._append_log( f"== TCP Bridge started [{ts}]\n" f" Listening on 0.0.0.0:{listen_port}\n" - f" Forwarding to {remote_host}:{remote_port}\n==\n" + f" Forwarding to {remote_host}:{remote_port}\n" + f" Each Blastware connection is automatically captured.\n==\n" ) + self._on_started(None) - logdir = self.logdir_var.get().strip() or "." - raw_bw_on = self._raw_bw_on.get() - raw_s3_on = self._raw_s3_on.get() - + logdir = self.logdir_var.get().strip() or "." threading.Thread( target=self._accept_loop, - args=(srv, remote_host, remote_port, logdir, raw_bw_on, raw_s3_on), + args=(srv, remote_host, remote_port, logdir), daemon=True, ).start() @@ -432,8 +563,8 @@ class BridgePanel(tk.Frame): self._bridge_ended() self._on_stopped() - def _accept_loop(self, srv: socket.socket, remote_host: str, remote_port: int, - logdir: str, raw_bw_on: bool, raw_s3_on: bool) -> None: + def _accept_loop(self, srv: socket.socket, remote_host: str, + remote_port: int, logdir: str) -> None: while not self._tcp_stop_event.is_set(): try: client_sock, addr = srv.accept() @@ -443,82 +574,98 @@ class BridgePanel(tk.Frame): break peer = f"{addr[0]}:{addr[1]}" - self._log_q.put(f"[TCP] Blastware connected from {peer}\n") + self._tcp_log_q.put(f"[TCP] Blastware connected from {peer}\n") try: dev_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) dev_sock.connect((remote_host, remote_port)) except OSError as e: - self._log_q.put(f"[TCP] Cannot reach device {remote_host}:{remote_port}: {e}\n") + self._tcp_log_q.put(f"[TCP] Cannot reach device {remote_host}:{remote_port}: {e}\n") client_sock.close() continue - self._log_q.put(f"[TCP] Connected to device at {remote_host}:{remote_port}\n") + self._tcp_log_q.put(f"[TCP] Connected to device at {remote_host}:{remote_port}\n") ts = datetime.datetime.now().strftime("%Y%m%d_%H%M%S") os.makedirs(logdir, exist_ok=True) - raw_bw_path = os.path.join(logdir, f"raw_bw_{ts}.bin") if raw_bw_on else None - raw_s3_path = os.path.join(logdir, f"raw_s3_{ts}.bin") if raw_s3_on else None + bw_path = os.path.join(logdir, f"raw_bw_{ts}.bin") + s3_path = os.path.join(logdir, f"raw_s3_{ts}.bin") - self.after(0, self._notify_tcp_session_start, - raw_bw_path, raw_s3_path, peer, remote_host, remote_port) - self._run_tcp_session(client_sock, dev_sock, raw_bw_path, raw_s3_path, ts) - self._log_q.put("<>") + # Auto-register in history as recording + label = f"tcp_{ts}" + self.after(0, self._tcp_session_started, bw_path, s3_path, label, peer, remote_host, remote_port) - def _notify_tcp_session_start(self, raw_bw_path, raw_s3_path, - peer, remote_host, remote_port) -> None: + self._run_tcp_session(client_sock, dev_sock, bw_path, s3_path, ts) + + self._tcp_log_q.put(f"<>\t{bw_path}\t{s3_path}\t{label}") + + def _tcp_session_started(self, bw_path, s3_path, label, peer, remote_host, remote_port) -> None: self.status_var.set(f"Active: {peer} → {remote_host}:{remote_port}") - self._on_started(raw_bw_path, raw_s3_path, None) + self._cap_label = label + self._cap_history.append({"label": label, "status": "recording", + "bw": bw_path, "s3": s3_path}) + self._refresh_hist() + self.mark_btn.configure(state="normal") + self.stop_cap_btn.configure(state="normal", bg=RED) + if self._on_cap_started: + self._on_cap_started(bw_path, s3_path, label) def _run_tcp_session(self, bw_sock: socket.socket, dev_sock: socket.socket, - raw_bw_path: Optional[str], raw_s3_path: Optional[str], - ts: str) -> None: - bw_fh = open(raw_bw_path, "wb") if raw_bw_path else None - s3_fh = open(raw_s3_path, "wb") if raw_s3_path else None + bw_path: str, s3_path: str, ts: str) -> None: bw_bytes = [0] s3_bytes = [0] - def _pipe(src, dst, fh, counter): - try: - while True: - data = src.recv(4096) - if not data: - break - dst.sendall(data) - if fh: + with open(bw_path, "wb") as bw_fh, open(s3_path, "wb") as s3_fh: + def _pipe(src, dst, fh, counter): + try: + while True: + data = src.recv(4096) + if not data: + break + dst.sendall(data) fh.write(data) fh.flush() - counter[0] += len(data) - except OSError: - pass - finally: - try: - dst.shutdown(socket.SHUT_WR) + counter[0] += len(data) except OSError: pass + finally: + try: + dst.shutdown(socket.SHUT_WR) + except OSError: + pass - t_bw = threading.Thread(target=_pipe, args=(bw_sock, dev_sock, bw_fh, bw_bytes), daemon=True) - t_s3 = threading.Thread(target=_pipe, args=(dev_sock, bw_sock, s3_fh, s3_bytes), daemon=True) - t_bw.start() - t_s3.start() - t_bw.join() - t_s3.join() + t_bw = threading.Thread(target=_pipe, args=(bw_sock, dev_sock, bw_fh, bw_bytes), daemon=True) + t_s3 = threading.Thread(target=_pipe, args=(dev_sock, bw_sock, s3_fh, s3_bytes), daemon=True) + t_bw.start() + t_s3.start() + t_bw.join() + t_s3.join() bw_sock.close() dev_sock.close() - if bw_fh: - bw_fh.close() - if s3_fh: - s3_fh.close() - - self._log_q.put( + self._tcp_log_q.put( f"[TCP] Session {ts} done " f"BW→dev: {bw_bytes[0]} bytes dev→BW: {s3_bytes[0]} bytes\n" ) - if raw_bw_path: - self._log_q.put(f"[TCP] BW capture: {raw_bw_path}\n") - if raw_s3_path: - self._log_q.put(f"[TCP] S3 capture: {raw_s3_path}\n") + + def _poll_tcp_log(self) -> None: + try: + while True: + msg = self._tcp_log_q.get_nowait() + if msg.startswith("<>"): + parts = msg.split("\t") + if len(parts) == 4: + _, bw_path, s3_path, label = parts + self._on_cap_stopped_msg(bw_path, s3_path) + if self._server is not None: + self.status_var.set(f"Listening on :{self.listen_port_var.get()}") + self.stop_cap_btn.configure(state="disabled", bg=BG3) + else: + self._append_log(msg) + except queue.Empty: + pass + finally: + self.after(100, self._poll_tcp_log) # ── marks ───────────────────────────────────────────────────────────── @@ -2116,6 +2263,8 @@ class SeismoLab(tk.Tk): nb, on_bridge_started=self._on_bridge_started, on_bridge_stopped=self._on_bridge_stopped, + on_capture_started=self._on_capture_started, + on_capture_complete=self._on_capture_complete, ) nb.add(self._bridge_panel, text=" Bridge ") @@ -2137,16 +2286,27 @@ class SeismoLab(tk.Tk): self._nb = nb self.protocol("WM_DELETE_WINDOW", self._on_close) - def _on_bridge_started(self, raw_bw: Optional[str], raw_s3: Optional[str], - struct_bin: Optional[str] = None) -> None: - """Bridge started — inject paths into analyzer and start live mode.""" - self._analyzer_panel.set_live_files(raw_bw, raw_s3, struct_bin) - # Switch to Analyzer tab so the user can watch it update - self._nb.select(1) + def _on_bridge_started(self, struct_bin: Optional[str] = None) -> None: + """Bridge is up — store struct bin path; stay on Bridge tab.""" + if struct_bin: + self._analyzer_panel.bin_var.set(struct_bin) def _on_bridge_stopped(self) -> None: self._analyzer_panel.stop_live() + def _on_capture_started(self, bw_path: str, s3_path: str, label: str) -> None: + """A capture segment began — wire live mode and switch to Analyzer.""" + self._analyzer_panel.set_live_files(bw_path, s3_path) + self._nb.select(1) + + def _on_capture_complete(self, bw_path: str, s3_path: str, label: str) -> None: + """A capture segment finished — run full analysis and switch to Analyzer.""" + self._analyzer_panel.stop_live() + self._analyzer_panel.s3_var.set(s3_path) + self._analyzer_panel.bw_var.set(bw_path) + self._analyzer_panel._run_analyze() + self._nb.select(1) + def _on_console_send_to_analyzer(self, raw_s3_path: str) -> None: """Console captured bytes → inject into Analyzer S3 field and switch tab.""" self._analyzer_panel.s3_var.set(raw_s3_path)