Big update to embedded-hal 1.0

mavlink-core/Cargo.toml

@@ -19,8 +19,10 @@ rust-version = "1.65.0"
 [dependencies]
 crc-any = { workspace = true, default-features = false }
 byteorder = { workspace = true, default-features = false }
-embedded-hal = { version = "0.2", optional = true }
 nb = { version = "1.0", optional = true }
+embedded-hal-02 = { version = "0.2", optional = true, package = "embedded-hal" }
+embedded-io = { version = "0.6.1", optional = true }
+embedded-io-async = { version = "0.6.1", optional = true }
 serde = { version = "1.0.115", optional = true, features = ["derive"] }
 serde_arrays = { version = "0.1.0", optional = true }
 serial = { version = "0.4", optional = true }
@@ -30,6 +32,10 @@ serial = { version = "0.4", optional = true }
 "udp" = []
 "tcp" = []
 "direct-serial" = ["serial"]
-"embedded" = ["embedded-hal", "nb"]
+# NOTE: Only one of 'embedded' and 'embedded-hal-02' features can be enabled.
+# Use "embedded' feature to enable embedded-hal=1.0 (embedded-io and embedded-io-async is part of embedded-hal).
+# Use 'embedded-hal-0.2' feature to enable deprecated embedded-hal=0.2.3 (some hals is not supports embedded-hal=1.0 yet).
+"embedded" = ["dep:embedded-io", "dep:embedded-io-async"]
+"embedded-hal-02" = ["dep:nb", "dep:embedded-hal-02"]
 "serde" = ["dep:serde", "dep:serde_arrays"]
 default = ["std", "tcp", "udp", "direct-serial", "serde"]

mavlink-core/src/embedded.rs

@@ -1,30 +1,45 @@
 use crate::error::*;
 
+#[cfg(all(feature = "embedded", feature = "embedded-hal-02"))]
+const _: () = panic!("Only one of 'embedded' and 'embedded-hal-02' features can be enabled.");
+
 /// Replacement for std::io::Read + byteorder::ReadBytesExt in no_std envs
 pub trait Read {
-    fn read_u8(&mut self) -> Result<u8, MessageReadError>;
+    fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), MessageReadError>;
+}
 
+#[cfg(all(feature = "embedded", not(feature = "embedded-hal-02")))]
+impl<R: embedded_io::Read> Read for R {
+    fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), MessageReadError> {
+        embedded_io::Read::read_exact(self, buf).map_err(|_| MessageReadError::Io)
+    }
+}
+
+#[cfg(all(feature = "embedded-hal-02", not(feature = "embedded")))]
+impl<R: embedded_hal_02::serial::Read<u8>> Read for R {
     fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), MessageReadError> {
         for byte in buf {
-            *byte = self.read_u8()?;
+            *byte = nb::block!(self.read()).map_err(|_| MessageReadError::Io)?;
         }
 
         Ok(())
     }
 }
 
-impl<R: embedded_hal::serial::Read<u8>> Read for R {
-    fn read_u8(&mut self) -> Result<u8, MessageReadError> {
-        nb::block!(self.read()).map_err(|_| MessageReadError::Io)
-    }
-}
-
 /// Replacement for std::io::Write + byteorder::WriteBytesExt in no_std envs
 pub trait Write {
     fn write_all(&mut self, buf: &[u8]) -> Result<(), MessageWriteError>;
 }
 
