Move traits into blocking/nonblocking modules, re-export nb

Author: eldruin

CHANGELOG.md

@@ -14,6 +14,9 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 ### Changed
 - Swap PWM channel arguments to references
 - All trait methods have been renamed to remove the `try_` prefix (i.e. `try_send` -> `send`) for consistency.
+- Moved all traits into two modules depending on the execution model: `blocking` and `nb` (non-blocking).
+- Re-export `nb::{block!, Error, Result}` to avoid version mismatches. These should be used instead of
+  importing the `nb` crate directly in dependendent crates.
 
 ## [v1.0.0-alpha.4] - 2020-11-11
 

src/digital.rs renamed to src/blocking/digital.rs

@@ -7,7 +7,7 @@ use core::{convert::From, ops::Not};
 /// Conversion from `bool` and logical negation are also implemented
 /// for this type.
 /// ```rust
-/// # use embedded_hal::digital::PinState;
+/// # use embedded_hal::blocking::digital::PinState;
 /// let state = PinState::from(false);
 /// assert_eq!(state, PinState::Low);
 /// assert_eq!(!state, PinState::High);
@@ -100,8 +100,8 @@ pub trait ToggleableOutputPin {
 /// toggleable by software.
 ///
 /// ```
-/// use embedded_hal::digital::{OutputPin, StatefulOutputPin, ToggleableOutputPin};
-/// use embedded_hal::digital::toggleable;
+/// use embedded_hal::blocking::digital::{OutputPin, StatefulOutputPin, ToggleableOutputPin};
+/// use embedded_hal::blocking::digital::toggleable;
 /// use core::convert::Infallible;
 ///
 /// /// A virtual output pin that exists purely in software
@@ -182,7 +182,7 @@ pub trait InputPin {
 ///
 /// ```
 /// use core::time::Duration;
-/// use embedded_hal::digital::{IoPin, InputPin, OutputPin};
+/// use embedded_hal::blocking::digital::{IoPin, InputPin, OutputPin};
 ///
 /// pub fn ping_and_read<TInputPin, TOutputPin, TError>(
 ///     mut pin: TOutputPin, delay_fn: &dyn Fn(Duration) -> ()) -> Result<bool, TError>

src/blocking/mod.rs

@@ -5,7 +5,11 @@
 //! Implementing that marker trait will opt in your type into a blanket implementation.
 
 pub mod delay;
+pub mod digital;
 pub mod i2c;
+pub mod pwm;
+pub mod qei;
 pub mod rng;
 pub mod serial;
 pub mod spi;
+pub mod watchdog;

src/pwm.rs renamed to src/blocking/pwm.rs

@@ -34,7 +34,7 @@
 /// # impl U32Ext for u32 { fn khz(self) -> KiloHertz { KiloHertz(self) } }
 /// # enum Channel { _1, _2 }
 /// # struct Pwm1;
-/// # impl hal::pwm::Pwm for Pwm1 {
+/// # impl hal::blocking::pwm::Pwm for Pwm1 {
 /// #     type Error = Infallible;
 /// #     type Channel = Channel;
 /// #     type Time = KiloHertz;

src/qei.rs renamed to src/blocking/qei.rs

@@ -38,14 +38,14 @@
 /// # trait U32Ext { fn s(self) -> Seconds; }
 /// # impl U32Ext for u32 { fn s(self) -> Seconds { Seconds(self) } }
 /// # struct Qei1;
-/// # impl hal::qei::Qei for Qei1 {
+/// # impl hal::blocking::qei::Qei for Qei1 {
 /// #     type Error = Infallible;
 /// #     type Count = u16;
 /// #     fn count(&self) -> Result<u16, Self::Error> { Ok(0) }
-/// #     fn direction(&self) -> Result<::hal::qei::Direction, Self::Error> { unimplemented!() }
+/// #     fn direction(&self) -> Result<::hal::blocking::qei::Direction, Self::Error> { unimplemented!() }
 /// # }
 /// # struct Timer6;
-/// # impl hal::timer::CountDown for Timer6 {
+/// # impl hal::nb::timer::CountDown for Timer6 {
 /// #     type Error = Infallible;
 /// #     type Time = Seconds;
 /// #     fn start<T>(&mut self, _: T) -> Result<(), Infallible> where T: Into<Seconds> { Ok(()) }

src/blocking/serial.rs

@@ -23,13 +23,13 @@ pub trait Write<Word> {
 pub mod write {
     /// Marker trait to opt into default blocking write implementation
     ///
-    /// Implementers of [`serial::Write`] can implement this marker trait
+    /// Implementers of [`nonblocking::serial::Write`] can implement this marker trait
     /// for their type. Doing so will automatically provide the default
     /// implementation of [`blocking::serial::Write`] for the type.
     ///
-    /// [`serial::Write`]: ../../serial/trait.Write.html
+    /// [`nonblocking::serial::Write`]: ../../nonblocking/serial/trait.Write.html
     /// [`blocking::serial::Write`]: ../trait.Write.html
-    pub trait Default<Word>: crate::serial::Write<Word> {}
+    pub trait Default<Word>: crate::nb::serial::Write<Word> {}
 
     impl<S, Word> crate::blocking::serial::Write<Word> for S
     where

src/blocking/spi.rs

@@ -32,8 +32,8 @@ pub trait WriteIter<W> {
 /// Blocking transfer
 pub mod transfer {
     /// Default implementation of `blocking::spi::Transfer<W>` for implementers of
-    /// `spi::FullDuplex<W>`
-    pub trait Default<W>: crate::spi::FullDuplex<W> {}
+    /// `nonblocking::spi::FullDuplex<W>`
+    pub trait Default<W>: crate::nb::spi::FullDuplex<W> {}
 
     impl<W, S> crate::blocking::spi::Transfer<W> for S
     where
@@ -55,8 +55,9 @@ pub mod transfer {
 
 /// Blocking write
 pub mod write {
-    /// Default implementation of `blocking::spi::Write<W>` for implementers of `spi::FullDuplex<W>`
-    pub trait Default<W>: crate::spi::FullDuplex<W> {}
+    /// Default implementation of `blocking::spi::Write<W>` for implementers
+    /// of `nonblocking::spi::FullDuplex<W>`
+    pub trait Default<W>: crate::nb::spi::FullDuplex<W> {}
 
     impl<W, S> crate::blocking::spi::Write<W> for S
     where
@@ -79,8 +80,8 @@ pub mod write {
 /// Blocking write (iterator version)
 pub mod write_iter {
     /// Default implementation of `blocking::spi::WriteIter<W>` for implementers of
-    /// `spi::FullDuplex<W>`
-    pub trait Default<W>: crate::spi::FullDuplex<W> {}
+    /// `nonblocking::spi::FullDuplex<W>`
+    pub trait Default<W>: crate::nb::spi::FullDuplex<W> {}
 
     impl<W, S> crate::blocking::spi::WriteIter<W> for S
     where

src/watchdog.rs renamed to src/blocking/watchdog.rs

@@ -3,7 +3,7 @@
 //! TODO write example of usage
 use core::fmt::{Result, Write};
 
-impl<Word, Error> Write for dyn crate::serial::Write<Word, Error = Error> + '_
+impl<Word, Error> Write for dyn crate::nb::serial::Write<Word, Error = Error> + '_
 where
     Word: From<u8>,
 {

src/fmt.rs

@@ -145,7 +145,7 @@
 //!     // omitted: other error variants
 //! }
 //!
-//! impl hal::serial::Read<u8> for Serial<USART1> {
+//! impl hal::nb::serial::Read<u8> for Serial<USART1> {
 //!     type Error = Error;
 //!
 //!     fn read(&mut self) -> nb::Result<u8, Error> {
@@ -167,7 +167,7 @@
 //!     }
 //! }
 //!
-//! impl hal::serial::Write<u8> for Serial<USART1> {
+//! impl hal::nb::serial::Write<u8> for Serial<USART1> {
 //!     type Error = Error;
 //!
 //!     fn write(&mut self, byte: u8) -> nb::Result<(), Error> {
@@ -198,7 +198,7 @@
 //!
 //! ```
 //! use crate::stm32f1xx_hal::Serial1;
-//! use embedded_hal::serial::Write;
+//! use embedded_hal::nb::serial::Write;
 //! use nb::block;
 //!
 //! # fn main() {
@@ -248,7 +248,7 @@
 //!
 //! fn write_all<S>(serial: &mut S, buffer: &[u8]) -> Result<(), S::Error>
 //! where
-//!     S: hal::serial::Write<u8>
+//!     S: hal::nb::serial::Write<u8>
 //! {
 //!     for &byte in buffer {
 //!         block!(serial.write(byte))?;
@@ -281,8 +281,8 @@
 //!     timeout: T::Time,
 //! ) -> Result<u8, Error<S::Error, T::Error>>
 //! where
-//!     T: hal::timer::CountDown<Error = ()>,
-//!     S: hal::serial::Read<u8>,
+//!     T: hal::nb::timer::CountDown<Error = ()>,
+//!     S: hal::nb::serial::Read<u8>,
 //! {
 //!     timer.start(timeout).map_err(Error::TimedOut)?;
 //!
@@ -325,7 +325,7 @@
 //!
 //! fn flush<S>(serial: &mut S, cb: &mut CircularBuffer)
 //! where
-//!     S: hal::serial::Write<u8, Error = Infallible>,
+//!     S: hal::nb::serial::Write<u8, Error = Infallible>,
 //! {
 //!     loop {
 //!         if let Some(byte) = cb.peek() {
@@ -389,7 +389,7 @@
 //! #     fn deref_mut(&mut self) -> &mut T { self.0 }
 //! # }
 //! # struct Serial1;
-//! # impl hal::serial::Write<u8> for Serial1 {
+//! # impl hal::nb::serial::Write<u8> for Serial1 {
 //! #   type Error = Infallible;
 //! #   fn write(&mut self, _: u8) -> nb::Result<(), Infallible> { Err(::nb::Error::WouldBlock) }
 //! #   fn flush(&mut self) -> nb::Result<(), Infallible> { Err(::nb::Error::WouldBlock) }
@@ -408,19 +408,10 @@
 #![deny(missing_docs)]
 #![no_std]
 
-pub mod adc;
 pub mod blocking;
-pub mod capture;
-pub mod digital;
 pub mod fmt;
+pub mod nb;
 pub mod prelude;
-pub mod pwm;
-pub mod qei;
-pub mod rng;
-pub mod serial;
-pub mod spi;
-pub mod timer;
-pub mod watchdog;
 
 mod private {
     use crate::blocking::i2c::{SevenBitAddress, TenBitAddress};