diff --git a/src/scan.rs b/src/scan.rs index e3c4c64..4483e15 100644 --- a/src/scan.rs +++ b/src/scan.rs @@ -24,8 +24,8 @@ use serialport::SerialPort; use std::{ fs::File, io::{BufWriter, Read, Write}, - sync::OnceLock, - thread::sleep, + sync::{Arc, Mutex, OnceLock}, + thread::{self}, time::Duration, }; @@ -44,61 +44,64 @@ pub struct DataPoint { static EOF: OnceLock> = 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) +pub(crate) fn scan_with_progress( + progress: Arc>, + scan_info: Arc>, + scan_message: Arc>, + port: String, + start: usize, + stop: usize, + points: usize, +) -> Result<(), TinyError> { + *scan_message.lock().unwrap() = "Oppening connection".to_string(); + let mut port = serialport::new(port, 115_200) .timeout(Duration::from_millis(3000)) .open() .expect("Failed to open port"); + *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); + // ("{}", send_cmd(&mut port, "leveloffset\r", SHORT_WAIT)); + // ("{}", send_cmd(&mut port, "deviceid\r", SHORT_WAIT)); + // ("{}", send_cmd(&mut port, "usart_cfg\r", 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.; + scanraw(&mut port, progress.clone(), start, stop, points)?; + + *scan_message.lock().unwrap() = "Scan finished".to_string(); + send_cmd(&mut port, "resume\r", SHORT_WAIT); + + *progress.lock().unwrap() = 100.; wait_sync(LONG_WAIT); Ok(()) } @@ -107,30 +110,26 @@ 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) { 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) -> 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]).?(); - // println!("{:?}", v); - // parse_data(v)?; - unsafe { send_raw(port, &format!("scanraw {} {} {}\r", START, STOP, POINTS)) } +fn scanraw( + port: &mut Box, + progress: Arc>, + start: usize, + stop: usize, + points: usize, +) -> Result<(), TinyError> { + unsafe { send_raw(port, &format!("scanraw {} {} {}\r", start, stop, points)) } wait_sync(SHORT_WAIT); - read_scanraw(port)?; + read_scanraw(port, progress, points)?; wait_sync(LONG_WAIT); Ok(()) } @@ -148,7 +147,6 @@ fn send_cmd(port: &mut Box, 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, command: &str) { let output = command.as_bytes(); - println!("Sending: {}", command); let _r = port.write(output).expect("Write failed!"); } @@ -164,13 +162,11 @@ fn read_port(port: &mut Box) -> Vec { 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,15 +174,19 @@ fn read_port(port: &mut Box) -> Vec { /// Waits the normal start Character '{' and begins treating data as normal /// /// Returns a struct summerizing the information processed -fn read_scanraw(port: &mut Box) -> Result<(), TinyError> { +fn read_scanraw( + port: &mut Box, + progress: Arc>, + points: usize, +) -> Result<(), TinyError> { let v = read_port(port); // Find the { marking the beggining - parse_data(v) + parse_data(v, progress, points) } /// A utility function used for parsing the raw data of a scan -pub fn parse_data(v: Vec) -> Result<(), TinyError> { - let mut values: Vec = Vec::with_capacity(POINTS); +pub fn parse_data(v: Vec, progress: Arc>, points: usize) -> Result<(), TinyError> { + let mut values: Vec = Vec::with_capacity(points); let mut out = BufWriter::new(File::create("test.csv")?); if let Some(begining) = memchr::memchr(b'{', &v) { // Finds the } marking the end @@ -195,14 +195,6 @@ pub fn parse_data(v: Vec) -> Result<(), TinyError> { for (i, slice) in data.chunks_exact(3).enumerate() { let s: &[u8; 3] = &[slice[0], slice[1], slice[2]]; let d = DataPoint::unpack(s)?; - // println!( - // "{} {} {} -> {} : {}", - // x, - // b1, - // b2, - // d.value, - // u16_to_f64(d.value) - // ); values.push(d.value); writeln!( out, @@ -211,12 +203,6 @@ pub fn parse_data(v: Vec) -> Result<(), TinyError> { u16_to_f64(d.value) // bytes_to_f64(b1, b2) )?; } - 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(()) } else { Err(TinyError::ParseEnd("}".to_owned())) @@ -239,25 +225,3 @@ fn u16_to_f64(v: u16) -> f64 { // status: ScanStatus, // data: Vec, // } - -// 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"); -// } diff --git a/src/structs.rs b/src/structs.rs index 31b8fa6..15bac25 100644 --- a/src/structs.rs +++ b/src/structs.rs @@ -1,4 +1,5 @@ //! All the structs used internally + use thiserror::Error; /// The most common error, exposed to the lib user and end used @@ -51,6 +52,10 @@ pub enum TinyUIError { /// 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 + #[error("An error occured while trying to fetch progress")] + Mutex, } // impl TinyUIError { diff --git a/src/ui.rs b/src/ui.rs index 3134229..f88e204 100644 --- a/src/ui.rs +++ b/src/ui.rs @@ -1,7 +1,8 @@ //! The (minimal) user interface to control the program #![allow(unused_imports)] use clap::builder::Resettable; -use color_eyre::owo_colors::OwoColorize; +use color_eyre::{owo_colors::OwoColorize, Section}; +use core::time; use ratatui::{ buffer::Buffer, crossterm::{ @@ -29,14 +30,15 @@ use std::{ fmt::Pointer, iter::Iterator, sync::{Arc, Mutex}, - time::Instant, + thread, + time::{Duration, Instant}, }; use strum::{EnumCount, EnumIter, EnumProperty}; use strum::{FromRepr, IntoEnumIterator}; use tui_textarea::{Input, Key, TextArea}; use crate::{ - mleft, mright, + mleft, mright, scan, structs::{InputDirection, TinyError, TinyUIError}, ui_struct::{ AppInfo, AppState, BaudRateList, MenuItems, PortList, SelectedConfig, SelectedFinalConfig, @@ -57,7 +59,9 @@ impl<'a> AppInfo<'a> { start_frequency: UIUsize::new(240, 10, 960), stop_frequency: UIUsize::new(960, 10, 960), points: UIUsize::new(10000, 100, 1000000), - progress: Arc::new(Mutex::new(0)), + progress: Arc::new(Mutex::new(0.)), + scan_info: Arc::new(Mutex::new(String::new())), + scan_message: Arc::new(Mutex::new(String::new())), } } @@ -69,11 +73,14 @@ impl<'a> AppInfo<'a> { self.init_config()?; loop { terminal.draw(|v| self.draw(v).inspect_err(|e| panic!("{}", e)).unwrap())?; - if let Event::Key(key) = event::read()? { - self.handle_start_keys(key)?; - }; - if self.should_quit { - break; + 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(()) @@ -117,21 +124,7 @@ impl<'a> AppInfo<'a> { /// Initialisation of all the ui element for the final configuration elements fn init_final_config(&mut self) -> Result<(), TinyUIError> { - // /// 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 - // }}; - // } - self.menu_items.textboxes = vec![ - // text_with_title!("Start Frequency"), - TextArea::default(), - TextArea::default(), - TextArea::default(), - ]; + self.menu_items.textboxes = vec![Paragraph::new("")]; self.update_color() } @@ -152,6 +145,7 @@ impl<'a> AppInfo<'a> { 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) @@ -185,6 +179,7 @@ impl<'a> AppInfo<'a> { area_points, ); + self.update_color()?; frame.render_widget(Paragraph::new(self.status_message.clone()), title_area); self.render_footer(frame, status_area); Ok(()) @@ -205,38 +200,67 @@ impl<'a> AppInfo<'a> { self.menu_items.progress_bar = Some( LineGauge::default() // .block(title) - .filled_style(Style::default().fg(Color::Blue).bg(Color::Blue)) - .unfilled_style(Style::default().fg(Color::Red).bg(Color::Red)) - .label("Background:"), + .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 progress, updates as the progress is being done - fn draw_progress(&self, frame: &mut Frame<'_>) -> Result<(), TinyUIError> { + fn draw_progress(&mut self, frame: &mut Frame<'_>) -> Result<(), TinyUIError> { // let title = title_block("Blue / red only background"); - let [title_area, main_area, status_area] = Layout::vertical([ - Constraint::Length(2), - Constraint::Min(10), - Constraint::Length(1), + + let [_, main_s, _] = Layout::horizontal([ + Constraint::Min(7), + Constraint::Percentage(90), + Constraint::Min(7), ]) .areas(frame.area()); - let [_, area_ports, area_baud, _] = Layout::horizontal([ - Constraint::Min(7), - Constraint::Percentage(50), - Constraint::Percentage(50), - Constraint::Min(7), + let [title_area, _, main_area, _, progress_area] = Layout::vertical([ + Constraint::Length(3), + // Constraint::Length(1), + Constraint::Length(1), + // Constraint::Length(1), + Constraint::Min(10), + Constraint::Length(1), + Constraint::Length(1), ]) - .areas(main_area); - // frame.render_widget( - // Paragraph::new(self.points.int_to_string()) - // .block(Block::bordered()) - // .style(poi_color), - // area_points, - // ); + .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 / 100.); + (pb, status, message) + }; + // let self= pb.clone + frame.render_widget(pb.clone(), progress_area); + frame.render_widget(status, title_area); + frame.render_widget(message, main_area); + // frame.render_widget(Paragraph::new(format!("{:?}", Instant::now())), main_area); + // thread::sleep(Duration::from_millis(100)); + self.menu_items.progress_bar = Some(pb); + // TODO: If progress = 100 move to final step and show S / enter to save G for graph Ok(()) - // .ratio(self.progress); - // .render(area, buf); } /// Draw the config info @@ -358,7 +382,22 @@ impl<'a> AppInfo<'a> { self.flow_state = AppState::FinalConfig(SelectedFinalConfig::default()); self.init_final_config()?; } - AppState::FinalConfig(_) => self.flow_state = AppState::Finished, + AppState::FinalConfig(_) => { + self.flow_state = AppState::Finished; + self.init_progress()?; + // Start the scan + let pmtx = self.progress.clone(); + let mmtx = self.scan_info.clone(); + let cmtx = self.scan_message.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(); + thread::spawn(move || { + scan::scan_with_progress(pmtx, mmtx, cmtx, port, start, stop, points).unwrap() + }); + // scan::scan_with_progress(pmtx, mmtx, cmtx, port).unwrap(); + } AppState::Popup => todo!(), AppState::Finished => todo!(), } diff --git a/src/ui_struct.rs b/src/ui_struct.rs index afa34f3..efdabab 100644 --- a/src/ui_struct.rs +++ b/src/ui_struct.rs @@ -31,6 +31,7 @@ use std::{ fmt::Pointer, iter::Iterator, ops::Add, + str::FromStr, sync::{Arc, Mutex}, time::Instant, }; @@ -77,9 +78,12 @@ pub(crate) struct AppInfo<'a> { /// The number of points pub(crate) points: UIUsize, /// Global progress - pub(crate) progress: Arc>, + pub(crate) progress: Arc>, + /// Global initialisation data + pub(crate) scan_info: Arc>, + /// Global message + pub(crate) scan_message: Arc>, } - #[derive(Debug)] pub(crate) struct UIUsize { /// Current value held by the usize @@ -115,8 +119,13 @@ impl UIUsize { } /// Convert to mhz multiplying it by 1_000_000 - pub(crate) fn mhz_to_string(&self) -> String { - format!("{}", self.value * 1000000) + pub(crate) fn mhz_to_usize(&self) -> usize { + self.value * 1000000 + } + + /// Output inner value + pub(crate) fn int_to_usize(&self) -> usize { + self.value } } @@ -289,6 +298,11 @@ impl PortList { _ => (), } } + + /// Returns the final selected port + pub(crate) fn selected_port(&self) -> String { + self.ports[self.state.selected().unwrap()].clone() + } } #[derive(Debug, Default)] @@ -299,7 +313,7 @@ pub(crate) struct MenuItems<'a> { /// List of port items pub(crate) baudlist: Option>, /// List of all the textboxes - pub(crate) textboxes: Vec>, + pub(crate) textboxes: Vec>, /// The progress bar pub(crate) progress_bar: Option>, /// Controller info @@ -318,14 +332,7 @@ fn find_best_port(ports: &[String]) -> usize { } 0 } -// #[allow(clippy::missing_docs_in_private_items)] -// const fn alternate_colors(i: usize) -> Color { -// if i % 2 == 0 { -// NORMAL_ROW_BG -// } else { -// ALT_ROW_BG_COLOR -// } -// } + impl<'a> AppInfo<'a> { /// Put an item a specified color pub(crate) fn change_color( @@ -363,27 +370,26 @@ impl<'a> AppInfo<'a> { self.menu_items.baudlist = self.change_color("Baudrate", b, b_c); } AppState::FinalConfig(ref c) => { - // let (mif_color, maf_color, poi_color) = match self.flow_state { - let colorlist = match c { - SelectedFinalConfig::StartFreq => { - [SELECTED_COLOR, UNSELECTED_COLOR, UNSELECTED_COLOR] - } - SelectedFinalConfig::FinalFreq => { - [UNSELECTED_COLOR, SELECTED_COLOR, UNSELECTED_COLOR] - } - SelectedFinalConfig::Points => { - [UNSELECTED_COLOR, UNSELECTED_COLOR, SELECTED_COLOR] - } - }; + // self.status_message = format!("Moo"); + // let colorlist = match c { + // SelectedFinalConfig::StartFreq => { + // [SELECTED_COLOR, UNSELECTED_COLOR, UNSELECTED_COLOR] + // } + // SelectedFinalConfig::FinalFreq => { + // [UNSELECTED_COLOR, SELECTED_COLOR, UNSELECTED_COLOR] + // } + // SelectedFinalConfig::Points => { + // [UNSELECTED_COLOR, UNSELECTED_COLOR, SELECTED_COLOR] + // } + // }; - for (area, color) in self.menu_items.textboxes.iter_mut().zip(colorlist) { - area.set_block( - Block::default() - .borders(Borders::ALL) - .style(Style::default().fg(color)) - .title(" Inactive (^X to switch) "), - ) - } + // for (area, color) in self.menu_items.textboxes.iter_mut().zip(colorlist) { + // .block( + // Block::default() + // // .borders(Borders::ALL) + // .style(Style::default().fg(Color::Blue)), // .title(" Inactive (^X to switch) "), + // ) + // } } AppState::Popup => todo!(), AppState::Finished => todo!(), @@ -391,3 +397,13 @@ impl<'a> AppInfo<'a> { 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 +// }}; +// }