serial: implement embedded-io traits for UART

Author: techmccat

Cargo.toml

@@ -12,7 +12,7 @@ repository = "https://github.com/stm32-rs/stm32g4xx-hal"
 version = "0.0.2"
 
 [dependencies]
-nb = "0.1.1"
+nb = "1"
 stm32g4 = "0.15.1"
 paste = "1.0"
 bitflags = "1.2"
@@ -21,6 +21,7 @@ static_assertions = "1.1"
 fugit = "0.3.7"
 stm32-usbd = { version = "0.7.0", optional = true }
 fixed = { version = "1.28.0", optional = true }
+embedded-io = "0.6"
 
 [dependencies.cortex-m]
 version = "0.7.7"
@@ -99,7 +100,7 @@ stm32g4a1 = ["stm32g4/stm32g4a1"]
 log-itm = ["cortex-m-log/itm"]
 log-rtt = []
 log-semihost = ["cortex-m-log/semihosting"]
-defmt = ["dep:defmt", "fugit/defmt"]
+defmt = ["dep:defmt", "fugit/defmt", "nb/defmt-0-3", "embedded-hal-one/defmt-03", "embedded-io/defmt-03"]
 cordic = ["dep:fixed"]
 
 [profile.dev]

examples/uart.rs

@@ -3,8 +3,7 @@
 #![no_main]
 #![no_std]
 
-use core::fmt::Write;
-
+use embedded_io::{Read, Write};
 use hal::prelude::*;
 use hal::pwr::PwrExt;
 use hal::serial::FullConfig;
