Struct Adc 

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

Analog to Digital driver.

Implementations

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

pub fn new_with_config(adc: Peri<'d, T>, config: AdcConfig) -> Self

pub fn new(adc: Peri<'d, T>) -> Self

Create a new ADC driver.

pub fn enable_vrefint(&self) -> VrefInt

Enable reading the voltage reference internal channel.

pub fn enable_temperature(&self) -> Temperature

Enable reading the temperature internal channel.

pub fn enable_vbat(&self) -> Vbat

Enable reading the vbat internal channel.

impl<'d, T: Instance<Regs = Adc4>> Adc<'d, T>

pub fn new_adc4(adc: Peri<'d, T>) -> Self

Create a new ADC driver.

pub fn enable_vrefint_adc4(&self) -> VrefInt

Enable reading the voltage reference internal channel.

pub fn enable_temperature_adc4(&self) -> Temperature

Enable reading the temperature internal channel.

pub fn enable_vbat_adc4(&self) -> Vbat

Enable reading the vbat internal channel.

pub fn enable_vcore_adc4(&self) -> Vcore

Enable reading the vbat internal channel.

pub fn enable_dac_channel_adc4(&self, dac: DacChannel) -> Dac

Enable reading the vbat internal channel.

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

Set the ADC resolution.

pub fn set_averaging_adc4(&mut self, averaging: Averaging)

Set hardware averaging.

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

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.

pub fn configured_sequence<'adc, 'ch, D: RxDma<T>>( &'adc mut self, rx_dma: Peri<'adc, D>, sequence: impl ExactSizeIterator<Item = (&'adc mut AnyAdcChannel<'ch, T>, <T::Regs as BasicAdcRegs>::SampleTime)>, buf: &'adc mut [u16], ) -> ConfiguredSequence<'adc, 'd, T, D>

where 'ch: 'adc,

Configure an ADC channel sequence once and return a ConfiguredSequence for repeated DMA reads without reprogramming the sequence each time.

Use Adc::read instead if you only need a single one-shot transfer.

Parameters

• rx_dma: The DMA channel to use for transfers.
• sequence: Iterator of channels and sample times. Maximum 16 entries.
• buf: Output buffer. Must have at least as many entries as sequence.

Returns

A ConfiguredSequence whose read method triggers one DMA conversion of the pre-configured sequence per call.

Notes

• The channel sequence is programmed into the ADC sequence registers once here and remains fixed for the lifetime of the returned ConfiguredSequence.