CLI args better UI behavior.

Author: john-michaelburke

console_backend/src/cli_options.rs

@@ -1,8 +1,56 @@
 use clap::Clap;
-use std::{ops, path::PathBuf};
+use std::{
+    ops::{Deref, Not},
+    path::PathBuf,
+    str::FromStr,
+};
+use strum::VariantNames;
 
+use crate::common_constants::{SbpLogging, Tabs};
 use crate::constants::{AVAILABLE_BAUDRATES, AVAILABLE_REFRESH_RATES};
-use crate::types::{CliTabs, FlowControl};
+use crate::types::FlowControl;
+
+#[derive(Debug)]
+pub struct CliTabs(Tabs);
+
+impl Deref for CliTabs {
+    type Target = Tabs;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl FromStr for CliTabs {
+    type Err = String;
+
+    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+        Ok(CliTabs(Tabs::from_str(s).map_err(|_| {
+            format!("Must choose from available tabs {:?}", Tabs::VARIANTS)
+        })?))
+    }
+}
+
+#[derive(Debug)]
+pub struct CliSbpLogging(SbpLogging);
+
+impl Deref for CliSbpLogging {
+    type Target = SbpLogging;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl FromStr for CliSbpLogging {
+    type Err = String;
+
+    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+        Ok(CliSbpLogging(SbpLogging::from_str(s).map_err(|_| {
+            format!("Must choose from available tabs {:?}", SbpLogging::VARIANTS)
+        })?))
+    }
+}
 
 #[derive(Clap, Debug)]
 #[clap(name = "swift_navigation_console", about = "Swift Navigation Console.")]
