app.rs now configures a given serial device with a given baud rate. If not defined, 4800bps are set by default, but this will be surely changed in the future.

I was messing up pretty badly with command line arguments, so they have been declared as constants in cmdline.rs, whereas CMD_LINE_ARGS is now private.
Uncommented  "extern crate serial". Question: why does need to be included on main?

3 files changed, 106 insertions, 21 deletions

diff --git a/src/app.rs b/src/app.rs
index 92490b1..a772989 100644
--- a/src/app.rs
+++ b/src/app.rs
@@ -6,11 +6,24 @@ use std::{string::String, io, collections::HashMap};
 /// if configured by command line parameters.
 pub fn app(arg_hash: HashMap<String, String>) -> io::Result<()> {
 
-    match arg_hash.get(&String::from("--tcp")) {
+    use cmdline;
+
+    let addr = arg_hash.get(&String::from(cmdline::TCP_ARG));
+
+    match addr {
         None => println!("No TCP address specified"),
         Some(addr) => setup_tcp(addr)?
     };
 
+    // Since this should never return None, always unwrap() it.
+    let port_name = arg_hash.get(&String::from(cmdline::PORT_NAME_ARG)).unwrap();
+
+    // Extract baud rate from command line parameters,
+    // but don't process it yet.
+    let baud_rate = arg_hash.get(&String::from(cmdline::BAUDRATE_ARG));
+
+    serial_comm(addr, port_name, baud_rate)?;
+
     Ok(())
 }
 
@@ -22,19 +35,67 @@ fn setup_tcp(tcp_addr : &String) -> io::Result<()> {
 
     println!("Awaiting for connection on address {}", tcp_addr);
 
-    for stream in listener.incoming() {
-        match stream {
-            Ok(s) => {
-                // do something with the TcpStream
-            }
-            Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
-                // wait until network socket is ready, typically implemented
-                // via platform-specific APIs such as epoll or IOCP
-                continue;
+    //~ for stream in listener.incoming() {
+        //~ match stream {
+            //~ Ok(s) => {
+                //~ // do something with the TcpStream
+            //~ }
+            //~ Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
+                //~ // wait until network socket is ready, typically implemented
+                //~ // via platform-specific APIs such as epoll or IOCP
+                //~ continue;
+            //~ }
+            //~ Err(e) => panic!("encountered IO error: {}", e),
+        //~ }
+    //~ }
+
+    Ok(())
+}
+
+fn serial_comm(addr : Option<&String>, port_name : &String, baud_rate : Option<&String>) -> io::Result<()> {
+    serial_init(addr, port_name, baud_rate).unwrap();
+
+    Ok(())
+}
+
+fn serial_init(addr : Option<&String>, port_name : &String, baud_rate : Option<&String>) -> io::Result<serial::SystemPort> {
+    use serial::SerialPort;
+
+    let port = serial::open(port_name);
+
+    let mut port_unwrapped;
+
+    let baud =  match baud_rate {
+        None => serial::Baud4800,
+        Some(b) => {
+            match b.parse() {
+                Ok(4800) => serial::Baud4800,
+                Ok(9600) => serial::Baud9600,
+                Err(_) | Ok(_) => return Err(io::Error::new(io::ErrorKind::Other, "Invalid baudrate")),
             }
-            Err(e) => panic!("encountered IO error: {}", e),
         }
-    }
+    };
 
-    Ok(())
+    match port {
+       Err(_) => {
+           println!();
+           return Err(io::Error::new(io::ErrorKind::NotFound, "Could not open serial device"));
+       },
+
+       Ok(p) => {
+           port_unwrapped = p;
+       }
+    };
+
+    let settings : serial::PortSettings = serial::PortSettings {
+                baud_rate: baud,
+                char_size: serial::Bits8,
+                parity: serial::ParityOdd,
+                stop_bits: serial::Stop1,
+                flow_control: serial::FlowNone
+            };
+
+    port_unwrapped.configure(&settings)?;
+
+    Ok(port_unwrapped)
 }
diff --git a/src/cmdline.rs b/src/cmdline.rs
index d3af076..c3278df 100644
--- a/src/cmdline.rs
+++ b/src/cmdline.rs
@@ -7,31 +7,36 @@ pub struct CmdLineArg {
     explanation : &'static str
 }
 
-pub const CMD_LINE_ARGS : [CmdLineArg; 4] =
+pub const PORT_NAME_ARG : &'static str = "--port-name";
+pub const DISABLE_OUTPUT_ARG : &'static str = "--disable-output";
+pub const BAUDRATE_ARG : &'static str = "--baudrate";
+pub const TCP_ARG : &'static str = "--tcp";
+
+const CMD_LINE_ARGS : [CmdLineArg; 4] =
 [
     CmdLineArg {
-        arg_str : "--port-name",
+        arg_str : PORT_NAME_ARG,
         param_str : Some("[PORT]"),
         is_required : true,
         explanation : "Sets serial port"
     },
 
     CmdLineArg {
-        arg_str : "--disable-output",
+        arg_str : DISABLE_OUTPUT_ARG,
         param_str : None,
         is_required : false,
         explanation : "Disables incoming debug messages from the console"
     },
 
     CmdLineArg {
-        arg_str : "--baudrate",
+        arg_str : BAUDRATE_ARG,
         param_str : Some("[BAUDRATE]"),
         is_required : false,
         explanation : "Sets serial port baudrate. Defaults to 4800bps"
     },
 
     CmdLineArg {
-        arg_str : "--tcp",
+        arg_str : TCP_ARG,
         param_str : Some("[IPv4:PORT]"),
         is_required : false,
         explanation : "Sets a TCP connection against a compatible \
@@ -73,6 +78,17 @@ pub fn process_arguments() -> Option<HashMap<String, String>> {
         ParameterValue
     };
 
+    impl std::fmt::Debug for ExpectedParameter {
+        fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+            write!( f,
+                    "ExpectedParameter::{}",
+                    match self {
+                        ExpectedParameter::ParameterOption => "ParameterOption",
+                        ExpectedParameter::ParameterValue => "ParameterValue"
+                    })
+        }
+    };
+
     let mut parameter_state = ExpectedParameter::ParameterOption;
 
     let mut arg_hash: HashMap<String, String> = HashMap::new();
@@ -86,6 +102,7 @@ pub fn process_arguments() -> Option<HashMap<String, String>> {
                 if arg_str.starts_with("--")
                 {
                     // Looks like a valid parameter
+                    let mut result : bool = false;
 
                     for param in CMD_LINE_ARGS.iter() {
 
@@ -103,13 +120,21 @@ pub fn process_arguments() -> Option<HashMap<String, String>> {
                                 }
                             }
 
+                            result = true;
+
                             break;
                         }
                     }
+
+                    if !result {
+                        // Parameter could not be found inside the list.
+                        println!("Invalid parameter {}", parameter_name);
+                        return None
+                    }
                 }
                 else
                 {
-                    return None;
+                    return None
                 }
             },
 
diff --git a/src/main.rs b/src/main.rs
index 3c49926..71870ec 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,5 +1,4 @@
-//~ extern crate serial;
-//~ use serial::prelude::*;
+extern crate serial;
 
 mod cmdline;
 mod app;