diff --git a/examples/rtic_frame_serial_dma.rs b/examples/rtic_frame_serial_dma.rs
index 04742658..51970ab0 100644
--- a/examples/rtic_frame_serial_dma.rs
+++ b/examples/rtic_frame_serial_dma.rs
@@ -24,8 +24,14 @@ use heapless::{
 use panic_halt as _;
 use rtic::app;
 use stm32l4xx_hal as hal;
-use stm32l4xx_hal::dma::{RxDma, TxDma};
-use stm32l4xx_hal::serial::{Rx, Tx};
+use stm32l4xx_hal::{
+    dma::{RxDma, TxDma},
+    gpio::{self, Alternate, PushPull},
+    serial::{Rx, Tx},
+};
+
+type TxPin = gpio::PA2<Alternate<PushPull, 7>>;
+type RxPin = gpio::PA3<Alternate<PushPull, 7>>;
 
 // The pool gives out `Box<DMAFrame>`s that can hold 8 bytes
 pool!(
@@ -36,8 +42,10 @@ pool!(
 #[app(device = stm32l4xx_hal::stm32, peripherals = true)]
 const APP: () = {
     struct Resources {
-        frame_reader: FrameReader<Box<SerialDMAPool>, RxDma<Rx<USART2>, dma::dma1::C6>, 8>,
-        frame_sender: FrameSender<Box<SerialDMAPool>, TxDma<Tx<USART2>, dma::dma1::C7>, 8>,
+        frame_reader:
+            FrameReader<Box<SerialDMAPool>, RxDma<Rx<USART2, (TxPin, RxPin)>, dma::dma1::C6>, 8>,
+        frame_sender:
+            FrameSender<Box<SerialDMAPool>, TxDma<Tx<USART2, (TxPin, RxPin)>, dma::dma1::C7>, 8>,
     }
 
     #[init]
diff --git a/examples/serial_echo_rtic.rs b/examples/serial_echo_rtic.rs
index e2a81027..e3f39169 100644
--- a/examples/serial_echo_rtic.rs
+++ b/examples/serial_echo_rtic.rs
@@ -7,16 +7,20 @@ use heapless::{consts::U8, spsc};
 use nb::block;
 use rtt_target::{rprint, rprintln};
 use stm32l4xx_hal::{
+    gpio::{self, Alternate, PushPull},
     pac::{self, USART2},
     prelude::*,
     serial::{self, Config, Serial},
 };
 
+type TxPin = gpio::PA2<Alternate<PushPull, 7>>;
+type RxPin = gpio::PA3<Alternate<PushPull, 7>>;
+
 #[rtic::app(device = stm32l4xx_hal::pac)]
 const APP: () = {
     struct Resources {
-        rx: serial::Rx<USART2>,
-        tx: serial::Tx<USART2>,
+        rx: serial::Rx<USART2, (TxPin, RxPin)>,
+        tx: serial::Tx<USART2, (TxPin, RxPin)>,
 
         rx_prod: spsc::Producer<'static, u8, U8>,
         rx_cons: spsc::Consumer<'static, u8, U8>,
diff --git a/src/dma.rs b/src/dma.rs
index 946bffc1..edf82dc4 100644
--- a/src/dma.rs
+++ b/src/dma.rs
@@ -333,6 +333,35 @@ where
     }
 }
 
+impl<BUFFER, PAYLOAD, CHANNEL> CircBuffer<BUFFER, RxDma<PAYLOAD, CHANNEL>>
+where
+    PAYLOAD: CharacterMatch,
+{
+    /// Checks to see if the peripheral has detected a character match and
+    /// clears the flag
+    pub fn check_character_match(&mut self, clear: bool) -> bool {
+        self.payload.payload.check_character_match(clear)
+    }
+}
+
+impl<BUFFER, PAYLOAD, CHANNEL> CircBuffer<BUFFER, RxDma<PAYLOAD, CHANNEL>>
+where
+    PAYLOAD: ReceiverTimeout,
+{
+    pub fn check_receiver_timeout(&mut self, clear: bool) -> bool {
+        self.payload.payload.check_receiver_timeout(clear)
+    }
+}
+
+impl<BUFFER, PAYLOAD, CHANNEL> CircBuffer<BUFFER, RxDma<PAYLOAD, CHANNEL>> {
+    pub fn check_operation_error<O, E>(&mut self) -> Result<O, E>
+    where
+        PAYLOAD: OperationError<O, E>,
+    {
+        self.payload.payload.check_operation_error()
+    }
+}
+
 pub trait DmaExt {
     type Channels;
 
diff --git a/src/serial.rs b/src/serial.rs
index 2e36c7b4..836ca582 100644
--- a/src/serial.rs
+++ b/src/serial.rs
@@ -206,18 +206,20 @@ impl From<Bps> for Config {
 
 /// Serial abstraction
 pub struct Serial<USART, PINS> {
-    usart: USART,
-    pins: PINS,
+    tx: Tx<USART, PINS>,
+    rx: Rx<USART, PINS>,
 }
 
 /// Serial receiver
-pub struct Rx<USART> {
+pub struct Rx<USART, PINS> {
     _usart: PhantomData<USART>,
+    pins: PINS,
 }
 
 /// Serial transmitter
-pub struct Tx<USART> {
-    _usart: PhantomData<USART>,
+pub struct Tx<USART, PINS> {
+    usart: USART,
+    pins: PhantomData<PINS>,
 }
 
 macro_rules! hal {
@@ -372,26 +374,34 @@ macro_rules! hal {
                         .cr1
                         .modify(|_, w| w.ue().set_bit().re().set_bit().te().set_bit());
 
-                    Serial { usart, pins }
+                    Serial {
+                        tx: Tx { usart, pins: PhantomData },
+                        rx: Rx { _usart: PhantomData, pins },
+                    }
+                }
+
+                #[inline]
+                fn usart(&self) -> &pac::$USARTX {
+                    &self.tx.usart
                 }
 
                 /// Starts listening for an interrupt event
                 pub fn listen(&mut self, event: Event) {
                     match event {
                         Event::Rxne => {
-                            self.usart.cr1.modify(|_, w| w.rxneie().set_bit())
+                            self.usart().cr1.modify(|_, w| w.rxneie().set_bit())
                         },
                         Event::Txe => {
-                            self.usart.cr1.modify(|_, w| w.txeie().set_bit())
+                            self.usart().cr1.modify(|_, w| w.txeie().set_bit())
                         },
                         Event::Idle => {
-                            self.usart.cr1.modify(|_, w| w.idleie().set_bit())
+                            self.usart().cr1.modify(|_, w| w.idleie().set_bit())
                         },
                         Event::CharacterMatch => {
-                            self.usart.cr1.modify(|_, w| w.cmie().set_bit())
+                            self.usart().cr1.modify(|_, w| w.cmie().set_bit())
                         },
                         Event::ReceiverTimeout => {
-                            self.usart.cr1.modify(|_, w| w.rtoie().set_bit())
+                            self.usart().cr1.modify(|_, w| w.rtoie().set_bit())
                         },
                     }
                 }
@@ -400,48 +410,62 @@ macro_rules! hal {
                 ///
                 /// See [`Rx::check_for_error`].
                 pub fn check_for_error() -> Result<(), Error> {
-                    let mut rx: Rx<pac::$USARTX> = Rx {
-                        _usart: PhantomData,
-                    };
-                    rx.check_for_error()
+                    // NOTE(unsafe): Only used for atomic access.
+                    let isr = unsafe { (*pac::$USARTX::ptr()).isr.read() };
+                    let icr = unsafe { &(*pac::$USARTX::ptr()).icr };
+
+                    if isr.pe().bit_is_set() {
+                        icr.write(|w| w.pecf().clear());
+                        return Err(Error::Parity);
+                    }
+                    if isr.fe().bit_is_set() {
+                        icr.write(|w| w.fecf().clear());
+                        return Err(Error::Framing);
+                    }
+                    if isr.nf().bit_is_set() {
+                        icr.write(|w| w.ncf().clear());
+                        return Err(Error::Noise);
+                    }
+                    if isr.ore().bit_is_set() {
+                        icr.write(|w| w.orecf().clear());
+                        return Err(Error::Overrun);
+                    }
+
+                    Ok(())
                 }
 
                 /// Stops listening for an interrupt event
                 pub fn unlisten(&mut self, event: Event) {
                     match event {
                         Event::Rxne => {
-                            self.usart.cr1.modify(|_, w| w.rxneie().clear_bit())
+                            self.usart().cr1.modify(|_, w| w.rxneie().clear_bit())
                         },
                         Event::Txe => {
-                            self.usart.cr1.modify(|_, w| w.txeie().clear_bit())
+                            self.usart().cr1.modify(|_, w| w.txeie().clear_bit())
                         },
                         Event::Idle => {
-                            self.usart.cr1.modify(|_, w| w.idleie().clear_bit())
+                            self.usart().cr1.modify(|_, w| w.idleie().clear_bit())
                         },
                         Event::CharacterMatch => {
-                            self.usart.cr1.modify(|_, w| w.cmie().clear_bit())
+                            self.usart().cr1.modify(|_, w| w.cmie().clear_bit())
                         },
                         Event::ReceiverTimeout => {
-                            self.usart.cr1.modify(|_, w| w.rtoie().clear_bit())
+                            self.usart().cr1.modify(|_, w| w.rtoie().clear_bit())
                         },
                     }
                 }
 
                 /// Splits the `Serial` abstraction into a transmitter and a receiver half
-                pub fn split(self) -> (Tx<pac::$USARTX>, Rx<pac::$USARTX>) {
+                pub fn split(self) -> (Tx<pac::$USARTX, PINS>, Rx<pac::$USARTX, PINS>) {
                     (
-                        Tx {
-                            _usart: PhantomData,
-                        },
-                        Rx {
-                            _usart: PhantomData,
-                        },
+                        self.tx,
+                        self.rx,
                     )
                 }
 
                 /// Frees the USART peripheral
                 pub fn release(self) -> (pac::$USARTX, PINS) {
-                    (self.usart, self.pins)
+                    (self.tx.usart, self.rx.pins)
                 }
             }
 
@@ -449,14 +473,11 @@ macro_rules! hal {
                 type Error = Error;
 
                 fn read(&mut self) -> nb::Result<u8, Error> {
-                    let mut rx: Rx<pac::$USARTX> = Rx {
-                        _usart: PhantomData,
-                    };
-                    rx.read()
+                    self.rx.read()
                 }
             }
 
-            impl serial::Read<u8> for Rx<pac::$USARTX> {
+            impl<PINS> serial::Read<u8> for Rx<pac::$USARTX, PINS> {
                 type Error = Error;
 
                 fn read(&mut self) -> nb::Result<u8, Error> {
@@ -480,21 +501,15 @@ macro_rules! hal {
                 type Error = Error;
 
                 fn flush(&mut self) -> nb::Result<(), Error> {
-                    let mut tx: Tx<pac::$USARTX> = Tx {
-                        _usart: PhantomData,
-                    };
-                    tx.flush()
+                    self.tx.flush()
                 }
 
                 fn write(&mut self, byte: u8) -> nb::Result<(), Error> {
-                    let mut tx: Tx<pac::$USARTX> = Tx {
-                        _usart: PhantomData,
-                    };
-                    tx.write(byte)
+                    self.tx.write(byte)
                 }
             }
 
-            impl serial::Write<u8> for Tx<pac::$USARTX> {
+            impl<PINS> serial::Write<u8> for Tx<pac::$USARTX, PINS> {
                 // NOTE(Void) See section "29.7 USART interrupts"; the only possible errors during
                 // transmission are: clear to send (which is disabled in this case) errors and
                 // framing errors (which only occur in SmartCard mode); neither of these apply to
@@ -529,23 +544,22 @@ macro_rules! hal {
                 }
             }
 
-            impl embedded_hal::blocking::serial::write::Default<u8>
-                for Tx<pac::$USARTX> {}
+            impl<PINS> embedded_hal::blocking::serial::write::Default<u8> for Tx<pac::$USARTX, PINS> {}
 
-            pub type $rxdma = RxDma<Rx<pac::$USARTX>, $dmarxch>;
-            pub type $txdma = TxDma<Tx<pac::$USARTX>, $dmatxch>;
+            pub type $rxdma<PINS> = RxDma<Rx<pac::$USARTX, PINS>, $dmarxch>;
+            pub type $txdma<PINS> = TxDma<Tx<pac::$USARTX, PINS>, $dmatxch>;
 
-            impl Receive for $rxdma {
+            impl<PINS> Receive for $rxdma<PINS> {
                 type RxChannel = $dmarxch;
                 type TransmittedWord = u8;
             }
 
-            impl Transmit for $txdma {
+            impl<PINS> Transmit for $txdma<PINS> {
                 type TxChannel = $dmatxch;
                 type ReceivedWord = u8;
             }
 
-            impl TransferPayload for $rxdma {
+            impl<PINS> TransferPayload for $rxdma<PINS> {
                 fn start(&mut self) {
                     self.channel.start();
                 }
@@ -554,7 +568,7 @@ macro_rules! hal {
                 }
             }
 
-            impl TransferPayload for $txdma {
+            impl<PINS> TransferPayload for $txdma<PINS> {
                 fn start(&mut self) {
                     self.channel.start();
                 }
@@ -563,8 +577,8 @@ macro_rules! hal {
                 }
             }
 
-            impl Rx<pac::$USARTX> {
-                pub fn with_dma(self, channel: $dmarxch) -> $rxdma {
+            impl<PINS> Rx<pac::$USARTX, PINS> {
+                pub fn with_dma(self, channel: $dmarxch) -> $rxdma<PINS> {
                     RxDma {
                         payload: self,
                         channel,
@@ -579,28 +593,7 @@ macro_rules! hal {
                 /// `Ok(())`, it should be possible to proceed with the next
                 /// `read` call unimpeded.
                 pub fn check_for_error(&mut self) -> Result<(), Error> {
-                    // NOTE(unsafe): Only used for atomic access.
-                    let isr = unsafe { (*pac::$USARTX::ptr()).isr.read() };
-                    let icr = unsafe { &(*pac::$USARTX::ptr()).icr };
-
-                    if isr.pe().bit_is_set() {
-                        icr.write(|w| w.pecf().clear());
-                        return Err(Error::Parity);
-                    }
-                    if isr.fe().bit_is_set() {
-                        icr.write(|w| w.fecf().clear());
-                        return Err(Error::Framing);
-                    }
-                    if isr.nf().bit_is_set() {
-                        icr.write(|w| w.ncf().clear());
-                        return Err(Error::Noise);
-                    }
-                    if isr.ore().bit_is_set() {
-                        icr.write(|w| w.orecf().clear());
-                        return Err(Error::Overrun);
-                    }
-
-                    Ok(())
+                    <Serial<pac::$USARTX, ()>>::check_for_error()
                 }
 
                 /// Checks to see if the USART peripheral has detected an idle line and clears
@@ -653,7 +646,7 @@ macro_rules! hal {
                 }
             }
 
-            impl crate::dma::CharacterMatch for Rx<pac::$USARTX> {
+            impl<PINS> crate::dma::CharacterMatch for Rx<pac::$USARTX, PINS> {
                 /// Checks to see if the USART peripheral has detected an character match and
                 /// clears the flag
                 fn check_character_match(&mut self, clear: bool) -> bool {
@@ -661,20 +654,20 @@ macro_rules! hal {
                 }
             }
 
-            impl crate::dma::ReceiverTimeout for Rx<pac::$USARTX> {
+            impl<PINS> crate::dma::ReceiverTimeout for Rx<pac::$USARTX, PINS> {
                 fn check_receiver_timeout(&mut self, clear: bool) -> bool {
                     self.is_receiver_timeout(clear)
                 }
             }
 
-            impl crate::dma::OperationError<(), Error> for Rx<pac::$USARTX>{
+            impl<PINS> crate::dma::OperationError<(), Error> for Rx<pac::$USARTX, PINS> {
                 fn check_operation_error(&mut self) -> Result<(), Error> {
                     self.check_for_error()
                 }
             }
 
-            impl Tx<pac::$USARTX> {
-                pub fn with_dma(self, channel: $dmatxch) -> $txdma {
+            impl<PINS> Tx<pac::$USARTX, PINS> {
+                pub fn with_dma(self, channel: $dmatxch) -> $txdma<PINS> {
                     TxDma {
                         payload: self,
                         channel,
@@ -682,8 +675,8 @@ macro_rules! hal {
                 }
             }
 
-            impl $rxdma {
-                pub fn split(mut self) -> (Rx<pac::$USARTX>, $dmarxch) {
+            impl<PINS> $rxdma<PINS> {
+                pub fn split(mut self) -> (Rx<pac::$USARTX, PINS>, $dmarxch) {
                     self.stop();
                     let RxDma {payload, channel} = self;
                     (
@@ -693,8 +686,8 @@ macro_rules! hal {
                 }
             }
 
-            impl $txdma {
-                pub fn split(mut self) -> (Tx<pac::$USARTX>, $dmatxch) {
+            impl<PINS> $txdma<PINS> {
+                pub fn split(mut self) -> (Tx<pac::$USARTX, PINS>, $dmatxch) {
                     self.stop();
                     let TxDma {payload, channel} = self;
                     (
@@ -704,7 +697,7 @@ macro_rules! hal {
                 }
             }
 
-            impl<B> crate::dma::CircReadDma<B, u8> for $rxdma
+            impl<B, PINS> crate::dma::CircReadDma<B, u8> for $rxdma<PINS>
             where
                 &'static mut B: StaticWriteBuffer<Word = u8>,
                 B: 'static,
@@ -756,7 +749,7 @@ macro_rules! hal {
                 }
             }
 
-            impl $rxdma {
+            impl<PINS> $rxdma<PINS> {
                 /// Create a frame reader that can either react on the Character match interrupt or
                 /// Transfer Complete from the DMA.
                 pub fn frame_reader<BUFFER, const N: usize>(
@@ -806,7 +799,7 @@ macro_rules! hal {
                 }
             }
 
-            impl $txdma {
+            impl<PINS> $txdma<PINS> {
                 /// Creates a new DMA frame sender
                 pub fn frame_sender<BUFFER, const N: usize>(
                     mut self,
@@ -846,6 +839,13 @@ macro_rules! hal {
     }
 }
 
+impl<USART, PINS> From<(Tx<USART, PINS>, Rx<USART, PINS>)> for Serial<USART, PINS> {
+    /// Convert a transmitter/receiver back to a combined serial port.
+    fn from((tx, rx): (Tx<USART, PINS>, Rx<USART, PINS>)) -> Self {
+        Self { tx, rx }
+    }
+}
+
 hal! {
     USART1: (usart1, pclk2, tx: (TxDma1, dma1::C4, DmaInput::Usart1Tx), rx: (RxDma1, dma1::C5, DmaInput::Usart1Rx)),
     USART2: (usart2, pclk1, tx: (TxDma2, dma1::C7, DmaInput::Usart2Tx), rx: (RxDma2, dma1::C6, DmaInput::Usart2Rx)),
@@ -915,9 +915,9 @@ where
     }
 }
 
-impl<USART> fmt::Write for Tx<USART>
+impl<USART, PINS> fmt::Write for Tx<USART, PINS>
 where
-    Tx<USART>: crate::hal::serial::Write<u8>,
+    Tx<USART, PINS>: crate::hal::serial::Write<u8>,
 {
     fn write_str(&mut self, s: &str) -> fmt::Result {
         let _ = s