-impl<W: embedded_hal::serial::Write<u8>> Write for W {
+#[cfg(all(feature = "embedded", not(feature = "embedded-hal-02")))]
+impl<W: embedded_io::Write> Write for W {
+    fn write_all(&mut self, buf: &[u8]) -> Result<(), MessageWriteError> {
+        embedded_io::Write::write_all(self, buf).map_err(|_| MessageWriteError::Io)
+    }
+}
+
+#[cfg(all(feature = "embedded-hal-02", not(feature = "embedded")))]
+impl<W: embedded_hal_02::serial::Write<u8>> Write for W {
     fn write_all(&mut self, buf: &[u8]) -> Result<(), MessageWriteError> {
         for byte in buf {
             nb::block!(self.write(*byte)).map_err(|_| MessageWriteError::Io)?;

mavlink-core/src/error.rs

@@ -32,7 +32,7 @@ impl Error for ParserError {}
 pub enum MessageReadError {
     #[cfg(feature = "std")]
     Io(std::io::Error),
-    #[cfg(feature = "embedded")]
+    #[cfg(any(feature = "embedded", feature = "embedded-hal-02"))]
     Io,
     Parse(ParserError),
 }
@@ -42,7 +42,7 @@ impl Display for MessageReadError {
         match self {
             #[cfg(feature = "std")]
             Self::Io(e) => write!(f, "Failed to read message: {e:#?}"),
-            #[cfg(feature = "embedded")]
+            #[cfg(any(feature = "embedded", feature = "embedded-hal-02"))]
             Self::Io => write!(f, "Failed to read message"),
             Self::Parse(e) => write!(f, "Failed to read message: {e:#?}"),
         }
@@ -69,7 +69,7 @@ impl From<ParserError> for MessageReadError {
 pub enum MessageWriteError {
     #[cfg(feature = "std")]
     Io(std::io::Error),
-    #[cfg(feature = "embedded")]
+    #[cfg(any(feature = "embedded", feature = "embedded-hal-02"))]
     Io,
 }
 
@@ -78,7 +78,7 @@ impl Display for MessageWriteError {
         match self {
             #[cfg(feature = "std")]
             Self::Io(e) => write!(f, "Failed to write message: {e:#?}"),
-            #[cfg(feature = "embedded")]
+            #[cfg(any(feature = "embedded", feature = "embedded-hal-02"))]
             Self::Io => write!(f, "Failed to write message"),
         }
     }

mavlink-core/src/lib.rs

@@ -49,9 +49,9 @@ pub mod error;
 #[cfg(feature = "std")]
 pub use self::connection::{connect, MavConnection};
 
-#[cfg(feature = "embedded")]
+#[cfg(any(feature = "embedded", feature = "embedded-hal-02"))]
 pub mod embedded;
-#[cfg(feature = "embedded")]
+#[cfg(any(feature = "embedded", feature = "embedded-hal-02"))]
 use embedded::{Read, Write};
 
 pub const MAX_FRAME_SIZE: usize = 280;
@@ -395,7 +395,49 @@ pub fn read_v1_raw_message<M: Message, R: Read>(
     }
 }
 
-/// Read a MAVLink v1  message from a Read stream.
+/// Async read a raw buffer with the mavlink message
+/// V1 maximum size is 263 bytes: `<https://mavlink.io/en/guide/serialization.html>`
+///
+/// # Example
+/// See mavlink/examples/embedded-async-read full example for details.
+#[cfg(feature = "embedded")]
+pub async fn read_v1_raw_message_async<M: Message>(
+    reader: &mut impl embedded_io_async::Read,
+) -> Result<MAVLinkV1MessageRaw, error::MessageReadError> {
+    loop {
+        // search for the magic framing value indicating start of mavlink message
+        let mut byte = [0u8];
+        loop {
+            reader
+                .read_exact(&mut byte)
+                .await
+                .map_err(|_| error::MessageReadError::Io)?;
+            if byte[0] == MAV_STX {
+                break;
+            }
+        }
+
+        let mut message = MAVLinkV1MessageRaw::new();
+
+        message.0[0] = MAV_STX;
+        reader
+            .read_exact(message.mut_header())
+            .await
+            .map_err(|_| error::MessageReadError::Io)?;
+        reader
+            .read_exact(message.mut_payload_and_checksum())
+            .await
+            .map_err(|_| error::MessageReadError::Io)?;
+
+        // retry if CRC failed after previous STX
+        // (an STX byte may appear in the middle of a message)
+        if message.has_valid_crc::<M>() {
+            return Ok(message);
+        }
+    }
+}
+
+/// Read a MAVLink v1 message from a Read stream.
 pub fn read_v1_msg<M: Message, R: Read>(
     r: &mut PeekReader<R>,
 ) -> Result<(MavHeader, M), error::MessageReadError> {
@@ -419,6 +461,34 @@ pub fn read_v1_msg<M: Message, R: Read>(
     .map_err(|err| err.into())
 }
 
+/// Async read a MAVLink v1 message from a Read stream.
+///
+/// NOTE: it will be add ~80KB to firmware flash size because all *_DATA::deser methods will be add to firmware.
+/// Use `*_DATA::ser` methods manually to prevent it.
+#[cfg(feature = "embedded")]
+pub async fn read_v1_msg_async<M: Message>(
+    r: &mut impl embedded_io_async::Read,
+) -> Result<(MavHeader, M), error::MessageReadError> {
+    let message = read_v1_raw_message_async::<M>(r).await?;
+
+    M::parse(
+        MavlinkVersion::V1,
+        u32::from(message.message_id()),
+        message.payload(),
+    )
+    .map(|msg| {
+        (
+            MavHeader {
+                sequence: message.sequence(),
+                system_id: message.system_id(),
+                component_id: message.component_id(),
+            },
+            msg,
+        )
+    })
+    .map_err(|err| err.into())
+}
+
 const MAVLINK_IFLAG_SIGNED: u8 = 0x01;
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
@@ -621,6 +691,48 @@ pub fn read_v2_raw_message<M: Message, R: Read>(
     }
 }
 
+/// Async read a raw buffer with the mavlink message
+/// V2 maximum size is 280 bytes: `<https://mavlink.io/en/guide/serialization.html>`
+///
+/// # Example
+/// See mavlink/examples/embedded-async-read full example for details.
+#[cfg(feature = "embedded")]
+pub async fn read_v2_raw_message_async<M: Message>(
+    reader: &mut impl embedded_io_async::Read,
+) -> Result<MAVLinkV2MessageRaw, error::MessageReadError> {
+    loop {
+        // search for the magic framing value indicating start of mavlink message
+        let mut byte = [0u8];
+        loop {
+            reader
+                .read_exact(&mut byte)
+                .await
+                .map_err(|_| error::MessageReadError::Io)?;
+            if byte[0] == MAV_STX_V2 {
+                break;
+            }
+        }
+
+        let mut message = MAVLinkV2MessageRaw::new();
+
+        message.0[0] = MAV_STX;
+        reader
+            .read_exact(message.mut_header())
+            .await
+            .map_err(|_| error::MessageReadError::Io)?;
+        reader
+            .read_exact(message.mut_payload_and_checksum_and_sign())
+            .await
+            .map_err(|_| error::MessageReadError::Io)?;
+
+        // retry if CRC failed after previous STX
+        // (an STX byte may appear in the middle of a message)
+        if message.has_valid_crc::<M>() {
+            return Ok(message);
+        }
+    }
+}
+
 /// Read a MAVLink v2  message from a Read stream.
 pub fn read_v2_msg<M: Message, R: Read>(
     read: &mut PeekReader<R>,
@@ -641,6 +753,34 @@ pub fn read_v2_msg<M: Message, R: Read>(
         .map_err(|err| err.into())
 }
 
+/// Async read a MAVLink v2  message from a Read stream.
+///
+/// NOTE: it will be add ~80KB to firmware flash size because all *_DATA::deser methods will be add to firmware.
+/// Use `*_DATA::deser` methods manually to prevent it.
+#[cfg(feature = "embedded")]
+pub async fn read_v2_msg_async<M: Message, R: embedded_io_async::Read>(
+    r: &mut R,
+) -> Result<(MavHeader, M), error::MessageReadError> {
+    let message = read_v2_raw_message_async::<M>(r).await?;
+
+    M::parse(
+        MavlinkVersion::V2,
+        u32::from(message.message_id()),
+        message.payload(),
+    )
+    .map(|msg| {
+        (
+            MavHeader {
+                sequence: message.sequence(),
+                system_id: message.system_id(),
+                component_id: message.component_id(),
+            },
+            msg,
+        )
+    })
+    .map_err(|err| err.into())
+}
+
 /// Write a message using the given mavlink version
 pub fn write_versioned_msg<M: Message, W: Write>(
     w: &mut W,
@@ -654,6 +794,23 @@ pub fn write_versioned_msg<M: Message, W: Write>(
     }
 }
 
+/// Async write a message using the given mavlink version
+///
+/// NOTE: it will be add ~70KB to firmware flash size because all *_DATA::ser methods will be add to firmware.
+/// Use `*_DATA::ser` methods manually to prevent it.
+#[cfg(feature = "embedded")]
+pub async fn write_versioned_msg_async<M: Message>(
+    w: &mut impl embedded_io_async::Write,
+    version: MavlinkVersion,
+    header: MavHeader,
+    data: &M,
+) -> Result<usize, error::MessageWriteError> {
+    match version {
+        MavlinkVersion::V2 => write_v2_msg_async(w, header, data).await,
+        MavlinkVersion::V1 => write_v1_msg_async(w, header, data).await,
+    }
+}
+
 /// Write a MAVLink v2 message to a Write stream.
 pub fn write_v2_msg<M: Message, W: Write>(
     w: &mut W,
@@ -671,6 +828,29 @@ pub fn write_v2_msg<M: Message, W: Write>(
     Ok(len)
 }
 
+/// Async write a MAVLink v2 message to a Write stream.
+///
+/// NOTE: it will be add ~70KB to firmware flash size because all *_DATA::ser methods will be add to firmware.
+/// Use `*_DATA::ser` methods manually to prevent it.
+#[cfg(feature = "embedded")]
+pub async fn write_v2_msg_async<M: Message>(
+    w: &mut impl embedded_io_async::Write,
+    header: MavHeader,
+    data: &M,
+) -> Result<usize, error::MessageWriteError> {
+    let mut message_raw = MAVLinkV2MessageRaw::new();
+    message_raw.serialize_message(header, data);
+
+    let payload_length: usize = message_raw.payload_length().into();
+    let len = 1 + MAVLinkV2MessageRaw::HEADER_SIZE + payload_length + 2;
+
+    w.write_all(&message_raw.0[..len])
+        .await
+        .map_err(|_| error::MessageWriteError::Io)?;
+
+    Ok(len)
+}
+
 /// Write a MAVLink v1 message to a Write stream.
 pub fn write_v1_msg<M: Message, W: Write>(
     w: &mut W,
@@ -687,3 +867,26 @@ pub fn write_v1_msg<M: Message, W: Write>(
 
     Ok(len)
 }
+
+/// Write a MAVLink v1 message to a Write stream.
+///
+/// NOTE: it will be add ~70KB to firmware flash size because all *_DATA::ser methods will be add to firmware.
+/// Use `*_DATA::ser` methods manually to prevent it.
+#[cfg(feature = "embedded")]
+pub async fn write_v1_msg_async<M: Message>(
+    w: &mut impl embedded_io_async::Write,
+    header: MavHeader,
+    data: &M,
+) -> Result<usize, error::MessageWriteError> {
+    let mut message_raw = MAVLinkV1MessageRaw::new();
+    message_raw.serialize_message(header, data);
+
+    let payload_length: usize = message_raw.payload_length().into();
+    let len = 1 + MAVLinkV1MessageRaw::HEADER_SIZE + payload_length + 2;
+
+    w.write_all(&message_raw.0[..len])
+        .await
+        .map_err(|_| error::MessageWriteError::Io)?;
+
+    Ok(len)
+}

mavlink-core/src/peek_reader.rs

@@ -11,7 +11,7 @@
 //! The main type `PeekReader`does not implement [`std::io::Read`] itself, as there is no added benefit
 //! in doing so.
 //!
-#[cfg(feature = "embedded")]
+#[cfg(any(feature = "embedded", feature = "embedded-hal-02"))]
 use crate::embedded::Read;
 
 #[cfg(feature = "std")]

mavlink/Cargo.toml

@@ -93,7 +93,11 @@ serde_arrays = { version = "0.1.0", optional = true }
 "udp" = ["mavlink-core/udp"]
 "tcp" = ["mavlink-core/tcp"]
 "direct-serial" = ["mavlink-core/direct-serial"]
+# NOTE: Only one of 'embedded' and 'embedded-hal-02' features can be enabled.
+# Use "embedded' feature to enable embedded-hal=1.0 (embedded-io and embedded-io-async is part of embedded-hal).
+# Use 'embedded-hal-0.2' feature to enable deprecated embedded-hal=0.2.3 (some hals is not supports embedded-hal=1.0 yet).
 "embedded" = ["mavlink-core/embedded"]
+"embedded-hal-02" = ["mavlink-core/embedded-hal-02"]
 "serde" = ["mavlink-core/serde", "dep:serde", "dep:serde_arrays"]
 default = ["std", "tcp", "udp", "direct-serial", "serde", "ardupilotmega"]