@@ -14,17 +62,34 @@ pub struct CliOptions {
     #[clap(long = "exit-after")]
     pub exit_after: bool,
 
-    // // Frontend Options
+    /// Enable CSV logging.
+    #[clap(long = "csv-log")]
+    pub csv_log: bool,
+
+    /// Enable SBP-JSON or SBP logging.
+    #[clap(long = "sbp-log")]
+    pub sbp_log: Option<CliSbpLogging>,
+
+    /// Set log directory.
+    #[clap(long = "log-dirname")]
+    pub dirname: Option<String>,
+
+    // Frontend Options
     /// Don't use opengl in plots.
-    #[clap(long = "no-opengl", parse(from_flag = ops::Not::not))]
+    #[clap(long = "no-opengl", parse(from_flag = Not::not))]
     pub no_opengl: bool,
 
-    /// Don't use opengl in plots.
+    /// Change the refresh rate of the plots.
     #[clap(long = "refresh-rate", validator(is_refresh_rate))]
     pub refresh_rate: Option<u8>,
 
+    /// Start console from specific tab.
     #[clap(long = "tab")]
     pub tab: Option<CliTabs>,
+
+    /// Show CSV logging button.
+    #[clap(long = "show-csv-log")]
+    pub show_csv_log: bool,
 }
 
 impl CliOptions {

console_backend/src/common_constants.rs

@@ -34,6 +34,38 @@ pub enum Tabs {
     ADVANCED,
 }
 
+#[derive(Clone, Debug, Display, EnumString, EnumVariantNames, Eq, Hash, PartialEq)]
+pub enum SbpLogging {
+    #[strum(serialize = "OFF")]
+    OFF,
+    #[strum(serialize = "SBP_JSON")]
+    SBP_JSON,
+    #[strum(serialize = "SBP")]
+    SBP,
+}
+
+#[derive(Clone, Debug, Display, EnumString, EnumVariantNames, Eq, Hash, PartialEq)]
+pub enum CsvLogging {
+    #[strum(serialize = "OFF")]
+    OFF,
+    #[strum(serialize = "ON")]
+    ON,
+}
+
+#[derive(Clone, Debug, Display, EnumString, EnumVariantNames, Eq, Hash, PartialEq)]
+pub enum LogLevel {
+    #[strum(serialize = "ERROR")]
+    ERROR,
+    #[strum(serialize = "WARNING")]
+    WARNING,
+    #[strum(serialize = "NOTICE")]
+    NOTICE,
+    #[strum(serialize = "INFO")]
+    INFO,
+    #[strum(serialize = "DEBUG")]
+    DEBUG,
+}
+
 #[derive(Clone, Debug, Display, EnumString, EnumVariantNames, Eq, Hash, PartialEq)]
 pub enum Keys {
     #[strum(serialize = "POINTS")]
@@ -78,8 +110,40 @@ pub enum Keys {
     WEEK,
     #[strum(serialize = "ROWS")]
     ROWS,
+    #[strum(serialize = "PREVIOUS_HOSTS")]
+    PREVIOUS_HOSTS,
+    #[strum(serialize = "PREVIOUS_PORTS")]
+    PREVIOUS_PORTS,
+    #[strum(serialize = "PREVIOUS_FILES")]
+    PREVIOUS_FILES,
     #[strum(serialize = "CONNECTED")]
     CONNECTED,
+    #[strum(serialize = "PORT")]
+    PORT,
+    #[strum(serialize = "POS")]
+    POS,
+    #[strum(serialize = "RTK")]
+    RTK,
+    #[strum(serialize = "SATS")]
+    SATS,
+    #[strum(serialize = "CORR_AGE")]
+    CORR_AGE,
+    #[strum(serialize = "INS")]
+    INS,
+    #[strum(serialize = "DATA_RATE")]
+    DATA_RATE,
+    #[strum(serialize = "SOLID_CONNECTION")]
+    SOLID_CONNECTION,
+    #[strum(serialize = "PREVIOUS_FOLDERS")]
+    PREVIOUS_FOLDERS,
+    #[strum(serialize = "SBP_LOGGING")]
+    SBP_LOGGING,
+    #[strum(serialize = "CSV_LOGGING")]
+    CSV_LOGGING,
+    #[strum(serialize = "SBP_LOGGING_LABELS")]
+    SBP_LOGGING_LABELS,
+    #[strum(serialize = "LOG_LEVEL_LABELS")]
+    LOG_LEVEL_LABELS,
 }
 
 #[derive(Clone, Debug, Display, EnumString, EnumVariantNames, Eq, Hash, PartialEq)]
@@ -96,10 +160,10 @@ pub enum ApplicationStates {
 pub enum MessageKeys {
     #[strum(serialize = "status")]
     STATUS,
-    #[strum(serialize = "connectedStatus")]
-    CONNECTED_STATUS,
-    #[strum(serialize = "bottomNavbarStatus")]
-    BOTTOM_NAVBAR_STATUS,
+    #[strum(serialize = "statusBarStatus")]
+    STATUS_BAR_STATUS,
+    #[strum(serialize = "navBarStatus")]
+    NAV_BAR_STATUS,
     #[strum(serialize = "solutionPositionStatus")]
     SOLUTION_POSITION_STATUS,
     #[strum(serialize = "solutionTableStatus")]
@@ -134,6 +198,10 @@ pub enum MessageKeys {
     SOLUTION_POSITION_STATUS_BUTTON_FRONT,
     #[strum(serialize = "logAppend")]
     LOG_APPEND,
+    #[strum(serialize = "loggingBarFront")]
+    LOGGING_BAR_FRONT,
+    #[strum(serialize = "loggingBarStatus")]
+    LOGGING_BAR_STATUS,
 }
 
 #[derive(Clone, Debug, Display, EnumString, EnumVariantNames, Eq, Hash, PartialEq)]

console_backend/src/constants.rs

@@ -34,6 +34,7 @@ pub const VEL_TIME_STR_FILEPATH: &str = "velocity_log_%Y%m%d-%H%M%S.csv";
 pub const POS_LLH_TIME_STR_FILEPATH: &str = "position_log_%Y%m%d-%H%M%S.csv";
 pub const SBP_FILEPATH: &str = "swift-gnss-%Y%m%d-%H%M%S.sbp";
 pub const SBP_JSON_FILEPATH: &str = "swift-gnss-%Y%m%d-%H%M%S.sbp.json";
+pub const DEFAULT_LOG_DIRECTORY: &str = "SwiftNav";
 
 // Common constants.
 pub const NUM_POINTS: usize = 200;

console_backend/src/main_tab.rs

@@ -3,6 +3,7 @@ use log::{debug, error};
 use sbp::{messages::SBP, time::GpsTime};
 use std::{path::PathBuf, result::Result, thread::sleep, time::Instant};
 
+use crate::common_constants::SbpLogging;
 use crate::constants::*;
 use crate::observation_tab::ObservationTab;
 use crate::output::*;
@@ -15,7 +16,7 @@ use crate::utils::refresh_loggingbar;
 
 pub struct MainTab<'a, S: MessageSender> {
     logging_directory: PathBuf,
-    last_solution_logging: CsvLogging,
+    last_csv_logging: CsvLogging,
     last_sbp_logging: SbpLogging,
     sbp_logger: Option<SbpLogger>,
     last_gps_update: Instant,
@@ -32,9 +33,9 @@ pub struct MainTab<'a, S: MessageSender> {
 impl<'a, S: MessageSender> MainTab<'a, S> {
     pub fn new(shared_state: SharedState, client_sender: S) -> MainTab<'a, S> {
         MainTab {
-            logging_directory: DATA_DIRECTORY.path(),
-            last_solution_logging: CsvLogging::Off,
-            last_sbp_logging: SbpLogging::Off,
+            logging_directory: shared_state.logging_directory(),
+            last_csv_logging: CsvLogging::OFF,
+            last_sbp_logging: SbpLogging::OFF,
             sbp_logger: None,
             last_gps_time: None,
             last_gps_update: Instant::now(),
@@ -110,8 +111,10 @@ impl<'a, S: MessageSender> MainTab<'a, S> {
                 None
             }
         };
+        self.shared_state.set_csv_logging(CsvLogging::ON);
     }
     pub fn end_csv_logging(&mut self) -> crate::types::Result<()> {
+        self.shared_state.set_csv_logging(CsvLogging::OFF);
         if let Some(vel_log) = &mut self.solution_tab.vel_log_file {
             vel_log.flush()?;
             self.solution_tab.vel_log_file = None;
@@ -130,7 +133,7 @@ impl<'a, S: MessageSender> MainTab<'a, S> {
     pub fn init_sbp_logging(&mut self, logging: SbpLogging) {
         let local_t = Local::now();
         self.sbp_logger = match logging {
-            SbpLogging::Sbp => {
+            SbpLogging::SBP => {
                 let sbp_log_file = local_t.format(SBP_FILEPATH).to_string();
                 let sbp_log_file = self.logging_directory.join(sbp_log_file);
                 match SbpLogger::new_sbp(&sbp_log_file) {
@@ -141,7 +144,7 @@ impl<'a, S: MessageSender> MainTab<'a, S> {
                     }
                 }
             }
-            SbpLogging::Json => {
+            SbpLogging::SBP_JSON => {
                 let sbp_json_log_file = local_t.format(SBP_JSON_FILEPATH).to_string();
                 let sbp_json_log_file = self.logging_directory.join(sbp_json_log_file);
                 match SbpLogger::new_sbp_json(&sbp_json_log_file) {
@@ -154,43 +157,49 @@ impl<'a, S: MessageSender> MainTab<'a, S> {
             }
             _ => None,
         };
+        self.shared_state.set_sbp_logging(logging);
     }
     pub fn serialize_sbp(&mut self, msg: &SBP) {
-        let solution_logging;
+        let csv_logging;
         let sbp_logging;
         let directory;
         {
             let shared_data = self.shared_state.lock().unwrap();
-            solution_logging = (*shared_data).logging_bar.solution_logging.clone();
+            csv_logging = (*shared_data).logging_bar.csv_logging.clone();
             sbp_logging = (*shared_data).logging_bar.sbp_logging.clone();
             directory = (*shared_data).logging_bar.logging_directory.clone();
         }
-        if self.last_solution_logging != solution_logging {
+        self.logging_directory = self.shared_state.clone().logging_directory();
+
+        if self.logging_directory != directory {
+            if let Err(e) = create_directory(directory.clone()) {
+                error!("Issue creating directory {}.", e);
+                self.shared_state
+                    .set_logging_directory(self.logging_directory.clone());
+            } else {
+                self.shared_state.update_folder_history(directory.clone());
+                self.logging_directory = directory;
+            }
+            refresh_loggingbar(&mut self.client_sender, self.shared_state.clone());
+        }
+
+        if self.last_csv_logging != csv_logging {
             if let Err(e) = self.end_csv_logging() {
                 error!("Issue closing csv file, {}", e);
             }
-            if let CsvLogging::On = &solution_logging {
+            if let CsvLogging::ON = &csv_logging {
                 self.init_csv_logging();
             }
-            self.last_solution_logging = solution_logging;
+            self.last_csv_logging = csv_logging;
+            refresh_loggingbar(&mut self.client_sender, self.shared_state.clone());
         }
         if self.last_sbp_logging != sbp_logging {
             self.close_sbp();
-            if let SbpLogging::Off = &sbp_logging {
+            if let SbpLogging::OFF = &sbp_logging {
             } else {
                 self.init_sbp_logging(sbp_logging.clone());
             }
             self.last_sbp_logging = sbp_logging;
-        }
-        if self.logging_directory != directory {
-            if let Err(e) = create_directory(directory.clone()) {
-                error!("Issue creating directory {}.", e);
-                self.shared_state
-                    .set_logging_directory(self.logging_directory.clone());
-            } else {
-                self.shared_state.update_folder_history(directory.clone());
-                self.logging_directory = directory;
-            }
             refresh_loggingbar(&mut self.client_sender, self.shared_state.clone());
         }
 
@@ -201,6 +210,7 @@ impl<'a, S: MessageSender> MainTab<'a, S> {
         }
     }
     pub fn close_sbp(&mut self) {
+        self.shared_state.set_sbp_logging(SbpLogging::OFF);
         self.sbp_logger = None;
     }
 }

console_backend/src/output.rs

@@ -10,44 +10,26 @@ use serde::Serialize;
 use serde_json::ser::CompactFormatter;
 use std::{fs::File, path::Path};
 
+use crate::common_constants as cc;
 use crate::types::Result;
 
-#[derive(Clone, Debug, PartialEq)]
-pub enum CsvLogging {
-    Off,
-    On,
-}
+pub type CsvLogging = cc::CsvLogging;
 impl From<bool> for CsvLogging {
     fn from(logging: bool) -> Self {
         if logging {
-            CsvLogging::On
+            CsvLogging::ON
         } else {
-            CsvLogging::Off
+            CsvLogging::OFF
         }
     }
 }
-
-#[derive(Clone, Debug, PartialEq)]
-pub enum SbpLogging {
-    Off,
-    Sbp,
-    Json,
-}
-impl From<(bool, bool)> for SbpLogging {
-    fn from(logging_and_format: (bool, bool)) -> Self {
-        let (sbp_logging, sbp_format) = logging_and_format;
-        if sbp_logging {
-            if sbp_format {
-                SbpLogging::Sbp
-            } else {
-                SbpLogging::Json
-            }
-        } else {
-            SbpLogging::Off
-        }
+impl CsvLogging {
+    pub fn to_bool(&self) -> bool {
+        matches!(self, CsvLogging::ON)
     }
 }
 
+pub type SbpLogging = cc::SbpLogging;
 pub enum SbpLogger {
     Sbp(FramedWrite<File, SbpEncoder>),
     Json(FramedWrite<File, JsonEncoder<CompactFormatter>>),