Refactoring / removed unneeded gps parse sentences for current implementation

Author: askrejans

Cargo.lock

@@ -8,4 +8,5 @@ serialport = "4.3.0"
 config = "0.13.4"
 paho-mqtt = "0.12.3"
 futures = "0.3.30"
-lazy_static = "1.4.0"
+lazy_static = "1.4.0"
+gumdrop = "0.8.1"

Cargo.toml

@@ -1,4 +1,5 @@
-use config::Config;
+use config::{Config, File};
+use std::path::Path;
 
 /// Struct to hold the application configuration.
 pub struct AppConfig {
@@ -8,7 +9,7 @@ pub struct AppConfig {
     /// The baud rate for the serial port.
     pub baud_rate: i64,
 
-    //Should the GPS sample rate be increased to 10Hz
+    // Should the GPS sample rate be increased to 10Hz
     pub set_gps_to_10hz: bool,
 
     /// The MQTT broker host address.
@@ -17,46 +18,62 @@ pub struct AppConfig {
     /// The MQTT broker port number.
     pub mqtt_port: i64,
 
-    //The base topic of MQTT where data is pushed
+    // The base topic of MQTT where data is pushed
     pub mqtt_base_topic: String,
+
+    // Optional: Path to the configuration file
+    pub config_path: Option<String>,
 }
 
 /// Load application configuration from a TOML file.
 ///
-/// This function reads the configuration settings from a TOML file named "settings.toml".
-/// It expects the following keys in the TOML file: "port_name", "baud_rate", "mqtt_host", and "mqtt_port".
+/// This function reads the configuration settings from a TOML file.
 ///
-/// # Panics
-/// Panics if any of the required configuration keys are missing or if there is an error reading the configuration file.
+/// # Arguments
+/// - `config_path`: An optional path to the configuration file.
 ///
 /// # Returns
-/// Returns an `AppConfig` struct containing the loaded configuration.
-pub fn load_configuration() -> AppConfig {
-    // Build a new Config object with a file source.
-    let settings = Config::builder()
-        .add_source(config::File::with_name("settings.toml"))
-        .build()
-        .unwrap();
+/// Returns a `Result` containing either the `AppConfig` struct with the loaded configuration or an error message.
+pub fn load_configuration(config_path: Option<&str>) -> Result<AppConfig, String> {
+    // Create a default configuration
+    let mut settings = Config::default();
 
-    // Create an AppConfig struct by extracting values from the configuration.
-    AppConfig {
-        port_name: settings
-            .get_string("port_name")
-            .expect("Missing port_name in configuration"),
-        baud_rate: settings
-            .get_int("baud_rate")
-            .expect("Missing baud_rate in configuration"),
-        set_gps_to_10hz: settings
-            .get_bool("set_gps_to_10hz")
-            .expect("Missing set_gps_to_10hz in configuration"),
-        mqtt_host: settings
-            .get_string("mqtt_host")
-            .expect("Missing mqtt_host in configuration"),
-        mqtt_port: settings
-            .get_int("mqtt_port")
-            .expect("Missing mqtt_port in configuration"),
-        mqtt_base_topic: settings
-            .get_string("mqtt_base_topic")
-            .expect("Missing mqtt_base_topic in configuration"),
+    // Try to load from the passed config_path
+    if let Some(path) = config_path {
+        match Config::builder().add_source(File::with_name(path)).build() {
+            Ok(config) => settings = config,
+            Err(err) => return Err(format!("{}", err)),
+        }
+    } else {
+        // Try to load from the executable's directory
+        if let Ok(exe_dir) = std::env::current_exe() {
+            let exe_dir = exe_dir.parent().unwrap_or_else(|| Path::new("."));
+            let default_path = exe_dir.join("settings.toml");
+
+            if let Ok(config) =
+                Config::builder().add_source(File::with_name(default_path.to_str().unwrap())).build()
+            {
+                settings = config;
+            }
+        }
+
+        // Try to load from /etc/g86-car-telemetry/speeduino-to-mqtt.toml
+        if let Ok(config) = Config::builder()
+            .add_source(File::with_name("/usr/etc/g86-car-telemetry/gps-to-mqtt.toml"))
+            .build()
+        {
+            settings = config;
+        }
     }
-}
+
+    // Create an AppConfig struct by extracting values from the configuration.
+    Ok(AppConfig {
+        port_name: settings.get_string("port_name").unwrap_or_else(|_| "default_port".to_string()),
+        baud_rate: settings.get_int("baud_rate").unwrap_or(9600),
+        set_gps_to_10hz: settings.get_bool("set_gps_to_10hz").unwrap_or(false),
+        mqtt_host: settings.get_string("mqtt_host").unwrap_or_else(|_| "default_host".to_string()),
+        mqtt_port: settings.get_int("mqtt_port").unwrap_or(1883),
+        mqtt_base_topic: settings.get_string("mqtt_base_topic").unwrap_or_else(|_| "default_topic".to_string()),
+        config_path: config_path.map(|p| p.to_string()),
+    })
+}

src/config.rs

@@ -1,3 +1,12 @@
+mod config;
+mod gps_data_parser;
+mod mqtt_handler;
+mod serial_port_handler;
+
+use serial_port_handler::{read_from_port, setup_serial_port};
+use gumdrop::Options;
+use config::load_configuration;
+
 /// # GPS Data Processor
 ///
 /// This Rust application serves as a processor for GPS data, converting it to MQTT messages.
@@ -19,13 +28,6 @@
 ///
 /// - `main()`: The main function that loads configuration, sets up serial communication, and starts reading data from the port.
 /// - `display_welcome()`: Function to display a graphical welcome message.
-mod config;
-mod gps_data_parser;
-mod mqtt_handler;
-mod serial_port_handler;
-
-use config::load_configuration;
-use serial_port_handler::{read_from_port, setup_serial_port};
 
 /// Displays a graphical welcome message.
 fn display_welcome() {
@@ -35,12 +37,47 @@ fn display_welcome() {
     println!("==========================================\n");
 }
 
+/// Define options for the program.
+#[derive(Debug, Options)]
+struct MyOptions {
+    #[options(help = "print help message")]
+    help: bool,
+
+    #[options(help = "Sets a custom config file", meta = "FILE")]
+    config: Option<String>,
+}
+
+fn print_help() {
+    println!("Usage: gps-to-mqtt [options]");
+    println!("Options:");
+    println!("  -h, --help               Print this help message");
+    println!("  -c, --config FILE        Sets a custom config file path");
+}
+
 fn main() {
+    // Parse CLI arguments using gumdrop
+    let opts = MyOptions::parse_args_default_or_exit();
+
+    if opts.help {
+        // Use custom print_help function to display help and exit
+        print_help();
+        std::process::exit(0);
+    }
+
     // Display welcome message
     display_welcome();
 
     // Load configuration, set up serial port, and start processing
-    let config = load_configuration();
+    let config_path = opts.config.as_deref();
+    let config = match load_configuration(config_path) {
+        Ok(config) => config,
+        Err(err) => {
+            // Handle the error gracefully, print a message, and exit
+            eprintln!("Error loading configuration: {}", err);
+            std::process::exit(1);
+        }
+    };
+
     let mut port = setup_serial_port(&config);
     read_from_port(&mut port, &config);
-}
+}

src/main.rs

@@ -23,19 +23,26 @@ use std::thread;
 /// # Returns
 ///
 /// Returns a boxed trait object representing the opened serial port.
-pub fn setup_serial_port(config: &AppConfig) -> Box<dyn SerialPort> {
-
+pub fn setup_serial_port(config: &AppConfig) -> Box<dyn serialport::SerialPort> {
     // Opening and configuring the specified serial port.
     println!("Opening port: {}", config.port_name);
-    let mut port = serialport::new(&config.port_name, config.baud_rate as u32)
+
+    let mut port = match serialport::new(&config.port_name, config.baud_rate as u32)
         .timeout(std::time::Duration::from_millis(1000))
         .open()
-        .expect("Failed to open port");
+    {
+        Ok(p) => p,
+        Err(err) => {
+            eprintln!("Failed to open port: {}", err);
+            std::process::exit(1);
+        }
+    };
 
     if config.set_gps_to_10hz {
         println!("Setting GPS sample rate to 10Hz");
         gps_resolution_to_10hz(&mut port);
     }
+
     port
 }
 
@@ -111,8 +118,6 @@ pub fn gps_resolution_to_10hz(port: &mut Box<dyn SerialPort>) {
 
 /// Check if the user wants to quit by entering 'q' + Enter.
 fn check_quit(sender: mpsc::Sender<String>) {
-    // Create a buffer to read user input
-    let mut input_buffer = String::new();
 
     // Read input from the user asynchronously
     let stdin = io::stdin();