Introduce Interface struct

Author: bugadani

cargo-espflash/src/main.rs

@@ -241,7 +241,7 @@ fn flash(
     if opts.flash_opts.monitor {
         let pid = flasher.get_usb_pid()?;
         monitor(
-            flasher.into_serial(),
+            flasher.into_interface(),
             Some(&elf_data),
             pid,
             opts.connect_opts.monitor_speed.unwrap_or(115200),

espflash/src/cli/mod.rs

@@ -23,6 +23,7 @@ use crate::{
     elf::{ElfFirmwareImage, FlashFrequency, FlashMode},
     error::{Error, NoOtadataError},
     flasher::FlashSize,
+    interface::Interface,
     partition_table, Chip, Flasher, ImageFormatId, InvalidPartitionTable, MissingPartitionTable,
     PartitionTable,
 };
@@ -147,8 +148,12 @@ pub fn connect(opts: &ConnectOpts, config: &Config) -> Result<Flasher> {
         _ => unreachable!(),
     };
 
+    let interface = Interface {
+        serial_port: serial,
+    };
+
     Ok(Flasher::connect(
-        serial,
+        interface,
         port_info,
         opts.speed,
         opts.use_stub,
@@ -167,7 +172,7 @@ pub fn serial_monitor(opts: ConnectOpts, config: Config) -> Result<()> {
     let pid = flasher.get_usb_pid()?;
 
     monitor(
-        flasher.into_serial(),
+        flasher.into_interface(),
         None,
         pid,
         opts.monitor_speed.unwrap_or(115200),

espflash/src/cli/monitor.rs

@@ -1,5 +1,5 @@
 use std::{
-    io::{stdout, ErrorKind, Read, Write},
+    io::{stdout, ErrorKind},
     time::Duration,
 };
 
@@ -9,9 +9,8 @@ use crossterm::{
 };
 use espmonitor::{handle_serial, load_bin_context, SerialState};
 use miette::{IntoDiagnostic, Result};
-use serialport::SerialPort;
 
-use crate::connection::reset_after_flash;
+use crate::{connection::reset_after_flash, interface::Interface};
 
 /// Converts key events from crossterm into appropriate character/escape
 /// sequences which are then sent over the serial connection.
@@ -84,7 +83,7 @@ impl Drop for RawModeGuard {
 }
 
 pub fn monitor(
-    mut serial: Box<dyn SerialPort>,
+    mut serial: Interface,
     elf: Option<&[u8]>,
     pid: u16,
     baud: u32,
@@ -96,8 +95,10 @@ pub fn monitor(
 
     // Explicitly set the baud rate when starting the serial monitor, to allow using
     // different rates for flashing.
-    serial.set_baud_rate(baud)?;
-    serial.set_timeout(Duration::from_millis(5))?;
+    serial.serial_port_mut().set_baud_rate(baud)?;
+    serial
+        .serial_port_mut()
+        .set_timeout(Duration::from_millis(5))?;
 
     let _raw_mode = RawModeGuard::new();
 
@@ -109,12 +110,12 @@ pub fn monitor(
         serial_state = SerialState::new(symbols);
     } else {
         serial_state = SerialState::new(None);
-        reset_after_flash(&mut *serial, pid)?;
+        reset_after_flash(&mut serial, pid)?;
     }
 
     let mut buff = [0; 1024];
     loop {
-        let read_count = match serial.read(&mut buff) {
+        let read_count = match serial.serial_port_mut().read(&mut buff) {
             Ok(count) => Ok(count),
             Err(e) if e.kind() == ErrorKind::TimedOut => Ok(0),
             Err(e) if e.kind() == ErrorKind::Interrupted => continue,
@@ -131,16 +132,16 @@ pub fn monitor(
                     match key.code {
                         KeyCode::Char('c') => break,
                         KeyCode::Char('r') => {
-                            reset_after_flash(&mut *serial, pid)?;
+                            reset_after_flash(&mut serial, pid)?;
                             continue;
                         }
                         _ => {}
                     }
                 }
 
                 if let Some(bytes) = handle_key_event(key) {
-                    serial.write_all(&bytes)?;
-                    serial.flush()?;
+                    serial.serial_port_mut().write_all(&bytes)?;
+                    serial.serial_port_mut().flush()?;
                 }
             }
         }

espflash/src/connection.rs

@@ -1,18 +1,19 @@
 use std::{
-    io::{BufWriter, Write},
+    io::{BufWriter, Read},
     thread::sleep,
     time::Duration,
 };
 
 use binread::{io::Cursor, BinRead, BinReaderExt};
 use bytemuck::{Pod, Zeroable};
-use serialport::{SerialPort, UsbPortInfo};
+use serialport::UsbPortInfo;
 use slip_codec::SlipDecoder;
 
 use crate::{
     command::{Command, CommandType},
     encoder::SlipEncoder,
     error::{ConnectionError, Error, ResultExt, RomError, RomErrorKind},
+    interface::Interface,
 };
 
 const DEFAULT_CONNECT_ATTEMPTS: usize = 7;
@@ -29,7 +30,7 @@ pub struct CommandResponse {
 }
 
 pub struct Connection {
-    serial: Box<dyn SerialPort>,
+    serial: Interface,
     port_info: UsbPortInfo,
     decoder: SlipDecoder,
 }
@@ -44,7 +45,7 @@ struct WriteRegParams {
 }
 
 impl Connection {
-    pub fn new(serial: Box<dyn SerialPort>, port_info: UsbPortInfo) -> Self {
+    pub fn new(serial: Interface, port_info: UsbPortInfo) -> Self {
         Connection {
             serial,
             port_info,
@@ -119,7 +120,7 @@ impl Connection {
 
     pub fn reset(&mut self) -> Result<(), Error> {
         let pid = self.port_info.pid;
-        Ok(reset_after_flash(&mut *self.serial, pid)?)
+        Ok(reset_after_flash(&mut self.serial, pid)?)
     }
 
     pub fn reset_to_flash(&mut self, extra_delay: bool) -> Result<(), Error> {
@@ -161,29 +162,36 @@ impl Connection {
     }
 
     pub fn set_timeout(&mut self, timeout: Duration) -> Result<(), Error> {
-        self.serial.set_timeout(timeout)?;
+        self.serial.serial_port_mut().set_timeout(timeout)?;
         Ok(())
     }
 
     pub fn set_baud(&mut self, speed: u32) -> Result<(), Error> {
-        self.serial.set_baud_rate(speed)?;
+        self.serial.serial_port_mut().set_baud_rate(speed)?;
 
         Ok(())
     }
 
     pub fn get_baud(&self) -> Result<u32, Error> {
-        Ok(self.serial.baud_rate()?)
+        Ok(self.serial.serial_port().baud_rate()?)
     }
 
     pub fn with_timeout<T, F: FnMut(&mut Connection) -> Result<T, Error>>(
         &mut self,
         timeout: Duration,
         mut f: F,
     ) -> Result<T, Error> {
-        let old_timeout = self.serial.timeout();
-        self.serial.set_timeout(timeout)?;
+        let old_timeout = {
+            let serial = self.serial.serial_port_mut();
+            let old_timeout = serial.timeout();
+            serial.set_timeout(timeout)?;
+            old_timeout
+        };
+
         let result = f(self);
-        self.serial.set_timeout(old_timeout)?;
+
+        self.serial.serial_port_mut().set_timeout(old_timeout)?;
+
         result
     }
 
@@ -199,8 +207,10 @@ impl Connection {
     }
 
     pub fn write_command(&mut self, command: Command) -> Result<(), Error> {
-        self.serial.clear(serialport::ClearBuffer::Input)?;
-        let mut writer = BufWriter::new(&mut self.serial);
+        let serial = self.serial.serial_port_mut();
+
+        serial.clear(serialport::ClearBuffer::Input)?;
+        let mut writer = BufWriter::new(serial);
         let mut encoder = SlipEncoder::new(&mut writer)?;
         command.write(&mut encoder)?;
         encoder.finish()?;
@@ -253,19 +263,20 @@ impl Connection {
     pub(crate) fn read(&mut self, len: usize) -> Result<Option<Vec<u8>>, Error> {
         let mut tmp = Vec::with_capacity(1024);
         loop {
-            self.decoder.decode(&mut self.serial, &mut tmp)?;
+            self.decoder
+                .decode(self.serial.serial_port_mut() as &mut dyn Read, &mut tmp)?;
             if tmp.len() >= len {
                 return Ok(Some(tmp));
             }
         }
     }
 
     pub fn flush(&mut self) -> Result<(), Error> {
-        self.serial.flush()?;
+        self.serial.serial_port_mut().flush()?;
         Ok(())
     }
 
-    pub fn into_serial(self) -> Box<dyn SerialPort> {
+    pub fn into_interface(self) -> Interface {
         self.serial
     }
 
@@ -274,7 +285,7 @@ impl Connection {
     }
 }
 
-pub fn reset_after_flash(serial: &mut dyn SerialPort, pid: u16) -> Result<(), serialport::Error> {
+pub fn reset_after_flash(serial: &mut Interface, pid: u16) -> Result<(), serialport::Error> {
     sleep(Duration::from_millis(100));
 
     if pid == USB_SERIAL_JTAG_PID {

espflash/src/flasher.rs

@@ -2,7 +2,7 @@ use std::{borrow::Cow, str::FromStr, thread::sleep};
 
 use bytemuck::{Pod, Zeroable, __core::time::Duration};
 use log::debug;
-use serialport::{SerialPort, UsbPortInfo};
+use serialport::UsbPortInfo;
 use strum_macros::{Display, EnumVariantNames};
 
 use crate::{
@@ -12,6 +12,7 @@ use crate::{
     elf::{ElfFirmwareImage, FirmwareImage, FlashFrequency, FlashMode, RomSegment},
     error::{ConnectionError, FlashDetectError, ResultExt},
     image_format::ImageFormatId,
+    interface::Interface,
     stubs::FlashStub,
     Error, PartitionTable,
 };
@@ -202,7 +203,7 @@ pub struct Flasher {
 
 impl Flasher {
     pub fn connect(
-        serial: Box<dyn SerialPort>,
+        serial: Interface,
         port_info: UsbPortInfo,
         speed: Option<u32>,
         use_stub: bool,
@@ -634,10 +635,6 @@ impl Flasher {
         Ok(())
     }
 
-    pub fn into_serial(self) -> Box<dyn SerialPort> {
-        self.connection.into_serial()
-    }
-
     pub fn get_usb_pid(&self) -> Result<u16, Error> {
         self.connection.get_usb_pid()
     }
@@ -653,6 +650,10 @@ impl Flasher {
         self.connection.flush()?;
         Ok(())
     }
+
+    pub fn into_interface(self) -> Interface {
+        self.connection.into_interface()
+    }
 }
 
 pub(crate) fn get_erase_size(offset: usize, size: usize) -> usize {

espflash/src/interface.rs

@@ -0,0 +1,28 @@
+use serialport::SerialPort;
+
+/// Wrapper around SerialPort where platform-specific modifications can be implemented.
+pub struct Interface {
+    pub serial_port: Box<dyn SerialPort>,
+}
+
+impl Interface {
+    pub fn write_data_terminal_ready(&mut self, pin_state: bool) -> serialport::Result<()> {
+        self.serial_port.write_data_terminal_ready(pin_state)
+    }
+
+    pub fn write_request_to_send(&mut self, pin_state: bool) -> serialport::Result<()> {
+        self.serial_port.write_request_to_send(pin_state)
+    }
+
+    pub fn into_serial(self) -> Box<dyn SerialPort> {
+        self.serial_port
+    }
+
+    pub fn serial_port(&self) -> &dyn SerialPort {
+        self.serial_port.as_ref()
+    }
+
+    pub fn serial_port_mut(&mut self) -> &mut dyn SerialPort {
+        self.serial_port.as_mut()
+    }
+}

espflash/src/lib.rs

@@ -1,3 +1,6 @@
+#![feature(trait_upcasting)]
+#![allow(incomplete_features)] // trait_upcasting
+
 pub use chip::Chip;
 pub use cli::config::Config;
 pub use elf::{FlashFrequency, FlashMode};
@@ -15,6 +18,7 @@ pub mod error;
 pub mod flash_target;
 pub mod flasher;
 pub mod image_format;
+pub mod interface;
 pub mod partition_table;
 
 #[doc(hidden)]

espflash/src/main.rs

@@ -179,7 +179,7 @@ fn flash(opts: Opts, config: Config) -> Result<()> {
         let pid = flasher.get_usb_pid()?;
 
         monitor(
-            flasher.into_serial(),
+            flasher.into_interface(),
             Some(&elf_data),
             pid,
             opts.connect_opts.monitor_speed.unwrap_or(115200),