feat: Use monitor_args in monitor()

cargo-espflash/src/main.rs

@@ -352,23 +352,22 @@ fn flash(args: FlashArgs, config: &Config) -> Result<()> {
 
     if args.flash_args.monitor {
         let pid = flasher.get_usb_pid()?;
+        let mut monitor_args = args.flash_args.monitor_args;
 
         // The 26MHz ESP32-C2's need to be treated as a special case.
-        let default_baud = if chip == Chip::Esp32c2 && target_xtal_freq == XtalFrequency::_26Mhz {
+        if chip == Chip::Esp32c2
+            && target_xtal_freq == XtalFrequency::_26Mhz
+            && monitor_args.baud_rate == 115_200
+        {
             // 115_200 * 26 MHz / 40 MHz = 74_880
-            74_880
-        } else {
-            115_200
-        };
+            monitor_args.baud_rate = 74_880;
+        }
 
         monitor(
             flasher.into_serial(),
             Some(&elf_data),
             pid,
-            args.flash_args.monitor_args.baud.unwrap_or(default_baud),
-            args.flash_args.monitor_args.log_format,
-            !args.flash_args.monitor_args.non_interactive,
-            args.flash_args.monitor_args.processors,
+            monitor_args,
             Some(build_ctx.artifact_path),
         )
     } else {

espflash/src/bin/espflash.rs

@@ -287,23 +287,22 @@ fn flash(args: FlashArgs, config: &Config) -> Result<()> {
 
     if args.flash_args.monitor {
         let pid = flasher.get_usb_pid()?;
+        let mut monitor_args = args.flash_args.monitor_args;
 
         // The 26MHz ESP32-C2's need to be treated as a special case.
-        let default_baud = if chip == Chip::Esp32c2 && target_xtal_freq == XtalFrequency::_26Mhz {
+        if chip == Chip::Esp32c2
+            && target_xtal_freq == XtalFrequency::_26Mhz
+            && monitor_args.baud_rate == 115_200
+        {
             // 115_200 * 26 MHz / 40 MHz = 74_880
-            74_880
-        } else {
-            115_200
-        };
+            monitor_args.baud_rate = 74_880;
+        }
 
         monitor(
             flasher.into_serial(),
             Some(&elf_data),
             pid,
-            args.flash_args.monitor_args.baud.unwrap_or(default_baud),
-            args.flash_args.monitor_args.log_format,
-            !args.flash_args.monitor_args.non_interactive,
-            args.flash_args.monitor_args.processors,
+            monitor_args,
             Some(args.image),
         )
     } else {

espflash/src/cli/mod.rs

@@ -136,18 +136,9 @@ pub struct FlashArgs {
     /// Erase specified data partitions
     #[arg(long, value_name = "PARTS", value_enum, value_delimiter = ',')]
     pub erase_data_parts: Option<Vec<DataType>>,
-    // /// Logging format.
-    // #[arg(long, short = 'L', default_value = "serial", requires = "monitor")]
-    // pub log_format: LogFormat,
     /// Open a serial monitor after flashing
     #[arg(short = 'M', long)]
     pub monitor: bool,
-    // /// Baud rate at which to read console output
-    // #[arg(long, requires = "monitor", value_name = "BAUD")]
-    // pub monitor_baud: Option<u32>,
-    // /// Avoids asking the user for interactions like resetting the device
-    // #[arg(long, requires = "monitor")]
-    // pub non_interactive: bool,
     /// Monitor configuration
     #[clap(flatten)]
     pub monitor_args: MonitorConfigArgs,
@@ -273,18 +264,15 @@ pub struct MonitorArgs {
 #[derive(Debug, Args)]
 #[non_exhaustive]
 pub struct MonitorConfigArgs {
-    // /// Connection configuration
-    // #[clap(flatten)]
-    // connect_args: ConnectArgs,
-    // /// Optional file name of the ELF image to load the symbols from
-    // #[arg(short = 'e', long, value_name = "FILE")]
-    // elf: Option<PathBuf>,
     /// Baud rate at which to communicate with target device
-    #[arg(short = 'B', long, env = "MONITOR_BAUD")]
-    pub baud: Option<u32>,
+    #[arg(short = 'r', long, env = "MONITOR_BAUD", default_value = "115_200", value_parser = parse_uint32)]
+    pub baud_rate: u32,
     /// Avoids asking the user for interactions like resetting the device
     #[arg(long)]
     pub non_interactive: bool,
+    /// Avoids restarting the device before monitoring
+    #[arg(long, requires = "non_interactive")]
+    pub no_reset: bool,
     /// Logging format.
     #[arg(long, short = 'L', default_value = "serial", requires = "elf")]
     pub log_format: LogFormat,
@@ -459,24 +447,22 @@ pub fn serial_monitor(args: MonitorArgs, config: &Config) -> Result<()> {
     let chip = flasher.chip();
     let target = chip.into_target();
 
+    let mut monitor_args = args.monitor_args;
+
     // The 26MHz ESP32-C2's need to be treated as a special case.
-    let default_baud = if chip == Chip::Esp32c2
+    if chip == Chip::Esp32c2
         && target.crystal_freq(flasher.connection())? == XtalFrequency::_26Mhz
+        && monitor_args.baud_rate == 115_200
     {
         // 115_200 * 26 MHz / 40 MHz = 74_880
-        74_880
-    } else {
-        115_200
-    };
+        monitor_args.baud_rate = 74_880;
+    }
 
     monitor(
         flasher.into_serial(),
         elf.as_deref(),
         pid,
-        args.monitor_args.baud.unwrap_or(default_baud),
-        args.monitor_args.log_format,
-        !args.monitor_args.non_interactive,
-        args.monitor_args.processors,
+        monitor_args,
         args.elf,
     )
 }

espflash/src/cli/monitor/mod.rs

@@ -22,14 +22,17 @@ use crossterm::{
     terminal::{disable_raw_mode, enable_raw_mode},
 };
 use external_processors::ExternalProcessors;
-use log::error;
+use log::{debug, error};
 use miette::{IntoDiagnostic, Result};
 #[cfg(feature = "serialport")]
 use serialport::SerialPort;
 use strum::{Display, EnumIter, EnumString, VariantNames};
 
 use crate::{
-    cli::monitor::parser::{InputParser, ResolvingPrinter},
+    cli::{
+        monitor::parser::{InputParser, ResolvingPrinter},
+        MonitorConfigArgs,
+    },
     connection::{reset::reset_after_flash, Port},
 };
 
@@ -74,21 +77,20 @@ pub fn monitor(
     mut serial: Port,
     elf: Option<&[u8]>,
     pid: u16,
-    baud: u32,
-    log_format: LogFormat,
-    interactive_mode: bool,
-    processors: Option<String>,
+    monitor_args: MonitorConfigArgs,
     elf_file: Option<PathBuf>,
 ) -> miette::Result<()> {
-    if interactive_mode {
+    if !monitor_args.non_interactive {
         println!("Commands:");
         println!("    CTRL+R    Reset chip");
         println!("    CTRL+C    Exit");
         println!();
-    } else {
+    } else if !monitor_args.no_reset {
         reset_after_flash(&mut serial, pid).into_diagnostic()?;
     }
-    println!("Baud rate: {}", baud);
+
+    let baud = monitor_args.baud_rate;
+    debug!("Opening serial monitor with baudrate: {}", baud);
 
     // Explicitly set the baud rate when starting the serial monitor, to allow using
     // different rates for flashing.
@@ -103,12 +105,12 @@ pub fn monitor(
     let stdout = stdout();
     let mut stdout = ResolvingPrinter::new(elf, stdout.lock());
 
-    let mut parser: Box<dyn InputParser> = match log_format {
+    let mut parser: Box<dyn InputParser> = match monitor_args.log_format {
         LogFormat::Defmt => Box::new(parser::esp_defmt::EspDefmt::new(elf)?),
         LogFormat::Serial => Box::new(parser::serial::Serial),
     };
 
-    let mut external_processors = ExternalProcessors::new(processors, elf_file)?;
+    let mut external_processors = ExternalProcessors::new(monitor_args.processors, elf_file)?;
 
     let mut buff = [0; 1024];
     loop {
@@ -125,7 +127,7 @@ pub fn monitor(
         // Don't forget to flush the writer!
         stdout.flush().ok();
 
-        if interactive_mode && poll(Duration::from_secs(0)).into_diagnostic()? {
+        if !monitor_args.non_interactive && poll(Duration::from_secs(0)).into_diagnostic()? {
             if let Event::Key(key) = read().into_diagnostic()? {
                 if key.kind == KeyEventKind::Press {
                     if key.modifiers.contains(KeyModifiers::CONTROL) {