pluto-siege 2.0.1__py3-none-any.whl

pluto_siege/ui/screens/capture.py

@@ -0,0 +1,226 @@
+# PlutoSiege - RF capture and replay tool for PlutoSDR.
+# Copyright (C) 2026 SketchTurnerDev
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+"""Capture screen: UI view layer that delegates signal capture to CaptureEngine."""
+
+from __future__ import annotations
+
+import curses
+import os
+import time
+
+from pluto_siege.config import CONFIG, AppConfig
+from pluto_siege.constants import (
+    IO_TIMEOUT_UNAVAILABLE,
+    RECORDS_DIR,
+)
+from pluto_siege.device import SDRDevice, cleanup_sdr
+from pluto_siege.engine import CaptureEngine
+from pluto_siege.gps import get_gps_manager
+from pluto_siege.sound import SoundCue, play_cue
+from pluto_siege.ui.widgets.framework import (
+    C_DIM,
+    C_ERR,
+    C_OK,
+    C_WARN,
+    KEY_ENTER,
+    KEY_ESC,
+    METER_REFRESH_SECONDS,
+    _tail,
+    draw_chrome,
+    draw_gps_status,
+    draw_signal_meter,
+    flush_input,
+    screen_is_usable,
+    scroll_view,
+    wait_for_usable_screen,
+)
+
+ABORT_HINT = "Esc/Q = abort"
+
+
+def do_capture(
+    win: curses.window,
+    sdr: SDRDevice,
+    hw_model: str,
+    config: AppConfig | None = None,
+) -> int:
+    """Execute a single capture cycle. Returns the exit key pressed in the log view."""
+    cfg = CONFIG if config is None else config
+    if not screen_is_usable(win) and not wait_for_usable_screen(win):
+        return KEY_ESC
+    log: list[tuple[str, int]] = []
+
+    def render_log(hint: str) -> tuple[int, int]:
+        start = draw_chrome(win, "Capture Mode", hint)
+        if start == -1:
+            return -1, 0
+        return start, _tail(log, win, start, 4)
+
+    def finish(title: str, hint: str = "Enter/R = capture again ▎ Esc/Q = back") -> int:
+        flush_input(win)
+        return scroll_view(
+            win,
+            title,
+            log,
+            hint=hint,
+            exit_keys=(KEY_ESC, ord("q"), ord("Q"), ord("r"), ord("R")) + KEY_ENTER,
+        )
+
+    try:
+        log.append(("Configuring receiver...", C_DIM))
+        render_log("Please wait...")
+        win.refresh()
+
+        engine = CaptureEngine(sdr, config=cfg)
+        engine.prepare()
+
+        if not engine.io_timeout_available:
+            log.append((IO_TIMEOUT_UNAVAILABLE, C_WARN))
+
+        if engine.actual_sr > 4_000_000:
+            log.append(("SR > 4 MSPS. USB 2.0 may drop samples.", C_WARN))
+
+        freq_str = f"{engine.actual_freq / 1e6:.3f} MHz"
+        sr_str = f"{engine.actual_sr / 1e6:.2f} MSPS"
+        thr_str = f"Threshold: {engine.trigger_threshold:.1f} dBFS"
+        log.append((f"{freq_str}  {sr_str}  {thr_str}", C_DIM))
+        if engine.trigger_threshold >= 0.0:
+            log.append(("Threshold >= 0 dBFS: nothing can trigger.", C_WARN))
+        log.append(("Listening...", C_DIM))
+        play_cue(SoundCue.START, enabled=cfg.enable_sound)
+
+        os.makedirs(RECORDS_DIR, exist_ok=True)
+        flush_input(win)
+        win.nodelay(True)
+        last_draw = [0.0]
+
+        start, shown = render_log(ABORT_HINT)
+        meter_row = start + shown + 1
+
+        def render_live_widgets(lvl: float = -100.0, saturated: bool = False) -> None:
+            if start == -1 or not screen_is_usable(win):
+                draw_chrome(win, "Capture Mode", ABORT_HINT)
+                win.refresh()
+                return
+            draw_signal_meter(
+                win,
+                meter_row,
+                lvl,
+                engine.trigger_threshold,
+                saturated,
+            )
+            if cfg.enable_gps:
+                mgr = get_gps_manager()
+                draw_gps_status(
+                    win,
+                    meter_row + 1,
+                    mgr.get_status_text(),
+                    has_fix=mgr.get_latest_fix().has_fix,
+                )
+            win.refresh()
+
+        render_live_widgets()
+
+        def check_abort() -> bool:
+            nonlocal start, shown, meter_row
+            k = win.getch()
+            if k == curses.KEY_RESIZE:
+                start, shown = render_log(ABORT_HINT)
+                meter_row = start + shown + 1
+                render_live_widgets(engine.current_level_dbfs, engine.current_saturated)
+            return k in (KEY_ESC, ord("q"), ord("Q"))
+
+        def on_trigger_detected() -> None:
+            nonlocal start, shown, meter_row
+            play_cue(SoundCue.TRIGGER, enabled=cfg.enable_sound)
+            log.append(("Key detected! Capturing...", C_DIM))
+            start, shown = render_log(ABORT_HINT)
+            meter_row = start + shown + 1
+            render_live_widgets(engine.current_level_dbfs, engine.current_saturated)
+
+        def on_meter_update(lvl: float, saturated: bool) -> None:
+            now = time.monotonic()
+            if now - last_draw[0] > METER_REFRESH_SECONDS:
+                render_live_widgets(lvl, saturated)
+                last_draw[0] = now
+
+        engine.listen_and_capture(
+            check_abort=check_abort,
+            on_trigger_detected=on_trigger_detected,
+            on_meter_update=on_meter_update,
+        )
+
+        flush_input(win)
+
+        if engine.is_aborted:
+            play_cue(SoundCue.ALERT, enabled=cfg.enable_sound)
+            log.append(("Capture aborted.", C_WARN))
+            return finish("Capture Aborted")
+
+        if engine.captured_data is None or engine.start_time is None:
+            log.append(("No signal captured.", C_WARN))
+            return finish("Capture")
+
+        if engine.is_partial:
+            log.append(("Saving partial recording...", C_WARN))
+
+        if engine.current_saturated:
+            log.append(("SATURATION detected. Lower RX gain.", C_WARN))
+
+        gps_fix = get_gps_manager().get_latest_fix() if cfg.enable_gps else None
+        base = engine.save_recording(RECORDS_DIR, hw_model, gps_fix=gps_fix)
+        if gps_fix is not None and gps_fix.has_fix:
+            lat_card = "N" if gps_fix.latitude >= 0 else "S"
+            lon_card = "E" if gps_fix.longitude >= 0 else "W"
+            log.append(
+                (
+                    f"Geotag: {abs(gps_fix.latitude):.5f}°{lat_card}, "
+                    f"{abs(gps_fix.longitude):.5f}°{lon_card} ({gps_fix.satellites} sats)",
+                    C_DIM,
+                )
+            )
+        play_cue(SoundCue.CAPTURE_SUCCESS, enabled=cfg.enable_sound)
+        log.append((f"Saved: {os.path.basename(base)}.sigmf-data", C_DIM))
+        log.append(("Key captured successfully!", C_OK))
+        return finish("Capture Complete")
+
+    except (OSError, RuntimeError, ValueError) as e:
+        play_cue(SoundCue.FAIL, enabled=cfg.enable_sound)
+        log.append((f"Capture failed: {e}", C_ERR))
+        return finish("Capture Failed", hint="Enter/R = retry ▎ Esc/Q = back")
+    finally:
+        try:
+            win.nodelay(False)
+        except curses.error:
+            pass
+        cleanup_sdr(sdr)
+
+
+def screen_capture(
+    win: curses.window,
+    sdr: SDRDevice,
+    hw_model: str,
+    config: AppConfig | None = None,
+) -> None:
+    """Listen for a burst, record with pre-trigger history, and save it as SigMF."""
+    while True:
+        key = do_capture(win, sdr, hw_model, config=config)
+        if key not in KEY_ENTER and key not in (ord("r"), ord("R")):
+            break
+
+
+__all__ = ["do_capture", "screen_capture"]

