2c7b1ba25e
The same window the aircraft use, given marks that are not aeroplanes. It already knew how to fetch a map, place an information box where it covers nothing, glide it when its owner moves, draw range rings, put a flag where the aerial stands and a scale along the bottom -- and not one of those has anything to do with aviation. What it did not know is that a mark might not fade, might not point anywhere, and might be coloured by what it is rather than by how high it is. Those are three hooks rather than a second window, and the aircraft map is untouched: every one of them defaults to exactly what an aeroplane does. Nothing fades, which is the difference asked for and the right one. An aeroplane that stops transmitting has flown out of range, and drawing it an hour later where it was would be drawing something that is certainly not there. A fixed amateur station that stops transmitting is still exactly where it was -- it beacons every half hour, and the gaps are silence rather than absence. So the picture accumulates and an evening of listening fills a map. Marks are ordered most-recently-heard first, because that is the order the boxes are laid out in and an accumulating map has more marks on it than it has room for boxes. Marks are drawn by what they are: something moving as a body with a stalk pointing where it is going, and anything fixed as a diamond, which is the one shape on the picture with no front -- a house that beacons twice an hour is a place, and a triangle would have it pointing north for no reason. Colours come off the altitude ramp, not because a station has an altitude but because that ramp is the one set of colours all five themes define: warm to cold on the default map, dim to bright on the phosphor ones, so a digipeater stays distinguishable from a car everywhere without a colour being named here. The box says what the station is, how far off and in which bearing, what it is doing if it is moving, its altitude, its weather, its status, the digipeaters it came through, how many packets and how many of those arrived directly, and how strongly. The heading prints the callsign once: an aeroplane has two names and the heading was built for that. Reachable both ways, as everything here is -- --window on the command line, w in the menu -- with the same eight map settings the aircraft side has. Forty new tests against nine deliberately broken builds. Two of them survived the first attempt, and both for the same reason: they asked whether the rendered frames differed rather than whether the symbol did, and the strip along the top carries a running clock, so two frames taken a millisecond apart differ by a few hundred pixels whatever is on the map. They now crop to the mark. That is the second time this session that a ticking header has made a test pass for the wrong reason. Full suite 2652 passed. Built as 2026-09-21_01. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_016PsWPTweCT6pwxKngvVxcg
1708 lines
74 KiB
Python
1708 lines
74 KiB
Python
"""The in-application interface: configure everything without command-line flags.
|
|
|
|
Every setting the command line accepts is reachable here, because both are
|
|
generated from the same table in :mod:`bandsaunter.settings`. Each one carries
|
|
its own help, so nothing has to be looked up elsewhere.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
from pathlib import Path
|
|
|
|
from rich.console import Console
|
|
from rich.panel import Panel
|
|
from rich.prompt import Confirm, Prompt
|
|
from rich.table import Table
|
|
from rich.text import Text
|
|
|
|
from . import bandplan, settings as st
|
|
from .bandplan import CATEGORIES, PRESETS, BandPreset, fmt_hz, in_category, search
|
|
from .config import (DEFAULT_CONFIG_DIR, DEFAULT_CONFIG_PATH,
|
|
DEFAULT_OUTPUT_DIR, ScanConfig,
|
|
delete_profile, list_profiles, load_config, save_config,
|
|
save_default)
|
|
from .ranges import RangeError, ScanRange, parse_frequency
|
|
|
|
__all__ = ["run_tui", "show_ranges", "settings_menu", "help_screen",
|
|
"aircraft_menu", "weather_menu", "aprs_menu", "first_run_setup",
|
|
"TUIAbort"]
|
|
|
|
_BACK = ("", "b", "back", "q", "quit", "x")
|
|
|
|
|
|
def _rule(console: Console, text: str) -> None:
|
|
console.print()
|
|
console.rule(f"[bold]{text}[/bold]", style="blue")
|
|
|
|
|
|
class TUIAbort(Exception):
|
|
"""Input ended or the user interrupted; unwind out of the menus."""
|
|
|
|
|
|
def _ask(console: Console, prompt: str, default: str = "") -> str:
|
|
try:
|
|
return Prompt.ask(prompt, default=default, show_default=bool(default))
|
|
except (EOFError, KeyboardInterrupt):
|
|
# Returning an empty string here would send the menu round again and,
|
|
# with no input left to read, round forever.
|
|
raise TUIAbort() from None
|
|
|
|
|
|
def _confirm(prompt: str, default: bool = False) -> bool:
|
|
"""Yes/no that treats a closed input as "no" rather than crashing."""
|
|
try:
|
|
return Confirm.ask(prompt, default=default)
|
|
except (EOFError, KeyboardInterrupt):
|
|
return False
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Ranges
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def show_ranges(console: Console, cfg: ScanConfig) -> None:
|
|
if not cfg.ranges:
|
|
console.print("[yellow]No frequency ranges selected yet.[/yellow] "
|
|
"[grey62]Add some with 1 or 2.[/grey62]")
|
|
return
|
|
t = Table(box=None, header_style="bold", pad_edge=False)
|
|
t.add_column("#", style="grey62", width=3, justify="right")
|
|
t.add_column("label")
|
|
t.add_column("from", justify="right")
|
|
t.add_column("to", justify="right")
|
|
t.add_column("span", justify="right", style="grey62")
|
|
t.add_column("mode", justify="center")
|
|
t.add_column("on", justify="center")
|
|
total = 0.0
|
|
for i, r in enumerate(cfg.ranges, 1):
|
|
if r.enabled:
|
|
total += r.span
|
|
t.add_row(str(i), r.label, fmt_hz(r.start), fmt_hz(r.stop),
|
|
fmt_hz(r.span), r.mode,
|
|
"[green]yes[/green]" if r.enabled else "[red]no[/red]")
|
|
console.print(t)
|
|
console.print(f"[grey62]{len(cfg.ranges)} range(s), {fmt_hz(total)} of "
|
|
f"spectrum enabled[/grey62]")
|
|
|
|
|
|
def add_manual_ranges(console: Console, cfg: ScanConfig) -> None:
|
|
_rule(console, "add frequency ranges")
|
|
console.print(
|
|
"Enter a start and end frequency for each range. Units may be "
|
|
"written [cyan]144M[/cyan], [cyan]144 MHz[/cyan], "
|
|
"[cyan]144000k[/cyan] or plain Hz; a bare number under 10000 is read "
|
|
"as MHz.\nLeave the start blank when you are done. There is no limit "
|
|
"on how many ranges you add.\n")
|
|
added = 0
|
|
while True:
|
|
start_s = _ask(console, f" [bold]start[/bold] of range "
|
|
f"{len(cfg.ranges) + 1}")
|
|
if not start_s.strip():
|
|
break
|
|
try:
|
|
start = parse_frequency(start_s)
|
|
except RangeError as exc:
|
|
console.print(f" [red]{exc}[/red]")
|
|
continue
|
|
end_s = _ask(console, " [bold]end[/bold] of range")
|
|
try:
|
|
stop = parse_frequency(end_s) if end_s.strip() else start
|
|
except RangeError as exc:
|
|
console.print(f" [red]{exc}[/red]")
|
|
continue
|
|
|
|
r = ScanRange(start, stop)
|
|
covering = bandplan.presets_covering(0.5 * (r.start + r.stop))
|
|
if covering:
|
|
best = min(covering, key=lambda p: p.span)
|
|
r.label = f"{fmt_hz(r.start)}-{fmt_hz(r.stop)} ({best.name})"
|
|
console.print(f" [grey62]that falls in: {best.name} — default "
|
|
f"mode {best.mode}[/grey62]")
|
|
mode = _ask(console, " mode [grey62](auto/nfm/wfm/am/usb/lsb/cw/raw)"
|
|
"[/grey62]", "auto").lower()
|
|
r.mode = mode if mode in ("auto", "nfm", "wfm", "am", "usb", "lsb",
|
|
"cw", "raw") else "auto"
|
|
cfg.ranges.append(r)
|
|
added += 1
|
|
console.print(f" [green]added[/green] {r.describe()}\n")
|
|
if added:
|
|
console.print(f"[green]{added} range(s) added.[/green]")
|
|
|
|
|
|
def choose_presets(console: Console, cfg: ScanConfig) -> None:
|
|
while True:
|
|
_rule(console, "US band plan")
|
|
t = Table(box=None, header_style="bold")
|
|
t.add_column("#", style="grey62", width=3, justify="right")
|
|
t.add_column("category")
|
|
t.add_column("presets", justify="right", style="grey62")
|
|
for i, cat in enumerate(CATEGORIES, 1):
|
|
t.add_row(str(i), cat, str(len(in_category(cat))))
|
|
console.print(t)
|
|
console.print("[grey62]Enter a category number, a search term, or "
|
|
"blank to go back.[/grey62]")
|
|
answer = _ask(console, " category or search").strip()
|
|
if not answer:
|
|
return
|
|
if answer.isdigit() and 1 <= int(answer) <= len(CATEGORIES):
|
|
presets = in_category(CATEGORIES[int(answer) - 1])
|
|
heading = CATEGORIES[int(answer) - 1]
|
|
else:
|
|
presets = search(answer)
|
|
heading = f"search: {answer!r}"
|
|
if not presets:
|
|
console.print(f" [yellow]nothing matched {answer!r}[/yellow]")
|
|
continue
|
|
_pick_from(console, cfg, presets, heading)
|
|
|
|
|
|
def _pick_from(console: Console, cfg: ScanConfig,
|
|
presets: list[BandPreset], heading: str) -> None:
|
|
_rule(console, heading)
|
|
t = Table(box=None, header_style="bold")
|
|
t.add_column("#", style="grey62", width=3, justify="right")
|
|
t.add_column("name")
|
|
t.add_column("range", justify="right")
|
|
t.add_column("mode", justify="center")
|
|
t.add_column("notes", style="grey62", overflow="fold", max_width=42)
|
|
for i, p in enumerate(presets, 1):
|
|
extent = (f"{len(p.expand())} ranges" if p.is_group
|
|
else f"{fmt_hz(p.start)} - {fmt_hz(p.stop)}")
|
|
t.add_row(str(i), p.name, extent, p.mode, p.note)
|
|
console.print(t)
|
|
console.print("[grey62]Numbers to add ([cyan]1,3,5[/cyan] or "
|
|
"[cyan]1-4[/cyan]), [cyan]all[/cyan], or blank to go "
|
|
"back.[/grey62]")
|
|
answer = _ask(console, " add").strip().lower()
|
|
if not answer:
|
|
return
|
|
chosen = list(presets) if answer == "all" else _expand(answer, presets)
|
|
existing = {r.preset_key for r in cfg.ranges if r.preset_key}
|
|
added = 0
|
|
hf = False
|
|
for picked in chosen:
|
|
# A preset may stand for a set of others; add what it actually scans.
|
|
for p in picked.expand():
|
|
if p.key in existing:
|
|
continue
|
|
cfg.ranges.append(ScanRange.from_preset(p))
|
|
existing.add(p.key)
|
|
added += 1
|
|
hf |= p.needs_direct_sampling
|
|
if hf:
|
|
console.print(" [yellow]some of these are below 24 MHz — they need "
|
|
"direct sampling and an HF antenna.[/yellow]")
|
|
console.print(f" [green]added {added} range(s)[/green]")
|
|
warn_about_aircraft_bands(console, cfg)
|
|
|
|
|
|
def warn_about_aircraft_bands(console: Console, cfg: ScanConfig) -> None:
|
|
"""Say so the moment a band that needs the aircraft mode is chosen.
|
|
|
|
The band plan lists 1090 MHz because that is where ADS-B is, so picking
|
|
it here is the obvious thing to do and the wrong one. It is not refused
|
|
-- looking at the spectrum there is a fair thing to want -- but it does
|
|
not happen silently, and the menu that does decode it is named.
|
|
"""
|
|
from . import aircraft as air
|
|
|
|
warning = air.scanning_aircraft_band(cfg.ranges)
|
|
if not warning:
|
|
return
|
|
console.print(Panel(Text.from_markup(
|
|
f"{warning}\n\n"
|
|
"Menu [cyan]5[/cyan], [bold]Aircraft (ADS-B)[/bold], listens to it "
|
|
"properly and draws where the aircraft went.\n\n"
|
|
"[grey62]Scanning it anyway is fine if what you want is the raw "
|
|
"spectrum \u2014 turn on 'Save raw IQ' to keep the samples."
|
|
"[/grey62]"),
|
|
title="[yellow]this band needs the aircraft mode",
|
|
border_style="yellow", padding=(0, 1)))
|
|
|
|
|
|
def _expand(answer: str, items: list) -> list:
|
|
out = []
|
|
for tok in answer.replace(" ", "").split(","):
|
|
if not tok:
|
|
continue
|
|
if "-" in tok:
|
|
a, _, b = tok.partition("-")
|
|
if a.isdigit() and b.isdigit():
|
|
out += [items[i - 1] for i in range(int(a), int(b) + 1)
|
|
if 1 <= i <= len(items)]
|
|
elif tok.isdigit() and 1 <= int(tok) <= len(items):
|
|
out.append(items[int(tok) - 1])
|
|
return out
|
|
|
|
|
|
def edit_ranges(console: Console, cfg: ScanConfig) -> None:
|
|
while True:
|
|
_rule(console, "ranges")
|
|
show_ranges(console, cfg)
|
|
console.print(
|
|
"\n [cyan]a[/cyan] add by hand "
|
|
"[cyan]p[/cyan] add from the band plan\n"
|
|
" [cyan]r[/cyan] remove "
|
|
"[cyan]t[/cyan] toggle on/off\n"
|
|
" [cyan]m[/cyan] change mode "
|
|
"[cyan]c[/cyan] clear all\n"
|
|
" [cyan]b[/cyan] back\n")
|
|
choice = _ask(console, " choice", "b").strip().lower()
|
|
if choice in _BACK:
|
|
return
|
|
if choice == "a":
|
|
add_manual_ranges(console, cfg)
|
|
elif choice == "p":
|
|
choose_presets(console, cfg)
|
|
elif choice == "c":
|
|
if cfg.ranges and _confirm(" remove every range"):
|
|
cfg.ranges = []
|
|
elif choice in ("r", "t", "m") and cfg.ranges:
|
|
which = _ask(console, " which numbers").strip()
|
|
picked = _expand(which, list(range(1, len(cfg.ranges) + 1)))
|
|
if not picked:
|
|
console.print(" [yellow]nothing selected[/yellow]")
|
|
continue
|
|
if choice == "r":
|
|
cfg.ranges = [r for i, r in enumerate(cfg.ranges, 1)
|
|
if i not in picked]
|
|
elif choice == "t":
|
|
for i in picked:
|
|
cfg.ranges[i - 1].enabled = not cfg.ranges[i - 1].enabled
|
|
else:
|
|
mode = _ask(console, " mode", "auto").strip().lower()
|
|
for i in picked:
|
|
cfg.ranges[i - 1].mode = mode or "auto"
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Settings
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def _setting_row(setting: st.Setting, cfg: ScanConfig, default: ScanConfig):
|
|
value = getattr(cfg, setting.key)
|
|
shown = st.format_value(setting, value)
|
|
changed = value != getattr(default, setting.key)
|
|
return Text(shown, style="bold cyan" if changed else "white"), changed
|
|
|
|
|
|
def _settings_table(console: Console, group: str, cfg: ScanConfig) -> list[st.Setting]:
|
|
items = st.in_group(group)
|
|
default = ScanConfig()
|
|
t = Table(box=None, header_style="bold", pad_edge=False)
|
|
t.add_column("#", style="grey62", width=3, justify="right")
|
|
t.add_column("setting", width=22)
|
|
t.add_column("value", width=18)
|
|
t.add_column("what it does", style="grey62", overflow="fold")
|
|
for i, s in enumerate(items, 1):
|
|
value, changed = _setting_row(s, cfg, default)
|
|
t.add_row(str(i), s.label + (" *" if changed else ""), value, s.help)
|
|
console.print(t)
|
|
console.print("[grey62]* differs from the built-in default[/grey62]")
|
|
return items
|
|
|
|
|
|
def setting_help(console: Console, setting: st.Setting,
|
|
cfg: ScanConfig, default=None) -> None:
|
|
default = ScanConfig() if default is None else default
|
|
body = [f"[bold]{setting.label}[/bold] [grey62]({setting.key})[/grey62]",
|
|
"", setting.help.capitalize() + "."]
|
|
if setting.detail:
|
|
body += ["", setting.detail]
|
|
if setting.guidance and setting.guidance != setting.detail:
|
|
body += ["", f"[grey62]{setting.guidance}[/grey62]"]
|
|
body.append("")
|
|
body.append(f"[grey62]now:[/grey62] "
|
|
f"{st.format_value(setting, getattr(cfg, setting.key))}"
|
|
f" [grey62]default:[/grey62] "
|
|
f"{st.format_value(setting, getattr(default, setting.key))}")
|
|
rng = setting.describe_range()
|
|
if rng:
|
|
body.append(f"[grey62]accepts:[/grey62] {rng}")
|
|
if setting.flags:
|
|
flags = " ".join(setting.flags)
|
|
if setting.off_flags:
|
|
flags += " / " + " ".join(setting.off_flags)
|
|
body.append(f"[grey62]command line:[/grey62] {flags}")
|
|
console.print(Panel(Text.from_markup("\n".join(body)),
|
|
border_style="blue", padding=(0, 1)))
|
|
|
|
|
|
def edit_setting(console: Console, setting: st.Setting, cfg: ScanConfig,
|
|
default=None, show_help=None) -> bool:
|
|
"""Prompt for one value. Returns True if it changed.
|
|
|
|
``cfg`` is whatever holds the value -- the scan config, or the aircraft
|
|
options, which are described by the same kind of table and so can be
|
|
edited by the same code. ``default`` is the object the built-in defaults
|
|
come from, and ``show_help`` the panel to print above the prompt.
|
|
"""
|
|
current = getattr(cfg, setting.key)
|
|
(show_help or setting_help)(console, setting, cfg)
|
|
hint = "yes/no" if setting.kind == "bool" else (
|
|
"/".join(setting.choices) if setting.choices else
|
|
(setting.example or setting.metavar or "value"))
|
|
while True:
|
|
raw = _ask(console, f" [bold]{setting.label}[/bold] [grey62]({hint})"
|
|
f"[/grey62]", st.format_value(setting, current)
|
|
if setting.kind not in ("lockout_list", "accept_list")
|
|
else "")
|
|
if raw.strip() == "" or raw == st.format_value(setting, current):
|
|
return False
|
|
if raw.strip().lower() in ("d", "default"):
|
|
value = getattr(default if default is not None else ScanConfig(),
|
|
setting.key)
|
|
else:
|
|
try:
|
|
value = st.parse_value(setting, raw)
|
|
except st.SettingError as exc:
|
|
console.print(f" [red]{exc}[/red]")
|
|
continue
|
|
setattr(cfg, setting.key, value)
|
|
errs = [e for e in cfg.validate() if "frequency ranges" not in e]
|
|
if errs:
|
|
console.print(f" [red]{errs[0]}[/red]")
|
|
setattr(cfg, setting.key, current)
|
|
continue
|
|
console.print(f" [green]{setting.label} = "
|
|
f"{st.format_value(setting, value)}[/green]")
|
|
return True
|
|
|
|
|
|
def settings_menu(console: Console, cfg: ScanConfig) -> None:
|
|
while True:
|
|
_rule(console, "settings")
|
|
t = Table(box=None, header_style="bold")
|
|
t.add_column("#", style="grey62", width=3, justify="right")
|
|
t.add_column("group")
|
|
t.add_column("settings", justify="right", style="grey62")
|
|
for i, g in enumerate(st.GROUPS, 1):
|
|
t.add_row(str(i), g, str(len(st.in_group(g))))
|
|
console.print(t)
|
|
console.print("[grey62]Enter a group number, a search term "
|
|
"(e.g. [cyan]hang[/cyan]), or blank to go back."
|
|
"[/grey62]")
|
|
answer = _ask(console, " group or search").strip()
|
|
if not answer:
|
|
return
|
|
if answer.isdigit() and 1 <= int(answer) <= len(st.GROUPS):
|
|
_group_menu(console, cfg, st.GROUPS[int(answer) - 1])
|
|
else:
|
|
hits = st.search(answer)
|
|
if not hits:
|
|
console.print(f" [yellow]no setting matches "
|
|
f"{answer!r}[/yellow]")
|
|
continue
|
|
if len(hits) == 1:
|
|
edit_setting(console, hits[0], cfg)
|
|
else:
|
|
_list_menu(console, cfg, hits, f"matching {answer!r}")
|
|
|
|
|
|
def _list_menu(console: Console, cfg: ScanConfig, items: list[st.Setting],
|
|
heading: str) -> None:
|
|
while True:
|
|
_rule(console, heading)
|
|
default = ScanConfig()
|
|
t = Table(box=None, header_style="bold")
|
|
t.add_column("#", style="grey62", width=3, justify="right")
|
|
t.add_column("setting", width=22)
|
|
t.add_column("value", width=18)
|
|
t.add_column("group", style="grey62")
|
|
for i, s in enumerate(items, 1):
|
|
value, _ = _setting_row(s, cfg, default)
|
|
t.add_row(str(i), s.label, value, s.group)
|
|
console.print(t)
|
|
answer = _ask(console, " number to edit, or blank to go back").strip()
|
|
if not answer or not answer.isdigit():
|
|
return
|
|
idx = int(answer)
|
|
if 1 <= idx <= len(items):
|
|
edit_setting(console, items[idx - 1], cfg)
|
|
|
|
|
|
def _group_menu(console: Console, cfg: ScanConfig, group: str) -> None:
|
|
while True:
|
|
_rule(console, group.lower())
|
|
items = _settings_table(console, group, cfg)
|
|
console.print("[grey62]Number to change it, [cyan]?N[/cyan] for help "
|
|
"on one, [cyan]d[/cyan] to reset the group, blank to go "
|
|
"back.[/grey62]")
|
|
answer = _ask(console, " choice").strip().lower()
|
|
if answer in _BACK:
|
|
return
|
|
if answer == "d":
|
|
if _confirm(f" reset every setting in {group}"):
|
|
default = ScanConfig()
|
|
for s in items:
|
|
setattr(cfg, s.key, getattr(default, s.key))
|
|
console.print(" [green]reset[/green]")
|
|
continue
|
|
want_help = answer.startswith("?")
|
|
token = answer.lstrip("?").strip()
|
|
if not token.isdigit():
|
|
console.print(" [yellow]enter a number from the list[/yellow]")
|
|
continue
|
|
idx = int(token)
|
|
if not (1 <= idx <= len(items)):
|
|
console.print(" [yellow]no such number[/yellow]")
|
|
continue
|
|
if want_help:
|
|
setting_help(console, items[idx - 1], cfg)
|
|
else:
|
|
edit_setting(console, items[idx - 1], cfg)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Profiles and saved settings
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def profiles_menu(console: Console, cfg: ScanConfig) -> ScanConfig:
|
|
while True:
|
|
_rule(console, "saved settings")
|
|
console.print(f"[grey62]Settings live in {DEFAULT_CONFIG_DIR}[/grey62]")
|
|
exists = DEFAULT_CONFIG_PATH.exists()
|
|
console.print(" default settings file: "
|
|
+ (f"[green]{DEFAULT_CONFIG_PATH}[/green]" if exists
|
|
else "[yellow]not saved yet[/yellow]"))
|
|
profiles = list_profiles()
|
|
if profiles:
|
|
t = Table(box=None, header_style="bold")
|
|
t.add_column("#", style="grey62", width=3, justify="right")
|
|
t.add_column("profile")
|
|
t.add_column("ranges", justify="right")
|
|
t.add_column("record", justify="right")
|
|
t.add_column("hang", justify="right")
|
|
for i, p in enumerate(profiles, 1):
|
|
try:
|
|
other = load_config(str(p))
|
|
t.add_row(str(i), p.stem, str(len(other.ranges)),
|
|
f"{other.record_seconds:g}s",
|
|
f"{other.hang_seconds:g}s")
|
|
except Exception:
|
|
t.add_row(str(i), p.stem, "[red]unreadable[/red]", "", "")
|
|
console.print(t)
|
|
else:
|
|
console.print(" [grey62]no named profiles yet[/grey62]")
|
|
|
|
console.print(
|
|
"\n [cyan]s[/cyan] save as the default settings\n"
|
|
" [cyan]n[/cyan] save as a named profile\n"
|
|
" [cyan]l[/cyan] load a profile\n"
|
|
" [cyan]d[/cyan] delete a profile\n"
|
|
" [cyan]b[/cyan] back\n")
|
|
choice = _ask(console, " choice", "b").strip().lower()
|
|
if choice in _BACK:
|
|
return cfg
|
|
try:
|
|
if choice == "s":
|
|
path = save_default(cfg)
|
|
console.print(f" [green]saved — every run will start from "
|
|
f"{path}[/green]")
|
|
elif choice == "n":
|
|
name = _ask(console, " profile name", "myscan").strip()
|
|
if name:
|
|
console.print(f" [green]saved to "
|
|
f"{save_config(cfg, name)}[/green]")
|
|
elif choice == "l" and profiles:
|
|
name = _ask(console, " profile name or number").strip()
|
|
if name.isdigit() and 1 <= int(name) <= len(profiles):
|
|
name = profiles[int(name) - 1].stem
|
|
cfg = load_config(name)
|
|
console.print(f" [green]loaded {name}[/green]")
|
|
elif choice == "d" and profiles:
|
|
name = _ask(console, " profile name or number").strip()
|
|
if name.isdigit() and 1 <= int(name) <= len(profiles):
|
|
name = profiles[int(name) - 1].stem
|
|
if name and _confirm(f" delete {name}"):
|
|
console.print(" [green]deleted[/green]"
|
|
if delete_profile(name)
|
|
else " [yellow]no such profile[/yellow]")
|
|
except (OSError, FileNotFoundError, ValueError) as exc:
|
|
console.print(f" [red]{exc}[/red]")
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Help
|
|
# ---------------------------------------------------------------------------
|
|
|
|
_TOPICS: dict[str, tuple[str, str]] = {
|
|
"1": ("Getting started", """
|
|
Pick what to scan, then start. Ranges come from two places: type start and
|
|
end frequencies by hand, or choose from the built-in US band plan, which
|
|
carries each band's usual channel spacing and demodulator so you do not have
|
|
to set them.
|
|
|
|
Everything on this menu can also be given on the command line, and every
|
|
command-line option can be set here. Settings you save become the starting
|
|
point for every later run."""),
|
|
"2": ("How the scan works", """
|
|
The scanner sweeps each range in steps, listening at each tuner position for
|
|
the dwell time. Anything standing far enough above the noise counts as a
|
|
detection.
|
|
|
|
It then drops onto that frequency, looks at the signal briefly to choose the
|
|
right demodulator, and records until either the record limit is reached or the
|
|
channel goes quiet for the hang time. Gaps shorter than the hang time are
|
|
recorded straight through, so a two-way exchange stays in one file."""),
|
|
"3": ("Why nothing is being recorded", """
|
|
Most often the squelch threshold is too high, or the content check is
|
|
rejecting what it hears.
|
|
|
|
Try 'Squelch threshold' lower (8 dB is sensitive, 15 dB is conservative), and
|
|
check the scan summary: it reports how many detections were discarded and
|
|
why. To see everything the squelch opens on, set 'Check for content' to no —
|
|
but expect static and interference to be recorded too."""),
|
|
"4": ("Why static is being recorded", """
|
|
Turn 'Check for content' back on. With it on, a capture is kept only if it
|
|
carries speech, decodable Morse, or an identified digital keying scheme;
|
|
static, hum, bare carriers and interference are deleted.
|
|
|
|
If real signals are being rejected, lower 'Minimum speech score'. Speech
|
|
detection needs roughly a second of audio, so very short overs may be
|
|
missed."""),
|
|
"5": ("Recording conversations", """
|
|
Set 'Record for' to 0 so a long exchange is not cut off, and 'Wait for quiet'
|
|
longer than the pause between overs — five or six seconds suits most two-way
|
|
traffic. 'Absolute limit' still stops a capture running away.
|
|
|
|
Silence, static and interference all count as quiet, so a burst of noise
|
|
during a pause will not park the receiver on a finished conversation."""),
|
|
"6": ("Files and where they go", """
|
|
Recordings are written to the output directory, all in one flat folder, named
|
|
yyyy-mm-dd_hh.mm.ss_frequency_modulation.wav. Beside each one is a .json with
|
|
the identification and measurements, and with 'Save raw IQ' on, the raw
|
|
samples plus a SigMF sidecar.
|
|
|
|
scan_log.csv lists every hit and opens in a spreadsheet."""),
|
|
"7": ("HF and direct sampling", """
|
|
Below about 24 MHz the tuner cannot reach, so the signal is fed straight into
|
|
the digitiser. 'Direct sampling' set to auto switches this on and off as
|
|
needed; most dongles use the Q branch.
|
|
|
|
There is no filtering or gain in front of the digitiser in this mode, so an HF
|
|
antenna and a quiet location matter more than usual."""),
|
|
"8": ("Trunked systems", """
|
|
Police, fire and large business radio mostly runs on trunked systems, where a
|
|
pool of channels is shared and one frequency is given over entirely to a data
|
|
stream saying which channel each conversation has been put on. That is the
|
|
control channel: loud, perfectly steady, never silent, and with nothing on it
|
|
to hear.
|
|
|
|
It is recognised by its symbol rate and its refusal to pause, named on screen,
|
|
and skipped within a second or two. Turn 'Skip trunk control channels' off
|
|
only if you are collecting them for a decoder. If digital voice calls are
|
|
being skipped by mistake, raise 'Control channel patience'."""),
|
|
"9": ("Reading data signals", """
|
|
Much of what a scanner finds is not speech: doorbells, tyre-pressure sensors,
|
|
weather stations, remote controls, paging, packet radio. All of it is read.
|
|
|
|
Whatever the modulation, a data signal comes down to the same shape once it has
|
|
been sliced — a train of runs whose lengths carry the information — and which
|
|
line code it is (PWM, PPM, Manchester, NRZ) is worked out from the runs alone
|
|
rather than configured. Four-level FSK, as P25 and DMR use it, is recognised
|
|
as such and read as symbols; where a frame sync word appears the system is
|
|
named.
|
|
|
|
POCSAG paging and APRS packet carry their own checksums, so those are read in
|
|
full: the address and message text of a page, the callsign and position of an
|
|
APRS beacon. A decoded callsign goes onto the map with the rest.
|
|
|
|
What keeps it honest is repetition. Noise sliced at a threshold produces runs,
|
|
and runs produce bits, so a reading with nothing behind it is reported as
|
|
nothing at all. These transmitters send the same packet three to ten times
|
|
over, and bits that come back identical every time did not come from noise."""),
|
|
"10": ("Callsigns and the map", """
|
|
Anyone who identifies themselves in a transcript is picked out and looked up in
|
|
the FCC's published licence register: the name, the town, the class of licence.
|
|
The callsign is the only thing sent, and each one is asked about once and then
|
|
remembered, so a net recorded night after night is looked up once.
|
|
|
|
Because a licence says where its holder is, the same information is written as
|
|
a map — callsigns.kml in the output directory — with one pin per station,
|
|
carrying the licensee, the town, and every frequency and time you heard them.
|
|
It opens in Google Earth, QGIS, Marble and OsmAnd, and later scans add to it
|
|
rather than starting it over, so it fills in as a picture of what your aerial
|
|
can reach.
|
|
|
|
Callsigns arrive from three directions and all three end up on the same map:
|
|
spoken and transcribed, sent in Morse, or carried in the header of an APRS
|
|
packet. Neither of the last two involves a speech recogniser, so a receiver
|
|
with none installed still builds a map -- most of the stations on the air
|
|
never say a word, and identify themselves in a short burst of CW instead.
|
|
|
|
Turn 'Look callsigns up' off to keep the scan entirely offline; callsigns are
|
|
still found, and named by country from their prefix. Clear 'Map file' to stop
|
|
writing the map. US licence records are public, and include addresses."""),
|
|
"12": ("Pictures, aircraft, meters", """
|
|
Three of the things a receiver can hear are images rather than sounds, and all
|
|
three arrive as the audio a scan already records: slow-scan television, the
|
|
NOAA weather satellites on 137 MHz, and the shortwave weather fax stations.
|
|
Each announces itself -- a VIS header, a pair of line syncs, a phasing signal
|
|
-- so none of them is guessed at, and what is decoded is written as a PNG
|
|
beside the recording. saunterbrowse marks those in the list and gives the
|
|
path. Turn 'Decode pictures' off to skip the work.
|
|
|
|
A picture takes minutes rather than seconds, so 'Max record time' has to be
|
|
long enough or what arrives is the top of one. A partial picture is kept and
|
|
labelled partial.
|
|
|
|
Utility meters on 900 MHz are named rather than reported as hexadecimal, and
|
|
are not believed without their own checksum.
|
|
|
|
Two things are separate commands, because neither fits through a scan.
|
|
`bandsaunter adsb` parks the receiver on 1090 MHz: ADS-B is a megabit a
|
|
second and will not go through a channel twelve and a half kilohertz wide.
|
|
`bandsaunter weather` parks it on 433.92 MHz for the weather sensors, whose
|
|
messages are bursts of a carrier switched on and off, which a scan records as
|
|
clicks."""),
|
|
"13": ("Weather sensors on 433 MHz", """
|
|
The plastic box on a fence post that came with a consumer weather station
|
|
broadcasts what it can see every sixteen seconds, in the clear, on 433.92
|
|
MHz. `bandsaunter weather` reads it, and reads five families of them:
|
|
|
|
Tower 592TXR temperature, humidity
|
|
5-in-1 06014RM wind speed, wind direction, rainfall, temperature, humidity
|
|
Lightning 6045M temperature, humidity, strike count, how far off the storm is
|
|
609TXC temperature, humidity
|
|
606TX temperature
|
|
|
|
Battery state comes from all of them. Nothing is reported that has not
|
|
satisfied its own checksum and, on the older two models, arrived twice.
|
|
|
|
The identity in the message is a number that came out of a hat in a factory,
|
|
so press n while listening to name whichever sensor is on the screen -- the
|
|
shed, the greenhouse -- and it keeps the name from then on. Names live in
|
|
sensors.yaml beside the settings and can be edited by hand.
|
|
|
|
`bandsaunter readings --csv` turns a log into a spreadsheet: a column per
|
|
quantity, a row per reading, the name in the second column."""),
|
|
"14": ("APRS on 144 MHz", """
|
|
One channel, one frequency, everybody: 144.390 MHz across North America and a
|
|
different number in every other region. `bandsaunter aprs` parks on it and
|
|
writes down everything that passes -- positions, weather, messages, objects,
|
|
telemetry -- from every amateur station in earshot and every digipeater
|
|
repeating them onward, which is most of what you will hear.
|
|
|
|
The frequency is agreed between amateurs rather than allocated, so check
|
|
--region first: on the wrong channel there is silence, not a bad signal.
|
|
north-america is 144.390, europe 144.800, australia 145.175.
|
|
|
|
Nothing here needs naming. A station broadcasts a callsign issued by a
|
|
government, which is already the name.
|
|
|
|
What it reads: positions both uncompressed and compressed; Mic-E, which every
|
|
Kenwood and Yaesu mobile sends and which hides half the position inside the
|
|
destination callsign; weather; messages, acknowledgements and bulletins;
|
|
objects and items; status; telemetry; and traffic relayed in from another
|
|
network. A packet in a format it cannot read keeps its text and says so,
|
|
rather than being reported as a position it never claimed.
|
|
|
|
Three tables when it stops: who was heard and how well, what they said, and
|
|
the messages in order. --at LAT,LON adds distance and bearing.
|
|
--direct-only leaves out anything that came through a digipeater, which is the
|
|
honest measure of what your aerial reaches. `bandsaunter packets --csv --kml`
|
|
turns a log into a spreadsheet and something Google Earth opens."""),
|
|
"11": ("Keys during a scan", """
|
|
q stop the scan
|
|
p pause and resume
|
|
s skip the signal being recorded and carry on sweeping
|
|
l lock out this frequency for the rest of the run
|
|
+/- raise or lower the squelch threshold on the fly
|
|
|
|
saunterbrowse writes to the same lock-out list afterwards: pressing m over a
|
|
recording locks out the frequency it was heard on, which is usually when you
|
|
find out a frequency is not worth listening to. It can also file recordings
|
|
into saved/, investigate/ or noise/, and delete the ones worth nothing."""),
|
|
}
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Aircraft
|
|
# ---------------------------------------------------------------------------
|
|
|
|
_AIRCRAFT_INTRO = (
|
|
"Every airliner overhead broadcasts its address, callsign, altitude, "
|
|
"position and speed twice a second on 1090 MHz. This is not a scan and "
|
|
"cannot be one \u2014 the signalling is a megabit a second, and the scan "
|
|
"path is 12.5 kHz wide \u2014 so it has its own listening mode here.\n\n"
|
|
"Everything heard is written to a log as it arrives; the map is drawn "
|
|
"from that log afterwards, and can be drawn again with different options "
|
|
"as often as you like.\n\n"
|
|
"[bold]Passive capture[/bold] listens and writes, showing a line per "
|
|
"aircraft in this terminal. [bold]Realtime display[/bold] does the same "
|
|
"and opens a window with a real map in it, each aircraft moving on it "
|
|
"with a box beside it saying everything known about the flight. Both "
|
|
"leave the same files behind."
|
|
)
|
|
|
|
|
|
def _section(section=None):
|
|
"""The module that owns a set of options: aircraft unless told otherwise.
|
|
|
|
Every helper below works off ``OPTIONS``, ``OPTION_GROUPS``, ``in_group``,
|
|
``defaults`` and ``format_option``, which both sections provide and which
|
|
say nothing about aircraft or weather. That is what lets one set of
|
|
menus drive both, and what will let it drive a third.
|
|
"""
|
|
if section is not None:
|
|
return section
|
|
from . import aircraft as air
|
|
|
|
return air
|
|
|
|
|
|
def _options_table(console: Console, options, group: str,
|
|
section=None) -> list[st.Setting]:
|
|
air = _section(section)
|
|
|
|
items = air.in_group(group)
|
|
default = air.defaults()
|
|
t = Table(box=None, header_style="bold", pad_edge=False,
|
|
title=f"[bold]{group.lower()}[/bold]", title_justify="left")
|
|
t.add_column("#", style="grey62", width=3, justify="right")
|
|
t.add_column("option", width=20)
|
|
t.add_column("value", width=16)
|
|
t.add_column("what it does", style="grey62", overflow="fold")
|
|
start = air.OPTIONS.index(items[0]) + 1
|
|
for i, o in enumerate(items, start):
|
|
value = air.format_option(o, getattr(options, o.key))
|
|
changed = getattr(options, o.key) != getattr(default, o.key)
|
|
t.add_row(str(i), o.label + (" *" if changed else ""),
|
|
Text(value, style="bold cyan" if changed else "white"),
|
|
o.help)
|
|
console.print(t)
|
|
return items
|
|
|
|
|
|
def aircraft_menu(console: Console, cfg: ScanConfig) -> None:
|
|
"""Listen to aircraft, and draw where they went, without a command line.
|
|
|
|
The options are the same ones the command line takes, described in the
|
|
same table, so the help here is the help there.
|
|
"""
|
|
from . import aircraft as air
|
|
|
|
options = air.load_options()
|
|
while True:
|
|
_rule(console, "aircraft (ADS-B)")
|
|
console.print(Panel(Text.from_markup(_AIRCRAFT_INTRO),
|
|
border_style="blue", padding=(0, 1)))
|
|
_option_groups(console, options)
|
|
logs = air.logs_in(cfg.output_dir)
|
|
kept = "no logs yet" if not logs else \
|
|
f"{len(logs)} log{'s' if len(logs) != 1 else ''}"
|
|
window = "opens a window" if air.windowed() else \
|
|
"needs Qt \u2014 see ?"
|
|
console.print(
|
|
f"\n [cyan]p[/cyan] [bold green]Passive capture[/bold green]"
|
|
f" [grey62]{air.describe(options)}[/grey62]\n"
|
|
f" [cyan]r[/cyan] [bold green]Realtime display[/bold green]"
|
|
f" [grey62]{window}, the map and the aircraft on it"
|
|
f"[/grey62]\n"
|
|
f" [cyan]m[/cyan] Draw a map from a log [grey62]{kept} in "
|
|
f"{cfg.output_dir}[/grey62]\n"
|
|
f" [cyan]N[/cyan] open group N "
|
|
f"[grey62]or type part of an option's name to find it[/grey62]\n"
|
|
f" [cyan]s[/cyan] Save these as default "
|
|
f"[grey62]kept in {air.options_path()}[/grey62]\n"
|
|
f" [cyan]d[/cyan] Reset them\n"
|
|
f" [cyan]b[/cyan] Back\n")
|
|
answer = _ask(console, " choice", "p").strip().lower()
|
|
|
|
if answer in _BACK:
|
|
return
|
|
# "l" was what this was called before there were two of them.
|
|
if answer in ("p", "l", "passive", "listen"):
|
|
_listen(console, cfg, options)
|
|
elif answer in ("r", "realtime", "window"):
|
|
_watch(console, cfg, options)
|
|
elif answer in ("m", "map", "draw"):
|
|
_draw_from_menu(console, cfg, options, logs)
|
|
elif answer == "s":
|
|
try:
|
|
where = air.save_options(options)
|
|
console.print(f" [green]saved to {where}[/green]")
|
|
except OSError as exc:
|
|
console.print(f" [red]could not save: {exc}[/red]")
|
|
elif answer == "d":
|
|
if _confirm(" reset every aircraft option"):
|
|
options = air.AircraftOptions()
|
|
console.print(" [green]reset[/green]")
|
|
elif answer.isdigit() and 1 <= int(answer) <= len(air.OPTION_GROUPS):
|
|
_option_group_menu(console, options,
|
|
air.OPTION_GROUPS[int(answer) - 1])
|
|
elif answer.lstrip("?").strip().isdigit():
|
|
_edit_option(console, options, answer)
|
|
elif answer:
|
|
found = _find_options(answer)
|
|
if not found:
|
|
console.print(f" [yellow]nothing matches {answer!r} \u2014 "
|
|
f"enter a group number, or p, r, m, s, d or b"
|
|
f"[/yellow]")
|
|
elif len(found) == 1:
|
|
_edit_option(console, options,
|
|
str(air.OPTIONS.index(found[0]) + 1))
|
|
else:
|
|
_option_list(console, options, found, f"matching {answer!r}")
|
|
_pick_option(console, options)
|
|
|
|
|
|
def _option_groups(console: Console, options, section=None) -> None:
|
|
"""The groups, and how many of each has been changed from the default.
|
|
|
|
A list of six lines rather than a table of thirty-three: the options
|
|
are all still there, and this is the way in to them.
|
|
"""
|
|
air = _section(section)
|
|
|
|
default = air.defaults()
|
|
t = Table(box=None, header_style="bold", pad_edge=False,
|
|
title="[bold]options[/bold]", title_justify="left")
|
|
t.add_column("#", style="grey62", width=3, justify="right")
|
|
t.add_column("group", width=20)
|
|
t.add_column("", width=16, style="grey62")
|
|
t.add_column("what is in it", style="grey62", overflow="fold")
|
|
for i, group in enumerate(air.OPTION_GROUPS, 1):
|
|
items = air.in_group(group)
|
|
changed = sum(1 for o in items
|
|
if getattr(options, o.key) != getattr(default, o.key))
|
|
count = f"{len(items)} option{'s' if len(items) != 1 else ''}"
|
|
if changed:
|
|
count += f", {changed} changed"
|
|
t.add_row(str(i), group.lower(),
|
|
Text(count, style="bold cyan" if changed else "grey62"),
|
|
", ".join(o.label.lower() for o in items))
|
|
console.print(t)
|
|
|
|
|
|
def _find_options(text: str, section=None) -> list:
|
|
"""Every option this could mean, nearest match first.
|
|
|
|
An exact name wins outright. Typing "seconds" should reach the setting
|
|
called seconds, not that one and every other whose description happens
|
|
to mention the word -- so a name that matches exactly is the answer, and
|
|
the wider search is only what happens when nothing does.
|
|
"""
|
|
air = _section(section)
|
|
|
|
wanted = text.strip().lower()
|
|
if not wanted:
|
|
return []
|
|
exact = [o for o in air.OPTIONS
|
|
if wanted in (o.key.lower(), o.label.lower())]
|
|
if exact:
|
|
return exact
|
|
return [o for o in air.OPTIONS
|
|
if wanted in o.key.lower() or wanted in o.label.lower()
|
|
or wanted in o.help.lower()]
|
|
|
|
|
|
def _option_list(console: Console, options, items, title: str,
|
|
section=None) -> None:
|
|
"""One table of whichever options were asked for."""
|
|
air = _section(section)
|
|
|
|
default = air.defaults()
|
|
t = Table(box=None, header_style="bold", pad_edge=False,
|
|
title=f"[bold]{title}[/bold]", title_justify="left")
|
|
t.add_column("#", style="grey62", width=3, justify="right")
|
|
t.add_column("option", width=20)
|
|
t.add_column("value", width=16)
|
|
t.add_column("what it does", style="grey62", overflow="fold")
|
|
for o in items:
|
|
value = air.format_option(o, getattr(options, o.key))
|
|
changed = getattr(options, o.key) != getattr(default, o.key)
|
|
t.add_row(str(air.OPTIONS.index(o) + 1), o.label + (" *" if changed else ""),
|
|
Text(value, style="bold cyan" if changed else "white"),
|
|
o.help)
|
|
console.print(t)
|
|
|
|
|
|
def _pick_option(console: Console, options, section=None) -> None:
|
|
"""Ask which of the options just listed to change, and change it."""
|
|
console.print("[grey62]Enter an option number to change it, "
|
|
"[cyan]?N[/cyan] for what it does, or blank to go back."
|
|
"[/grey62]")
|
|
answer = _ask(console, " option").strip().lower()
|
|
if answer and answer.lstrip("?").strip().isdigit():
|
|
_edit_option(console, options, answer, section)
|
|
|
|
|
|
def _option_group_menu(console: Console, options, group: str,
|
|
section=None) -> None:
|
|
"""One group of options, on a screen of its own."""
|
|
air = _section(section)
|
|
|
|
while True:
|
|
_rule(console, group.lower())
|
|
items = air.in_group(group)
|
|
_option_list(console, options, items, group.lower(), air)
|
|
console.print("\n[grey62]Enter an option number to change it, "
|
|
"[cyan]?N[/cyan] for what it does, or [cyan]b[/cyan] "
|
|
"to go back.[/grey62]")
|
|
answer = _ask(console, " option", "b").strip().lower()
|
|
if not answer or answer in _BACK:
|
|
return
|
|
if answer.lstrip("?").strip().isdigit():
|
|
_edit_option(console, options, answer, air)
|
|
else:
|
|
console.print(" [yellow]enter a number from the list, "
|
|
"or b[/yellow]")
|
|
|
|
|
|
def _edit_option(console: Console, options, answer: str,
|
|
section=None) -> None:
|
|
"""Change one option, or explain it when asked with a question mark."""
|
|
air = _section(section)
|
|
|
|
want_help = answer.startswith("?")
|
|
index = int(answer.lstrip("?").strip())
|
|
if not 1 <= index <= len(air.OPTIONS):
|
|
console.print(" [yellow]no such number[/yellow]")
|
|
return
|
|
option = air.OPTIONS[index - 1]
|
|
if want_help:
|
|
option_help(console, option, options, air)
|
|
else:
|
|
edit_setting(console, option, options, default=air.defaults(),
|
|
show_help=lambda c, o, v: option_help(c, o, v, air))
|
|
|
|
|
|
def option_help(console: Console, option: st.Setting, options,
|
|
section=None) -> None:
|
|
"""The same help panel the settings menu shows, for a section option."""
|
|
air = _section(section)
|
|
|
|
body = [f"[bold]{option.label}[/bold] [grey62]({option.key})[/grey62]",
|
|
"", option.help.capitalize() + "."]
|
|
if option.detail:
|
|
body += ["", option.detail]
|
|
if option.guidance and option.guidance != option.detail:
|
|
body += ["", f"[grey62]{option.guidance}[/grey62]"]
|
|
default = air.defaults()
|
|
body += ["", f"[grey62]now:[/grey62] "
|
|
f"{air.format_option(option, getattr(options, option.key))}"
|
|
f" [grey62]default:[/grey62] "
|
|
f"{air.format_option(option, getattr(default, option.key))}"]
|
|
rng = option.describe_range()
|
|
if rng:
|
|
body.append(f"[grey62]accepts:[/grey62] {rng}")
|
|
if option.flags:
|
|
flags = " ".join(option.flags)
|
|
if option.off_flags:
|
|
flags += " / " + " ".join(option.off_flags)
|
|
body.append(f"[grey62]command line:[/grey62] {flags}")
|
|
console.print(Panel(Text.from_markup("\n".join(body)),
|
|
border_style="blue", padding=(0, 1)))
|
|
|
|
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# APRS
|
|
# ---------------------------------------------------------------------------
|
|
|
|
_APRS_INTRO = (
|
|
"One channel, one frequency, everybody: 144.390 MHz across North "
|
|
"America and a different number in every other region, carrying "
|
|
"position reports, weather, messages, objects and telemetry from every "
|
|
"amateur station within earshot \u2014 and from every hilltop "
|
|
"digipeater repeating them onward, which is most of what you will "
|
|
"hear.\n\n"
|
|
"Unlike the other two modes this is a conversation rather than a "
|
|
"broadcast. Stations address each other, acknowledge each other and "
|
|
"relay for each other, so what is worth showing is not only who is out "
|
|
"there but what was said.\n\n"
|
|
"Nothing here has to be named. A weather sensor broadcasts a number out "
|
|
"of a hat; an APRS station broadcasts a callsign issued by a "
|
|
"government, which is already the name."
|
|
)
|
|
|
|
|
|
def aprs_menu(console: Console, cfg: ScanConfig) -> None:
|
|
"""Listen to the APRS channel, without a command line."""
|
|
from . import aprs as ap
|
|
|
|
options = ap.load_options()
|
|
while True:
|
|
_rule(console, "APRS (144 MHz packet)")
|
|
console.print(Panel(Text.from_markup(_APRS_INTRO),
|
|
border_style="blue", padding=(0, 1)))
|
|
_option_groups(console, options, ap)
|
|
logs = ap.logs_in(cfg.output_dir)
|
|
kept = "no logs yet" if not logs else \
|
|
f"{len(logs)} log{'s' if len(logs) != 1 else ''}"
|
|
window = "opens a window" if ap.windowed() else "needs Qt \u2014 see ?"
|
|
console.print(
|
|
f"\n [cyan]l[/cyan] [bold green]Listen[/bold green]"
|
|
f" [grey62]{ap.describe(options)}[/grey62]\n"
|
|
f" [cyan]w[/cyan] [bold green]Realtime map[/bold green]"
|
|
f" [grey62]{window}, the stations on it, and they stay"
|
|
f"[/grey62]\n"
|
|
# The channel is the setting that decides whether anything is
|
|
# heard at all, and it cannot be discovered from the air on any
|
|
# one frequency, so it sits here rather than a level down among
|
|
# the gain and the sample rate.
|
|
f" [cyan]c[/cyan] Channel / region "
|
|
f"[bold]{ap.channel_text(options)}[/bold]\n"
|
|
f" [cyan]f[/cyan] Find the channel [grey62]listen on each "
|
|
f"region's in turn and see which has traffic[/grey62]\n"
|
|
f" [cyan]r[/cyan] Read a log back [grey62]{kept} in "
|
|
f"{cfg.output_dir}[/grey62]\n"
|
|
f" [cyan]N[/cyan] open group N "
|
|
f"[grey62]or type part of an option's name to find it[/grey62]\n"
|
|
f" [cyan]s[/cyan] Save these as default "
|
|
f"[grey62]kept in {ap.options_path()}[/grey62]\n"
|
|
f" [cyan]d[/cyan] Reset them\n"
|
|
f" [cyan]b[/cyan] Back\n")
|
|
answer = _ask(console, " choice", "l").strip().lower()
|
|
|
|
if answer in _BACK:
|
|
return
|
|
if answer in ("l", "listen", "p"):
|
|
_aprs_listen(console, cfg, options)
|
|
elif answer in ("w", "window", "map", "realtime"):
|
|
_aprs_watch(console, cfg, options)
|
|
elif answer in ("c", "channel", "region"):
|
|
_aprs_channel(console, options)
|
|
elif answer in ("f", "find", "search", "scan"):
|
|
_aprs_find(console, options)
|
|
elif answer in ("r", "read", "packets", "m"):
|
|
_aprs_read(console, cfg, options, logs)
|
|
elif answer == "s":
|
|
try:
|
|
where = ap.save_options(options)
|
|
console.print(f" [green]saved to {where}[/green]")
|
|
except OSError as exc:
|
|
console.print(f" [red]could not save: {exc}[/red]")
|
|
elif answer == "d":
|
|
if _confirm(" reset every APRS option"):
|
|
options = ap.AprsOptions()
|
|
console.print(" [green]reset[/green]")
|
|
elif answer.isdigit() and 1 <= int(answer) <= len(ap.OPTION_GROUPS):
|
|
_option_group_menu(console, options,
|
|
ap.OPTION_GROUPS[int(answer) - 1], ap)
|
|
elif answer.lstrip("?").strip().isdigit():
|
|
_edit_option(console, options, answer, ap)
|
|
elif answer:
|
|
found = _find_options(answer, ap)
|
|
if not found:
|
|
console.print(f" [yellow]nothing matches {answer!r} \u2014 "
|
|
f"enter a group number, or l, w, c, f, r, s, "
|
|
f"d or b[/yellow]")
|
|
elif len(found) == 1:
|
|
_edit_option(console, options,
|
|
str(ap.OPTIONS.index(found[0]) + 1), ap)
|
|
else:
|
|
_option_list(console, options, found, f"matching {answer!r}",
|
|
ap)
|
|
_pick_option(console, options, ap)
|
|
|
|
|
|
def _aprs_watch(console: Console, cfg: ScanConfig, options) -> None:
|
|
"""Open the window, and come back to the menu when it is closed."""
|
|
from . import aprs as ap
|
|
|
|
errs = options.validate()
|
|
if errs:
|
|
for e in errs:
|
|
console.print(f" [red]{e}[/red]")
|
|
return
|
|
console.print("[grey62]closing the window stops the listening and "
|
|
"writes the log and the report, exactly as listening "
|
|
"without one does. Stations stay on the map once they have "
|
|
"been heard \u2014 they do not fade off it.[/grey62]")
|
|
try:
|
|
ap.watch(console, options, cfg.output_dir)
|
|
except Exception as exc: # a menu must survive it
|
|
console.print(f" [red]{exc}[/red]")
|
|
|
|
|
|
def _aprs_channel(console: Console, options) -> None:
|
|
"""Choose the region, which sets the frequency with it.
|
|
|
|
On the front page of the menu because it is the one setting that decides
|
|
whether anything is heard at all, and because being on the wrong channel
|
|
sounds exactly like having no aerial.
|
|
"""
|
|
from . import aprs as ap
|
|
from .ax25 import APRS_CHANNELS
|
|
|
|
_rule(console, "APRS channel")
|
|
console.print(Panel(Text.from_markup(
|
|
"The frequency is agreed between amateurs rather than allocated, so "
|
|
"it differs by region and there is no way to discover it from the "
|
|
"air: on the wrong channel there is [bold]silence, not a bad "
|
|
"signal[/bold].\n\n"
|
|
"If you do not know which applies, [cyan]f[/cyan] on the previous "
|
|
"screen listens on each in turn and tells you which has traffic."),
|
|
border_style="blue", padding=(0, 1)))
|
|
t = Table(box=None, header_style="bold", pad_edge=False)
|
|
t.add_column("#", style="grey62", width=3, justify="right")
|
|
t.add_column("region", width=15)
|
|
t.add_column("frequency", justify="right", width=12)
|
|
t.add_column("used in", style="grey62", overflow="fold")
|
|
for i, (region, hz, where) in enumerate(APRS_CHANNELS, 1):
|
|
here = abs(hz - options.frequency) < 1.0
|
|
t.add_row(str(i),
|
|
Text(region, style="bold cyan" if here else "white"),
|
|
f"{hz / 1e6:.3f} MHz", where + (" ← now" if here else ""))
|
|
console.print(t)
|
|
console.print("\n[grey62]Enter a number, a frequency in MHz for a "
|
|
"channel that is not a region's, or blank to go back."
|
|
"[/grey62]")
|
|
answer = _ask(console, " channel").strip()
|
|
if not answer or answer in _BACK:
|
|
return
|
|
if answer.isdigit() and 1 <= int(answer) <= len(APRS_CHANNELS):
|
|
ap.use_region(options, APRS_CHANNELS[int(answer) - 1][0])
|
|
console.print(f" [green]{ap.channel_text(options)}[/green]")
|
|
return
|
|
try:
|
|
megahertz = float(answer)
|
|
except ValueError:
|
|
console.print(" [yellow]enter a number from the list, or a "
|
|
"frequency in MHz[/yellow]")
|
|
return
|
|
hz = megahertz * 1e6 if megahertz < 1e6 else megahertz
|
|
options.frequency = hz
|
|
console.print(f" [green]{ap.channel_text(options)}[/green]")
|
|
|
|
|
|
def _aprs_find(console: Console, options) -> None:
|
|
"""Listen on every region's channel and say which has traffic."""
|
|
from . import aprs as ap
|
|
|
|
_rule(console, "find the channel")
|
|
console.print(Panel(Text.from_markup(
|
|
"Each region's channel in turn, for a few seconds each. This answers "
|
|
"the one question about APRS that cannot be answered on any single "
|
|
"frequency, because the answer [bold]is[/bold] a frequency.\n\n"
|
|
"A quiet channel is not proof of an empty one \u2014 a fixed station "
|
|
"beacons every half hour \u2014 so what this finds is traffic, and "
|
|
"what it misses is only the absence of traffic while it listened."),
|
|
border_style="blue", padding=(0, 1)))
|
|
answer = _ask(console, " seconds on each", "20").strip()
|
|
try:
|
|
seconds = max(2.0, float(answer))
|
|
except ValueError:
|
|
console.print(" [yellow]that is not a number of seconds[/yellow]")
|
|
return
|
|
console.print(f"[grey62]about {seconds * len(ap.ax25.APRS_CHANNELS):.0f} "
|
|
f"seconds altogether \u2014 control-C stops it[/grey62]")
|
|
try:
|
|
found = ap.find_channel(console, options, seconds)
|
|
except Exception as exc: # a menu must survive it
|
|
console.print(f" [red]{exc}[/red]")
|
|
return
|
|
best = ap.report_channels(console, found, seconds)
|
|
if best is None:
|
|
return
|
|
if _confirm(f" listen on {best.region} from now on"):
|
|
ap.use_region(options, best.region)
|
|
console.print(f" [green]{ap.channel_text(options)}[/green] "
|
|
f"[grey62]\u2014 press s to keep it[/grey62]")
|
|
|
|
|
|
def _aprs_listen(console: Console, cfg: ScanConfig, options) -> None:
|
|
from . import aprs as ap
|
|
|
|
errs = options.validate()
|
|
if errs:
|
|
for e in errs:
|
|
console.print(f" [red]{e}[/red]")
|
|
return
|
|
console.print("[grey62]control-C stops listening and comes back here. "
|
|
"Stations beacon every few minutes, so give it a while."
|
|
"[/grey62]")
|
|
try:
|
|
ap.listen(console, options, cfg.output_dir)
|
|
except Exception as exc: # a menu must survive it
|
|
console.print(f" [red]{exc}[/red]")
|
|
|
|
|
|
def _aprs_read(console: Console, cfg: ScanConfig, options, logs) -> None:
|
|
"""Pick a log and read it back, newest first."""
|
|
from . import aprs as ap
|
|
from .aprslog import read_logs, write_csv, write_kml
|
|
|
|
if not logs:
|
|
console.print(f" [yellow]no logs in {cfg.output_dir} yet \u2014 "
|
|
"listen first, or turn the invented channel on"
|
|
"[/yellow]")
|
|
return
|
|
t = Table(box=None, header_style="bold")
|
|
t.add_column("#", style="grey62", width=3, justify="right")
|
|
t.add_column("log")
|
|
t.add_column("when", style="grey62")
|
|
t.add_column("size", style="grey62", justify="right")
|
|
for i, path in enumerate(logs[:12], 1):
|
|
stat = path.stat()
|
|
t.add_row(str(i), path.name, _when(stat.st_mtime),
|
|
f"{stat.st_size / 1e6:.2f} MB")
|
|
console.print(t)
|
|
answer = _ask(console, " which log", "1").strip()
|
|
if answer in _BACK or not answer.isdigit():
|
|
return
|
|
index = int(answer)
|
|
if not 1 <= index <= min(12, len(logs)):
|
|
console.print(" [yellow]no such number[/yellow]")
|
|
return
|
|
path = logs[index - 1]
|
|
heard = read_logs([path])
|
|
if not heard:
|
|
console.print(f" [yellow]{path.name} holds no packets[/yellow]")
|
|
return
|
|
ap.report(console, ap.Net.of(heard), options)
|
|
if _confirm(" write a map and a spreadsheet too"):
|
|
for writer, suffix in ((write_csv, ".csv"), (write_kml, ".kml")):
|
|
try:
|
|
where = writer(path.with_suffix(suffix), heard,
|
|
options.imperial)
|
|
except OSError as exc:
|
|
console.print(f" [red]could not write it: {exc}[/red]")
|
|
continue
|
|
if where is not None:
|
|
console.print(f" [green]wrote {where}[/green]")
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Weather sensors
|
|
# ---------------------------------------------------------------------------
|
|
|
|
_WEATHER_INTRO = (
|
|
"Every consumer weather station has a plastic box on a fence post which "
|
|
"says what it can see, in the clear, on 433.92 MHz, every sixteen "
|
|
"seconds \u2014 to the display in the kitchen and to anyone else "
|
|
"listening. This reads the box.\n\n"
|
|
"Temperature and humidity from all of them; wind speed, wind direction "
|
|
"and rainfall from a 5-in-1; lightning strikes and how far off the storm "
|
|
"is from a 6045M. Battery state from every one.\n\n"
|
|
"What a sensor cannot tell you is which sensor it is: the identity in "
|
|
"the message came out of a hat in a factory. So [bold]press n while "
|
|
"listening[/bold] to give whichever is on the screen a name \u2014 the "
|
|
"shed, the greenhouse, the back fence \u2014 and it keeps it from then "
|
|
"on, in the display, in the log and in the spreadsheet."
|
|
)
|
|
|
|
|
|
def weather_menu(console: Console, cfg: ScanConfig) -> None:
|
|
"""Listen to the weather sensors, and name them, without a command line."""
|
|
from . import weather as wx
|
|
from .sensors import SensorBook
|
|
|
|
options = wx.load_options()
|
|
while True:
|
|
_rule(console, "weather sensors (433 MHz)")
|
|
console.print(Panel(Text.from_markup(_WEATHER_INTRO),
|
|
border_style="blue", padding=(0, 1)))
|
|
_option_groups(console, options, wx)
|
|
logs = wx.logs_in(cfg.output_dir)
|
|
book = SensorBook()
|
|
kept = "no logs yet" if not logs else \
|
|
f"{len(logs)} log{'s' if len(logs) != 1 else ''}"
|
|
named = sum(1 for s in book.ordered() if s.named)
|
|
known = (f"{len(book)} heard, {named} named" if len(book)
|
|
else "none heard yet")
|
|
console.print(
|
|
f"\n [cyan]l[/cyan] [bold green]Listen[/bold green]"
|
|
f" [grey62]{wx.describe(options)}[/grey62]\n"
|
|
f" [cyan]n[/cyan] Name the sensors [grey62]{known}"
|
|
f"[/grey62]\n"
|
|
f" [cyan]r[/cyan] Read a log back [grey62]{kept} in "
|
|
f"{cfg.output_dir}[/grey62]\n"
|
|
f" [cyan]N[/cyan] open group N "
|
|
f"[grey62]or type part of an option's name to find it[/grey62]\n"
|
|
f" [cyan]s[/cyan] Save these as default "
|
|
f"[grey62]kept in {wx.options_path()}[/grey62]\n"
|
|
f" [cyan]d[/cyan] Reset them\n"
|
|
f" [cyan]b[/cyan] Back\n")
|
|
answer = _ask(console, " choice", "l").strip().lower()
|
|
|
|
if answer in _BACK:
|
|
return
|
|
if answer in ("l", "listen", "p"):
|
|
_weather_listen(console, cfg, options)
|
|
elif answer in ("n", "name", "names"):
|
|
_sensor_names(console, book)
|
|
elif answer in ("r", "read", "readings", "m"):
|
|
_weather_readings(console, cfg, options, logs)
|
|
elif answer == "s":
|
|
try:
|
|
where = wx.save_options(options)
|
|
console.print(f" [green]saved to {where}[/green]")
|
|
except OSError as exc:
|
|
console.print(f" [red]could not save: {exc}[/red]")
|
|
elif answer == "d":
|
|
if _confirm(" reset every weather option"):
|
|
options = wx.WeatherOptions()
|
|
console.print(" [green]reset[/green]")
|
|
elif answer.isdigit() and 1 <= int(answer) <= len(wx.OPTION_GROUPS):
|
|
_option_group_menu(console, options,
|
|
wx.OPTION_GROUPS[int(answer) - 1], wx)
|
|
elif answer.lstrip("?").strip().isdigit():
|
|
_edit_option(console, options, answer, wx)
|
|
elif answer:
|
|
found = _find_options(answer, wx)
|
|
if not found:
|
|
console.print(f" [yellow]nothing matches {answer!r} \u2014 "
|
|
f"enter a group number, or l, n, r, s, d or b"
|
|
f"[/yellow]")
|
|
elif len(found) == 1:
|
|
_edit_option(console, options,
|
|
str(wx.OPTIONS.index(found[0]) + 1), wx)
|
|
else:
|
|
_option_list(console, options, found, f"matching {answer!r}",
|
|
wx)
|
|
_pick_option(console, options, wx)
|
|
|
|
|
|
def _weather_listen(console: Console, cfg: ScanConfig, options) -> None:
|
|
"""Run a listening session from the menu and come back afterwards."""
|
|
from . import weather as wx
|
|
|
|
errs = options.validate()
|
|
if errs:
|
|
for e in errs:
|
|
console.print(f" [red]{e}[/red]")
|
|
return
|
|
console.print("[grey62]control-C stops listening and comes back here. "
|
|
"Press [cyan]n[/cyan] while it runs to name a sensor."
|
|
"[/grey62]")
|
|
try:
|
|
wx.listen(console, options, cfg.output_dir)
|
|
except Exception as exc: # a menu must survive it
|
|
console.print(f" [red]{exc}[/red]")
|
|
|
|
|
|
def _sensor_names(console: Console, book) -> None:
|
|
"""The list of everything ever heard, and what it is called.
|
|
|
|
Everything ever heard rather than everything heard lately, because a
|
|
sensor with a flat battery is exactly the one somebody wants to look up.
|
|
"""
|
|
while True:
|
|
_rule(console, "sensor names")
|
|
sensors = book.ordered()
|
|
if not sensors:
|
|
console.print(" [yellow]nothing heard yet. Listen first, or "
|
|
"turn the invented garden on.[/yellow]")
|
|
return
|
|
t = Table(box=None, header_style="bold", pad_edge=False)
|
|
t.add_column("#", style="grey62", width=3, justify="right")
|
|
t.add_column("name", width=18)
|
|
t.add_column("id", style="grey62", width=6)
|
|
t.add_column("model", style="grey62", width=18)
|
|
t.add_column("msgs", style="grey62", justify="right", width=7)
|
|
t.add_column("last heard", style="grey62")
|
|
t.add_column("note", style="grey62", overflow="fold")
|
|
for i, sensor in enumerate(sensors, 1):
|
|
t.add_row(str(i),
|
|
Text(sensor.name, style="bold") if sensor.named
|
|
else Text("unnamed", style="yellow"),
|
|
sensor.sensor, sensor.model, f"{sensor.messages:,}",
|
|
_when(sensor.last_heard) if sensor.last_heard else "",
|
|
sensor.note)
|
|
console.print(t)
|
|
console.print(f"\n[grey62]Enter a number to name it, "
|
|
f"[cyan]-N[/cyan] to forget it, or [cyan]b[/cyan] to go "
|
|
f"back. Kept in {book.path}.[/grey62]")
|
|
answer = _ask(console, " sensor", "b").strip().lower()
|
|
if not answer or answer in _BACK:
|
|
return
|
|
forget = answer.startswith("-")
|
|
index = answer.lstrip("-").strip()
|
|
if not index.isdigit() or not 1 <= int(index) <= len(sensors):
|
|
console.print(" [yellow]enter a number from the list[/yellow]")
|
|
continue
|
|
sensor = sensors[int(index) - 1]
|
|
if forget:
|
|
if _confirm(f" forget {sensor.label()}"):
|
|
book.forget(sensor.key)
|
|
console.print(" [green]forgotten[/green]")
|
|
continue
|
|
name = _ask(console, f" a name for {sensor.sensor}",
|
|
sensor.name).strip()
|
|
note = _ask(console, " a note (optional)", sensor.note).strip()
|
|
try:
|
|
book.tag(sensor.key, name, note)
|
|
console.print(f" [green]saved[/green]")
|
|
except OSError as exc:
|
|
console.print(f" [red]could not save: {exc}[/red]")
|
|
|
|
|
|
def _weather_readings(console: Console, cfg: ScanConfig, options,
|
|
logs) -> None:
|
|
"""Pick a log and read it back, newest first."""
|
|
from . import weather as wx
|
|
from .sensors import SensorBook
|
|
from .weatherlog import read_logs, write_csv
|
|
|
|
if not logs:
|
|
console.print(f" [yellow]no logs in {cfg.output_dir} yet \u2014 "
|
|
"listen first, or turn the invented garden on[/yellow]")
|
|
return
|
|
t = Table(box=None, header_style="bold")
|
|
t.add_column("#", style="grey62", width=3, justify="right")
|
|
t.add_column("log")
|
|
t.add_column("when", style="grey62")
|
|
t.add_column("size", style="grey62", justify="right")
|
|
for i, path in enumerate(logs[:12], 1):
|
|
stat = path.stat()
|
|
t.add_row(str(i), path.name, _when(stat.st_mtime),
|
|
f"{stat.st_size / 1e6:.2f} MB")
|
|
console.print(t)
|
|
answer = _ask(console, " which log", "1").strip()
|
|
if answer in _BACK or not answer.isdigit():
|
|
return
|
|
index = int(answer)
|
|
if not 1 <= index <= min(12, len(logs)):
|
|
console.print(" [yellow]no such number[/yellow]")
|
|
return
|
|
path = logs[index - 1]
|
|
readings = read_logs([path])
|
|
if not readings:
|
|
console.print(f" [yellow]{path.name} holds no readings[/yellow]")
|
|
return
|
|
book = SensorBook()
|
|
wx.report(console, wx.Garden.of(readings), book, options.imperial)
|
|
if _confirm(" write it as a spreadsheet too"):
|
|
try:
|
|
where = write_csv(path.with_suffix(".csv"), readings, book,
|
|
options.imperial)
|
|
console.print(f" [green]wrote {where}[/green]")
|
|
except OSError as exc:
|
|
console.print(f" [red]could not write it: {exc}[/red]")
|
|
|
|
|
|
def _listen(console: Console, cfg: ScanConfig, options) -> None:
|
|
"""Run a listening session from the menu and come back afterwards."""
|
|
from . import aircraft as air
|
|
|
|
errs = options.validate()
|
|
if errs:
|
|
for e in errs:
|
|
console.print(f" [red]{e}[/red]")
|
|
return
|
|
if not options.simulate:
|
|
console.print("[grey62]control-C stops listening and comes back "
|
|
"here.[/grey62]")
|
|
try:
|
|
heard = air.listen(console, options, cfg.output_dir)
|
|
except Exception as exc: # a menu must survive it
|
|
console.print(f" [red]{exc}[/red]")
|
|
return
|
|
if heard.log_path and not options.draw_after:
|
|
console.print(" [grey62]draw it with [cyan]m[/cyan], or set "
|
|
"\"Draw when finished\"[/grey62]")
|
|
|
|
|
|
def _watch(console: Console, cfg: ScanConfig, options) -> None:
|
|
"""Open the window, and come back to the menu when it is closed."""
|
|
from . import aircraft as air
|
|
|
|
errs = options.validate()
|
|
if errs:
|
|
for e in errs:
|
|
console.print(f" [red]{e}[/red]")
|
|
return
|
|
console.print("[grey62]closing the window stops the capture and writes "
|
|
"the log, the report and the map, exactly as the passive "
|
|
"capture does.[/grey62]")
|
|
try:
|
|
air.watch(console, options, cfg.output_dir)
|
|
except Exception as exc: # a menu must survive it
|
|
console.print(f" [red]{exc}[/red]")
|
|
|
|
|
|
def _draw_from_menu(console: Console, cfg: ScanConfig, options, logs) -> None:
|
|
"""Pick a log and draw it, newest first because that is usually the one."""
|
|
from . import aircraft as air
|
|
|
|
if not logs:
|
|
console.print(f" [yellow]no logs in {cfg.output_dir} yet \u2014 "
|
|
"listen first, or turn the simulated sky on[/yellow]")
|
|
return
|
|
t = Table(box=None, header_style="bold")
|
|
t.add_column("#", style="grey62", width=3, justify="right")
|
|
t.add_column("log")
|
|
t.add_column("when", style="grey62")
|
|
t.add_column("size", style="grey62", justify="right")
|
|
for i, path in enumerate(logs[:12], 1):
|
|
stat = path.stat()
|
|
t.add_row(str(i), path.name,
|
|
_when(stat.st_mtime), f"{stat.st_size/1e6:.1f} MB")
|
|
console.print(t)
|
|
answer = _ask(console, " which log", "1").strip()
|
|
if answer in _BACK:
|
|
return
|
|
if not answer.isdigit() or not 1 <= int(answer) <= len(logs[:12]):
|
|
console.print(" [yellow]no such log[/yellow]")
|
|
return
|
|
chosen = logs[int(answer) - 1]
|
|
try:
|
|
air.draw_log(console, options, [chosen])
|
|
except Exception as exc:
|
|
console.print(f" [red]{exc}[/red]")
|
|
|
|
|
|
def _when(stamp: float) -> str:
|
|
from datetime import datetime
|
|
|
|
return datetime.fromtimestamp(stamp).strftime("%y-%m-%d %H:%M")
|
|
|
|
|
|
def help_screen(console: Console) -> None:
|
|
while True:
|
|
_rule(console, "help")
|
|
t = Table(box=None, header_style="bold")
|
|
t.add_column("#", style="grey62", width=3, justify="right")
|
|
t.add_column("topic")
|
|
for k, (title, _) in _TOPICS.items():
|
|
t.add_row(k, title)
|
|
console.print(t)
|
|
console.print("[grey62]Enter a topic number, a setting name to look "
|
|
"up, or blank to go back.[/grey62]")
|
|
answer = _ask(console, " topic").strip()
|
|
if not answer:
|
|
return
|
|
if answer in _TOPICS:
|
|
title, body = _TOPICS[answer]
|
|
console.print(Panel(Text(body.strip()), title=title,
|
|
border_style="blue", padding=(0, 1)))
|
|
else:
|
|
hits = st.search(answer)
|
|
if not hits:
|
|
console.print(f" [yellow]nothing matches {answer!r}[/yellow]")
|
|
for s in hits[:4]:
|
|
setting_help(console, s, ScanConfig())
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# First run
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def first_run_setup(console: Console, cfg: ScanConfig) -> bool:
|
|
"""Ask where recordings should go, the first time the program is run.
|
|
|
|
Returns True if settings were saved. Only the one question: everything
|
|
else has a working default and can be changed from the settings menu.
|
|
"""
|
|
console.print(Panel(Text.from_markup(
|
|
"[bold]Welcome to bandsaunter[/bold]\n\n"
|
|
"Recordings, transcripts and the scan log are all written to one "
|
|
"directory. Where would you like them?\n\n"
|
|
"[grey62]This is saved, so you are only asked once. Everything else "
|
|
"can be changed later from Settings, or with "
|
|
"[cyan]bandsaunter config[/cyan].[/grey62]"),
|
|
border_style="blue", padding=(0, 1)))
|
|
|
|
while True:
|
|
answer = _ask(console, " recordings directory",
|
|
cfg.output_dir or DEFAULT_OUTPUT_DIR).strip()
|
|
if not answer:
|
|
answer = DEFAULT_OUTPUT_DIR
|
|
path = Path(answer).expanduser()
|
|
try:
|
|
path.mkdir(parents=True, exist_ok=True)
|
|
probe = path / ".bandsaunter-write-test"
|
|
probe.touch()
|
|
probe.unlink()
|
|
except OSError as exc:
|
|
console.print(f" [red]cannot use that directory: {exc}[/red]")
|
|
continue
|
|
cfg.output_dir = answer
|
|
break
|
|
|
|
try:
|
|
saved = save_default(cfg)
|
|
console.print(f" [green]recordings will go to {path}[/green]")
|
|
console.print(f" [grey62]settings saved to {saved}[/grey62]\n")
|
|
return True
|
|
except OSError as exc:
|
|
console.print(f" [yellow]could not save settings: {exc}[/yellow]")
|
|
return False
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Main menu
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def _summary(cfg: ScanConfig) -> str:
|
|
record = ("no limit" if not cfg.record_seconds
|
|
else f"{cfg.record_seconds:g}s")
|
|
gate = ", ".join(cfg.accept) if cfg.require_signal else "everything"
|
|
return (f"record {record}, hang {cfg.hang_seconds:g}s, "
|
|
f"squelch +{cfg.threshold_db:g} dB, keep {gate}")
|
|
|
|
|
|
def run_tui(console: Console, cfg: ScanConfig | None = None,
|
|
source: Path | None = None) -> ScanConfig | None:
|
|
"""The interactive front end. Returns a config to scan with, or None."""
|
|
cfg = cfg or ScanConfig()
|
|
console.print(Panel(Text.from_markup(
|
|
"[bold]bandsaunter[/bold] — RTL-SDR signal scanner\n"
|
|
"[grey62]Scan any set of frequencies, record what turns up, and "
|
|
"identify it. Everything is configurable here; press "
|
|
"[cyan]h[/cyan] for help at any point.[/grey62]"),
|
|
border_style="blue"))
|
|
if source:
|
|
console.print(f"[grey62]settings loaded from {source}[/grey62]")
|
|
|
|
try:
|
|
return _main_loop(console, cfg)
|
|
except TUIAbort:
|
|
console.print()
|
|
return None
|
|
|
|
|
|
def _main_loop(console: Console, cfg: ScanConfig) -> ScanConfig | None:
|
|
while True:
|
|
_rule(console, "main menu")
|
|
show_ranges(console, cfg)
|
|
console.print(
|
|
f"\n [cyan]1[/cyan] Frequency ranges "
|
|
f"[grey62]{len(cfg.ranges)} configured[/grey62]\n"
|
|
f" [cyan]2[/cyan] Band plan "
|
|
f"[grey62]{len(PRESETS)} US presets[/grey62]\n"
|
|
f" [cyan]3[/cyan] Settings "
|
|
f"[grey62]{_summary(cfg)}[/grey62]\n"
|
|
f" [cyan]4[/cyan] Saved settings and profiles\n"
|
|
f" [cyan]5[/cyan] Aircraft (ADS-B) "
|
|
f"[grey62]listen on 1090 MHz, draw where they went[/grey62]\n"
|
|
f" [cyan]6[/cyan] Weather sensors "
|
|
f"[grey62]listen on 433 MHz, name what is out there[/grey62]\n"
|
|
f" [cyan]7[/cyan] APRS (144 MHz packet) "
|
|
f"[grey62]positions, weather and messages from amateurs"
|
|
f"[/grey62]\n"
|
|
f" [cyan]h[/cyan] Help\n"
|
|
f" [cyan]s[/cyan] [bold green]Start scanning[/bold green]\n"
|
|
f" [cyan]q[/cyan] Quit\n")
|
|
choice = _ask(console, " choice", "s").strip().lower()
|
|
|
|
if choice == "1":
|
|
edit_ranges(console, cfg)
|
|
elif choice == "2":
|
|
choose_presets(console, cfg)
|
|
elif choice == "3":
|
|
settings_menu(console, cfg)
|
|
elif choice == "4":
|
|
cfg = profiles_menu(console, cfg)
|
|
elif choice == "5":
|
|
aircraft_menu(console, cfg)
|
|
elif choice == "6":
|
|
weather_menu(console, cfg)
|
|
elif choice == "7":
|
|
aprs_menu(console, cfg)
|
|
elif choice in ("h", "?", "help"):
|
|
help_screen(console)
|
|
elif choice in ("s", "start", "go"):
|
|
errs = cfg.validate()
|
|
if errs:
|
|
for e in errs:
|
|
console.print(f" [red]{e}[/red]")
|
|
continue
|
|
return cfg
|
|
elif choice in ("q", "quit", "exit"):
|
|
return None
|