clear_idle_interrupt

Author: burrbull

src/serial.rs

@@ -294,21 +294,29 @@ where
         }
     }
 
-    /// Return true if the line idle status is set
+    /// Returns true if the line idle status is set
     pub fn is_idle(&self) -> bool {
         self.usart.sr.read().idle().bit_is_set()
     }
 
-    /// Return true if the tx register is empty (and can accept data)
+    /// Returns true if the tx register is empty (and can accept data)
     pub fn is_tx_empty(&self) -> bool {
         self.usart.sr.read().txe().bit_is_set()
     }
 
-    /// Return true if the rx register is not empty (and can be read)
+    /// Returns true if the rx register is not empty (and can be read)
     pub fn is_rx_not_empty(&self) -> bool {
         self.usart.sr.read().rxne().bit_is_set()
     }
 
+    /// Clear idle line interrupt flag
+    pub fn clear_idle_interrupt(&self) {
+        unsafe {
+            let _ = (*USART::ptr()).sr.read();
+            let _ = (*USART::ptr()).dr.read();
+        }
+    }
+
     /// Returns ownership of the borrowed register handles
     pub fn release(self) -> (USART, PINS) {
         (self.usart, self.pins)
@@ -383,14 +391,17 @@ impl<USART> Tx<USART>
 where
     USART: Instance,
 {
+    /// Start listening for transmit interrupt event
     pub fn listen(&mut self) {
         unsafe { (*USART::ptr()).cr1.modify(|_, w| w.txeie().set_bit()) };
     }
 
+    /// Stop listening for transmit interrupt event
     pub fn unlisten(&mut self) {
         unsafe { (*USART::ptr()).cr1.modify(|_, w| w.txeie().clear_bit()) };
     }
 
+    /// Returns true if the tx register is empty (and can accept data)
     pub fn is_tx_empty(&self) -> bool {
         unsafe { (*USART::ptr()).sr.read().txe().bit_is_set() }
     }
@@ -400,29 +411,43 @@ impl<USART> Rx<USART>
 where
     USART: Instance,
 {
+    /// Start listening for receive interrupt event
     pub fn listen(&mut self) {
         unsafe { (*USART::ptr()).cr1.modify(|_, w| w.rxneie().set_bit()) };
     }
 
+    /// Stop listening for receive interrupt event
     pub fn unlisten(&mut self) {
         unsafe { (*USART::ptr()).cr1.modify(|_, w| w.rxneie().clear_bit()) };
     }
 
+    /// Start listening for idle interrupt event
     pub fn listen_idle(&mut self) {
         unsafe { (*USART::ptr()).cr1.modify(|_, w| w.idleie().set_bit()) };
     }
 
+    /// Stop listening for idle interrupt event
     pub fn unlisten_idle(&mut self) {
         unsafe { (*USART::ptr()).cr1.modify(|_, w| w.idleie().clear_bit()) };
     }
 
+    /// Returns true if the line idle status is set
     pub fn is_idle(&self) -> bool {
         unsafe { (*USART::ptr()).sr.read().idle().bit_is_set() }
     }
 
+    /// Returns true if the rx register is not empty (and can be read)
     pub 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) {
+        unsafe {
+            let _ = (*USART::ptr()).sr.read();
+            let _ = (*USART::ptr()).dr.read();
+        }
+    }
 }
 
 impl<USART> crate::hal::serial::Read<u8> for Rx<USART>