ADC: Add free() function and fix enable disable functions

Author: Sh3Rm4n

CHANGELOG.md

@@ -18,6 +18,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - Support for GPIO interrupts ([#189])
 - `ld` feature, which enables the memory.x generation ([#216])
 - Implement `DelayMs` for `Milliseconds` and `DelayUs` for `Microseconds` ([#234])
+- ADC can now be `free()`'d ([#212])
 
 ### Changed
 
@@ -329,6 +330,7 @@ let clocks = rcc
 [#220]: https://github.com/stm32-rs/stm32f3xx-hal/pull/220
 [#217]: https://github.com/stm32-rs/stm32f3xx-hal/pull/217
 [#216]: https://github.com/stm32-rs/stm32f3xx-hal/pull/216
+[#212]: https://github.com/stm32-rs/stm32f3xx-hal/pull/212
 [#210]: https://github.com/stm32-rs/stm32f3xx-hal/pull/210
 [#208]: https://github.com/stm32-rs/stm32f3xx-hal/pull/208
 [#203]: https://github.com/stm32-rs/stm32f3xx-hal/issues/203

examples/adc.rs

@@ -32,8 +32,8 @@ fn main() -> ! {
 
     // Set up pin PA0 as analog pin.
     // This pin is connected to the user button on the stm32f3discovery board.
-    let mut gpio_a = dp.GPIOA.split(&mut rcc.ahb);
-    let mut adc1_in1_pin = gpio_a.pa0.into_analog(&mut gpio_a.moder, &mut gpio_a.pupdr);
+    let mut gpioa = dp.GPIOA.split(&mut rcc.ahb);
+    let mut adc1_in1_pin = gpioa.pa0.into_analog(&mut gpioa.moder, &mut gpioa.pupdr);
 
     // Be aware that the values in the table below depend on the input of VREF.
     // To have a stable VREF input, put a condensator and a volt limiting diode in front of it.

src/adc.rs

@@ -339,6 +339,12 @@ macro_rules! adc_hal {
                     this_adc
                 }
 
+                /// Releases the ADC peripheral and associated pins
+                pub fn free(mut self) -> $ADC {
+                    self.disable();
+                    self.rb
+                }
+
                 /// Software can use CkMode::SYNCDIV1 only if
                 /// hclk and sysclk are the same. (see reference manual 15.3.3)
                 fn clocks_welldefined(&self, clocks: Clocks) -> bool {
@@ -373,16 +379,47 @@ macro_rules! adc_hal {
                     self.rb.cfgr.modify(|_, w| w.align().variant(align.into()));
                 }
 
+                /// Software procedure to enable the ADC
+                /// According to RM0316 15.3.9
                 fn enable(&mut self) {
-                    self.rb.cr.modify(|_, w| w.aden().enable());
-                    while self.rb.isr.read().adrdy().is_not_ready() {}
+                    // This check assumes, that the ADC was enabled before and it was waited until
+                    // ADRDY=1 was set.
+                    // This assumption is true, if the peripheral was initially enabled through
+                    // this method.
+                    if !self.rb.cr.read().aden().is_enable() {
+                        // Set ADEN=1
+                        self.rb.cr.modify(|_, w| w.aden().enable());
+                        // Wait until ADRDY=1 (ADRDY is set after the ADC startup time). This can be
+                        // done using the associated interrupt (setting ADRDYIE=1).
+                        while self.rb.isr.read().adrdy().is_not_ready() {}
+                    }
                 }
 
+                /// Disable according to RM0316 15.3.9
                 fn disable(&mut self) {
-                    self.rb.cr.modify(|_, w| w.addis().disable());
+                    // NOTE: Software is allowed to set ADSTP only when ADSTART=1 and ADDIS=0
+                    // (ADC is enabled and eventually converting a regular conversion and there is no
+                    // pending request to disable the ADC)
+                    if self.rb.cr.read().addis().bit() == false
+                        && (self.rb.cr.read().adstart().bit() || self.rb.cr.read().jadstart().bit()) {
+                        self.rb.cr.modify(|_, w| w.adstp().stop());
+                        // NOTE: In auto-injection mode (JAUTO=1), setting ADSTP bit aborts both
+                        // regular and injected conversions (do not use JADSTP)
+                        if !self.rb.cfgr.read().jauto().is_enabled() {
+                            self.rb.cr.modify(|_, w| w.jadstp().stop());
+                        }
+                        while self.rb.cr.read().adstp().bit() || self.rb.cr.read().jadstp().bit() { }
+                    }
+
+                    // NOTE: Software is allowed to set ADDIS only when ADEN=1 and both ADSTART=0
+                    // and JADSTART=0 (which ensures that no conversion is ongoing)
+                    if self.rb.cr.read().aden().is_enable() {
+                        self.rb.cr.modify(|_, w| w.addis().disable());
+                        while self.rb.cr.read().addis().bit() { }
+                    }
                 }
 
-                /// Calibrate according to 15.3.8 in the Reference Manual
+                /// Calibrate according to RM0316 15.3.8
                 fn calibrate(&mut self) {
                     if !self.rb.cr.read().advregen().is_enabled() {
                         self.advregen_enable();
@@ -425,7 +462,9 @@ macro_rules! adc_hal {
 
                 /// busy ADC read
                 fn convert_one(&mut self, chan: u8) -> u16 {
-                    self.ensure_oneshot();
+                    if self.operation_mode != Some(OperationMode::OneShot) {
+                        self.setup_oneshot();
+                    }
                     self.set_chan_smps(chan, SampleTime::default());
                     self.select_single_chan(chan);
 
@@ -435,12 +474,6 @@ macro_rules! adc_hal {
                     return self.rb.dr.read().rdata().bits();
                 }
 
-                fn ensure_oneshot(&mut self) {
-                    if self.operation_mode != Some(OperationMode::OneShot) {
-                        self.setup_oneshot();
-                    }
-                }
-
                 /// This should only be invoked with the defined channels for the particular
                 /// device. (See Pin/Channel mapping above)
                 fn select_single_chan(&self, chan: u8) {
@@ -477,15 +510,16 @@ macro_rules! adc_hal {
 
             }
 
-            impl<WORD, PIN> OneShot<$ADC, WORD, PIN> for Adc<$ADC>
+            impl<Word, Pin> OneShot<$ADC, Word, Pin> for Adc<$ADC>
             where
-                WORD: From<u16>,
-                PIN: Channel<$ADC, ID = u8>,
+                Word: From<u16>,
+                Pin: Channel<$ADC, ID = u8>,
                 {
                     type Error = ();
 
-                    fn read(&mut self, _pin: &mut PIN) -> nb::Result<WORD, Self::Error> {
-                        let res = self.convert_one(PIN::channel());
+                    fn read(&mut self, _pin: &mut Pin) -> nb::Result<Word, Self::Error> {
+                        // TODO: Convert back to previous mode after use.
+                        let res = self.convert_one(Pin::channel());
                         return Ok(res.into());
                     }
                 }

testsuite/tests/adc.rs

@@ -1,7 +1,6 @@
 #![no_std]
 #![no_main]
 
-// TODO: Get pa9 and pa10 because these also implement spi and uart
 use defmt_rtt as _;
 use panic_probe as _;
 
@@ -11,37 +10,25 @@ use hal::adc;
 use hal::gpio::{Analog, Output, PushPull};
 use hal::pac;
 use hal::prelude::*;
-use hal::serial::{Rx, Serial, Tx};
 use hal::{
-    gpio::{
-        gpioa::{PA10, PA2, PA3, PA9},
-        gpiob::{PB10, PB11},
-        gpioc::{PC0, PC1},
-    },
+    gpio::gpioc::{PC0, PC1},
     pac::ADC1_2,
-    rcc::{Clocks, Rcc, AHB},
+    rcc::{Clocks, AHB},
 };
 
-use core::array::IntoIter;
-
-use hal::serial::Error;
-
 struct State {
     adc: Option<adc::Adc<pac::ADC1>>,
     analog: PC0<Analog>,
     output: PC1<Output<PushPull>>,
     ahb: AHB,
-    flash: hal::flash::Parts,
     clocks: Clocks,
     adc1_2: ADC1_2,
 }
 
-const TEST_MSG: [u8; 8] = [0xD, 0xE, 0xA, 0xD, 0xB, 0xE, 0xE, 0xF];
-
 #[defmt_test::tests]
 mod tests {
     use super::*;
-    use defmt::{self, assert, assert_eq, unwrap};
+    use defmt::{self, assert, unwrap};
 
     #[init]
     fn init() -> State {
@@ -54,9 +41,7 @@ mod tests {
 
         State {
             adc: Some(adc::Adc::adc1(
-                dp.ADC1, // The ADC we are going to control
-                // The following is only needed to make sure the clock signal for the ADC is set up
-                // correctly.
+                dp.ADC1,
                 &mut dp.ADC1_2,
                 &mut rcc.ahb,
                 adc::CkMode::default(),
@@ -67,7 +52,6 @@ mod tests {
                 .pc1
                 .into_push_pull_output(&mut gpioc.moder, &mut gpioc.otyper),
             ahb: rcc.ahb,
-            flash,
             clocks,
             adc1_2: dp.ADC1_2,
         }
@@ -76,40 +60,40 @@ mod tests {
     #[test]
     fn measure_pin_high_low(state: &mut State) {
         let mut adc = defmt::unwrap!(state.adc.take());
-        for _ in 1..10 {
+        for _ in 0..10 {
             defmt::unwrap!(state.output.set_high());
             let adc_level: u16 = defmt::unwrap!(adc.read(&mut state.analog).ok());
             defmt::info!("{}", adc_level);
             defmt::unwrap!(state.output.set_low());
             // Vref is 3V so output should reach the maximum.
-            defmt::assert!(adc_level >= 4070 && adc_level <= 4100);
+            assert!(adc_level >= 3900 && adc_level <= 4100);
             let adc_level: u16 = defmt::unwrap!(adc.read(&mut state.analog).ok());
             defmt::info!("{}", adc_level);
-            defmt::assert_eq!(adc_level, 0);
+            // nearly zero (always zero can not be guaranteed)
+            assert!(adc_level <= 100);
         }
 
         // put adc back in place
         state.adc.replace(adc);
     }
 
-    // #[test]
-    // fn free_and_reconfigure(state: &mut State) {
-    //     let mut adc = defmt::unwrap!(state.adc.take());
-    //     defmt::debug!("Free");
-    //     let adc1 = adc.free();
-
-    //     // FIXME: This is not working (stuck on this function)
-    //     defmt::debug!("Reconfigure");
-    //     let new_adc = adc::Adc::adc1(
-    //         adc1,
-    //         &mut state.adc1_2,
-    //         &mut state.ahb,
-    //         adc::CkMode::default(),
-    //         state.clocks,
-    //     );
-
-    //     defmt::debug!("Replace");
-    //     // put adc back in place
-    //     state.adc.replace(new_adc);
-    // }
+    #[test]
+    fn free_and_reconfigure(state: &mut State) {
+        let adc = defmt::unwrap!(state.adc.take());
+        defmt::debug!("Free");
+        let adc1 = adc.free();
+
+        defmt::debug!("Reconfigure");
+        let new_adc = adc::Adc::adc1(
+            adc1,
+            &mut state.adc1_2,
+            &mut state.ahb,
+            adc::CkMode::default(),
+            state.clocks,
+        );
+
+        defmt::debug!("Replace");
+        // put adc back in place
+        state.adc.replace(new_adc);
+    }
 }