From 129b7589ca6cc3f26fd75dc860ca4a903aa9b76f Mon Sep 17 00:00:00 2001 From: TheZoq2 Date: Sat, 27 Jun 2020 11:57:47 +0200 Subject: [PATCH 1/7] Improve DMA ergonomics when working with generics --- CHANGELOG.md | 4 ++++ src/dma.rs | 25 +++++++++++++++---------- src/serial.rs | 13 ++++++++++--- src/spi.rs | 10 +++++----- 4 files changed, 34 insertions(+), 18 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 7ddf62ca..435433f3 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](http://semver.org/). ## [Unreleased] +### Breaking changes + +- Replace DMA buffer types with `Deref` ans `Unpin` + ## [v0.6.1] - 2020-06-25 ### Added diff --git a/src/dma.rs b/src/dma.rs index 9628587d..61677300 100644 --- a/src/dma.rs +++ b/src/dma.rs @@ -70,6 +70,11 @@ pub trait TransferPayload { fn stop(&mut self); } +pub trait Transferable { + fn is_done(&self) -> bool; + fn wait(self) -> (BUFFER, DMA); +} + pub struct Transfer { _mode: PhantomData, buffer: BUFFER, @@ -128,7 +133,7 @@ macro_rules! dma { use crate::pac::{$DMAX, dma1}; - use crate::dma::{CircBuffer, DmaExt, Error, Event, Half, Transfer, W, RxDma, TxDma, TransferPayload}; + use crate::dma::{CircBuffer, DmaExt, Error, Event, Half, Transfer, W, RxDma, TxDma, TransferPayload, Transferable}; use crate::rcc::{AHB, Enable}; pub struct Channels((), $(pub $CX),+); @@ -294,15 +299,15 @@ macro_rules! dma { } } - impl Transfer> + impl Transferable> for Transfer> where RxDma: TransferPayload, { - pub fn is_done(&self) -> bool { + fn is_done(&self) -> bool { !self.payload.channel.in_progress() } - pub fn wait(mut self) -> (BUFFER, RxDma) { + fn wait(mut self) -> (BUFFER, RxDma) { while !self.is_done() {} atomic::compiler_fence(Ordering::Acquire); @@ -320,15 +325,15 @@ macro_rules! dma { } } - impl Transfer> + impl Transferable> for Transfer> where TxDma: TransferPayload, { - pub fn is_done(&self) -> bool { + fn is_done(&self) -> bool { !self.payload.channel.in_progress() } - pub fn wait(mut self) -> (BUFFER, TxDma) { + fn wait(mut self) -> (BUFFER, TxDma) { while !self.is_done() {} atomic::compiler_fence(Ordering::Acquire); @@ -496,10 +501,10 @@ where fn read(self, buffer: &'static mut B) -> Transfer; } -pub trait WriteDma: Transmit +pub trait WriteDma: Transmit where - A: as_slice::AsSlice, - B: Static, + B: core::ops::Deref + 'static, + B::Target: as_slice::AsSlice + Unpin, Self: core::marker::Sized, { fn write(self, buffer: B) -> Transfer; diff --git a/src/serial.rs b/src/serial.rs index f8b5d2de..f9d4c28d 100644 --- a/src/serial.rs +++ b/src/serial.rs @@ -44,10 +44,13 @@ use core::sync::atomic::{self, Ordering}; use crate::pac::{USART1, USART2, USART3}; use core::convert::Infallible; + +use as_slice::AsSlice; + use embedded_hal::serial::Write; use crate::afio::MAPR; -use crate::dma::{dma1, CircBuffer, RxDma, Static, Transfer, TxDma, R, W}; +use crate::dma::{dma1, CircBuffer, RxDma, Transfer, TxDma, R, W}; use crate::gpio::gpioa::{PA10, PA2, PA3, PA9}; use crate::gpio::gpiob::{PB10, PB11, PB6, PB7}; use crate::gpio::gpioc::{PC10, PC11}; @@ -637,12 +640,16 @@ macro_rules! serialdma { } } - impl crate::dma::WriteDma for $txdma where A: as_slice::AsSlice, B: Static { + impl crate::dma::WriteDma for $txdma + where + B: core::ops::Deref + 'static, + B::Target: AsSlice + Unpin, + { fn write(mut self, buffer: B ) -> Transfer { { - let buffer = buffer.borrow().as_slice(); + let buffer = (*buffer).as_slice(); self.channel.set_peripheral_address(unsafe{ &(*$USARTX::ptr()).dr as *const _ as u32 }, false); diff --git a/src/spi.rs b/src/spi.rs index b7363ac8..009f919f 100644 --- a/src/spi.rs +++ b/src/spi.rs @@ -41,7 +41,7 @@ use crate::pac::{SPI1, SPI2}; use crate::afio::MAPR; use crate::dma::dma1::{C3, C5}; -use crate::dma::{Static, Transfer, TransferPayload, Transmit, TxDma, R}; +use crate::dma::{Transfer, TransferPayload, Transmit, TxDma, R}; use crate::gpio::gpioa::{PA5, PA6, PA7}; use crate::gpio::gpiob::{PB13, PB14, PB15, PB3, PB4, PB5}; #[cfg(feature = "connectivity")] @@ -450,14 +450,14 @@ macro_rules! spi_dma { } } - impl crate::dma::WriteDma for SpiTxDma<$SPIi, REMAP, PIN, $TCi> + impl crate::dma::WriteDma for SpiTxDma<$SPIi, REMAP, PIN, $TCi> where - A: AsSlice, - B: Static, + B: core::ops::Deref + 'static, + B::Target: as_slice::AsSlice + Unpin, { fn write(mut self, buffer: B) -> Transfer { { - let buffer = buffer.borrow().as_slice(); + let buffer = buffer.as_slice(); self.channel.set_peripheral_address( unsafe { &(*$SPIi::ptr()).dr as *const _ as u32 }, false, From 701eaee717c8a34b8bc9780648ae2d57a4ffea3c Mon Sep 17 00:00:00 2001 From: TheZoq2 Date: Sun, 28 Jun 2020 10:03:29 +0200 Subject: [PATCH 2/7] Add stable deref bound --- Cargo.toml | 4 ++++ src/dma.rs | 3 +++ src/serial.rs | 3 ++- src/spi.rs | 3 ++- 4 files changed, 11 insertions(+), 2 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index c71c8a2e..ba03ac53 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -34,6 +34,10 @@ version = "0.2.2" version = "0.2.3" features = ["unproven"] +[dependencies.stable_deref_trait] +default-features = false +version = "1.1" + [dependencies.stm32-usbd] version = "0.5.0" features = ["ram_access_1x16"] diff --git a/src/dma.rs b/src/dma.rs index 61677300..20e0e1c9 100644 --- a/src/dma.rs +++ b/src/dma.rs @@ -4,6 +4,8 @@ use core::marker::PhantomData; use core::ops; +use stable_deref_trait::StableDeref; + use crate::rcc::AHB; #[derive(Debug)] @@ -505,6 +507,7 @@ pub trait WriteDma: Transmit where B: core::ops::Deref + 'static, B::Target: as_slice::AsSlice + Unpin, + B: StableDeref, Self: core::marker::Sized, { fn write(self, buffer: B) -> Transfer; diff --git a/src/serial.rs b/src/serial.rs index f9d4c28d..160679b9 100644 --- a/src/serial.rs +++ b/src/serial.rs @@ -46,6 +46,7 @@ use crate::pac::{USART1, USART2, USART3}; use core::convert::Infallible; use as_slice::AsSlice; +use stable_deref_trait::StableDeref; use embedded_hal::serial::Write; @@ -642,7 +643,7 @@ macro_rules! serialdma { impl crate::dma::WriteDma for $txdma where - B: core::ops::Deref + 'static, + B: StableDeref + core::ops::Deref + 'static, B::Target: AsSlice + Unpin, { fn write(mut self, buffer: B diff --git a/src/spi.rs b/src/spi.rs index 009f919f..4231a559 100644 --- a/src/spi.rs +++ b/src/spi.rs @@ -53,6 +53,7 @@ use crate::time::Hertz; use core::sync::atomic::{self, Ordering}; use as_slice::AsSlice; +use stable_deref_trait::StableDeref; /// SPI error #[derive(Debug)] @@ -452,7 +453,7 @@ macro_rules! spi_dma { impl crate::dma::WriteDma for SpiTxDma<$SPIi, REMAP, PIN, $TCi> where - B: core::ops::Deref + 'static, + B: StableDeref + core::ops::Deref + 'static, B::Target: as_slice::AsSlice + Unpin, { fn write(mut self, buffer: B) -> Transfer { From 05e0821269d4a08ca673547fbeaeca9cde91d24c Mon Sep 17 00:00:00 2001 From: TheZoq2 Date: Sun, 28 Jun 2020 10:09:21 +0200 Subject: [PATCH 3/7] Cargo fmt --- src/dma.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/dma.rs b/src/dma.rs index 20e0e1c9..61edd0fc 100644 --- a/src/dma.rs +++ b/src/dma.rs @@ -506,7 +506,7 @@ where pub trait WriteDma: Transmit where B: core::ops::Deref + 'static, - B::Target: as_slice::AsSlice + Unpin, + B::Target: as_slice::AsSlice + Unpin, B: StableDeref, Self: core::marker::Sized, { From 71edfcd1cec8b721862746fa83293a195e8d3347 Mon Sep 17 00:00:00 2001 From: Rudi Horn Date: Sun, 5 Jul 2020 09:42:04 +0100 Subject: [PATCH 4/7] add granular circular DMA --- examples/serial-dma-circ-len.rs | 99 ++++++++++++++++++++++++++ src/dma.rs | 121 +++++++++++++++++++++++++++++++- src/serial.rs | 13 +++- 3 files changed, 231 insertions(+), 2 deletions(-) create mode 100644 examples/serial-dma-circ-len.rs diff --git a/examples/serial-dma-circ-len.rs b/examples/serial-dma-circ-len.rs new file mode 100644 index 00000000..7a45a1e8 --- /dev/null +++ b/examples/serial-dma-circ-len.rs @@ -0,0 +1,99 @@ +//! Serial interface circular DMA RX transfer test + +#![deny(unsafe_code)] +#![no_std] +#![no_main] + +use panic_semihosting as _; + +use cortex_m::{asm, singleton}; +use cortex_m_semihosting::{hprint, hprintln}; + +use cortex_m_rt::entry; +use stm32f1xx_hal::{ + dma::CircReadDmaLen, + pac, + prelude::*, + serial::{Config, Serial}, +}; + +#[entry] +fn main() -> ! { + let p = pac::Peripherals::take().unwrap(); + + let mut flash = p.FLASH.constrain(); + let mut rcc = p.RCC.constrain(); + + let clocks = rcc.cfgr.freeze(&mut flash.acr); + + let mut afio = p.AFIO.constrain(&mut rcc.apb2); + let channels = p.DMA1.split(&mut rcc.ahb); + + let mut gpioa = p.GPIOA.split(&mut rcc.apb2); + // let mut gpiob = p.GPIOB.split(&mut rcc.apb2); + + // USART1 + let tx = gpioa.pa9.into_alternate_push_pull(&mut gpioa.crh); + let rx = gpioa.pa10; + + // USART1 + // let tx = gpiob.pb6.into_alternate_push_pull(&mut gpiob.crl); + // let rx = gpiob.pb7; + + // USART2 + // let tx = gpioa.pa2.into_alternate_push_pull(&mut gpioa.crl); + // let rx = gpioa.pa3; + + // USART3 + // let tx = gpiob.pb10.into_alternate_push_pull(&mut gpiob.crh); + // let rx = gpiob.pb11; + + let serial = Serial::usart1( + p.USART1, + (tx, rx), + &mut afio.mapr, + Config::default().baudrate(9_600.bps()), + clocks, + &mut rcc.apb2, + ); + + hprintln!("waiting for 5 bytes").unwrap(); + + let rx = serial.split().1.with_dma(channels.5); + // increase to reasonable size (e.g. 64, 128 etc.) for actual applications + let buf = singleton!(: [u8; 8] = [0; 8]).unwrap(); + + let mut circ_buffer = rx.circ_read_len(buf); + + // wait until we have 5 bytes + while circ_buffer.len() < 5 {} + + let mut dat = [0 as u8; 4]; + assert!(circ_buffer.read(&mut dat[..]) == 4); + + hprintln!("[{}, {}, {}, {}]", dat[0], dat[1], dat[2], dat[3]).unwrap(); + + // try to read again, now only one byte is returned + hprintln!("read {}", circ_buffer.read(&mut dat)).unwrap(); + + hprintln!("[{}]", dat[0]).unwrap(); + + // wait for the buffer to have 4 bytes again + while circ_buffer.len() < 4 {} + + // all four bytes should be read in one go + assert!(circ_buffer.read(&mut dat) == 4); + + hprintln!("[{}, {}, {}, {}]", dat[0], dat[1], dat[2], dat[3]).unwrap(); + + loop { + let read = circ_buffer.read(&mut dat); + + if read > 0 { + for c in &dat[..read]{ + hprint!("{}", *c as char).unwrap(); + } + hprintln!("").unwrap(); + } + } +} diff --git a/src/dma.rs b/src/dma.rs index 61edd0fc..5721d006 100644 --- a/src/dma.rs +++ b/src/dma.rs @@ -26,6 +26,28 @@ pub enum Half { Second, } +type DataSize = crate::stm32::dma1::ch::cr::PSIZE_A; +pub type Priority = crate::stm32::dma1::ch::cr::PL_A; + +pub struct CircBufferLen +where + EL : 'static, +{ + buffer: &'static mut [EL], + payload: PAYLOAD, + position: usize, +} + +impl CircBufferLen { + pub(crate) fn new(buf: &'static mut [EL], payload: PAYLOAD) -> Self { + CircBufferLen { + buffer: buf, + payload, + position: 0, + } + } +} + pub struct CircBuffer where BUFFER: 'static, @@ -130,12 +152,28 @@ macro_rules! dma { }),)+) => { $( pub mod $dmaX { + use core::marker::Copy; + use core::mem::size_of; use core::sync::atomic::{self, Ordering}; use core::ptr; use crate::pac::{$DMAX, dma1}; - use crate::dma::{CircBuffer, DmaExt, Error, Event, Half, Transfer, W, RxDma, TxDma, TransferPayload, Transferable}; + use crate::dma::{ + CircBuffer, + CircBufferLen, + DataSize, + DmaExt, + Error, + Event, + Half, + Priority, + Transfer, + W, + RxDma, + TxDma, + TransferPayload, + Transferable}; use crate::rcc::{AHB, Enable}; pub struct Channels((), $(pub $CX),+); @@ -225,6 +263,79 @@ macro_rules! dma { } } + impl CircBufferLen> + where + RxDma: TransferPayload, + EL: Copy, + { + pub unsafe fn setup(&mut self, peripheral_address : u32, priority: Priority) { + self.payload.channel.set_peripheral_address(peripheral_address, false); + self.payload.channel.set_memory_address(self.buffer.as_ptr() as u32, true); + self.payload.channel.set_transfer_length(self.buffer.len()); + + atomic::compiler_fence(Ordering::Release); + + let bits = match size_of::() { + 1 => DataSize::BITS8, + 2 => DataSize::BITS16, + 4 => DataSize::BITS32, + _ => panic!("Unsupported element size.") + }; + + self.payload.channel.ch().cr.modify(|_, w| { + w.mem2mem().clear_bit() + .pl() .variant(priority) + .circ() .set_bit() + .dir() .clear_bit() + .msize() .variant(bits) + .psize() .variant(bits) + }); + + self.payload.start(); + } + + + /// Return the number of elements available to read + pub fn len(&mut self) -> usize { + let blen = self.buffer.len(); + let ndtr = self.payload.channel.get_ndtr() as usize; + let pos_at = self.position; + + // the position the DMA would write to next + let pos_to = blen - ndtr; + + if pos_at > pos_to { + // the buffer wraps around + blen + pos_to - pos_at + } else { + // the buffer does not wrap around + pos_to - pos_at + } + } + + pub fn read(&mut self, dat: &mut [EL]) -> usize { + let blen = self.buffer.len(); + let len = self.len(); + let pos = self.position; + let read = if dat.len() > len { len } else { dat.len() }; + + if pos + read <= blen { + dat[0..read].copy_from_slice(&self.buffer[pos..pos + read]); + self.position = pos + read; + } else { + let left = blen - pos; + // copy until the end of the buffer + dat[0..left].copy_from_slice(&self.buffer[pos..blen]); + // copy from the beginning of the buffer until the amount to read + dat[left..read].copy_from_slice(&self.buffer[0..read - left]); + self.position = read - left; + } + + + read + } + } + impl CircBuffer> where RxDma: TransferPayload, @@ -487,6 +598,14 @@ pub trait Transmit { type ReceivedWord; } +pub trait CircReadDmaLen: Receive +where + B: as_slice::AsMutSlice, + Self: core::marker::Sized, +{ + fn circ_read_len(self, buffer: &'static mut B) -> CircBufferLen; +} + pub trait CircReadDma: Receive where B: as_slice::AsMutSlice, diff --git a/src/serial.rs b/src/serial.rs index 160679b9..e01e13d5 100644 --- a/src/serial.rs +++ b/src/serial.rs @@ -51,7 +51,7 @@ use stable_deref_trait::StableDeref; use embedded_hal::serial::Write; use crate::afio::MAPR; -use crate::dma::{dma1, CircBuffer, RxDma, Transfer, TxDma, R, W}; +use crate::dma::{dma1, CircBuffer, CircBufferLen, Priority, RxDma, Transfer, TxDma, R, W}; use crate::gpio::gpioa::{PA10, PA2, PA3, PA9}; use crate::gpio::gpiob::{PB10, PB11, PB6, PB7}; use crate::gpio::gpioc::{PC10, PC11}; @@ -588,6 +588,17 @@ macro_rules! serialdma { } } + impl crate::dma::CircReadDmaLen for $rxdma where B: as_slice::AsMutSlice { + fn circ_read_len(self, buffer: &'static mut B) -> CircBufferLen{ + let buffer = buffer.as_mut_slice(); + let paddr = unsafe { &(*$USARTX::ptr()).dr as *const _ as u32 }; + + let mut buf = CircBufferLen::new(buffer, self); + unsafe { buf.setup(paddr, Priority::MEDIUM) }; + buf + } + } + impl crate::dma::CircReadDma for $rxdma where B: as_slice::AsMutSlice { fn circ_read(mut self, buffer: &'static mut [B; 2], ) -> CircBuffer From b485a5b29291fe83b9a64ff433c1bdd054e2783c Mon Sep 17 00:00:00 2001 From: Rudi Horn Date: Sun, 5 Jul 2020 10:00:37 +0100 Subject: [PATCH 5/7] add more comments and ensure position is reset for read till end operations --- examples/serial-dma-circ-len.rs | 2 +- src/dma.rs | 11 +++++++++-- 2 files changed, 10 insertions(+), 3 deletions(-) diff --git a/examples/serial-dma-circ-len.rs b/examples/serial-dma-circ-len.rs index 7a45a1e8..4d5e85b5 100644 --- a/examples/serial-dma-circ-len.rs +++ b/examples/serial-dma-circ-len.rs @@ -6,7 +6,7 @@ use panic_semihosting as _; -use cortex_m::{asm, singleton}; +use cortex_m::{singleton}; use cortex_m_semihosting::{hprint, hprintln}; use cortex_m_rt::entry; diff --git a/src/dma.rs b/src/dma.rs index 5721d006..c0843331 100644 --- a/src/dma.rs +++ b/src/dma.rs @@ -156,6 +156,7 @@ macro_rules! dma { use core::mem::size_of; use core::sync::atomic::{self, Ordering}; use core::ptr; + use core::cmp::min; use crate::pac::{$DMAX, dma1}; @@ -317,12 +318,18 @@ macro_rules! dma { let blen = self.buffer.len(); let len = self.len(); let pos = self.position; - let read = if dat.len() > len { len } else { dat.len() }; + let read = min(dat.len(), len); if pos + read <= blen { + // the read operation does not wrap around the + // circular buffer, perform a single read dat[0..read].copy_from_slice(&self.buffer[pos..pos + read]); self.position = pos + read; + if self.position >= blen { + self.position = 0; + } } else { + // the read operation wraps around the circular buffer, let left = blen - pos; // copy until the end of the buffer dat[0..left].copy_from_slice(&self.buffer[pos..blen]); @@ -331,7 +338,7 @@ macro_rules! dma { self.position = read - left; } - + // return the number of bytes read read } } From 56724ac34365b6172ae2bd5e72af599f399de066 Mon Sep 17 00:00:00 2001 From: Rudi Horn Date: Sun, 12 Jul 2020 10:01:41 +0100 Subject: [PATCH 6/7] rename CircBuffer to CircDoubleBuffer --- examples/adc-dma-circ.rs | 2 +- examples/serial-dma-circ-len.rs | 4 ++-- examples/serial-dma-circ.rs | 2 +- src/adc.rs | 6 +++--- src/dma.rs | 14 +++++++------- src/serial.rs | 8 ++++---- 6 files changed, 18 insertions(+), 18 deletions(-) diff --git a/examples/adc-dma-circ.rs b/examples/adc-dma-circ.rs index dc3a3a4a..d2397831 100644 --- a/examples/adc-dma-circ.rs +++ b/examples/adc-dma-circ.rs @@ -38,7 +38,7 @@ fn main() -> ! { let adc_dma = adc1.with_dma(adc_ch0, dma_ch1); let buf = singleton!(: [[u16; 8]; 2] = [[0; 8]; 2]).unwrap(); - let mut circ_buffer = adc_dma.circ_read(buf); + let mut circ_buffer = adc_dma.circ_double_read(buf); while circ_buffer.readable_half().unwrap() != Half::First {} diff --git a/examples/serial-dma-circ-len.rs b/examples/serial-dma-circ-len.rs index 4d5e85b5..508cf0b5 100644 --- a/examples/serial-dma-circ-len.rs +++ b/examples/serial-dma-circ-len.rs @@ -6,7 +6,7 @@ use panic_semihosting as _; -use cortex_m::{singleton}; +use cortex_m::singleton; use cortex_m_semihosting::{hprint, hprintln}; use cortex_m_rt::entry; @@ -90,7 +90,7 @@ fn main() -> ! { let read = circ_buffer.read(&mut dat); if read > 0 { - for c in &dat[..read]{ + for c in &dat[..read] { hprint!("{}", *c as char).unwrap(); } hprintln!("").unwrap(); diff --git a/examples/serial-dma-circ.rs b/examples/serial-dma-circ.rs index 956bb970..f474c74f 100644 --- a/examples/serial-dma-circ.rs +++ b/examples/serial-dma-circ.rs @@ -59,7 +59,7 @@ fn main() -> ! { let rx = serial.split().1.with_dma(channels.5); let buf = singleton!(: [[u8; 8]; 2] = [[0; 8]; 2]).unwrap(); - let mut circ_buffer = rx.circ_read(buf); + let mut circ_buffer = rx.circ_double_read(buf); while circ_buffer.readable_half().unwrap() != Half::First {} diff --git a/src/adc.rs b/src/adc.rs index f6cd520b..79625343 100644 --- a/src/adc.rs +++ b/src/adc.rs @@ -3,7 +3,7 @@ use core::marker::PhantomData; use embedded_hal::adc::{Channel, OneShot}; -use crate::dma::{dma1::C1, CircBuffer, Receive, RxDma, Transfer, TransferPayload, W}; +use crate::dma::{dma1::C1, CircDoubleBuffer, Receive, RxDma, Transfer, TransferPayload, W}; use crate::gpio::Analog; use crate::gpio::{gpioa, gpiob, gpioc}; use crate::rcc::{Clocks, Enable, Reset, APB2}; @@ -672,7 +672,7 @@ where Self: TransferPayload, B: as_slice::AsMutSlice, { - fn circ_read(mut self, buffer: &'static mut [B; 2]) -> CircBuffer { + fn circ_double_read(mut self, buffer: &'static mut [B; 2]) -> CircDoubleBuffer { { let buffer = buffer[0].as_mut_slice(); self.channel @@ -701,7 +701,7 @@ where self.start(); - CircBuffer::new(buffer, self) + CircDoubleBuffer::new(buffer, self) } } diff --git a/src/dma.rs b/src/dma.rs index c0843331..d800d62c 100644 --- a/src/dma.rs +++ b/src/dma.rs @@ -31,7 +31,7 @@ pub type Priority = crate::stm32::dma1::ch::cr::PL_A; pub struct CircBufferLen where - EL : 'static, + EL: 'static, { buffer: &'static mut [EL], payload: PAYLOAD, @@ -48,7 +48,7 @@ impl CircBufferLen { } } -pub struct CircBuffer +pub struct CircDoubleBuffer where BUFFER: 'static, { @@ -57,9 +57,9 @@ where readable_half: Half, } -impl CircBuffer { +impl CircDoubleBuffer { pub(crate) fn new(buf: &'static mut [BUFFER; 2], payload: PAYLOAD) -> Self { - CircBuffer { + CircDoubleBuffer { buffer: buf, payload, readable_half: Half::Second, @@ -161,8 +161,8 @@ macro_rules! dma { use crate::pac::{$DMAX, dma1}; use crate::dma::{ - CircBuffer, CircBufferLen, + CircDoubleBuffer, DataSize, DmaExt, Error, @@ -343,7 +343,7 @@ macro_rules! dma { } } - impl CircBuffer> + impl CircDoubleBuffer> where RxDma: TransferPayload, { @@ -618,7 +618,7 @@ where B: as_slice::AsMutSlice, Self: core::marker::Sized, { - fn circ_read(self, buffer: &'static mut [B; 2]) -> CircBuffer; + fn circ_double_read(self, buffer: &'static mut [B; 2]) -> CircDoubleBuffer; } pub trait ReadDma: Receive diff --git a/src/serial.rs b/src/serial.rs index e01e13d5..e3f3aa6b 100644 --- a/src/serial.rs +++ b/src/serial.rs @@ -51,7 +51,7 @@ use stable_deref_trait::StableDeref; use embedded_hal::serial::Write; use crate::afio::MAPR; -use crate::dma::{dma1, CircBuffer, CircBufferLen, Priority, RxDma, Transfer, TxDma, R, W}; +use crate::dma::{dma1, CircBufferLen, CircDoubleBuffer, Priority, RxDma, Transfer, TxDma, R, W}; use crate::gpio::gpioa::{PA10, PA2, PA3, PA9}; use crate::gpio::gpiob::{PB10, PB11, PB6, PB7}; use crate::gpio::gpioc::{PC10, PC11}; @@ -600,8 +600,8 @@ macro_rules! serialdma { } impl crate::dma::CircReadDma for $rxdma where B: as_slice::AsMutSlice { - fn circ_read(mut self, buffer: &'static mut [B; 2], - ) -> CircBuffer + fn circ_double_read(mut self, buffer: &'static mut [B; 2], + ) -> CircDoubleBuffer { { let buffer = buffer[0].as_mut_slice(); @@ -623,7 +623,7 @@ macro_rules! serialdma { self.start(); - CircBuffer::new(buffer, self) + CircDoubleBuffer::new(buffer, self) } } From 6a653b091e1ad5907f89a31a544766be492552a8 Mon Sep 17 00:00:00 2001 From: Rudi Horn Date: Sun, 12 Jul 2020 10:06:29 +0100 Subject: [PATCH 7/7] rename CircBufferLen to CircBuffer, similarly rename traits --- src/adc.rs | 2 +- src/dma.rs | 16 ++++++++-------- src/serial.rs | 10 +++++----- 3 files changed, 14 insertions(+), 14 deletions(-) diff --git a/src/adc.rs b/src/adc.rs index 79625343..c265d1aa 100644 --- a/src/adc.rs +++ b/src/adc.rs @@ -667,7 +667,7 @@ where } } -impl crate::dma::CircReadDma for AdcDma +impl crate::dma::CircDoubleReadDma for AdcDma where Self: TransferPayload, B: as_slice::AsMutSlice, diff --git a/src/dma.rs b/src/dma.rs index d800d62c..95d89434 100644 --- a/src/dma.rs +++ b/src/dma.rs @@ -29,7 +29,7 @@ pub enum Half { type DataSize = crate::stm32::dma1::ch::cr::PSIZE_A; pub type Priority = crate::stm32::dma1::ch::cr::PL_A; -pub struct CircBufferLen +pub struct CircBuffer where EL: 'static, { @@ -38,9 +38,9 @@ where position: usize, } -impl CircBufferLen { +impl CircBuffer { pub(crate) fn new(buf: &'static mut [EL], payload: PAYLOAD) -> Self { - CircBufferLen { + CircBuffer { buffer: buf, payload, position: 0, @@ -161,7 +161,7 @@ macro_rules! dma { use crate::pac::{$DMAX, dma1}; use crate::dma::{ - CircBufferLen, + CircBuffer, CircDoubleBuffer, DataSize, DmaExt, @@ -264,7 +264,7 @@ macro_rules! dma { } } - impl CircBufferLen> + impl CircBuffer> where RxDma: TransferPayload, EL: Copy, @@ -605,15 +605,15 @@ pub trait Transmit { type ReceivedWord; } -pub trait CircReadDmaLen: Receive +pub trait CircReadDma: Receive where B: as_slice::AsMutSlice, Self: core::marker::Sized, { - fn circ_read_len(self, buffer: &'static mut B) -> CircBufferLen; + fn circ_read(self, buffer: &'static mut B) -> CircBuffer; } -pub trait CircReadDma: Receive +pub trait CircDoubleReadDma: Receive where B: as_slice::AsMutSlice, Self: core::marker::Sized, diff --git a/src/serial.rs b/src/serial.rs index e3f3aa6b..82826e7a 100644 --- a/src/serial.rs +++ b/src/serial.rs @@ -51,7 +51,7 @@ use stable_deref_trait::StableDeref; use embedded_hal::serial::Write; use crate::afio::MAPR; -use crate::dma::{dma1, CircBufferLen, CircDoubleBuffer, Priority, RxDma, Transfer, TxDma, R, W}; +use crate::dma::{dma1, CircBuffer, CircDoubleBuffer, Priority, RxDma, Transfer, TxDma, R, W}; use crate::gpio::gpioa::{PA10, PA2, PA3, PA9}; use crate::gpio::gpiob::{PB10, PB11, PB6, PB7}; use crate::gpio::gpioc::{PC10, PC11}; @@ -588,18 +588,18 @@ macro_rules! serialdma { } } - impl crate::dma::CircReadDmaLen for $rxdma where B: as_slice::AsMutSlice { - fn circ_read_len(self, buffer: &'static mut B) -> CircBufferLen{ + impl crate::dma::CircReadDma for $rxdma where B: as_slice::AsMutSlice { + fn circ_read(self, buffer: &'static mut B) -> CircBuffer{ let buffer = buffer.as_mut_slice(); let paddr = unsafe { &(*$USARTX::ptr()).dr as *const _ as u32 }; - let mut buf = CircBufferLen::new(buffer, self); + let mut buf = CircBuffer::new(buffer, self); unsafe { buf.setup(paddr, Priority::MEDIUM) }; buf } } - impl crate::dma::CircReadDma for $rxdma where B: as_slice::AsMutSlice { + impl crate::dma::CircDoubleReadDma for $rxdma where B: as_slice::AsMutSlice { fn circ_double_read(mut self, buffer: &'static mut [B; 2], ) -> CircDoubleBuffer {