serial terminal, commands not working yet

Author: addrian-77

process-console/Cargo.toml

@@ -24,4 +24,9 @@ queues = "1.0.2"
 itertools = "0.12.1"
 ratatui = "0.28.0"
 probe-rs = "0.24.0"
-
+clap = { version = "4.1.1", features = ["cargo"] }
+async-trait = "0.1.73"
+enum_dispatch = "0.3.12"
+console = { git = "https://github.com/george-cosma/console.git", branch = "unblock" }
+futures = "0.3.31"
+tokio-util = "0.7.15"

process-console/src/legacy/errors.rs

@@ -0,0 +1,68 @@
+use core::fmt;
+
+#[derive(Debug)]
+pub enum TockloaderError {
+    TokioSeriallError(tokio_serial::Error),
+    NoPortAvailable,
+    CLIError(CLIError),
+    IOError(std::io::Error),
+    JoinError(tokio::task::JoinError),
+}
+
+#[derive(Debug)]
+pub enum CLIError {
+    MultipleInterfaces,
+}
+
+impl fmt::Display for TockloaderError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            TockloaderError::TokioSeriallError(inner) => {
+                inner.fmt(f)
+            }
+            TockloaderError::NoPortAvailable => {
+                f.write_str("Tockloader has failed to find any open ports. If your device is plugged in, you can manually specify it using the '--port <path>' argument.")
+            },
+            TockloaderError::CLIError(inner) => {
+                inner.fmt(f)
+            }
+            TockloaderError::IOError(inner) => {
+                inner.fmt(f)
+            },
+            TockloaderError::JoinError(inner) => {
+                inner.fmt(f)
+            },
+        }
+    }
+}
+
+impl fmt::Display for CLIError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            CLIError::MultipleInterfaces => {
+                f.write_str("At most one of the following tranport interfaces may be used: '--serial', '--openocd', '-jlink'")
+            },
+        }
+    }
+}
+
+impl From<std::io::Error> for TockloaderError {
+    fn from(value: std::io::Error) -> Self {
+        Self::IOError(value)
+    }
+}
+
+impl From<tokio_serial::Error> for TockloaderError {
+    fn from(value: tokio_serial::Error) -> Self {
+        Self::TokioSeriallError(value)
+    }
+}
+
+impl From<tokio::task::JoinError> for TockloaderError {
+    fn from(value: tokio::task::JoinError) -> Self {
+        Self::JoinError(value)
+    }
+}
+
+impl std::error::Error for TockloaderError {}
+impl std::error::Error for CLIError {}

process-console/src/legacy/mod.rs

@@ -1,4 +1,17 @@
-pub fn run() {
-    // TODO
-    panic!();
+use clap::ArgMatches;
+
+use crate::legacy::errors::TockloaderError;
+use crate::legacy::serial::interface::build_interface;
+use crate::legacy::serial::traits::BoardInterface;
+use crate::legacy::serial::traits::VirtualTerminal;
+
+mod errors;
+mod serial;
+
+pub async fn run(sub_matches: &ArgMatches) -> Result<(), TockloaderError> {
+    let mut interface = build_interface(sub_matches)?;
+    interface.open()?;
+    interface.run_terminal().await?;
+
+    Ok(())
 }

process-console/src/legacy/serial/board_interface.rs

@@ -0,0 +1,16 @@
+use tokio_serial::SerialPortBuilderExt;
+
+use crate::legacy::errors::TockloaderError;
+use crate::legacy::serial::traits::BoardInterface;
+use crate::legacy::serial::serial::SerialInterface;
+
+impl BoardInterface for SerialInterface {
+    fn open(&mut self) -> Result<(), TockloaderError> {
+        // Is it async? It can't be awaited...
+        let stream = tokio_serial::new(self.port.clone(), self.baud_rate).open_native_async()?;
+
+        self.stream = Some(stream);
+
+        Ok(())
+    }
+}

process-console/src/legacy/serial/interface.rs

@@ -0,0 +1,17 @@
+use crate::legacy::serial::serial::SerialInterface;
+
+use crate::legacy::errors::{CLIError, TockloaderError};
+use clap::ArgMatches;
+use enum_dispatch::enum_dispatch;
+
+use crate::legacy::serial::traits;
+
+#[enum_dispatch(BoardInterface)]
+#[enum_dispatch(VirtualTerminal)]
+pub enum Interface {
+    Serial(SerialInterface),
+}
+
+pub fn build_interface(args: &ArgMatches) -> Result<Interface, TockloaderError> {
+    Ok(SerialInterface::new(args)?.into())
+}

process-console/src/legacy/serial/mod.rs

@@ -0,0 +1,5 @@
+pub mod interface;
+mod serial;
+pub mod terminal;
+pub mod traits;
+pub mod board_interface;

process-console/src/legacy/serial/serial.rs

@@ -0,0 +1,63 @@
+use crate::legacy::serial::interface;
+use crate::legacy::serial::terminal;
+
+use clap::ArgMatches;
+use tokio_serial::SerialStream;
+
+use crate::legacy::errors::TockloaderError;
+
+pub struct SerialInterface {
+    pub port: String,
+    pub baud_rate: u32,
+    pub stream: Option<SerialStream>,
+}
+
+impl SerialInterface {
+    pub fn new(args: &ArgMatches) -> Result<Self, TockloaderError> {
+        // If the user has specified a port, we want to try to use it.
+        // Otherwise, we let tokio-serial enumarate all ports and
+        // if multiple ports are present, we let the user decide which.
+        let port = if let Some(user_port) = args.get_one::<String>("port") {
+            user_port.clone()
+        } else {
+            let available_ports = tokio_serial::available_ports()?;
+
+            if available_ports.is_empty() {
+                return Err(TockloaderError::NoPortAvailable);
+            } else if available_ports.len() == 1 {
+                clean_port_path(available_ports[0].port_name.clone())
+            } else {
+                // available_ports.len() > 1
+                todo!("Make user choose out of multiple available ports")
+            }
+        };
+
+        // change this back!!
+        let baud_rate: u32 = 115200;
+        // let baud_rate = if let Some(baud_rate) = args.get_one::<u32>("baud-rate") {
+        //     *baud_rate
+        // } else {
+        //     unreachable!("'--baud-rate' should have a default value.")
+        // };
+
+        Ok(Self {
+            port,
+            baud_rate,
+            stream: None,
+        })
+    }
+}
+
+// When listing available ports, tokio_serial list unix ports like so:
+//     /sys/class/tty/ttyACM0
+//     /sys/class/tty/<port>
+// For some users, tokio_serial fails to open ports using this path scheme.
+// This function replaces it with the normal '/dev/<port>' scheme.
+// Windows COM ports should not be affected.
+fn clean_port_path(port: String) -> String {
+    if port.contains("/sys/class/tty/") {
+        port.replace("/sys/class/tty/", "/dev/")
+    } else {
+        port
+    }
+}