implement basic serial monitor

Author: icewind1991

cargo-espflash/Cargo.toml

@@ -32,4 +32,5 @@ guess_host_triple = "0.1"
 serde = { version = "1.0", features = ["derive"] }
 serial = "0.4"
 toml = "0.5"
+termion = "1"
 thiserror = "1"

cargo-espflash/src/line_endings.rs

@@ -0,0 +1,57 @@
+// Adapted from https://github.com/derekdreery/normalize-line-endings
+
+struct Normalized<I> {
+    iter: I,
+    prev_was_cr: bool,
+    peeked: Option<u8>,
+}
+
+pub fn normalized(iter: impl Iterator<Item = u8>) -> impl Iterator<Item = u8> {
+    Normalized {
+        iter,
+        prev_was_cr: false,
+        peeked: None,
+    }
+}
+
+impl<I> Iterator for Normalized<I>
+where
+    I: Iterator<Item = u8>,
+{
+    type Item = u8;
+    fn next(&mut self) -> Option<u8> {
+        if let Some(peeked) = self.peeked.take() {
+            return Some(peeked);
+        }
+        match self.iter.next() {
+            Some(b'\n') if !self.prev_was_cr => {
+                self.peeked = Some(b'\n');
+                self.prev_was_cr = false;
+                Some(b'\r')
+            }
+            Some(b'\r') => {
+                self.prev_was_cr = true;
+                Some(b'\r')
+            }
+            any => {
+                self.prev_was_cr = false;
+                any
+            }
+        }
+    }
+}
+
+// tests
+#[cfg(test)]
+mod tests {
+    use std::iter::FromIterator;
+
+    #[test]
+    fn normalized() {
+        let input = b"This is a string \n with \n some \n\r\n random newlines\r\n\n";
+        assert_eq!(
+            &Vec::from_iter(super::normalized(input.iter().copied())),
+            b"This is a string \r\n with \r\n some \r\n\r\n random newlines\r\n\r\n"
+        );
+    }
+}

cargo-espflash/src/main.rs

@@ -3,7 +3,7 @@ use clap::{App, Arg, SubCommand};
 use error::Error;
 use espflash::{Config, Flasher, PartitionTable};
 use miette::{IntoDiagnostic, Result, WrapErr};
-use serial::{BaudRate, SerialPort};
+use serial::{BaudRate, SerialPort, SystemPort};
 
 use std::{
     fs,
@@ -14,8 +14,14 @@ use std::{
 
 mod cargo_config;
 mod error;
+mod line_endings;
 
+use crate::line_endings::normalized;
 use cargo_config::has_build_std;
+use std::io::{stdout, ErrorKind, Read, Write};
+use std::thread::sleep;
+use std::time::Duration;
+use termion::{async_stdin, raw::IntoRawMode};
 
 fn main() -> Result<()> {
     let mut app = App::new(env!("CARGO_PKG_NAME"))
@@ -80,6 +86,11 @@ fn main() -> Result<()> {
                         .takes_value(true)
                         .value_name("SERIAL")
                         .help("Serial port connected to target device"),
+                )
+                .arg(
+                    Arg::with_name("monitor")
+                        .long("monitor")
+                        .help("Open a serial monitor after flashing"),
                 ),
         );
 
@@ -178,6 +189,10 @@ fn main() -> Result<()> {
         flasher.load_elf_to_flash(&elf_data, bootloader, partition_table)?;
     }
 
+    if matches.is_present("monitor") {
+        monitor(flasher.into_serial())?;
+    }
+
     // We're all done!
     Ok(())
 }
@@ -280,3 +295,50 @@ fn exit_with_process_status(status: ExitStatus) -> ! {
 
     exit(code)
 }
+
+const KEYCODE_CTRL_C: u8 = 3;
+const KEYCODE_CTRL_R: u8 = 18;
+
+fn monitor(mut serial: SystemPort) -> anyhow::Result<()> {
+    println!("Commands:");
+    println!("    CTRL+R    Reset chip");
+    println!("    CTRL+C    Exit");
+    println!();
+
+    let mut buff = [0; 128];
+    serial.set_timeout(Duration::from_millis(5))?;
+
+    let mut stdin = async_stdin().bytes();
+    let stdout = stdout().into_raw_mode()?;
+    let mut stdout = stdout.lock();
+    loop {
+        let read = match serial.read(&mut buff) {
+            Ok(count) => Ok(count),
+            Err(e) if e.kind() == ErrorKind::TimedOut => Ok(0),
+            err => err,
+        }?;
+        if read > 0 {
+            let data: Vec<u8> = normalized(buff[0..read].iter().copied()).collect();
+            stdout.write_all(&data).ok();
+            stdout.flush()?;
+        }
+        if let Some(Ok(byte)) = stdin.next() {
+            match byte {
+                KEYCODE_CTRL_C => break,
+                KEYCODE_CTRL_R => {
+                    serial.set_dtr(false)?;
+                    serial.set_rts(true)?;
+
+                    sleep(Duration::from_millis(100));
+
+                    serial.set_rts(false)?;
+                }
+                _ => {
+                    serial.write_all(&[byte])?;
+                    serial.flush()?;
+                }
+            }
+        }
+    }
+    Ok(())
+}