rfe 0.1.0

//! `rfe` is a Rust library for communicating with
//! [RF Explorer](https://www.j3.rf-explorer.com/) spectrum analyzers and signal
//! generators over a USB virtual serial port.
//!
//! It provides high-level device types for RF Explorer hardware and lower-level
//! building blocks for similar serial devices that use the same message
//! container pattern.
//!
//! ## Connecting to an RF Explorer
//!
//! `rfe` can search for an attached RF Explorer without knowing its port name or
//! baud rate. It tries USB serial ports with the VID and PID used by the RF
//! Explorer's Silicon Labs CP210x USB-to-UART bridge.
//!
//! ```no_run
//! use rfe::{SignalGenerator, SpectrumAnalyzer};
//!
//! let spectrum_analyzer =
//!     SpectrumAnalyzer::connect().expect("RF Explorer spectrum analyzer should be connected");
//! let signal_generator =
//!     SignalGenerator::connect().expect("RF Explorer signal generator should be connected");
//! ```
//!
//! You can also connect to a known serial port and baud rate.
//!
//! ```no_run
//! use rfe::{SignalGenerator, SpectrumAnalyzer};
//!
//! let spectrum_analyzer =
//!     SpectrumAnalyzer::connect_with_name_and_baud_rate("COM2", 500_000)?;
//! let signal_generator =
//!     SignalGenerator::connect_with_name_and_baud_rate("COM1", 500_000)?;
//! # Ok::<(), rfe::ConnectionError>(())
//! ```
//!
//! ## Collecting spectrum analyzer sweeps
//!
//! `rfe` provides three APIs for reading spectrum analyzer sweeps.
//!
//! ### Waiting for the next sweep
//!
//! [`SpectrumAnalyzer::wait_for_next_sweep()`] blocks until the device reports a
//! new sweep or the timeout elapses.
//!
//! ```no_run
//! use rfe::SpectrumAnalyzer;
//!
//! let rfe = SpectrumAnalyzer::connect().expect("RF Explorer should be connected");
//! let sweep = rfe.wait_for_next_sweep()?;
//! println!("{:?}", sweep);
//! # Ok::<(), rfe::Error>(())
//! ```
//!
//! ### Reading the latest cached sweep
//!
//! [`SpectrumAnalyzer::sweep()`] returns the most recently measured sweep, or
//! `None` if no sweep has been received yet.
//!
//! ```no_run
//! use rfe::SpectrumAnalyzer;
//!
//! let rfe = SpectrumAnalyzer::connect().expect("RF Explorer should be connected");
//! let sweep = rfe.sweep();
//! ```
//!
//! ### Receiving sweeps with a callback
//!
//! [`SpectrumAnalyzer::set_sweep_callback()`] registers a callback that runs on a
//! separate thread whenever a sweep is received.
//!
//! ```no_run
//! use rfe::SpectrumAnalyzer;
//!
//! let rfe = SpectrumAnalyzer::connect().expect("RF Explorer should be connected");
//! rfe.set_sweep_callback(|sweep, start_freq, stop_freq| {
//!     println!(
//!         "Received sweep from {}-{} MHz",
//!         start_freq.as_mhz(),
//!         stop_freq.as_mhz()
//!     );
//!     println!("{sweep:?}");
//! });
//! ```
//!
//! ## Generating a signal with an RF Explorer Signal Generator
//!
//! ```no_run
//! use rfe::{
//!     signal_generator::{Attenuation, PowerLevel, SignalGenerator},
//!     Frequency,
//! };
//!
//! let rfe = SignalGenerator::connect().expect("RF Explorer should be connected");
//! rfe.start_cw(Frequency::from_mhz(2412), Attenuation::Off, PowerLevel::Low)?;
//! # Ok::<(), rfe::Error>(())
//! ```

mod common;
mod rf_explorer;

/// RF Explorer signal generator types and commands.
pub mod signal_generator;
/// RF Explorer spectrum analyzer types and commands.
pub mod spectrum_analyzer;

pub use common::*;
pub use rf_explorer::ScreenData;
pub use signal_generator::SignalGenerator;
pub use spectrum_analyzer::SpectrumAnalyzer;