Struct rp2040_hal::adc::AdcFifo

pub struct AdcFifo<'a, Word> { /* private fields */ }

Represents the ADC fifo

Constructed by AdcFifoBuilder::start, which is accessible through Adc::build_fifo.

Implementations

impl<'a, Word> AdcFifo<'a, Word>

pub fn len(&mut self) -> u8

Returns the number of elements currently in the fifo

pub fn is_over(&mut self) -> bool

Check if there was a fifo overrun

An overrun happens when the fifo is filled up faster than read is called to consume it.

This function also clears the over bit if it was set.

pub fn is_under(&mut self) -> bool

Check if there was a fifo underrun

An underrun happens when read is called on an empty fifo (len() == 0).

This function also clears the under bit if it was set.

pub fn read_single(&mut self) -> u16

Read the most recently sampled ADC value

Returns the most recently sampled value, bypassing the FIFO.

This can be used if you want to read samples occasionally, but don’t want to incur the 96 cycle delay of a one-off read.

Example:

// start continuously sampling values:
let mut fifo = adc.build_fifo().set_channel(&mut adc_pin).start();

loop {
  do_something_timing_critical();

  // read the most recent value:
  if fifo.read_single() > THRESHOLD {
    led.set_high().unwrap();
  } else {
    led.set_low().unwrap();
  }
}

// stop sampling, when it's no longer needed
fifo.stop();

Note that when round-robin sampling is used, there is no way to tell from which channel this sample came.

pub fn is_paused(&mut self) -> bool

Returns true if conversion is currently paused.

While paused, no samples will be added to the FIFO.

There may be existing samples in the FIFO though, or a conversion may still be in progress.

pub fn pause(&mut self)

Temporarily pause conversion

This method stops ADC conversion, but leaves everything else configured.

No new samples are captured until AdcFifo::resume is called.

Note that existing samples can still be read from the FIFO, and can possibly cause interrupts and DMA transfer progress until the FIFO is emptied.

pub fn resume(&mut self)

Resume conversion after it was paused

There are two situations when it makes sense to use this method:

• After having called AdcFifo::pause on an AdcFifo
• If the FIFO was initialized using AdcFifoBuilder::prepare.

Calling this method when conversion is already running has no effect.

pub fn clear(&mut self)

Clears the FIFO, removing all values

Reads and discards values from the FIFO until it is empty.

This only makes sense to use while the FIFO is paused (see AdcFifo::pause).

pub fn stop(self) -> &'a mut Adc

Stop capturing in free running mode.

Resets all capture options that can be set via AdcFifoBuilder to their defaults.

Returns the underlying Adc, to be reused.

pub fn wait_for_interrupt(&mut self)

Block until a ADC_IRQ_FIFO interrupt occurs

Interrupts must be enabled (AdcFifoBuilder::enable_interrupt), or else this methods blocks forever.

pub fn dma_read_target(&self) -> DmaReadTarget<Word>

Returns a read-target for initiating DMA transfers

The DmaReadTarget returned by this function can be used to initiate DMA transfers reading from the ADC.

pub fn trigger(&mut self)

Trigger a single conversion

Ignored when in Adc::free_running mode.

pub fn is_ready(&self) -> bool

Check if ADC is ready for the next conversion trigger

Not useful when in Adc::free_running mode.

impl<'a> AdcFifo<'a, u16>

pub fn read(&mut self) -> u16

Read a single value from the fifo (u16 version, not shifted)

impl<'a> AdcFifo<'a, u8>

pub fn read(&mut self) -> u8

Read a single value from the fifo (u8 version, shifted)

Also see AdcFifoBuilder::shift_8bit.