Serial/USART improvements (#122)

* serial: add 7-bit support

* serial: support inverting Tx and Rx pins

* serial: add listen_idle and co

* serial: correct DE handling

Author: agalakhov

src/serial/config.rs

@@ -60,6 +60,8 @@ pub struct BasicConfig {
     pub(crate) wordlength: WordLength,
     pub(crate) parity: Parity,
     pub(crate) stopbits: StopBits,
+    pub(crate) inverted_tx: bool,
+    pub(crate) inverted_rx: bool,
     pub(crate) swap: bool,
 }
 
@@ -69,6 +71,8 @@ pub struct FullConfig {
     pub(crate) wordlength: WordLength,
     pub(crate) parity: Parity,
     pub(crate) stopbits: StopBits,
+    pub(crate) inverted_tx: bool,
+    pub(crate) inverted_rx: bool,
     pub(crate) swap: bool,
     pub(crate) fifo_enable: bool,
     pub(crate) tx_fifo_threshold: FifoThreshold,
@@ -100,6 +104,11 @@ impl BasicConfig {
         self
     }
 
+    pub fn wordlength_7(mut self) -> Self {
+        self.wordlength = WordLength::DataBits7;
+        self
+    }
+
     pub fn wordlength_8(mut self) -> Self {
         self.wordlength = WordLength::DataBits8;
         self
@@ -115,6 +124,16 @@ impl BasicConfig {
         self
     }
 
+    pub fn invert_tx(mut self) -> Self {
+        self.inverted_tx = true;
+        self
+    }
+
+    pub fn invert_rx(mut self) -> Self {
+        self.inverted_rx = true;
+        self
+    }
+
     /// Swap the Tx/Rx pins
     ///
     /// The peripheral will transmit on the pin given as the `rx` argument.
@@ -145,6 +164,11 @@ impl FullConfig {
         self
     }
 
+    pub fn wordlength_7(mut self) -> Self {
+        self.wordlength = WordLength::DataBits7;
+        self
+    }
+
     pub fn wordlength_8(mut self) -> Self {
         self.wordlength = WordLength::DataBits8;
         self
@@ -160,6 +184,16 @@ impl FullConfig {
         self
     }
 
+    pub fn invert_tx(mut self) -> Self {
+        self.inverted_tx = true;
+        self
+    }
+
+    pub fn invert_rx(mut self) -> Self {
+        self.inverted_rx = true;
+        self
+    }
+
     /// Swap the Tx/Rx pins
     ///
     /// The peripheral will transmit on the pin given as the `rx` argument.
@@ -212,6 +246,8 @@ impl Default for BasicConfig {
             wordlength: WordLength::DataBits8,
             parity: Parity::ParityNone,
             stopbits: StopBits::STOP1,
+            inverted_tx: false,
+            inverted_rx: false,
             swap: false,
         }
     }
@@ -225,6 +261,8 @@ impl Default for FullConfig {
             wordlength: WordLength::DataBits8,
             parity: Parity::ParityNone,
             stopbits: StopBits::STOP1,
+            inverted_tx: false,
+            inverted_rx: false,
             swap: false,
             fifo_enable: false,
             tx_fifo_threshold: FifoThreshold::FIFO_8_BYTES,

src/serial/usart.rs

@@ -247,12 +247,13 @@ macro_rules! uart_shared {
         )+
 
         impl<Config> Rx<$USARTX, Config> {
+            /// Listen for a data interrupt event
             pub fn listen(&mut self) {
                 let usart = unsafe { &(*$USARTX::ptr()) };
                 usart.cr1.modify(|_, w| w.rxneie().set_bit());
             }
 
-            /// Stop listening for an interrupt event
+            /// Stop listening for a data interrupt event
             pub fn unlisten(&mut self) {
                 let usart = unsafe { &(*$USARTX::ptr()) };
                 usart.cr1.modify(|_, w| w.rxneie().clear_bit());
@@ -264,6 +265,29 @@ macro_rules! uart_shared {
                 usart.isr.read().rxne().bit_is_set()
             }
 
+            /// Listen for an idle interrupt event
+            pub fn listen_idle(&mut self) {
+                let usart = unsafe { &(*$USARTX::ptr()) };
+                usart.cr1.modify(|_, w| w.idleie().set_bit());
+            }
+
+            /// Stop listening for an idle interrupt event
+            pub fn unlisten_idle(&mut self) {
+                let usart = unsafe { &(*$USARTX::ptr()) };
+                usart.cr1.modify(|_, w| w.idleie().clear_bit());
+            }
+
+            /// Return true if the idle event occured
+            pub fn is_idle(&self) -> bool {
+                let usart = unsafe { &(*$USARTX::ptr()) };
+                usart.isr.read().idle().bit_is_set()
+            }
+
+            /// Clear the idle event flag
+            pub fn clear_idle(&mut self) {
+                let usart = unsafe { &(*$USARTX::ptr()) };
+                usart.icr.write(|w| w.idlecf().set_bit());
+            }
         }
 
         impl<Config> hal::serial::Read<u8> for Rx<$USARTX, Config> {
@@ -477,6 +501,10 @@ macro_rules! uart_basic {
                             StopBits::STOP2 => 0b10,
                             StopBits::STOP1P5 => 0b11,
                         })
+                        .txinv()
+                        .bit(config.inverted_tx)
+                        .rxinv()
+                        .bit(config.inverted_rx)
                         .swap()
                         .bit(config.swap)
                 });
@@ -578,6 +606,10 @@ macro_rules! uart_full {
                 usart.cr2.write(|w| unsafe {
                     w.stop()
                         .bits(config.stopbits.bits())
+                        .txinv()
+                        .bit(config.inverted_tx)
+                        .rxinv()
+                        .bit(config.inverted_rx)
                         .swap()
                         .bit(config.swap)
                 });
@@ -597,6 +629,8 @@ macro_rules! uart_full {
                         .bit(config.tx_fifo_interrupt)
                         .rxftie()
                         .bit(config.rx_fifo_interrupt)
+                        .dem()
+                        .bit(PINS::DRIVER_ENABLE)
                 });
 
                 usart.cr1.modify(|_, w| {
@@ -618,8 +652,6 @@ macro_rules! uart_full {
                         .bit(config.fifo_enable)
                 });
 
-                usart.cr3.write(|w| w.dem().bit(PINS::DRIVER_ENABLE));
-
                 // Enable pins
                 pins.setup();