tiny-wb/src/structs.rs

318 lines
11 KiB
Rust

//! All the structs used internally
use std::{
fs::File,
io::{Read, Write},
sync::{Arc, Mutex},
};
use flexi_logger::FlexiLoggerError;
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 {
/// An error occured while receiving the raw data and '{' couldn't be found
#[error("Couldn't parse the beggining of the data ({0})")]
ParseBeggining(String),
/// An error occured while receiving the raw data and '}' couldn't be found
#[error("Couldn't parse the end of the data ({0})")]
ParseEnd(String),
/// The given serial port couldn't be opened
#[error("Couldn't connect to the given port")]
PortConnection(#[from] serialport::Error),
/// 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),
/// The version couldn't be acquired, likely a bogus connection
#[error("Couldn't acquire the version of the device connected to the specified port")]
NoVersionFound,
/// The given scan frequencies are incorrect
#[error("The given scan frequencies are inccorect ({0})")]
BadScanFrequencies(String),
/// Couldn't initialize the logging modure
#[error("Couldn't initialize the logging modure")]
LoggerError(#[from] FlexiLoggerError),
/// Couldn't send data
#[error("Couldn't write to the TinySA, connection lost")]
SendError(std::io::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),
/// Couldn't get a port from the selection
#[error("No port was selected")]
NoPortSelected,
/// Any Scan Error
#[error("An error occured while trying to scan: \n => {0}")]
ScanError(#[from] TinyError),
/// No connection object was created
#[error("An error occured while trying to acquire the connection info structure")]
NoConnectionInfoCreated,
/// No return data was created or initialized
#[error("An error occured while trying to acquire the return data")]
NoReturnData,
/// No error was generated, this error is a meta error
#[error("An unspecified error occured")]
NoErrorSpecified,
/// Error occured while tring to serialize the config to file
#[error("Couldn't serialize the error to file")]
SerializeError(#[from] toml::ser::Error),
}
#[derive(Serialize, Deserialize, Debug)]
pub(crate) struct SavedConfig {
/// The default com port
pub(crate) port: String,
/// The default baudrate
pub(crate) baudrate: u32,
/// 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,
/// The default number of repeat per point
pub(crate) repeat: 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.selected_baudrate()?,
start_frequency: arg.start_frequency.int_to_usize(),
stop_frequency: arg.stop_frequency.int_to_usize(),
points: arg.points.int_to_usize(),
repeat: arg.repeat.int_to_usize(),
})?
.as_bytes(),
)?;
Ok(())
}
}
/// The various status the connection can take
#[derive(Debug, Clone, Copy)]
pub(crate) enum ConnectionStatus {
/// The connection was created with no initialisation data
Uninitialised,
// /// The connection has initialisation data but wasn't established
// Initialised,
// /// The connection was established
// Connected,
/// The connection coudn't be done, with a string explaining the error
ConnectionFailure,
/// The connection is closed and the connection was a succes
ClosedWithSuccess,
}
type ScanData = Vec<(f64, f64)>;
#[derive(Debug, Clone)]
/// All data needed to handle a connection to the TinySA
pub(crate) struct ConnectionInfo {
/// The number of points to scan
pub(crate) points: usize,
/// The baudrate of the connection
pub(crate) baudrate: u32,
/// The Serial port to open for connection
pub(crate) port: String,
/// A mutex to share the progression (over 100)
progress: Arc<Mutex<usize>>,
/// The number of times to repeate a mesurement of a point
pub(crate) repeat: usize,
/// A mutex to the result of the scan
return_data: Arc<Mutex<Option<ScanData>>>,
/// The information of the TinySA
scan_info: Arc<Mutex<String>>,
/// The last scan message (what's happening as the scan goes)
scan_message: Arc<Mutex<String>>,
/// The value to start at (in Hz)
pub(crate) start: usize,
/// The value to stop at (in Hz)
pub(crate) stop: usize,
/// The file name to store all data
file_name: Arc<Mutex<String>>,
/// The connection status
connection_status: Arc<Mutex<ConnectionStatus>>,
/// The last error raised
pub(crate) error_raised: Arc<Mutex<Option<TinyUIError>>>,
}
impl ConnectionInfo {
/// Create the initial connection containing only the initial mutex for error collection
pub(crate) fn new() -> Self {
Self::default()
}
/// Updates the connection with the given data
pub(crate) fn fill(
&mut self,
port: String,
baudrate: u32,
start: usize,
stop: usize,
points: usize,
repeat: usize,
) {
self.port = port;
self.baudrate = baudrate;
self.start = start;
self.stop = stop;
self.points = points;
self.repeat = repeat;
}
/// Updates the generic scan message
pub(crate) fn update_message(&self, message: &'static str) {
*self.scan_message.lock().unwrap() = message.to_string();
}
/// Updates the scan progress
pub(crate) fn update_progress(&self, progress: usize) {
*self.progress.lock().unwrap() = progress;
}
/// Update the information of the TinySA
pub(crate) fn update_info(&self, message: String) {
*self.scan_info.lock().unwrap() = message.to_string();
}
/// A clone of the mutex to keep it updated
pub(crate) fn mutex_progress(&self) -> Arc<Mutex<usize>> {
self.progress.clone()
}
/// Update the return data with the new points
pub(crate) fn update_return_data(&self, return_data: Vec<(f64, f64)>) {
*self.return_data.lock().unwrap() = Some(return_data);
}
/// Update the filename with the one choosen by the save method
pub(crate) fn update_filename(&self, name: String) {
*self.file_name.lock().unwrap() = name;
}
/// Get the current progression level
pub(crate) fn get_progress(&self) -> usize {
*self.progress.lock().unwrap()
}
/// Get the latest scan message
pub(crate) fn get_scan_message(&self) -> String {
(*self.scan_message.lock().unwrap()).to_string()
}
/// Get the latest tinySA information (There is no guaranty it is initialised or valid)
pub(crate) fn get_scan_info(&self) -> String {
(*self.scan_info.lock().unwrap()).to_string()
}
/// Get the latest connection status
pub(crate) fn get_connection_status(&self) -> ConnectionStatus {
*self.connection_status.lock().unwrap()
}
/// Take the return data and leave none in place
pub(crate) fn get_return_data(&self) -> Result<Vec<(f64, f64)>, TinyUIError> {
self.return_data
.lock()
.unwrap()
.take()
.ok_or(TinyUIError::NoReturnData)
}
/// Updates the connection status
pub(crate) fn update_connection_status(&self, new_status: ConnectionStatus) {
*self.connection_status.lock().unwrap() = new_status
}
/// Set an error
pub(crate) fn set_error(&self, e: Option<TinyUIError>) {
*self.error_raised.lock().unwrap() = e;
}
/// Wether an error has been raised
pub(crate) fn has_error(&self) -> bool {
self.error_raised.lock().unwrap().is_some()
}
// pub(crate) fn get_error(&self) -> &Option<TinyError> {
// self.error_raised.lock().as_ref().unwrap()
// }
}
impl Default for ConnectionInfo {
fn default() -> Self {
Self {
points: 11,
baudrate: 115_200,
port: String::new(),
progress: Arc::new(Mutex::new(0)),
repeat: 1,
return_data: Arc::new(Mutex::new(None)),
scan_info: Arc::new(Mutex::new(String::new())),
scan_message: Arc::new(Mutex::new(String::new())),
start: 240,
stop: 960,
file_name: Arc::new(Mutex::new(String::new())),
connection_status: Arc::new(Mutex::new(ConnectionStatus::Uninitialised)),
error_raised: Arc::new(Mutex::new(None)),
}
}
}