io

Author: burrbull

Diff for: CHANGELOG.md

@@ -7,11 +7,16 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
+### Added
+
+ - initial `embedded-io` support [#725]
+
 ### Changed
 
  - Use `stm32f4-staging` until `stm32f4` is released [#706]
 
 [#706]: https://github.com/stm32-rs/stm32f4xx-hal/pull/706
+[#725]: https://github.com/stm32-rs/stm32f4xx-hal/pull/725
 
 ## [v0.21.0] - 2024-05-30
 

Diff for: Cargo.toml

@@ -81,6 +81,9 @@ version = "1.0"
 [dependencies.embedded-hal-nb]
 version = "1.0"
 
+[dependencies.embedded-io]
+version = "0.6.1"
+
 [dependencies.stm32_i2s_v12x]
 version = "0.5.0"
 optional = true

Diff for: src/serial/hal_1.rs

@@ -95,3 +95,71 @@ mod nb {
         }
     }
 }
+
+mod io {
+    use core::ops::Deref;
+
+    use super::super::{Error, Instance, RegisterBlockImpl, Rx, Serial, Tx};
+    use embedded_io::Write;
+
+    impl embedded_io::Error for Error {
+        // TODO: fix error conversion
+        fn kind(&self) -> embedded_io::ErrorKind {
+            embedded_io::ErrorKind::Other
+        }
+    }
+
+    impl<USART: Instance, WORD> embedded_io::ErrorType for Serial<USART, WORD> {
+        type Error = Error;
+    }
+
+    impl<USART: Instance, WORD> embedded_io::ErrorType for Tx<USART, WORD> {
+        type Error = Error;
+    }
+
+    impl<USART: Instance, WORD> embedded_io::ErrorType for Rx<USART, WORD> {
+        type Error = Error;
+    }
+
+    impl<USART: Instance> Write for Tx<USART, u8>
+    where
+        <USART as Instance>::RegisterBlock: RegisterBlockImpl,
+        USART: Deref<Target = <USART as Instance>::RegisterBlock>,
+    {
+        fn write(&mut self, bytes: &[u8]) -> Result<usize, Self::Error> {
+            let mut i = 0;
+            for byte in bytes.iter() {
+                match self.usart.write_u8(*byte) {
+                    Ok(_) => {
+                        i += 1;
+                    }
+                    Err(nb::Error::WouldBlock) => {
+                        return Ok(i);
+                    }
+                    Err(nb::Error::Other(e)) => {
+                        return Err(e);
+                    }
+                }
+            }
+            Ok(i)
+        }
+
+        fn flush(&mut self) -> Result<(), Self::Error> {
+            self.usart.bflush()?;
+            Ok(())
+        }
+    }
+
+    impl<USART: Instance> Write for Serial<USART, u8>
+    where
+        Tx<USART, u8>: Write<Error = Error>,
+    {
+        fn write(&mut self, bytes: &[u8]) -> Result<usize, Self::Error> {
+            self.tx.write(bytes)
+        }
+
+        fn flush(&mut self) -> Result<(), Self::Error> {
+            self.tx.flush()
+        }
+    }
+}