ACK from the device is received.

Fixed serial configuration as "no parity".
Added command-line argument "--cdimg-folder", used to retrieve data.

.vscode/launch.json

@@ -0,0 +1,27 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "(gdb) Launch",
+            "type": "cppdbg",
+            "request": "launch",
+            "program": "${workspaceFolder}/target/debug/rspsxserial",
+            "args": ["--port-name", "/dev/ttyUSB0", "--cdimg-folder", "~/Airport/cdimg"],
+            "stopAtEntry": false,
+            "cwd": "${workspaceFolder}",
+            "environment": [],
+            "externalConsole": false,
+            "MIMode": "gdb",
+            "setupCommands": [
+                {
+                    "description": "Enable pretty-printing for gdb",
+                    "text": "-enable-pretty-printing",
+                    "ignoreFailures": true
+                }
+            ]
+        }
+    ]
+}

Cargo.toml

@@ -5,3 +5,5 @@ authors = ["Xavier Del Campo <xavi92psx@gmail.com>"]
 
 [dependencies]
 serial = "0.4.0"
+regex = "1"
+lazy_static = "1.2.0"

src/app.rs

@@ -27,7 +27,10 @@ pub fn app(arg_hash: HashMap<String, String>) -> Result<()> {
     // but don't process it yet.
     let baud_rate = arg_hash.get(&String::from(cmdline::BAUDRATE_ARG));
 
-    serial_comm(addr, port_name, baud_rate)?;
+    // Extract folder where CD-ROM file system is mounted.
+    let folder = arg_hash.get(&String::from(cmdline::CDIMG_FOLDER)).expect("Invalid given folder");
+
+    serial_comm(addr, port_name, baud_rate, folder)?;
 
     Ok(())
 }
@@ -57,7 +60,7 @@ fn setup_tcp(tcp_addr : &String) -> Result<()> {
     Ok(())
 }
 
-fn serial_comm(addr : Option<&String>, port_name : &String, baud_rate : Option<&String>) -> Result<()> {
+fn serial_comm(addr : Option<&String>, port_name : &String, baud_rate : Option<&String>, folder : &String) -> Result<()> {
     use transfer;
     use transfer::TransferState;
 
@@ -74,7 +77,9 @@ fn serial_comm(addr : Option<&String>, port_name : &String, baud_rate : Option<&
                 prev_state = state;
                 state
             },
-            _ => TransferState::Finished
+            TransferState::SendHeader => transfer::send_header(&mut port, folder),
+            _ => TransferState::Finished,
+            TransferState::Finished => break,
         };
     }
 
@@ -122,7 +127,7 @@ fn serial_init(addr : Option<&String>, port_name : &String, baud_rate : Option<&
         serial::PortSettings {
             baud_rate: baud,
             char_size: serial::Bits8,
-            parity: serial::ParityOdd,
+            parity: serial::ParityNone,
             stop_bits: serial::Stop1,
             flow_control: serial::FlowNone
         };

src/cmdline.rs

@@ -25,7 +25,11 @@ pub const BAUDRATE_ARG : &'static str = "--baud-rate";
 /// against a GUI front-end.
 pub const TCP_ARG : &'static str = "--tcp";
 
-const CMD_LINE_ARGS : [CmdLineArg; 4] =
+/// This parameter defines what folder should
+/// be looked up in order to set up a working environment
+pub const CDIMG_FOLDER : &'static str = "--cdimg-folder";
+
+const CMD_LINE_ARGS : [CmdLineArg; 5] =
 [
     CmdLineArg {
         arg_str : PORT_NAME_ARG,
@@ -54,6 +58,13 @@ const CMD_LINE_ARGS : [CmdLineArg; 4] =
         is_required : false,
         explanation : "Sets a TCP connection against a compatible \
                       front-end application"
+    },
+
+    CmdLineArg {
+        arg_str : CDIMG_FOLDER,
+        param_str : Some("[FOLDER]"),
+        is_required : true,
+        explanation : "Sets working directory"
     }
 ];
 

src/main.rs

@@ -1,4 +1,6 @@
 extern crate serial;
+extern crate regex;
+#[macro_use] extern crate lazy_static;
 mod cmdline;
 mod app;
 mod transfer;
@@ -16,27 +18,3 @@ fn main() {
         }
     }
 }
-
-//~ /** let mut port = serial::open(&arg).unwrap();
-        //~ interact(&mut port).unwrap();*/
-
-//~ /// This function reconfigures a serial port with default parameters
-//~ fn interact<T: SerialPort>(port: &mut T) -> io::Result<()> {
-    //~ port.reconfigure(&|settings| {
-        //~ settings.set_baud_rate(serial::Baud9600)?;
-        //~ settings.set_char_size(serial::Bits8);
-        //~ settings.set_parity(serial::ParityNone);
-        //~ settings.set_stop_bits(serial::Stop1);
-        //~ settings.set_flow_control(serial::FlowNone);
-        //~ Ok(())
-    //~ })?;
-
-    //~ port.set_timeout(Duration::from_millis(1000))?;
-
-    //~ let buf: Vec<u8> = (0..255).collect();
-
-    //~ port.write(&buf[..])?;
-    //~ //port.read(&mut buf[..])?;
-
-    //~ Ok(())
-//~ }

src/transfer.rs

@@ -16,6 +16,7 @@ pub fn first_contact(port : &mut serial::SystemPort) -> TransferState {
         Err(_) => TransferState::FirstContact,
         Ok(b) => {
             if b == 1 {
+                println!("Written 1 byte: {}", INITIAL_TRANSMISSION);
                 TransferState::WaitAck
             }
             else
@@ -34,19 +35,46 @@ pub fn wait_ack(port : &mut serial::SystemPort, prev_state: TransferState) -> Tr
 
     let mut buffer : [u8; 1] = [0];
 
+    use serial::SerialPort;
+
+    (*port).set_timeout(std::time::Duration::from_secs(2)).expect("Could not adjust timeout");
+
     match (*port).read(&mut buffer) {
-        Err(_) => TransferState::WaitAck,
+        Err(_) => {
+            prev_state
+        },
         Ok(b) => {
             if b == 1 {
-                match prev_state {
-                    TransferState::FirstContact => TransferState::SendHeader,
-                    _ => TransferState::Finished
+                if buffer[0] == 'b' as u8 {
+                    println!("Received ACK");
+                    match prev_state {
+                        TransferState::FirstContact => TransferState::SendHeader,
+                        _ => TransferState::Finished
+                    }
+                }
+                else
+                {
+                    prev_state
                 }
             }
             else
             {
-                TransferState::WaitAck
+                prev_state
             }
         }
     }
 }
+
+pub fn send_header(port : &mut serial::SystemPort, folder : &String) -> TransferState {
+    use std::fs;
+    use regex::Regex;
+
+    let data_buffer = fs::read_to_string(format!("{}/{}", folder, "SYSTEM.CNF")).unwrap();
+    lazy_static! {
+        static ref RX: Regex = Regex::new(r"BOOT\s*=\s*cdrom:\(.+\.EXE);1").unwrap();
+    }
+
+    println!("{:?}", RX.captures(&data_buffer).unwrap());
+
+    TransferState::SendHeader
+}