diff options
47 files changed, 699 insertions, 1762 deletions
diff --git a/embassy-net/Cargo.toml b/embassy-net/Cargo.toml index 2d0116bd..1b2847a0 100644 --- a/embassy-net/Cargo.toml +++ b/embassy-net/Cargo.toml @@ -31,12 +31,15 @@ pool-32 = [] pool-64 = [] pool-128 = [] +nightly = ["embedded-io/async"] + [dependencies] defmt = { version = "0.3", optional = true } log = { version = "0.4.14", optional = true } embassy = { version = "0.1.0", path = "../embassy" } +embedded-io = "0.2.0" managed = { version = "0.8.0", default-features = false, features = [ "map" ] } heapless = { version = "0.7.5", default-features = false } diff --git a/embassy-net/src/device.rs b/embassy-net/src/device.rs index f66ebc19..1f4fa520 100644 --- a/embassy-net/src/device.rs +++ b/embassy-net/src/device.rs @@ -4,7 +4,6 @@ use smoltcp::phy::DeviceCapabilities; use smoltcp::time::Instant as SmolInstant; use crate::packet_pool::PacketBoxExt; -use crate::Result; use crate::{Packet, PacketBox, PacketBuf}; #[derive(PartialEq, Eq, Clone, Copy)] @@ -78,9 +77,9 @@ pub struct RxToken { } impl smoltcp::phy::RxToken for RxToken { - fn consume<R, F>(mut self, _timestamp: SmolInstant, f: F) -> Result<R> + fn consume<R, F>(mut self, _timestamp: SmolInstant, f: F) -> smoltcp::Result<R> where - F: FnOnce(&mut [u8]) -> Result<R>, + F: FnOnce(&mut [u8]) -> smoltcp::Result<R>, { f(&mut self.pkt) } @@ -92,9 +91,9 @@ pub struct TxToken<'a> { } impl<'a> smoltcp::phy::TxToken for TxToken<'a> { - fn consume<R, F>(self, _timestamp: SmolInstant, len: usize, f: F) -> Result<R> + fn consume<R, F>(self, _timestamp: SmolInstant, len: usize, f: F) -> smoltcp::Result<R> where - F: FnOnce(&mut [u8]) -> Result<R>, + F: FnOnce(&mut [u8]) -> smoltcp::Result<R>, { let mut buf = self.pkt.slice(0..len); let r = f(&mut buf)?; diff --git a/embassy-net/src/lib.rs b/embassy-net/src/lib.rs index ffe786b3..ded84190 100644 --- a/embassy-net/src/lib.rs +++ b/embassy-net/src/lib.rs @@ -1,5 +1,9 @@ #![cfg_attr(not(feature = "std"), no_std)] #![allow(clippy::new_without_default)] +#![cfg_attr( + feature = "nightly", + feature(generic_associated_types, type_alias_impl_trait) +)] // This mod MUST go first, so that the others see its macros. pub(crate) mod fmt; @@ -20,9 +24,7 @@ pub use stack::{ }; #[cfg(feature = "tcp")] -mod tcp_socket; -#[cfg(feature = "tcp")] -pub use tcp_socket::TcpSocket; +pub mod tcp; // smoltcp reexports pub use smoltcp::phy::{DeviceCapabilities, Medium}; @@ -32,4 +34,3 @@ pub use smoltcp::time::Instant as SmolInstant; pub use smoltcp::wire::{EthernetAddress, HardwareAddress}; pub use smoltcp::wire::{IpAddress, IpCidr, Ipv4Address, Ipv4Cidr}; pub type Interface = smoltcp::iface::Interface<'static, device::DeviceAdapter>; -pub use smoltcp::{Error, Result}; diff --git a/embassy-net/src/tcp/io_impl.rs b/embassy-net/src/tcp/io_impl.rs new file mode 100644 index 00000000..15573349 --- /dev/null +++ b/embassy-net/src/tcp/io_impl.rs @@ -0,0 +1,67 @@ +use core::future::Future; +use core::task::Poll; +use futures::future::poll_fn; + +use super::{Error, TcpSocket}; + +impl<'d> embedded_io::asynch::Read for TcpSocket<'d> { + type ReadFuture<'a> = impl Future<Output = Result<usize, Self::Error>> + where + Self: 'a; + + fn read<'a>(&'a mut self, buf: &'a mut [u8]) -> Self::ReadFuture<'a> { + poll_fn(move |cx| { + // CAUTION: smoltcp semantics around EOF are different to what you'd expect + // from posix-like IO, so we have to tweak things here. + self.with(|s, _| match s.recv_slice(buf) { + // No data ready + Ok(0) => { + s.register_recv_waker(cx.waker()); + Poll::Pending + } + // Data ready! + Ok(n) => Poll::Ready(Ok(n)), + // EOF + Err(smoltcp::Error::Finished) => Poll::Ready(Ok(0)), + // Connection reset. TODO: this can also be timeouts etc, investigate. + Err(smoltcp::Error::Illegal) => Poll::Ready(Err(Error::ConnectionReset)), + // smoltcp returns no errors other than the above. + Err(_) => unreachable!(), + }) + }) + } +} + +impl<'d> embedded_io::asynch::Write for TcpSocket<'d> { + type WriteFuture<'a> = impl Future<Output = Result<usize, Self::Error>> + where + Self: 'a; + + fn write<'a>(&'a mut self, buf: &'a [u8]) -> Self::WriteFuture<'a> { + poll_fn(move |cx| { + self.with(|s, _| match s.send_slice(buf) { + // Not ready to send (no space in the tx buffer) + Ok(0) => { + s.register_send_waker(cx.waker()); + Poll::Pending + } + // Some data sent + Ok(n) => Poll::Ready(Ok(n)), + // Connection reset. TODO: this can also be timeouts etc, investigate. + Err(smoltcp::Error::Illegal) => Poll::Ready(Err(Error::ConnectionReset)), + // smoltcp returns no errors other than the above. + Err(_) => unreachable!(), + }) + }) + } + + type FlushFuture<'a> = impl Future<Output = Result<(), Self::Error>> + where + Self: 'a; + + fn flush<'a>(&'a mut self) -> Self::FlushFuture<'a> { + poll_fn(move |_| { + Poll::Ready(Ok(())) // TODO: Is there a better implementation for this? + }) + } +} diff --git a/embassy-net/src/tcp_socket.rs b/embassy-net/src/tcp/mod.rs index 5637505d..3bfd4c7b 100644 --- a/embassy-net/src/tcp_socket.rs +++ b/embassy-net/src/tcp/mod.rs @@ -1,17 +1,46 @@ use core::marker::PhantomData; use core::mem; -use core::pin::Pin; -use core::task::{Context, Poll}; -use embassy::io; -use embassy::io::{AsyncBufRead, AsyncWrite}; +use core::task::Poll; use smoltcp::iface::{Context as SmolContext, SocketHandle}; use smoltcp::socket::TcpSocket as SyncTcpSocket; use smoltcp::socket::{TcpSocketBuffer, TcpState}; use smoltcp::time::Duration; use smoltcp::wire::IpEndpoint; +#[cfg(feature = "nightly")] +mod io_impl; + use super::stack::Stack; -use crate::{Error, Result}; + +#[derive(PartialEq, Eq, Clone, Copy, Debug)] +#[cfg_attr(feature = "defmt", derive(defmt::Format))] +pub enum Error { + ConnectionReset, +} + +#[derive(PartialEq, Eq, Clone, Copy, Debug)] +#[cfg_attr(feature = "defmt", derive(defmt::Format))] +pub enum ConnectError { + /// The socket is already connected or listening. + InvalidState, + /// The remote host rejected the connection with a RST packet. + ConnectionReset, + /// Connect timed out. + TimedOut, + /// No route to host. + NoRoute, +} + +#[derive(PartialEq, Eq, Clone, Copy, Debug)] +#[cfg_attr(feature = "defmt", derive(defmt::Format))] +pub enum AcceptError { + /// The socket is already connected or listening. + InvalidState, + /// Invalid listen port + InvalidPort, + /// The remote host rejected the connection with a RST packet. + ConnectionReset, +} pub struct TcpSocket<'a> { handle: SocketHandle, @@ -37,17 +66,25 @@ impl<'a> TcpSocket<'a> { } } - pub async fn connect<T>(&mut self, remote_endpoint: T) -> Result<()> + pub async fn connect<T>(&mut self, remote_endpoint: T) -> Result<(), ConnectError> where T: Into<IpEndpoint>, { let local_port = Stack::with(|stack| stack.get_local_port()); - self.with(|s, cx| s.connect(cx, remote_endpoint, local_port))?; + match self.with(|s, cx| s.connect(cx, remote_endpoint, local_port)) { + Ok(()) => {} + Err(smoltcp::Error::Illegal) => return Err(ConnectError::InvalidState), + Err(smoltcp::Error::Unaddressable) => return Err(ConnectError::NoRoute), + // smoltcp returns no errors other than the above. + Err(_) => unreachable!(), + } futures::future::poll_fn(|cx| { self.with(|s, _| match s.state() { - TcpState::Closed | TcpState::TimeWait => Poll::Ready(Err(Error::Unaddressable)), - TcpState::Listen => Poll::Ready(Err(Error::Illegal)), + TcpState::Closed | TcpState::TimeWait => { + Poll::Ready(Err(ConnectError::ConnectionReset)) + } + TcpState::Listen => unreachable!(), TcpState::SynSent | TcpState::SynReceived => { s.register_send_waker(cx.waker()); Poll::Pending @@ -58,11 +95,17 @@ impl<'a> TcpSocket<'a> { .await } - pub async fn accept<T>(&mut self, local_endpoint: T) -> Result<()> + pub async fn accept<T>(&mut self, local_endpoint: T) -> Result<(), AcceptError> where T: Into<IpEndpoint>, { - self.with(|s, _| s.listen(local_endpoint))?; + match self.with(|s, _| s.listen(local_endpoint)) { + Ok(()) => {} + Err(smoltcp::Error::Illegal) => return Err(AcceptError::InvalidState), + Err(smoltcp::Error::Unaddressable) => return Err(AcceptError::InvalidPort), + // smoltcp returns no errors other than the above. + Err(_) => unreachable!(), + } futures::future::poll_fn(|cx| { self.with(|s, _| match s.state() { @@ -130,11 +173,6 @@ impl<'a> TcpSocket<'a> { } } -fn to_ioerr(_err: Error) -> io::Error { - // todo - io::Error::Other -} - impl<'a> Drop for TcpSocket<'a> { fn drop(&mut self) { Stack::with(|stack| { @@ -143,63 +181,12 @@ impl<'a> Drop for TcpSocket<'a> { } } -impl<'a> AsyncBufRead for TcpSocket<'a> { - fn poll_fill_buf<'z>( - self: Pin<&'z mut Self>, - cx: &mut Context<'_>, - ) -> Poll<io::Result<&'z [u8]>> { - self.with(|s, _| match s.peek(1 << 30) { - // No data ready - Ok(buf) if buf.is_empty() => { - s.register_recv_waker(cx.waker()); - Poll::Pending - } - // Data ready! - Ok(buf) => { - // Safety: - // - User can't touch the inner TcpSocket directly at all. - // - The socket itself won't touch these bytes until consume() is called, which - // requires the user to release this borrow. - let buf: &'z [u8] = unsafe { core::mem::transmute(&*buf) }; - Poll::Ready(Ok(buf)) - } - // EOF - Err(Error::Finished) => Poll::Ready(Ok(&[][..])), - // Error - Err(e) => Poll::Ready(Err(to_ioerr(e))), - }) - } - - fn consume(self: Pin<&mut Self>, amt: usize) { - if amt == 0 { - // smoltcp's recv returns Finished if we're at EOF, - // even if we're "reading" 0 bytes. - return; - } - self.with(|s, _| s.recv(|_| (amt, ()))).unwrap() +impl embedded_io::Error for Error { + fn kind(&self) -> embedded_io::ErrorKind { + embedded_io::ErrorKind::Other } } -impl<'a> AsyncWrite for TcpSocket<'a> { - fn poll_write( - self: Pin<&mut Self>, - cx: &mut Context<'_>, - buf: &[u8], - ) -> Poll<io::Result<usize>> { - self.with(|s, _| match s.send_slice(buf) { - // Not ready to send (no space in the tx buffer) - Ok(0) => { - s.register_send_waker(cx.waker()); - Poll::Pending - } - // Some data sent - Ok(n) => Poll::Ready(Ok(n)), - // Error - Err(e) => Poll::Ready(Err(to_ioerr(e))), - }) - } - - fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> { - Poll::Ready(Ok(())) // TODO: Is there a better implementation for this? - } +impl<'d> embedded_io::Io for TcpSocket<'d> { + type Error = Error; } diff --git a/embassy-nrf/Cargo.toml b/embassy-nrf/Cargo.toml index b7c09286..cf61abcc 100644 --- a/embassy-nrf/Cargo.toml +++ b/embassy-nrf/Cargo.toml @@ -19,10 +19,10 @@ flavors = [ time = ["embassy/time"] -defmt = ["dep:defmt", "embassy/defmt", "embassy-usb?/defmt"] +defmt = ["dep:defmt", "embassy/defmt", "embassy-usb?/defmt", "embedded-io?/defmt"] # Enable nightly-only features -nightly = ["embassy/nightly", "embedded-hal-1", "embedded-hal-async", "embassy-usb", "embedded-storage-async"] +nightly = ["embassy/nightly", "embedded-hal-1", "embedded-hal-async", "embassy-usb", "embedded-storage-async", "dep:embedded-io"] # Reexport the PAC for the currently enabled chip at `embassy_nrf::pac`. # This is unstable because semver-minor (non-breaking) releases of embassy-nrf may major-bump (breaking) the PAC version. @@ -73,6 +73,7 @@ embassy-usb = {version = "0.1.0", path = "../embassy-usb", optional=true } embedded-hal-02 = { package = "embedded-hal", version = "0.2.6", features = ["unproven"] } embedded-hal-1 = { package = "embedded-hal", version = "1.0.0-alpha.8", optional = true} embedded-hal-async = { version = "0.1.0-alpha.0", optional = true} +embedded-io = { version = "0.2.0", features = ["async"], optional = true } defmt = { version = "0.3", optional = true } log = { version = "0.4.14", optional = true } diff --git a/embassy-nrf/src/buffered_uarte.rs b/embassy-nrf/src/buffered_uarte.rs index b49c1278..fc4e9c8d 100644 --- a/embassy-nrf/src/buffered_uarte.rs +++ b/embassy-nrf/src/buffered_uarte.rs @@ -14,18 +14,17 @@ //! Please also see [crate::uarte] to understand when [BufferedUarte] should be used. use core::cmp::min; +use core::future::Future; use core::marker::PhantomData; -use core::mem; -use core::pin::Pin; use core::sync::atomic::{compiler_fence, Ordering}; -use core::task::{Context, Poll}; +use core::task::Poll; use embassy::interrupt::InterruptExt; -use embassy::io::{AsyncBufRead, AsyncWrite}; use embassy::util::Unborrow; use embassy::waitqueue::WakerRegistration; use embassy_hal_common::peripheral::{PeripheralMutex, PeripheralState, StateStorage}; use embassy_hal_common::ring_buffer::RingBuffer; use embassy_hal_common::{low_power_wait_until, unborrow}; +use futures::future::poll_fn; use crate::gpio::Pin as GpioPin; use crate::pac; @@ -197,82 +196,99 @@ impl<'d, U: UarteInstance, T: TimerInstance> BufferedUarte<'d, U, T> { } } -impl<'d, U: UarteInstance, T: TimerInstance> AsyncBufRead for BufferedUarte<'d, U, T> { - fn poll_fill_buf( - mut self: Pin<&mut Self>, - cx: &mut Context<'_>, - ) -> Poll<embassy::io::Result<&[u8]>> { - self.inner.with(|state| { - compiler_fence(Ordering::SeqCst); - trace!("poll_read"); - - // We have data ready in buffer? Return it. - let buf = state.rx.pop_buf(); - if !buf.is_empty() { - trace!(" got {:?} {:?}", buf.as_ptr() as u32, buf.len()); - let buf: &[u8] = buf; - let buf: &[u8] = unsafe { mem::transmute(buf) }; - return Poll::Ready(Ok(buf)); +impl<'d, U: UarteInstance, T: TimerInstance> embedded_io::Io for BufferedUarte<'d, U, T> { + type Error = core::convert::Infallible; +} + +impl<'d, U: UarteInstance, T: TimerInstance> embedded_io::asynch::Read for BufferedUarte<'d, U, T> { + type ReadFuture<'a> = impl Future<Output = Result<usize, Self::Error>> + where + Self: 'a; + + fn read<'a>(&'a mut self, buf: &'a mut [u8]) -> Self::ReadFuture<'a> { + poll_fn(move |cx| { + let mut do_pend = false; + let res = self.inner.with(|state| { + compiler_fence(Ordering::SeqCst); + trace!("poll_read"); + + // We have data ready in buffer? Return it. + let data = state.rx.pop_buf(); + if !data.is_empty() { + trace!(" got {:?} {:?}", data.as_ptr() as u32, data.len()); + let len = data.len().min(data.len()); + buf[..len].copy_from_slice(&data[..len]); + state.rx.pop(len); + do_pend = true; + return Poll::Ready(Ok(len)); + } + + trace!(" empty"); + state.rx_waker.register(cx.waker()); + Poll::Pending + }); + if do_pend { + self.inner.pend(); } - trace!(" empty"); - state.rx_waker.register(cx.waker()); - Poll::<embassy::io::Result<&[u8]>>::Pending + res }) } - - fn consume(mut self: Pin<&mut Self>, amt: usize) { - self.inner.with(|state| { - trace!("consume {:?}", amt); - state.rx.pop(amt); - }); - self.inner.pend(); - } } -impl<'d, U: UarteInstance, T: TimerInstance> AsyncWrite for BufferedUarte<'d, U, T> { - fn poll_write( - mut self: Pin<&mut Self>, - cx: &mut Context<'_>, - buf: &[u8], - ) -> Poll<embassy::io::Result<usize>> { - let poll = self.inner.with(|state| { - trace!("poll_write: {:?}", buf.len()); - - let tx_buf = state.tx.push_buf(); - if tx_buf.is_empty() { - trace!("poll_write: pending"); - state.tx_waker.register(cx.waker()); - return Poll::Pending; - } +impl<'d, U: UarteInstance, T: TimerInstance> embedded_io::asynch::Write + for BufferedUarte<'d, U, T> +{ + type WriteFuture<'a> = impl Future<Output = Result<usize, Self::Error>> + where + Self: 'a; + + fn write<'a>(&'a mut self, buf: &'a [u8]) -> Self::WriteFuture<'a> { + poll_fn(move |cx| { + let res = self.inner.with(|state| { + trace!("poll_write: {:?}", buf.len()); + + let tx_buf = state.tx.push_buf(); + if tx_buf.is_empty() { + trace!("poll_write: pending"); + state.tx_waker.register(cx.waker()); + return Poll::Pending; + } - let n = min(tx_buf.len(), buf.len()); - tx_buf[..n].copy_from_slice(&buf[..n]); - state.tx.push(n); + let n = min(tx_buf.len(), buf.len()); + tx_buf[..n].copy_from_slice(&buf[..n]); + state.tx.push(n); - trace!("poll_write: queued {:?}", n); + trace!("poll_write: queued {:?}", n); - compiler_fence(Ordering::SeqCst); + compiler_fence(Ordering::SeqCst); - Poll::Ready(Ok(n)) - }); + Poll::Ready(Ok(n)) + }); - self.inner.pend(); + self.inner.pend(); - poll + res + }) } - fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<embassy::io::Result<()>> { - self.inner.with(|state| { - trace!("poll_flush"); + type FlushFuture<'a> = impl Future<Output = Result<(), Self::Error>> + where + Self: 'a; - if !state.tx.is_empty() { - trace!("poll_flush: pending"); - state.tx_waker.register(cx.waker()); - return Poll::Pending; - } + fn flush<'a>(&'a mut self) -> Self::FlushFuture<'a> { + poll_fn(move |cx| { + self.inner.with(|state| { + trace!("poll_flush"); + + if !state.tx.is_empty() { + trace!("poll_flush: pending"); + state.tx_waker.register(cx.waker()); + return Poll::Pending; + } - Poll::Ready(Ok(())) + Poll::Ready(Ok(())) + }) }) } } diff --git a/embassy-nrf/src/lib.rs b/embassy-nrf/src/lib.rs index 3b180902..865f33d7 100644 --- a/embassy-nrf/src/lib.rs +++ b/embassy-nrf/src/lib.rs @@ -64,6 +64,7 @@ pub(crate) mod util; #[cfg(feature = "_time-driver")] mod time_driver; +#[cfg(feature = "nightly")] pub mod buffered_uarte; pub mod gpio; #[cfg(feature = "gpiote")] diff --git a/embassy-stm32/Cargo.toml b/embassy-stm32/Cargo.toml index ea9ac3b5..9686e016 100644 --- a/embassy-stm32/Cargo.toml +++ b/embassy-stm32/Cargo.toml @@ -57,12 +57,13 @@ critical-section = "0.2.5" bare-metal = "1.0.0" atomic-polyfill = "0.1.5" stm32-metapac = { version = "0.1.0", path = "../stm32-metapac", features = ["rt"] } -vcell = { version = "0.1.3", optional = true } +vcell = "0.1.3" bxcan = "0.6.2" nb = "1.0.0" stm32-fmc = "0.2.4" seq-macro = "0.2.2" cfg-if = "1.0.0" +embedded-io = { version = "0.2.0", features = ["async"], optional = true } [build-dependencies] proc-macro2 = "1.0.36" @@ -70,8 +71,9 @@ quote = "1.0.15" stm32-metapac = { version = "0.1.0", path = "../stm32-metapac", default-features = false, features = ["metadata"]} [features] +defmt = ["dep:defmt", "embassy/defmt", "embedded-io?/defmt" ] sdmmc-rs = ["embedded-sdmmc"] -net = ["embassy-net", "vcell"] +net = ["embassy-net" ] memory-x = ["stm32-metapac/memory-x"] subghz = [] exti = [] @@ -88,7 +90,7 @@ time-driver-tim12 = ["_time-driver"] time-driver-tim15 = ["_time-driver"] # Enable nightly-only features -nightly = ["embassy/nightly", "embedded-hal-1", "embedded-hal-async", "embedded-storage-async"] +nightly = ["embassy/nightly", "embassy-net?/nightly", "embedded-hal-1", "embedded-hal-async", "embedded-storage-async", "dep:embedded-io"] # Reexport stm32-metapac at `embassy_stm32::pac`. # This is unstable because semver-minor (non-breaking) releases of embassy-stm32 may major-bump (breaking) the stm32-metapac version. diff --git a/embassy-stm32/build.rs b/embassy-stm32/build.rs index db757764..490f2d8f 100644 --- a/embassy-stm32/build.rs +++ b/embassy-stm32/build.rs @@ -244,200 +244,200 @@ fn main() { #[rustfmt::skip] let signals: HashMap<_, _> = [ - // (kind, signal) => (trait, cfgs) - (("usart", "TX"), (quote!(crate::usart::TxPin), quote!())), - (("usart", "RX"), (quote!(crate::usart::RxPin), quote!())), - (("usart", "CTS"), (quote!(crate::usart::CtsPin), quote!())), - (("usart", "RTS"), (quote!(crate::usart::RtsPin), quote!())), - (("usart", "CK"), (quote!(crate::usart::CkPin), quote!())), - (("usart", "TX"), (quote!(crate::usart::TxPin), quote!())), - (("usart", "RX"), (quote!(crate::usart::RxPin), quote!())), - (("usart", "CTS"), (quote!(crate::usart::CtsPin), quote!())), - (("usart", "RTS"), (quote!(crate::usart::RtsPin), quote!())), - (("usart", "CK"), (quote!(crate::usart::CkPin), quote!())), - (("spi", "SCK"), (quote!(crate::spi::SckPin), quote!())), - (("spi", "MOSI"), (quote!(crate::spi::MosiPin), quote!())), - (("spi", "MISO"), (quote!(crate::spi::MisoPin), quote!())), - (("i2c", "SDA"), (quote!(crate::i2c::SdaPin), quote!())), - (("i2c", "SCL"), (quote!(crate::i2c::SclPin), quote!())), - (("rcc", "MCO_1"), (quote!(crate::rcc::McoPin), quote!())), - (("rcc", "MCO_2"), (quote!(crate::rcc::McoPin), quote!())), - (("dcmi", "D0"), (quote!(crate::dcmi::D0Pin), quote!())), - (("dcmi", "D1"), (quote!(crate::dcmi::D1Pin), quote!())), - (("dcmi", "D2"), (quote!(crate::dcmi::D2Pin), quote!())), - (("dcmi", "D3"), (quote!(crate::dcmi::D3Pin), quote!())), - (("dcmi", "D4"), (quote!(crate::dcmi::D4Pin), quote!())), - (("dcmi", "D5"), (quote!(crate::dcmi::D5Pin), quote!())), - (("dcmi", "D6"), (quote!(crate::dcmi::D6Pin), quote!())), - (("dcmi", "D7"), (quote!(crate::dcmi::D7Pin), quote!())), - (("dcmi", "D8"), (quote!(crate::dcmi::D8Pin), quote!())), - (("dcmi", "D9"), (quote!(crate::dcmi::D9Pin), quote!())), - (("dcmi", "D10"), (quote!(crate::dcmi::D10Pin), quote!())), - (("dcmi", "D11"), (quote!(crate::dcmi::D11Pin), quote!())), - (("dcmi", "D12"), (quote!(crate::dcmi::D12Pin), quote!())), - (("dcmi", "D13"), (quote!(crate::dcmi::D13Pin), quote!())), - (("dcmi", "HSYNC"), (quote!(crate::dcmi::HSyncPin), quote!())), - (("dcmi", "VSYNC"), (quote!(crate::dcmi::VSyncPin), quote!())), - (("dcmi", "PIXCLK"), (quote!(crate::dcmi::PixClkPin), quote!())), - (("otgfs", "DP"), (quote!(crate::usb_otg::DpPin), quote!())), - (("otgfs", "DM"), (quote!(crate::usb_otg::DmPin), quote!())), - (("otghs", "DP"), (quote!(crate::usb_otg::DpPin), quote!())), - (("otghs", "DM"), (quote!(crate::usb_otg::DmPin), quote!())), - (("otghs", "ULPI_CK"), (quote!(crate::usb_otg::UlpiClkPin), quote!())), - (("otghs", "ULPI_DIR"), (quote!(crate::usb_otg::UlpiDirPin), quote!())), - (("otghs", "ULPI_NXT"), (quote!(crate::usb_otg::UlpiNxtPin), quote!())), - (("otghs", "ULPI_STP"), (quote!(crate::usb_otg::UlpiStpPin), quote!())), - (("otghs", "ULPI_D0"), (quote!(crate::usb_otg::UlpiD0Pin), quote!())), - (("otghs", "ULPI_D1"), (quote!(crate::usb_otg::UlpiD1Pin), quote!())), - (("otghs", "ULPI_D2"), (quote!(crate::usb_otg::UlpiD2Pin), quote!())), - (("otghs", "ULPI_D3"), (quote!(crate::usb_otg::UlpiD3Pin), quote!())), - (("otghs", "ULPI_D4"), (quote!(crate::usb_otg::UlpiD4Pin), quote!())), - (("otghs", "ULPI_D5"), (quote!(crate::usb_otg::UlpiD5Pin), quote!())), - (("otghs", "ULPI_D6"), (quote!(crate::usb_otg::UlpiD6Pin), quote!())), - (("otghs", "ULPI_D7"), (quote!(crate::usb_otg::UlpiD7Pin), quote!())), - (("can", "TX"), (quote!(crate::can::TxPin), quote!())), - (("can", "RX"), (quote!(crate::can::RxPin), quote!())), - (("eth", "REF_CLK"), (quote!(crate::eth::RefClkPin), quote!(#[cfg(feature="net")]))), - (("eth", "MDIO"), (quote!(crate::eth::MDIOPin), quote!(#[cfg(feature="net")]))), - (("eth", "MDC"), (quote!(crate::eth::MDCPin), quote!(#[cfg(feature="net")]))), - (("eth", "CRS_DV"), (quote!(crate::eth::CRSPin), quote!(#[cfg(feature="net")]))), - (("eth", "RXD0"), (quote!(crate::eth::RXD0Pin), quote!(#[cfg(feature="net")]))), - (("eth", "RXD1"), (quote!(crate::eth::RXD1Pin), quote!(#[cfg(feature="net")]))), - (("eth", "TXD0"), (quote!(crate::eth::TXD0Pin), quote!(#[cfg(feature="net")]))), - (("eth", "TXD1"), (quote!(crate::eth::TXD1Pin), quote!(#[cfg(feature="net")]))), - (("eth", "TX_EN"), (quote!(crate::eth::TXEnPin), quote!(#[cfg(feature="net")]))), - (("fmc", "A0"), (quote!(crate::fmc::A0Pin), quote!())), - (("fmc", "A1"), (quote!(crate::fmc::A1Pin), quote!())), - (("fmc", "A2"), (quote!(crate::fmc::A2Pin), quote!())), - (("fmc", "A3"), (quote!(crate::fmc::A3Pin), quote!())), - (("fmc", "A4"), (quote!(crate::fmc::A4Pin), quote!())), - (("fmc", "A5"), (quote!(crate::fmc::A5Pin), quote!())), - (("fmc", "A6"), (quote!(crate::fmc::A6Pin), quote!())), - (("fmc", "A7"), (quote!(crate::fmc::A7Pin), quote!())), - (("fmc", "A8"), (quote!(crate::fmc::A8Pin), quote!())), - (("fmc", "A9"), (quote!(crate::fmc::A9Pin), quote!())), - (("fmc", "A10"), (quote!(crate::fmc::A10Pin), quote!())), - (("fmc", "A11"), (quote!(crate::fmc::A11Pin), quote!())), - (("fmc", "A12"), (quote!(crate::fmc::A12Pin), quote!())), - (("fmc", "A13"), (quote!(crate::fmc::A13Pin), quote!())), - (("fmc", "A14"), (quote!(crate::fmc::A14Pin), quote!())), - (("fmc", "A15"), (quote!(crate::fmc::A15Pin), quote!())), - (("fmc", "A16"), (quote!(crate::fmc::A16Pin), quote!())), - (("fmc", "A17"), (quote!(crate::fmc::A17Pin), quote!())), - (("fmc", "A18"), (quote!(crate::fmc::A18Pin), quote!())), - (("fmc", "A19"), (quote!(crate::fmc::A19Pin), quote!())), - (("fmc", "A20"), (quote!(crate::fmc::A20Pin), quote!())), - (("fmc", "A21"), (quote!(crate::fmc::A21Pin), quote!())), - (("fmc", "A22"), (quote!(crate::fmc::A22Pin), quote!())), - (("fmc", "A23"), (quote!(crate::fmc::A23Pin), quote!())), - (("fmc", "A24"), (quote!(crate::fmc::A24Pin), quote!())), - (("fmc", "A25"), (quote!(crate::fmc::A25Pin), quote!())), - (("fmc", "D0"), (quote!(crate::fmc::D0Pin), quote!())), - (("fmc", "D1"), (quote!(crate::fmc::D1Pin), quote!())), - (("fmc", "D2"), (quote!(crate::fmc::D2Pin), quote!())), - (("fmc", "D3"), (quote!(crate::fmc::D3Pin), quote!())), - (("fmc", "D4"), (quote!(crate::fmc::D4Pin), quote!())), - (("fmc", "D5"), (quote!(crate::fmc::D5Pin), quote!())), - (("fmc", "D6"), (quote!(crate::fmc::D6Pin), quote!())), - (("fmc", "D7"), (quote!(crate::fmc::D7Pin), quote!())), - (("fmc", "D8"), (quote!(crate::fmc::D8Pin), quote!())), - (("fmc", "D9"), (quote!(crate::fmc::D9Pin), quote!())), - (("fmc", "D10"), (quote!(crate::fmc::D10Pin), quote!())), - (("fmc", "D11"), (quote!(crate::fmc::D11Pin), quote!())), - (("fmc", "D12"), (quote!(crate::fmc::D12Pin), quote!())), - (("fmc", "D13"), (quote!(crate::fmc::D13Pin), quote!())), - (("fmc", "D14"), (quote!(crate::fmc::D14Pin), quote!())), - (("fmc", "D15"), (quote!(crate::fmc::D15Pin), quote!())), - (("fmc", "D16"), (quote!(crate::fmc::D16Pin), quote!())), - (("fmc", "D17"), (quote!(crate::fmc::D17Pin), quote!())), - (("fmc", "D18"), (quote!(crate::fmc::D18Pin), quote!())), - (("fmc", "D19"), (quote!(crate::fmc::D19Pin), quote!())), - (("fmc", "D20"), (quote!(crate::fmc::D20Pin), quote!())), - (("fmc", "D21"), (quote!(crate::fmc::D21Pin), quote!())), - (("fmc", "D22"), (quote!(crate::fmc::D22Pin), quote!())), - (("fmc", "D23"), (quote!(crate::fmc::D23Pin), quote!())), - (("fmc", "D24"), (quote!(crate::fmc::D24Pin), quote!())), - (("fmc", "D25"), (quote!(crate::fmc::D25Pin), quote!())), - (("fmc", "D26"), (quote!(crate::fmc::D26Pin), quote!())), - (("fmc", "D27"), (quote!(crate::fmc::D27Pin), quote!())), - (("fmc", "D28"), (quote!(crate::fmc::D28Pin), quote!())), - (("fmc", "D29"), (quote!(crate::fmc::D29Pin), quote!())), - (("fmc", "D30"), (quote!(crate::fmc::D30Pin), quote!())), - (("fmc", "D31"), (quote!(crate::fmc::D31Pin), quote!())), - (("fmc", "DA0"), (quote!(crate::fmc::DA0Pin), quote!())), - (("fmc", "DA1"), (quote!(crate::fmc::DA1Pin), quote!())), - (("fmc", "DA2"), (quote!(crate::fmc::DA2Pin), quote!())), - (("fmc", "DA3"), (quote!(crate::fmc::DA3Pin), quote!())), - (("fmc", "DA4"), (quote!(crate::fmc::DA4Pin), quote!())), - (("fmc", "DA5"), (quote!(crate::fmc::DA5Pin), quote!())), - (("fmc", "DA6"), (quote!(crate::fmc::DA6Pin), quote!())), - (("fmc", "DA7"), (quote!(crate::fmc::DA7Pin), quote!())), - (("fmc", "DA8"), (quote!(crate::fmc::DA8Pin), quote!())), - (("fmc", "DA9"), (quote!(crate::fmc::DA9Pin), quote!())), - (("fmc", "DA10"), (quote!(crate::fmc::DA10Pin), quote!())), - (("fmc", "DA11"), (quote!(crate::fmc::DA11Pin), quote!())), - (("fmc", "DA12"), (quote!(crate::fmc::DA12Pin), quote!())), - (("fmc", "DA13"), (quote!(crate::fmc::DA13Pin), quote!())), - (("fmc", "DA14"), (quote!(crate::fmc::DA14Pin), quote!())), - (("fmc", "DA15"), (quote!(crate::fmc::DA15Pin), quote!())), - (("fmc", "SDNWE"), (quote!(crate::fmc::SDNWEPin), quote!())), - (("fmc", "SDNCAS"), (quote!(crate::fmc::SDNCASPin), quote!())), - (("fmc", "SDNRAS"), (quote!(crate::fmc::SDNRASPin), quote!())), - (("fmc", "SDNE0"), (quote!(crate::fmc::SDNE0Pin), quote!())), - (("fmc", "SDNE1"), (quote!(crate::fmc::SDNE1Pin), quote!())), - (("fmc", "SDCKE0"), (quote!(crate::fmc::SDCKE0Pin), quote!())), - (("fmc", "SDCKE1"), (quote!(crate::fmc::SDCKE1Pin), quote!())), - (("fmc", "SDCLK"), (quote!(crate::fmc::SDCLKPin), quote!())), - (("fmc", "NBL0"), (quote!(crate::fmc::NBL0Pin), quote!())), - (("fmc", "NBL1"), (quote!(crate::fmc::NBL1Pin), quote!())), - (("fmc", "NBL2"), (quote!(crate::fmc::NBL2Pin), quote!())), - (("fmc", "NBL3"), (quote!(crate::fmc::NBL3Pin), quote!())), - (("fmc", "INT"), (quote!(crate::fmc::INTPin), quote!())), - (("fmc", "NL"), (quote!(crate::fmc::NLPin), quote!())), - (("fmc", "NWAIT"), (quote!(crate::fmc::NWaitPin), quote!())), - (("fmc", "NE1"), (quote!(crate::fmc::NE1Pin), quote!())), - (("fmc", "NE2"), (quote!(crate::fmc::NE2Pin), quote!())), - (("fmc", "NE3"), (quote!(crate::fmc::NE3Pin), quote!())), - (("fmc", "NE4"), (quote!(crate::fmc::NE4Pin), quote!())), - (("fmc", "NCE"), (quote!(crate::fmc::NCEPin), quote!())), - (("fmc", "NOE"), (quote!(crate::fmc::NOEPin), quote!())), - (("fmc", "NWE"), (quote!(crate::fmc::NWEPin), quote!())), - (("fmc", "Clk"), (quote!(crate::fmc::ClkPin), quote!())), - (("fmc", "BA0"), (quote!(crate::fmc::BA0Pin), quote!())), - (("fmc", "BA1"), (quote!(crate::fmc::BA1Pin), quote!())), - (("timer", "CH1"), (quote!(crate::pwm::Channel1Pin), quote!())), - (("timer", "CH1N"), (quote!(crate::pwm::Channel1ComplementaryPin), quote!())), - (("timer", "CH2"), (quote!(crate::pwm::Channel2Pin), quote!())), - (("timer", "CH2N"), (quote!(crate::pwm::Channel2ComplementaryPin), quote!())), - (("timer", "CH3"), (quote!(crate::pwm::Channel3Pin), quote!())), - (("timer", "CH3N"), (quote!(crate::pwm::Channel3ComplementaryPin), quote!())), - (("timer", "CH4"), (quote!(crate::pwm::Channel4Pin), quote!())), - (("timer", "CH4N"), (quote!(crate::pwm::Channel4ComplementaryPin), quote!())), - (("timer", "ETR"), (quote!(crate::pwm::ExternalTriggerPin), quote!())), - (("timer", "BKIN"), (quote!(crate::pwm::BreakInputPin), quote!())), - (("timer", "BKIN_COMP1"), (quote!(crate::pwm::BreakInputComparator1Pin), quote!())), - (("timer", "BKIN_COMP2"), (quote!(crate::pwm::BreakInputComparator2Pin), quote!())), - (("timer", "BKIN2"), (quote!(crate::pwm::BreakInput2Pin), quote!())), - (("timer", "BKIN2_COMP1"), (quote!(crate::pwm::BreakInput2Comparator1Pin), quote!())), - (("timer", "BKIN2_COMP2"), (quote!(crate::pwm::BreakInput2Comparator2Pin), quote!())), - (("sdmmc", "CK"), (quote!(crate::sdmmc::CkPin), quote!())), - (("sdmmc", "CMD"), (quote!(crate::sdmmc::CmdPin), quote!())), - (("sdmmc", "D0"), (quote!(crate::sdmmc::D0Pin), quote!())), - (("sdmmc", "D1"), (quote!(crate::sdmmc::D1Pin), quote!())), - (("sdmmc", "D2"), (quote!(crate::sdmmc::D2Pin), quote!())), - (("sdmmc", "D3"), (quote!(crate::sdmmc::D3Pin), quote!())), - (("sdmmc", "D4"), (quote!(crate::sdmmc::D4Pin), quote!())), - (("sdmmc", "D5"), (quote!(crate::sdmmc::D5Pin), quote!())), - (("sdmmc", "D6"), (quote!(crate::sdmmc::D6Pin), quote!())), - (("sdmmc", "D6"), (quote!(crate::sdmmc::D7Pin), quote!())), - (("sdmmc", "D8"), (quote!(crate::sdmmc::D8Pin), quote!())), + // (kind, signal) => trait + (("usart", "TX"), quote!(crate::usart::TxPin)), + (("usart", "RX"), quote!(crate::usart::RxPin)), + (("usart", "CTS"), quote!(crate::usart::CtsPin)), + (("usart", "RTS"), quote!(crate::usart::RtsPin)), + (("usart", "CK"), quote!(crate::usart::CkPin)), + (("usart", "TX"), quote!(crate::usart::TxPin)), + (("usart", "RX"), quote!(crate::usart::RxPin)), + (("usart", "CTS"), quote!(crate::usart::CtsPin)), + (("usart", "RTS"), quote!(crate::usart::RtsPin)), + (("usart", "CK"), quote!(crate::usart::CkPin)), + (("spi", "SCK"), quote!(crate::spi::SckPin)), + (("spi", "MOSI"), quote!(crate::spi::MosiPin)), + (("spi", "MISO"), quote!(crate::spi::MisoPin)), + (("i2c", "SDA"), quote!(crate::i2c::SdaPin)), + (("i2c", "SCL"), quote!(crate::i2c::SclPin)), + (("rcc", "MCO_1"), quote!(crate::rcc::McoPin)), + (("rcc", "MCO_2"), quote!(crate::rcc::McoPin)), + (("dcmi", "D0"), quote!(crate::dcmi::D0Pin)), + (("dcmi", "D1"), quote!(crate::dcmi::D1Pin)), + (("dcmi", "D2"), quote!(crate::dcmi::D2Pin)), + (("dcmi", "D3"), quote!(crate::dcmi::D3Pin)), + (("dcmi", "D4"), quote!(crate::dcmi::D4Pin)), + (("dcmi", "D5"), quote!(crate::dcmi::D5Pin)), + (("dcmi", "D6"), quote!(crate::dcmi::D6Pin)), + (("dcmi", "D7"), quote!(crate::dcmi::D7Pin)), + (("dcmi", "D8"), quote!(crate::dcmi::D8Pin)), + (("dcmi", "D9"), quote!(crate::dcmi::D9Pin)), + (("dcmi", "D10"), quote!(crate::dcmi::D10Pin)), + (("dcmi", "D11"), quote!(crate::dcmi::D11Pin)), + (("dcmi", "D12"), quote!(crate::dcmi::D12Pin)), + (("dcmi", "D13"), quote!(crate::dcmi::D13Pin)), + (("dcmi", "HSYNC"), quote!(crate::dcmi::HSyncPin)), + (("dcmi", "VSYNC"), quote!(crate::dcmi::VSyncPin)), + (("dcmi", "PIXCLK"), quote!(crate::dcmi::PixClkPin)), + (("otgfs", "DP"), quote!(crate::usb_otg::DpPin)), + (("otgfs", "DM"), quote!(crate::usb_otg::DmPin)), + (("otghs", "DP"), quote!(crate::usb_otg::DpPin)), + (("otghs", "DM"), quote!(crate::usb_otg::DmPin)), + (("otghs", "ULPI_CK"), quote!(crate::usb_otg::UlpiClkPin)), + (("otghs", "ULPI_DIR"), quote!(crate::usb_otg::UlpiDirPin)), + (("otghs", "ULPI_NXT"), quote!(crate::usb_otg::UlpiNxtPin)), + (("otghs", "ULPI_STP"), quote!(crate::usb_otg::UlpiStpPin)), + (("otghs", "ULPI_D0"), quote!(crate::usb_otg::UlpiD0Pin)), + (("otghs", "ULPI_D1"), quote!(crate::usb_otg::UlpiD1Pin)), + (("otghs", "ULPI_D2"), quote!(crate::usb_otg::UlpiD2Pin)), + (("otghs", "ULPI_D3"), quote!(crate::usb_otg::UlpiD3Pin)), + (("otghs", "ULPI_D4"), quote!(crate::usb_otg::UlpiD4Pin)), + (("otghs", "ULPI_D5"), quote!(crate::usb_otg::UlpiD5Pin)), + (("otghs", "ULPI_D6"), quote!(crate::usb_otg::UlpiD6Pin)), + (("otghs", "ULPI_D7"), quote!(crate::usb_otg::UlpiD7Pin)), + (("can", "TX"), quote!(crate::can::TxPin)), + (("can", "RX"), quote!(crate::can::RxPin)), + (("eth", "REF_CLK"), quote!(crate::eth::RefClkPin)), + (("eth", "MDIO"), quote!(crate::eth::MDIOPin)), + (("eth", "MDC"), quote!(crate::eth::MDCPin)), + (("eth", "CRS_DV"), quote!(crate::eth::CRSPin)), + (("eth", "RXD0"), quote!(crate::eth::RXD0Pin)), + (("eth", "RXD1"), quote!(crate::eth::RXD1Pin)), + (("eth", "TXD0"), quote!(crate::eth::TXD0Pin)), + (("eth", "TXD1"), quote!(crate::eth::TXD1Pin)), + (("eth", "TX_EN"), quote!(crate::eth::TXEnPin)), + (("fmc", "A0"), quote!(crate::fmc::A0Pin)), + (("fmc", "A1"), quote!(crate::fmc::A1Pin)), + (("fmc", "A2"), quote!(crate::fmc::A2Pin)), + (("fmc", "A3"), quote!(crate::fmc::A3Pin)), + (("fmc", "A4"), quote!(crate::fmc::A4Pin)), + (("fmc", "A5"), quote!(crate::fmc::A5Pin)), + (("fmc", "A6"), quote!(crate::fmc::A6Pin)), + (("fmc", "A7"), quote!(crate::fmc::A7Pin)), + (("fmc", "A8"), quote!(crate::fmc::A8Pin)), + (("fmc", "A9"), quote!(crate::fmc::A9Pin)), + (("fmc", "A10"), quote!(crate::fmc::A10Pin)), + (("fmc", "A11"), quote!(crate::fmc::A11Pin)), + (("fmc", "A12"), quote!(crate::fmc::A12Pin)), + (("fmc", "A13"), quote!(crate::fmc::A13Pin)), + (("fmc", "A14"), quote!(crate::fmc::A14Pin)), + (("fmc", "A15"), quote!(crate::fmc::A15Pin)), + (("fmc", "A16"), quote!(crate::fmc::A16Pin)), + (("fmc", "A17"), quote!(crate::fmc::A17Pin)), + (("fmc", "A18"), quote!(crate::fmc::A18Pin)), + (("fmc", "A19"), quote!(crate::fmc::A19Pin)), + (("fmc", "A20"), quote!(crate::fmc::A20Pin)), + (("fmc", "A21"), quote!(crate::fmc::A21Pin)), + (("fmc", "A22"), quote!(crate::fmc::A22Pin)), + (("fmc", "A23"), quote!(crate::fmc::A23Pin)), + (("fmc", "A24"), quote!(crate::fmc::A24Pin)), + (("fmc", "A25"), quote!(crate::fmc::A25Pin)), + (("fmc", "D0"), quote!(crate::fmc::D0Pin)), + (("fmc", "D1"), quote!(crate::fmc::D1Pin)), + (("fmc", "D2"), quote!(crate::fmc::D2Pin)), + (("fmc", "D3"), quote!(crate::fmc::D3Pin)), + (("fmc", "D4"), quote!(crate::fmc::D4Pin)), + (("fmc", "D5"), quote!(crate::fmc::D5Pin)), + (("fmc", "D6"), quote!(crate::fmc::D6Pin)), + (("fmc", "D7"), quote!(crate::fmc::D7Pin)), + (("fmc", "D8"), quote!(crate::fmc::D8Pin)), + (("fmc", "D9"), quote!(crate::fmc::D9Pin)), + (("fmc", "D10"), quote!(crate::fmc::D10Pin)), + (("fmc", "D11"), quote!(crate::fmc::D11Pin)), + (("fmc", "D12"), quote!(crate::fmc::D12Pin)), + (("fmc", "D13"), quote!(crate::fmc::D13Pin)), + (("fmc", "D14"), quote!(crate::fmc::D14Pin)), + (("fmc", "D15"), quote!(crate::fmc::D15Pin)), + (("fmc", "D16"), quote!(crate::fmc::D16Pin)), + (("fmc", "D17"), quote!(crate::fmc::D17Pin)), + (("fmc", "D18"), quote!(crate::fmc::D18Pin)), + (("fmc", "D19"), quote!(crate::fmc::D19Pin)), + (("fmc", "D20"), quote!(crate::fmc::D20Pin)), + (("fmc", "D21"), quote!(crate::fmc::D21Pin)), + (("fmc", "D22"), quote!(crate::fmc::D22Pin)), + (("fmc", "D23"), quote!(crate::fmc::D23Pin)), + (("fmc", "D24"), quote!(crate::fmc::D24Pin)), + (("fmc", "D25"), quote!(crate::fmc::D25Pin)), + (("fmc", "D26"), quote!(crate::fmc::D26Pin)), + (("fmc", "D27"), quote!(crate::fmc::D27Pin)), + (("fmc", "D28"), quote!(crate::fmc::D28Pin)), + (("fmc", "D29"), quote!(crate::fmc::D29Pin)), + (("fmc", "D30"), quote!(crate::fmc::D30Pin)), + (("fmc", "D31"), quote!(crate::fmc::D31Pin)), + (("fmc", "DA0"), quote!(crate::fmc::DA0Pin)), + (("fmc", "DA1"), quote!(crate::fmc::DA1Pin)), + (("fmc", "DA2"), quote!(crate::fmc::DA2Pin)), + (("fmc", "DA3"), quote!(crate::fmc::DA3Pin)), + (("fmc", "DA4"), quote!(crate::fmc::DA4Pin)), + (("fmc", "DA5"), quote!(crate::fmc::DA5Pin)), + (("fmc", "DA6"), quote!(crate::fmc::DA6Pin)), + (("fmc", "DA7"), quote!(crate::fmc::DA7Pin)), + (("fmc", "DA8"), quote!(crate::fmc::DA8Pin)), + (("fmc", "DA9"), quote!(crate::fmc::DA9Pin)), + (("fmc", "DA10"), quote!(crate::fmc::DA10Pin)), + (("fmc", "DA11"), quote!(crate::fmc::DA11Pin)), + (("fmc", "DA12"), quote!(crate::fmc::DA12Pin)), + (("fmc", "DA13"), quote!(crate::fmc::DA13Pin)), + (("fmc", "DA14"), quote!(crate::fmc::DA14Pin)), + (("fmc", "DA15"), quote!(crate::fmc::DA15Pin)), + (("fmc", "SDNWE"), quote!(crate::fmc::SDNWEPin)), + (("fmc", "SDNCAS"), quote!(crate::fmc::SDNCASPin)), + (("fmc", "SDNRAS"), quote!(crate::fmc::SDNRASPin)), + (("fmc", "SDNE0"), quote!(crate::fmc::SDNE0Pin)), + (("fmc", "SDNE1"), quote!(crate::fmc::SDNE1Pin)), + (("fmc", "SDCKE0"), quote!(crate::fmc::SDCKE0Pin)), + (("fmc", "SDCKE1"), quote!(crate::fmc::SDCKE1Pin)), + (("fmc", "SDCLK"), quote!(crate::fmc::SDCLKPin)), + (("fmc", "NBL0"), quote!(crate::fmc::NBL0Pin)), + (("fmc", "NBL1"), quote!(crate::fmc::NBL1Pin)), + (("fmc", "NBL2"), quote!(crate::fmc::NBL2Pin)), + (("fmc", "NBL3"), quote!(crate::fmc::NBL3Pin)), + (("fmc", "INT"), quote!(crate::fmc::INTPin)), + (("fmc", "NL"), quote!(crate::fmc::NLPin)), + (("fmc", "NWAIT"), quote!(crate::fmc::NWaitPin)), + (("fmc", "NE1"), quote!(crate::fmc::NE1Pin)), + (("fmc", "NE2"), quote!(crate::fmc::NE2Pin)), + (("fmc", "NE3"), quote!(crate::fmc::NE3Pin)), + (("fmc", "NE4"), quote!(crate::fmc::NE4Pin)), + (("fmc", "NCE"), quote!(crate::fmc::NCEPin)), + (("fmc", "NOE"), quote!(crate::fmc::NOEPin)), + (("fmc", "NWE"), quote!(crate::fmc::NWEPin)), + (("fmc", "Clk"), quote!(crate::fmc::ClkPin)), + (("fmc", "BA0"), quote!(crate::fmc::BA0Pin)), + (("fmc", "BA1"), quote!(crate::fmc::BA1Pin)), + (("timer", "CH1"), quote!(crate::pwm::Channel1Pin)), + (("timer", "CH1N"), quote!(crate::pwm::Channel1ComplementaryPin)), + (("timer", "CH2"), quote!(crate::pwm::Channel2Pin)), + (("timer", "CH2N"), quote!(crate::pwm::Channel2ComplementaryPin)), + (("timer", "CH3"), quote!(crate::pwm::Channel3Pin)), + (("timer", "CH3N"), quote!(crate::pwm::Channel3ComplementaryPin)), + (("timer", "CH4"), quote!(crate::pwm::Channel4Pin)), + (("timer", "CH4N"), quote!(crate::pwm::Channel4ComplementaryPin)), + (("timer", "ETR"), quote!(crate::pwm::ExternalTriggerPin)), + (("timer", "BKIN"), quote!(crate::pwm::BreakInputPin)), + (("timer", "BKIN_COMP1"), quote!(crate::pwm::BreakInputComparator1Pin)), + (("timer", "BKIN_COMP2"), quote!(crate::pwm::BreakInputComparator2Pin)), + (("timer", "BKIN2"), quote!(crate::pwm::BreakInput2Pin)), + (("timer", "BKIN2_COMP1"), quote!(crate::pwm::BreakInput2Comparator1Pin)), + (("timer", "BKIN2_COMP2"), quote!(crate::pwm::BreakInput2Comparator2Pin)), + (("sdmmc", "CK"), quote!(crate::sdmmc::CkPin)), + (("sdmmc", "CMD"), quote!(crate::sdmmc::CmdPin)), + (("sdmmc", "D0"), quote!(crate::sdmmc::D0Pin)), + (("sdmmc", "D1"), quote!(crate::sdmmc::D1Pin)), + (("sdmmc", "D2"), quote!(crate::sdmmc::D2Pin)), + (("sdmmc", "D3"), quote!(crate::sdmmc::D3Pin)), + (("sdmmc", "D4"), quote!(crate::sdmmc::D4Pin)), + (("sdmmc", "D5"), quote!(crate::sdmmc::D5Pin)), + (("sdmmc", "D6"), quote!(crate::sdmmc::D6Pin)), + (("sdmmc", "D6"), quote!(crate::sdmmc::D7Pin)), + (("sdmmc", "D8"), quote!(crate::sdmmc::D8Pin)), ].into(); for p in METADATA.peripherals { if let Some(regs) = &p.registers { for pin in p.pins { let key = (regs.kind, pin.signal); - if let Some((tr, cfgs)) = signals.get(&key) { + if let Some(tr) = signals.get(&key) { let mut peri = format_ident!("{}", p.name); let pin_name = format_ident!("{}", pin.pin); let af = pin.af.unwrap_or(0); @@ -453,7 +453,6 @@ fn main() { } g.extend(quote! { - #cfgs pin_trait_impl!(#tr, #peri, #pin_name, #af); }) } diff --git a/embassy-stm32/src/eth/mod.rs b/embassy-stm32/src/eth/mod.rs index 28f0c178..76a3dfab 100644 --- a/embassy-stm32/src/eth/mod.rs +++ b/embassy-stm32/src/eth/mod.rs @@ -1,10 +1,12 @@ #![macro_use] +#[cfg(feature = "net")] #[cfg_attr(any(eth_v1a, eth_v1b, eth_v1c), path = "v1/mod.rs")] #[cfg_attr(eth_v2, path = "v2/mod.rs")] mod _version; pub mod generic_smi; +#[cfg(feature = "net")] pub use _version::*; /// Station Management Interface (SMI) on an ethernet PHY diff --git a/embassy-stm32/src/lib.rs b/embassy-stm32/src/lib.rs index 6e9077b4..86b3e25d 100644 --- a/embassy-stm32/src/lib.rs +++ b/embassy-stm32/src/lib.rs @@ -39,7 +39,7 @@ pub mod can; pub mod dac; #[cfg(dcmi)] pub mod dcmi; -#[cfg(all(eth, feature = "net"))] +#[cfg(eth)] pub mod eth; #[cfg(feature = "exti")] pub mod exti; diff --git a/embassy-stm32/src/usart/buffered.rs b/embassy-stm32/src/usart/buffered.rs new file mode 100644 index 00000000..b2fcb504 --- /dev/null +++ b/embassy-stm32/src/usart/buffered.rs @@ -0,0 +1,238 @@ +use atomic_polyfill::{compiler_fence, Ordering}; +use core::future::Future; +use core::task::Poll; +use embassy::waitqueue::WakerRegistration; +use embassy_hal_common::peripheral::{PeripheralMutex, PeripheralState, StateStorage}; +use embassy_hal_common::ring_buffer::RingBuffer; +use futures::future::poll_fn; + +use super::*; + +pub struct State<'d, T: Instance>(StateStorage<StateInner<'d, T>>); +impl<'d, T: Instance> State<'d, T> { + pub fn new() -> Self { + Self(StateStorage::new()) + } +} + +struct StateInner<'d, T: Instance> { + phantom: PhantomData<&'d mut T>, + + rx_waker: WakerRegistration, + rx: RingBuffer<'d>, + + tx_waker: WakerRegistration, + tx: RingBuffer<'d>, +} + +unsafe impl<'d, T: Instance> Send for StateInner<'d, T> {} +unsafe impl<'d, T: Instance> Sync for StateInner<'d, T> {} + +pub struct BufferedUart<'d, T: Instance> { + inner: PeripheralMutex<'d, StateInner<'d, T>>, +} + +impl<'d, T: Instance> Unpin for BufferedUart<'d, T> {} + +impl<'d, T: Instance> BufferedUart<'d, T> { + pub unsafe fn new( + state: &'d mut State<'d, T>, + _uart: Uart<'d, T, NoDma, NoDma>, + irq: impl Unborrow<Target = T::Interrupt> + 'd, + tx_buffer: &'d mut [u8], + rx_buffer: &'d mut [u8], + ) -> BufferedUart<'d, T> { + unborrow!(irq); + + let r = T::regs(); + r.cr1().modify(|w| { + w.set_rxneie(true); + w.set_idleie(true); + }); + + Self { + inner: PeripheralMutex::new_unchecked(irq, &mut state.0, move || StateInner { + phantom: PhantomData, + tx: RingBuffer::new(tx_buffer), + tx_waker: WakerRegistration::new(), + + rx: RingBuffer::new(rx_buffer), + rx_waker: WakerRegistration::new(), + }), + } + } +} + +impl<'d, T: Instance> StateInner<'d, T> +where + Self: 'd, +{ + fn on_rx(&mut self) { + let r = T::regs(); + unsafe { + let sr = sr(r).read(); + clear_interrupt_flags(r, sr); + + // This read also clears the error and idle interrupt flags on v1. + let b = rdr(r).read_volatile(); + + if sr.rxne() { + if sr.pe() { + warn!("Parity error"); + } + if sr.fe() { + warn!("Framing error"); + } + if sr.ne() { + warn!("Noise error"); + } + if sr.ore() { + warn!("Overrun error"); + } + + let buf = self.rx.push_buf(); + if !buf.is_empty() { + buf[0] = b; + self.rx.push(1); + } else { + warn!("RX buffer full, discard received byte"); + } + + if self.rx.is_full() { + self.rx_waker.wake(); + } + } + + if sr.idle() { + self.rx_waker.wake(); + }; + } + } + + fn on_tx(&mut self) { + let r = T::regs(); + unsafe { + if sr(r).read().txe() { + let buf = self.tx.pop_buf(); + if !buf.is_empty() { + r.cr1().modify(|w| { + w.set_txeie(true); + }); + tdr(r).write_volatile(buf[0].into()); + self.tx.pop(1); + self.tx_waker.wake(); + } else { + // Disable interrupt until we have something to transmit again + r.cr1().modify(|w| { + w.set_txeie(false); + }); + } + } + } + } +} + +impl<'d, T: Instance> PeripheralState for StateInner<'d, T> +where + Self: 'd, +{ + type Interrupt = T::Interrupt; + fn on_interrupt(&mut self) { + self.on_rx(); + self.on_tx(); + } +} + +impl embedded_io::Error for Error { + fn kind(&self) -> embedded_io::ErrorKind { + embedded_io::ErrorKind::Other + } +} + +impl<'d, T: Instance> embedded_io::Io for BufferedUart<'d, T> { + type Error = Error; +} + +impl<'d, T: Instance> embedded_io::asynch::Read for BufferedUart<'d, T> { + type ReadFuture<'a> = impl Future<Output = Result<usize, Self::Error>> + where + Self: 'a; + + fn read<'a>(&'a mut self, buf: &'a mut [u8]) -> Self::ReadFuture<'a> { + poll_fn(move |cx| { + let mut do_pend = false; + let res = self.inner.with(|state| { + compiler_fence(Ordering::SeqCst); + + // We have data ready in buffer? Return it. + let data = state.rx.pop_buf(); + if !data.is_empty() { + let len = data.len().min(buf.len()); + buf[..len].copy_from_slice(&data[..len]); + + if state.rx.is_full() { + do_pend = true; + } + state.rx.pop(len); + + return Poll::Ready(Ok(len)); + } + + state.rx_waker.register(cx.waker()); + Poll::Pending + }); + + if do_pend { + self.inner.pend(); + } + + res + }) + } +} + +impl<'d, T: Instance> embedded_io::asynch::Write for BufferedUart<'d, T> { + type WriteFuture<'a> = impl Future<Output = Result<usize, Self::Error>> + where + Self: 'a; + + fn write<'a>(&'a mut self, buf: &'a [u8]) -> Self::WriteFuture<'a> { + poll_fn(move |cx| { + let (poll, empty) = self.inner.with(|state| { + let empty = state.tx.is_empty(); + let tx_buf = state.tx.push_buf(); + if tx_buf.is_empty() { + state.tx_waker.register(cx.waker()); + return (Poll::Pending, empty); + } + + let n = core::cmp::min(tx_buf.len(), buf.len()); + tx_buf[..n].copy_from_slice(&buf[..n]); + state.tx.push(n); + + (Poll::Ready(Ok(n)), empty) + }); + if empty { + self.inner.pend(); + } + poll + }) + } + + type FlushFuture<'a> = impl Future<Output = Result<(), Self::Error>> + where + Self: 'a; + + fn flush<'a>(&'a mut self) -> Self::FlushFuture<'a> { + poll_fn(move |cx| { + self.inner.with(|state| { + if !state.tx.is_empty() { + state.tx_waker.register(cx.waker()); + return Poll::Pending; + } + + Poll::Ready(Ok(())) + }) + }) + } +} diff --git a/embassy-stm32/src/usart/mod.rs b/embassy-stm32/src/usart/mod.rs index 22224215..6feecd18 100644 --- a/embassy-stm32/src/usart/mod.rs +++ b/embassy-stm32/src/usart/mod.rs @@ -424,227 +424,10 @@ cfg_if::cfg_if! { } } +#[cfg(feature = "nightly")] pub use buffered::*; -mod buffered { - use atomic_polyfill::{compiler_fence, Ordering}; - use core::pin::Pin; - use core::task::Context; - use core::task::Poll; - use embassy::waitqueue::WakerRegistration; - use embassy_hal_common::peripheral::{PeripheralMutex, PeripheralState, StateStorage}; - use embassy_hal_common::ring_buffer::RingBuffer; - - use super::*; - - pub struct State<'d, T: Instance>(StateStorage<StateInner<'d, T>>); - impl<'d, T: Instance> State<'d, T> { - pub fn new() -> Self { - Self(StateStorage::new()) - } - } - - struct StateInner<'d, T: Instance> { - phantom: PhantomData<&'d mut T>, - - rx_waker: WakerRegistration, - rx: RingBuffer<'d>, - - tx_waker: WakerRegistration, - tx: RingBuffer<'d>, - } - - unsafe impl<'d, T: Instance> Send for StateInner<'d, T> {} - unsafe impl<'d, T: Instance> Sync for StateInner<'d, T> {} - - pub struct BufferedUart<'d, T: Instance> { - inner: PeripheralMutex<'d, StateInner<'d, T>>, - } - - impl<'d, T: Instance> Unpin for BufferedUart<'d, T> {} - - impl<'d, T: Instance> BufferedUart<'d, T> { - pub unsafe fn new( - state: &'d mut State<'d, T>, - _uart: Uart<'d, T, NoDma, NoDma>, - irq: impl Unborrow<Target = T::Interrupt> + 'd, - tx_buffer: &'d mut [u8], - rx_buffer: &'d mut [u8], - ) -> BufferedUart<'d, T> { - unborrow!(irq); - - let r = T::regs(); - r.cr1().modify(|w| { - w.set_rxneie(true); - w.set_idleie(true); - }); - - Self { - inner: PeripheralMutex::new_unchecked(irq, &mut state.0, move || StateInner { - phantom: PhantomData, - tx: RingBuffer::new(tx_buffer), - tx_waker: WakerRegistration::new(), - - rx: RingBuffer::new(rx_buffer), - rx_waker: WakerRegistration::new(), - }), - } - } - } - - impl<'d, T: Instance> StateInner<'d, T> - where - Self: 'd, - { - fn on_rx(&mut self) { - let r = T::regs(); - unsafe { - let sr = sr(r).read(); - clear_interrupt_flags(r, sr); - - // This read also clears the error and idle interrupt flags on v1. - let b = rdr(r).read_volatile(); - - if sr.rxne() { - if sr.pe() { - warn!("Parity error"); - } - if sr.fe() { - warn!("Framing error"); - } - if sr.ne() { - warn!("Noise error"); - } - if sr.ore() { - warn!("Overrun error"); - } - - let buf = self.rx.push_buf(); - if !buf.is_empty() { - buf[0] = b; - self.rx.push(1); - } else { - warn!("RX buffer full, discard received byte"); - } - - if self.rx.is_full() { - self.rx_waker.wake(); - } - } - - if sr.idle() { - self.rx_waker.wake(); - }; - } - } - - fn on_tx(&mut self) { - let r = T::regs(); - unsafe { - if sr(r).read().txe() { - let buf = self.tx.pop_buf(); - if !buf.is_empty() { - r.cr1().modify(|w| { - w.set_txeie(true); - }); - tdr(r).write_volatile(buf[0].into()); - self.tx.pop(1); - self.tx_waker.wake(); - } else { - // Disable interrupt until we have something to transmit again - r.cr1().modify(|w| { - w.set_txeie(false); - }); - } - } - } - } - } - - impl<'d, T: Instance> PeripheralState for StateInner<'d, T> - where - Self: 'd, - { - type Interrupt = T::Interrupt; - fn on_interrupt(&mut self) { - self.on_rx(); - self.on_tx(); - } - } - - impl<'d, T: Instance> embassy::io::AsyncBufRead for BufferedUart<'d, T> { - fn poll_fill_buf( - mut self: Pin<&mut Self>, - cx: &mut Context<'_>, - ) -> Poll<Result<&[u8], embassy::io::Error>> { - self.inner.with(|state| { - compiler_fence(Ordering::SeqCst); - - // We have data ready in buffer? Return it. - let buf = state.rx.pop_buf(); - if !buf.is_empty() { - let buf: &[u8] = buf; - // Safety: buffer lives as long as uart - let buf: &[u8] = unsafe { core::mem::transmute(buf) }; - return Poll::Ready(Ok(buf)); - } - - state.rx_waker.register(cx.waker()); - Poll::<Result<&[u8], embassy::io::Error>>::Pending - }) - } - fn consume(mut self: Pin<&mut Self>, amt: usize) { - let signal = self.inner.with(|state| { - let full = state.rx.is_full(); - state.rx.pop(amt); - full - }); - if signal { - self.inner.pend(); - } - } - } - - impl<'d, T: Instance> embassy::io::AsyncWrite for BufferedUart<'d, T> { - fn poll_write( - mut self: Pin<&mut Self>, - cx: &mut Context<'_>, - buf: &[u8], - ) -> Poll<Result<usize, embassy::io::Error>> { - let (poll, empty) = self.inner.with(|state| { - let empty = state.tx.is_empty(); - let tx_buf = state.tx.push_buf(); - if tx_buf.is_empty() { - state.tx_waker.register(cx.waker()); - return (Poll::Pending, empty); - } - - let n = core::cmp::min(tx_buf.len(), buf.len()); - tx_buf[..n].copy_from_slice(&buf[..n]); - state.tx.push(n); - - (Poll::Ready(Ok(n)), empty) - }); - if empty { - self.inner.pend(); - } - poll - } - - fn poll_flush( - mut self: Pin<&mut Self>, - cx: &mut Context<'_>, - ) -> Poll<Result<(), embassy::io::Error>> { - self.inner.with(|state| { - if !state.tx.is_empty() { - state.tx_waker.register(cx.waker()); - return Poll::Pending; - } - - Poll::Ready(Ok(())) - }) - } - } -} +#[cfg(feature = "nightly")] +mod buffered; #[cfg(usart_v1)] fn tdr(r: crate::pac::usart::Usart) -> *mut u8 { @@ -662,6 +445,7 @@ fn sr(r: crate::pac::usart::Usart) -> crate::pac::common::Reg<regs::Sr, crate::p } #[cfg(usart_v1)] +#[allow(unused)] unsafe fn clear_interrupt_flags(_r: crate::pac::usart::Usart, _sr: regs::Sr) { // On v1 the flags are cleared implicitly by reads and writes to DR. } @@ -682,6 +466,7 @@ fn sr(r: crate::pac::usart::Usart) -> crate::pac::common::Reg<regs::Ixr, crate:: } #[cfg(usart_v2)] +#[allow(unused)] unsafe fn clear_interrupt_flags(r: crate::pac::usart::Usart, sr: regs::Ixr) { r.icr().write(|w| *w = sr); } diff --git a/embassy/src/io/error.rs b/embassy/src/io/error.rs deleted file mode 100644 index 2092c0d1..00000000 --- a/embassy/src/io/error.rs +++ /dev/null @@ -1,142 +0,0 @@ -/// Categories of errors that can occur. -#[derive(Debug, Clone, Copy, PartialEq, Eq)] -#[cfg_attr(feature = "defmt", derive(defmt::Format))] -#[non_exhaustive] -pub enum Error { - /// An entity was not found, often a file. - NotFound, - /// The operation lacked the necessary privileges to complete. - PermissionDenied, - /// The connection was refused by the remote server. - ConnectionRefused, - /// The connection was reset by the remote server. - ConnectionReset, - /// The connection was aborted (terminated) by the remote server. - ConnectionAborted, - /// The network operation failed because it was not connected yet. - NotConnected, - /// A socket address could not be bound because the address is already in - /// use elsewhere. - AddrInUse, - /// A nonexistent interface was requested or the requested address was not - /// local. - AddrNotAvailable, - /// The operation failed because a pipe was closed. - BrokenPipe, - /// An entity already exists, often a file. - AlreadyExists, - /// The operation needs to block to complete, but the blocking operation was - /// requested to not occur. - WouldBlock, - /// A parameter was incorrect. - InvalidInput, - /// Data not valid for the operation were encountered. - /// - /// Unlike [`InvalidInput`], this typically means that the operation - /// parameters were valid, however the error was caused by malformed - /// input data. - /// - /// For example, a function that reads a file into a string will error with - /// `InvalidData` if the file's contents are not valid UTF-8. - /// - /// [`InvalidInput`]: #variant.InvalidInput - InvalidData, - /// The I/O operation's timeout expired, causing it to be canceled. - TimedOut, - /// An error returned when an operation could not be completed because a - /// call to [`write`] returned [`Ok(0)`]. - /// - /// This typically means that an operation could only succeed if it wrote a - /// particular number of bytes but only a smaller number of bytes could be - /// written. - /// - /// [`write`]: ../../std/io/trait.Write.html#tymethod.write - /// [`Ok(0)`]: ../../std/io/type.Result.html - WriteZero, - /// This operation was interrupted. - /// - /// Interrupted operations can typically be retried. - Interrupted, - - /// An error returned when an operation could not be completed because an - /// "end of file" was reached prematurely. - /// - /// This typically means that an operation could only succeed if it read a - /// particular number of bytes but only a smaller number of bytes could be - /// read. - UnexpectedEof, - - /// An operation would have read more data if the given buffer was large. - /// - /// This typically means that the buffer has been filled with the first N bytes - /// of the read data. - Truncated, - - /// Any I/O error not part of this list. - Other, -} - -pub type Result<T> = core::result::Result<T, Error>; - -#[cfg(feature = "std")] -impl From<std::io::Error> for Error { - fn from(err: std::io::Error) -> Error { - match err.kind() { - std::io::ErrorKind::NotFound => Error::NotFound, - std::io::ErrorKind::PermissionDenied => Error::PermissionDenied, - std::io::ErrorKind::ConnectionRefused => Error::ConnectionRefused, - std::io::ErrorKind::ConnectionReset => Error::ConnectionReset, - std::io::ErrorKind::ConnectionAborted => Error::ConnectionAborted, - std::io::ErrorKind::NotConnected => Error::NotConnected, - std::io::ErrorKind::AddrInUse => Error::AddrInUse, - std::io::ErrorKind::AddrNotAvailable => Error::AddrNotAvailable, - std::io::ErrorKind::BrokenPipe => Error::BrokenPipe, - std::io::ErrorKind::AlreadyExists => Error::AlreadyExists, - std::io::ErrorKind::WouldBlock => Error::WouldBlock, - std::io::ErrorKind::InvalidInput => Error::InvalidInput, - std::io::ErrorKind::InvalidData => Error::InvalidData, - std::io::ErrorKind::TimedOut => Error::TimedOut, - std::io::ErrorKind::WriteZero => Error::WriteZero, - std::io::ErrorKind::Interrupted => Error::Interrupted, - std::io::ErrorKind::UnexpectedEof => Error::UnexpectedEof, - _ => Error::Other, - } - } -} - -#[cfg(feature = "std")] -impl From<Error> for std::io::Error { - fn from(e: Error) -> Self { - let kind = match e { - Error::NotFound => std::io::ErrorKind::NotFound, - Error::PermissionDenied => std::io::ErrorKind::PermissionDenied, - Error::ConnectionRefused => std::io::ErrorKind::ConnectionRefused, - Error::ConnectionReset => std::io::ErrorKind::ConnectionReset, - Error::ConnectionAborted => std::io::ErrorKind::ConnectionAborted, - Error::NotConnected => std::io::ErrorKind::NotConnected, - Error::AddrInUse => std::io::ErrorKind::AddrInUse, - Error::AddrNotAvailable => std::io::ErrorKind::AddrNotAvailable, - Error::BrokenPipe => std::io::ErrorKind::BrokenPipe, - Error::AlreadyExists => std::io::ErrorKind::AlreadyExists, - Error::WouldBlock => std::io::ErrorKind::WouldBlock, - Error::InvalidInput => std::io::ErrorKind::InvalidInput, - Error::InvalidData => std::io::ErrorKind::InvalidData, - Error::TimedOut => std::io::ErrorKind::TimedOut, - Error::WriteZero => std::io::ErrorKind::WriteZero, - Error::Interrupted => std::io::ErrorKind::Interrupted, - Error::UnexpectedEof => std::io::ErrorKind::UnexpectedEof, - Error::Truncated => std::io::ErrorKind::Other, - Error::Other => std::io::ErrorKind::Other, - }; - std::io::Error::new(kind, "embassy::io::Error") - } -} - -impl core::fmt::Display for Error { - fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - write!(f, "{:?}", self) - } -} - -#[cfg(feature = "std")] -impl std::error::Error for Error {} diff --git a/embassy/src/io/mod.rs b/embassy/src/io/mod.rs deleted file mode 100644 index 52b05097..00000000 --- a/embassy/src/io/mod.rs +++ /dev/null @@ -1,11 +0,0 @@ -mod error; -#[cfg(feature = "std")] -mod std; -mod traits; -mod util; - -pub use self::error::*; -#[cfg(feature = "std")] -pub use self::std::*; -pub use self::traits::*; -pub use self::util::*; diff --git a/embassy/src/io/std.rs b/embassy/src/io/std.rs deleted file mode 100644 index 580d5289..00000000 --- a/embassy/src/io/std.rs +++ /dev/null @@ -1,41 +0,0 @@ -use core::pin::Pin; -use core::task::{Context, Poll}; -use futures::io as std_io; - -use super::{AsyncBufRead, AsyncWrite, Result}; - -pub struct FromStdIo<T>(T); - -impl<T> FromStdIo<T> { - pub fn new(inner: T) -> Self { - Self(inner) - } -} - -impl<T: std_io::AsyncBufRead> AsyncBufRead for FromStdIo<T> { - fn poll_fill_buf(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<&[u8]>> { - let Self(inner) = unsafe { self.get_unchecked_mut() }; - unsafe { Pin::new_unchecked(inner) } - .poll_fill_buf(cx) - .map_err(|e| e.into()) - } - fn consume(self: Pin<&mut Self>, amt: usize) { - let Self(inner) = unsafe { self.get_unchecked_mut() }; - unsafe { Pin::new_unchecked(inner) }.consume(amt) - } -} - -impl<T: std_io::AsyncWrite> AsyncWrite for FromStdIo<T> { - fn poll_write(self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &[u8]) -> Poll<Result<usize>> { - let Self(inner) = unsafe { self.get_unchecked_mut() }; - unsafe { Pin::new_unchecked(inner) } - .poll_write(cx, buf) - .map_err(|e| e.into()) - } - fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>> { - let Self(inner) = unsafe { self.get_unchecked_mut() }; - unsafe { Pin::new_unchecked(inner) } - .poll_flush(cx) - .map_err(|e| e.into()) - } -} diff --git a/embassy/src/io/traits.rs b/embassy/src/io/traits.rs deleted file mode 100644 index 06500a68..00000000 --- a/embassy/src/io/traits.rs +++ /dev/null @@ -1,175 +0,0 @@ -use core::ops::DerefMut; -use core::pin::Pin; -use core::task::{Context, Poll}; - -#[cfg(feature = "alloc")] -use alloc::boxed::Box; - -use super::error::Result; - -/// Read bytes asynchronously. -/// -/// This trait is analogous to the `std::io::BufRead` trait, but integrates -/// with the asynchronous task system. In particular, the `poll_fill_buf` -/// method, unlike `BufRead::fill_buf`, will automatically queue the current task -/// for wakeup and return if data is not yet available, rather than blocking -/// the calling thread. -pub trait AsyncBufRead { - /// Attempt to return the contents of the internal buffer, filling it with more data - /// from the inner reader if it is empty. - /// - /// On success, returns `Poll::Ready(Ok(buf))`. - /// - /// If no data is available for reading, the method returns - /// `Poll::Pending` and arranges for the current task (via - /// `cx.waker().wake_by_ref()`) to receive a notification when the object becomes - /// readable or is closed. - /// - /// This function is a lower-level call. It needs to be paired with the - /// [`consume`] method to function properly. When calling this - /// method, none of the contents will be "read" in the sense that later - /// calling [`poll_fill_buf`] may return the same contents. As such, [`consume`] must - /// be called with the number of bytes that are consumed from this buffer to - /// ensure that the bytes are never returned twice. - /// - /// [`poll_fill_buf`]: AsyncBufRead::poll_fill_buf - /// [`consume`]: AsyncBufRead::consume - /// - /// An empty buffer returned indicates that the stream has reached EOF. - /// - /// # Implementation - /// - /// This function may not return errors of kind `WouldBlock` or - /// `Interrupted`. Implementations must convert `WouldBlock` into - /// `Poll::Pending` and either internally retry or convert - /// `Interrupted` into another error kind. - fn poll_fill_buf(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<&[u8]>>; - - /// Tells this buffer that `amt` bytes have been consumed from the buffer, - /// so they should no longer be returned in calls to [`poll_fill_buf`]. - /// - /// This function is a lower-level call. It needs to be paired with the - /// [`poll_fill_buf`] method to function properly. This function does - /// not perform any I/O, it simply informs this object that some amount of - /// its buffer, returned from [`poll_fill_buf`], has been consumed and should - /// no longer be returned. As such, this function may do odd things if - /// [`poll_fill_buf`] isn't called before calling it. - /// - /// The `amt` must be `<=` the number of bytes in the buffer returned by - /// [`poll_fill_buf`]. - /// - /// [`poll_fill_buf`]: AsyncBufRead::poll_fill_buf - fn consume(self: Pin<&mut Self>, amt: usize); -} - -/// Write bytes asynchronously. -/// -/// This trait is analogous to the `core::io::Write` trait, but integrates -/// with the asynchronous task system. In particular, the `poll_write` -/// method, unlike `Write::write`, will automatically queue the current task -/// for wakeup and return if the writer cannot take more data, rather than blocking -/// the calling thread. -pub trait AsyncWrite { - /// Attempt to write bytes from `buf` into the object. - /// - /// On success, returns `Poll::Ready(Ok(num_bytes_written))`. - /// - /// If the object is not ready for writing, the method returns - /// `Poll::Pending` and arranges for the current task (via - /// `cx.waker().wake_by_ref()`) to receive a notification when the object becomes - /// writable or is closed. - /// - /// # Implementation - /// - /// This function may not return errors of kind `WouldBlock` or - /// `Interrupted`. Implementations must convert `WouldBlock` into - /// `Poll::Pending` and either internally retry or convert - /// `Interrupted` into another error kind. - /// - /// `poll_write` must try to make progress by flushing the underlying object if - /// that is the only way the underlying object can become writable again. - fn poll_write(self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &[u8]) -> Poll<Result<usize>>; - - /// Attempt to flush the object, ensuring that any buffered data reach their destination. - /// - /// On success, returns Poll::Ready(Ok(())). - /// - /// If flushing cannot immediately complete, this method returns [Poll::Pending] and arranges for the - /// current task (via cx.waker()) to receive a notification when the object can make progress - /// towards flushing. - fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>>; -} - -macro_rules! defer_async_read { - () => { - fn poll_fill_buf(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<&[u8]>> { - Pin::new(&mut **self.get_mut()).poll_fill_buf(cx) - } - - fn consume(mut self: Pin<&mut Self>, amt: usize) { - Pin::new(&mut **self).consume(amt) - } - }; -} - -#[cfg(feature = "alloc")] -impl<T: ?Sized + AsyncBufRead + Unpin> AsyncBufRead for Box<T> { - defer_async_read!(); -} - -impl<T: ?Sized + AsyncBufRead + Unpin> AsyncBufRead for &mut T { - defer_async_read!(); -} - -impl<P> AsyncBufRead for Pin<P> -where - P: DerefMut + Unpin, - P::Target: AsyncBufRead, -{ - fn poll_fill_buf(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<&[u8]>> { - self.get_mut().as_mut().poll_fill_buf(cx) - } - - fn consume(self: Pin<&mut Self>, amt: usize) { - self.get_mut().as_mut().consume(amt) - } -} - -macro_rules! deref_async_write { - () => { - fn poll_write( - mut self: Pin<&mut Self>, - cx: &mut Context<'_>, - buf: &[u8], - ) -> Poll<Result<usize>> { - Pin::new(&mut **self).poll_write(cx, buf) - } - - fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>> { - Pin::new(&mut **self).poll_flush(cx) - } - }; -} - -#[cfg(feature = "alloc")] -impl<T: ?Sized + AsyncWrite + Unpin> AsyncWrite for Box<T> { - deref_async_write!(); -} - -impl<T: ?Sized + AsyncWrite + Unpin> AsyncWrite for &mut T { - deref_async_write!(); -} - -impl<P> AsyncWrite for Pin<P> -where - P: DerefMut + Unpin, - P::Target: AsyncWrite, -{ - fn poll_write(self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &[u8]) -> Poll<Result<usize>> { - self.get_mut().as_mut().poll_write(cx, buf) - } - - fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>> { - self.get_mut().as_mut().poll_flush(cx) - } -} diff --git a/embassy/src/io/util/copy_buf.rs b/embassy/src/io/util/copy_buf.rs deleted file mode 100644 index 6d7932a0..00000000 --- a/embassy/src/io/util/copy_buf.rs +++ /dev/null @@ -1,80 +0,0 @@ -use core::future::Future; -use core::pin::Pin; -use core::task::{Context, Poll}; -use futures::ready; -use pin_project::pin_project; - -use crate::io::{AsyncBufRead, AsyncWrite, Error, Result}; - -/// Creates a future which copies all the bytes from one object to another. -/// -/// The returned future will copy all the bytes read from this `AsyncBufRead` into the -/// `writer` specified. This future will only complete once the `reader` has hit -/// EOF and all bytes have been written to and flushed from the `writer` -/// provided. -/// -/// On success the number of bytes is returned. -/// -/// # Examples -/// -/// ``` ignore -/// # futures::executor::block_on(async { -/// use futures::io::{self, AsyncWriteExt, Cursor}; -/// -/// let reader = Cursor::new([1, 2, 3, 4]); -/// let mut writer = Cursor::new(vec![0u8; 5]); -/// -/// let bytes = io::copy_buf(reader, &mut writer).await?; -/// writer.close().await?; -/// -/// assert_eq!(bytes, 4); -/// assert_eq!(writer.into_inner(), [1, 2, 3, 4, 0]); -/// # Ok::<(), Box<dyn std::error::Error>>(()) }).unwrap(); -/// ``` -pub fn copy_buf<R, W>(reader: R, writer: &mut W) -> CopyBuf<'_, R, W> -where - R: AsyncBufRead, - W: AsyncWrite + Unpin + ?Sized, -{ - CopyBuf { - reader, - writer, - amt: 0, - } -} - -/// Future for the [`copy_buf()`] function. -#[pin_project] -#[derive(Debug)] -#[must_use = "futures do nothing unless you `.await` or poll them"] -pub struct CopyBuf<'a, R, W: ?Sized> { - #[pin] - reader: R, - writer: &'a mut W, - amt: usize, -} - -impl<R, W> Future for CopyBuf<'_, R, W> -where - R: AsyncBufRead, - W: AsyncWrite + Unpin + ?Sized, -{ - type Output = Result<usize>; - - fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> { - let mut this = self.project(); - loop { - let buffer = ready!(this.reader.as_mut().poll_fill_buf(cx))?; - if buffer.is_empty() { - return Poll::Ready(Ok(*this.amt)); - } - - let i = ready!(Pin::new(&mut this.writer).poll_write(cx, buffer))?; - if i == 0 { - return Poll::Ready(Err(Error::WriteZero)); - } - *this.amt += i; - this.reader.as_mut().consume(i); - } - } -} diff --git a/embassy/src/io/util/drain.rs b/embassy/src/io/util/drain.rs deleted file mode 100644 index 2542876d..00000000 --- a/embassy/src/io/util/drain.rs +++ /dev/null @@ -1,41 +0,0 @@ -use core::pin::Pin; -use futures::future::Future; -use futures::task::{Context, Poll}; - -use super::super::error::Result; -use super::super::traits::AsyncBufRead; - -pub struct Drain<'a, R: ?Sized> { - reader: &'a mut R, -} - -impl<R: ?Sized + Unpin> Unpin for Drain<'_, R> {} - -impl<'a, R: AsyncBufRead + ?Sized + Unpin> Drain<'a, R> { - pub(super) fn new(reader: &'a mut R) -> Self { - Self { reader } - } -} - -impl<'a, R: AsyncBufRead + ?Sized + Unpin> Future for Drain<'a, R> { - type Output = Result<usize>; - - fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> { - let Self { reader } = &mut *self; - let mut reader = Pin::new(reader); - - let mut n = 0; - - loop { - match reader.as_mut().poll_fill_buf(cx) { - Poll::Pending => return Poll::Ready(Ok(n)), - Poll::Ready(Err(e)) => return Poll::Ready(Err(e)), - Poll::Ready(Ok(buf)) => { - let len = buf.len(); - n += len; - reader.as_mut().consume(len); - } - } - } - } -} diff --git a/embassy/src/io/util/flush.rs b/embassy/src/io/util/flush.rs deleted file mode 100644 index 966ef10f..00000000 --- a/embassy/src/io/util/flush.rs +++ /dev/null @@ -1,32 +0,0 @@ -use core::pin::Pin; -use futures::future::Future; -use futures::ready; -use futures::task::{Context, Poll}; - -use super::super::error::Result; -use super::super::traits::AsyncWrite; - -/// Future for the [`flush`](super::AsyncWriteExt::flush) method. -#[derive(Debug)] -#[must_use = "futures do nothing unless you `.await` or poll them"] -pub struct Flush<'a, W: ?Sized> { - writer: &'a mut W, -} - -impl<W: ?Sized + Unpin> Unpin for Flush<'_, W> {} - -impl<'a, W: AsyncWrite + ?Sized + Unpin> Flush<'a, W> { - pub(super) fn new(writer: &'a mut W) -> Self { - Flush { writer } - } -} - -impl<W: AsyncWrite + ?Sized + Unpin> Future for Flush<'_, W> { - type Output = Result<()>; - - fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>> { - let this = &mut *self; - let _ = ready!(Pin::new(&mut this.writer).poll_flush(cx))?; - Poll::Ready(Ok(())) - } -} diff --git a/embassy/src/io/util/mod.rs b/embassy/src/io/util/mod.rs deleted file mode 100644 index 49758ba9..00000000 --- a/embassy/src/io/util/mod.rs +++ /dev/null @@ -1,177 +0,0 @@ -use core::cmp::min; -use core::pin::Pin; -use core::task::{Context, Poll}; -use futures::ready; - -mod read; -pub use self::read::Read; - -mod read_buf; -pub use self::read_buf::ReadBuf; - -mod read_byte; -pub use self::read_byte::ReadByte; - -mod read_exact; -pub use self::read_exact::ReadExact; - -mod read_while; -pub use self::read_while::ReadWhile; - -mod read_to_end; -pub use self::read_to_end::ReadToEnd; - -mod skip_while; -pub use self::skip_while::SkipWhile; - -mod drain; -pub use self::drain::Drain; - -mod flush; -pub use self::flush::Flush; - -mod write; -pub use self::write::Write; - -mod write_all; -pub use self::write_all::WriteAll; - -mod write_byte; -pub use self::write_byte::WriteByte; - -#[cfg(feature = "alloc")] -mod split; -#[cfg(feature = "alloc")] -pub use self::split::{split, ReadHalf, WriteHalf}; - -mod copy_buf; -pub use self::copy_buf::{copy_buf, CopyBuf}; - -use super::error::Result; -use super::traits::{AsyncBufRead, AsyncWrite}; - -pub trait AsyncBufReadExt: AsyncBufRead { - fn poll_read( - mut self: Pin<&mut Self>, - cx: &mut Context<'_>, - buf: &mut [u8], - ) -> Poll<Result<usize>> - where - Self: Unpin, - { - let mut this = &mut *self; - let rbuf = ready!(Pin::new(&mut this).poll_fill_buf(cx))?; - let n = min(buf.len(), rbuf.len()); - buf[..n].copy_from_slice(&rbuf[..n]); - Pin::new(&mut this).consume(n); - Poll::Ready(Ok(n)) - } - - fn read_while<'a, F: Fn(u8) -> bool>( - &'a mut self, - buf: &'a mut [u8], - f: F, - ) -> ReadWhile<'a, Self, F> - where - Self: Unpin, - { - ReadWhile::new(self, f, buf) - } - - fn skip_while<F: Fn(u8) -> bool>(&mut self, f: F) -> SkipWhile<Self, F> - where - Self: Unpin, - { - SkipWhile::new(self, f) - } - - fn drain(&mut self) -> Drain<Self> - where - Self: Unpin, - { - Drain::new(self) - } - - fn read<'a>(&'a mut self, buf: &'a mut [u8]) -> Read<'a, Self> - where - Self: Unpin, - { - Read::new(self, buf) - } - - fn read_buf(&mut self) -> ReadBuf<Self> - where - Self: Unpin, - { - ReadBuf::new(self) - } - - fn read_byte(&mut self) -> ReadByte<Self> - where - Self: Unpin, - { - ReadByte::new(self) - } - - fn read_exact<'a>(&'a mut self, buf: &'a mut [u8]) -> ReadExact<'a, Self> - where - Self: Unpin, - { - ReadExact::new(self, buf) - } - - fn read_to_end<'a>(&'a mut self, buf: &'a mut [u8]) -> ReadToEnd<'a, Self> - where - Self: Unpin, - { - ReadToEnd::new(self, buf) - } -} - -impl<R: AsyncBufRead + ?Sized> AsyncBufReadExt for R {} - -pub async fn read_line<R: AsyncBufRead + Unpin + ?Sized>( - r: &mut R, - buf: &mut [u8], -) -> Result<usize> { - r.skip_while(|b| b == b'\r' || b == b'\n').await?; - let n = r.read_while(buf, |b| b != b'\r' && b != b'\n').await?; - r.skip_while(|b| b == b'\r').await?; - //assert_eq!(b'\n', r.read_byte().await?); - r.read_byte().await?; - Ok(n) -} - -pub trait AsyncWriteExt: AsyncWrite { - fn write_all<'a>(&'a mut self, buf: &'a [u8]) -> WriteAll<'a, Self> - where - Self: Unpin, - { - WriteAll::new(self, buf) - } - - fn write_byte(&mut self, byte: u8) -> WriteByte<Self> - where - Self: Unpin, - { - WriteByte::new(self, byte) - } - - fn write<'a>(&'a mut self, buf: &'a [u8]) -> Write<'a, Self> - where - Self: Unpin, - { - Write::new(self, buf) - } - - /// Awaits until all bytes have actually been written, and - /// not just enqueued as per the other "write" methods. - fn flush<'a>(&mut self) -> Flush<Self> - where - Self: Unpin, - { - Flush::new(self) - } -} - -impl<R: AsyncWrite + ?Sized> AsyncWriteExt for R {} diff --git a/embassy/src/io/util/read.rs b/embassy/src/io/util/read.rs deleted file mode 100644 index 274b43a4..00000000 --- a/embassy/src/io/util/read.rs +++ /dev/null @@ -1,39 +0,0 @@ -use super::super::error::Result; -use super::super::traits::AsyncBufRead; - -use core::cmp::min; - -use core::pin::Pin; -use futures::future::Future; -use futures::ready; -use futures::task::{Context, Poll}; - -/// Future for the [`read_exact`](super::AsyncBufReadExt::read_exact) method. -#[derive(Debug)] -#[must_use = "futures do nothing unless you `.await` or poll them"] -pub struct Read<'a, R: ?Sized> { - reader: &'a mut R, - buf: &'a mut [u8], -} - -impl<R: ?Sized + Unpin> Unpin for Read<'_, R> {} - -impl<'a, R: AsyncBufRead + ?Sized + Unpin> Read<'a, R> { - pub(super) fn new(reader: &'a mut R, buf: &'a mut [u8]) -> Self { - Read { reader, buf } - } -} - -impl<R: AsyncBufRead + ?Sized + Unpin> Future for Read<'_, R> { - type Output = Result<usize>; - - fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> { - let this = &mut *self; - let buf = ready!(Pin::new(&mut this.reader).poll_fill_buf(cx))?; - - let n = min(this.buf.len(), buf.len()); - this.buf[..n].copy_from_slice(&buf[..n]); - Pin::new(&mut this.reader).consume(n); - Poll::Ready(Ok(n)) - } -} diff --git a/embassy/src/io/util/read_buf.rs b/embassy/src/io/util/read_buf.rs deleted file mode 100644 index 71299b05..00000000 --- a/embassy/src/io/util/read_buf.rs +++ /dev/null @@ -1,34 +0,0 @@ -use super::super::error::Result; -use super::super::traits::AsyncBufRead; - -use core::pin::Pin; -use futures::future::Future; -use futures::ready; -use futures::task::{Context, Poll}; - -pub struct ReadBuf<'a, R: ?Sized> { - reader: Option<&'a mut R>, -} - -impl<R: ?Sized + Unpin> Unpin for ReadBuf<'_, R> {} - -impl<'a, R: AsyncBufRead + ?Sized + Unpin> ReadBuf<'a, R> { - pub(super) fn new(reader: &'a mut R) -> Self { - ReadBuf { - reader: Some(reader), - } - } -} - -impl<'a, R: AsyncBufRead + ?Sized + Unpin> Future for ReadBuf<'a, R> { - type Output = Result<&'a [u8]>; - - fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> { - let this = &mut *self; - - let buf = ready!(Pin::new(this.reader.as_mut().unwrap()).poll_fill_buf(cx))?; - let buf: &'a [u8] = unsafe { core::mem::transmute(buf) }; - this.reader = None; - Poll::Ready(Ok(buf)) - } -} diff --git a/embassy/src/io/util/read_byte.rs b/embassy/src/io/util/read_byte.rs deleted file mode 100644 index e5bbcb1f..00000000 --- a/embassy/src/io/util/read_byte.rs +++ /dev/null @@ -1,36 +0,0 @@ -use core::pin::Pin; -use futures::future::Future; -use futures::ready; -use futures::task::{Context, Poll}; - -use super::super::error::{Error, Result}; -use super::super::traits::AsyncBufRead; - -pub struct ReadByte<'a, R: ?Sized> { - reader: &'a mut R, -} - -impl<R: ?Sized + Unpin> Unpin for ReadByte<'_, R> {} - -impl<'a, R: AsyncBufRead + ?Sized + Unpin> ReadByte<'a, R> { - pub(super) fn new(reader: &'a mut R) -> Self { - Self { reader } - } -} - -impl<'a, R: AsyncBufRead + ?Sized + Unpin> Future for ReadByte<'a, R> { - type Output = Result<u8>; - - fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> { - let Self { reader } = &mut *self; - let mut reader = Pin::new(reader); - let rbuf = ready!(reader.as_mut().poll_fill_buf(cx))?; - if rbuf.is_empty() { - return Poll::Ready(Err(Error::UnexpectedEof)); - } - - let r = rbuf[0]; - reader.as_mut().consume(1); - Poll::Ready(Ok(r)) - } -} diff --git a/embassy/src/io/util/read_exact.rs b/embassy/src/io/util/read_exact.rs deleted file mode 100644 index 4eecba4c..00000000 --- a/embassy/src/io/util/read_exact.rs +++ /dev/null @@ -1,48 +0,0 @@ -use super::super::error::{Error, Result}; -use super::super::traits::AsyncBufRead; - -use core::cmp::min; -use core::mem; -use core::pin::Pin; -use futures::future::Future; -use futures::ready; -use futures::task::{Context, Poll}; - -/// Future for the [`read_exact`](super::AsyncBufReadExt::read_exact) method. -#[derive(Debug)] -#[must_use = "futures do nothing unless you `.await` or poll them"] -pub struct ReadExact<'a, R: ?Sized> { - reader: &'a mut R, - buf: &'a mut [u8], -} - -impl<R: ?Sized + Unpin> Unpin for ReadExact<'_, R> {} - -impl<'a, R: AsyncBufRead + ?Sized + Unpin> ReadExact<'a, R> { - pub(super) fn new(reader: &'a mut R, buf: &'a mut [u8]) -> Self { - ReadExact { reader, buf } - } -} - -impl<R: AsyncBufRead + ?Sized + Unpin> Future for ReadExact<'_, R> { - type Output = Result<()>; - - fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> { - let this = &mut *self; - while !this.buf.is_empty() { - let buf = ready!(Pin::new(&mut this.reader).poll_fill_buf(cx))?; - if buf.is_empty() { - return Poll::Ready(Err(Error::UnexpectedEof)); - } - - let n = min(this.buf.len(), buf.len()); - this.buf[..n].copy_from_slice(&buf[..n]); - Pin::new(&mut this.reader).consume(n); - { - let (_, rest) = mem::take(&mut this.buf).split_at_mut(n); - this.buf = rest; - } - } - Poll::Ready(Ok(())) - } -} diff --git a/embassy/src/io/util/read_to_end.rs b/embassy/src/io/util/read_to_end.rs deleted file mode 100644 index d09999ad..00000000 --- a/embassy/src/io/util/read_to_end.rs +++ /dev/null @@ -1,48 +0,0 @@ -use core::cmp::min; -use core::pin::Pin; -use futures::future::Future; -use futures::ready; -use futures::task::{Context, Poll}; - -use super::super::error::{Error, Result}; -use super::super::traits::AsyncBufRead; - -pub struct ReadToEnd<'a, R: ?Sized> { - reader: &'a mut R, - buf: &'a mut [u8], - n: usize, -} - -impl<R: ?Sized + Unpin> Unpin for ReadToEnd<'_, R> {} - -impl<'a, R: AsyncBufRead + ?Sized + Unpin> ReadToEnd<'a, R> { - pub(super) fn new(reader: &'a mut R, buf: &'a mut [u8]) -> Self { - Self { reader, buf, n: 0 } - } -} - -impl<'a, R: AsyncBufRead + ?Sized + Unpin> Future for ReadToEnd<'a, R> { - type Output = Result<usize>; - - fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> { - let Self { reader, buf, n } = &mut *self; - let mut reader = Pin::new(reader); - loop { - let rbuf = ready!(reader.as_mut().poll_fill_buf(cx))?; - if rbuf.is_empty() { - return Poll::Ready(Ok(*n)); - } - - if *n == buf.len() { - return Poll::Ready(Err(Error::Truncated)); - } - - // truncate data if it doesn't fit in buf - let p = min(rbuf.len(), buf.len() - *n); - buf[*n..*n + p].copy_from_slice(&rbuf[..p]); - *n += p; - - reader.as_mut().consume(p); - } - } -} diff --git a/embassy/src/io/util/read_while.rs b/embassy/src/io/util/read_while.rs deleted file mode 100644 index e2463803..00000000 --- a/embassy/src/io/util/read_while.rs +++ /dev/null @@ -1,61 +0,0 @@ -use core::cmp::min; -use core::pin::Pin; -use futures::future::Future; -use futures::ready; -use futures::task::{Context, Poll}; - -use super::super::error::{Error, Result}; -use super::super::traits::AsyncBufRead; - -pub struct ReadWhile<'a, R: ?Sized, F> { - reader: &'a mut R, - buf: &'a mut [u8], - n: usize, - f: F, -} - -impl<R: ?Sized + Unpin, F> Unpin for ReadWhile<'_, R, F> {} - -impl<'a, R: AsyncBufRead + ?Sized + Unpin, F: Fn(u8) -> bool> ReadWhile<'a, R, F> { - pub(super) fn new(reader: &'a mut R, f: F, buf: &'a mut [u8]) -> Self { - Self { - reader, - f, - buf, - n: 0, - } - } -} - -impl<'a, R: AsyncBufRead + ?Sized + Unpin, F: Fn(u8) -> bool> Future for ReadWhile<'a, R, F> { - type Output = Result<usize>; - - fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> { - let Self { reader, f, buf, n } = &mut *self; - let mut reader = Pin::new(reader); - loop { - let rbuf = ready!(reader.as_mut().poll_fill_buf(cx))?; - if rbuf.is_empty() { - return Poll::Ready(Err(Error::UnexpectedEof)); - } - - let (p, done) = match rbuf.iter().position(|&b| !f(b)) { - Some(p) => (p, true), - None => (rbuf.len(), false), - }; - - // truncate data if it doesn't fit in buf - let p2 = min(p, buf.len() - *n); - buf[*n..*n + p2].copy_from_slice(&rbuf[..p2]); - *n += p2; - - // consume it all, even if it doesn't fit. - // Otherwise we can deadlock because we never read to the ending char - reader.as_mut().consume(p); - - if done { - return Poll::Ready(Ok(*n)); - } - } - } -} diff --git a/embassy/src/io/util/skip_while.rs b/embassy/src/io/util/skip_while.rs deleted file mode 100644 index 6f0e167d..00000000 --- a/embassy/src/io/util/skip_while.rs +++ /dev/null @@ -1,45 +0,0 @@ -use core::iter::Iterator; -use core::pin::Pin; -use futures::future::Future; -use futures::ready; -use futures::task::{Context, Poll}; - -use super::super::error::{Error, Result}; -use super::super::traits::AsyncBufRead; - -pub struct SkipWhile<'a, R: ?Sized, F> { - reader: &'a mut R, - f: F, -} - -impl<R: ?Sized + Unpin, F> Unpin for SkipWhile<'_, R, F> {} - -impl<'a, R: AsyncBufRead + ?Sized + Unpin, F: Fn(u8) -> bool> SkipWhile<'a, R, F> { - pub(super) fn new(reader: &'a mut R, f: F) -> Self { - Self { reader, f } - } -} - -impl<'a, R: AsyncBufRead + ?Sized + Unpin, F: Fn(u8) -> bool> Future for SkipWhile<'a, R, F> { - type Output = Result<()>; - - fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> { - let Self { reader, f } = &mut *self; - let mut reader = Pin::new(reader); - loop { - let buf = ready!(reader.as_mut().poll_fill_buf(cx))?; - if buf.is_empty() { - return Poll::Ready(Err(Error::UnexpectedEof)); - } - - let (p, done) = match buf.iter().position(|b| !f(*b)) { - Some(p) => (p, true), - None => (buf.len(), false), - }; - reader.as_mut().consume(p); - if done { - return Poll::Ready(Ok(())); - } - } - } -} diff --git a/embassy/src/io/util/split.rs b/embassy/src/io/util/split.rs deleted file mode 100644 index cc029aa5..00000000 --- a/embassy/src/io/util/split.rs +++ /dev/null @@ -1,43 +0,0 @@ -use alloc::rc::Rc; -use core::cell::UnsafeCell; -use core::pin::Pin; -use futures::task::{Context, Poll}; - -use super::super::error::Result; -use super::super::traits::{AsyncBufRead, AsyncWrite}; - -/// The readable half of an object returned from `AsyncBufRead::split`. -#[derive(Debug)] -pub struct ReadHalf<T> { - handle: Rc<UnsafeCell<T>>, -} - -/// The writable half of an object returned from `AsyncBufRead::split`. -#[derive(Debug)] -pub struct WriteHalf<T> { - handle: Rc<UnsafeCell<T>>, -} - -impl<T: AsyncBufRead + Unpin> AsyncBufRead for ReadHalf<T> { - fn poll_fill_buf(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<&[u8]>> { - Pin::new(unsafe { &mut *self.handle.get() }).poll_fill_buf(cx) - } - - fn consume(self: Pin<&mut Self>, amt: usize) { - Pin::new(unsafe { &mut *self.handle.get() }).consume(amt) - } -} - -impl<T: AsyncWrite + Unpin> AsyncWrite for WriteHalf<T> { - fn poll_write(self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &[u8]) -> Poll<Result<usize>> { - Pin::new(unsafe { &mut *self.handle.get() }).poll_write(cx, buf) - } - fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>> { - Pin::new(unsafe { &mut *self.handle.get() }).poll_flush(cx) - } -} - -pub fn split<T: AsyncBufRead + AsyncWrite>(t: T) -> (ReadHalf<T>, WriteHalf<T>) { - let c = Rc::new(UnsafeCell::new(t)); - (ReadHalf { handle: c.clone() }, WriteHalf { handle: c }) -} diff --git a/embassy/src/io/util/write.rs b/embassy/src/io/util/write.rs deleted file mode 100644 index 403cd59f..00000000 --- a/embassy/src/io/util/write.rs +++ /dev/null @@ -1,33 +0,0 @@ -use core::pin::Pin; -use futures::future::Future; -use futures::ready; -use futures::task::{Context, Poll}; - -use super::super::error::Result; -use super::super::traits::AsyncWrite; - -/// Future for the [`write_all`](super::AsyncWriteExt::write_all) method. -#[derive(Debug)] -#[must_use = "futures do nothing unless you `.await` or poll them"] -pub struct Write<'a, W: ?Sized> { - writer: &'a mut W, - buf: &'a [u8], -} - -impl<W: ?Sized + Unpin> Unpin for Write<'_, W> {} - -impl<'a, W: AsyncWrite + ?Sized + Unpin> Write<'a, W> { - pub(super) fn new(writer: &'a mut W, buf: &'a [u8]) -> Self { - Write { writer, buf } - } -} - -impl<W: AsyncWrite + ?Sized + Unpin> Future for Write<'_, W> { - type Output = Result<usize>; - - fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<usize>> { - let this = &mut *self; - let n = ready!(Pin::new(&mut this.writer).poll_write(cx, this.buf))?; - Poll::Ready(Ok(n)) - } -} diff --git a/embassy/src/io/util/write_all.rs b/embassy/src/io/util/write_all.rs deleted file mode 100644 index 8a7d9984..00000000 --- a/embassy/src/io/util/write_all.rs +++ /dev/null @@ -1,44 +0,0 @@ -use core::mem; -use core::pin::Pin; -use futures::future::Future; -use futures::ready; -use futures::task::{Context, Poll}; - -use super::super::error::Result; -use super::super::traits::AsyncWrite; - -/// Future for the [`write_all`](super::AsyncWriteExt::write_all) method. -#[derive(Debug)] -#[must_use = "futures do nothing unless you `.await` or poll them"] -pub struct WriteAll<'a, W: ?Sized> { - writer: &'a mut W, - buf: &'a [u8], -} - -impl<W: ?Sized + Unpin> Unpin for WriteAll<'_, W> {} - -impl<'a, W: AsyncWrite + ?Sized + Unpin> WriteAll<'a, W> { - pub(super) fn new(writer: &'a mut W, buf: &'a [u8]) -> Self { - WriteAll { writer, buf } - } -} - -impl<W: AsyncWrite + ?Sized + Unpin> Future for WriteAll<'_, W> { - type Output = Result<()>; - - fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>> { - let this = &mut *self; - while !this.buf.is_empty() { - let n = ready!(Pin::new(&mut this.writer).poll_write(cx, this.buf))?; - { - let (_, rest) = mem::take(&mut this.buf).split_at(n); - this.buf = rest; - } - if n == 0 { - panic!(); - } - } - - Poll::Ready(Ok(())) - } -} diff --git a/embassy/src/io/util/write_byte.rs b/embassy/src/io/util/write_byte.rs deleted file mode 100644 index 659e427b..00000000 --- a/embassy/src/io/util/write_byte.rs +++ /dev/null @@ -1,39 +0,0 @@ -use core::pin::Pin; -use futures::future::Future; -use futures::ready; -use futures::task::{Context, Poll}; - -use super::super::error::Result; -use super::super::traits::AsyncWrite; - -/// Future for the [`write_all`](super::AsyncWriteExt::write_all) method. -#[derive(Debug)] -#[must_use = "futures do nothing unless you `.await` or poll them"] -pub struct WriteByte<'a, W: ?Sized> { - writer: &'a mut W, - byte: u8, -} - -impl<W: ?Sized + Unpin> Unpin for WriteByte<'_, W> {} - -impl<'a, W: AsyncWrite + ?Sized + Unpin> WriteByte<'a, W> { - pub(super) fn new(writer: &'a mut W, byte: u8) -> Self { - WriteByte { writer, byte } - } -} - -impl<W: AsyncWrite + ?Sized + Unpin> Future for WriteByte<'_, W> { - type Output = Result<()>; - - fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>> { - let this = &mut *self; - let buf = [this.byte; 1]; - let n = ready!(Pin::new(&mut this.writer).poll_write(cx, &buf))?; - if n == 0 { - panic!(); - } - assert!(n == 1); - - Poll::Ready(Ok(())) - } -} diff --git a/embassy/src/lib.rs b/embassy/src/lib.rs index ec697b40..087bd357 100644 --- a/embassy/src/lib.rs +++ b/embassy/src/lib.rs @@ -13,7 +13,6 @@ pub mod channel; pub mod executor; #[cfg(cortex_m)] pub mod interrupt; -pub mod io; pub mod mutex; #[cfg(feature = "time")] pub mod time; diff --git a/examples/nrf/Cargo.toml b/examples/nrf/Cargo.toml index 4258544f..ffac0a76 100644 --- a/examples/nrf/Cargo.toml +++ b/examples/nrf/Cargo.toml @@ -6,7 +6,7 @@ version = "0.1.0" [features] default = ["nightly"] -nightly = ["embassy-nrf/nightly", "embassy-nrf/unstable-traits", "embassy-usb", "embassy-usb-serial", "embassy-usb-hid", "embassy-usb-ncm"] +nightly = ["embassy-nrf/nightly", "embassy-nrf/unstable-traits", "embassy-usb", "embassy-usb-serial", "embassy-usb-hid", "embassy-usb-ncm", "embedded-io/async", "embassy-net/nightly"] [dependencies] embassy = { version = "0.1.0", path = "../../embassy", features = ["defmt", "defmt-timestamp-uptime"] } @@ -16,6 +16,7 @@ embassy-usb = { version = "0.1.0", path = "../../embassy-usb", features = ["defm embassy-usb-serial = { version = "0.1.0", path = "../../embassy-usb-serial", features = ["defmt"], optional = true } embassy-usb-hid = { version = "0.1.0", path = "../../embassy-usb-hid", features = ["defmt"], optional = true } embassy-usb-ncm = { version = "0.1.0", path = "../../embassy-usb-ncm", features = ["defmt"], optional = true } +embedded-io = "0.2.0" defmt = "0.3" defmt-rtt = "0.3" diff --git a/examples/nrf/src/bin/buffered_uart.rs b/examples/nrf/src/bin/buffered_uart.rs index 2cd163a9..a64c5821 100644 --- a/examples/nrf/src/bin/buffered_uart.rs +++ b/examples/nrf/src/bin/buffered_uart.rs @@ -4,9 +4,9 @@ use defmt::*; use embassy::executor::Spawner; -use embassy::io::{AsyncBufReadExt, AsyncWriteExt}; use embassy_nrf::buffered_uarte::State; use embassy_nrf::{buffered_uarte::BufferedUarte, interrupt, uarte, Peripherals}; +use embedded_io::asynch::{Read, Write}; use futures::pin_mut; use defmt_rtt as _; // global logger diff --git a/examples/nrf/src/bin/usb_ethernet.rs b/examples/nrf/src/bin/usb_ethernet.rs index f14a29c4..843487c0 100644 --- a/examples/nrf/src/bin/usb_ethernet.rs +++ b/examples/nrf/src/bin/usb_ethernet.rs @@ -10,9 +10,9 @@ use defmt::*; use embassy::blocking_mutex::raw::ThreadModeRawMutex; use embassy::channel::Channel; use embassy::executor::Spawner; -use embassy::io::{AsyncBufReadExt, AsyncWriteExt}; use embassy::util::Forever; -use embassy_net::{PacketBox, PacketBoxExt, PacketBuf, TcpSocket}; +use embassy_net::tcp::TcpSocket; +use embassy_net::{PacketBox, PacketBoxExt, PacketBuf}; use embassy_nrf::pac; use embassy_nrf::usb::Driver; use embassy_nrf::Peripherals; @@ -20,7 +20,9 @@ use embassy_nrf::{interrupt, peripherals}; use embassy_usb::{Builder, Config, UsbDevice}; use embassy_usb_ncm::{CdcNcmClass, Receiver, Sender, State}; -use defmt_rtt as _; // global logger +use defmt_rtt as _; +use embedded_io::asynch::{Read, Write}; +// global logger use panic_probe as _; type MyDriver = Driver<'static, peripherals::USBD>; diff --git a/examples/std/Cargo.toml b/examples/std/Cargo.toml index 0853c323..fa2a98a4 100644 --- a/examples/std/Cargo.toml +++ b/examples/std/Cargo.toml @@ -6,7 +6,8 @@ version = "0.1.0" [dependencies] embassy = { version = "0.1.0", path = "../../embassy", features = ["log", "std", "time", "nightly"] } -embassy-net = { version = "0.1.0", path = "../../embassy-net", features=["std", "log", "medium-ethernet", "tcp", "dhcpv4", "pool-16"] } +embassy-net = { version = "0.1.0", path = "../../embassy-net", features=["nightly", "std", "log", "medium-ethernet", "tcp", "dhcpv4", "pool-16"] } +embedded-io = { version = "0.2.0", features = ["async", "std"] } async-io = "1.6.0" env_logger = "0.9.0" diff --git a/examples/std/src/bin/net.rs b/examples/std/src/bin/net.rs index 3b4bc6fe..daedffb0 100644 --- a/examples/std/src/bin/net.rs +++ b/examples/std/src/bin/net.rs @@ -2,12 +2,13 @@ use clap::Parser; use embassy::executor::{Executor, Spawner}; -use embassy::io::AsyncWriteExt; use embassy::util::Forever; +use embassy_net::tcp::TcpSocket; use embassy_net::{ Config, Configurator, DhcpConfigurator, Ipv4Address, Ipv4Cidr, StackResources, - StaticConfigurator, TcpSocket, + StaticConfigurator, }; +use embedded_io::asynch::Write; use heapless::Vec; use log::*; diff --git a/examples/std/src/bin/serial.rs b/examples/std/src/bin/serial.rs index 129dc209..b1e5b014 100644 --- a/examples/std/src/bin/serial.rs +++ b/examples/std/src/bin/serial.rs @@ -5,8 +5,8 @@ mod serial_port; use async_io::Async; use embassy::executor::Executor; -use embassy::io::AsyncBufReadExt; use embassy::util::Forever; +use embedded_io::asynch::Read; use log::*; use nix::sys::termios; @@ -24,12 +24,12 @@ async fn run() { // Essentially, async_io::Async converts from AsRawFd+Read+Write to futures's AsyncRead+AsyncWrite let port = Async::new(port).unwrap(); - // This implements futures's AsyncBufRead based on futures's AsyncRead - let port = futures::io::BufReader::new(port); - - // We can then use FromStdIo to convert from futures's AsyncBufRead+AsyncWrite - // to embassy's AsyncBufRead+AsyncWrite - let mut port = embassy::io::FromStdIo::new(port); + // We can then use FromStdIo to convert from futures's AsyncRead+AsyncWrite + // to embedded_io's async Read+Write. + // + // This is not really needed, you could write the code below using futures::io directly. + // It's useful if you want to have portable code across embedded and std. + let mut port = embedded_io::adapters::FromFutures::new(port); info!("Serial opened!"); diff --git a/examples/stm32f7/Cargo.toml b/examples/stm32f7/Cargo.toml index 09a06aa7..bbeee179 100644 --- a/examples/stm32f7/Cargo.toml +++ b/examples/stm32f7/Cargo.toml @@ -9,6 +9,7 @@ resolver = "2" embassy = { version = "0.1.0", path = "../../embassy", features = ["defmt", "defmt-timestamp-uptime"] } embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["nightly", "defmt", "net", "stm32f767zi", "unstable-pac", "time-driver-any", "exti"] } embassy-net = { path = "../../embassy-net", features = ["defmt", "tcp", "medium-ethernet", "pool-16"] } +embedded-io = { version = "0.2.0", features = ["async"] } defmt = "0.3" defmt-rtt = "0.3" diff --git a/examples/stm32f7/src/bin/eth.rs b/examples/stm32f7/src/bin/eth.rs index 33e41de9..dca9338b 100644 --- a/examples/stm32f7/src/bin/eth.rs +++ b/examples/stm32f7/src/bin/eth.rs @@ -5,12 +5,10 @@ use cortex_m_rt::entry; use defmt::*; use embassy::executor::{Executor, Spawner}; -use embassy::io::AsyncWriteExt; use embassy::time::{Duration, Timer}; use embassy::util::Forever; -use embassy_net::{ - Config as NetConfig, Ipv4Address, Ipv4Cidr, StackResources, StaticConfigurator, TcpSocket, -}; +use embassy_net::tcp::TcpSocket; +use embassy_net::{Config as NetConfig, Ipv4Address, Ipv4Cidr, StackResources, StaticConfigurator}; use embassy_stm32::eth::generic_smi::GenericSMI; use embassy_stm32::eth::{Ethernet, State}; use embassy_stm32::interrupt; @@ -19,6 +17,7 @@ use embassy_stm32::peripherals::RNG; use embassy_stm32::rng::Rng; use embassy_stm32::time::U32Ext; use embassy_stm32::Config; +use embedded_io::asynch::Write; use heapless::Vec; use defmt_rtt as _; // global logger diff --git a/examples/stm32h7/Cargo.toml b/examples/stm32h7/Cargo.toml index 419bbec3..ff70e6db 100644 --- a/examples/stm32h7/Cargo.toml +++ b/examples/stm32h7/Cargo.toml @@ -5,12 +5,11 @@ name = "embassy-stm32h7-examples" version = "0.1.0" resolver = "2" -[features] - [dependencies] embassy = { version = "0.1.0", path = "../../embassy", features = ["defmt", "defmt-timestamp-uptime", "unstable-traits"] } embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["nightly", "defmt", "stm32h743bi", "net", "time-driver-any", "exti", "unstable-pac", "unstable-traits"] } embassy-net = { path = "../../embassy-net", features = ["defmt", "tcp", "medium-ethernet", "pool-16"] } +embedded-io = { version = "0.2.0", features = ["async"] } defmt = "0.3" defmt-rtt = "0.3" diff --git a/examples/stm32h7/src/bin/eth.rs b/examples/stm32h7/src/bin/eth.rs index 9a2e7a33..8ece2940 100644 --- a/examples/stm32h7/src/bin/eth.rs +++ b/examples/stm32h7/src/bin/eth.rs @@ -8,12 +8,10 @@ use panic_probe as _; use cortex_m_rt::entry; use defmt::*; use embassy::executor::{Executor, Spawner}; -use embassy::io::AsyncWriteExt; use embassy::time::{Duration, Timer}; use embassy::util::Forever; -use embassy_net::{ - Config as NetConfig, Ipv4Address, Ipv4Cidr, StackResources, StaticConfigurator, TcpSocket, -}; +use embassy_net::tcp::TcpSocket; +use embassy_net::{Config as NetConfig, Ipv4Address, Ipv4Cidr, StackResources, StaticConfigurator}; use embassy_stm32::eth::generic_smi::GenericSMI; use embassy_stm32::eth::{Ethernet, State}; use embassy_stm32::interrupt; @@ -22,6 +20,7 @@ use embassy_stm32::peripherals::RNG; use embassy_stm32::rng::Rng; use embassy_stm32::time::U32Ext; use embassy_stm32::Config; +use embedded_io::asynch::Write; use heapless::Vec; #[embassy::task] diff --git a/examples/stm32l0/.cargo/config.toml b/examples/stm32l0/.cargo/config.toml index 840faa62..ec0b931f 100644 --- a/examples/stm32l0/.cargo/config.toml +++ b/examples/stm32l0/.cargo/config.toml @@ -1,6 +1,6 @@ [target.'cfg(all(target_arch = "arm", target_os = "none"))'] # replace your chip as listed in `probe-run --list-chips` -runner = "probe-run --chip STM32L072CZTx" +runner = "probe-run --chip STM32L053R8Tx" [build] target = "thumbv6m-none-eabi" diff --git a/examples/stm32l0/Cargo.toml b/examples/stm32l0/Cargo.toml index 1cdb2f37..d6848c27 100644 --- a/examples/stm32l0/Cargo.toml +++ b/examples/stm32l0/Cargo.toml @@ -7,12 +7,11 @@ resolver = "2" [features] default = ["nightly"] -nightly = ["embassy-stm32/nightly", "embassy-lora", "lorawan-device", "lorawan"] +nightly = ["embassy-stm32/nightly", "embassy-lora", "lorawan-device", "lorawan", "embedded-io/async"] [dependencies] embassy = { version = "0.1.0", path = "../../embassy", features = ["defmt", "defmt-timestamp-uptime"] } embassy-stm32 = { version = "0.1.0", path = "../../embassy-stm32", features = ["defmt", "stm32l072cz", "time-driver-any", "exti", "unstable-traits", "memory-x"] } - embassy-lora = { version = "0.1.0", path = "../../embassy-lora", features = ["sx127x", "time", "defmt"], optional = true} lorawan-device = { version = "0.7.1", default-features = false, features = ["async"], optional = true } @@ -22,6 +21,7 @@ defmt = "0.3" defmt-rtt = "0.3" embedded-storage = "0.3.0" +embedded-io = "0.2.0" cortex-m = "0.7.3" cortex-m-rt = "0.7.0" diff --git a/examples/stm32l0/src/bin/usart_irq.rs b/examples/stm32l0/src/bin/usart_irq.rs index abb27fa4..4413a294 100644 --- a/examples/stm32l0/src/bin/usart_irq.rs +++ b/examples/stm32l0/src/bin/usart_irq.rs @@ -2,13 +2,14 @@ #![no_main] #![feature(type_alias_impl_trait)] -use defmt_rtt as _; // global logger +use defmt_rtt as _; +use embedded_io::asynch::{Read, Write}; +// global logger use panic_probe as _; use defmt::*; use embassy::executor::Spawner; -use embassy::io::{AsyncBufReadExt, AsyncWriteExt}; use embassy_stm32::dma::NoDma; use embassy_stm32::interrupt; use embassy_stm32::usart::{BufferedUart, Config, State, Uart}; @@ -16,19 +17,21 @@ use embassy_stm32::Peripherals; #[embassy::main] async fn main(_spawner: Spawner, p: Peripherals) { + info!("Hi!"); + static mut TX_BUFFER: [u8; 8] = [0; 8]; static mut RX_BUFFER: [u8; 256] = [0; 256]; let mut config = Config::default(); config.baudrate = 9600; - let usart = Uart::new(p.USART1, p.PA10, p.PA9, NoDma, NoDma, config); + let usart = Uart::new(p.USART2, p.PA3, p.PA2, NoDma, NoDma, config); let mut state = State::new(); let mut usart = unsafe { BufferedUart::new( &mut state, usart, - interrupt::take!(USART1), + interrupt::take!(USART2), &mut TX_BUFFER, &mut RX_BUFFER, ) |