Improve UART DMA

Author: JalonWong

.vscode/tasks.json

@@ -15,7 +15,6 @@
                 "kind": "build",
                 "isDefault": true
             },
-
         },
         {
             "label": "build",
@@ -37,6 +36,19 @@
                 "f103c8"
             ],
             "group": "build",
+        },
+        {
+            "label": "Test Windows",
+            "type": "cargo",
+            "command": "test",
+            "args": [
+                "--features=std",
+                "--target=x86_64-pc-windows-msvc",
+            ],
+            "group": {
+                "kind": "test",
+                "isDefault": true
+            },
         }
     ]
 }

Cargo.toml

@@ -15,12 +15,15 @@
         features = ["stm32f103", "xG"]
 
 [features]
-    critical-section-single-core = ["cortex-m/critical-section-single-core"]
-    stm32f100 = ["stm32f1/stm32f100"]
-    stm32f101 = ["stm32f1/stm32f101"]
-    stm32f103 = ["stm32f1/stm32f103"]
-    stm32f105 = ["stm32f1/stm32f107", "connectivity"]
-    stm32f107 = ["stm32f1/stm32f107", "connectivity"]
+    critical-section-single-core = [
+        "cortex-m/critical-section-single-core",
+        "mcu",
+    ]
+    stm32f100 = ["stm32f1/stm32f100", "mcu"]
+    stm32f101 = ["stm32f1/stm32f101", "mcu"]
+    stm32f103 = ["stm32f1/stm32f103", "mcu"]
+    stm32f105 = ["stm32f1/stm32f107", "connectivity", "mcu"]
+    stm32f107 = ["stm32f1/stm32f107", "connectivity", "mcu"]
     x4 = []
     x6 = []
     x8 = ["medium"]
@@ -42,12 +45,15 @@
     has-can = []
     # Devices with Dac
     has-dac = []
+    mcu = ["dep:cortex-m", "dep:cortex-m-rt", "dep:stm32f1"]
     rtic = ["dep:rtic-monotonic"]
+    std = []
 
 [dependencies]
     bitflags = "2.9"
-    cortex-m = "0.7"
-    cortex-m-rt = "0.7"
+    cfg-if = "1.0"
+    cortex-m = { version = "0.7", optional = true }
+    cortex-m-rt = { version = "0.7", optional = true }
     critical-section = "1.2"
     embedded-dma = "0.2"
     embedded-hal = "1.0"
@@ -58,7 +64,7 @@
     nb = "1.1"
     rtic-monotonic = { version = "1.0", optional = true }
     rtrb = { version = "0.3", default-features = false }
-    stm32f1 = { version = "0.16", features = ["atomics"] }
+    stm32f1 = { version = "0.16", optional = true }
 
 [profile.release]
     codegen-units = 1

examples/f103c8/src/main.rs

@@ -5,22 +5,21 @@
 #![allow(unused_mut)]
 
 use core::{mem::MaybeUninit, panic::PanicInfo};
-use stm32f1_hal::gpio::ExtiPin;
-use stm32f1_hal::{self as hal, Steal};
 use stm32f1_hal::{
-    Heap, Mcu,
+    self as hal, Heap, Mcu, Steal,
     afio::{NONE_PIN, RemapDefault},
     cortex_m::asm,
     cortex_m_rt::entry,
+    dma::{DmaBindRx, DmaBindTx, DmaEvent, DmaPriority},
     embedded_hal::{self, pwm::SetDutyCycle},
     embedded_io,
-    gpio::{Edge, PinState},
+    gpio::{Edge, ExtiPin, PinState},
     nvic_scb::PriorityGrouping,
     pac::{self, Interrupt},
     prelude::*,
     rcc,
     timer::*,
-    uart::{self, UartPeriph},
+    uart::{self, UartPeriphExt},
 };
 
 mod led_task;
