Merge pull request 'gui' (#1) from gui into main
Reviewed-on: Dandaedre/tiny-wb#1
This commit is contained in:
commit
07a8d033fd
|
|
@ -0,0 +1,2 @@
|
|||
[build]
|
||||
rustflags = ["-Clink-arg=-fuse-ld=lld"]
|
||||
|
|
@ -20,3 +20,4 @@ Cargo.lock
|
|||
|
||||
/target
|
||||
*.csv
|
||||
config.toml
|
||||
|
|
|
|||
33
Cargo.toml
33
Cargo.toml
|
|
@ -4,12 +4,39 @@ version = "0.1.0"
|
|||
edition = "2021"
|
||||
|
||||
[dependencies]
|
||||
byteorder = "1.5.0"
|
||||
chrono = "0.4.38"
|
||||
# byteorder = "1.5.0"
|
||||
clap = { version = "4.5.17", features = ["derive"] }
|
||||
csv = "1.3.0"
|
||||
hex = "0.4.3"
|
||||
color-eyre = "0.6.3"
|
||||
human-panic = "2.0.1"
|
||||
# csv = "1.3.0"
|
||||
memchr = "2.7.4"
|
||||
once_cell = "1.19.0"
|
||||
packed_struct = "0.10.1"
|
||||
ratatui = "0.28.1"
|
||||
serde = { version = "1.0.210", features = ["derive"] }
|
||||
serialport = "4.5.0"
|
||||
strum = { version = "0.26.3", features = ["derive"] }
|
||||
thiserror = "1.0.63"
|
||||
toml = "0.8.19"
|
||||
tui-textarea = "0.6.1"
|
||||
|
||||
[profile.release]
|
||||
opt-level = "z"
|
||||
strip = true
|
||||
lto = true
|
||||
codegen-units = 1
|
||||
panic = "abort"
|
||||
|
||||
[profile.dev]
|
||||
debug = 0
|
||||
|
||||
[profile.windows]
|
||||
inherits = "release"
|
||||
opt-level = "z"
|
||||
debug = false
|
||||
strip = true
|
||||
lto = true
|
||||
codegen-units = 1
|
||||
incremental = false
|
||||
panic = "abort"
|
||||
|
|
|
|||
22
README.md
22
README.md
|
|
@ -2,6 +2,28 @@
|
|||
|
||||
Simple tinySA to Workbench converter
|
||||
|
||||
# First window
|
||||
> Selection
|
||||
|
||||
Starts with the most likely com port selected (last used, then usual suspect, then port 0)
|
||||
Enter selects it (in the validation sense)
|
||||
Selects the first likely baudrate (same algo)
|
||||
Enter selects it
|
||||
Selects the validate text box
|
||||
|
||||
First selection should be enter, then with L/R U/D (or mouse?) you can change the params
|
||||
(P) to select a port (B) to select a baudrate (Enter) to be put on the <Next> selection
|
||||
|
||||
# Second window
|
||||
> Customisation
|
||||
|
||||
Tab/L/R for navigation, Enter to change a parameter
|
||||
Starts with <Scan> selected and either (L/R/U/D) to be put on the fields
|
||||
|
||||
# Third window
|
||||
> Result
|
||||
|
||||
Show a progress bar, then show a nice message with a prompt to ask where to save, then exits
|
||||
|
||||
# References
|
||||
|
||||
|
|
|
|||
19
src/main.rs
19
src/main.rs
|
|
@ -4,14 +4,25 @@
|
|||
//! and will not offer any scripting capabilities
|
||||
|
||||
#![warn(missing_docs, clippy::missing_docs_in_private_items)]
|
||||
// #![allow(dead_code)]
|
||||
mod scan;
|
||||
mod structs;
|
||||
mod ui;
|
||||
mod ui_struct;
|
||||
|
||||
use crate::scan::scan;
|
||||
|
||||
use color_eyre::Result;
|
||||
// use human_panic::setup_panic;
|
||||
use structs::TinyError;
|
||||
use ui_struct::AppInfo;
|
||||
|
||||
fn main() -> Result<(), TinyError> {
|
||||
// let args = Args::parse();
|
||||
scan()
|
||||
color_eyre::install()?;
|
||||
let terminal = ratatui::init();
|
||||
// setup_panic!();
|
||||
let ports = serialport::available_ports()?;
|
||||
let app_r = AppInfo::new(ports).run(terminal);
|
||||
|
||||
ratatui::restore();
|
||||
|
||||
app_r.map_err(TinyError::TUIRuntimeError)
|
||||
}
|
||||
|
|
|
|||
274
src/scan.rs
274
src/scan.rs
|
|
@ -1,13 +1,9 @@
|
|||
//! The "lib" used for all scan related functions
|
||||
|
||||
/// The default start value for a scan
|
||||
static START: usize = 240000000;
|
||||
static START: usize = 240_000_000;
|
||||
/// The default stop value for a scan
|
||||
static STOP: usize = 959000000;
|
||||
/// The default number of points
|
||||
static POINTS: usize = 290; //(STOP - START) * 10;
|
||||
/// The default increment (deduced from the number of points)
|
||||
static INCREMENT: usize = (STOP - START) / POINTS; // 1000/100
|
||||
static STOP: usize = 959_000_000;
|
||||
/// The offset used for sending data
|
||||
static OFFSET: usize = 128;
|
||||
/// The base delay used inbetween commands
|
||||
|
|
@ -24,11 +20,13 @@ use serialport::SerialPort;
|
|||
use std::{
|
||||
fs::File,
|
||||
io::{BufWriter, Read, Write},
|
||||
sync::OnceLock,
|
||||
thread::sleep,
|
||||
sync::{Arc, Mutex, OnceLock},
|
||||
thread::{self},
|
||||
time::Duration,
|
||||
};
|
||||
|
||||
use chrono::Local;
|
||||
|
||||
/// A single datapoint, using a struct might be overkill but msb/lsb could become a problem in the future
|
||||
#[derive(PackedStruct, Debug)]
|
||||
#[packed_struct(endian = "lsb")]
|
||||
|
|
@ -44,62 +42,75 @@ pub struct DataPoint {
|
|||
static EOF: OnceLock<memmem::Finder<'_>> = OnceLock::new();
|
||||
|
||||
/// Scan a specific range and returns the scan result
|
||||
pub(crate) fn scan() -> Result<(), TinyError> {
|
||||
let ports = serialport::available_ports()?;
|
||||
for p in ports {
|
||||
println!("{}", p.port_name);
|
||||
}
|
||||
let mut port = serialport::new("/dev/ttyACM0", 115_200)
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub(crate) fn scan_with_progress(
|
||||
progress: Arc<Mutex<usize>>,
|
||||
scan_info: Arc<Mutex<String>>,
|
||||
scan_message: Arc<Mutex<String>>,
|
||||
return_data: Arc<Mutex<Vec<(f64, f64)>>>,
|
||||
port: String,
|
||||
start: usize,
|
||||
stop: usize,
|
||||
points: usize,
|
||||
) -> Result<(), TinyError> {
|
||||
*scan_message.lock().unwrap() = "Oppening connection".to_string();
|
||||
let port = serialport::new(port, 115_200)
|
||||
.timeout(Duration::from_millis(3000))
|
||||
.open()
|
||||
.expect("Failed to open port");
|
||||
.open(); // .expect("Failed to open port");
|
||||
if let Err(e) = port {
|
||||
*scan_message.lock().unwrap() = "Noo".to_string();
|
||||
return Err(TinyError::PortConnection(e));
|
||||
}
|
||||
let mut port = port.unwrap();
|
||||
*scan_message.lock().unwrap() = "Initialisation...".to_string();
|
||||
*progress.lock().unwrap() = 5;
|
||||
initialize(&mut port);
|
||||
println!("{}", send_cmd(&mut port, "help\r", SHORT_WAIT));
|
||||
println!("{}", send_cmd(&mut port, "version\r", SHORT_WAIT));
|
||||
println!("{}", send_cmd(&mut port, "info\r", SHORT_WAIT));
|
||||
|
||||
println!(
|
||||
"{}",
|
||||
send_cmd(&mut port, &format!("zero {}\r", OFFSET), SHORT_WAIT)
|
||||
);
|
||||
println!("{}", send_cmd(&mut port, "leveloffset\r", SHORT_WAIT));
|
||||
println!("{}", send_cmd(&mut port, "deviceid\r", SHORT_WAIT));
|
||||
println!("{}", send_cmd(&mut port, "vbat offset\r", SHORT_WAIT));
|
||||
println!("{}", send_cmd(&mut port, "vbat\r", SHORT_WAIT));
|
||||
println!("{}", send_cmd(&mut port, "usart_cfg\r", SHORT_WAIT));
|
||||
println!("{}", send_cmd(&mut port, "marker\r", SHORT_WAIT));
|
||||
*progress.lock().unwrap() = 15;
|
||||
*scan_message.lock().unwrap() = "Acquiring version & info".to_string();
|
||||
let v = send_cmd(&mut port, "version\r", SHORT_WAIT);
|
||||
let i = send_cmd(&mut port, "info\r", SHORT_WAIT);
|
||||
*scan_info.lock().unwrap() = format!("{}{}", v, i);
|
||||
|
||||
println!("{}", send_cmd(&mut port, "sweep\r", SHORT_WAIT));
|
||||
println!("{}", send_cmd(&mut port, "mode\r", SHORT_WAIT));
|
||||
println!("{}", send_cmd(&mut port, "lna\r", SHORT_WAIT));
|
||||
*progress.lock().unwrap() = 16;
|
||||
*scan_message.lock().unwrap() = "Setting zero...".to_string();
|
||||
send_cmd(&mut port, &format!("zero {}\r", OFFSET), SHORT_WAIT);
|
||||
|
||||
println!("{}", send_cmd(&mut port, "pause\r", SHORT_WAIT));
|
||||
println!("{}", send_cmd(&mut port, "vbat\r", SHORT_WAIT));
|
||||
println!("{}", send_cmd(&mut port, "marker\r", SHORT_WAIT));
|
||||
println!("{}", send_cmd(&mut port, "sweep\r", SHORT_WAIT));
|
||||
println!("{}", send_cmd(&mut port, "mode high input\r", SHORT_WAIT));
|
||||
*progress.lock().unwrap() = 17;
|
||||
*scan_message.lock().unwrap() = "Setting up scan & mode".to_string();
|
||||
send_cmd(&mut port, "marker\r", SHORT_WAIT);
|
||||
send_cmd(&mut port, "pause\r", SHORT_WAIT);
|
||||
send_cmd(&mut port, "mode high input\r", SHORT_WAIT);
|
||||
|
||||
println!("{}", send_cmd(&mut port, "sweep\r", SHORT_WAIT));
|
||||
println!(
|
||||
"{}",
|
||||
send_cmd(&mut port, &format!("sweep start {}\r", START), SHORT_WAIT)
|
||||
*progress.lock().unwrap() = 18;
|
||||
*scan_message.lock().unwrap() = "Setting up sweep".to_string();
|
||||
send_cmd(&mut port, &format!("sweep start {}\r", START), SHORT_WAIT);
|
||||
send_cmd(&mut port, &format!("sweep stop {}\r", STOP), SHORT_WAIT);
|
||||
|
||||
*progress.lock().unwrap() = 20;
|
||||
*scan_message.lock().unwrap() = "Starting scan...".to_string();
|
||||
send_cmd(&mut port, "sweep\r", SHORT_WAIT);
|
||||
send_cmd(
|
||||
&mut port,
|
||||
&format!("scan {} {} 290 101\r", start, stop),
|
||||
TIMEOUT,
|
||||
);
|
||||
println!(
|
||||
"{}",
|
||||
send_cmd(&mut port, &format!("sweep stop {}\r", STOP), SHORT_WAIT)
|
||||
);
|
||||
println!("{}", send_cmd(&mut port, "sweep\r", SHORT_WAIT));
|
||||
println!(
|
||||
"{}",
|
||||
send_cmd(&mut port, "scan 240000000 959000000 290 101\r", TIMEOUT)
|
||||
);
|
||||
// println!(
|
||||
// "{}",
|
||||
// send_cmd(&mut port, &format!("scan {} {} 100 101\r", START, STOP), 50)
|
||||
// );
|
||||
println!("{:?}", scanraw(&mut port));
|
||||
println!("{}", send_cmd(&mut port, "resume\r", SHORT_WAIT));
|
||||
|
||||
*progress.lock().unwrap() = 22;
|
||||
let name = scanraw(
|
||||
&mut port,
|
||||
progress.clone(),
|
||||
return_data.clone(),
|
||||
start,
|
||||
stop,
|
||||
points,
|
||||
)?;
|
||||
|
||||
*scan_message.lock().unwrap() = format!("Scan saved as {}", name);
|
||||
send_cmd(&mut port, "resume\r", SHORT_WAIT);
|
||||
|
||||
wait_sync(LONG_WAIT);
|
||||
*progress.lock().unwrap() = 100;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
|
|
@ -107,32 +118,36 @@ pub(crate) fn scan() -> Result<(), TinyError> {
|
|||
/// Wait's for a whole timeout for data stuck in the buffer and dumps it
|
||||
fn initialize(port: &mut Box<dyn SerialPort>) {
|
||||
wait_sync(SHORT_WAIT);
|
||||
println!(
|
||||
"Initializing ... \nUninialized bytes: {:?}",
|
||||
read_port(port)
|
||||
);
|
||||
read_port(port);
|
||||
wait_sync(SHORT_WAIT)
|
||||
}
|
||||
|
||||
/// Bad synchronisation method to ensure data is truthfully sent/received
|
||||
fn wait_sync(duration: u64) {
|
||||
sleep(Duration::from_millis(duration));
|
||||
thread::sleep(Duration::from_millis(duration));
|
||||
}
|
||||
|
||||
/// Scan raw frequencies
|
||||
fn scanraw(port: &mut Box<dyn SerialPort>) -> Result<(), TinyError> {
|
||||
// let mut f = File::open("b.txt")?;
|
||||
// let mut s = String::new();
|
||||
// let d = f.read_to_string(&mut s)?;
|
||||
// println!("{}", s);
|
||||
// let v = hex::decode(&s[..s.len() - 1]).unwrap();
|
||||
// println!("{:?}", v);
|
||||
// parse_data(v).unwrap();
|
||||
unsafe { send_raw(port, &format!("scanraw {} {} {}\r", START, STOP, POINTS)) }
|
||||
fn scanraw(
|
||||
port: &mut Box<dyn SerialPort>,
|
||||
progress: Arc<Mutex<usize>>,
|
||||
return_data: Arc<Mutex<Vec<(f64, f64)>>>,
|
||||
start: usize,
|
||||
stop: usize,
|
||||
points: usize,
|
||||
) -> Result<String, TinyError> {
|
||||
unsafe { send_raw(port, &format!("scanraw {} {} {}\r", start, stop, points)) }
|
||||
wait_sync(SHORT_WAIT);
|
||||
read_scanraw(port)?;
|
||||
let (name, val) = read_scanraw(
|
||||
port,
|
||||
progress,
|
||||
points,
|
||||
start,
|
||||
(stop - start) as f64 / points as f64,
|
||||
)?;
|
||||
*return_data.lock().unwrap() = val;
|
||||
wait_sync(LONG_WAIT);
|
||||
Ok(())
|
||||
Ok(name)
|
||||
}
|
||||
|
||||
/// Send a command and reads it to a string
|
||||
|
|
@ -148,7 +163,6 @@ fn send_cmd(port: &mut Box<dyn SerialPort>, command: &str, wait: u64) -> String
|
|||
/// This command will produce unknown results if the output buffer is never read
|
||||
unsafe fn send_raw(port: &mut Box<dyn SerialPort>, command: &str) {
|
||||
let output = command.as_bytes();
|
||||
println!("Sending: {}", command);
|
||||
let _r = port.write(output).expect("Write failed!");
|
||||
}
|
||||
|
||||
|
|
@ -158,19 +172,40 @@ fn read_utf8(port: &mut Box<dyn SerialPort>) -> String {
|
|||
}
|
||||
|
||||
/// Reads the serial port until it reaches EOF
|
||||
fn read_port_with_progress(
|
||||
port: &mut Box<dyn SerialPort>,
|
||||
expected: usize,
|
||||
progress: Arc<Mutex<usize>>,
|
||||
) -> Vec<u8> {
|
||||
let mut serial_buf: Vec<u8> = vec![0; 64];
|
||||
let mut res = Vec::new();
|
||||
let finder = EOF.get_or_init(|| memmem::Finder::new("ch>"));
|
||||
while let Ok(r) = port.read(serial_buf.as_mut_slice()) {
|
||||
*progress.lock().unwrap() = (100usize.saturating_sub(
|
||||
(80 * (expected.saturating_sub(res.len())).clamp(0, expected)) / expected,
|
||||
))
|
||||
.clamp(20, 99);
|
||||
if let Some(pos) = finder.find(&serial_buf) {
|
||||
res.extend_from_slice(&serial_buf[..pos]);
|
||||
break;
|
||||
}
|
||||
res.extend_from_slice(&serial_buf[..r]);
|
||||
}
|
||||
res
|
||||
}
|
||||
|
||||
/// Read port without updating progress
|
||||
fn read_port(port: &mut Box<dyn SerialPort>) -> Vec<u8> {
|
||||
let mut serial_buf: Vec<u8> = vec![0; 256];
|
||||
let mut res = Vec::new();
|
||||
let finder = EOF.get_or_init(|| memmem::Finder::new("ch>"));
|
||||
while let Ok(r) = port.read(serial_buf.as_mut_slice()) {
|
||||
if let Some(pos) = finder.find(&serial_buf) {
|
||||
// println!("{:?}", serial_buf);
|
||||
res.extend_from_slice(&serial_buf[..pos]);
|
||||
break;
|
||||
}
|
||||
res.extend_from_slice(&serial_buf[..r]);
|
||||
}
|
||||
// println!("{:?}", res);
|
||||
res
|
||||
}
|
||||
|
||||
|
|
@ -178,46 +213,46 @@ fn read_port(port: &mut Box<dyn SerialPort>) -> Vec<u8> {
|
|||
/// Waits the normal start Character '{' and begins treating data as normal
|
||||
///
|
||||
/// Returns a struct summerizing the information processed
|
||||
fn read_scanraw(port: &mut Box<dyn SerialPort>) -> Result<(), TinyError> {
|
||||
let v = read_port(port);
|
||||
fn read_scanraw(
|
||||
port: &mut Box<dyn SerialPort>,
|
||||
progress: Arc<Mutex<usize>>,
|
||||
points: usize,
|
||||
start: usize,
|
||||
increment: f64,
|
||||
) -> Result<(String, Vec<(f64, f64)>), TinyError> {
|
||||
let v = read_port_with_progress(port, points * 3 + 6, progress);
|
||||
// Find the { marking the beggining
|
||||
parse_data(v)
|
||||
parse_data(v, points, start, increment)
|
||||
}
|
||||
|
||||
/// A utility function used for parsing the raw data of a scan
|
||||
pub fn parse_data(v: Vec<u8>) -> Result<(), TinyError> {
|
||||
let mut values: Vec<u16> = Vec::with_capacity(POINTS);
|
||||
let mut out = BufWriter::new(File::create("test.csv")?);
|
||||
pub fn parse_data(
|
||||
v: Vec<u8>,
|
||||
points: usize,
|
||||
start: usize,
|
||||
increment: f64,
|
||||
) -> Result<(String, Vec<(f64, f64)>), TinyError> {
|
||||
// let mut values: Vec<u16> = Vec::with_capacity(points);
|
||||
let name = format!("scan_{}.csv", Local::now().format("%Y%m%d %H_%M_%S"));
|
||||
let mut out = BufWriter::new(File::create(&name)?);
|
||||
let mut csvdata = Vec::with_capacity(points);
|
||||
if let Some(begining) = memchr::memchr(b'{', &v) {
|
||||
// Finds the } marking the end
|
||||
if let Some(end) = memchr::memchr(b'}', &v) {
|
||||
let data = &v[begining + 1..end];
|
||||
for (i, slice) in data.chunks_exact(3).enumerate() {
|
||||
let s: &[u8; 3] = &[slice[0], slice[1], slice[2]];
|
||||
let d = DataPoint::unpack(s).unwrap();
|
||||
// println!(
|
||||
// "{} {} {} -> {} : {}",
|
||||
// x,
|
||||
// b1,
|
||||
// b2,
|
||||
// d.value,
|
||||
// u16_to_f64(d.value)
|
||||
// );
|
||||
values.push(d.value);
|
||||
writeln!(
|
||||
out,
|
||||
"{},{}",
|
||||
(i * INCREMENT + START) as f64 / 1000000.,
|
||||
u16_to_f64(d.value) // bytes_to_f64(b1, b2)
|
||||
)?;
|
||||
let d = DataPoint::unpack(s)?;
|
||||
let (pos, val) = (
|
||||
(i as f64 * increment + start as f64) / 1000000.,
|
||||
u16_to_f64(d.value),
|
||||
);
|
||||
|
||||
csvdata.push((pos, val));
|
||||
writeln!(out, "{},{}", pos, val)?;
|
||||
}
|
||||
println!(
|
||||
"Found {} values, min: {:?}, max: {:?}",
|
||||
values.len(),
|
||||
u16_to_f64(*values.iter().min().unwrap_or(&0)),
|
||||
u16_to_f64(*values.iter().max().unwrap_or(&0)),
|
||||
);
|
||||
Ok(())
|
||||
// TODO: Dont return use mutex
|
||||
Ok((name, csvdata))
|
||||
} else {
|
||||
Err(TinyError::ParseEnd("}".to_owned()))
|
||||
}
|
||||
|
|
@ -230,34 +265,3 @@ pub fn parse_data(v: Vec<u8>) -> Result<(), TinyError> {
|
|||
fn u16_to_f64(v: u16) -> f64 {
|
||||
(v as f64) / 32. - OFFSET as f64
|
||||
}
|
||||
|
||||
// /// The result of a scan
|
||||
// pub struct ScanResult {
|
||||
// start: usize,
|
||||
// stop: usize,
|
||||
// points: usize,
|
||||
// status: ScanStatus,
|
||||
// data: Vec<f64>,
|
||||
// }
|
||||
|
||||
// pub enum ScanStatus {
|
||||
// Success,
|
||||
// Failure,
|
||||
// Interrupted,
|
||||
// }
|
||||
// loop {
|
||||
// // println!("{}", send_cmd(&mut port, "0\r"));
|
||||
// print!("ch> ");
|
||||
// io::stdout().flush().expect("IO error");
|
||||
// let mut input = String::new();
|
||||
// match io::stdin().read_line(&mut input) {
|
||||
// Ok(_) => {
|
||||
// println!("{}", send_cmd(&mut port, &format!("{}\r", input)));
|
||||
// }
|
||||
// Err(e) => println!("Error {}", e),
|
||||
// }
|
||||
// // println!("{}", send_cmd(&mut port, "scan 240m 960m 240 11\r"));
|
||||
// // println!("{}", send_cmd(&mut port, "scanraw 240m 960m 10000\r"));
|
||||
// // // println!("{}", send_cmd(&mut port, "scanraw 240m 960m 1000\r"));
|
||||
// // send_cmd(&mut port, "resume\r");
|
||||
// }
|
||||
|
|
|
|||
106
src/structs.rs
106
src/structs.rs
|
|
@ -1,6 +1,15 @@
|
|||
//! All the structs used internally
|
||||
|
||||
use std::{
|
||||
fs::File,
|
||||
io::{Read, Write},
|
||||
};
|
||||
|
||||
use serde::{Deserialize, Serialize};
|
||||
use thiserror::Error;
|
||||
|
||||
use crate::ui_struct::AppInfo;
|
||||
|
||||
/// The most common error, exposed to the lib user and end used
|
||||
#[derive(Error, Debug)]
|
||||
pub enum TinyError {
|
||||
|
|
@ -16,4 +25,101 @@ pub enum TinyError {
|
|||
/// The given file could't be exported
|
||||
#[error("Couldn't open the given file")]
|
||||
OpenOutput(#[from] std::io::Error),
|
||||
/// Generic TUI initialization error
|
||||
#[error("An error occured while creating the TUI")]
|
||||
TUIInitialization(#[from] color_eyre::Report),
|
||||
/// A runtime error occured
|
||||
#[error("A runtime error occured :\n{0}")]
|
||||
TUIRuntimeError(color_eyre::eyre::Error),
|
||||
/// An error occured while trying to parse the result
|
||||
#[error("An error occured while trying to parse the result")]
|
||||
TUIPackingError(#[from] packed_struct::PackingError),
|
||||
/// The config file couldn't be opened
|
||||
#[error("The config file couldn't be opened")]
|
||||
ConfigNotFound,
|
||||
/// The config file couldn't be parsed as a valid toml
|
||||
#[error("The config config.toml couldn't be read")]
|
||||
InvalidConfig(#[from] toml::de::Error),
|
||||
/// The config file couldn't be parsed as a valid toml
|
||||
#[error("The config config.toml couldn't be written")]
|
||||
InvalidDataForConfig(#[from] toml::ser::Error),
|
||||
}
|
||||
|
||||
#[allow(missing_docs, clippy::missing_docs_in_private_items)]
|
||||
/// The direction the input was received, usefull for menu where R/L U/D give similar results and implementation
|
||||
pub(crate) enum InputDirection {
|
||||
Up,
|
||||
Down,
|
||||
Right,
|
||||
Left,
|
||||
}
|
||||
|
||||
/// All implementation of errors happening while in the UI
|
||||
#[derive(Error, Debug)]
|
||||
pub enum TinyUIError {
|
||||
/// An error due to bad menuing implementation
|
||||
#[error("An error occured while selecting a menu item")]
|
||||
MenuSelectionError,
|
||||
|
||||
/// An error due to bad initialization
|
||||
#[error("The item list ({0}) wasn't initialyzed ({2}:{1})")]
|
||||
UninitializedItemList(&'static str, u32, &'static str),
|
||||
|
||||
/// An error occured while proccesing the key events
|
||||
#[error("An error occured while proccesing the key events")]
|
||||
KeyPress(#[from] std::io::Error),
|
||||
// /// Mutex error likely a data race mishandled
|
||||
// #[allow(dead_code)]
|
||||
// #[error("An error occured while trying to fetch progress")]
|
||||
// Mutex,
|
||||
}
|
||||
|
||||
// impl TinyUIError {
|
||||
// pub(crate) fn uninitialized_item_list_error(list: &'static str) -> Self {
|
||||
// Self::UninitializedItemList(list, line!(), file!())
|
||||
// }
|
||||
// }
|
||||
|
||||
#[derive(Serialize, Deserialize, Debug)]
|
||||
pub(crate) struct SavedConfig {
|
||||
/// The default com port
|
||||
pub(crate) port: String,
|
||||
/// The default baudrate
|
||||
pub(crate) baudrate: usize,
|
||||
/// The default start frequency
|
||||
pub(crate) start_frequency: usize,
|
||||
/// The default stop frequency
|
||||
pub(crate) stop_frequency: usize,
|
||||
/// The default number of points
|
||||
pub(crate) points: usize,
|
||||
}
|
||||
impl SavedConfig {
|
||||
/// Create a config from file or returns an error
|
||||
pub(crate) fn new() -> Result<Self, TinyError> {
|
||||
if let Ok(mut f) = File::open("config.toml") {
|
||||
let mut s = String::new();
|
||||
f.read_to_string(&mut s)?;
|
||||
let c = toml::from_str(&s)?;
|
||||
Ok(c)
|
||||
} else {
|
||||
Err(TinyError::ConfigNotFound)
|
||||
}
|
||||
}
|
||||
|
||||
/// Save the config with all runtime parameters
|
||||
pub(crate) fn save(arg: &AppInfo) -> Result<(), TinyUIError> {
|
||||
let mut f = File::create("config.toml")?;
|
||||
f.write_all(
|
||||
toml::to_string(&Self {
|
||||
port: arg.port_list.selected_port(),
|
||||
baudrate: arg.baudrate.state.selected().unwrap(),
|
||||
start_frequency: arg.start_frequency.int_to_usize(),
|
||||
stop_frequency: arg.stop_frequency.int_to_usize(),
|
||||
points: arg.points.int_to_usize(),
|
||||
})
|
||||
.unwrap()
|
||||
.as_bytes(),
|
||||
)?;
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -0,0 +1,554 @@
|
|||
//! The (minimal) user interface to control the program
|
||||
#![allow(unused_imports)]
|
||||
use clap::builder::Resettable;
|
||||
use color_eyre::{owo_colors::OwoColorize, Section};
|
||||
use core::{panic, time};
|
||||
use ratatui::{
|
||||
buffer::Buffer,
|
||||
crossterm::{
|
||||
event::{self, Event, KeyCode, KeyEvent, KeyEventKind},
|
||||
style::Print,
|
||||
},
|
||||
layout::{Alignment, Constraint, Direction, Layout, Rect},
|
||||
prelude::BlockExt,
|
||||
style::{
|
||||
palette::tailwind::{BLUE, GREEN, SLATE},
|
||||
Color, Modifier, Style, Styled, Stylize,
|
||||
},
|
||||
symbols::{self, Marker},
|
||||
text::Line,
|
||||
widgets::{
|
||||
block::Title, Axis, Block, Borders, Chart, Dataset, GraphType, HighlightSpacing, LineGauge,
|
||||
List, ListDirection, ListItem, ListState, Padding, Paragraph, ScrollDirection,
|
||||
StatefulWidget, Widget, Wrap,
|
||||
},
|
||||
DefaultTerminal, Frame,
|
||||
};
|
||||
use serialport::SerialPortInfo;
|
||||
use std::{
|
||||
borrow::{Borrow, BorrowMut},
|
||||
cmp::min,
|
||||
fmt::Pointer,
|
||||
iter::Iterator,
|
||||
sync::{Arc, Mutex},
|
||||
thread,
|
||||
time::{Duration, Instant},
|
||||
};
|
||||
use strum::{EnumCount, EnumIter, EnumProperty};
|
||||
use strum::{FromRepr, IntoEnumIterator};
|
||||
use tui_textarea::{Input, Key, TextArea};
|
||||
|
||||
use crate::{
|
||||
mleft, mright, scan,
|
||||
structs::{InputDirection, SavedConfig, TinyError, TinyUIError},
|
||||
ui_struct::{
|
||||
AppInfo, AppState, BaudRateList, MenuItems, PortList, SelectedConfig, SelectedFinalConfig,
|
||||
UIUsize, SELECTED_COLOR, UNSELECTED_COLOR,
|
||||
},
|
||||
};
|
||||
|
||||
impl<'a> AppInfo<'a> {
|
||||
/// Create a new app with the port info available
|
||||
pub(crate) fn new(info: Vec<SerialPortInfo>) -> Self {
|
||||
let loaded_conf = SavedConfig::new();
|
||||
let (start_frequency, stop_frequency, points) = {
|
||||
if let Ok(c) = &loaded_conf {
|
||||
(
|
||||
UIUsize::new(c.start_frequency, 10, 960),
|
||||
UIUsize::new(c.stop_frequency, 10, 960),
|
||||
UIUsize::new(c.points, 100, 1000000),
|
||||
)
|
||||
} else {
|
||||
(
|
||||
UIUsize::new(240, 10, 960),
|
||||
UIUsize::new(960, 10, 960),
|
||||
UIUsize::new(10000, 100, 1000000),
|
||||
)
|
||||
}
|
||||
};
|
||||
Self {
|
||||
should_quit: false,
|
||||
baudrate: BaudRateList::from_conf(&loaded_conf),
|
||||
port_list: PortList::from_serial(info, &loaded_conf),
|
||||
flow_state: AppState::default(),
|
||||
status_message: String::new(),
|
||||
menu_items: MenuItems::default(),
|
||||
start_frequency,
|
||||
stop_frequency,
|
||||
points,
|
||||
progress: Arc::new(Mutex::new(0)),
|
||||
scan_info: Arc::new(Mutex::new(String::new())),
|
||||
scan_message: Arc::new(Mutex::new(String::new())),
|
||||
return_data: Arc::new(Mutex::new(Vec::new())),
|
||||
}
|
||||
}
|
||||
|
||||
/// Contains the main loop for running the app
|
||||
pub(crate) fn run(
|
||||
&mut self,
|
||||
mut terminal: DefaultTerminal,
|
||||
) -> Result<(), color_eyre::eyre::Error> {
|
||||
self.init_config()?;
|
||||
loop {
|
||||
terminal.draw(|v| self.draw(v).inspect_err(|e| panic!("{}", e)).unwrap())?;
|
||||
let timeout = Duration::from_millis(16);
|
||||
if event::poll(timeout)? {
|
||||
if let Event::Key(key) = event::read()? {
|
||||
self.handle_start_keys(key)?;
|
||||
};
|
||||
if self.should_quit {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Generic draw loop method
|
||||
fn draw(&mut self, frame: &mut Frame<'_>) -> Result<(), TinyUIError> {
|
||||
match self.flow_state {
|
||||
AppState::InitialConfig(_) => self.draw_config(frame),
|
||||
AppState::FinalConfig(_) => self.draw_final_config(frame),
|
||||
AppState::Finished => self.draw_progress(frame),
|
||||
AppState::EndWindow => self.draw_end_window(frame),
|
||||
}
|
||||
}
|
||||
|
||||
/// Initialisation of the config window
|
||||
fn init_config(&mut self) -> Result<(), TinyUIError> {
|
||||
self.menu_items.portlist = Some(
|
||||
List::new(self.port_list.to_vecstr())
|
||||
.block(Block::bordered().title("COM Ports"))
|
||||
.highlight_style(
|
||||
Style::default()
|
||||
.add_modifier(Modifier::ITALIC)
|
||||
.bg(Color::Blue),
|
||||
)
|
||||
.repeat_highlight_symbol(true),
|
||||
);
|
||||
self.menu_items.baudlist = Some(
|
||||
List::new(self.baudrate.to_vecstr())
|
||||
.block(Block::bordered().title("Baudrates"))
|
||||
.highlight_style(
|
||||
Style::default()
|
||||
.add_modifier(Modifier::ITALIC)
|
||||
.bg(Color::Blue),
|
||||
)
|
||||
.repeat_highlight_symbol(true),
|
||||
);
|
||||
self.update_color()
|
||||
}
|
||||
|
||||
/// Initialisation of all the ui element for the final configuration elements
|
||||
fn init_final_config(&mut self) -> Result<(), TinyUIError> {
|
||||
self.menu_items.textboxes = vec![Paragraph::new("")];
|
||||
self.update_color()
|
||||
}
|
||||
|
||||
/// Initialisation of all the final ui elements
|
||||
pub(crate) fn init_end(&self) -> Result<(), TinyUIError> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Draw the final configuration labels
|
||||
fn draw_final_config(&mut self, frame: &mut Frame<'_>) -> Result<(), TinyUIError> {
|
||||
let [title_area, main_area, _, status_area] = Layout::vertical([
|
||||
Constraint::Length(2),
|
||||
Constraint::Length(3),
|
||||
Constraint::Min(0),
|
||||
Constraint::Length(1),
|
||||
])
|
||||
.areas(frame.area());
|
||||
let [_, area_minf, area_maxf, area_points, _] = Layout::horizontal([
|
||||
Constraint::Min(7),
|
||||
Constraint::Percentage(30),
|
||||
Constraint::Percentage(30),
|
||||
Constraint::Percentage(30),
|
||||
Constraint::Min(7),
|
||||
])
|
||||
.areas(main_area);
|
||||
// TODO: Move this in the color update
|
||||
let (mif_color, maf_color, poi_color) = match self.flow_state {
|
||||
AppState::FinalConfig(SelectedFinalConfig::StartFreq) => {
|
||||
(SELECTED_COLOR, UNSELECTED_COLOR, UNSELECTED_COLOR)
|
||||
}
|
||||
AppState::FinalConfig(SelectedFinalConfig::FinalFreq) => {
|
||||
(UNSELECTED_COLOR, SELECTED_COLOR, UNSELECTED_COLOR)
|
||||
}
|
||||
AppState::FinalConfig(SelectedFinalConfig::Points) => {
|
||||
(UNSELECTED_COLOR, UNSELECTED_COLOR, SELECTED_COLOR)
|
||||
}
|
||||
_ => unreachable!(),
|
||||
};
|
||||
|
||||
// self.status_message = format!("{:?} ", self.flow_state);
|
||||
frame.render_widget(
|
||||
Paragraph::new(self.start_frequency.int_to_string())
|
||||
.block(Block::bordered().title("Start Frequency"))
|
||||
.style(mif_color),
|
||||
area_minf,
|
||||
);
|
||||
frame.render_widget(
|
||||
Paragraph::new(self.stop_frequency.int_to_string())
|
||||
.block(Block::bordered().title("Stop Frequency"))
|
||||
.style(maf_color),
|
||||
area_maxf,
|
||||
);
|
||||
frame.render_widget(
|
||||
Paragraph::new(self.points.int_to_string())
|
||||
.block(Block::bordered().title("Points"))
|
||||
.style(poi_color),
|
||||
area_points,
|
||||
);
|
||||
|
||||
self.update_color()?;
|
||||
frame.render_widget(Paragraph::new(self.status_message.clone()), title_area);
|
||||
self.render_footer(frame, status_area);
|
||||
Ok(())
|
||||
}
|
||||
/// Render the selection footer
|
||||
fn render_footer(&self, frame: &mut Frame, area: Rect) {
|
||||
frame.render_widget(
|
||||
Paragraph::new(
|
||||
"Use ↓↑ to move, ←→ to change status widget and ↲ to validate configuration.",
|
||||
)
|
||||
.centered(),
|
||||
area,
|
||||
);
|
||||
}
|
||||
|
||||
/// Initialize the progress window
|
||||
fn init_progress(&mut self) -> Result<(), TinyUIError> {
|
||||
self.menu_items.progress_bar = Some(
|
||||
LineGauge::default()
|
||||
// .block(title)
|
||||
.filled_style(Style::default().fg(Color::Blue))
|
||||
.unfilled_style(Style::default().fg(Color::Red))
|
||||
// .filled_style(Style::default().fg(Color::Blue).bg(Color::Blue))
|
||||
// .unfilled_style(Style::default().fg(Color::Red).bg(Color::Red))
|
||||
.label("Progress:"),
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Draw the config info
|
||||
fn draw_config(&mut self, frame: &mut Frame) -> Result<(), TinyUIError> {
|
||||
let [title_area, main_area, status_area] = Layout::vertical([
|
||||
Constraint::Length(2),
|
||||
Constraint::Min(10),
|
||||
Constraint::Length(1),
|
||||
])
|
||||
.areas(frame.area());
|
||||
let [_, area_ports, area_baud, _] = Layout::horizontal([
|
||||
Constraint::Min(7),
|
||||
Constraint::Percentage(50),
|
||||
Constraint::Percentage(50),
|
||||
Constraint::Min(7),
|
||||
])
|
||||
.areas(main_area);
|
||||
let list_ports = self
|
||||
.menu_items
|
||||
.portlist
|
||||
.as_ref()
|
||||
.ok_or(TinyUIError::UninitializedItemList("Port", line!(), file!()))?;
|
||||
let list_baudrates = self
|
||||
.menu_items
|
||||
.baudlist
|
||||
.as_ref()
|
||||
.ok_or(TinyUIError::UninitializedItemList("Baud", line!(), file!()))?;
|
||||
// self.status_message = format!("{:?} ", self.flow_state);
|
||||
frame.render_stateful_widget(list_ports, area_ports, &mut self.port_list.state);
|
||||
frame.render_stateful_widget(list_baudrates, area_baud, &mut self.baudrate.state);
|
||||
frame.render_widget(Paragraph::new(self.status_message.clone()), title_area);
|
||||
self.render_footer(frame, status_area);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Draw the progress, updates as the progress is being done
|
||||
fn draw_progress(&mut self, frame: &mut Frame<'_>) -> Result<(), TinyUIError> {
|
||||
let [_, main_s, _] = Layout::horizontal([
|
||||
Constraint::Min(7),
|
||||
Constraint::Percentage(90),
|
||||
Constraint::Min(7),
|
||||
])
|
||||
.areas(frame.area());
|
||||
let [title_area, progress_area, main_area, _, _] = Layout::vertical([
|
||||
Constraint::Length(3),
|
||||
Constraint::Length(1),
|
||||
Constraint::Min(10),
|
||||
Constraint::Length(1),
|
||||
Constraint::Length(1),
|
||||
])
|
||||
.areas(main_s);
|
||||
let (pb, status, message) = {
|
||||
let status = self.scan_message.try_lock().unwrap();
|
||||
let status = Paragraph::new(status.clone())
|
||||
.block(Block::bordered().title("Operation"))
|
||||
.style(SELECTED_COLOR);
|
||||
let message = self.scan_info.try_lock().unwrap();
|
||||
let message = Paragraph::new(message.clone())
|
||||
.block(Block::bordered().title("TinySA Info"))
|
||||
.style(SELECTED_COLOR);
|
||||
let progress = self.progress.try_lock().unwrap();
|
||||
|
||||
let pb = self
|
||||
.menu_items
|
||||
.progress_bar
|
||||
.take()
|
||||
.ok_or(TinyUIError::UninitializedItemList(
|
||||
"ProgressBar",
|
||||
line!(),
|
||||
file!(),
|
||||
))?
|
||||
.ratio(*progress as f64 / 100.);
|
||||
(pb, status, message)
|
||||
};
|
||||
frame.render_widget(pb.clone(), progress_area);
|
||||
frame.render_widget(status, title_area);
|
||||
frame.render_widget(message, main_area);
|
||||
self.menu_items.progress_bar = Some(pb);
|
||||
if *self.progress.lock().unwrap() >= 100 {
|
||||
self.next_step()?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Draw the last confirmation window
|
||||
fn draw_end_window(&mut self, frame: &mut Frame) -> Result<(), TinyUIError> {
|
||||
let [_, main_s, _] = Layout::horizontal([
|
||||
Constraint::Min(7),
|
||||
Constraint::Percentage(90),
|
||||
Constraint::Min(7),
|
||||
])
|
||||
.areas(frame.area());
|
||||
let [title_area, _main_area, graph_area, _, footer_area] = Layout::vertical([
|
||||
Constraint::Length(3),
|
||||
Constraint::Length(1),
|
||||
Constraint::Min(10),
|
||||
Constraint::Length(1),
|
||||
Constraint::Length(1),
|
||||
])
|
||||
.areas(main_s);
|
||||
let status = Paragraph::new(format!(
|
||||
"The scan ({}Mhz - {}Mhz) of {} points finished sucessfuly",
|
||||
self.start_frequency.int_to_usize(),
|
||||
self.stop_frequency.int_to_usize(),
|
||||
self.points.int_to_usize()
|
||||
))
|
||||
.block(Block::bordered().title("Status"))
|
||||
.style(SELECTED_COLOR);
|
||||
// let dataset = Dataset::default()
|
||||
// .marker(symbols::Marker::HalfBlock)
|
||||
// .style(Style::new().fg(Color::Blue))
|
||||
// .graph_type(GraphType::Bar)
|
||||
// // a bell curve
|
||||
// .data(&[
|
||||
// (250., -2.9),
|
||||
// (260., -13.5),
|
||||
// (270., -41.1),
|
||||
// (280., -80.1),
|
||||
// (390., -100.0),
|
||||
// (500., -80.1),
|
||||
// (610., -41.1),
|
||||
// (720., -13.5),
|
||||
// (830., -2.9),
|
||||
// (930., -2.9),
|
||||
// ]);
|
||||
|
||||
// let chart = Chart::new(vec![dataset])
|
||||
// .block(
|
||||
// Block::bordered().title(
|
||||
// Title::default()
|
||||
// .content("Bar chart".cyan().bold())
|
||||
// .alignment(Alignment::Center),
|
||||
// ),
|
||||
// )
|
||||
// .x_axis(
|
||||
// Axis::default()
|
||||
// .style(Style::default().gray())
|
||||
// .bounds([
|
||||
// self.start_frequency.mhz_to_usize() as f64,
|
||||
// self.stop_frequency.mhz_to_usize() as f64,
|
||||
// ])
|
||||
// .labels([
|
||||
// self.start_frequency.int_to_string().bold(),
|
||||
// format!(
|
||||
// "{}",
|
||||
// (self.stop_frequency.int_to_usize()
|
||||
// - self.start_frequency.int_to_usize() / 2)
|
||||
// )
|
||||
// .into(),
|
||||
// self.stop_frequency.int_to_string().bold(),
|
||||
// ]),
|
||||
// )
|
||||
// .y_axis(
|
||||
// Axis::default()
|
||||
// .style(Style::default().gray())
|
||||
// .bounds([-128.0, 0.])
|
||||
// .labels(["-128".bold(), "-64".into(), "0".bold()]),
|
||||
// );
|
||||
// // .hidden_legend_constraints((Constraint::Ratio(1, 2), Constraint::Ratio(1, 2)));
|
||||
|
||||
// TODO: Don't acquire a mutex at 60Hz
|
||||
let binding = self.return_data.lock().unwrap();
|
||||
let datasets = vec![Dataset::default()
|
||||
// .name("Heavy")
|
||||
.marker(Marker::Dot)
|
||||
.graph_type(GraphType::Scatter)
|
||||
.style(Style::new().yellow())
|
||||
.data(&binding)];
|
||||
|
||||
let chart = Chart::new(datasets)
|
||||
// .block(
|
||||
// Block::bordered().title(
|
||||
// Title::default()
|
||||
// .content("Scatter chart".cyan().bold())
|
||||
// .alignment(Alignment::Center),
|
||||
// ),
|
||||
// )
|
||||
.x_axis(
|
||||
Axis::default()
|
||||
// .title("Year")
|
||||
.bounds([
|
||||
self.start_frequency.int_to_usize() as f64,
|
||||
self.stop_frequency.int_to_usize() as f64,
|
||||
])
|
||||
.style(Style::default().fg(Color::Gray))
|
||||
.labels([
|
||||
self.start_frequency.int_to_string(),
|
||||
format!(
|
||||
"{}",
|
||||
(self.stop_frequency.int_to_usize()
|
||||
- self.start_frequency.int_to_usize())
|
||||
/ 2
|
||||
),
|
||||
self.stop_frequency.int_to_string(),
|
||||
]),
|
||||
)
|
||||
.y_axis(
|
||||
Axis::default()
|
||||
// .title("Cost")
|
||||
.bounds([-128., 0.])
|
||||
.style(Style::default().fg(Color::Gray))
|
||||
.labels(["-128dbm", "-64dbm", "0dbm"]),
|
||||
);
|
||||
frame.render_widget(chart, graph_area);
|
||||
let footer = Paragraph::new(format!(
|
||||
"{}, press ↲ or q to exit",
|
||||
self.scan_message.lock().unwrap().clone()
|
||||
))
|
||||
.centered();
|
||||
frame.render_widget(status, title_area);
|
||||
frame.render_widget(footer, footer_area);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Handle keys while in the first menu
|
||||
fn handle_start_keys(&mut self, key: KeyEvent) -> Result<(), TinyUIError> {
|
||||
if key.kind != KeyEventKind::Press {
|
||||
return Ok(());
|
||||
}
|
||||
match key.code {
|
||||
KeyCode::Char('q') | KeyCode::Esc => self.should_quit = true,
|
||||
KeyCode::Char('j') | KeyCode::Down => self.change_cursor_position(InputDirection::Down),
|
||||
KeyCode::Char('k') | KeyCode::Up => self.change_cursor_position(InputDirection::Up),
|
||||
KeyCode::Char('h') | KeyCode::Left => self.next_menu(InputDirection::Left)?,
|
||||
KeyCode::Char('l') | KeyCode::Right => self.next_menu(InputDirection::Right)?,
|
||||
KeyCode::Enter => match self.flow_state {
|
||||
AppState::Finished => (),
|
||||
_ => self.next_step()?,
|
||||
},
|
||||
_ => {}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// A directionnal input was received
|
||||
fn change_cursor_position(&mut self, direction: InputDirection) {
|
||||
match self.flow_state {
|
||||
AppState::InitialConfig(ref selected_menu) => match selected_menu {
|
||||
SelectedConfig::Baudrate => self.baudrate.change_cursor(direction),
|
||||
SelectedConfig::Port => self.port_list.change_cursor(direction),
|
||||
},
|
||||
AppState::FinalConfig(ref selected_menu) => match selected_menu {
|
||||
SelectedFinalConfig::StartFreq => self.start_frequency.change_value(direction),
|
||||
SelectedFinalConfig::FinalFreq => self.stop_frequency.change_value(direction),
|
||||
SelectedFinalConfig::Points => self.points.change_value(direction),
|
||||
},
|
||||
AppState::EndWindow => (),
|
||||
AppState::Finished => (),
|
||||
}
|
||||
}
|
||||
|
||||
/// Goes to the next menu depending on the position in the program
|
||||
fn next_menu(&mut self, direction: InputDirection) -> Result<(), TinyUIError> {
|
||||
if let Some(s) = match self.flow_state {
|
||||
AppState::InitialConfig(ref r) => {
|
||||
let v = *r as usize;
|
||||
|
||||
match direction {
|
||||
InputDirection::Right => mright!(v, InitialConfig, SelectedConfig),
|
||||
InputDirection::Left => mleft!(v, InitialConfig, SelectedConfig),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
AppState::FinalConfig(ref r) => {
|
||||
let v = *r as usize;
|
||||
|
||||
match direction {
|
||||
InputDirection::Right => mright!(v, FinalConfig, SelectedFinalConfig),
|
||||
InputDirection::Left => mleft!(v, FinalConfig, SelectedFinalConfig),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
AppState::EndWindow => None,
|
||||
AppState::Finished => None,
|
||||
} {
|
||||
self.flow_state = s;
|
||||
}
|
||||
self.update_color()?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Progress in the flow of the program
|
||||
fn next_step(&mut self) -> Result<(), TinyUIError> {
|
||||
match self.flow_state {
|
||||
AppState::InitialConfig(_) => {
|
||||
self.flow_state = AppState::FinalConfig(SelectedFinalConfig::default());
|
||||
self.init_final_config()?;
|
||||
}
|
||||
AppState::FinalConfig(_) => {
|
||||
self.flow_state = AppState::Finished;
|
||||
self.init_progress()?;
|
||||
// Start the scan
|
||||
// TODO: Have a struct to avoid this clusterfk
|
||||
let pmtx = self.progress.clone();
|
||||
let mmtx = self.scan_info.clone();
|
||||
let cmtx = self.scan_message.clone();
|
||||
let rdata = self.return_data.clone();
|
||||
let port = self.port_list.selected_port();
|
||||
let start = self.start_frequency.mhz_to_usize();
|
||||
let stop = self.stop_frequency.mhz_to_usize();
|
||||
let points = self.points.int_to_usize();
|
||||
// BYPASS
|
||||
*self.progress.lock().unwrap() = 100;
|
||||
self.save_config()?;
|
||||
thread::spawn(move || {
|
||||
let status = scan::scan_with_progress(
|
||||
pmtx, mmtx, cmtx, rdata, port, start, stop, points,
|
||||
);
|
||||
// TODO: Do something with bad status to avoid false positive
|
||||
});
|
||||
// scan::scan_with_progress(pmtx, mmtx, cmtx, port).unwrap();
|
||||
}
|
||||
AppState::EndWindow => {
|
||||
self.should_quit = true;
|
||||
}
|
||||
AppState::Finished => {
|
||||
self.flow_state = AppState::EndWindow;
|
||||
self.init_end()?;
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,388 @@
|
|||
//! All ui structures and utility functions
|
||||
|
||||
//! The (minimal) user interface to control the program
|
||||
use color_eyre::Result;
|
||||
use ratatui::{
|
||||
style::{Color, Style},
|
||||
widgets::{Block, LineGauge, List, ListState, Paragraph},
|
||||
};
|
||||
use serialport::SerialPortInfo;
|
||||
use std::{
|
||||
iter::Iterator,
|
||||
ops::Add,
|
||||
sync::{Arc, Mutex},
|
||||
};
|
||||
use strum::{EnumCount, EnumIter};
|
||||
use strum::{FromRepr, IntoEnumIterator};
|
||||
|
||||
use crate::structs::{InputDirection, SavedConfig, TinyError, TinyUIError};
|
||||
|
||||
/// Color of a selected border
|
||||
pub(crate) const SELECTED_COLOR: Color = Color::White;
|
||||
/// Color of an unselected item
|
||||
pub(crate) const UNSELECTED_COLOR: Color = Color::DarkGray;
|
||||
|
||||
/// This struct holds the current state of the app.
|
||||
#[derive(Debug)]
|
||||
pub(crate) struct AppInfo<'a> {
|
||||
/// Wether the app sould immediately quit
|
||||
pub(crate) should_quit: bool,
|
||||
/// The list of baudrates
|
||||
pub(crate) baudrate: BaudRateList,
|
||||
/// The list of ports
|
||||
pub(crate) port_list: PortList,
|
||||
/// State of the configuration, akin to tab or window
|
||||
pub(crate) flow_state: AppState,
|
||||
/// The list of menu item generated
|
||||
pub(crate) menu_items: MenuItems<'a>,
|
||||
/// A debug message string
|
||||
pub(crate) status_message: String,
|
||||
/// The start frequency
|
||||
pub(crate) start_frequency: UIUsize,
|
||||
/// The stop frequency
|
||||
pub(crate) stop_frequency: UIUsize,
|
||||
/// The number of points
|
||||
pub(crate) points: UIUsize,
|
||||
/// Global progress
|
||||
pub(crate) progress: Arc<Mutex<usize>>,
|
||||
/// Global initialisation data
|
||||
pub(crate) scan_info: Arc<Mutex<String>>,
|
||||
/// Global message
|
||||
pub(crate) scan_message: Arc<Mutex<String>>,
|
||||
/// Return scan data
|
||||
pub(crate) return_data: Arc<Mutex<Vec<(f64, f64)>>>,
|
||||
}
|
||||
#[derive(Debug)]
|
||||
pub(crate) struct UIUsize {
|
||||
/// Current value held by the usize
|
||||
value: usize,
|
||||
/// Increment by witch it can be upped
|
||||
increment: usize,
|
||||
/// Max value to clamp it to
|
||||
clamp: usize,
|
||||
}
|
||||
|
||||
impl UIUsize {
|
||||
/// Change the value depending on selection
|
||||
pub(crate) fn change_value(&mut self, direction: InputDirection) {
|
||||
match direction {
|
||||
InputDirection::Up => self.value = self.value.add(self.increment).clamp(0, self.clamp),
|
||||
InputDirection::Down => self.value = self.value.saturating_sub(self.increment),
|
||||
_ => (),
|
||||
}
|
||||
}
|
||||
|
||||
/// Create a new UIUsize, usefull for TUI manipulation
|
||||
pub(crate) fn new(value: usize, increment: usize, clamp: usize) -> Self {
|
||||
Self {
|
||||
value,
|
||||
increment,
|
||||
clamp,
|
||||
}
|
||||
}
|
||||
|
||||
/// Convert to a string with the litteral value
|
||||
pub(crate) fn int_to_string(&self) -> String {
|
||||
format!("{}", self.value)
|
||||
}
|
||||
|
||||
/// Convert to mhz multiplying it by 1_000_000
|
||||
pub(crate) fn mhz_to_usize(&self) -> usize {
|
||||
self.value * 1000000
|
||||
}
|
||||
|
||||
/// Output inner value
|
||||
pub(crate) fn int_to_usize(&self) -> usize {
|
||||
self.value
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
/// The inner state of the app, useful for display and keystrokes
|
||||
pub(crate) enum AppState {
|
||||
/// Initial config, baudrate and port
|
||||
InitialConfig(SelectedConfig),
|
||||
/// Final config, frequencies and points
|
||||
FinalConfig(SelectedFinalConfig),
|
||||
/// The end window for confirmation
|
||||
EndWindow,
|
||||
/// Save window
|
||||
Finished,
|
||||
}
|
||||
|
||||
impl Default for AppState {
|
||||
fn default() -> Self {
|
||||
Self::InitialConfig(SelectedConfig::default())
|
||||
}
|
||||
}
|
||||
|
||||
#[macro_export]
|
||||
/// Shortcut for move right
|
||||
macro_rules! mright {
|
||||
($v:ident, $cname:ident,$fname:ident) => {
|
||||
Some(AppState::$cname(
|
||||
$fname::from_repr(min(($v + 1), $fname::COUNT - 1))
|
||||
.ok_or(TinyUIError::MenuSelectionError)?,
|
||||
))
|
||||
};
|
||||
}
|
||||
|
||||
#[macro_export]
|
||||
/// Shortcut to move left
|
||||
macro_rules! mleft {
|
||||
($v:ident, $cname:ident,$fname:ident) => {
|
||||
if $v == 0 {
|
||||
None
|
||||
} else {
|
||||
Some(AppState::$cname(
|
||||
$fname::from_repr($v - 1).ok_or(TinyUIError::MenuSelectionError)?,
|
||||
))
|
||||
}
|
||||
};
|
||||
}
|
||||
/// The selected item in the config
|
||||
#[derive(Debug, EnumCount, FromRepr, Clone, Copy)]
|
||||
pub(crate) enum SelectedConfig {
|
||||
/// Selects the ports
|
||||
Port,
|
||||
/// Selects the baudrate
|
||||
Baudrate,
|
||||
// /// Selects <Ok> to proceed
|
||||
// Proceed,
|
||||
}
|
||||
|
||||
impl Default for SelectedConfig {
|
||||
fn default() -> Self {
|
||||
Self::Port
|
||||
}
|
||||
}
|
||||
|
||||
/// The selected item in the final menu
|
||||
#[derive(Debug, EnumCount, FromRepr, Copy, Clone)]
|
||||
pub(crate) enum SelectedFinalConfig {
|
||||
/// Selects the start frequency
|
||||
StartFreq,
|
||||
/// Selects the final frequency
|
||||
FinalFreq,
|
||||
/// Selects the number of points
|
||||
Points,
|
||||
// /// Selects <Ok> to proceed
|
||||
// Proceed,
|
||||
}
|
||||
|
||||
impl Default for SelectedFinalConfig {
|
||||
fn default() -> Self {
|
||||
Self::StartFreq
|
||||
}
|
||||
}
|
||||
|
||||
/// The list of all baudrates selectables
|
||||
#[derive(Debug)]
|
||||
pub(crate) struct BaudRateList {
|
||||
// /// The selected baudrate (default : BAUD1115200)
|
||||
// pub(crate) selected: usize,
|
||||
/// The baudrate list
|
||||
pub(crate) baudrates: Vec<BaudRate>,
|
||||
/// The inner state of the widget
|
||||
pub(crate) state: ListState,
|
||||
}
|
||||
impl BaudRateList {
|
||||
/// Convert into a vec of strings, this is extremely expensive and shouldn't be done that way
|
||||
pub(crate) fn to_vecstr(&self) -> Vec<String> {
|
||||
self.baudrates
|
||||
.iter()
|
||||
.map(|i| format!("{}", *i as usize))
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// Change the cursor position on the baudrates
|
||||
pub(crate) fn change_cursor(&mut self, direction: InputDirection) {
|
||||
match direction {
|
||||
InputDirection::Down => self.state.select_next(),
|
||||
InputDirection::Up => self.state.select_previous(),
|
||||
_ => (),
|
||||
}
|
||||
}
|
||||
|
||||
/// Create a baudrate from a config file
|
||||
pub(crate) fn from_conf(loaded_conf: &Result<SavedConfig, TinyError>) -> BaudRateList {
|
||||
// TODO: Actually load from baudrate
|
||||
if let Ok(c) = loaded_conf {
|
||||
for (i, baud) in BaudRate::iter().enumerate() {
|
||||
if c.baudrate == baud as usize {
|
||||
return Self {
|
||||
state: ListState::default().with_selected(Some(i)),
|
||||
..Default::default()
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
Self::default()
|
||||
}
|
||||
}
|
||||
|
||||
impl Default for BaudRateList {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
baudrates: BaudRate::iter().collect::<Vec<_>>(),
|
||||
state: ListState::default().with_selected(Some(3)),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A list of possible baudrates
|
||||
#[derive(Debug, EnumIter, Copy, Clone)]
|
||||
pub(crate) enum BaudRate {
|
||||
BAUD19200 = 19_200,
|
||||
BAUD38400 = 38_400,
|
||||
BAUD57600 = 57_600,
|
||||
BAUD115200 = 115_200,
|
||||
BAUD230400 = 230_400,
|
||||
BAUD460800 = 460_800,
|
||||
BAUD921600 = 921_600,
|
||||
BAUD1843200 = 1_843_200,
|
||||
BAUD2000000 = 2_000_000,
|
||||
BAUD3000000 = 3_000_000,
|
||||
}
|
||||
|
||||
/// A wrapper over the list of ports
|
||||
#[derive(Debug)]
|
||||
pub(crate) struct PortList {
|
||||
/// The list of found ports
|
||||
pub(crate) ports: Vec<String>,
|
||||
// /// The currently selected port (doing it that way completly avoids the )
|
||||
// pub(crate) selected: usize,
|
||||
/// The inner state of the widget
|
||||
pub(crate) state: ListState,
|
||||
}
|
||||
|
||||
impl PortList {
|
||||
/// Make a port list from a serial reading
|
||||
pub(crate) fn from_serial(
|
||||
info: Vec<SerialPortInfo>,
|
||||
saved_config: &Result<SavedConfig, TinyError>,
|
||||
) -> Self {
|
||||
let ports: Vec<String> = info.into_iter().map(|port| port.port_name).collect();
|
||||
let selected = find_best_port(&ports, saved_config);
|
||||
Self {
|
||||
ports,
|
||||
// selected,
|
||||
state: ListState::default().with_selected(Some(selected)),
|
||||
}
|
||||
}
|
||||
|
||||
/// Convert the list of ports
|
||||
pub(crate) fn to_vecstr(&self) -> Vec<String> {
|
||||
self.ports.clone()
|
||||
}
|
||||
|
||||
/// Change the selected item
|
||||
pub(crate) fn change_cursor(&mut self, direction: InputDirection) {
|
||||
match direction {
|
||||
InputDirection::Up => self.state.select_previous(),
|
||||
InputDirection::Down => self.state.select_next(),
|
||||
_ => (),
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns the final selected port
|
||||
pub(crate) fn selected_port(&self) -> String {
|
||||
self.ports[self.state.selected().unwrap()].clone()
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Default)]
|
||||
/// The static list of all menu items
|
||||
pub(crate) struct MenuItems<'a> {
|
||||
/// List of port items
|
||||
pub(crate) portlist: Option<List<'a>>,
|
||||
/// List of port items
|
||||
pub(crate) baudlist: Option<List<'a>>,
|
||||
/// List of all the textboxes
|
||||
pub(crate) textboxes: Vec<Paragraph<'a>>,
|
||||
/// The progress bar
|
||||
pub(crate) progress_bar: Option<LineGauge<'a>>,
|
||||
// /// Controller info
|
||||
// pub(crate) info: Option<Chart<'a>>,
|
||||
// /// The final graph
|
||||
// pub(crate) graph: Option<Chart<'a>>,
|
||||
}
|
||||
|
||||
/// Try to guess the best port to preselect
|
||||
fn find_best_port(ports: &[String], saved_config: &Result<SavedConfig, TinyError>) -> usize {
|
||||
// TODO: Try to load from disk then save to disk
|
||||
let mut best_ports = vec!["/dev/ttyACM0", "COM3", "COM5", "/dev/ttyS16"];
|
||||
let p: Vec<&str> = if let Ok(c) = saved_config {
|
||||
let mut v = vec![&*c.port];
|
||||
v.append(&mut best_ports);
|
||||
v
|
||||
} else {
|
||||
best_ports
|
||||
};
|
||||
for port in p {
|
||||
if let Some(p) = ports.iter().position(|v| v == port) {
|
||||
return p;
|
||||
}
|
||||
}
|
||||
0
|
||||
}
|
||||
|
||||
impl<'a> AppInfo<'a> {
|
||||
/// Put an item a specified color
|
||||
pub(crate) fn change_color(
|
||||
&mut self,
|
||||
name: &'a str,
|
||||
list: List<'a>,
|
||||
color: Color,
|
||||
) -> Option<List<'a>> {
|
||||
Some(
|
||||
list.block(Block::bordered().title(name).border_style(color))
|
||||
.style(Style::default().fg(color)),
|
||||
)
|
||||
}
|
||||
|
||||
/// Save the config with the current runtime variables
|
||||
pub(crate) fn save_config(&self) -> Result<(), TinyUIError> {
|
||||
SavedConfig::save(self)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> AppInfo<'a> {
|
||||
/// Update all the colors
|
||||
pub(crate) fn update_color(&mut self) -> Result<(), TinyUIError> {
|
||||
match self.flow_state {
|
||||
AppState::InitialConfig(ref c) => {
|
||||
let (p_c, b_c) = match c {
|
||||
SelectedConfig::Baudrate => (UNSELECTED_COLOR, SELECTED_COLOR),
|
||||
SelectedConfig::Port => (SELECTED_COLOR, UNSELECTED_COLOR),
|
||||
};
|
||||
let (p, b) =
|
||||
(
|
||||
self.menu_items.portlist.take().ok_or(
|
||||
TinyUIError::UninitializedItemList("Port List", line!(), file!()),
|
||||
)?,
|
||||
self.menu_items.baudlist.take().ok_or(
|
||||
TinyUIError::UninitializedItemList("Port List", line!(), file!()),
|
||||
)?,
|
||||
);
|
||||
// self.status_message = format!("{:?} p:{:?} {:?} {:?}", Instant::now(), p_c, b_c, c);
|
||||
self.menu_items.portlist = self.change_color("COM Ports", p, p_c);
|
||||
self.menu_items.baudlist = self.change_color("Baudrate", b, b_c);
|
||||
}
|
||||
// TODO: Have all color update here
|
||||
AppState::FinalConfig(_selected_final_config) => (),
|
||||
_ => (),
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
// /// Create a textbox with a custom title
|
||||
// macro_rules! text_with_title {
|
||||
// ($name:expr) => {{
|
||||
// let mut texta = TextArea::default();
|
||||
// let block = Block::default().title($name);
|
||||
// texta.set_block(block);
|
||||
// texta
|
||||
// }};
|
||||
// }
|
||||
Loading…
Reference in New Issue