Merge #250

250: Allow parallel conversion on multiple ADCs r=richardeoin a=phoracek

This patch splits the current `convert()` method of ADC in two public methods: `start_conversion()` and `read_sample()`. With this, it is now possible to start conversion on multiple ADCs at the same time and then collect results.

There is one issue I'm not sure how to solve - I can call `start_conversion` on one channel and then `read_sample` on another and it would successfully read something. I suppose it would be better to protect user by exploding in case two channels are mixed. Thoughts?

Co-authored-by: Petr Horacek <hrck@protonmail.com>

Author: bors[bot]

CHANGELOG.md

@@ -9,6 +9,7 @@
 * MSRV increased to 1.51.0
 * **Breaking**: Simplified API for reading device signature
   values. `VAL::get().read()` becomes `VAL::read()`
+* adc: Allow parallel execution of multiple ADCs through `start_conversion()`
 
 ## [v0.10.0] 2021-07-xx
 

examples/adc.rs

@@ -2,6 +2,7 @@
 //!
 //! For an example of using ADC3, see examples/temperature.rs
 //! For an example of using ADC1 and ADC2 together, see examples/adc12.rs
+//! For an example of using ADC1 and ADC2 in parallel, see examples/adc12_parallel.rs
 
 #![no_main]
 #![no_std]

examples/adc12.rs

@@ -2,6 +2,7 @@
 //!
 //! For an example of using ADC3, see examples/temperature.rs
 //! For an example of using ADC1 alone, see examples/adc.rs
+//! For an example of using ADC1 and ADC2 in parallel, see examples/adc12_parallel.rs
 
 #![no_main]
 #![no_std]

examples/adc12_parallel.rs

@@ -0,0 +1,98 @@
+//! Example of reading a voltage with ADC1 and ADC2 on two different channels in
+//! parallel
+//!
+//! For an example of using ADC1, see examples/adc.rs
+//! For an example of using ADC3, see examples/temperature.rs
+//! For an example of using ADC1 and ADC2 together, see examples/adc12.rs
+
+#![no_main]
+#![no_std]
+
+use log::info;
+
+use nb::block;
+
+use cortex_m_rt::entry;
+
+use stm32h7xx_hal::{adc, delay::Delay, pac, prelude::*, rcc::rec::AdcClkSel};
+
+#[macro_use]
+mod utilities;
+
+#[entry]
+fn main() -> ! {
+    utilities::logger::init();
+    let cp = cortex_m::Peripherals::take().unwrap();
+    let dp = pac::Peripherals::take().unwrap();
+
+    // Constrain and Freeze power
+    info!("Setup PWR...");
+    let pwr = dp.PWR.constrain();
+    let pwrcfg = example_power!(pwr).freeze();
+
+    // Constrain and Freeze clock
+    info!("Setup RCC...");
+    let rcc = dp.RCC.constrain();
+
+    // We need to configure a clock for adc_ker_ck_input. The default
+    // adc_ker_ck_input is pll2_p_ck, but we will use per_ck. Here we
+    // set per_ck to 4MHz.
+    //
+    // The maximum adc_ker_ck_input frequency is 100MHz for revision V and 36MHz
+    // otherwise
+    let mut ccdr = rcc
+        .sys_ck(100.mhz())
+        .per_ck(4.mhz())
+        .freeze(pwrcfg, &dp.SYSCFG);
+
+    // Switch adc_ker_ck_input multiplexer to per_ck
+    ccdr.peripheral.kernel_adc_clk_mux(AdcClkSel::PER);
+
+    info!("");
+    info!("stm32h7xx-hal example - ADC");
+    info!("");
+
+    let mut delay = Delay::new(cp.SYST, ccdr.clocks);
+
+    // Setup ADC1 and ADC2
+    let (adc1, adc2) = adc::adc12(
+        dp.ADC1,
+        dp.ADC2,
+        &mut delay,
+        ccdr.peripheral.ADC12,
+        &ccdr.clocks,
+    );
+    let mut adc1 = adc1.enable();
+    adc1.set_resolution(adc::Resolution::SIXTEENBIT);
+    adc1.set_sample_time(adc::AdcSampleTime::T_387);
+    let mut adc2 = adc2.enable();
+    adc2.set_resolution(adc::Resolution::SIXTEENBIT);
+    adc2.set_sample_time(adc::AdcSampleTime::T_387);
+
+    // Setup GPIOA
+    let gpioa = dp.GPIOA.split(ccdr.peripheral.GPIOA);
+
+    // Configure pins 23 and 22 as an analog inputs
+    let mut channel1 = gpioa.pa4.into_analog(); // DAISY PIN 23
+    let mut channel2 = gpioa.pa5.into_analog(); // DAISY PIN 22
+
+    loop {
+        adc1.start_conversion(&mut channel1);
+        adc2.start_conversion(&mut channel2);
+
+        let data1 = block!(adc1.read_sample()).unwrap();
+        let data2 = block!(adc2.read_sample()).unwrap();
+
+        // voltage = reading * (vref/resolution)
+        info!(
+            "ADC1 reading: {}, voltage for Daisy pin X: {}",
+            data1,
+            data1 as f32 * (3.3 / adc1.max_sample() as f32)
+        );
+        info!(
+            "ADC2 reading: {}, voltage for Daisy pin X: {}",
+            data2,
+            data2 as f32 * (3.3 / adc2.max_sample() as f32)
+        );
+    }
+}

