adc: check buffer length on DMA

Author: yjh0502

CHANGELOG.md

@@ -18,6 +18,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - Add `QeiOptions` struct to configure slave mode and auto reload value of QEI interface
 - Implement multiplication and division for frequency wrappers (#193)
 - Add support for CRC
+- ADC multichannel continuous conversion
 
 ### Changed
 

examples/adc-dma-rx.rs

@@ -3,7 +3,7 @@
 #![no_main]
 #![no_std]
 
-use panic_halt as _;
+use panic_semihosting as _;
 
 use cortex_m::singleton;
 use cortex_m_semihosting::hprintln;
@@ -72,11 +72,21 @@ fn main() -> ! {
         let pins = AdcPins(adc_ch0, adc_ch2);
         let adc_dma = adc1.with_scan_dma::<_, adc::Single>(pins, dma_ch1);
 
-        // TODO: should match with # of conversions specified by AdcPins
         let buf = singleton!(: [u16; 4] = [0; 4]).unwrap();
+        let (_buf, adc_dma) = adc_dma.read(buf).wait();
+        hprintln!(
+            "multi-channel single-shot conversion, exact buffer={:?}",
+            _buf
+        )
+        .ok();
 
+        let buf = singleton!(: [u16; 8] = [0; 8]).unwrap();
         let (_buf, adc_dma) = adc_dma.read(buf).wait();
-        hprintln!("multi-channel single-shot conversion={:?}", _buf).ok();
+        hprintln!(
+            "multi-channel single-shot conversion, larger buffer={:?}",
+            _buf
+        )
+        .ok();
 
         adc_dma.split()
     };

src/adc.rs

@@ -21,6 +21,22 @@ pub struct Continuous;
 /// Single conversion mode
 pub struct Single;
 
+pub trait ConversionMode {
+    fn is_continuous() -> bool;
+}
+
+impl ConversionMode for Continuous {
+    fn is_continuous() -> bool {
+        true
+    }
+}
+
+impl ConversionMode for Single {
+    fn is_continuous() -> bool {
+        false
+    }
+}
+
 /// ADC configuration
 pub struct Adc<ADC> {
     rb: ADC,
@@ -344,6 +360,11 @@ macro_rules! adc_hal {
                     self.rb.sqr1.modify(|_, w| w.l().bits((len-1) as u8));
                 }
 
+                #[allow(unused)]
+                fn sequence_len(&self) -> usize {
+                    self.rb.sqr1.read().l().bits() as usize + 1
+                }
+
                 /**
                   Performs an ADC conversion
 
@@ -709,15 +730,29 @@ impl<B, PINS, MODE> crate::dma::ReadDma<B, u16> for AdcDma<PINS, MODE>
 where
     Self: TransferPayload,
     B: as_slice::AsMutSlice<Element = u16>,
+    MODE: ConversionMode,
 {
     fn read(mut self, buffer: &'static mut B) -> Transfer<W, &'static mut B, Self> {
         {
             let buffer = buffer.as_mut_slice();
+
+            let conversion_len = if MODE::is_continuous() {
+                buffer.len()
+            } else {
+                // for non-continous conversion, conversion sequence length should match with DMA
+                // transfer length, to prevent DMA from waiting for a conversion indefinitely
+                let sequence_len = self.payload.adc.sequence_len();
+                if buffer.len() < sequence_len {
+                    panic!("short buffer on ADC conversion: buffer.len()={:?}, adc.seqeuence_len()={:?}", buffer.len(), sequence_len);
+                }
+                sequence_len
+            };
+
             self.channel
                 .set_peripheral_address(unsafe { &(*ADC1::ptr()).dr as *const _ as u32 }, false);
             self.channel
                 .set_memory_address(buffer.as_ptr() as u32, true);
-            self.channel.set_transfer_length(buffer.len());
+            self.channel.set_transfer_length(conversion_len);
         }
         atomic::compiler_fence(Ordering::Release);
         self.channel.ch().cr.modify(|_, w| {