diff --git a/parsers/s3_analyzer.py b/parsers/s3_analyzer.py index c86477d..6feb32b 100644 --- a/parsers/s3_analyzer.py +++ b/parsers/s3_analyzer.py @@ -53,7 +53,9 @@ SUB_TABLE: dict[int, tuple[str, str, str]] = { 0x82: ("TRIGGER_CONFIG_WRITE", "BW→S3", "0x1C bytes; trigger config block; mirrors SUB 1C"), 0x83: ("TRIGGER_WRITE_CONFIRM", "BW→S3", "Short frame; commit step after 0x82"), # S3→BW responses + 0x5A: ("BULK_WAVEFORM_STREAM", "BW→S3", "Bulk waveform chunk request; response is A5 stream"), 0xA4: ("POLL_RESPONSE", "S3→BW", "Response to SUB 5B poll"), + 0xA5: ("BULK_WAVEFORM_RESPONSE", "S3→BW", "Response to SUB 5A; waveform chunks + metadata"), 0xFE: ("FULL_CONFIG_RESPONSE", "S3→BW", "Response to SUB 01"), 0xF9: ("CHANNEL_CONFIG_RESPONSE", "S3→BW", "Response to SUB 06"), 0xF7: ("EVENT_INDEX_RESPONSE", "S3→BW", "Response to SUB 08; contains backlight/power-save"), diff --git a/parsers/s3_parser.py b/parsers/s3_parser.py index 2f32933..2bb3de1 100644 --- a/parsers/s3_parser.py +++ b/parsers/s3_parser.py @@ -33,7 +33,7 @@ STX = 0x02 ETX = 0x03 ACK = 0x41 -__version__ = "0.2.3" +__version__ = "0.2.5" @dataclass @@ -184,9 +184,9 @@ def validate_bw_body_auto(body: bytes) -> Optional[Tuple[bytes, bytes, str]]: def parse_s3(blob: bytes, trailer_len: int) -> List[Frame]: frames: List[Frame] = [] - IDLE = 0 - IN_FRAME = 1 - AFTER_DLE = 2 + IDLE = 0 + IN_FRAME = 1 + IN_FRAME_DLE = 2 # saw DLE inside frame — waiting for next byte state = IDLE body = bytearray() @@ -206,66 +206,63 @@ def parse_s3(blob: bytes, trailer_len: int) -> List[Frame]: state = IN_FRAME i += 2 continue + # ACK bytes, boot strings, garbage — silently ignored elif state == IN_FRAME: if b == DLE: - state = AFTER_DLE + state = IN_FRAME_DLE i += 1 continue - body.append(b) - - else: # AFTER_DLE - if b == DLE: - body.append(DLE) - state = IN_FRAME - i += 1 - continue - if b == ETX: + # Bare ETX = real S3 frame terminator (confirmed from S3FrameParser) end_offset = i + 1 trailer_start = i + 1 trailer_end = trailer_start + trailer_len trailer = blob[trailer_start:trailer_end] - chk_valid = None - chk_type = None - chk_hex = None - payload = bytes(body) - - if len(body) >= 1: - received_chk = body[-1] - computed_chk = checksum8_sum(bytes(body[:-1])) - if computed_chk == received_chk: - chk_valid = True - chk_type = "SUM8" - chk_hex = f"{received_chk:02x}" - payload = bytes(body[:-1]) - else: - chk_valid = False - + # S3 checksums are deliberately not validated here. + # Large S3 responses (A5 bulk waveform, E5 compliance) embed + # inner DLE+ETX sub-frame terminators whose trailing 0x03 byte + # lands where the parser would expect the SUM8 checksum, causing + # false failures. The live protocol (protocol.py _validate_frame) + # also skips S3 checksum enforcement for the same reason. frames.append(Frame( index=idx, start_offset=start_offset, end_offset=end_offset, payload_raw=bytes(body), - payload=payload, + payload=bytes(body), trailer=trailer, - checksum_valid=chk_valid, - checksum_type=chk_type, - checksum_hex=chk_hex + checksum_valid=None, + checksum_type=None, + checksum_hex=None )) idx += 1 state = IDLE i = trailer_end continue + body.append(b) + else: # IN_FRAME_DLE + if b == DLE: + # DLE DLE → literal 0x10 in payload + body.append(DLE) + state = IN_FRAME + i += 1 + continue + if b == ETX: + # DLE+ETX inside a frame = inner-frame terminator (A4/E5 sub-frames). + # Treat as literal data, NOT the outer frame end. + body.append(DLE) + body.append(ETX) + state = IN_FRAME + i += 1 + continue # Unexpected DLE + byte → treat as literal data body.append(DLE) body.append(b) state = IN_FRAME - i += 1 - continue i += 1 diff --git a/seismo_lab.py b/seismo_lab.py index 48ad0e9..723a921 100644 --- a/seismo_lab.py +++ b/seismo_lab.py @@ -22,6 +22,7 @@ from __future__ import annotations import datetime import os import queue +import socket import subprocess import sys import threading @@ -96,12 +97,25 @@ class AnalyzerState: class BridgePanel(tk.Frame): """ - All bridge controls and live log output. - Calls on_bridge_started(struct_bin_path) when the bridge starts. - Calls on_capture_started(bw_path, s3_path, label) when a capture begins. - Calls on_capture_complete(bw_path, s3_path, label) when a capture ends. + Bridge controls and live log output. + + Two modes selectable at the top: + - 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. + + 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, + on_capture_started=None, on_capture_complete=None, **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) @@ -111,12 +125,29 @@ class BridgePanel(tk.Frame): self._on_cap_complete = on_capture_complete # (bw, s3, label) 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() + self._tcp_log_q: queue.Queue[str] = queue.Queue() + # tcp capture file handles — written only when capture is active + self._tcp_cap_lock = threading.Lock() + self._tcp_cap_bw_fh = None + self._tcp_cap_s3_fh = None + self._tcp_cap_bw_path: Optional[str] = None + self._tcp_cap_s3_path: Optional[str] = None + # 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") # Capture state self._capturing = False self._cap_label: Optional[str] = None self._cap_history: list[dict] = [] # {label, status, bw, s3} self._build() self._poll_stdout() + self._poll_tcp_log() # ── build ───────────────────────────────────────────────────────────── @@ -126,33 +157,68 @@ class BridgePanel(tk.Frame): cfg = tk.Frame(self, bg=BG2) cfg.pack(side=tk.TOP, fill=tk.X, padx=4, pady=4) - # Row 0: ports - tk.Label(cfg, text="BW COM:", bg=BG2, fg=FG, font=MONO).grid(row=0, column=0, sticky="e", **pad) + # Row 0: mode selector + mode_row = tk.Frame(cfg, bg=BG2) + mode_row.grid(row=0, column=0, columnspan=6, sticky="w", padx=6, pady=(4, 0)) + tk.Label(mode_row, text="Mode:", bg=BG2, fg=FG, font=MONO).pack(side=tk.LEFT, padx=(0, 8)) + tk.Radiobutton(mode_row, text="Serial", variable=self._mode, value="serial", + bg=BG2, fg=FG, selectcolor=BG3, activebackground=BG2, + font=MONO, command=self._on_mode_change).pack(side=tk.LEFT, padx=4) + tk.Radiobutton(mode_row, text="TCP", variable=self._mode, value="tcp", + bg=BG2, fg=FG, selectcolor=BG3, activebackground=BG2, + font=MONO, command=self._on_mode_change).pack(side=tk.LEFT, padx=4) + + # Row 1a: serial connection fields (shown by default) + self._serial_frame = tk.Frame(cfg, bg=BG2) + self._serial_frame.grid(row=1, column=0, columnspan=6, sticky="w") + + tk.Label(self._serial_frame, text="BW COM:", bg=BG2, fg=FG, font=MONO).grid(row=0, column=0, sticky="e", **pad) self.bw_var = tk.StringVar(value="COM4") - tk.Entry(cfg, textvariable=self.bw_var, width=10, + tk.Entry(self._serial_frame, textvariable=self.bw_var, width=10, bg=BG3, fg=FG, insertbackground=FG, relief="flat", font=MONO).grid(row=0, column=1, sticky="w", **pad) - tk.Label(cfg, text="S3 COM:", bg=BG2, fg=FG, font=MONO).grid(row=0, column=2, sticky="e", **pad) + tk.Label(self._serial_frame, text="S3 COM:", bg=BG2, fg=FG, font=MONO).grid(row=0, column=2, sticky="e", **pad) self.s3_var = tk.StringVar(value="COM5") - tk.Entry(cfg, textvariable=self.s3_var, width=10, + tk.Entry(self._serial_frame, textvariable=self.s3_var, width=10, bg=BG3, fg=FG, insertbackground=FG, relief="flat", font=MONO).grid(row=0, column=3, sticky="w", **pad) - tk.Label(cfg, text="Baud:", bg=BG2, fg=FG, font=MONO).grid(row=0, column=4, sticky="e", **pad) + tk.Label(self._serial_frame, text="Baud:", bg=BG2, fg=FG, font=MONO).grid(row=0, column=4, sticky="e", **pad) self.baud_var = tk.StringVar(value="38400") - tk.Entry(cfg, textvariable=self.baud_var, width=8, + tk.Entry(self._serial_frame, textvariable=self.baud_var, width=8, bg=BG3, fg=FG, insertbackground=FG, relief="flat", font=MONO).grid(row=0, column=5, sticky="w", **pad) - # Row 1: log dir - tk.Label(cfg, text="Log dir:", bg=BG2, fg=FG, font=MONO).grid(row=1, column=0, sticky="e", **pad) + # Row 1b: TCP connection fields (hidden until TCP mode selected) + self._tcp_frame = tk.Frame(cfg, bg=BG2) + + tk.Label(self._tcp_frame, text="Listen port:", bg=BG2, fg=FG, font=MONO).grid(row=0, column=0, sticky="e", **pad) + self.listen_port_var = tk.StringVar(value="9034") + tk.Entry(self._tcp_frame, textvariable=self.listen_port_var, width=8, + bg=BG3, fg=FG, insertbackground=FG, relief="flat", + font=MONO).grid(row=0, column=1, sticky="w", **pad) + + tk.Label(self._tcp_frame, text="Device host:", bg=BG2, fg=FG, font=MONO).grid(row=0, column=2, sticky="e", **pad) + self.remote_host_var = tk.StringVar(value="63.43.212.232") + tk.Entry(self._tcp_frame, textvariable=self.remote_host_var, width=18, + bg=BG3, fg=FG, insertbackground=FG, relief="flat", + font=MONO).grid(row=0, column=3, sticky="w", **pad) + + tk.Label(self._tcp_frame, text="Port:", bg=BG2, fg=FG, font=MONO).grid(row=0, column=4, sticky="e", **pad) + self.remote_port_var = tk.StringVar(value="9034") + tk.Entry(self._tcp_frame, textvariable=self.remote_port_var, width=8, + bg=BG3, fg=FG, insertbackground=FG, relief="flat", + font=MONO).grid(row=0, column=5, sticky="w", **pad) + + # Row 2: log dir + tk.Label(cfg, text="Log dir:", bg=BG2, fg=FG, font=MONO).grid(row=2, column=0, sticky="e", **pad) self.logdir_var = tk.StringVar(value=str(SCRIPT_DIR / "bridges" / "captures")) tk.Entry(cfg, textvariable=self.logdir_var, width=40, bg=BG3, fg=FG, insertbackground=FG, relief="flat", - font=MONO).grid(row=1, column=1, columnspan=4, sticky="we", **pad) + font=MONO).grid(row=2, column=1, columnspan=4, sticky="we", **pad) tk.Button(cfg, text="Browse", bg=BG3, fg=FG, relief="flat", cursor="hand2", - font=MONO, command=self._choose_dir).grid(row=1, column=5, **pad) + font=MONO, command=self._choose_dir).grid(row=2, column=5, **pad) # Row 2: buttons + status btn_row = tk.Frame(self, bg=BG2) @@ -170,6 +236,18 @@ class BridgePanel(tk.Frame): 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) + + 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") @@ -211,11 +289,37 @@ class BridgePanel(tk.Frame): 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) + + # 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=14, font=MONO_SM, self, height=14, font=MONO_SM, bg=BG, fg=FG, insertbackground=FG, relief="flat", state="disabled", @@ -224,6 +328,14 @@ class BridgePanel(tk.Frame): # ── helpers ─────────────────────────────────────────────────────────── + def _on_mode_change(self) -> None: + if self._mode.get() == "serial": + self._tcp_frame.grid_remove() + self._serial_frame.grid(row=1, column=0, columnspan=6, sticky="w") + else: + self._serial_frame.grid_remove() + self._tcp_frame.grid(row=1, column=0, columnspan=6, sticky="w") + def _choose_dir(self) -> None: path = filedialog.askdirectory(initialdir=self.logdir_var.get()) if path: @@ -235,9 +347,79 @@ class BridgePanel(tk.Frame): self.log_view.see(tk.END) self.log_view.configure(state="disabled") - # ── bridge control ──────────────────────────────────────────────────── + 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 _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) ─────────────────────── def start_bridge(self) -> None: + if self._mode.get() == "tcp": + self._start_tcp() + else: + self._start_serial() + + def stop_bridge(self) -> None: + if self._mode.get() == "tcp": + self._stop_tcp() + else: + self._stop_serial() + + def _bridge_ended(self) -> None: + 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: if self.process and self.process.poll() is None: messagebox.showinfo("Bridge", "Bridge is already running.") return @@ -280,8 +462,10 @@ class BridgePanel(tk.Frame): self.start_btn.configure(state="disabled") self.stop_btn.configure(state="normal", bg=RED) self.cap_btn.configure(state="normal") + self.cap_btn.configure(state="normal") self._append_log(f"== Bridge started [{ts}] ==\n") - self._append_log(" Click 'New Capture' when ready to record a setting change.\n") + self._append_log(" Click 'New Capture' when ready to record.\n") + self._on_started(struct_bin_path) # Notify parent — no raw files yet, just the structured bin path self._on_started(struct_bin_path) @@ -439,16 +623,231 @@ class BridgePanel(tk.Frame): def add_mark(self) -> None: if not self.process or not self.process.stdin or self.process.poll() is not None: return + label = label.strip() + self._capturing = True + self._cap_label = label or datetime.datetime.now().strftime("%H%M%S") + + if self._mode.get() == "tcp": + # TCP: open the capture files now; pipe threads write here while active + logdir = self.logdir_var.get().strip() or "." + os.makedirs(logdir, exist_ok=True) + ts = datetime.datetime.now().strftime("%Y%m%d_%H%M%S") + safe_label = self._cap_label.replace(" ", "_") if self._cap_label else "" + suffix = f"_{safe_label}" if safe_label else "" + bw_path = os.path.join(logdir, f"raw_bw_{ts}{suffix}.bin") + s3_path = os.path.join(logdir, f"raw_s3_{ts}{suffix}.bin") + with self._tcp_cap_lock: + self._tcp_cap_bw_fh = open(bw_path, "wb") + self._tcp_cap_s3_fh = open(s3_path, "wb") + self._tcp_cap_bw_path = bw_path + self._tcp_cap_s3_path = s3_path + self._cap_history.append({"label": self._cap_label, "status": "recording", + "bw": bw_path, "s3": s3_path}) + self._refresh_hist() + self._on_cap_started_msg(bw_path, s3_path) + else: + if not self.process or self.process.poll() is not None: + return + 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._cap_history.append({"label": self._cap_label, "status": "recording", + "bw": None, "s3": None}) + self._refresh_hist() + + 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") + + def _stop_capture(self) -> None: + if self._mode.get() == "tcp": + with self._tcp_cap_lock: + bw_path = self._tcp_cap_bw_path + s3_path = self._tcp_cap_s3_path + if self._tcp_cap_bw_fh: + self._tcp_cap_bw_fh.close() + self._tcp_cap_bw_fh = None + if self._tcp_cap_s3_fh: + self._tcp_cap_s3_fh.close() + self._tcp_cap_s3_fh = None + self._tcp_cap_bw_path = None + self._tcp_cap_s3_path = None + if bw_path and s3_path: + self._on_cap_stopped_msg(bw_path, s3_path) + 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 ────────────────────────────────────────────────────────── + + def _start_tcp(self) -> None: + if self._server is not None: + messagebox.showinfo("Bridge", "TCP bridge is already listening.") + return + + try: + listen_port = int(self.listen_port_var.get().strip()) + remote_host = self.remote_host_var.get().strip() + remote_port = int(self.remote_port_var.get().strip()) + except ValueError: + messagebox.showerror("Error", "Invalid port number.") + return + if not remote_host: + messagebox.showerror("Error", "Please enter the device host.") + return + + try: + srv = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + srv.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) + srv.bind(("0.0.0.0", listen_port)) + srv.listen(5) + srv.settimeout(1.0) + except OSError as e: + messagebox.showerror("Error", f"Cannot bind to port {listen_port}:\n{e}") + return + + self._server = srv + self._tcp_stop_event.clear() + self.start_btn.configure(state="disabled") + self.stop_btn.configure(state="normal", bg=RED) + self.cap_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" + f" Click 'New Capture' before the operation you want to record.\n==\n" + ) + self._on_started(None) + + threading.Thread( + target=self._accept_loop, + args=(srv, remote_host, remote_port), + daemon=True, + ).start() + + def _stop_tcp(self) -> None: + # Close any open capture files first + with self._tcp_cap_lock: + if self._tcp_cap_bw_fh: + self._tcp_cap_bw_fh.close() + self._tcp_cap_bw_fh = None + if self._tcp_cap_s3_fh: + self._tcp_cap_s3_fh.close() + self._tcp_cap_s3_fh = None + self._tcp_stop_event.set() + if self._server: + try: + self._server.close() + except OSError: + pass + self._server = None + self._bridge_ended() + self._on_stopped() + + def _accept_loop(self, srv: socket.socket, remote_host: str, remote_port: int) -> None: + while not self._tcp_stop_event.is_set(): + try: + client_sock, addr = srv.accept() + except socket.timeout: + continue + except OSError: + break + + peer = f"{addr[0]}:{addr[1]}" + 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._tcp_log_q.put(f"[TCP] Cannot reach device {remote_host}:{remote_port}: {e}\n") + client_sock.close() + continue + + self._tcp_log_q.put(f"[TCP] Connected to device at {remote_host}:{remote_port}\n") + self._run_tcp_session(client_sock, dev_sock) + self._tcp_log_q.put(f"[TCP] Connection from {peer} closed\n") + + def _run_tcp_session(self, bw_sock: socket.socket, dev_sock: socket.socket) -> None: + """Forward bytes in both directions; write to capture files only when active.""" + bw_bytes = [0] + s3_bytes = [0] + + def _pipe(src, dst, get_fh, counter): + try: + while True: + data = src.recv(4096) + if not data: + break + dst.sendall(data) + with self._tcp_cap_lock: + fh = get_fh() + if fh: + fh.write(data) + fh.flush() + 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, + lambda: self._tcp_cap_bw_fh, bw_bytes), daemon=True) + t_s3 = threading.Thread(target=_pipe, + args=(dev_sock, bw_sock, + lambda: self._tcp_cap_s3_fh, s3_bytes), daemon=True) + t_bw.start() + t_s3.start() + t_bw.join() + t_s3.join() + bw_sock.close() + dev_sock.close() + + def _poll_tcp_log(self) -> None: + try: + while True: + msg = self._tcp_log_q.get_nowait() + self._append_log(msg) + except queue.Empty: + pass + finally: + self.after(100, self._poll_tcp_log) + + # ── marks ───────────────────────────────────────────────────────────── + + def add_mark(self) -> None: label = simpledialog.askstring("Mark", "Enter label for this mark:", parent=self) if not label or not label.strip(): return - try: - self.process.stdin.write("m\n") - self.process.stdin.write(label.strip() + "\n") - self.process.stdin.flush() - self._append_log(f"[MARK] {label.strip()}\n") - except Exception as e: - messagebox.showerror("Error", f"Failed to send mark:\n{e}") + if self._mode.get() == "tcp": + ts = datetime.datetime.now().strftime("%H:%M:%S") + self._append_log(f"[MARK {ts}] {label.strip()}\n") + else: + if not self.process or not self.process.stdin or self.process.poll() is not None: + return + try: + self.process.stdin.write("m\n") + self.process.stdin.write(label.strip() + "\n") + self.process.stdin.flush() + self._append_log(f"[MARK] {label.strip()}\n") + except Exception as e: + messagebox.showerror("Error", f"Failed to send mark:\n{e}") # ─────────────────────────────────────────────────────────────────────────────