Improve UART module by systick timeout

Author: JalonWong

examples/f103c8/src/main.rs

@@ -154,10 +154,8 @@ fn uart_poll_init<U: UartPeriphExt>(
     tx: uart::Tx<U>,
     rx: uart::Rx<U>,
 ) -> UartPollTask<impl embedded_io::Write, impl embedded_io::Read> {
-    let (uart_tx, uart_rx) = (
-        tx.into_poll(RetryTimes::new(0), 10_000),
-        rx.into_poll(RetryTimes::new(0), 1_000),
-    );
+    let uart_rx = rx.into_poll(RetryTimes::new(0), RetryTimes::new(1_000));
+    let uart_tx = tx.into_poll(RetryTimes::new(0), RetryTimes::new(10_000));
     UartPollTask::new(32, uart_tx, uart_rx)
 }
 
@@ -167,8 +165,9 @@ fn uart_interrupt_init<U: UartPeriphExt + 'static>(
     interrupt_callback: &hal::interrupt::Callback,
     mcu: &mut Mcu,
 ) -> UartPollTask<impl embedded_io::Write + 'static, impl embedded_io::Read + 'static> {
-    let (tx, mut tx_it) = tx.into_interrupt(64, 0, 10_000);
-    let (rx, mut rx_it) = rx.into_interrupt(64, 0);
+    let (rx, mut rx_it) = rx.into_interrupt(64, SysTickTimeout::new(100));
+    let (tx, mut tx_it) =
+        tx.into_interrupt(64, SysTickTimeout::new(0), SysTickTimeout::new(20_000));
     interrupt_callback.set(mcu, move || {
         rx_it.handler();
         tx_it.handler();
@@ -184,9 +183,14 @@ fn uart_dma_init<'r, U: UartPeriphExt + 'static>(
     dma_rx: impl DmaBindRx<U> + 'r,
     mcu: &mut Mcu,
 ) -> UartPollTask<impl embedded_io::Write + 'static, impl embedded_io::Read + 'r> {
-    let uart_rx = rx.into_dma_circle(dma_rx, 64);
+    let uart_rx = rx.into_dma_circle(dma_rx, 64, SysTickTimeout::new(100));
     dma_tx.set_interrupt(DmaEvent::TransferComplete, true);
-    let (uart_tx, mut tx_it) = tx.into_dma_ringbuf(dma_tx, 32);
+    let (uart_tx, mut tx_it) = tx.into_dma_ringbuf(
+        dma_tx,
+        32,
+        SysTickTimeout::new(0),
+        SysTickTimeout::new(20_000),
+    );
     interrupt_callback.set(mcu, move || {
         tx_it.interrupt_reload();
     });

src/common/uart/uart_dma.rs

@@ -1,94 +1,145 @@
 use super::*;
-use crate::common::dma::*;
+use crate::common::{dma::*, os::*};
 use embedded_io::{ErrorType, Read, Write};
 
 // TX -------------------------------------------------------------------------
 
-pub struct UartDmaBufTx<U, CH> {
+pub struct UartDmaBufTx<U, CH, T> {
     _uart: U,
     w: DmaRingbufTxWriter<u8, CH>,
+    timeout: T,
+    flush_timeout: T,
 }
 
-impl<U, CH> UartDmaBufTx<U, CH>
+impl<U, CH, T> UartDmaBufTx<U, CH, T>
 where
     U: UartPeriph,
     CH: DmaChannel,
+    T: Timeout,
 {
-    pub fn new(mut uart: U, dma_ch: CH, buf_size: usize) -> (Self, DmaRingbufTxLoader<u8, CH>) {
+    pub fn new(
+        mut uart: U,
+        dma_ch: CH,
+        buf_size: usize,
+        timeout: T,
+        flush_timeout: T,
+    ) -> (Self, DmaRingbufTxLoader<u8, CH>) {
         uart.enable_dma_tx(true);
         let (w, l) = DmaRingbufTx::new(dma_ch, uart.get_tx_data_reg_addr(), buf_size);
-        (Self { _uart: uart, w }, l)
+        (
+            Self {
+                _uart: uart,
+                w,
+                timeout,
+                flush_timeout,
+            },
+            l,
+        )
     }
 }
 
-impl<U, CH> ErrorType for UartDmaBufTx<U, CH>
+impl<U, CH, T> ErrorType for UartDmaBufTx<U, CH, T>
 where
     U: UartPeriph,
     CH: DmaChannel,
+    T: Timeout,
 {
     type Error = Error;
 }
 
-impl<U, CH> Write for UartDmaBufTx<U, CH>
+impl<U, CH, T> Write for UartDmaBufTx<U, CH, T>
 where
     U: UartPeriph,
     CH: DmaChannel,
+    T: Timeout,
 {
     #[inline(always)]
     fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
-        // TODO block
-        if let n @ 1.. = self.w.write(buf) {
-            Ok(n)
-        } else {
-            Err(Error::Busy)
+        if buf.len() == 0 {
+            return Err(Error::Other);
         }
+
+        let mut t = self.timeout.start();
+        loop {
+            if let n @ 1.. = self.w.write(buf) {
+                return Ok(n);
+            } else if t.timeout() {
+                break;
+            }
+            t.interval();
+        }
+        Err(Error::Busy)
     }
 
     fn flush(&mut self) -> Result<(), Self::Error> {
-        // TODO
-        Ok(())
+        let mut t = self.flush_timeout.start();
+        loop {
+            if !self.w.in_progress() {
+                return Ok(());
+            } else if t.timeout() {
+                break;
+            }
+            t.interval();
+        }
+        Err(Error::Other)
     }
 }
 
 // RX -------------------------------------------------------------------------
 
-pub struct UartDmaRx<U, CH> {
+pub struct UartDmaRx<U, CH, T> {
     _uart: U,
     ch: DmaCircularBufferRx<u8, CH>,
+    timeout: T,
 }
 
-impl<U, CH> UartDmaRx<U, CH>
+impl<U, CH, T> UartDmaRx<U, CH, T>
 where
     U: UartPeriph,
     CH: DmaChannel,
+    T: Timeout,
 {
-    pub fn new(mut uart: U, dma_ch: CH, buf_size: usize) -> Self {
+    pub fn new(mut uart: U, dma_ch: CH, buf_size: usize, timeout: T) -> Self {
         let ch = DmaCircularBufferRx::<u8, CH>::new(dma_ch, uart.get_rx_data_reg_addr(), buf_size);
         uart.enable_dma_rx(true);
-        Self { _uart: uart, ch }
+        Self {
+            _uart: uart,
+            ch,
+            timeout,
+        }
     }
 }
 
-impl<U, CH> ErrorType for UartDmaRx<U, CH>
+impl<U, CH, T> ErrorType for UartDmaRx<U, CH, T>
 where
     U: UartPeriph,
     CH: DmaChannel,
+    T: Timeout,
 {
     type Error = Error;
 }
 
-impl<U, CH> Read for UartDmaRx<U, CH>
+impl<U, CH, T> Read for UartDmaRx<U, CH, T>
 where
     U: UartPeriph,
     CH: DmaChannel,
+    T: Timeout,
 {
     fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
-        // TODO block
-        if let Some(d) = self.ch.read(buf.len()) {
-            buf[..d.len()].copy_from_slice(d);
-            Ok(d.len())
-        } else {
-            Err(Error::Other)
+        if buf.len() == 0 {
+            return Err(Error::Other);
+        }
+
+        let mut t = self.timeout.start();
+        loop {
+            if let Some(d) = self.ch.read(buf.len()) {
+                buf[..d.len()].copy_from_slice(d);
+                return Ok(d.len());
+            } else if t.timeout() {
+                break;
+            }
+            t.interval();
         }
+        Err(Error::Other)
     }
 }