Serial: wrap interrupt functions in new traits

this allows consumers to talk about the ISR functions of a `Serial`,
`Rx` or `Tx` in a generic way, namely when using type parameters.
this will be used in the DMA implementation in a next step (see
follow-up commit).

Author: rursprung

src/prelude.rs

@@ -68,7 +68,9 @@ pub use crate::qei::QeiExt as _stm32f4xx_hal_QeiExt;
 pub use crate::rcc::RccExt as _stm32f4xx_hal_rcc_RccExt;
 #[cfg(all(feature = "device-selected", feature = "rng"))]
 pub use crate::rng::RngExt as _stm32f4xx_hal_rng_RngExt;
+pub use crate::serial::RxISR as _stm32f4xx_hal_serial_RxISR;
 pub use crate::serial::SerialExt as _stm32f4xx_hal_serial_SerialExt;
+pub use crate::serial::TxISR as _stm32f4xx_hal_serial_TxISR;
 pub use crate::spi::SpiExt as _stm32f4xx_hal_spi_SpiExt;
 pub use crate::syscfg::SysCfgExt as _stm32f4xx_hal_syscfg_SysCfgExt;
 pub use crate::time::U32Ext as _stm32f4xx_hal_time_U32Ext;

src/serial.rs

@@ -262,19 +262,33 @@ impl<USART: Instance, WORD> Rx<USART, WORD> {
     pub fn unlisten_idle(&mut self) {
         unsafe { (*USART::ptr()).cr1.modify(|_, w| w.idleie().clear_bit()) }
     }
+}
 
+/// Trait for [`Rx`] interrupt handling.
+pub trait RxISR {
     /// Return true if the line idle status is set
-    pub fn is_idle(&self) -> bool {
+    fn is_idle(&self) -> bool;
+
+    /// Return true if the rx register is not empty (and can be read)
+    fn is_rx_not_empty(&self) -> bool;
+
+    /// Clear idle line interrupt flag
+    fn clear_idle_interrupt(&self);
+}
+
+impl<USART: Instance, WORD> RxISR for Rx<USART, WORD> {
+    /// Return true if the line idle status is set
+    fn is_idle(&self) -> bool {
         unsafe { (*USART::ptr()).sr.read().idle().bit_is_set() }
     }
 
     /// Return true if the rx register is not empty (and can be read)
-    pub fn is_rx_not_empty(&self) -> bool {
+    fn is_rx_not_empty(&self) -> bool {
         unsafe { (*USART::ptr()).sr.read().rxne().bit_is_set() }
     }
 
     /// Clear idle line interrupt flag
-    pub fn clear_idle_interrupt(&self) {
+    fn clear_idle_interrupt(&self) {
         unsafe {
             let _ = (*USART::ptr()).sr.read();
             let _ = (*USART::ptr()).dr.read();
@@ -302,9 +316,17 @@ impl<USART: Instance, WORD> Tx<USART, WORD> {
     pub fn unlisten(&mut self) {
         unsafe { (*USART::ptr()).cr1.modify(|_, w| w.txeie().clear_bit()) }
     }
+}
+
+/// Trait for [`Tx`] interrupt handling.
+pub trait TxISR {
+    /// Return true if the tx register is empty (and can accept data)
+    fn is_tx_empty(&self) -> bool;
+}
 
+impl<USART: Instance, WORD> TxISR for Tx<USART, WORD> {
     /// Return true if the tx register is empty (and can accept data)
-    pub fn is_tx_empty(&self) -> bool {
+    fn is_tx_empty(&self) -> bool {
         unsafe { (*USART::ptr()).sr.read().txe().bit_is_set() }
     }
 }
@@ -713,28 +735,32 @@ impl<USART: Instance, PINS, WORD> Serial<USART, PINS, WORD> {
         }
     }
 
-    /// Return true if the line idle status is set
-    pub fn is_idle(&self) -> bool {
-        self.rx.is_idle()
+    pub fn split(self) -> (Tx<USART, WORD>, Rx<USART, WORD>) {
+        (self.tx, self.rx)
     }
+}
 
-    /// Return true if the tx register is empty (and can accept data)
-    pub fn is_tx_empty(&self) -> bool {
-        self.tx.is_tx_empty()
+impl<USART: Instance, PINS, WORD> RxISR for Serial<USART, PINS, WORD> {
+    /// Return true if the line idle status is set
+    fn is_idle(&self) -> bool {
+        self.rx.is_idle()
     }
 
     /// Return true if the rx register is not empty (and can be read)
-    pub fn is_rx_not_empty(&self) -> bool {
+    fn is_rx_not_empty(&self) -> bool {
         self.rx.is_rx_not_empty()
     }
 
     /// Clear idle line interrupt flag
-    pub fn clear_idle_interrupt(&self) {
+    fn clear_idle_interrupt(&self) {
         self.rx.clear_idle_interrupt();
     }
+}
 
-    pub fn split(self) -> (Tx<USART, WORD>, Rx<USART, WORD>) {
-        (self.tx, self.rx)
+impl<USART: Instance, PINS, WORD> TxISR for Serial<USART, PINS, WORD> {
+    /// Return true if the tx register is empty (and can accept data)
+    fn is_tx_empty(&self) -> bool {
+        self.tx.is_tx_empty()
     }
 }