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(&mut self) -> VrefInt

pub fn enable_temperature(&mut self) -> Temperature

pub fn enable_auto_off(&mut self)

pub fn disable_auto_off(&mut 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)>, trigger: Option<RegularAdcTrigger<T>>, 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)>, irq: impl Binding<D::Interrupt, InterruptHandler<D>> + 'd, ) -> ConfiguredSequence<'adc, T::Regs>

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.

pub fn into_ring_buffered<'a, 'b, D: RxDma<T>>( self, dma: Peri<'a, D>, dma_buf: &'a mut [u16], irq: impl Binding<D::Interrupt, InterruptHandler<D>> + 'a, sequence: impl ExactSizeIterator<Item = (AnyAdcChannel<'b, T>, <T::Regs as BasicAdcRegs>::SampleTime)>, trigger: Option<RegularAdcTrigger<T>>, ) -> RingBufferedAdc<'a, T::Regs>

Configures the ADC to use a DMA ring buffer for continuous data acquisition.

Use the Self::read method to retrieve measurements from the DMA ring buffer. The read buffer should be exactly half the size of dma_buf. When using triggered mode, it is recommended to configure dma_buf as a double buffer so that one half can be read while the other half is being filled by the DMA, preventing data loss. The trigger period of the ADC effectively defines the period at which the buffer should be read.

If continous conversion mode is selected, the provided dma_buf must be large enough to prevent DMA buffer overruns. Its length should be a multiple of the number of ADC channels being measured. For example, if 3 channels are measured and you want to store 40 samples per channel, the buffer length should be 3 * 40 = 120.

Parameters

• dma: The DMA peripheral used to transfer ADC data into the buffer.
• dma_buf: The buffer where DMA stores ADC samples.
• regular_sequence: Sequence of channels and sample times for regular ADC conversions.
• regular_conversion_mode: Mode for regular conversions (continuous or triggered).

Returns

A RingBufferedAdc<'a, T> instance configured for continuous DMA-based sampling.

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 non-adc_f3v3 only.

fn drop(&mut self)

Executes the destructor for this type.