pluto_siege/ui/screens/loopback.py

@@ -0,0 +1,90 @@
+# PlutoSiege - RF capture and replay tool for PlutoSDR.
+# Copyright (C) 2026 SketchTurnerDev
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+"""Loopback test screen: digital loopback tone + SNR measurement."""
+
+from __future__ import annotations
+
+import curses
+
+from pluto_siege.config import CONFIG, AppConfig
+from pluto_siege.constants import (
+    IO_TIMEOUT_UNAVAILABLE,
+    LOOPBACK_MIN_SNR_DB,
+)
+from pluto_siege.device import SDRDevice
+from pluto_siege.engine import LoopbackTester
+from pluto_siege.sound import SoundCue, play_cue
+from pluto_siege.ui.widgets.framework import (
+    C_DIM,
+    C_ERR,
+    C_OK,
+    C_WARN,
+    KEY_ENTER,
+    KEY_ESC,
+    _tail,
+    draw_chrome,
+    flush_input,
+    screen_is_usable,
+    scroll_view,
+    wait_for_usable_screen,
+)
+
+
+def screen_loopback(
+    win: curses.window, sdr: SDRDevice, config: AppConfig | None = None
+) -> None:
+    """Send a tone through the chip's digital loopback and measure its SNR."""
+    cfg = CONFIG if config is None else config
+    while True:
+        if not screen_is_usable(win) and not wait_for_usable_screen(win):
+            return
+        log: list[tuple[str, int]] = [("Running digital loopback test...", C_DIM)]
+
+        try:
+            play_cue(SoundCue.START, enabled=cfg.enable_sound)
+            start = draw_chrome(win, "Loopback Test", "Please wait...")
+            if start != -1:
+                _tail(log, win, start, 2)
+                win.refresh()
+
+            snr_db, tone_freq, timeout_ok = LoopbackTester.run_test(
+                sdr, cfg.sample_rate, cfg.rx_buffer_size, config=cfg
+            )
+            if not timeout_ok:
+                log.append((IO_TIMEOUT_UNAVAILABLE, C_WARN))
+
+            log.append((f"Test tone: {tone_freq / 1000:.3f} kHz", C_DIM))
+            if snr_db >= LOOPBACK_MIN_SNR_DB:
+                play_cue(SoundCue.PASS, enabled=cfg.enable_sound)
+                log.append((f"PASSED. SNR: {snr_db:.1f} dB", C_OK))
+            else:
+                play_cue(SoundCue.FAIL, enabled=cfg.enable_sound)
+                log.append((f"FAILED. SNR: {snr_db:.1f} dB", C_ERR))
+        except Exception as e:
+            play_cue(SoundCue.FAIL, enabled=cfg.enable_sound)
+            log.append((f"Loopback failed: {e}", C_ERR))
+
+        flush_input(win)
+        key = scroll_view(
+            win,
+            "Loopback Test",
+            log,
+            hint="Enter/R = retest ▎ Esc/Q = back",
+            exit_keys=(KEY_ESC, ord("q"), ord("Q"), ord("r"), ord("R")) + KEY_ENTER,
+        )
+        if key not in (ord("r"), ord("R")) and key not in KEY_ENTER:
+            return

