Struct Adc 

pub struct Adc<'d, T: Instance> { /* private fields */ }

Analog to Digital driver.

Implementations

impl<'d, T: DefaultInstance> Adc<'d, T>

pub fn init_watchdog( &mut self, channels: WatchdogChannels, low_threshold: u16, high_threshold: u16, ) -> AnalogWatchdog<'_, 'd, T>

Configure the analog window watchdog to monitor one or more ADC channels

high_threshold and low_threshold are expressed in the same way as ADC results. The format depends on the values of CFGR1.ALIGN and CFGR1.RES.

impl<'d, T: DefaultInstance> Adc<'d, T>

pub fn new( adc: Peri<'d, T>, _irq: impl Binding<T::Interrupt, InterruptHandler<T>> + 'd, ) -> Self

pub fn power_down(&mut self)

Power down the ADC.

This stops ADC operation and powers down ADC-specific circuitry. Later reads will enable the ADC again, but internal measurement paths such as VREFINT or temperature sensing may need to be re-enabled.

pub fn enable_vref(&self) -> VrefInt

pub fn enable_temperature(&self) -> Temperature

pub fn enable_auto_off(&self)

pub fn disable_auto_off(&self)

pub fn set_resolution(&mut self, resolution: Resolution)

pub fn set_ckmode(&mut self, ckmode: Ckmode)

impl<'d, T: Instance> Adc<'d, T>

pub async fn irq_read( &mut self, channel: &mut impl AdcChannel<T>, sample_time: <T::Regs as BasicAdcRegs>::SampleTime, ) -> u16

Read an ADC pin async using the irq handler.

pub fn blocking_read( &mut self, channel: &mut impl AdcChannel<T>, sample_time: <T::Regs as BasicAdcRegs>::SampleTime, ) -> u16

Read an ADC pin.

pub async fn read<'a, 'b: 'a, D: RxDma<T>>( &mut self, rx_dma: Peri<'a, D>, irq: impl Binding<D::Interrupt, InterruptHandler<D>> + 'a, sequence: impl ExactSizeIterator<Item = (&'a mut AnyAdcChannel<'b, T>, <T::Regs as BasicAdcRegs>::SampleTime)>, readings: &mut [u16], )

Read one or multiple ADC regular channels using DMA.

readings must have a length that is a multiple of the length of the sequence iterator.

Example

use embassy_stm32::adc::{Adc, AdcChannel}

let mut adc = Adc::new(p.ADC1);
let mut adc_pin0 = p.PA0.into();
let mut adc_pin1 = p.PA1.into();
let mut measurements = [0u16; 2];

adc.read(
    p.DMA1_CH2.reborrow(),
    Irqs,
    [
        (&mut *adc_pin0, SampleTime::CYCLES160_5),
        (&mut *adc_pin1, SampleTime::CYCLES160_5),
    ]
    .into_iter(),
    &mut measurements,
)
.await;
defmt::info!("measurements: {}", measurements);

Note: This is not very efficient as the ADC needs to be reconfigured for each read. Use into_ring_buffered, into_ring_buffered_and_injected

Note: Depending on hardware limitations, this method may require channels to be passed in order or require the sequence to have the same sample time for all channnels, depending on the number and properties of the channels in the sequence. This method will panic if the hardware cannot deliver the requested configuration.

Trait Implementations

impl<'d, T: Instance> Drop for Adc<'d, T>

Available on adc_v2 or adc_v3 or adc_g0 or adc_h5 or adc_h7rs or adc_u0 or adc_v4 or adc_u3 or adc_u5 or adc_wba or adc_g4 or adc_c0 or adc_v1 or adc_l0 or adc_f1 only.

fn drop(&mut self)

Executes the destructor for this type.