From 78bd22023cd2826edaab8ca1732d14a770c9de0a Mon Sep 17 00:00:00 2001 From: Dandaedre Date: Thu, 8 Oct 2026 09:39:05 +0200 Subject: [PATCH] feat: add live scan mode --- README.md | 5 + docs/architecture.md | 11 +- docs/testing.md | 5 +- docs/tiny-wb-operations.md | 40 ++++- docs/usb-protocol.md | 8 +- src/acquisition.rs | 247 +++++++++++++++++++++++------ src/error.rs | 3 + src/lib.rs | 1 + src/live.rs | 283 +++++++++++++++++++++++++++++++++ src/main.rs | 22 ++- src/scan.rs | 309 ++++++++++++++++++++++++++++++++++++- src/ui/mod.rs | 113 +++++++++++++- src/ui/state.rs | 24 ++- src/ui/view.rs | 71 +++++++++ task.md | 13 +- 15 files changed, 1082 insertions(+), 73 deletions(-) create mode 100644 src/live.rs diff --git a/README.md b/README.md index 95c294c..eed42ce 100644 --- a/README.md +++ b/README.md @@ -43,6 +43,11 @@ From the repository root: cargo run --release ``` +Use `cargo run --release -- --live` to confirm the usual connection and scan +settings, then display repeated complete sweeps until stopped. Number keys select +average/hold/decay traces, `s` saves the visible buffer, and `q`, Escape, or +Enter stops, resumes the instrument, saves once more, and exits. + On Linux the serial device is commonly `/dev/ttyACM0`; on Windows it appears as a COM port. If the port cannot be opened, follow the [serial-permission guidance](docs/tiny-wb-operations.md#serial-permissions). diff --git a/docs/architecture.md b/docs/architecture.md index 48d2677..fa9e7c4 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -20,7 +20,8 @@ widgets, port discovery, worker threads, or the application's working directory. | `examples/mock-tinysa-server.rs` | Portable TCP listener for the mock, outside release binaries. | | `src/acquisition.rs` | Command ordering, progress events, frame decoding and resume attempts. | | `src/export.rs` | CSV parsing/serialization over I/O traits and collision-safe file export. | -| `src/main.rs` | Select acquisition/direct-view mode, load configuration, start diagnostics, enumerate ports when needed and manage terminal lifetime. | +| `src/live.rs` | Bounded rolling average, hold and decay calculations over explicit sweeps. | +| `src/main.rs` | Select single/live/direct-view mode, load configuration, start diagnostics, enumerate ports when needed and manage terminal lifetime. | | `src/error.rs` | Application/UI boundary errors with original context. | | `src/scan.rs` | Open the configured connection, adapt core events to shared progress, and export successful acquisitions. | | `src/ui/mod.rs` | Screen transitions, keyboard handling, worker startup and progress reconciliation. | @@ -73,6 +74,7 @@ SelectingConnection -> SelectingScan -> Scanning -> Complete -> exit | | | +------------------+-------------+-> Error -> exit CSV file -------------------------------------> Complete -> exit +--live: SelectingConnection -> SelectingScan -> Live --stop+save--> exit ``` The constructor takes configuration and enumerated ports as values, without @@ -87,6 +89,13 @@ Zooming and panning mutate only that viewport, not sample data. This plot boundary can grow into a tabbed collection without coupling CSV parsing or acquisition to Ratatui. +Live mode uses repeated complete snapshots over one configured connection. The +worker publishes only decoded sweeps into a bounded `TraceBuffer`; rendering +copies at most once per completed sweep. Stop and save requests cross the shared +state boundary, while device I/O and CSV creation remain in the worker. Native +continuous `scanraw` is intentionally deferred because it needs verified abort +syntax and stream resynchronization. + The terminal guard restores terminal modes on ordinary returns and unwinding. Configuration and direct-view CSV errors occur before logger initialization; logging and enumeration errors occur before terminal takeover. diff --git a/docs/testing.md b/docs/testing.md index ac03e6e..6aff5e4 100644 --- a/docs/testing.md +++ b/docs/testing.md @@ -15,8 +15,9 @@ cargo test --locked --doc | Configuration | Embedded defaults, legacy flat keys, partial nested overrides, unknown/malformed values, numeric and path bounds, round trips, and failed replacement preservation. | | Protocol | Basic mode boundaries, point/repeat validation, truncated/extra records, alignment, closing brace, binary delimiter bytes, little-endian levels, Basic/Ultra raw offsets, both frequency-axis conventions, and firmware integer/single-precision frequency rounding. | | Transport | One-byte/fragmented reads, multiple responses in one read, retained bytes after prompts, partial writes, invalid command lines, EOF, timeout, response size limits and raw-body framing. | -| Acquisition | Exact command ordering, one retry after an unusable identity reply, optional legacy pre-scan, progress completion, successful decoding, resume after malformed frames, and preservation of acquisition plus recovery errors. | -| UI/startup | Missing/stale ports, numeric overflow and clamping, typed frequency/point commit/cancel/bounds, configured baud rates, sample-resolution plot zoom, adaptive axis precision, pan/reset and clamping, new-scan navigation, view-only CSV behavior, direct CSV startup failures, one-time result transfer, every screen on small/headless terminals, and invalid config before terminal startup. | +| Acquisition | Exact command ordering, one retry after an unusable identity reply, repeated complete live snapshots, optional legacy pre-scan, progress completion, successful decoding, resume after malformed frames, and preservation of acquisition plus recovery errors. | +| Live processing | Four/sixteen-sweep rolling windows, bounded history, min/max hold, one-dB decay, incompatible axes, non-finite input and mode-key mapping. | +| UI/startup | `--live` parsing, missing/stale ports, numeric overflow and clamping, typed frequency/point commit/cancel/bounds, configured baud rates, sample-resolution plot zoom, adaptive axis precision, pan/reset and clamping, new-scan navigation, view-only CSV behavior, direct CSV startup failures, one-time result transfer, every screen on small/headless terminals, and invalid config before terminal startup. | | Export | Header/units, header and headerless parsing, malformed/unordered input, deterministic CSV values, propagated write failures and collision-safe output files. | `Shell` accepts `T: Read + Write`. To add a regression, provide a transcript diff --git a/docs/tiny-wb-operations.md b/docs/tiny-wb-operations.md index b471bfd..a184177 100644 --- a/docs/tiny-wb-operations.md +++ b/docs/tiny-wb-operations.md @@ -17,7 +17,8 @@ can represent it in the UI. | Ultra+ ZS406 0.1–900 MHz | Hardware communications validated | Explicit ZS406/V0.4.6 identity permits the full normal-mode range; RF accuracy is not qualified. | | Ultra+ ZS406 above 900 MHz through 5.4 GHz | Opt-in; hardware communications validated | Requires `scan.enable_ultra_mode = true`, sends `ultra on`, and verifies sweep readback. Expect slower scans, aliases/spurs and RF-port LO leakage. | | ZS407 extended mode or any harmonic mode | Rejected | Their different ceilings and measurement behavior are not implemented. | -| Generator control, live streaming, capture, calibration, firmware update | Out of scope | No corresponding application workflow exists. | +| Repeated-snapshot live display | Implemented; awaiting hardware qualification | `--live` retains a bounded 16-sweep history and one point buffer per derived hold/decay trace. It does not use native continuous framing. | +| Generator control, display capture, calibration, firmware update | Out of scope | No corresponding application workflow exists. | At the exact 350 MHz boundary, the implementation's matching rules matter: low accepts frequencies strictly below 350 MHz, while high accepts 350 MHz @@ -59,6 +60,18 @@ open its renderer directly: Run it from the working directory for your settings and output, or set `TINY_WB_CONFIG` to another configuration path. See [configuration](configuration.md). +For live display, launch: + +```console +./target/release/tiny-wb --live +``` + +Select the connection and scan parameters normally. The configured Points value +is the fixed size of every live sweep and visible/exported trace. tiny-wb opens +one connection, configures it once, and requests repeated complete `scanraw` +snapshots. This deliberately avoids firmware continuous framing until abort and +stream-resynchronization behavior is verified on supported hardware. + ### Serial permissions On Linux, identify the device after plugging it in: @@ -140,6 +153,31 @@ are not available when viewing a CSV directly. Plot bindings are configurable under `[ui.bindings]`; on acquired results, `r` and `n` take precedence over any matching plot binding. `q`, Escape, or Enter exits the renderer. +### Live display + +Live mode updates the plot only after a complete, validated sweep. Its host-side +calculation keys are: + +| Key | Visible buffer | +| --- | --- | +| `1` | Rolling arithmetic average of up to 4 sweeps | +| `2` | Rolling arithmetic average of up to 16 sweeps | +| `3` | Maximum held at each frequency since live capture began | +| `4` | Maximum with a 1 dB fall per completed sweep, limited by the new value | +| `5` | Minimum held at each frequency since live capture began | +| `6` | Minimum with a 1 dB rise per completed sweep, limited by the new value | + +The history is bounded to 16 complete sweeps regardless of run duration. Hold +and decay calculations retain one value per configured point. `s` writes the +currently selected buffer to a new collision-safe CSV while capture continues. +`q`, Escape, or Enter requests a stop; the current sweep is allowed to finish, +the instrument receives `resume`, the selected buffer is saved, and the program +exits. A transport failure is reported rather than exporting a partial frame. + +Subtraction/reference-buffer processing is not implemented yet. The live modes +are host calculations over repeated snapshots, not claims about the firmware's +front-panel detector or trace modes, and require physical-device qualification. + ## Files ### `config.toml` diff --git a/docs/usb-protocol.md b/docs/usb-protocol.md index d556f07..d974abe 100644 --- a/docs/usb-protocol.md +++ b/docs/usb-protocol.md @@ -82,9 +82,11 @@ Constraints visible in upstream firmware: - waterfall is disabled before acquisition in current firmware; - a continuous request must be explicitly aborted and needs a streaming parser. -tiny-wb omits OPTIONS, so it requests one buffered acquisition. The firmware -buffers in small blocks internally; “buffered” does not mean the entire sweep -is delivered in a single USB transfer. +tiny-wb omits OPTIONS, so ordinary acquisition requests one buffered sweep and +`--live` repeats that complete request over one configured connection. The +firmware buffers in small blocks internally; “buffered” does not mean the entire +sweep is delivered in a single USB transfer. Native option-2 continuous framing +remains unsupported until explicit abort and resynchronization are verified. ## Binary response framing diff --git a/src/acquisition.rs b/src/acquisition.rs index 27b9abd..9a79cde 100644 --- a/src/acquisition.rs +++ b/src/acquisition.rs @@ -108,13 +108,85 @@ pub fn acquire( serial: &SerialConfig, mut report: impl FnMut(ScanEvent), ) -> Result, AcquisitionError> { + let prepared = prepare_acquisition(shell, request, scan, serial, &mut report)?; + // Pause may take effect even when its response times out, so recovery also + // covers failure receiving the pause response itself. + let result = (|| { + configure_paused(shell, request, scan, serial, prepared)?; + report(ScanEvent::Message("Acquiring samples")); + let frame = read_snapshot(shell, request, &mut report)?; + Ok(protocol::decode_frame( + &frame, + request, + prepared.zero_offset, + scan.frequency_axis, + )?) + })(); + let samples = resume_after(shell, prepared, result)?; + report(ScanEvent::Message("Acquisition complete")); + report(ScanEvent::Progress(100)); + Ok(samples) +} + +/// Repeatedly acquire complete bounded snapshots on one configured connection. +/// +/// This deliberately does not use firmware continuous framing. Cancellation is +/// checked before each snapshot, so an in-progress sweep completes before the +/// instrument is resumed. `on_sweep` receives only fully decoded frames. +/// +/// # Errors +/// +/// Returns an error when validation, device identification, configuration, +/// transport, frame decoding, or the final resume command fails. When both +/// acquisition and resume fail, both errors are retained. +pub fn acquire_live( + shell: &mut Shell, + request: &ScanRequest, + scan: &ScanConfig, + serial: &SerialConfig, + mut should_stop: impl FnMut() -> bool, + mut on_sweep: impl FnMut(Vec), + mut report: impl FnMut(ScanEvent), +) -> Result { + let prepared = prepare_acquisition(shell, request, scan, serial, &mut report)?; + let result = (|| { + configure_paused(shell, request, scan, serial, prepared)?; + report(ScanEvent::Message("Live capture running")); + let mut sweeps = 0_u64; + while !should_stop() { + let frame = read_snapshot(shell, request, &mut report)?; + let samples = + protocol::decode_frame(&frame, request, prepared.zero_offset, scan.frequency_axis)?; + sweeps = sweeps.saturating_add(1); + on_sweep(samples); + } + Ok(sweeps) + })(); + resume_after(shell, prepared, result) +} + +#[derive(Clone, Copy)] +struct PreparedAcquisition { + delay: Duration, + settle: Duration, + plan: crate::device::AcquisitionPlan, + zero_offset: u16, +} + +fn prepare_acquisition( + shell: &mut Shell, + request: &ScanRequest, + scan: &ScanConfig, + serial: &SerialConfig, + report: &mut impl FnMut(ScanEvent), +) -> Result { request.validate()?; let delay = Duration::from_millis(serial.command_delay_ms); let settle = Duration::from_millis(serial.settle_delay_ms); report(ScanEvent::Message("Identifying instrument")); report(ScanEvent::Progress(5)); shell.synchronize()?; - let identity = identify_with_retry(shell, delay, settle, &mut report)?; + let identity = identify_with_retry(shell, delay, settle, report)?; let expected = match scan.device_model { ModelSelection::Auto => None, ModelSelection::Basic => Some(DeviceModel::Basic), @@ -176,59 +248,82 @@ pub fn acquire( None => { return Err(AcquisitionError::MissingZeroReadback { requested: zero_offset, - }); + }) } } report(ScanEvent::Progress(20)); - // Pause may take effect even when its response times out, so recovery also - // covers failure receiving the pause response itself. - let result = (|| { - shell.command_checked("pause", delay, settle)?; - shell.command_checked(plan.input_command, delay, settle)?; - if plan.enable_ultra_mode { - shell.command_checked("ultra on", delay, settle)?; - } - shell.command_checked(&format!("sweep start {}", request.start_hz), delay, settle)?; - shell.command_checked(&format!("sweep stop {}", request.stop_hz), delay, settle)?; - let sweep_response = shell.command_checked("sweep", delay, settle)?; - if plan.enable_ultra_mode - && parse_sweep_bounds(&sweep_response) != Some((request.start_hz, request.stop_hz)) - { - return Err(AcquisitionError::SweepReadbackMismatch { - requested_start: request.start_hz, - requested_stop: request.stop_hz, - response: sweep_response, - }); - } - if scan.legacy_pre_scan { - shell.command_checked( - &format!("scan {} {} 290 101", request.start_hz, request.stop_hz), - Duration::from_millis(serial.scan_delay_ms), - settle, - )?; - } - report(ScanEvent::Message("Acquiring samples")); - shell.send(&format!( - "scanraw {} {} {}", - request.start_hz, request.stop_hz, request.points - ))?; - let frame = shell.read_frame(request, |received, expected| { - report(ScanEvent::Progress((20 + received * 75 / expected) as u8)) - })?; - Ok(protocol::decode_frame( - &frame, - request, - zero_offset, - scan.frequency_axis, - )?) - })(); - let recovery = shell.command_checked("resume", delay, settle); + Ok(PreparedAcquisition { + delay, + settle, + plan, + zero_offset, + }) +} + +fn configure_paused( + shell: &mut Shell, + request: &ScanRequest, + scan: &ScanConfig, + serial: &SerialConfig, + prepared: PreparedAcquisition, +) -> Result<(), AcquisitionError> { + shell.command_checked("pause", prepared.delay, prepared.settle)?; + shell.command_checked(prepared.plan.input_command, prepared.delay, prepared.settle)?; + if prepared.plan.enable_ultra_mode { + shell.command_checked("ultra on", prepared.delay, prepared.settle)?; + } + shell.command_checked( + &format!("sweep start {}", request.start_hz), + prepared.delay, + prepared.settle, + )?; + shell.command_checked( + &format!("sweep stop {}", request.stop_hz), + prepared.delay, + prepared.settle, + )?; + let sweep_response = shell.command_checked("sweep", prepared.delay, prepared.settle)?; + if prepared.plan.enable_ultra_mode + && parse_sweep_bounds(&sweep_response) != Some((request.start_hz, request.stop_hz)) + { + return Err(AcquisitionError::SweepReadbackMismatch { + requested_start: request.start_hz, + requested_stop: request.stop_hz, + response: sweep_response, + }); + } + if scan.legacy_pre_scan { + shell.command_checked( + &format!("scan {} {} 290 101", request.start_hz, request.stop_hz), + Duration::from_millis(serial.scan_delay_ms), + prepared.settle, + )?; + } + Ok(()) +} + +fn read_snapshot( + shell: &mut Shell, + request: &ScanRequest, + report: &mut impl FnMut(ScanEvent), +) -> Result, AcquisitionError> { + shell.send(&format!( + "scanraw {} {} {}", + request.start_hz, request.stop_hz, request.points + ))?; + Ok(shell.read_frame(request, |received, expected| { + report(ScanEvent::Progress((20 + received * 75 / expected) as u8)) + })?) +} + +fn resume_after( + shell: &mut Shell, + prepared: PreparedAcquisition, + result: Result, +) -> Result { + let recovery = shell.command_checked("resume", prepared.delay, prepared.settle); match (result, recovery) { - (Ok(samples), Ok(_)) => { - report(ScanEvent::Message("Acquisition complete")); - report(ScanEvent::Progress(100)); - Ok(samples) - } + (Ok(value), Ok(_)) => Ok(value), (Err(primary), Err(recovery)) => Err(AcquisitionError::Recovery { primary: Box::new(primary), recovery, @@ -298,6 +393,7 @@ mod tests { use super::*; use crate::config::Config; use std::{ + cell::Cell, io::{self, Cursor}, sync::{Arc, Mutex}, }; @@ -431,6 +527,57 @@ mod tests { assert!(events.contains(&ScanEvent::Message("Retrying instrument identification"))); } + #[test] + fn live_acquisition_repeats_complete_snapshots_then_resumes() { + let config = Config::from_toml( + "[scan]\nlegacy_pre_scan=false\n[serial]\ncommand_delay_ms=0\nsettle_delay_ms=0", + ) + .unwrap(); + let request = ScanRequest { + start_hz: 240_000_000, + stop_hz: 960_000_000, + points: 2, + repeat: 1, + }; + let mut input = b"ch>tinySA_v1.4-test\r\nch>tinySA\r\nch>Commands: repeat zero pause mode sweep scanraw resume\r\nch>" + .to_vec(); + input.extend_from_slice(b"okch>".repeat(2).as_slice()); + input.extend_from_slice(b"128dBm\r\nch>"); + input.extend_from_slice(b"okch>".repeat(5).as_slice()); + input.extend_from_slice(b"{x\0\x08x\0\x10}ch>"); + input.extend_from_slice(b"{x\0\x10x\0\x18}ch>okch>"); + let commands = Arc::new(Mutex::new(Vec::new())); + let mut shell = Shell::new( + Transcript { + input: Cursor::new(input), + commands: commands.clone(), + }, + 1024, + ); + let received = Cell::new(0_u64); + let mut levels = Vec::new(); + + let sweeps = acquire_live( + &mut shell, + &request, + &config.scan, + &config.serial, + || received.get() == 2, + |samples| { + received.set(received.get() + 1); + levels.push(samples[0].level_dbm); + }, + |_| {}, + ) + .unwrap(); + + assert_eq!(sweeps, 2); + assert_eq!(levels, vec![-64.0, 0.0]); + let written = String::from_utf8(commands.lock().unwrap().clone()).unwrap(); + assert_eq!(written.matches("scanraw ").count(), 2); + assert!(written.ends_with("resume\r")); + } + #[test] fn malformed_frames_still_resume_and_preserve_original_error() { let (result, commands, _) = exercise(b"{y\0\x08x\0\x10}", true, true); diff --git a/src/error.rs b/src/error.rs index 7ef4d41..3b9e49a 100644 --- a/src/error.rs +++ b/src/error.rs @@ -29,6 +29,9 @@ pub(crate) enum AppError { /// Acquisition failed, potentially including a failed resume attempt. #[error(transparent)] Acquisition(#[from] tiny_wb::acquisition::AcquisitionError), + /// Host-side live trace processing failed. + #[error("live capture: {0}")] + Live(String), /// The file logger could not be initialized. #[error("logging: {0}")] Logger(#[from] flexi_logger::FlexiLoggerError), diff --git a/src/lib.rs b/src/lib.rs index 06d9d7c..5475b20 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -27,6 +27,7 @@ pub mod config; pub mod connection; pub mod device; pub mod export; +pub mod live; /// Opt-in deterministic simulator and TCP server support. #[cfg(feature = "mock")] pub mod mock; diff --git a/src/live.rs b/src/live.rs new file mode 100644 index 0000000..c5e13d8 --- /dev/null +++ b/src/live.rs @@ -0,0 +1,283 @@ +//! Bounded host-side processing for repeated live scan snapshots. +//! +//! This module owns no device, terminal or file. It retains at most sixteen +//! complete sweeps and one value per point for each hold/decay trace. + +use crate::protocol::Sample; +use std::{collections::VecDeque, fmt}; + +/// Host-side trace calculation shown and exported by live mode. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum TraceMode { + /// Rolling arithmetic mean of up to four completed sweeps. + Average4, + /// Rolling arithmetic mean of up to sixteen completed sweeps. + Average16, + /// Highest value observed at every frequency since capture began. + MaxHold, + /// Maximum trace that falls by 1 dB per completed sweep. + MaxDecay, + /// Lowest value observed at every frequency since capture began. + MinHold, + /// Minimum trace that rises by 1 dB per completed sweep. + MinDecay, +} + +impl TraceMode { + /// Resolve the live-mode number-key binding. + pub fn from_key(key: char) -> Option { + match key { + '1' => Some(Self::Average4), + '2' => Some(Self::Average16), + '3' => Some(Self::MaxHold), + '4' => Some(Self::MaxDecay), + '5' => Some(Self::MinHold), + '6' => Some(Self::MinDecay), + _ => None, + } + } +} + +impl fmt::Display for TraceMode { + fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + formatter.write_str(match self { + Self::Average4 => "average 4", + Self::Average16 => "average 16", + Self::MaxHold => "max hold", + Self::MaxDecay => "max decay", + Self::MinHold => "min hold", + Self::MinDecay => "min decay", + }) + } +} + +/// A malformed or incompatible sweep supplied to [`TraceBuffer`]. +#[derive(Debug, thiserror::Error, PartialEq)] +pub enum LiveTraceError { + /// Live traces require at least one point. + #[error("a live sweep cannot be empty")] + Empty, + /// Every sweep must retain the configured point count. + #[error("live sweep has {actual} points; expected {expected}")] + PointCount { + /// Point count established by the first sweep. + expected: usize, + /// Point count in the rejected sweep. + actual: usize, + }, + /// A point's frequency changed between repeated snapshots. + #[error( + "live sweep frequency changed at point {index}: expected {expected} MHz, got {actual} MHz" + )] + Frequency { + /// Zero-based point index. + index: usize, + /// Frequency established by the first sweep, in MHz. + expected: f64, + /// Frequency in the rejected sweep, in MHz. + actual: f64, + }, + /// Input values must remain finite before processing. + #[error("live sweep contains a non-finite value at point {index}")] + NonFinite { + /// Zero-based point index. + index: usize, + }, +} + +/// Bounded rolling history and derived hold/decay traces. +#[derive(Debug, Default)] +pub struct TraceBuffer { + history: VecDeque>, + max_hold: Vec, + max_decay: Vec, + min_hold: Vec, + min_decay: Vec, + sweeps: u64, +} + +impl TraceBuffer { + /// Add one complete sweep, rejecting axis or point-count changes. + /// + /// # Errors + /// + /// Returns [`LiveTraceError`] for an empty sweep, non-finite values, or a + /// point count or frequency axis that differs from the retained history. + /// Rejected input does not change the buffer. + pub fn push(&mut self, samples: Vec) -> Result<(), LiveTraceError> { + if samples.is_empty() { + return Err(LiveTraceError::Empty); + } + for (index, sample) in samples.iter().enumerate() { + if !sample.frequency_mhz.is_finite() || !sample.level_dbm.is_finite() { + return Err(LiveTraceError::NonFinite { index }); + } + } + if let Some(previous) = self.history.back() { + if previous.len() != samples.len() { + return Err(LiveTraceError::PointCount { + expected: previous.len(), + actual: samples.len(), + }); + } + for (index, (expected, actual)) in previous.iter().zip(&samples).enumerate() { + if expected.frequency_mhz != actual.frequency_mhz { + return Err(LiveTraceError::Frequency { + index, + expected: expected.frequency_mhz, + actual: actual.frequency_mhz, + }); + } + } + } + if self.history.is_empty() { + let levels: Vec<_> = samples.iter().map(|sample| sample.level_dbm).collect(); + self.max_hold = levels.clone(); + self.max_decay = levels.clone(); + self.min_hold = levels.clone(); + self.min_decay = levels; + } else { + for (index, sample) in samples.iter().enumerate() { + self.max_hold[index] = self.max_hold[index].max(sample.level_dbm); + self.min_hold[index] = self.min_hold[index].min(sample.level_dbm); + self.max_decay[index] = (self.max_decay[index] - 1.0).max(sample.level_dbm); + self.min_decay[index] = (self.min_decay[index] + 1.0).min(sample.level_dbm); + } + } + self.history.push_back(samples); + if self.history.len() > 16 { + self.history.pop_front(); + } + self.sweeps = self.sweeps.saturating_add(1); + Ok(()) + } + + /// Number of complete sweeps incorporated since the last reset. + pub fn sweeps(&self) -> u64 { + self.sweeps + } + + /// Produce the selected trace with the original frequency axis. + pub fn trace(&self, mode: TraceMode) -> Option> { + let latest = self.history.back()?; + let levels = match mode { + TraceMode::Average4 => return Some(self.average(4)), + TraceMode::Average16 => return Some(self.average(16)), + TraceMode::MaxHold => &self.max_hold, + TraceMode::MaxDecay => &self.max_decay, + TraceMode::MinHold => &self.min_hold, + TraceMode::MinDecay => &self.min_decay, + }; + Some( + latest + .iter() + .zip(levels) + .map(|(sample, level)| Sample { + frequency_mhz: sample.frequency_mhz, + level_dbm: *level, + }) + .collect(), + ) + } + + fn average(&self, count: usize) -> Vec { + let used = self.history.len().min(count); + let start = self.history.len() - used; + let latest = self.history.back().expect("average requires one sweep"); + latest + .iter() + .enumerate() + .map(|(index, sample)| Sample { + frequency_mhz: sample.frequency_mhz, + level_dbm: self + .history + .iter() + .skip(start) + .map(|sweep| sweep[index].level_dbm) + .sum::() + / used as f64, + }) + .collect() + } +} + +#[cfg(test)] +mod tests { + use super::*; + + fn sweep(levels: &[f64]) -> Vec { + levels + .iter() + .enumerate() + .map(|(index, level)| Sample { + frequency_mhz: 100.0 + index as f64, + level_dbm: *level, + }) + .collect() + } + + fn levels(buffer: &TraceBuffer, mode: TraceMode) -> Vec { + buffer + .trace(mode) + .unwrap() + .into_iter() + .map(|sample| sample.level_dbm) + .collect() + } + + #[test] + fn rolling_averages_are_bounded_to_four_and_sixteen_sweeps() { + let mut buffer = TraceBuffer::default(); + for level in 1..=20 { + buffer.push(sweep(&[f64::from(level)])).unwrap(); + } + assert_eq!(buffer.history.len(), 16); + assert_eq!(levels(&buffer, TraceMode::Average4), vec![18.5]); + assert_eq!(levels(&buffer, TraceMode::Average16), vec![12.5]); + assert_eq!(buffer.sweeps(), 20); + } + + #[test] + fn holds_and_one_db_decay_follow_deterministic_sequences() { + let mut buffer = TraceBuffer::default(); + buffer.push(sweep(&[-10.0, -30.0])).unwrap(); + buffer.push(sweep(&[-20.0, -20.0])).unwrap(); + assert_eq!(levels(&buffer, TraceMode::MaxHold), vec![-10.0, -20.0]); + assert_eq!(levels(&buffer, TraceMode::MinHold), vec![-20.0, -30.0]); + assert_eq!(levels(&buffer, TraceMode::MaxDecay), vec![-11.0, -20.0]); + assert_eq!(levels(&buffer, TraceMode::MinDecay), vec![-20.0, -29.0]); + } + + #[test] + fn incompatible_or_non_finite_sweeps_are_rejected_without_mutation() { + let mut buffer = TraceBuffer::default(); + assert_eq!(buffer.push(Vec::new()), Err(LiveTraceError::Empty)); + buffer.push(sweep(&[-10.0, -20.0])).unwrap(); + assert!(matches!( + buffer.push(sweep(&[-10.0])), + Err(LiveTraceError::PointCount { .. }) + )); + let mut changed = sweep(&[-10.0, -20.0]); + changed[1].frequency_mhz = 999.0; + assert!(matches!( + buffer.push(changed), + Err(LiveTraceError::Frequency { .. }) + )); + assert!(matches!( + buffer.push(sweep(&[f64::NAN, -20.0])), + Err(LiveTraceError::NonFinite { .. }) + )); + assert_eq!(buffer.sweeps(), 1); + } + + #[test] + fn number_keys_select_every_supported_mode() { + assert_eq!(TraceMode::from_key('1'), Some(TraceMode::Average4)); + assert_eq!(TraceMode::from_key('2'), Some(TraceMode::Average16)); + assert_eq!(TraceMode::from_key('3'), Some(TraceMode::MaxHold)); + assert_eq!(TraceMode::from_key('4'), Some(TraceMode::MaxDecay)); + assert_eq!(TraceMode::from_key('5'), Some(TraceMode::MinHold)); + assert_eq!(TraceMode::from_key('6'), Some(TraceMode::MinDecay)); + assert_eq!(TraceMode::from_key('7'), None); + } +} diff --git a/src/main.rs b/src/main.rs index 775bd45..983b711 100644 --- a/src/main.rs +++ b/src/main.rs @@ -15,6 +15,8 @@ use tiny_wb::config::{Backend, Config}; enum StartMode { /// Configure and acquire a new scan. Acquire, + /// Configure and run repeated snapshots until the user stops them. + Live, /// Open an existing CSV directly in the renderer. View(PathBuf), /// Print command help without loading configuration. @@ -26,12 +28,15 @@ fn parse_start_mode(args: impl IntoIterator) -> Result = args.into_iter().collect(); match args.as_slice() { [] => Ok(StartMode::Acquire), + [flag] if flag == "--live" => Ok(StartMode::Live), [flag] if flag == "-h" || flag == "--help" => Ok(StartMode::Help), [flag, path] if flag == "--view" => Ok(StartMode::View(PathBuf::from(path))), [path] if !path.to_string_lossy().starts_with('-') => { Ok(StartMode::View(PathBuf::from(path))) } - _ => Err(AppError::Usage("usage: tiny-wb [--view] [SCAN.csv]".into())), + _ => Err(AppError::Usage( + "usage: tiny-wb [--live | --view SCAN.csv | SCAN.csv]".into(), + )), } } @@ -49,7 +54,7 @@ fn main() -> Result<(), AppError> { color_eyre::install()?; let mode = parse_start_mode(std::env::args_os().skip(1))?; if mode == StartMode::Help { - println!("tiny-wb [--view] [SCAN.csv]\n\nWith no CSV, acquire a scan. With a CSV path, open the plot renderer directly."); + println!("tiny-wb [--live | --view SCAN.csv | SCAN.csv]\n\nWith no option, acquire one scan. --live repeats complete snapshots until stopped. With a CSV path, open the plot renderer directly."); return Ok(()); } let config_path = std::env::var_os("TINY_WB_CONFIG") @@ -82,8 +87,9 @@ fn main() -> Result<(), AppError> { .log_to_file(FileSpec::default().directory(&config.logging.directory)) .write_mode(WriteMode::BufferAndFlush) .start()?; + let live_mode = mode == StartMode::Live; let mut app = match mode { - StartMode::Acquire => { + StartMode::Acquire | StartMode::Live => { let ports = match config.connection.backend { Backend::Serial => serialport::available_ports()?, Backend::Tcp => vec![serialport::SerialPortInfo { @@ -91,7 +97,11 @@ fn main() -> Result<(), AppError> { port_type: serialport::SerialPortType::Unknown, }], }; - ui::App::new(ports, config, config_path) + if live_mode { + ui::App::live(ports, config, config_path) + } else { + ui::App::new(ports, config, config_path) + } } StartMode::View(path) => ui::App::viewer( config, @@ -113,6 +123,10 @@ mod tests { #[test] fn command_line_selects_acquisition_help_and_csv_viewer() { assert_eq!(parse_start_mode([]).unwrap(), StartMode::Acquire); + assert_eq!( + parse_start_mode([OsString::from("--live")]).unwrap(), + StartMode::Live + ); assert_eq!( parse_start_mode([OsString::from("--help")]).unwrap(), StartMode::Help diff --git a/src/scan.rs b/src/scan.rs index 160059a..ca95afc 100644 --- a/src/scan.rs +++ b/src/scan.rs @@ -9,10 +9,12 @@ use std::{ sync::{Arc, Mutex, MutexGuard}, }; use tiny_wb::{ - acquisition::{acquire, ScanEvent}, + acquisition::{acquire, acquire_live, ScanEvent}, config::Config, connection::open_connection, export::save_csv, + live::{TraceBuffer, TraceMode}, + protocol::Sample, protocol::ScanRequest, transport::Shell, }; @@ -54,6 +56,64 @@ struct Progress { #[derive(Debug, Clone, Default)] pub(crate) struct ScanState(Arc>); +/// Shared repeated-snapshot state for the live terminal screen. +#[derive(Debug, Clone)] +pub(crate) struct LiveState(Arc>); + +/// One coherent live snapshot and its control flags. +#[derive(Debug)] +struct LiveProgress { + /// Worker lifecycle. + status: ScanStatus, + /// Current operation or save result. + message: String, + /// Verbatim device identity. + info: String, + /// Failure retained for the error screen. + error: Option, + /// Bounded raw history and derived traces. + trace: TraceBuffer, + /// Calculation selected by the terminal. + mode: TraceMode, + /// Monotonic renderer invalidation counter. + generation: u64, + /// Graceful cancellation requested by the terminal. + stop_requested: bool, + /// Visible trace captured for the next worker-side intermediate export. + pending_save: Option>, + /// Save requested before the first complete sweep became available. + save_after_first: bool, +} + +/// Renderer-owned copy of one derived live trace. +pub(crate) struct LiveSnapshot { + /// Monotonic state generation. + pub(crate) generation: u64, + /// Selected host-side calculation. + pub(crate) mode: TraceMode, + /// Complete sweeps incorporated in the calculation. + pub(crate) sweeps: u64, + /// Plot-ready `(MHz, dBm)` points. + pub(crate) data: Vec<(f64, f64)>, +} + +impl Default for LiveState { + fn default() -> Self { + Self(Arc::new(Mutex::new(LiveProgress { + status: ScanStatus::Ready, + message: String::new(), + info: String::new(), + error: None, + trace: TraceBuffer::default(), + mode: TraceMode::Average4, + generation: 0, + stop_requested: false, + pending_save: None, + save_after_first: false, + }))) + } +} + impl ScanState { /// Recover telemetry after a poisoned lock rather than panic in error rendering. fn lock(&self) -> MutexGuard<'_, Progress> { @@ -125,6 +185,169 @@ impl ScanState { } } +impl LiveState { + /// Recover shared live state after a poisoned worker lock. + fn lock(&self) -> MutexGuard<'_, LiveProgress> { + self.0 + .lock() + .unwrap_or_else(std::sync::PoisonError::into_inner) + } + + /// Reset all bounded history and control flags for a new live run. + pub(crate) fn begin(&self) { + let mut state = self.lock(); + *state = LiveProgress { + status: ScanStatus::Running, + message: "Opening live connection".into(), + info: String::new(), + error: None, + trace: TraceBuffer::default(), + mode: TraceMode::Average4, + generation: state.generation.saturating_add(1), + stop_requested: false, + pending_save: None, + save_after_first: false, + }; + } + + /// Adapt core acquisition events without exposing the terminal to the core. + fn report(&self, event: ScanEvent) { + let mut state = self.lock(); + match event { + ScanEvent::Message(message) => state.message = message.into(), + ScanEvent::InstrumentInfo(info) => state.info = info, + ScanEvent::Progress(_) => {} + } + } + + /// Incorporate one decoded complete sweep. + fn publish(&self, samples: Vec) -> Result<(), tiny_wb::live::LiveTraceError> { + let mut state = self.lock(); + state.trace.push(samples)?; + state.generation = state.generation.saturating_add(1); + state.message = format!("Live capture — {} sweeps", state.trace.sweeps()); + Ok(()) + } + + /// Return a rendered trace only when samples or the selected mode changed. + pub(crate) fn snapshot_after(&self, generation: u64) -> Option { + let state = self.lock(); + if state.generation == generation { + return None; + } + state.trace.trace(state.mode).map(|samples| LiveSnapshot { + generation: state.generation, + mode: state.mode, + sweeps: state.trace.sweeps(), + data: samples + .into_iter() + .map(|sample| (sample.frequency_mhz, sample.level_dbm)) + .collect(), + }) + } + + /// Copy the selected calculation for worker-side CSV export. + fn samples(&self) -> Option> { + let state = self.lock(); + state.trace.trace(state.mode) + } + + /// Select a host-side calculation without discarding its retained history. + pub(crate) fn set_mode(&self, mode: TraceMode) { + let mut state = self.lock(); + if state.mode != mode { + state.mode = mode; + state.generation = state.generation.saturating_add(1); + } + } + + /// Current host-side calculation. + pub(crate) fn mode(&self) -> TraceMode { + self.lock().mode + } + + /// Capture the visible trace for worker-side export after the current sweep. + pub(crate) fn request_save(&self) { + let mut state = self.lock(); + if let Some(samples) = state.trace.trace(state.mode) { + state.pending_save = Some(samples); + state.message = "Save requested for the visible buffer".into(); + } else { + state.save_after_first = true; + state.message = "Save requested; waiting for the first complete sweep".into(); + } + } + + /// Consume one captured intermediate export, deferring an early request. + fn take_save_request(&self) -> Option> { + let mut state = self.lock(); + if let Some(samples) = state.pending_save.take() { + return Some(samples); + } + if state.save_after_first { + if let Some(samples) = state.trace.trace(state.mode) { + state.save_after_first = false; + return Some(samples); + } + } + None + } + + /// Request cancellation after the current sweep completes. + pub(crate) fn request_stop(&self) { + let mut state = self.lock(); + state.stop_requested = true; + state.message = "Stopping after the current sweep".into(); + } + + /// Whether the worker should refrain from starting another snapshot. + fn should_stop(&self) -> bool { + self.lock().stop_requested + } + + /// Report a successful intermediate export without stopping capture. + fn saved(&self, path: &std::path::Path) { + self.lock().message = format!("Saved {}; live capture continues", path.display()); + } + + /// Publish final export and recovery completion together. + fn complete(&self, path: Option<&std::path::Path>) { + let mut state = self.lock(); + state.status = ScanStatus::Complete; + state.message = path.map_or_else( + || "Live capture stopped before the first complete sweep".into(), + |path| format!("Saved {} and stopped live capture", path.display()), + ); + } + + /// Record a worker failure for the terminal error screen. + pub(crate) fn fail(&self, error: impl std::fmt::Display) { + let mut state = self.lock(); + state.error = Some(error.to_string()); + state.status = ScanStatus::Failed; + } + + /// Current live worker lifecycle. + pub(crate) fn status(&self) -> ScanStatus { + self.lock().status + } + + /// Current live operation or save result. + pub(crate) fn message(&self) -> String { + self.lock().message.clone() + } + + /// Device identification text received by the live worker. + pub(crate) fn info(&self) -> String { + self.lock().info.clone() + } + + /// Live worker failure, when present. + pub(crate) fn error(&self) -> Option { + self.lock().error.clone() + } +} + /// Open one port, acquire through the reusable core, then export valid samples. pub(crate) fn run_scan( state: ScanState, @@ -157,6 +380,58 @@ pub(crate) fn run_scan( Ok(()) } +/// Keep one connection configured while acquiring repeated complete snapshots. +pub(crate) fn run_live( + state: LiveState, + request: ScanRequest, + config: Config, +) -> Result<(), AppError> { + if state.status() == ScanStatus::Ready { + state.begin(); + } + config.validate()?; + request + .validate() + .map_err(tiny_wb::acquisition::AcquisitionError::from)?; + let port = open_connection(&config)?; + let mut shell = Shell::new(port, config.serial.max_response_bytes); + let callback_state = state.clone(); + let output = config.output.clone(); + acquire_live( + &mut shell, + &request, + &config.scan, + &config.serial, + || state.should_stop(), + move |samples| { + if let Err(error) = callback_state.publish(samples) { + callback_state.fail(error); + callback_state.request_stop(); + return; + } + if let Some(samples) = callback_state.take_save_request() { + match save_csv(&samples, &output) { + Ok(path) => callback_state.saved(&path), + Err(error) => { + callback_state.fail(error); + callback_state.request_stop(); + } + } + } + }, + |event| state.report(event), + )?; + if let Some(error) = state.error() { + return Err(AppError::Live(error)); + } + let saved = match state.samples() { + Some(samples) => Some(save_csv(&samples, &config.output)?), + None => None, + }; + state.complete(saved.as_deref()); + Ok(()) +} + #[cfg(test)] mod tests { use super::*; @@ -197,4 +472,36 @@ mod tests { assert!(state.error().is_none()); assert!(state.take_samples().is_err()); } + + #[test] + fn live_state_publishes_modes_and_control_requests_coherently() { + let state = LiveState::default(); + state.begin(); + state + .publish(vec![Sample { + frequency_mhz: 240.0, + level_dbm: -64.0, + }]) + .unwrap(); + let snapshot = state.snapshot_after(0).unwrap(); + assert_eq!(snapshot.mode, TraceMode::Average4); + assert_eq!(snapshot.sweeps, 1); + assert_eq!(snapshot.data, vec![(240.0, -64.0)]); + assert!(state.snapshot_after(snapshot.generation).is_none()); + + state.set_mode(TraceMode::MaxHold); + assert_eq!(state.mode(), TraceMode::MaxHold); + assert!(state.snapshot_after(snapshot.generation).is_some()); + state.request_save(); + state + .publish(vec![Sample { + frequency_mhz: 240.0, + level_dbm: -20.0, + }]) + .unwrap(); + assert_eq!(state.take_save_request().unwrap()[0].level_dbm, -64.0); + assert!(state.take_save_request().is_none()); + state.request_stop(); + assert!(state.should_stop()); + } } diff --git a/src/ui/mod.rs b/src/ui/mod.rs index fff7736..45c28e6 100644 --- a/src/ui/mod.rs +++ b/src/ui/mod.rs @@ -21,7 +21,7 @@ use state::{ }; use std::{path::PathBuf, thread, time::Duration}; use strum::EnumCount; -use tiny_wb::{config::Config, protocol::ScanRequest}; +use tiny_wb::{config::Config, live::TraceMode, protocol::ScanRequest}; impl App { /// Construct UI state from already validated settings; no file I/O here. @@ -53,6 +53,10 @@ impl App { ), repeat: NumericInput::new(config.repeat, 1, 1, config.scan.max_repeat), scan_state: ScanState::default(), + live_state: scan::LiveState::default(), + live_enabled: false, + live_generation: 0, + live_exit_requested: false, plot: None, last_scan: None, can_acquire: true, @@ -61,6 +65,13 @@ impl App { } } + /// Construct an acquisition UI whose confirmed settings launch live mode. + pub(crate) fn live(info: Vec, config: Config, config_path: PathBuf) -> Self { + let mut app = Self::new(info, config, config_path); + app.live_enabled = true; + app + } + /// Construct the renderer directly from an already parsed CSV plot. pub(crate) fn viewer(config: Config, source: PathBuf, data: Vec<(f64, f64)>) -> Self { let mut app = Self::new(Vec::new(), config, PathBuf::new()); @@ -81,6 +92,7 @@ impl App { self.scan_state.fail(error); self.flow_state = AppState::Error; } + self.refresh_live(); let mut draw_error = None; terminal.draw(|frame| { draw_error = self.draw(frame).err(); @@ -88,6 +100,9 @@ impl App { if let Some(error) = draw_error { return Err(error.into()); } + if self.should_quit { + break; + } let timeout = Duration::from_millis(self.config.ui.poll_interval_ms); if event::poll(timeout)? { if let Event::Key(key) = event::read()? { @@ -96,9 +111,6 @@ impl App { self.flow_state = AppState::Error; }; }; - if self.should_quit { - break; - } } } Ok(()) @@ -153,6 +165,9 @@ impl App { if matches!(self.flow_state, AppState::Complete) { return self.handle_plot_key(key.code); } + if matches!(self.flow_state, AppState::Live) { + return self.handle_live_key(key.code); + } if self.handle_numeric_editor_key(key.code) { return Ok(()); } @@ -171,6 +186,24 @@ impl App { Ok(()) } + /// Apply live processing, save and graceful-stop controls. + fn handle_live_key(&mut self, code: KeyCode) -> Result<(), UiError> { + match code { + KeyCode::Char('q') | KeyCode::Esc | KeyCode::Enter => { + self.live_exit_requested = true; + self.live_state.request_stop(); + } + KeyCode::Char('s') => self.live_state.request_save(), + KeyCode::Char(key) => { + if let Some(mode) = TraceMode::from_key(key) { + self.live_state.set_mode(mode); + } + } + _ => {} + } + Ok(()) + } + /// Give an active direct-entry editor exclusive use of keys and start one on a digit. fn handle_numeric_editor_key(&mut self, code: KeyCode) -> bool { let input = match self.flow_state { @@ -260,6 +293,7 @@ impl App { }, AppState::Complete => (), AppState::Scanning => (), + AppState::Live => (), AppState::Error => (), } } @@ -299,6 +333,7 @@ impl App { } AppState::Complete => None, AppState::Scanning => None, + AppState::Live => None, AppState::Error => None, } { self.flow_state = s; @@ -322,6 +357,7 @@ impl App { self.should_quit = true; } AppState::Scanning => {} + AppState::Live => {} AppState::Error => { self.should_quit = true; } @@ -343,7 +379,11 @@ impl App { .map_err(tiny_wb::acquisition::AcquisitionError::from) .map_err(AppError::from)?; config.save(&self.config_path).map_err(AppError::from)?; - self.launch_scan(request, config) + if self.live_enabled { + self.launch_live(request, config) + } else { + self.launch_scan(request, config) + } } /// Relaunch the exact request and settings used by the previous scan. @@ -369,6 +409,22 @@ impl App { }); Ok(()) } + + /// Reset live history and start one persistent repeated-snapshot worker. + fn launch_live(&mut self, request: ScanRequest, config: Config) -> Result<(), UiError> { + self.live_state.begin(); + self.live_generation = 0; + self.live_exit_requested = false; + self.flow_state = AppState::Live; + self.plot = None; + let live = self.live_state.clone(); + thread::spawn(move || { + if let Err(error) = scan::run_live(live.clone(), request, config) { + live.fail(error); + } + }); + Ok(()) + } /// Transfer completed samples once and keep rendering free of transitions. fn refresh_scan(&mut self) -> Result<(), UiError> { if matches!(self.flow_state, AppState::Scanning) { @@ -384,6 +440,34 @@ impl App { } Ok(()) } + + /// Copy at most one newly completed live trace into renderer-owned storage. + fn refresh_live(&mut self) { + if !matches!(self.flow_state, AppState::Live) { + return; + } + if let Some(snapshot) = self.live_state.snapshot_after(self.live_generation) { + self.live_generation = snapshot.generation; + let label = format!("Live {} — {} sweeps", snapshot.mode, snapshot.sweeps); + if let Some(plot) = self.plot.as_mut() { + plot.replace_data(label, snapshot.data); + } else { + self.plot = Some(Plot::new(label, snapshot.data)); + } + } + match self.live_state.status() { + ScanStatus::Failed => { + self.scan_state.fail( + self.live_state + .error() + .unwrap_or_else(|| "live capture failed".into()), + ); + self.flow_state = AppState::Error; + } + ScanStatus::Complete if self.live_exit_requested => self.should_quit = true, + ScanStatus::Ready | ScanStatus::Running | ScanStatus::Complete => {} + } + } } /// Renderer action resolved from configured key names. @@ -608,6 +692,24 @@ mod tests { assert!(matches!(viewer.flow_state, AppState::Complete)); } + #[test] + fn live_keys_switch_mode_and_request_a_graceful_exit() { + let mut app = app(); + app.flow_state = AppState::Live; + app.live_state.begin(); + app.handle_start_keys(KeyEvent::new(KeyCode::Char('6'), KeyModifiers::NONE)) + .unwrap(); + assert_eq!(app.live_state.mode(), TraceMode::MinDecay); + app.handle_start_keys(KeyEvent::new(KeyCode::Char('q'), KeyModifiers::NONE)) + .unwrap(); + assert!(app.live_exit_requested); + assert!( + !app.should_quit, + "worker recovery and final save must finish first" + ); + assert_eq!(app.live_state.message(), "Stopping after the current sweep"); + } + #[test] fn every_screen_renders_without_a_physical_terminal() { for (width, height) in [(120, 40), (40, 10), (1, 1)] { @@ -623,6 +725,7 @@ mod tests { AppState::SelectingScan(SelectedScan::Points), AppState::SelectingScan(SelectedScan::Repeat), AppState::Scanning, + AppState::Live, AppState::Complete, AppState::Error, ] { diff --git a/src/ui/state.rs b/src/ui/state.rs index f32d787..0e9ab1e 100644 --- a/src/ui/state.rs +++ b/src/ui/state.rs @@ -11,7 +11,7 @@ use strum::FromRepr; use crate::{ error::{AppError, UiError}, - scan::ScanState, + scan::{LiveState, ScanState}, }; use tiny_wb::{config::Config, protocol::ScanRequest}; @@ -45,6 +45,14 @@ pub(crate) struct App { pub(crate) repeat: NumericInput, /// Shared acquisition telemetry; request settings are passed separately. pub(crate) scan_state: ScanState, + /// Shared repeated-snapshot state used only by `--live` sessions. + pub(crate) live_state: LiveState, + /// Whether scans launched from the settings screen should run continuously. + pub(crate) live_enabled: bool, + /// Last live generation copied into the plot. + pub(crate) live_generation: u64, + /// Whether the UI should exit after live recovery and final export. + pub(crate) live_exit_requested: bool, /// Validated settings retained when the selection is saved. pub(crate) config: Config, /// Explicit settings path selected at startup. @@ -78,6 +86,18 @@ impl Plot { viewport, } } + + /// Replace samples without resetting a compatible live viewport. + pub(crate) fn replace_data(&mut self, label: impl Into, data: Vec<(f64, f64)>) { + let replacement = FrequencyViewport::from_samples(&data); + if self.viewport.full_min != replacement.full_min + || self.viewport.full_max != replacement.full_max + { + self.viewport = replacement; + } + self.label = label.into(); + self.data = data; + } } /// Horizontal chart bounds with zoom and pan clamped to the source data. @@ -289,6 +309,8 @@ pub(crate) enum AppState { Complete, /// Acquisition and export progress. Scanning, + /// Repeated complete snapshots displayed while acquisition continues. + Live, /// Error window Error, } diff --git a/src/ui/view.rs b/src/ui/view.rs index 397a589..57d3a4f 100644 --- a/src/ui/view.rs +++ b/src/ui/view.rs @@ -19,11 +19,82 @@ impl App { AppState::SelectingConnection(_) => self.draw_config(frame), AppState::SelectingScan(_) => self.draw_final_config(frame), AppState::Scanning => self.draw_progress(frame), + AppState::Live => self.draw_live(frame), AppState::Complete => self.draw_end_window(frame), AppState::Error => self.draw_error(frame), } } + /// Render the newest complete live snapshot while the worker continues. + fn draw_live(&mut self, frame: &mut Frame<'_>) -> Result<(), UiError> { + let [_, main, _] = Layout::horizontal([ + Constraint::Min(2), + Constraint::Percentage(96), + Constraint::Min(2), + ]) + .areas(frame.area()); + let [status_area, graph_area, footer_area] = Layout::vertical([ + Constraint::Length(4), + Constraint::Min(4), + Constraint::Length(2), + ]) + .areas(main); + let status = format!( + "{} — {}\n{}", + self.live_state.mode(), + self.live_state.message(), + self.live_state.info() + ); + frame.render_widget( + Paragraph::new(status) + .wrap(Wrap { trim: true }) + .block(Block::bordered().title("Live capture")), + status_area, + ); + if let Some(plot) = self.plot.as_ref() { + let bounds = plot.viewport.bounds(); + let span = bounds[1] - bounds[0]; + let midpoint = (bounds[0] + bounds[1]) / 2.0; + let chart = Chart::new(vec![Dataset::default() + .marker(Marker::Dot) + .graph_type(GraphType::Scatter) + .style(Style::new().yellow()) + .data(&plot.data)]) + .x_axis( + Axis::default() + .title("Frequency (MHz)") + .bounds(bounds) + .labels([ + format_frequency(bounds[0], span), + format_frequency(midpoint, span), + format_frequency(bounds[1], span), + ]), + ) + .y_axis( + Axis::default() + .title("Level (dBm)") + .bounds([self.config.ui.chart_min_dbm, self.config.ui.chart_max_dbm]), + ); + frame.render_widget(chart, graph_area); + } else { + frame.render_widget( + Paragraph::new("Waiting for the first complete sweep…") + .centered() + .block(Block::bordered()), + graph_area, + ); + } + frame.render_widget( + Paragraph::new( + "1 avg4 · 2 avg16 · 3 max hold · 4 max decay · 5 min hold · 6 min decay · s save · q stop+save", + ) + .centered() + .wrap(Wrap { trim: true }), + footer_area, + ); + Ok(()) + } + /// Render scan settings with the focused field highlighted. fn draw_final_config(&mut self, frame: &mut Frame<'_>) -> Result<(), UiError> { let [_, spaced, _] = Layout::horizontal([ diff --git a/task.md b/task.md index 056c46c..1253cf6 100644 --- a/task.md +++ b/task.md @@ -41,7 +41,7 @@ model-detection entry. Hardware and extended-range gates remain open. | Basic | Low/high selection, one-shot raw sweep, repeat, configurable zero offset, resume attempt | Hardware qualification, processing/input controls, generator and complete workflows | | Ultra | Synthetic profile; experimental physical validator at 240–300 MHz | Model detection, normal/extended range planning, Ultra-specific controls and qualification | | Transport | Buffered mixed text/binary I/O, complete writes, bounded responses, serial/TCP adapters | Overall deadlines, abort, reconnect, typed replies and full recovery | -| Interface | One scan per TUI launch, plot and CSV | Headless commands, repeat/live operation, capability-aware controls | +| Interface | Rescan/settings return, repeated-snapshot live plot, bounded host trace calculations, plot and CSV | Headless commands, native continuous framing, subtraction/reference buffers and capability-aware controls | | Verification | Regression/mock tests, CI gates, guided hardware validator | Captured real-device fixtures, RF reference measurements and platform matrix | - [x] F01–F04: reusable library, injected I/O, bounded mock profiles and loopback tests. @@ -320,8 +320,10 @@ reference measurements verify exported amplitude and visible correction state. only for advertised forms. Verify frequency/value lengths and record counts. - [ ] Introduce trace metadata: device/build/profile, requested and actual range, axis policy, offset, RF path, processing, timestamps and completion status. -- [ ] Support repeated snapshots before native continuous frames; both need - bounded queues, cancellation, backpressure and explicit dropped-frame counts. +- [x] Support repeated complete snapshots with bounded sixteen-sweep history, + frame-boundary cancellation and no partial-frame publication. +- [ ] Add native continuous frames with bounded queues, backpressure, verified + abort/resynchronization and explicit dropped-frame counts. - [ ] Preserve current two-column CSV compatibility. Add opt-in metadata sidecars or a documented versioned format; keep serialization independent of paths. - [ ] Define atomic completion for trace plus metadata and a clearly labeled @@ -465,8 +467,9 @@ Depends incrementally on P01/P02 and each exposed feature. - [ ] Display model/build/connection state and derive field limits/choices from capabilities. Explain unavailable features rather than offering illegal values. -- [ ] Add rescan and return-to-settings without restarting, live plots, marker - controls and appropriate analyzer/generator/preset screens. +- [x] Add rescan, return-to-settings and a repeated-snapshot live plot without + restarting the process. +- [ ] Add marker controls and appropriate analyzer/generator/preset screens. - [ ] Keep worker events/state updates outside rendering; add cancel, recovery, trigger-wait and reconnect states without blocking the event loop. - [ ] Label MHz/dBm/time axes, selected path, corrections, output state and dropped