pluto_siege/ui/screens/main_menu.py

@@ -0,0 +1,363 @@
+# PlutoSiege - RF capture and replay tool for PlutoSDR.
+# Copyright (C) 2026 SketchTurnerDev
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+"""Main menu, startup connection screen, and application entry point."""
+
+from __future__ import annotations
+
+import atexit
+import curses
+import signal
+import sys
+import threading
+import time
+from typing import Any
+
+from pluto_siege.config import CONFIG, AppConfig, save_settings
+from pluto_siege.device import SDRDevice, open_sdr, release_sdr
+from pluto_siege.gps import init_gps, stop_gps
+from pluto_siege.sound import SoundCue, play_cue
+from pluto_siege.ui.screens.capture import screen_capture
+from pluto_siege.ui.screens.loopback import screen_loopback
+from pluto_siege.ui.screens.settings import screen_settings
+from pluto_siege.ui.screens.transmit import screen_transmit
+from pluto_siege.ui.widgets.framework import (
+    C_DIM,
+    C_ERR,
+    C_OK,
+    C_WARN,
+    CONTENT_X,
+    ESC_DELAY_MS,
+    KEY_ENTER,
+    KEY_ESC,
+    _put,
+    cp,
+    draw_chrome,
+    flush_input,
+    init_colors,
+    init_mouse,
+    menu_select,
+    message_box,
+    screen_is_usable,
+    set_cursor_visible,
+    wait_for_usable_screen,
+)
+
+_ACTIVE_SDR: SDRDevice | None = None
+_SDR_LOCK = threading.Lock()
+
+
+def _set_active_sdr(sdr: SDRDevice | None) -> None:
+    global _ACTIVE_SDR
+    with _SDR_LOCK:
+        _ACTIVE_SDR = sdr
+
+
+def _cleanup_active_sdr() -> None:
+    global _ACTIVE_SDR
+    with _SDR_LOCK:
+        sdr = _ACTIVE_SDR
+        _ACTIVE_SDR = None
+    if sdr is not None:
+        try:
+            release_sdr(sdr)
+        except (OSError, RuntimeError, AttributeError):
+            pass
+    stop_gps()
+
+
+atexit.register(_cleanup_active_sdr)
+
+
+def reconnect_sdr(
+    win: curses.window,
+    sdr: SDRDevice | None,
+    hw_model: str,
+    previous_uri: str,
+    config: AppConfig | None = None,
+) -> tuple[SDRDevice | None, str]:
+    """Re-open the device after the URI changed in Settings."""
+    cfg = CONFIG if config is None else config
+    uri = cfg.pluto_uri
+    if not screen_is_usable(win) and not wait_for_usable_screen(win):
+        cfg.update({"pluto_uri": previous_uri})
+        save_settings(cfg)
+        return sdr, hw_model
+    start_y = draw_chrome(win, "Reconnecting", "Please wait...")
+    _put(win, start_y, CONTENT_X, f"Connecting to PlutoSDR at {uri} ...", cp(C_DIM))
+    win.refresh()
+    _set_active_sdr(None)
+    release_sdr(sdr)
+    try:
+        new_sdr, model = open_sdr(uri, hw_model)
+    except Exception as e:
+        cfg.update({"pluto_uri": previous_uri})
+        save_settings(cfg)
+        prev_sdr = None
+        try:
+            prev_sdr, _ = open_sdr(previous_uri, hw_model)
+            _set_active_sdr(prev_sdr)
+        except Exception:
+            pass
+        play_cue(SoundCue.FAIL, enabled=cfg.enable_sound)
+        if prev_sdr is not None:
+            message_box(
+                win,
+                "Reconnect Failed",
+                [
+                    (f"Could not open {uri}: {e}", C_ERR),
+                    ("Please check Pluto connection settings.", C_WARN),
+                    (f"Reverted to {previous_uri}.", C_WARN),
+                ],
+            )
+        else:
+            message_box(
+                win,
+                "Reconnect Failed",
+                [
+                    (f"Could not open {uri}: {e}", C_ERR),
+                    ("Please check Pluto connection settings.", C_WARN),
+                    (f"Could not revert to {previous_uri}.", C_ERR),
+                    ("Device disconnected.", C_WARN),
+                ],
+            )
+        return prev_sdr, hw_model
+    _set_active_sdr(new_sdr)
+    init_gps(cfg)
+    play_cue(SoundCue.SUCCESS, enabled=cfg.enable_sound)
+    message_box(win, "Reconnected", [(f"Connected: {model} at {uri}", C_OK)])
+    return new_sdr, model
+
+
+def is_sdr_connected(sdr: SDRDevice | None) -> bool:
+    """Check if the SDR device is still responsive."""
+    if sdr is None:
+        return False
+    try:
+        _ = sdr.sample_rate
+        return True
+    except (OSError, RuntimeError, AttributeError):
+        return False
+
+
+def connect_screen(
+    win: curses.window, config: AppConfig | None = None
+) -> tuple[SDRDevice | None, str]:
+    """Connect at startup, letting the user fix the URI. Returns (None, _) on exit."""
+    cfg = CONFIG if config is None else config
+    hint = "Enter = settings ▎ R = retry ▎ Esc/Q = quit"
+    hw_model = "PlutoSDR"
+    attempt = True
+    err_msg = ""
+
+    while True:
+        if not screen_is_usable(win) and not wait_for_usable_screen(win):
+            return None, hw_model
+        uri = cfg.pluto_uri
+        if attempt:
+            start_y = draw_chrome(win, "Startup", hint)
+            _put(
+                win,
+                start_y,
+                CONTENT_X,
+                f"Connecting to PlutoSDR at {uri} ...",
+                cp(C_DIM),
+            )
+            win.refresh()
+            try:
+                sdr, hw_model = open_sdr(uri, hw_model)
+                _set_active_sdr(sdr)
+                init_gps(cfg)
+                _put(win, start_y + 1, CONTENT_X, f"Connected: {hw_model}", cp(C_OK))
+                win.refresh()
+                time.sleep(0.4)
+                return sdr, hw_model
+            except Exception as e:
+                err_msg = str(e)
+                attempt = False
+
+        start_y = draw_chrome(win, "Startup", hint)
+        if start_y == -1:
+            win.refresh()
+            k = win.getch()
+            if k in (KEY_ESC, ord("q"), ord("Q")):
+                return None, hw_model
+            continue
+        err_lines = [line.strip() for line in err_msg.splitlines() if line.strip()]
+        curr_y = start_y
+        if len(err_lines) <= 1:
+            msg = err_lines[0] if err_lines else "Unknown error"
+            _put(win, curr_y, CONTENT_X, f"Cannot connect: {msg}", cp(C_ERR))
+            curr_y += 1
+        else:
+            _put(win, curr_y, CONTENT_X, "Cannot connect:", cp(C_ERR))
+            curr_y += 1
+            for el in err_lines:
+                _put(win, curr_y, CONTENT_X + 2, el, cp(C_ERR))
+                curr_y += 1
+        curr_y += 1
+        _put(
+            win,
+            curr_y,
+            CONTENT_X,
+            "Check the Pluto URI in Settings, then retry.",
+            cp(C_WARN),
+        )
+        _put(
+            win,
+            curr_y + 1,
+            CONTENT_X,
+            "You can still open Settings to change the URI.",
+            cp(C_WARN),
+        )
+        win.refresh()
+
+        flush_input(win)
+        win.nodelay(False)
+        k = win.getch()
+        if k in (KEY_ESC, ord("q"), ord("Q")):
+            return None, hw_model
+        elif k == getattr(curses, "KEY_RESIZE", -1):
+            continue
+        elif k in KEY_ENTER or k in (ord("s"), ord("S")):
+            screen_settings(win, config=cfg)
+            init_gps(cfg)
+            attempt = cfg.pluto_uri != uri
+        elif k in (ord("r"), ord("R")):
+            attempt = True
+
+
+def curses_app(win: curses.window, config: AppConfig | None = None) -> None:
+    """Run the initialized UI lifecycle, always restoring terminal/device state."""
+    cfg = CONFIG if config is None else config
+    try:
+        try:
+            win.keypad(True)
+        except curses.error:
+            pass
+        set_cursor_visible(False)
+        try:
+            curses.set_escdelay(ESC_DELAY_MS)
+        except (AttributeError, curses.error):
+            pass
+        init_colors()
+        init_mouse(cfg.enable_mouse)
+        init_gps(cfg)
+
+        sdr, hw_model = connect_screen(win, config=cfg)
+        if sdr is None:
+            return
+
+        items = ["Capture", "Transmit", "Loopback Test", "Settings", "Exit"]
+        idx = 0
+        while True:
+            choice = menu_select(
+                win,
+                "Main Menu",
+                items,
+                start_idx=idx,
+                hint="Up/Down = move ▎ Enter = select ▎ Esc/Q = quit",
+                hotkeys=True,
+            )
+            if choice is None:
+                break
+            idx = choice
+            if items[idx] == "Exit":
+                break
+            if items[idx] in ("Capture", "Transmit", "Loopback Test"):
+                if not is_sdr_connected(sdr):
+                    _cleanup_active_sdr()
+                    sdr = None
+                    play_cue(SoundCue.ALERT, enabled=cfg.enable_sound)
+                    message_box(
+                        win,
+                        "SDR Disconnected",
+                        [
+                            (
+                                "SDR device is not responding (USB disconnected?).",
+                                C_ERR,
+                            ),
+                            ("Opening connection screen...", C_WARN),
+                        ],
+                    )
+                    new_sdr, new_hw = connect_screen(win, config=cfg)
+                    if new_sdr is None:
+                        continue
+                    sdr, hw_model = new_sdr, new_hw
+
+                if sdr is None:
+                    continue
+
+                if items[idx] == "Capture":
+                    screen_capture(win, sdr, hw_model, config=cfg)
+                elif items[idx] == "Transmit":
+                    screen_transmit(win, sdr, config=cfg)
+                elif items[idx] == "Loopback Test":
+                    screen_loopback(win, sdr, config=cfg)
+
+                if not is_sdr_connected(sdr):
+                    _cleanup_active_sdr()
+                    sdr = None
+            elif items[idx] == "Settings":
+                uri_before = cfg.pluto_uri
+                screen_settings(win, config=cfg)
+                init_gps(cfg)
+                if cfg.pluto_uri != uri_before:
+                    new_sdr, new_hw = reconnect_sdr(
+                        win, sdr, hw_model, uri_before, config=cfg
+                    )
+                    if new_sdr is None:
+                        new_sdr, new_hw = connect_screen(win, config=cfg)
+                        if new_sdr is None:
+                            break
+                    sdr, hw_model = new_sdr, new_hw
+    except KeyboardInterrupt:
+        pass
+    finally:
+        set_cursor_visible(True)
+        _cleanup_active_sdr()
+
+
+def sig_handler(signum: int, frame: Any) -> None:
+    """Defer cleanup to normal control flow; signal handlers must not lock."""
+    raise KeyboardInterrupt
+
+
+def main() -> None:
+    if not (sys.stdin.isatty() and sys.stdout.isatty()):
+        print("Requires an interactive terminal.", file=sys.stderr)
+        sys.exit(1)
+    for sig_name in ("SIGINT", "SIGTERM", "SIGHUP"):
+        sig = getattr(signal, sig_name, None)
+        if sig is not None:
+            try:
+                signal.signal(sig, sig_handler)
+            except (ValueError, OSError):
+                pass
+    try:
+        curses.wrapper(curses_app)
+    except KeyboardInterrupt:
+        pass
+    except curses.error as e:
+        print(f"Terminal error: {e}", file=sys.stderr)
+        sys.exit(1)
+    finally:
+        _cleanup_active_sdr()
+    print("Goodbye!")
+
+
+if __name__ == "__main__":
+    main()