Add a tx only and a rx only serial instance

Author: david-sawatzke

src/serial.rs

@@ -186,16 +186,53 @@ unsafe impl<USART> Send for Tx<USART> {}
 
 #[cfg(feature = "device-selected")]
 macro_rules! usart {
-    ($($USART:ident: ($usart:ident, $usartXen:ident, $apbenr:ident),)+) => {
+    ($($USART:ident: ($usart:ident, $usarttx:ident, $usartrx:ident, $usartXen:ident, $apbenr:ident),)+) => {
         $(
             use crate::stm32::$USART;
-            impl<TXPIN, RXPIN> Serial<$USART, TXPIN, RXPIN> {
+            impl<TXPIN, RXPIN> Serial<$USART, TXPIN, RXPIN>
+            where
+                TXPIN: TxPin<$USART>,
+                RXPIN: RxPin<$USART>,
+            {
                 /// Creates a new serial instance
                 pub fn $usart(usart: $USART, pins: (TXPIN, RXPIN), baud_rate: Bps, clocks: Clocks) -> Self
-                where
-                    TXPIN: TxPin<$USART>,
-                    RXPIN: RxPin<$USART>,
                 {
+                    let mut serial = Serial { usart, pins };
+                    serial.enable(baud_rate, clocks);
+                    serial
+                }
+            }
+
+            impl<TXPIN> Serial<$USART, TXPIN, ()>
+            where
+                TXPIN: TxPin<$USART>,
+            {
+                /// Creates a new tx-only serial instance
+                pub fn $usarttx(usart: $USART, txpin: TXPIN, baud_rate: Bps, clocks: Clocks) -> Self
+                {
+                    let rxpin = ();
+                    let mut serial = Serial { usart, pins: (txpin, rxpin) };
+                    serial.enable(baud_rate, clocks);
+                    serial
+                }
+            }
+
+            impl<RXPIN> Serial<$USART, (), RXPIN>
+            where
+                RXPIN: RxPin<$USART>,
+            {
+                /// Creates a new tx-only serial instance
+                pub fn $usartrx(usart: $USART, rxpin: RXPIN, baud_rate: Bps, clocks: Clocks) -> Self
+                {
+                    let txpin = ();
+                    let mut serial = Serial { usart, pins: (txpin, rxpin) };
+                    serial.enable(baud_rate, clocks);
+                    serial
+                }
+            }
+
+            impl<TXPIN, RXPIN> Serial<$USART, TXPIN, RXPIN> {
+                fn enable(&mut self, baud_rate: Bps, clocks: Clocks) {
                     // NOTE(unsafe) This executes only during initialisation
                     let rcc = unsafe { &(*crate::stm32::RCC::ptr()) };
 
@@ -204,16 +241,14 @@ macro_rules! usart {
 
                     // Calculate correct baudrate divisor on the fly
                     let brr = clocks.pclk().0 / baud_rate.0;
-                    usart.brr.write(|w| unsafe { w.bits(brr) });
+                    self.usart.brr.write(|w| unsafe { w.bits(brr) });
 
                     // Reset other registers to disable advanced USART features
-                    usart.cr2.reset();
-                    usart.cr3.reset();
+                    self.usart.cr2.reset();
+                    self.usart.cr3.reset();
 
                     // Enable transmission and receiving
-                    usart.cr1.modify(|_, w| w.te().set_bit().re().set_bit().ue().set_bit());
-
-                    Serial { usart, pins }
+                    self.usart.cr1.modify(|_, w| w.te().set_bit().re().set_bit().ue().set_bit());
                 }
 
                 /// Starts listening for an interrupt event
@@ -252,7 +287,7 @@ macro_rules! usart {
 
 #[cfg(feature = "device-selected")]
 usart! {
-    USART1: (usart1, usart1en, apb2enr),
+    USART1: (usart1, usart1tx, usart1rx, usart1en, apb2enr),
 }
 #[cfg(any(
     feature = "stm32f030x8",
@@ -262,21 +297,21 @@ usart! {
     feature = "stm32f072",
 ))]
 usart! {
-    USART2: (usart2, usart2en, apb1enr),
+    USART2: (usart2, usart2tx, usart2rx,usart2en, apb1enr),
 }
 #[cfg(any(
     feature = "stm32f030xc",
     feature = "stm32f070xb",
     feature = "stm32f072",
 ))]
 usart! {
-    USART3: (usart3, usart3en, apb1enr),
-    USART4: (usart4, usart4en, apb1enr),
+    USART3: (usart3, usart3tx, usart3rx,usart3en, apb1enr),
+    USART4: (usart4, usart4tx, usart4rx,usart4en, apb1enr),
 }
 #[cfg(feature = "stm32f030xc")]
 usart! {
-    USART5: (usart5, usart5en, apb1enr),
-    USART6: (usart6, usart6en, apb2enr),
+    USART5: (usart5, usart5tx, usart5rx,usart5en, apb1enr),
+    USART6: (usart6, usart6tx, usart6rx,usart6en, apb2enr),
 }
 
 // It's s needed for the impls, but rustc doesn't recognize that
@@ -313,6 +348,22 @@ where
     }
 }
 
+impl<USART, TXPIN, RXPIN> embedded_hal::serial::Read<u8> for Serial<USART, TXPIN, RXPIN>
+where
+    USART: Deref<Target = SerialRegisterBlock>,
+    RXPIN: RxPin<USART>,
+{
+    type Error = Error;
+
+    /// Tries to read a byte from the uart
+    fn read(&mut self) -> nb::Result<u8, Error> {
+        Rx {
+            usart: &self.usart as *const _,
+        }
+        .read()
+    }
+}
+
 #[cfg(feature = "device-selected")]
 impl<USART> embedded_hal::serial::Write<u8> for Tx<USART>
 where
@@ -349,14 +400,43 @@ where
     }
 }
 
+impl<USART, TXPIN, RXPIN> embedded_hal::serial::Write<u8> for Serial<USART, TXPIN, RXPIN>
+where
+    USART: Deref<Target = SerialRegisterBlock>,
+    TXPIN: TxPin<USART>,
+{
+    type Error = void::Void;
+
+    /// Ensures that none of the previously written words are still buffered
+    fn flush(&mut self) -> nb::Result<(), Self::Error> {
+        Tx {
+            usart: &self.usart as *const _,
+        }
+        .flush()
+    }
+
+    /// Tries to write a byte to the uart
+    /// Fails if the transmit buffer is full
+    fn write(&mut self, byte: u8) -> nb::Result<(), Self::Error> {
+        Tx {
+            usart: &self.usart as *const _,
+        }
+        .write(byte)
+    }
+}
+
 #[cfg(feature = "device-selected")]
 impl<USART, TXPIN, RXPIN> Serial<USART, TXPIN, RXPIN>
 where
     USART: Deref<Target = SerialRegisterBlock>,
 {
     /// Splits the UART Peripheral in a Tx and an Rx part
     /// This is required for sending/receiving
-    pub fn split(self) -> (Tx<USART>, Rx<USART>) {
+    pub fn split(self) -> (Tx<USART>, Rx<USART>)
+    where
+        TXPIN: TxPin<USART>,
+        RXPIN: RxPin<USART>,
+    {
         (
             Tx {
                 usart: &self.usart as *const _,
@@ -366,6 +446,7 @@ where
             },
         )
     }
+
     pub fn release(self) -> (USART, (TXPIN, RXPIN)) {
         (self.usart, self.pins)
     }