unify ringbuffered versions

4 files changed, 189 insertions, 257 deletions

diff --git a/embassy-stm32/src/adc/ringbuffered_v3.rs b/embassy-stm32/src/adc/ringbuffered.rs
index 0aee309e3..bea981fe2 100644
--- a/embassy-stm32/src/adc/ringbuffered_v3.rs
+++ b/embassy-stm32/src/adc/ringbuffered.rs
@@ -1,21 +1,33 @@
 use core::marker::PhantomData;
 use core::sync::atomic::{Ordering, compiler_fence};
 
+#[allow(unused_imports)]
 use embassy_hal_internal::Peri;
 
+#[allow(unused_imports)]
 use crate::adc::{Instance, RxDma};
+#[allow(unused_imports)]
 use crate::dma::{ReadableRingBuffer, TransferOptions};
 use crate::rcc;
 
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub struct OverrunError;
 
+#[cfg(adc_v2)]
+fn clear_interrupt_flags(r: crate::pac::adc::Adc) {
+    r.sr().modify(|regs| {
+        regs.set_eoc(false);
+        regs.set_ovr(false);
+    });
+}
+
 pub struct RingBufferedAdc<'d, T: Instance> {
     pub _phantom: PhantomData<T>,
     pub ring_buf: ReadableRingBuffer<'d, u16>,
 }
 
 impl<'d, T: Instance> RingBufferedAdc<'d, T> {
+    #[cfg(not(adc_v2))]
     pub(crate) fn new(dma: Peri<'d, impl RxDma<T>>, dma_buf: &'d mut [u16]) -> Self {
         //dma side setup
         let opts = TransferOptions {
@@ -36,6 +48,116 @@ impl<'d, T: Instance> RingBufferedAdc<'d, T> {
         }
     }
 
+    #[cfg(adc_v2)]
+    fn is_on() -> bool {
+        T::regs().cr2().read().adon()
+    }
+
+    #[cfg(adc_v2)]
+    /// Turns on ADC if it is not already turned on and starts continuous DMA transfer.
+    pub fn start(&mut self) -> Result<(), OverrunError> {
+        self.setup_adc();
+        self.ring_buf.clear();
+
+        Ok(())
+    }
+
+    #[cfg(adc_v2)]
+    fn stop(&mut self, err: OverrunError) -> Result<usize, OverrunError> {
+        self.teardown_adc();
+        Err(err)
+    }
+
+    #[cfg(adc_v2)]
+    /// Stops DMA transfer.
+    /// It does not turn off ADC.
+    /// Calling `start` restarts continuous DMA transfer.
+    ///
+    /// [`start`]: #method.start
+    pub fn teardown_adc(&mut self) {
+        // Stop the DMA transfer
+        self.ring_buf.request_pause();
+
+        let r = T::regs();
+
+        // Stop ADC
+        r.cr2().modify(|reg| {
+            // Stop ADC
+            reg.set_swstart(false);
+            // Stop DMA
+            reg.set_dma(false);
+        });
+
+        r.cr1().modify(|w| {
+            // Disable interrupt for end of conversion
+            w.set_eocie(false);
+            // Disable interrupt for overrun
+            w.set_ovrie(false);
+        });
+
+        clear_interrupt_flags(r);
+
+        compiler_fence(Ordering::SeqCst);
+    }
+
+    #[cfg(adc_v2)]
+    fn setup_adc(&mut self) {
+        use crate::pac::adc::vals;
+
+        compiler_fence(Ordering::SeqCst);
+
+        self.ring_buf.start();
+
+        let r = T::regs();
+
+        // Enable ADC
+        let was_on = Self::is_on();
+        if !was_on {
+            r.cr2().modify(|reg| {
+                reg.set_adon(false);
+                reg.set_swstart(false);
+            });
+        }
+
+        // Clear all interrupts
+        r.sr().modify(|regs| {
+            regs.set_eoc(false);
+            regs.set_ovr(false);
+            regs.set_strt(false);
+        });
+
+        r.cr1().modify(|w| {
+            // Enable interrupt for end of conversion
+            w.set_eocie(true);
+            // Enable interrupt for overrun
+            w.set_ovrie(true);
+            // Scanning converisons of multiple channels
+            w.set_scan(true);
+            // Continuous conversion mode
+            w.set_discen(false);
+        });
+
+        r.cr2().modify(|w| {
+            // Enable DMA mode
+            w.set_dma(true);
+            // Enable continuous conversions
+            w.set_cont(true);
+            // DMA requests are issues as long as DMA=1 and data are converted.
+            w.set_dds(vals::Dds::CONTINUOUS);
+            // EOC flag is set at the end of each conversion.
+            w.set_eocs(vals::Eocs::EACH_CONVERSION);
+        });
+
+        // Begin ADC conversions
+        T::regs().cr2().modify(|reg| {
+            reg.set_adon(true);
+            reg.set_swstart(true);
+        });
+
+        super::blocking_delay_us(3);
+    }
+
+    #[cfg(any(adc_v3, adc_g0, adc_h5, adc_h7rs, adc_u0))]
     #[inline]
     fn start_continuous_sampling(&mut self) {
         // Start adc conversion
@@ -45,6 +167,7 @@ impl<'d, T: Instance> RingBufferedAdc<'d, T> {
         self.ring_buf.start();
     }
 
+    #[cfg(any(adc_v3, adc_g0, adc_h5, adc_h7rs, adc_u0))]
     #[inline]
     pub fn stop_continuous_sampling(&mut self) {
         // Stop adc conversion
@@ -55,12 +178,15 @@ impl<'d, T: Instance> RingBufferedAdc<'d, T> {
             while T::regs().cr().read().adstart() {}
         }
     }
+
+    #[cfg(any(adc_v3, adc_g0, adc_h5, adc_h7rs, adc_u0))]
     pub fn disable_adc(&mut self) {
         self.stop_continuous_sampling();
         self.ring_buf.clear();
         self.ring_buf.request_pause();
     }
 
+    #[cfg(any(adc_v3, adc_g0, adc_h5, adc_h7rs, adc_u0))]
     pub fn teardown_adc(&mut self) {
         self.disable_adc();
 
@@ -133,9 +259,25 @@ impl<'d, T: Instance> RingBufferedAdc<'d, T> {
 
         let r = T::regs();
 
-        // Start background receive if it was not already started
-        if !r.cr().read().adstart() {
-            self.start_continuous_sampling();
+        #[cfg(adc_v2)]
+        {
+            // Start background receive if it was not already started
+            if !r.cr2().read().dma() {
+                self.start()?;
+            }
+        }
+
+        #[cfg(not(adc_v2))]
+        {
+            // Clear overrun flag if set.
+            if r.sr().read().ovr() {
+                return self.stop(OverrunError);
+            }
+
+            // Start background receive if it was not already started
+            if !r.cr().read().adstart() {
+                self.start_continuous_sampling();
+            }
         }
 
         self.ring_buf.read_exact(measurements).await.map_err(|_| OverrunError)
@@ -152,20 +294,48 @@ impl<'d, T: Instance> RingBufferedAdc<'d, T> {
     pub fn blocking_read(&mut self, buf: &mut [u16]) -> Result<usize, OverrunError> {
         let r = T::regs();
 
-        // Start background receive if it was not already started
-        if !r.cr().read().adstart() {
-            self.start_continuous_sampling();
-        }
+        #[cfg(adc_v2)]
+        {
+            // Start background receive if it was not already started
+            if !r.cr2().read().dma() {
+                self.start()?;
+            }
 
-        loop {
-            match self.ring_buf.read(buf) {
-                Ok((0, _)) => {}
-                Ok((len, _)) => {
-                    return Ok(len);
+            // Clear overrun flag if set.
+            if r.sr().read().ovr() {
+                return self.stop(OverrunError);
+            }
+
+            loop {
+                match self.ring_buf.read(buf) {
+                    Ok((0, _)) => {}
+                    Ok((len, _)) => {
+                        return Ok(len);
+                    }
+                    Err(_) => {
+                        return self.stop(OverrunError);
+                    }
                 }
-                Err(_) => {
-                    self.stop_continuous_sampling();
-                    return Err(OverrunError);
+            }
+        }
+
+        #[cfg(not(adc_v2))]
+        {
+            // Start background receive if it was not already started
+            if !r.cr().read().adstart() {
+                self.start_continuous_sampling();
+            }
+
+            loop {
+                match self.ring_buf.read(buf) {
+                    Ok((0, _)) => {}
+                    Ok((len, _)) => {
+                        return Ok(len);
+                    }
+                    Err(_) => {
+                        self.stop_continuous_sampling();
+                        return Err(OverrunError);
+                    }
                 }
             }
         }
diff --git a/embassy-stm32/src/adc/ringbuffered_v2.rs b/embassy-stm32/src/adc/ringbuffered_v2.rs
deleted file mode 100644
index c520daea4..000000000
--- a/embassy-stm32/src/adc/ringbuffered_v2.rs
+++ /dev/null
@@ -1,238 +0,0 @@
-use core::marker::PhantomData;
-use core::sync::atomic::{Ordering, compiler_fence};
-
-use crate::adc::Instance;
-use crate::dma::ReadableRingBuffer;
-use crate::pac::adc::vals;
-use crate::rcc;
-
-#[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub struct OverrunError;
-
-fn clear_interrupt_flags(r: crate::pac::adc::Adc) {
-    r.sr().modify(|regs| {
-        regs.set_eoc(false);
-        regs.set_ovr(false);
-    });
-}
-
-pub struct RingBufferedAdc<'d, T: Instance> {
-    pub(super) _phantom: PhantomData<T>,
-    pub(super) ring_buf: ReadableRingBuffer<'d, u16>,
-}
-
-impl<'d, T: Instance> RingBufferedAdc<'d, T> {
-    fn is_on() -> bool {
-        T::regs().cr2().read().adon()
-    }
-
-    /// Turns on ADC if it is not already turned on and starts continuous DMA transfer.
-    pub fn start(&mut self) -> Result<(), OverrunError> {
-        self.setup_adc();
-        self.ring_buf.clear();
-
-        Ok(())
-    }
-
-    fn stop(&mut self, err: OverrunError) -> Result<usize, OverrunError> {
-        self.teardown_adc();
-        Err(err)
-    }
-
-    /// Stops DMA transfer.
-    /// It does not turn off ADC.
-    /// Calling `start` restarts continuous DMA transfer.
-    ///
-    /// [`start`]: #method.start
-    pub fn teardown_adc(&mut self) {
-        // Stop the DMA transfer
-        self.ring_buf.request_pause();
-
-        let r = T::regs();
-
-        // Stop ADC
-        r.cr2().modify(|reg| {
-            // Stop ADC
-            reg.set_swstart(false);
-            // Stop DMA
-            reg.set_dma(false);
-        });
-
-        r.cr1().modify(|w| {
-            // Disable interrupt for end of conversion
-            w.set_eocie(false);
-            // Disable interrupt for overrun
-            w.set_ovrie(false);
-        });
-
-        clear_interrupt_flags(r);
-
-        compiler_fence(Ordering::SeqCst);
-    }
-
-    fn setup_adc(&mut self) {
-        compiler_fence(Ordering::SeqCst);
-
-        self.ring_buf.start();
-
-        let r = T::regs();
-
-        // Enable ADC
-        let was_on = Self::is_on();
-        if !was_on {
-            r.cr2().modify(|reg| {
-                reg.set_adon(false);
-                reg.set_swstart(false);
-            });
-        }
-
-        // Clear all interrupts
-        r.sr().modify(|regs| {
-            regs.set_eoc(false);
-            regs.set_ovr(false);
-            regs.set_strt(false);
-        });
-
-        r.cr1().modify(|w| {
-            // Enable interrupt for end of conversion
-            w.set_eocie(true);
-            // Enable interrupt for overrun
-            w.set_ovrie(true);
-            // Scanning converisons of multiple channels
-            w.set_scan(true);
-            // Continuous conversion mode
-            w.set_discen(false);
-        });
-
-        r.cr2().modify(|w| {
-            // Enable DMA mode
-            w.set_dma(true);
-            // Enable continuous conversions
-            w.set_cont(true);
-            // DMA requests are issues as long as DMA=1 and data are converted.
-            w.set_dds(vals::Dds::CONTINUOUS);
-            // EOC flag is set at the end of each conversion.
-            w.set_eocs(vals::Eocs::EACH_CONVERSION);
-        });
-
-        // Begin ADC conversions
-        T::regs().cr2().modify(|reg| {
-            reg.set_adon(true);
-            reg.set_swstart(true);
-        });
-
-        super::blocking_delay_us(3);
-    }
-
-    /// Read bytes that are readily available in the ring buffer.
-    /// If no bytes are currently available in the buffer the call waits until the some
-    /// bytes are available (at least one byte and at most half the buffer size)
-    ///
-    /// Background receive is started if `start()` has not been previously called.
-    ///
-    /// Receive in the background is terminated if an error is returned.
-    /// It must then manually be started again by calling `start()` or by re-calling `read()`.
-    pub fn blocking_read<const N: usize>(&mut self, buf: &mut [u16; N]) -> Result<usize, OverrunError> {
-        let r = T::regs();
-
-        // Start background receive if it was not already started
-        if !r.cr2().read().dma() {
-            self.start()?;
-        }
-
-        // Clear overrun flag if set.
-        if r.sr().read().ovr() {
-            return self.stop(OverrunError);
-        }
-
-        loop {
-            match self.ring_buf.read(buf) {
-                Ok((0, _)) => {}
-                Ok((len, _)) => {
-                    return Ok(len);
-                }
-                Err(_) => {
-                    return self.stop(OverrunError);
-                }
-            }
-        }
-    }
-
-    /// Reads measurements from the DMA ring buffer.
-    ///
-    /// This method fills the provided `measurements` array with ADC readings from the DMA buffer.
-    /// The length of the `measurements` array should be exactly half of the DMA buffer length. Because interrupts are only generated if half or full DMA transfer completes.
-    ///
-    /// Each call to `read` will populate the `measurements` array in the same order as the channels defined with `set_sample_sequence`.
-    /// There will be many sequences worth of measurements in this array because it only returns if at least half of the DMA buffer is filled.
-    /// For example if 3 channels are sampled `measurements` contain: `[sq0 sq1 sq3 sq0 sq1 sq3 sq0 sq1 sq3 sq0 sq1 sq3..]`.
-    ///
-    /// If an error is returned, it indicates a DMA overrun, and the process must be restarted by calling `start` or `read` again.
-    ///
-    /// By default, the ADC fills the DMA buffer as quickly as possible. To control the sample rate, call `teardown_adc` after each readout, and then start the DMA again at the desired interval.
-    /// Note that even if using `teardown_adc` to control the sample rate, with each call to `read`, measurements equivalent to half the size of the DMA buffer are still collected.
-    ///
-    /// Example:
-    /// ```rust,ignore
-    /// const DMA_BUF_LEN: usize = 120;
-    /// let adc_dma_buf = [0u16; DMA_BUF_LEN];
-    /// let mut adc: RingBufferedAdc<embassy_stm32::peripherals::ADC1> = adc.into_ring_buffered(p.DMA2_CH0, adc_dma_buf);
-    ///
-    /// adc.set_sample_sequence(Sequence::One, &mut p.PA0, SampleTime::CYCLES112);
-    /// adc.set_sample_sequence(Sequence::Two, &mut p.PA1, SampleTime::CYCLES112);
-    /// adc.set_sample_sequence(Sequence::Three, &mut p.PA2, SampleTime::CYCLES112);
-    ///
-    /// let mut measurements = [0u16; DMA_BUF_LEN / 2];
-    /// loop {
-    ///     match adc.read(&mut measurements).await {
-    ///         Ok(_) => {
-    ///             defmt::info!("adc1: {}", measurements);
-    ///             // Only needed to manually control sample rate.
-    ///             adc.teardown_adc();
-    ///         }
-    ///         Err(e) => {
-    ///             defmt::warn!("Error: {:?}", e);
-    ///             // DMA overrun, next call to `read` restarts ADC.
-    ///         }
-    ///     }
-    ///
-    ///     // Manually control sample rate.
-    ///     Timer::after_millis(100).await;
-    /// }
-    /// ```
-    ///
-    ///
-    /// [`set_sample_sequence`]: #method.set_sample_sequence
-    /// [`teardown_adc`]: #method.teardown_adc
-    /// [`start`]: #method.start
-    pub async fn read<const N: usize>(&mut self, measurements: &mut [u16; N]) -> Result<usize, OverrunError> {
-        assert_eq!(
-            self.ring_buf.capacity() / 2,
-            N,
-            "Buffer size must be half the size of the ring buffer"
-        );
-
-        let r = T::regs();
-
-        // Start background receive if it was not already started
-        if !r.cr2().read().dma() {
-            self.start()?;
-        }
-
-        // Clear overrun flag if set.
-        if r.sr().read().ovr() {
-            return self.stop(OverrunError);
-        }
-        match self.ring_buf.read_exact(measurements).await {
-            Ok(len) => Ok(len),
-            Err(_) => self.stop(OverrunError),
-        }
-    }
-}
-
-impl<T: Instance> Drop for RingBufferedAdc<'_, T> {
-    fn drop(&mut self) {
-        self.teardown_adc();
-        rcc::disable::<T>();
-    }
-}
diff --git a/embassy-stm32/src/adc/v2.rs b/embassy-stm32/src/adc/v2.rs
index 44e655b45..e57cd19b3 100644
--- a/embassy-stm32/src/adc/v2.rs
+++ b/embassy-stm32/src/adc/v2.rs
@@ -8,8 +8,8 @@ use crate::peripherals::ADC1;
 use crate::time::Hertz;
 use crate::{Peri, rcc};
 
-mod ringbuffered_v2;
-pub use ringbuffered_v2::RingBufferedAdc;
+mod ringbuffered;
+pub use ringbuffered::RingBufferedAdc;
 
 /// Default VREF voltage used for sample conversion to millivolts.
 pub const VREF_DEFAULT_MV: u32 = 3300;
diff --git a/embassy-stm32/src/adc/v3.rs b/embassy-stm32/src/adc/v3.rs
index d9a3ce21d..8a0cc0fcf 100644
--- a/embassy-stm32/src/adc/v3.rs
+++ b/embassy-stm32/src/adc/v3.rs
@@ -14,10 +14,10 @@ use super::{
 };
 
 #[cfg(any(adc_v3, adc_g0, adc_u0))]
-mod ringbuffered_v3;
+mod ringbuffered;
 
 #[cfg(any(adc_v3, adc_g0, adc_u0))]
-use ringbuffered_v3::RingBufferedAdc;
+use ringbuffered::RingBufferedAdc;
 
 use crate::dma::Transfer;
 use crate::{Peri, pac, rcc};