adc: multichannel continuous conversion

Author: yjh0502

examples/adc-dma-rx.rs

@@ -5,10 +5,23 @@
 
 use panic_halt as _;
 
-use cortex_m::{asm, singleton};
+use cortex_m::singleton;
+use cortex_m_semihosting::hprintln;
 
 use cortex_m_rt::entry;
-use stm32f1xx_hal::{adc, pac, prelude::*};
+use stm32f1xx_hal::gpio::gpioa::{PA0, PA2};
+use stm32f1xx_hal::{adc, gpio::Analog, pac, prelude::*};
+
+pub struct AdcPins(PA0<Analog>, PA2<Analog>);
+impl adc::SetChannels<AdcPins> for adc::Adc<pac::ADC1> {
+    fn set_samples(&mut self) {
+        self.set_channel_sample_time(0, adc::SampleTime::T_28);
+        self.set_channel_sample_time(2, adc::SampleTime::T_28);
+    }
+    fn set_sequence(&mut self) {
+        self.set_regular_sequence(&[0, 2, 0, 2]);
+    }
+}
 
 #[entry]
 fn main() -> ! {
@@ -34,21 +47,51 @@ fn main() -> ! {
 
     // Configure pa0 as an analog input
     let adc_ch0 = gpioa.pa0.into_analog(&mut gpioa.crl);
+    let adc_ch2 = gpioa.pa2.into_analog(&mut gpioa.crl);
+
+    // single-channel continuous conversion
+    let (adc1, adc_ch0, dma_ch1) = {
+        let adc_dma = adc1.with_dma(adc_ch0, dma_ch1);
+        let buf = singleton!(: [u16; 8] = [0; 8]).unwrap();
+
+        // The read method consumes the buf and self, starts the adc and dma transfer and returns a
+        // RxDma struct. The wait method consumes the RxDma struct, waits for the whole transfer to
+        // be completed and then returns the updated buf and underlying adc_dma struct. For non
+        // blocking, one can call the is_done method of RxDma and only call wait after that method
+        // returns true.
+        let (_buf, adc_dma) = adc_dma.read(buf).wait();
+        hprintln!("single-channel continuous conversion={:?}", _buf).ok();
+
+        // Consumes the AdcDma struct, restores adc configuration to previous state and returns the
+        // Adc struct in normal mode.
+        adc_dma.split()
+    };
+
+    // multi-channel single-shot conversion
+    let (adc1, AdcPins(adc_ch0, adc_ch2), dma_ch1) = {
+        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={:?}", _buf).ok();
+
+        adc_dma.split()
+    };
 
-    let adc_dma = adc1.with_dma(adc_ch0, dma_ch1);
-    let buf = singleton!(: [u16; 8] = [0; 8]).unwrap();
+    // multi-channel continuous conversion
+    let (_adc1, AdcPins(_adc_ch0, _adc_ch2), _dma_ch1) = {
+        let pins = AdcPins(adc_ch0, adc_ch2);
+        let adc_dma = adc1.with_scan_dma::<_, adc::Continuous>(pins, dma_ch1);
+        let buf = singleton!(: [u16; 8] = [0; 8]).unwrap();
 
-    // The read method consumes the buf and self, starts the adc and dma transfer and returns a
-    // RxDma struct. The wait method consumes the RxDma struct, waits for the whole transfer to be
-    // completed and then returns the updated buf and underlying adc_dma struct. For non blocking,
-    // one can call the is_done method of RxDma and only call wait after that method returns true.
-    let (_buf, adc_dma) = adc_dma.read(buf).wait();
-    asm::bkpt();
+        let (_buf, adc_dma) = adc_dma.read(buf).wait();
+        hprintln!("multi-channel continuous conversion={:?}", _buf).ok();
 
-    // Consumes the AdcDma struct, restores adc configuration to previous state and returns the
-    // Adc struct in normal mode.
-    let (_adc1, _adc_ch0, _dma_ch1) = adc_dma.split();
-    asm::bkpt();
+        adc_dma.split()
+    };
 
     loop {}
 }

src/adc.rs

@@ -18,8 +18,8 @@ use crate::pac::ADC3;
 
 /// Continuous mode
 pub struct Continuous;
-/// Scan mode
-pub struct Scan;
+/// Single conversion mode
+pub struct Single;
 
 /// ADC configuration
 pub struct Adc<ADC> {
@@ -567,7 +567,7 @@ impl<PINS> TransferPayload for AdcDma<PINS, Continuous> {
     }
 }
 
-impl<PINS> TransferPayload for AdcDma<PINS, Scan> {
+impl<PINS> TransferPayload for AdcDma<PINS, Single> {
     fn start(&mut self) {
         self.channel.start();
         self.payload.adc.rb.cr2.modify(|_, w| w.adon().set_bit());
@@ -601,7 +601,7 @@ impl Adc<ADC1> {
         }
     }
 
-    pub fn with_scan_dma<PINS>(mut self, pins: PINS, dma_ch: C1) -> AdcDma<PINS, Scan>
+    pub fn with_scan_dma<PINS, T>(mut self, pins: PINS, dma_ch: C1) -> AdcDma<PINS, T>
     where
         Self: SetChannels<PINS>,
     {
@@ -651,7 +651,7 @@ where
     }
 }
 
-impl<PINS> AdcDma<PINS, Scan>
+impl<PINS> AdcDma<PINS, Single>
 where
     Self: TransferPayload,
 {