@@ -49,9 +48,6 @@ fn main() -> ! {
     let mut rcc = dp.RCC.constrain().freeze(cfg, &mut flash.acr);
     assert_eq!(rcc.clocks.sysclk(), sysclk);
 
-    let mut gpioa = dp.GPIOA.split(&mut rcc);
-    let mut gpiob = dp.GPIOB.split(&mut rcc);
-
     let afio = dp.AFIO.constrain(&mut rcc);
     let mut mcu = Mcu {
         scb,
@@ -62,10 +58,16 @@ fn main() -> ! {
     };
 
     // Keep them in one place for easier management
-    mcu.nvic.enable(pac::interrupt::USART1, false); // Optional
+    mcu.nvic.enable(Interrupt::USART1, false); // Optional
     mcu.nvic.set_priority(Interrupt::USART1, 2);
-    mcu.nvic.enable(pac::interrupt::EXTI1, false);
+    mcu.nvic.enable(Interrupt::EXTI1, false);
     mcu.nvic.set_priority(Interrupt::EXTI1, 1);
+    mcu.nvic.enable(Interrupt::DMA1_CHANNEL4, false);
+    mcu.nvic.set_priority(Interrupt::DMA1_CHANNEL4, 2);
+
+    let mut gpioa = dp.GPIOA.split(&mut mcu.rcc);
+    let mut gpiob = dp.GPIOB.split(&mut mcu.rcc);
+    let mut dma1 = dp.DMA1.split(&mut mcu.rcc);
 
     // UART -------------------------------------
 
@@ -85,17 +87,18 @@ fn main() -> ! {
     };
 
     // let mut uart_task = uart_poll_init(uart_tx, uart_rx);
-    let mut uart_task = uart_interrupt_init(
+    // let mut uart_task = uart_interrupt_init(uart_tx, uart_rx, &all_it::USART1_CB, &mut mcu);
+    dma1.4.set_priority(DmaPriority::Medium);
+    dma1.5.set_priority(DmaPriority::Medium);
+    let mut uart_task = uart_dma_init(
         uart_tx,
+        dma1.4,
+        &all_it::DMA1_CHANNEL4_CB,
         uart_rx,
+        dma1.5,
         &mut mcu,
-        pac::interrupt::USART1,
-        &all_it::USART1_CB,
     );
 
-    let dma1 = dp.DMA1.split(&mut mcu.rcc);
-    let dma_rx = dma1.5;
-
     // LED --------------------------------------
 
     let mut led = gpiob
@@ -149,21 +152,20 @@ fn panic(_info: &PanicInfo) -> ! {
     loop {}
 }
 
-fn uart_poll_init<U: UartPeriph>(
+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(0, 10_000), rx.into_poll(0, 1_000));
     UartPollTask::new(32, uart_tx, uart_rx)
 }
 
-fn uart_interrupt_init<U: UartPeriph + 'static>(
+fn uart_interrupt_init<U: UartPeriphExt + 'static>(
     tx: uart::Tx<U>,
     rx: uart::Rx<U>,
-    mcu: &mut Mcu,
-    it_line: pac::interrupt,
     interrupt_callback: &hal::interrupt::Callback,
-) -> UartPollTask<impl embedded_io::Write + use<U>, impl embedded_io::Read + use<U>> {
+    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);
     interrupt_callback.set(mcu, move || {
@@ -173,7 +175,28 @@ fn uart_interrupt_init<U: UartPeriph + 'static>(
     UartPollTask::new(32, tx, rx)
 }
 
+fn uart_dma_init<'r, U: UartPeriphExt + 'static>(
+    tx: uart::Tx<U>,
+    mut dma_tx: impl DmaBindTx<U> + 'static,
+    interrupt_callback: &hal::interrupt::Callback,
+    rx: uart::Rx<U>,
+    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);
+    dma_tx.set_interrupt(DmaEvent::TransferComplete, true);
+    let (uart_tx, mut tx_it) = tx.into_dma_ringbuf(dma_tx, 32);
+    interrupt_callback.set(mcu, move || {
+        tx_it.interrupt_reload();
+    });
+    UartPollTask::new(32, uart_tx, uart_rx)
+}
+
 mod all_it {
     use super::hal::{interrupt_handler, pac::interrupt};
-    interrupt_handler!((USART1, USART1_CB), (EXTI1, EXTI1_CB),);
+    interrupt_handler!(
+        (USART1, USART1_CB),
+        (EXTI1, EXTI1_CB),
+        (DMA1_CHANNEL4, DMA1_CHANNEL4_CB),
+    );
 }

src/common/dma/circular_buffer_rx.rs

@@ -0,0 +1,131 @@
+use super::*;
+use crate::common::os::*;
+
+/// A buffer used for DMA cyclic data reception, continuously read by the user.
+pub struct DmaCircularBufferRx<T: Sized, CH> {
+    ch: CH,
+    buf: CircularBuffer<T>,
+}
+
+impl<T, CH> DmaCircularBufferRx<T, CH>
+where
+    T: Sized + Copy,
+    CH: DmaChannel,
+{
+    pub fn new(mut ch: CH, peripheral_addr: usize, buf_size: usize) -> Self {
+        let buf = CircularBuffer::<T>::new(buf_size);
+        ch.stop();
+        ch.set_memory_buf_for_peripheral(buf.as_slice());
+        ch.set_peripheral_address::<T>(peripheral_addr, false, false, true);
+        ch.start();
+        Self { ch, buf }
+    }
+
+    pub fn read(&mut self, max: usize) -> Option<&[T]> {
+        self.buf.read(self.ch.get_left_len(), max)
+    }
+}
+
+pub struct CircularBuffer<T: Sized> {
+    recv_buf: Vec<T>,
+    read_idx: usize,
+}
+
+impl<T> CircularBuffer<T> {
+    fn new(buf_size: usize) -> Self {
+        let mut recv_buf = Vec::<T>::with_capacity(buf_size);
+        unsafe { recv_buf.set_len(buf_size) }
+
+        Self {
+            recv_buf,
+            read_idx: 0,
+        }
+    }
+
+    fn read(&mut self, left_len: usize, max: usize) -> Option<&[T]> {
+        let dma_recv_idx = if left_len == 0 {
+            0
+        } else {
+            self.recv_buf.len() - left_len
+        };
+
+        if self.read_idx == dma_recv_idx {
+            return None;
+        }
+
+        let ret;
+        if dma_recv_idx < self.read_idx {
+            if max > self.recv_buf.len() - self.read_idx {
+                ret = Some(&self.recv_buf[self.read_idx..]);
+                self.read_idx = 0;
+            } else {
+                let end = self.read_idx + max;
+                ret = Some(&self.recv_buf[self.read_idx..end]);
+                self.read_idx = end;
+            }
+        } else {
+            if max > dma_recv_idx - self.read_idx {
+                ret = Some(&self.recv_buf[self.read_idx..dma_recv_idx]);
+                self.read_idx = dma_recv_idx;
+            } else {
+                let end = self.read_idx + max;
+                ret = Some(&self.recv_buf[self.read_idx..end]);
+                self.read_idx = end;
+            };
+        }
+
+        return ret;
+    }
+
+    fn as_slice(&self) -> &[T] {
+        self.recv_buf.as_slice()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn circular_buffer() {
+        let buf_size = 13;
+        let mut buf = CircularBuffer::new(buf_size);
+        assert_eq!(buf.recv_buf.len(), buf_size);
+
+        for i in 0..buf_size {
+            buf.recv_buf[i] = i as u8;
+        }
+
+        assert_eq!(
+            buf.read(5, usize::MAX),
+            Some([0u8, 1, 2, 3, 4, 5, 6, 7].as_slice())
+        );
+        assert_eq!(buf.read(5, usize::MAX), None);
+        // Single wraparound
+        assert_eq!(
+            buf.read(0, usize::MAX),
+            Some([8u8, 9, 10, 11, 12].as_slice())
+        );
+        assert_eq!(buf.read(0, usize::MAX), None);
+        assert_eq!(buf.read(buf_size, usize::MAX), None);
+        // small max
+        assert_eq!(buf.read(5, 5), Some([0u8, 1, 2, 3, 4].as_slice()));
+        assert_eq!(buf.read(5, 5), Some([5u8, 6, 7].as_slice()));
+        assert_eq!(buf.read(5, 5), None);
+        assert_eq!(
+            buf.read(0, usize::MAX),
+            Some([8u8, 9, 10, 11, 12].as_slice())
+        );
+        // Multiple wraparounds
+        assert_eq!(
+            buf.read(5, usize::MAX),
+            Some([0u8, 1, 2, 3, 4, 5, 6, 7].as_slice())
+        );
+        assert_eq!(
+            buf.read(10, usize::MAX),
+            Some([8u8, 9, 10, 11, 12].as_slice())
+        );
+        assert_eq!(buf.read(10, usize::MAX), Some([0u8, 1, 2].as_slice()));
+        assert_eq!(buf.read(10, usize::MAX), None);
+    }
+}

src/common/dma/mod.rs

@@ -1,8 +1,13 @@
+mod circular_buffer_rx;
+pub use circular_buffer_rx::*;
+mod ringbuf_tx;
+pub use ringbuf_tx::*;
+
 pub trait DmaChannel {
     fn start(&mut self);
     fn stop(&mut self);
 
-    fn set_peripheral_address<T: Sized>(
+    fn set_peripheral_address<T: Sized + Copy>(
         &mut self,
         address: usize,
         mem_to_periph: bool,
@@ -11,12 +16,17 @@ pub trait DmaChannel {
     );
     fn set_memory_address(&mut self, address: usize, increase: bool);
     fn set_transfer_length(&mut self, len: usize);
-    fn set_memory_buf_for_peripheral<T: Sized>(&mut self, buf: &[T]) {
+    fn set_memory_buf_for_peripheral<T: Sized + Copy>(&mut self, buf: &[T]) {
         self.set_memory_address(buf.as_ptr() as usize, true);
         self.set_transfer_length(buf.len());
     }
 
-    fn set_memory_to_memory<T: Sized>(&mut self, src_addr: usize, dst_addr: usize, len: usize);
+    fn set_memory_to_memory<T: Sized + Copy>(
+        &mut self,
+        src_addr: usize,
+        dst_addr: usize,
+        len: usize,
+    );
 
     fn get_left_len(&self) -> usize;
     fn in_progress(&self) -> bool;