@@ -54,10 +53,13 @@ fn main() -> ! {
         .unwrap();
 
     writeln!(usart, "Hello USART3, yay!!\r\n").unwrap();
+    let mut read_buf = [0u8; 8];
+    usart.read_exact(&mut read_buf).unwrap();
+    usart.write_all(&read_buf).unwrap();
 
     let mut cnt = 0;
     loop {
-        match block!(usart.read()) {
+        match block!(embedded_hal::serial::Read::read(&mut usart)) {
             Ok(byte) => writeln!(usart, "{}: {}\r", cnt, byte).unwrap(),
             Err(e) => writeln!(usart, "E: {:?}\r", e).unwrap(),
         };

src/serial/usart.rs

@@ -12,6 +12,7 @@ use crate::stm32::*;
 
 use cortex_m::interrupt;
 use nb::block;
+use embedded_io::{ReadReady, WriteReady};
 
 use crate::serial::config::*;
 /// Serial error
@@ -27,6 +28,17 @@ pub enum Error {
     Parity,
 }
 
+impl embedded_io::Error for Error {
+    fn kind(&self) -> embedded_io::ErrorKind {
+        match self {
+            Error::Framing => embedded_io::ErrorKind::InvalidData,
+            Error::Noise => embedded_io::ErrorKind::InvalidData,
+            Error::Overrun => embedded_io::ErrorKind::Other,
+            Error::Parity => embedded_io::ErrorKind::InvalidData,
+        }
+    }
+}
+
 /// Interrupt event
 pub enum Event {
     /// TXFIFO reaches the threshold
@@ -202,6 +214,29 @@ macro_rules! uart_shared {
                     _dma: PhantomData,
                 }
             }
+            fn data_ready(&mut self) -> nb::Result<(), Error> {
+                let usart = unsafe { &(*$USARTX::ptr()) };
+                let isr = usart.isr.read();
+                Err(
+                    if isr.pe().bit_is_set() {
+                        usart.icr.write(|w| w.pecf().set_bit());
+                        nb::Error::Other(Error::Parity)
+                    } else if isr.fe().bit_is_set() {
+                        usart.icr.write(|w| w.fecf().set_bit());
+                        nb::Error::Other(Error::Framing)
+                    } else if isr.nf().bit_is_set() {
+                        usart.icr.write(|w| w.ncf().set_bit());
+                        nb::Error::Other(Error::Noise)
+                    } else if isr.ore().bit_is_set() {
+                        usart.icr.write(|w| w.orecf().set_bit());
+                        nb::Error::Other(Error::Overrun)
+                    } else if isr.rxne().bit_is_set() {
+                        return Ok(())
+                    } else {
+                        nb::Error::WouldBlock
+                    }
+                )
+            }
         }
 
         impl<Pin> Rx<$USARTX, Pin, DMA> {
@@ -225,26 +260,7 @@ macro_rules! uart_shared {
 
             fn read(&mut self) -> nb::Result<u8, Error> {
                 let usart = unsafe { &(*$USARTX::ptr()) };
-                let isr = usart.isr.read();
-                Err(
-                    if isr.pe().bit_is_set() {
-                        usart.icr.write(|w| w.pecf().set_bit());
-                        nb::Error::Other(Error::Parity)
-                    } else if isr.fe().bit_is_set() {
-                        usart.icr.write(|w| w.fecf().set_bit());
-                        nb::Error::Other(Error::Framing)
-                    } else if isr.nf().bit_is_set() {
-                        usart.icr.write(|w| w.ncf().set_bit());
-                        nb::Error::Other(Error::Noise)
-                    } else if isr.ore().bit_is_set() {
-                        usart.icr.write(|w| w.orecf().set_bit());
-                        nb::Error::Other(Error::Overrun)
-                    } else if isr.rxne().bit_is_set() {
-                        return Ok(usart.rdr.read().bits() as u8)
-                    } else {
-                        nb::Error::WouldBlock
-                    }
-                )
+                self.data_ready().map(|_| usart.rdr.read().bits() as u8)
             }
         }
 
@@ -349,6 +365,91 @@ macro_rules! uart_shared {
             }
         }
 
+        impl<Pin> embedded_io::ErrorType for Tx<$USARTX, Pin, NoDMA> {
+            type Error = Error;
+        }
+        impl<Pin> WriteReady for Tx<$USARTX, Pin, NoDMA> {
+            fn write_ready(&mut self) -> Result<bool, Self::Error> {
+                let usart = unsafe { &(*$USARTX::ptr()) };
+                Ok(usart.isr.read().txe().bit_is_set())
+            }
+        }
+        // writes until fifo (or tdr) is full
+        impl<Pin> embedded_io::Write for Tx<$USARTX, Pin, NoDMA> {
+            fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
+                if buf.len() == 0 { return Ok(0) }
+                let usart = unsafe { &(*$USARTX::ptr()) };
+                while !self.write_ready()? {
+                    core::hint::spin_loop()
+                }
+                // can't know fifo capacity in advance
+                let count = buf.into_iter()
+                    .take_while(|_| usart.isr.read().txe().bit_is_set())
+                    .map(|b| usart.tdr.write(|w| unsafe { w.tdr().bits(*b as u16) }))
+                    .count();
+
+                Ok(count)
+            }
+            fn flush(&mut self) -> Result<(), Error> {
+                nb::block!(hal::serial::Write::<u8>::flush(self))
+            }
+        }
+
+        impl<Pin> embedded_io::ErrorType for Rx<$USARTX, Pin, NoDMA> {
+            type Error = Error;
+        }
+        impl<Pin> ReadReady for Rx<$USARTX, Pin, NoDMA> {
+            fn read_ready(&mut self) -> Result<bool, Self::Error> {
+                match self.data_ready() {
+                    Ok(()) => Ok(true),
+                    Err(nb::Error::WouldBlock) => Ok(false),
+                    Err(nb::Error::Other(e)) => Err(e),
+                }
+            }
+        }
+        impl<Pin> embedded_io::Read for Rx<$USARTX, Pin, NoDMA> {
+            fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
+                if buf.len() == 0 { return Ok(0) }
+                let usart = unsafe { &(*$USARTX::ptr()) };
+                let mut count = 0;
+
+                while !self.read_ready()? {
+                    core::hint::spin_loop()
+                }
+                while self.read_ready()? && count < buf.len() {
+                    buf[count] = usart.rdr.read().bits() as u8;
+                    count += 1
+                }
+                Ok(count)
+            }
+        }
+
+        impl<TX, RX> embedded_io::ErrorType for Serial<$USARTX, TX, RX> {
+            type Error = Error;
+        }
+        impl<TX, RX> WriteReady for Serial<$USARTX, TX, RX> {
+            fn write_ready(&mut self) -> Result<bool, Self::Error> {
+                self.tx.write_ready()
+            }
+        }
+        impl<TX, RX> embedded_io::Write for Serial<$USARTX, TX, RX> {
+            fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
+                embedded_io::Write::write(&mut self.tx, buf)
+            }
+            fn flush(&mut self) -> Result<(), Error> {
+                embedded_io::Write::flush(&mut self.tx)
+            }
+        }
+        impl<TX, RX> ReadReady for Serial<$USARTX, TX, RX> {
+            fn read_ready(&mut self) -> Result<bool, Self::Error> {
+                self.rx.read_ready()
+            }
+        }
+        impl<TX, RX> embedded_io::Read for Serial<$USARTX, TX, RX> {
+            fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
+                embedded_io::Read::read(&mut self.rx, buf)
+            }
+        }
 
         impl<TX, RX> Serial<$USARTX, TX, RX> {