diff --git a/CHANGELOG.md b/CHANGELOG.md
index cbcdb9a0..a2c72af7 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -19,7 +19,6 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - Pwm channels now constants [#432]
 - Add channel events, make Event use bitflags (simplify interrupt handling) [#425]
 - reexport `digital::v2::PinState` again [#428]
-- reexport `digital::v2::PinState` again
 - Timer impls with time based on `fugit` moved to `fugit` module, added `Pwm` and `fugit-timer` impls [#423]
 
 ### Fixed
@@ -29,6 +28,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 ### Added
 
 - Missing `DelayMs<u8>` / `DelayUs<u8>` impls for fugit::Delay
+- Support of embedded-hal 1.0.0-alpha.7
 - Aliases for peripheral wrappers [#434]
 - `WithPwm` trait implemented for timers with channels (internals) [#425]
 - `Pwm` struct with `split` method and implementation of embedded-hal::Pwm (similar to f1xx-hal) [#425]
diff --git a/Cargo.toml b/Cargo.toml
index 571d6b96..88a5a8b5 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -39,7 +39,7 @@ embedded-dma = "0.2.0"
 bare-metal = { version = "1" }
 cast = { default-features = false, version = "0.3.0" }
 void = { default-features = false, version = "1.0.2" }
-embedded-hal = { features = ["unproven"], version = "0.2.6" }
+embedded-hal = { features = ["unproven"], version = "0.2.7" }
 display-interface = { version = "0.4.1", optional = true }
 fugit = "0.3.3"
 fugit-timer = "0.1.3"
@@ -52,7 +52,7 @@ version = "0.3"
 default-features = false
 
 [dependencies.embedded-hal-one]
-version = "=1.0.0-alpha.6"
+version = "1.0.0-alpha.7"
 package = "embedded-hal"
 
 [dependencies.stm32_i2s_v12x]
diff --git a/src/fmpi2c/hal_1.rs b/src/fmpi2c/hal_1.rs
index 9a7237a5..9567ca2b 100644
--- a/src/fmpi2c/hal_1.rs
+++ b/src/fmpi2c/hal_1.rs
@@ -1,148 +1,67 @@
+use embedded_hal_one::i2c::ErrorType;
+
+impl<I2C, PINS> ErrorType for super::FMPI2c<I2C, PINS> {
+    type Error = super::Error;
+}
+
 mod blocking {
-    use super::super::{fmpi2c1, Error, FMPI2c};
+    use super::super::{fmpi2c1, FMPI2c};
     use core::ops::Deref;
-    use embedded_hal_one::i2c::blocking::{Read, Write, WriteRead};
+    use embedded_hal_one::i2c::blocking::Operation;
 
-    impl<I2C, PINS> WriteRead for FMPI2c<I2C, PINS>
+    impl<I2C, PINS> embedded_hal_one::i2c::blocking::I2c for FMPI2c<I2C, PINS>
     where
         I2C: Deref<Target = fmpi2c1::RegisterBlock>,
     {
-        type Error = Error;
-
-        fn write_read(&mut self, addr: u8, bytes: &[u8], buffer: &mut [u8]) -> Result<(), Error> {
-            // Set up current slave address for writing and disable autoending
-            self.i2c.cr2.modify(|_, w| {
-                w.sadd()
-                    .bits(u16::from(addr) << 1)
-                    .nbytes()
-                    .bits(bytes.len() as u8)
-                    .rd_wrn()
-                    .clear_bit()
-                    .autoend()
-                    .clear_bit()
-            });
-
-            // Send a START condition
-            self.i2c.cr2.modify(|_, w| w.start().set_bit());
-
-            // Wait until the transmit buffer is empty and there hasn't been any error condition
-            while {
-                let isr = self.i2c.isr.read();
-                self.check_and_clear_error_flags(&isr)
-                    .map_err(Error::nack_addr)?;
-                isr.txis().bit_is_clear() && isr.tc().bit_is_clear()
-            } {}
-
-            // Send out all individual bytes
-            for c in bytes {
-                self.send_byte(*c)?;
-            }
-
-            // Wait until data was sent
-            while {
-                let isr = self.i2c.isr.read();
-                self.check_and_clear_error_flags(&isr)
-                    .map_err(Error::nack_data)?;
-                isr.tc().bit_is_clear()
-            } {}
-
-            // Set up current address for reading
-            self.i2c.cr2.modify(|_, w| {
-                w.sadd()
-                    .bits(u16::from(addr) << 1)
-                    .nbytes()
-                    .bits(buffer.len() as u8)
-                    .rd_wrn()
-                    .set_bit()
-            });
-
-            // Send another START condition
-            self.i2c.cr2.modify(|_, w| w.start().set_bit());
-
-            // Send the autoend after setting the start to get a restart
-            self.i2c.cr2.modify(|_, w| w.autoend().set_bit());
-
-            // Now read in all bytes
-            for c in buffer.iter_mut() {
-                *c = self.recv_byte()?;
-            }
-
-            // Check and clear flags if they somehow ended up set
-            self.check_and_clear_error_flags(&self.i2c.isr.read())
-                .map_err(Error::nack_data)?;
-
-            Ok(())
+        fn read(&mut self, addr: u8, buffer: &mut [u8]) -> Result<(), Self::Error> {
+            self.read(addr, buffer)
         }
-    }
 
-    impl<I2C, PINS> Read for FMPI2c<I2C, PINS>
-    where
-        I2C: Deref<Target = fmpi2c1::RegisterBlock>,
-    {
-        type Error = Error;
-
-        fn read(&mut self, addr: u8, buffer: &mut [u8]) -> Result<(), Error> {
-            // Set up current address for reading
-            self.i2c.cr2.modify(|_, w| {
-                w.sadd()
-                    .bits(u16::from(addr) << 1)
-                    .nbytes()
-                    .bits(buffer.len() as u8)
-                    .rd_wrn()
-                    .set_bit()
-            });
-
-            // Send a START condition
-            self.i2c.cr2.modify(|_, w| w.start().set_bit());
-
-            // Send the autoend after setting the start to get a restart
-            self.i2c.cr2.modify(|_, w| w.autoend().set_bit());
-
-            // Now read in all bytes
-            for c in buffer.iter_mut() {
-                *c = self.recv_byte()?;
-            }
-
-            // Check and clear flags if they somehow ended up set
-            self.check_and_clear_error_flags(&self.i2c.isr.read())
-                .map_err(Error::nack_data)?;
-
-            Ok(())
+        fn write(&mut self, addr: u8, bytes: &[u8]) -> Result<(), Self::Error> {
+            self.write(addr, bytes)
         }
-    }
 
-    impl<I2C, PINS> Write for FMPI2c<I2C, PINS>
-    where
-        I2C: Deref<Target = fmpi2c1::RegisterBlock>,
-    {
-        type Error = Error;
-
-        fn write(&mut self, addr: u8, bytes: &[u8]) -> Result<(), Error> {
-            // Set up current slave address for writing and enable autoending
-            self.i2c.cr2.modify(|_, w| {
-                w.sadd()
-                    .bits(u16::from(addr) << 1)
-                    .nbytes()
-                    .bits(bytes.len() as u8)
-                    .rd_wrn()
-                    .clear_bit()
-                    .autoend()
-                    .set_bit()
-            });
+        fn write_iter<B>(&mut self, _addr: u8, _bytes: B) -> Result<(), Self::Error>
+        where
+            B: IntoIterator<Item = u8>,
+        {
+            todo!()
+        }
 
-            // Send a START condition
-            self.i2c.cr2.modify(|_, w| w.start().set_bit());
+        fn write_read(
+            &mut self,
+            addr: u8,
+            bytes: &[u8],
+            buffer: &mut [u8],
+        ) -> Result<(), Self::Error> {
+            self.write_read(addr, bytes, buffer)
+        }
 
-            // Send out all individual bytes
-            for c in bytes {
-                self.send_byte(*c)?;
-            }
+        fn write_iter_read<B>(
+            &mut self,
+            _addr: u8,
+            _bytes: B,
+            _buffer: &mut [u8],
+        ) -> Result<(), Self::Error>
+        where
+            B: IntoIterator<Item = u8>,
+        {
+            todo!()
+        }
 
-            // Check and clear flags if they somehow ended up set
-            self.check_and_clear_error_flags(&self.i2c.isr.read())
-                .map_err(Error::nack_data)?;
+        fn transaction<'a>(
+            &mut self,
+            _addr: u8,
+            _operations: &mut [Operation<'a>],
+        ) -> Result<(), Self::Error> {
+            todo!()
+        }
 
-            Ok(())
+        fn transaction_iter<'a, O>(&mut self, _addr: u8, _operations: O) -> Result<(), Self::Error>
+        where
+            O: IntoIterator<Item = Operation<'a>>,
+        {
+            todo!()
         }
     }
 }
diff --git a/src/fugit/hal_1.rs b/src/fugit/hal_1.rs
new file mode 100644
index 00000000..cd9f6df7
--- /dev/null
+++ b/src/fugit/hal_1.rs
@@ -0,0 +1,17 @@
+use super::{Delay, Error, Instance};
+
+use embedded_hal_one::delay::blocking::DelayUs;
+
+use fugit::ExtU32;
+
+impl<TIM: Instance, const FREQ: u32> DelayUs for Delay<TIM, FREQ> {
+    type Error = Error;
+
+    fn delay_us(&mut self, us: u32) -> Result<(), Self::Error> {
+        self.delay(us.micros())
+    }
+
+    fn delay_ms(&mut self, ms: u32) -> Result<(), Self::Error> {
+        self.delay(ms.millis())
+    }
+}
diff --git a/src/fugit/mod.rs b/src/fugit/mod.rs
index 318a9d7a..75bb8298 100644
--- a/src/fugit/mod.rs
+++ b/src/fugit/mod.rs
@@ -25,6 +25,7 @@ pub mod pwm;
 pub use pwm::*;
 
 mod hal_02;
+mod hal_1;
 
 /// Timer wrapper
 pub struct Timer<TIM, const FREQ: u32> {
diff --git a/src/gpio/hal_1.rs b/src/gpio/hal_1.rs
index 91a06155..0998d3a3 100644
--- a/src/gpio/hal_1.rs
+++ b/src/gpio/hal_1.rs
@@ -5,10 +5,11 @@ use super::{
     PushPull,
 };
 
-use embedded_hal_one::digital::blocking::{
-    InputPin, IoPin, OutputPin, StatefulOutputPin, ToggleableOutputPin,
-};
 pub use embedded_hal_one::digital::PinState;
+use embedded_hal_one::digital::{
+    blocking::{InputPin, IoPin, OutputPin, StatefulOutputPin, ToggleableOutputPin},
+    ErrorType,
+};
 
 fn into_state(state: PinState) -> super::PinState {
     match state {
@@ -18,10 +19,11 @@ fn into_state(state: PinState) -> super::PinState {
 }
 
 // Implementations for `Pin`
-
-impl<MODE, const P: char, const N: u8> OutputPin for Pin<Output<MODE>, P, N> {
+impl<MODE, const P: char, const N: u8> ErrorType for Pin<MODE, P, N> {
     type Error = Infallible;
+}
 
+impl<MODE, const P: char, const N: u8> OutputPin for Pin<Output<MODE>, P, N> {
     #[inline(always)]
     fn set_high(&mut self) -> Result<(), Self::Error> {
         self.set_high();
@@ -48,8 +50,6 @@ impl<MODE, const P: char, const N: u8> StatefulOutputPin for Pin<Output<MODE>, P
 }
 
 impl<MODE, const P: char, const N: u8> ToggleableOutputPin for Pin<Output<MODE>, P, N> {
-    type Error = Infallible;
-
     #[inline(always)]
     fn toggle(&mut self) -> Result<(), Self::Error> {
         self.toggle();
@@ -58,8 +58,6 @@ impl<MODE, const P: char, const N: u8> ToggleableOutputPin for Pin<Output<MODE>,
 }
 
 impl<const P: char, const N: u8> InputPin for Pin<Output<OpenDrain>, P, N> {
-    type Error = Infallible;
-
     #[inline(always)]
     fn is_high(&self) -> Result<bool, Self::Error> {
         Ok(self.is_high())
@@ -72,8 +70,6 @@ impl<const P: char, const N: u8> InputPin for Pin<Output<OpenDrain>, P, N> {
 }
 
 impl<MODE, const P: char, const N: u8> InputPin for Pin<Input<MODE>, P, N> {
-    type Error = Infallible;
-
     #[inline(always)]
     fn is_high(&self) -> Result<bool, Self::Error> {
         Ok(self.is_high())
@@ -197,10 +193,11 @@ impl<const P: char, const N: u8> IoPin<Self, Pin<Output<PushPull>, P, N>>
 }
 
 // Implementations for `ErasedPin`
-
-impl<MODE> OutputPin for ErasedPin<Output<MODE>> {
+impl<MODE> ErrorType for ErasedPin<MODE> {
     type Error = core::convert::Infallible;
+}
 
+impl<MODE> OutputPin for ErasedPin<Output<MODE>> {
     #[inline(always)]
     fn set_high(&mut self) -> Result<(), Self::Error> {
         self.set_high();
@@ -227,8 +224,6 @@ impl<MODE> StatefulOutputPin for ErasedPin<Output<MODE>> {
 }
 
 impl<MODE> ToggleableOutputPin for ErasedPin<Output<MODE>> {
-    type Error = Infallible;
-
     #[inline(always)]
     fn toggle(&mut self) -> Result<(), Self::Error> {
         self.toggle();
@@ -237,8 +232,6 @@ impl<MODE> ToggleableOutputPin for ErasedPin<Output<MODE>> {
 }
 
 impl InputPin for ErasedPin<Output<OpenDrain>> {
-    type Error = core::convert::Infallible;
-
     #[inline(always)]
     fn is_high(&self) -> Result<bool, Self::Error> {
         Ok(self.is_high())
@@ -251,8 +244,6 @@ impl InputPin for ErasedPin<Output<OpenDrain>> {
 }
 
 impl<MODE> InputPin for ErasedPin<Input<MODE>> {
-    type Error = core::convert::Infallible;
-
     #[inline(always)]
     fn is_high(&self) -> Result<bool, Self::Error> {
         Ok(self.is_high())
@@ -265,10 +256,11 @@ impl<MODE> InputPin for ErasedPin<Input<MODE>> {
 }
 
 // Implementations for `PartiallyErasedPin`
-
-impl<MODE, const P: char> OutputPin for PartiallyErasedPin<Output<MODE>, P> {
+impl<MODE, const P: char> ErrorType for PartiallyErasedPin<MODE, P> {
     type Error = Infallible;
+}
 
+impl<MODE, const P: char> OutputPin for PartiallyErasedPin<Output<MODE>, P> {
     #[inline(always)]
     fn set_high(&mut self) -> Result<(), Self::Error> {
         self.set_high();
@@ -295,8 +287,6 @@ impl<MODE, const P: char> StatefulOutputPin for PartiallyErasedPin<Output<MODE>,
 }
 
 impl<MODE, const P: char> ToggleableOutputPin for PartiallyErasedPin<Output<MODE>, P> {
-    type Error = Infallible;
-
     #[inline(always)]
     fn toggle(&mut self) -> Result<(), Self::Error> {
         self.toggle();
@@ -305,8 +295,6 @@ impl<MODE, const P: char> ToggleableOutputPin for PartiallyErasedPin<Output<MODE
 }
 
 impl<const P: char> InputPin for PartiallyErasedPin<Output<OpenDrain>, P> {
-    type Error = Infallible;
-
     #[inline(always)]
     fn is_high(&self) -> Result<bool, Self::Error> {
         Ok(self.is_high())
@@ -319,8 +307,6 @@ impl<const P: char> InputPin for PartiallyErasedPin<Output<OpenDrain>, P> {
 }
 
 impl<MODE, const P: char> InputPin for PartiallyErasedPin<Input<MODE>, P> {
-    type Error = Infallible;
-
     #[inline(always)]
     fn is_high(&self) -> Result<bool, Self::Error> {
         Ok(self.is_high())
diff --git a/src/i2c/hal_1.rs b/src/i2c/hal_1.rs
index 9d95f81b..30ea3260 100644
--- a/src/i2c/hal_1.rs
+++ b/src/i2c/hal_1.rs
@@ -1,4 +1,4 @@
-use embedded_hal_one::i2c::{Error, ErrorKind, NoAcknowledgeSource};
+use embedded_hal_one::i2c::{Error, ErrorKind, ErrorType, NoAcknowledgeSource};
 
 impl Error for super::Error {
     fn kind(&self) -> ErrorKind {
@@ -14,15 +14,29 @@ impl Error for super::Error {
     }
 }
 
+impl<I2C: super::Instance, PINS> ErrorType for super::I2c<I2C, PINS> {
+    type Error = super::Error;
+}
+
 mod blocking {
-    use super::super::{Error, I2c, Instance};
-    use embedded_hal_one::i2c::blocking::{Read, Write, WriteIter, WriteIterRead, WriteRead};
+    use super::super::{I2c, Instance};
+    use embedded_hal_one::i2c::blocking::Operation;
+
+    impl<I2C: Instance, PINS> embedded_hal_one::i2c::blocking::I2c for I2c<I2C, PINS> {
+        fn read(&mut self, addr: u8, buffer: &mut [u8]) -> Result<(), Self::Error> {
+            self.read(addr, buffer)
+        }
+
+        fn write(&mut self, addr: u8, bytes: &[u8]) -> Result<(), Self::Error> {
+            self.write(addr, bytes)
+        }
 
-    impl<I2C, PINS> WriteRead for I2c<I2C, PINS>
-    where
-        I2C: Instance,
-    {
-        type Error = Error;
+        fn write_iter<B>(&mut self, addr: u8, bytes: B) -> Result<(), Self::Error>
+        where
+            B: IntoIterator<Item = u8>,
+        {
+            self.write_iter(addr, bytes)
+        }
 
         fn write_read(
             &mut self,
@@ -32,13 +46,6 @@ mod blocking {
         ) -> Result<(), Self::Error> {
             self.write_read(addr, bytes, buffer)
         }
-    }
-
-    impl<I2C, PINS> WriteIterRead for I2c<I2C, PINS>
-    where
-        I2C: Instance,
-    {
-        type Error = Error;
 
         fn write_iter_read<B>(
             &mut self,
@@ -51,41 +58,20 @@ mod blocking {
         {
             self.write_iter_read(addr, bytes, buffer)
         }
-    }
-
-    impl<I2C, PINS> Write for I2c<I2C, PINS>
-    where
-        I2C: Instance,
-    {
-        type Error = Error;
 
-        fn write(&mut self, addr: u8, bytes: &[u8]) -> Result<(), Self::Error> {
-            self.write(addr, bytes)
+        fn transaction<'a>(
+            &mut self,
+            _addr: u8,
+            _operations: &mut [Operation<'a>],
+        ) -> Result<(), Self::Error> {
+            todo!()
         }
-    }
 
-    impl<I2C, PINS> WriteIter for I2c<I2C, PINS>
-    where
-        I2C: Instance,
-    {
-        type Error = Error;
-
-        fn write_iter<B>(&mut self, addr: u8, bytes: B) -> Result<(), Self::Error>
+        fn transaction_iter<'a, O>(&mut self, _addr: u8, _operations: O) -> Result<(), Self::Error>
         where
-            B: IntoIterator<Item = u8>,
+            O: IntoIterator<Item = Operation<'a>>,
         {
-            self.write_iter(addr, bytes)
-        }
-    }
-
-    impl<I2C, PINS> Read for I2c<I2C, PINS>
-    where
-        I2C: Instance,
-    {
-        type Error = Error;
-
-        fn read(&mut self, addr: u8, buffer: &mut [u8]) -> Result<(), Self::Error> {
-            self.read(addr, buffer)
+            todo!()
         }
     }
 }
diff --git a/src/pwm.rs b/src/pwm.rs
index 25b4b8ae..fa1749f0 100644
--- a/src/pwm.rs
+++ b/src/pwm.rs
@@ -2,7 +2,7 @@ use crate::{
     time::{Hertz, U32Ext},
     timer::{compute_arr_presc, Channel, Instance, Ocm, Timer, WithPwm},
 };
-use core::{convert::Infallible, marker::PhantomData};
+use core::marker::PhantomData;
 
 pub trait Pins<TIM, P> {
     const C1: bool = false;
@@ -146,27 +146,6 @@ impl<TIM: WithPwm, const C: u8> embedded_hal::PwmPin for PwmChannel<TIM, C> {
     }
 }
 
-impl<TIM: WithPwm, const C: u8> embedded_hal_one::pwm::blocking::PwmPin for PwmChannel<TIM, C> {
-    type Error = Infallible;
-    type Duty = u16;
-
-    fn disable(&mut self) -> Result<(), Self::Error> {
-        Ok(self.disable())
-    }
-    fn enable(&mut self) -> Result<(), Self::Error> {
-        Ok(self.enable())
-    }
-    fn get_duty(&self) -> Result<Self::Duty, Self::Error> {
-        Ok(self.get_duty())
-    }
-    fn get_max_duty(&self) -> Result<Self::Duty, Self::Error> {
-        Ok(self.get_max_duty())
-    }
-    fn set_duty(&mut self, duty: Self::Duty) -> Result<(), Self::Error> {
-        Ok(self.set_duty(duty))
-    }
-}
-
 impl<TIM: Instance + WithPwm> Timer<TIM> {
     pub fn pwm<P, PINS, T>(mut self, _pins: PINS, freq: T) -> Pwm<TIM, P, PINS>
     where
diff --git a/src/qei.rs b/src/qei.rs
index 6ad27262..8328a061 100644
--- a/src/qei.rs
+++ b/src/qei.rs
@@ -59,23 +59,6 @@ impl<TIM: Instance, PINS> embedded_hal::Qei for Qei<TIM, PINS> {
     }
 }
 
-impl<TIM: Instance, PINS> embedded_hal_one::qei::blocking::Qei for Qei<TIM, PINS> {
-    type Error = core::convert::Infallible;
-    type Count = TIM::Width;
-
-    fn count(&self) -> Result<Self::Count, Self::Error> {
-        Ok(self.tim.read_count() as Self::Count)
-    }
-
-    fn direction(&self) -> Result<embedded_hal_one::qei::Direction, Self::Error> {
-        Ok(if self.tim.read_direction() {
-            embedded_hal_one::qei::Direction::Upcounting
-        } else {
-            embedded_hal_one::qei::Direction::Downcounting
-        })
-    }
-}
-
 pub trait Instance: crate::Sealed + rcc::Enable + rcc::Reset + General {
     fn setup_qei(&mut self);
 
diff --git a/src/serial/hal_1.rs b/src/serial/hal_1.rs
index 3510c425..1f698b46 100644
--- a/src/serial/hal_1.rs
+++ b/src/serial/hal_1.rs
@@ -1,4 +1,4 @@
-use embedded_hal_one::serial::{Error, ErrorKind};
+use embedded_hal_one::serial::{Error, ErrorKind, ErrorType};
 
 impl Error for super::Error {
     fn kind(&self) -> ErrorKind {
@@ -11,25 +11,36 @@ impl Error for super::Error {
     }
 }
 
+impl<USART, PINS, WORD> ErrorType for super::Serial<USART, PINS, WORD> {
+    type Error = super::Error;
+}
+
+impl<USART, WORD> ErrorType for super::Rx<USART, WORD> {
+    type Error = super::Error;
+}
+
+impl<USART, WORD> ErrorType for super::Tx<USART, WORD> {
+    type Error = super::Error;
+}
+
 mod nb {
     use super::super::{Error, Instance, Rx, Serial, Tx};
-    use embedded_hal_one::serial::nb::{Read, Write};
+    use embedded_hal_one::serial::{
+        nb::{Read, Write},
+        ErrorType,
+    };
 
-    impl<USART, PINS, WORD> Read<WORD> for Serial<USART, PINS, WORD>
+    impl<USART, PINS, WORD: Copy> Read<WORD> for Serial<USART, PINS, WORD>
     where
         USART: Instance,
-        Rx<USART, WORD>: Read<WORD, Error = Error>,
+        Rx<USART, WORD>: Read<WORD> + ErrorType<Error = Error>,
     {
-        type Error = Error;
-
         fn read(&mut self) -> nb::Result<WORD, Error> {
             self.rx.read()
         }
     }
 
     impl<USART: Instance> Read<u8> for Rx<USART, u8> {
-        type Error = Error;
-
         fn read(&mut self) -> nb::Result<u8, Self::Error> {
             // Delegate to the Read<u16> implementation, then truncate to 8 bits
             Rx::<USART, u16>::new().read().map(|word16| word16 as u8)
@@ -42,8 +53,6 @@ mod nb {
     /// 9 received data bits and all other bits set to zero. Otherwise, the returned value will contain
     /// 8 received data bits and all other bits set to zero.
     impl<USART: Instance> Read<u16> for Rx<USART, u16> {
-        type Error = Error;
-
         fn read(&mut self) -> nb::Result<u16, Error> {
             // NOTE(unsafe) atomic read with no side effects
             let sr = unsafe { (*USART::ptr()).sr.read() };
@@ -74,13 +83,11 @@ mod nb {
         }
     }
 
-    impl<USART, PINS, WORD> Write<WORD> for Serial<USART, PINS, WORD>
+    impl<USART, PINS, WORD: Copy> Write<WORD> for Serial<USART, PINS, WORD>
     where
         USART: Instance,
-        Tx<USART, WORD>: Write<WORD, Error = Error>,
+        Tx<USART, WORD>: Write<WORD> + ErrorType<Error = Error>,
     {
-        type Error = Error;
-
         fn flush(&mut self) -> nb::Result<(), Self::Error> {
             self.tx.flush()
         }
@@ -91,8 +98,6 @@ mod nb {
     }
 
     impl<USART: Instance> Write<u8> for Tx<USART, u8> {
-        type Error = Error;
-
         fn write(&mut self, word: u8) -> nb::Result<(), Self::Error> {
             // Delegate to u16 version
             Tx::<USART, u16>::new().write(u16::from(word))
@@ -110,8 +115,6 @@ mod nb {
     /// be transmitted and the other 7 bits will be ignored. Otherwise, the 8 least significant bits
     /// will be transmitted and the other 8 bits will be ignored.
     impl<USART: Instance> Write<u16> for Tx<USART, u16> {
-        type Error = Error;
-
         fn write(&mut self, word: u16) -> nb::Result<(), Self::Error> {
             // NOTE(unsafe) atomic read with no side effects
             let sr = unsafe { (*USART::ptr()).sr.read() };
@@ -139,12 +142,10 @@ mod nb {
 }
 
 mod blocking {
-    use super::super::{Error, Instance, Serial, Tx};
+    use super::super::{Instance, Serial, Tx};
     use embedded_hal_one::serial::{self, blocking::Write};
 
     impl<USART: Instance> Write<u8> for Tx<USART, u8> {
-        type Error = Error;
-
         fn write(&mut self, bytes: &[u8]) -> Result<(), Self::Error> {
             for &b in bytes {
                 loop {
@@ -170,8 +171,6 @@ mod blocking {
     }
 
     impl<USART: Instance, PINS> Write<u8> for Serial<USART, PINS, u8> {
-        type Error = Error;
-
         fn write(&mut self, bytes: &[u8]) -> Result<(), Self::Error> {
             self.tx.write(bytes)
         }
@@ -182,8 +181,6 @@ mod blocking {
     }
 
     impl<USART: Instance> Write<u16> for Tx<USART, u16> {
-        type Error = Error;
-
         fn write(&mut self, buffer: &[u16]) -> Result<(), Self::Error> {
             for &b in buffer {
                 loop {
@@ -209,8 +206,6 @@ mod blocking {
     }
 
     impl<USART: Instance, PINS> Write<u16> for Serial<USART, PINS, u16> {
-        type Error = Error;
-
         fn write(&mut self, bytes: &[u16]) -> Result<(), Self::Error> {
             self.tx.write(bytes)
         }
diff --git a/src/spi/hal_1.rs b/src/spi/hal_1.rs
index 24c4a807..c6d2f686 100644
--- a/src/spi/hal_1.rs
+++ b/src/spi/hal_1.rs
@@ -1,4 +1,4 @@
-pub use embedded_hal_one::spi::{Error, ErrorKind, Mode, Phase, Polarity};
+pub use embedded_hal_one::spi::{Error, ErrorKind, ErrorType, Mode, Phase, Polarity};
 
 impl From<Polarity> for super::Polarity {
     fn from(p: Polarity) -> Self {
@@ -37,6 +37,10 @@ impl Error for super::Error {
     }
 }
 
+impl<SPI, PINS, TRANSFER_MODE> ErrorType for super::Spi<SPI, PINS, TRANSFER_MODE> {
+    type Error = super::Error;
+}
+
 mod nb {
     use super::super::{Error, Instance, Spi, TransferModeBidi, TransferModeNormal};
     use embedded_hal_one::spi::nb::FullDuplex;
@@ -45,8 +49,6 @@ mod nb {
     where
         SPI: Instance,
     {
-        type Error = Error;
-
         fn read(&mut self) -> nb::Result<u8, Error> {
             self.check_read()
         }
@@ -60,8 +62,6 @@ mod nb {
     where
         SPI: Instance,
     {
-        type Error = Error;
-
         fn read(&mut self) -> nb::Result<u8, Error> {
             self.spi.cr1.modify(|_, w| w.bidioe().clear_bit());
             self.check_read()
@@ -86,8 +86,6 @@ mod blocking {
         Self: FullDuplex<u8, Error = Error>,
         SPI: Instance,
     {
-        type Error = Error;
-
         fn transfer_inplace(&mut self, words: &mut [u8]) -> Result<(), Self::Error> {
             for word in words.iter_mut() {
                 nb::block!(self.write(*word))?;
@@ -103,8 +101,6 @@ mod blocking {
         Self: FullDuplex<u8, Error = Error>,
         SPI: Instance,
     {
-        type Error = Error;
-
         fn write(&mut self, words: &[u8]) -> Result<(), Self::Error> {
             for word in words {
                 nb::block!(<Self as FullDuplex<u8>>::write(self, *word))?;
@@ -120,8 +116,6 @@ mod blocking {
         Self: FullDuplex<u8, Error = Error>,
         SPI: Instance,
     {
-        type Error = Error;
-
         fn write(&mut self, words: &[u8]) -> Result<(), Self::Error> {
             for word in words {
                 nb::block!(<Self as FullDuplex<u8>>::write(self, *word))?;
@@ -136,8 +130,6 @@ mod blocking {
         Self: FullDuplex<u8, Error = Error>,
         SPI: Instance,
     {
-        type Error = Error;
-
         fn write_iter<WI>(&mut self, words: WI) -> Result<(), Self::Error>
         where
             WI: IntoIterator<Item = u8>,
@@ -156,8 +148,6 @@ mod blocking {
         Self: FullDuplex<u8, Error = Error>,
         SPI: Instance,
     {
-        type Error = Error;
-
         fn write_iter<WI>(&mut self, words: WI) -> Result<(), Self::Error>
         where
             WI: IntoIterator<Item = u8>,
@@ -170,12 +160,10 @@ mod blocking {
         }
     }
 
-    impl<SPI, PINS, TRANSFER_MODE, W: 'static> Transactional<W> for Spi<SPI, PINS, TRANSFER_MODE>
+    impl<SPI, PINS, TRANSFER_MODE, W: Copy + 'static> Transactional<W> for Spi<SPI, PINS, TRANSFER_MODE>
     where
         Self: Write<W, Error = Error> + TransferInplace<W, Error = Error>,
     {
-        type Error = Error;
-
         fn exec<'a>(&mut self, operations: &mut [Operation<'a, W>]) -> Result<(), Error> {
             for op in operations {
                 match op {