From 83b78b632c7d2996ccfb64b6fb48386ef8785141 Mon Sep 17 00:00:00 2001 From: Dandaedre Date: Tue, 24 Sep 2024 21:24:51 +0200 Subject: [PATCH] First "working" version --- .gitignore | 1 + Cargo.toml | 3 ++ src/main.rs | 2 +- src/scan.rs | 79 +++++++++++++++++++++++----------- src/structs.rs | 70 +++++++++++++++++++++++++++--- src/ui.rs | 109 +++++++++++++++++++++++++++++------------------ src/ui_struct.rs | 106 ++++++++++++++++++++++----------------------- 7 files changed, 244 insertions(+), 126 deletions(-) diff --git a/.gitignore b/.gitignore index 3c68812..365d39a 100644 --- a/.gitignore +++ b/.gitignore @@ -20,3 +20,4 @@ Cargo.lock /target *.csv +config.toml diff --git a/Cargo.toml b/Cargo.toml index a0e44e4..510afda 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -4,6 +4,7 @@ version = "0.1.0" edition = "2021" [dependencies] +chrono = "0.4.38" # byteorder = "1.5.0" clap = { version = "4.5.17", features = ["derive"] } color-eyre = "0.6.3" @@ -13,9 +14,11 @@ 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] diff --git a/src/main.rs b/src/main.rs index 43a76f7..7a4603d 100644 --- a/src/main.rs +++ b/src/main.rs @@ -4,7 +4,7 @@ //! and will not offer any scripting capabilities #![warn(missing_docs, clippy::missing_docs_in_private_items)] -#![allow(dead_code)] +// #![allow(dead_code)] mod scan; mod structs; mod ui; diff --git a/src/scan.rs b/src/scan.rs index 336ae24..1e02dc1 100644 --- a/src/scan.rs +++ b/src/scan.rs @@ -4,10 +4,6 @@ static START: usize = 240_000_000; /// The default stop value for a scan static STOP: usize = 959_000_000; -/// 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 /// The offset used for sending data static OFFSET: usize = 128; /// The base delay used inbetween commands @@ -29,6 +25,8 @@ use std::{ 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,20 +42,26 @@ pub struct DataPoint { static EOF: OnceLock> = OnceLock::new(); /// Scan a specific range and returns the scan result +#[allow(clippy::too_many_arguments)] pub(crate) fn scan_with_progress( progress: Arc>, scan_info: Arc>, scan_message: Arc>, + return_data: 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) + 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); @@ -93,9 +97,16 @@ pub(crate) fn scan_with_progress( ); *progress.lock().unwrap() = 22; - scanraw(&mut port, progress.clone(), start, stop, points)?; + let name = scanraw( + &mut port, + progress.clone(), + return_data.clone(), + start, + stop, + points, + )?; - *scan_message.lock().unwrap() = "Scan finished".to_string(); + *scan_message.lock().unwrap() = format!("Scan saved as {}", name); send_cmd(&mut port, "resume\r", SHORT_WAIT); wait_sync(LONG_WAIT); @@ -120,15 +131,23 @@ fn wait_sync(duration: u64) { fn scanraw( port: &mut Box, progress: Arc>, + return_data: Arc>>, start: usize, stop: usize, points: usize, -) -> Result<(), TinyError> { +) -> Result { unsafe { send_raw(port, &format!("scanraw {} {} {}\r", start, stop, points)) } wait_sync(SHORT_WAIT); - read_scanraw(port, progress, points)?; + 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 @@ -198,16 +217,25 @@ fn read_scanraw( port: &mut Box, progress: Arc>, points: usize, -) -> Result<(), TinyError> { + 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, points) + parse_data(v, points, start, increment) } /// A utility function used for parsing the raw data of a scan -pub fn parse_data(v: Vec, points: usize) -> Result<(), TinyError> { - let mut values: Vec = Vec::with_capacity(points); - let mut out = BufWriter::new(File::create("test.csv")?); +pub fn parse_data( + v: Vec, + points: usize, + start: usize, + increment: f64, +) -> Result<(String, Vec<(f64, f64)>), TinyError> { + // let mut values: Vec = 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) { @@ -215,15 +243,16 @@ pub fn parse_data(v: Vec, points: usize) -> 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)?; - values.push(d.value); - writeln!( - out, - "{},{}", - (i * INCREMENT + START) as f64 / 1000000., - u16_to_f64(d.value) // bytes_to_f64(b1, b2) - )?; + let (pos, val) = ( + (i as f64 * increment + start as f64) / 1000000., + u16_to_f64(d.value), + ); + + csvdata.push((pos, val)); + writeln!(out, "{},{}", pos, val)?; } - Ok(()) + // TODO: Dont return use mutex + Ok((name, csvdata)) } else { Err(TinyError::ParseEnd("}".to_owned())) } diff --git a/src/structs.rs b/src/structs.rs index 15bac25..1d5b8c5 100644 --- a/src/structs.rs +++ b/src/structs.rs @@ -1,7 +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 { @@ -23,10 +31,18 @@ pub enum TinyError { /// 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)] @@ -52,10 +68,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, + // /// Mutex error likely a data race mishandled + // #[allow(dead_code)] + // #[error("An error occured while trying to fetch progress")] + // Mutex, } // impl TinyUIError { @@ -63,3 +79,47 @@ pub enum TinyUIError { // 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 { + 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(()) + } +} diff --git a/src/ui.rs b/src/ui.rs index 5ccf950..6e91b0b 100644 --- a/src/ui.rs +++ b/src/ui.rs @@ -40,7 +40,7 @@ use tui_textarea::{Input, Key, TextArea}; use crate::{ mleft, mright, scan, - structs::{InputDirection, TinyError, TinyUIError}, + structs::{InputDirection, SavedConfig, TinyError, TinyUIError}, ui_struct::{ AppInfo, AppState, BaudRateList, MenuItems, PortList, SelectedConfig, SelectedFinalConfig, UIUsize, SELECTED_COLOR, UNSELECTED_COLOR, @@ -50,19 +50,36 @@ use crate::{ impl<'a> AppInfo<'a> { /// Create a new app with the port info available pub(crate) fn new(info: Vec) -> 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::default(), - port_list: PortList::from_serial(info), + 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: UIUsize::new(240, 10, 960), - stop_frequency: UIUsize::new(960, 10, 960), - points: UIUsize::new(10000, 100, 1000000), + 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())), } } @@ -94,7 +111,6 @@ impl<'a> AppInfo<'a> { AppState::FinalConfig(_) => self.draw_final_config(frame), AppState::Finished => self.draw_progress(frame), AppState::EndWindow => self.draw_end_window(frame), - // _ => unimplemented!(), } } @@ -305,9 +321,9 @@ impl<'a> AppInfo<'a> { Constraint::Min(7), ]) .areas(frame.area()); - let [title_area, main_area, graph_area, _, footer_area] = Layout::vertical([ + let [title_area, _main_area, graph_area, _, footer_area] = Layout::vertical([ Constraint::Length(3), - Constraint::Length(4), + Constraint::Length(1), Constraint::Min(10), Constraint::Length(1), Constraint::Length(1), @@ -373,50 +389,55 @@ impl<'a> AppInfo<'a> { // ); // // .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") + // .name("Heavy") .marker(Marker::Dot) .graph_type(GraphType::Scatter) .style(Style::new().yellow()) - .data(&[ - (1965., -82.), - (1967., -54.), - (1981., -65.), - (1989., -30.), - (1997., -10.), - (2004., -11.), - (2014., -45.), - (2016., -79.), - (2018., -15.), - ])]; + .data(&binding)]; let chart = Chart::new(datasets) - .block( - Block::bordered().title( - Title::default() - .content("Scatter chart".cyan().bold()) - .alignment(Alignment::Center), - ), - ) + // .block( + // Block::bordered().title( + // Title::default() + // .content("Scatter chart".cyan().bold()) + // .alignment(Alignment::Center), + // ), + // ) .x_axis( Axis::default() - .title("Year") - .bounds([1960., 2020.]) + // .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(["1960", "1990", "2020"]), + .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") + // .title("Cost") .bounds([-128., 0.]) .style(Style::default().fg(Color::Gray)) - .labels(["0", "37 500", "75 000"]), - ) - .hidden_legend_constraints((Constraint::Ratio(1, 2), Constraint::Ratio(1, 2))); + .labels(["-128dbm", "-64dbm", "0dbm"]), + ); frame.render_widget(chart, graph_area); - let footer = - Paragraph::new("Press ↲ to save the data as a csv or q to exit without saving.") - .centered(); + 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(()) @@ -500,18 +521,24 @@ impl<'a> AppInfo<'a> { 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; - // thread::spawn(move || { - // scan::scan_with_progress(pmtx, mmtx, cmtx, port, start, stop, points).unwrap() - // }); + 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 => { diff --git a/src/ui_struct.rs b/src/ui_struct.rs index a35ebfb..9fa56c0 100644 --- a/src/ui_struct.rs +++ b/src/ui_struct.rs @@ -1,56 +1,22 @@ //! All ui structures and utility functions //! The (minimal) user interface to control the program -#![allow(unused_imports)] -use clap::builder::Resettable; -use color_eyre::{owo_colors::OwoColorize, Result}; +use color_eyre::Result; use ratatui::{ - buffer::Buffer, - crossterm::{ - event::{self, Event, KeyCode, KeyEvent, KeyEventKind}, - style::Print, - }, - layout::{Constraint, Direction, Layout, Rect}, - prelude::BlockExt, - style::{ - palette::tailwind::{BLUE, GREEN, SLATE}, - Color, Modifier, Style, Styled, Stylize, - }, - symbols, - text::Line, - widgets::{ - Block, Borders, Chart, HighlightSpacing, LineGauge, List, ListDirection, ListItem, - ListState, Padding, Paragraph, ScrollDirection, StatefulWidget, Widget, Wrap, - }, - DefaultTerminal, Frame, + style::{Color, Style}, + widgets::{Block, LineGauge, List, ListState, Paragraph}, }; use serialport::SerialPortInfo; use std::{ - borrow::{Borrow, BorrowMut}, - cmp::min, - fmt::Pointer, iter::Iterator, ops::Add, - str::FromStr, sync::{Arc, Mutex}, - time::Instant, }; -use strum::{EnumCount, EnumIter, EnumProperty}; +use strum::{EnumCount, EnumIter}; use strum::{FromRepr, IntoEnumIterator}; -use tui_textarea::{Input, Key, TextArea}; -use crate::structs::{InputDirection, TinyUIError}; +use crate::structs::{InputDirection, SavedConfig, TinyError, TinyUIError}; -/// The header style -const HEADER_STYLE: Style = Style::new().fg(SLATE.c100).bg(BLUE.c800); -/// The background color -const NORMAL_ROW_BG: Color = SLATE.c950; -/// Background color for alternated rows -const ALT_ROW_BG_COLOR: Color = SLATE.c900; -/// The style applied to the currently selected item -const SELECTED_STYLE: Style = Style::new().bg(SLATE.c800).add_modifier(Modifier::BOLD); -/// Foreground color -const TEXT_FG_COLOR: Color = SLATE.c200; /// Color of a selected border pub(crate) const SELECTED_COLOR: Color = Color::White; /// Color of an unselected item @@ -83,6 +49,8 @@ pub(crate) struct AppInfo<'a> { pub(crate) scan_info: Arc>, /// Global message pub(crate) scan_message: Arc>, + /// Return scan data + pub(crate) return_data: Arc>>, } #[derive(Debug)] pub(crate) struct UIUsize { @@ -211,8 +179,8 @@ impl Default for SelectedFinalConfig { /// The list of all baudrates selectables #[derive(Debug)] pub(crate) struct BaudRateList { - /// The selected baudrate (default : BAUD1115200) - pub(crate) selected: usize, + // /// The selected baudrate (default : BAUD1115200) + // pub(crate) selected: usize, /// The baudrate list pub(crate) baudrates: Vec, /// The inner state of the widget @@ -235,12 +203,27 @@ impl BaudRateList { _ => (), } } + + /// Create a baudrate from a config file + pub(crate) fn from_conf(loaded_conf: &Result) -> 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 { - selected: 0, baudrates: BaudRate::iter().collect::>(), state: ListState::default().with_selected(Some(3)), } @@ -267,20 +250,23 @@ pub(crate) enum BaudRate { pub(crate) struct PortList { /// The list of found ports pub(crate) ports: Vec, - /// The currently selected port (doing it that way completly avoids the ) - pub(crate) selected: usize, + // /// 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) -> Self { + pub(crate) fn from_serial( + info: Vec, + saved_config: &Result, + ) -> Self { let ports: Vec = info.into_iter().map(|port| port.port_name).collect(); - let selected = find_best_port(&ports); + let selected = find_best_port(&ports, saved_config); Self { ports, - selected, + // selected, state: ListState::default().with_selected(Some(selected)), } } @@ -316,17 +302,24 @@ pub(crate) struct MenuItems<'a> { pub(crate) textboxes: Vec>, /// The progress bar pub(crate) progress_bar: Option>, - /// Controller info - pub(crate) info: Option>, - /// The final graph - pub(crate) graph: Option>, + // /// Controller info + // pub(crate) info: Option>, + // /// The final graph + // pub(crate) graph: Option>, } /// Try to guess the best port to preselect -fn find_best_port(ports: &[String]) -> usize { +fn find_best_port(ports: &[String], saved_config: &Result) -> usize { // TODO: Try to load from disk then save to disk - let best_ports = ["/dev/ttyACM0", "COM3", "COM5", "/dev/ttyS16"]; - for port in best_ports { + 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; } @@ -347,6 +340,11 @@ impl<'a> AppInfo<'a> { .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> {