stm32: impl uart write_all without panic

Default write_all implementation uses panic: https://github.com/rust-embedded/embedded-hal/blob/master/embedded-io-async/src/lib.rs#L138 and https://github.com/rust-embedded/embedded-hal/blob/master/embedded-io/src/lib.rs#L397 This version produced 456 bytes smaller binary in my application where embedded-io-async::write_all was used.
embassy-rs · Mar 6, 2024 · 15b4ba5 · 15b4ba5
1 parent 3638df7
commit 15b4ba5
Show file tree

Hide file tree

Showing 2 changed files with 73 additions and 2 deletions.
diff --git a/embassy-stm32/src/usart/buffered.rs b/embassy-stm32/src/usart/buffered.rs
@@ -562,6 +562,18 @@ impl<'d, T: BasicInstance> embedded_io_async::Write for BufferedUart<'d, T> {
         self.tx.write(buf).await
     }
 
+    async fn write_all(&mut self, buf: &[u8]) -> Result<(), Self::Error> {
+        let mut buf = buf;
+        while !buf.is_empty() {
+            match self.tx.write(buf).await {
+                Ok(0) => return Err(Error::WriteZero),
+                Ok(n) => buf = &buf[n..],
+                Err(e) => return Err(e),
+            }
+        }
+        Ok(())
+    }
+
     async fn flush(&mut self) -> Result<(), Self::Error> {
         self.tx.flush().await
     }
@@ -572,6 +584,18 @@ impl<'d, T: BasicInstance> embedded_io_async::Write for BufferedUartTx<'d, T> {
         Self::write(self, buf).await
     }
 
+    async fn write_all(&mut self, buf: &[u8]) -> Result<(), Self::Error> {
+        let mut buf = buf;
+        while !buf.is_empty() {
+            match Self::write(self, buf).await {
+                Ok(0) => return Err(Error::WriteZero),
+                Ok(n) => buf = &buf[n..],
+                Err(e) => return Err(e),
+            }
+        }
+        Ok(())
+    }
+
     async fn flush(&mut self) -> Result<(), Self::Error> {
         Self::flush(self).await
     }
@@ -594,6 +618,18 @@ impl<'d, T: BasicInstance> embedded_io::Write for BufferedUart<'d, T> {
         self.tx.blocking_write(buf)
     }
 
+    fn write_all(&mut self, buf: &[u8]) -> Result<(), Self::Error> {
+        let mut buf = buf;
+        while !buf.is_empty() {
+            match self.tx.blocking_write(buf) {
+                Ok(0) => return Err(Error::WriteZero),
+                Ok(n) => buf = &buf[n..],
+                Err(e) => return Err(e),
+            }
+        }
+        Ok(())
+    }
+
     fn flush(&mut self) -> Result<(), Self::Error> {
         self.tx.blocking_flush()
     }
@@ -604,6 +640,18 @@ impl<'d, T: BasicInstance> embedded_io::Write for BufferedUartTx<'d, T> {
         Self::blocking_write(self, buf)
     }
 
+    fn write_all(&mut self, buf: &[u8]) -> Result<(), Self::Error> {
+        let mut buf = buf;
+        while !buf.is_empty() {
+            match Self::blocking_write(self, buf) {
+                Ok(0) => return Err(Error::WriteZero),
+                Ok(n) => buf = &buf[n..],
+                Err(e) => return Err(e),
+            }
+        }
+        Ok(())
+    }
+
     fn flush(&mut self) -> Result<(), Self::Error> {
         Self::blocking_flush(self)
     }
@@ -643,7 +691,7 @@ impl<'d, T: BasicInstance> embedded_hal_02::blocking::serial::Write<u8> for Buff
     fn bwrite_all(&mut self, mut buffer: &[u8]) -> Result<(), Self::Error> {
         while !buffer.is_empty() {
             match self.blocking_write(buffer) {
-                Ok(0) => panic!("zero-length write."),
+                Ok(0) => return Err(Error::WriteZero),
                 Ok(n) => buffer = &buffer[n..],
                 Err(e) => return Err(e),
             }
@@ -670,7 +718,7 @@ impl<'d, T: BasicInstance> embedded_hal_02::blocking::serial::Write<u8> for Buff
     fn bwrite_all(&mut self, mut buffer: &[u8]) -> Result<(), Self::Error> {
         while !buffer.is_empty() {
             match self.tx.blocking_write(buffer) {
-                Ok(0) => panic!("zero-length write."),
+                Ok(0) => return Err(Error::WriteZero),
                 Ok(n) => buffer = &buffer[n..],
                 Err(e) => return Err(e),
             }

diff --git a/embassy-stm32/src/usart/mod.rs b/embassy-stm32/src/usart/mod.rs
@@ -199,6 +199,8 @@ pub enum Error {
     Parity,
     /// Buffer too large for DMA
     BufferTooLong,
+    /// An attempted write could not write any data.
+    WriteZero,
 }
 
 enum ReadCompletionEvent {
@@ -1188,6 +1190,7 @@ impl embedded_hal_nb::serial::Error for Error {
             Self::Overrun => embedded_hal_nb::serial::ErrorKind::Overrun,
             Self::Parity => embedded_hal_nb::serial::ErrorKind::Parity,
             Self::BufferTooLong => embedded_hal_nb::serial::ErrorKind::Other,
+            Self::WriteZero => embedded_hal_nb::serial::ErrorKind::Other,
         }
     }
 }
@@ -1266,6 +1269,11 @@ where
         Ok(buf.len())
     }
 
+    fn write_all(&mut self, buf: &[u8]) -> Result<(), Self::Error> {
+        self.blocking_write(buf)?;
+        Ok(())
+    }
+
     fn flush(&mut self) -> Result<(), Self::Error> {
         self.blocking_flush()
     }
@@ -1281,6 +1289,11 @@ where
         Ok(buf.len())
     }
 
+    fn write_all(&mut self, buf: &[u8]) -> Result<(), Self::Error> {
+        self.blocking_write(buf)?;
+        Ok(())
+    }
+
     fn flush(&mut self) -> Result<(), Self::Error> {
         self.blocking_flush()
     }
@@ -1296,6 +1309,11 @@ where
         Ok(buf.len())
     }
 
+    async fn write_all(&mut self, buf: &[u8]) -> Result<(), Self::Error> {
+        self.write(buf).await?;
+        Ok(())
+    }
+
     async fn flush(&mut self) -> Result<(), Self::Error> {
         self.blocking_flush()
     }
@@ -1311,6 +1329,11 @@ where
         Ok(buf.len())
     }
 
+    async fn write_all(&mut self, buf: &[u8]) -> Result<(), Self::Error> {
+        self.write(buf).await?;
+        Ok(())
+    }
+
     async fn flush(&mut self) -> Result<(), Self::Error> {
         self.blocking_flush()
     }