examples/temperature.rs

@@ -2,6 +2,7 @@
 //!
 //! For an example of using ADC1, see examples/adc.rs
 //! For an example of using ADC1 and ADC2 together, see examples/adc12.rs
+//! For an example of using ADC1 and ADC2 in parallel, see examples/adc12_parallel.rs
 
 #![no_main]
 #![no_std]

src/adc.rs

@@ -6,8 +6,11 @@
 use crate::hal::adc::{Channel, OneShot};
 use crate::hal::blocking::delay::DelayUs;
 
+use core::convert::Infallible;
 use core::marker::PhantomData;
 
+use nb::block;
+
 #[cfg(feature = "rm0455")]
 use crate::stm32::ADC12_COMMON;
 use crate::stm32::{ADC1, ADC2};
@@ -69,6 +72,7 @@ pub struct Adc<ADC, ED> {
     sample_time: AdcSampleTime,
     resolution: Resolution,
     lshift: AdcLshift,
+    current_channel: Option<u8>,
     _enabled: PhantomData<ED>,
 }
 
@@ -467,6 +471,7 @@ macro_rules! adc_hal {
                         sample_time: AdcSampleTime::default(),
                         resolution: Resolution::SIXTEENBIT,
                         lshift: AdcLshift::default(),
+                        current_channel: None,
                         _enabled: PhantomData,
                     }
                 }
@@ -568,6 +573,7 @@ macro_rules! adc_hal {
                         sample_time: self.sample_time,
                         resolution: self.resolution,
                         lshift: self.lshift,
+                        current_channel: None,
                         _enabled: PhantomData,
                     }
                 }
@@ -610,9 +616,17 @@ macro_rules! adc_hal {
                     }
                 }
 
+                /// Start conversion
+                ///
+                /// This method will start reading sequence on the given pin.
+                /// The value can be then read through the `read_sample` method.
                 // Refer to RM0433 Rev 6 - Chapter 24.4.16
-                fn convert(&mut self, chan: u8) -> u32 {
+                pub fn start_conversion<PIN>(&mut self, _pin: &mut PIN)
+                    where PIN: Channel<$ADC, ID = u8>,
+                {
+                    let chan = PIN::channel();
                     assert!(chan <= 19);
+
                     self.check_conversion_conditions();
 
                     // Set resolution
@@ -628,19 +642,32 @@ macro_rules! adc_hal {
                         w.sq1().bits(chan)
                             .l().bits(0)
                     });
+                    self.current_channel = Some(chan);
 
                     // Perform conversion
                     self.rb.cr.modify(|_, w| w.adstart().set_bit());
+                }
 
-                    // Wait until conversion finished
-                    while self.rb.isr.read().eoc().bit_is_clear() {}
+                /// Read sample
+                ///
+                /// `nb::Error::WouldBlock` in case the conversion is still
+                /// progressing.
+                // Refer to RM0433 Rev 6 - Chapter 24.4.16
+                pub fn read_sample(&mut self) -> nb::Result<u32, Infallible> {
+                    let chan = self.current_channel.expect("No channel was selected, use start_conversion first");
+
+                    // Check if the conversion is finished
+                    if self.rb.isr.read().eoc().bit_is_clear() {
+                        return Err(nb::Error::WouldBlock);
+                    }
 
                     // Disable preselection of this channel, refer to RM0433 Rev 6 - Chapter 24.4.12
                     self.rb.pcsel.modify(|r, w| unsafe { w.pcsel().bits(r.pcsel().bits() & !(1 << chan)) });
+                    self.current_channel = None;
 
                     // Retrieve result
                     let result = self.rb.dr.read().bits();
-                    result
+                    nb::Result::Ok(result)
                 }
 
                 fn check_conversion_conditions(&self) {
@@ -678,6 +705,7 @@ macro_rules! adc_hal {
                         sample_time: self.sample_time,
                         resolution: self.resolution,
                         lshift: self.lshift,
+                        current_channel: None,
                         _enabled: PhantomData,
                     }
                 }
@@ -811,8 +839,9 @@ macro_rules! adc_hal {
             {
                 type Error = ();
 
-                fn read(&mut self, _pin: &mut PIN) -> nb::Result<WORD, Self::Error> {
-                    let res = self.convert(PIN::channel());
+                fn read(&mut self, pin: &mut PIN) -> nb::Result<WORD, Self::Error> {
+                    self.start_conversion(pin);
+                    let res = block!(self.read_sample()).unwrap();
                     Ok(res.into())
                 }
             }