modm API documentation
modm::platform::AdcInterrupt1 Class Reference

#include <modm/platform/adc/adc_interrupt_1.hpp>

Inheritance diagram for modm::platform::AdcInterrupt1:
modm::platform::Adc1 modm::AdcInterrupt modm::Adc modm::PeripheralDriver

Public Typedefs

typedef uint8_t Channel
 this type may also be an enum or enum class
 

Public Types

enum  CalibrationMode : uint32_t { SingleEndedInputsMode = 0, DifferntialInputsMode = ADC_CR_ADCALDIF, DoNotCalibrate = 0xff }
 
enum  Channel : uint8_t {
  Channel1 = 1, Channel2 = 2, Channel3 = 3, Channel4 = 4,
  Channel5 = 5, Channel6 = 6, Channel7 = 7, Channel8 = 8,
  Channel9 = 9, Channel10 = 10, Channel11 = 11, Channel12 = 12,
  Channel14 = 14, Channel15 = 15, Opamp1 = 13, Temperature = 16,
  BatDiv3 = 17, InternalReference = 18
}
 Channels, which can be used with this ADC.
 
enum  ClockMode : uint32_t {
  DoNotChange = 0xff, Asynchronous = 0, SynchronousPrescaler1 = ADC_CCR_CKMODE_0, SynchronousPrescaler2 = ADC_CCR_CKMODE_1,
  SynchronousPrescaler4 = ADC_CCR_CKMODE_1 | ADC_CCR_CKMODE_0
}
 
enum  ClockSource : uint32_t { NoClock = 0, Pll = RCC_CCIPR_ADC12SEL_0, SystemClock = RCC_CCIPR_ADC12SEL_1 }
 
enum  DmaMode : uint32_t { Disabled = 0, OneShot = ADC_CFGR_DMAEN, Circular = ADC_CFGR_DMACFG | ADC_CFGR_DMAEN, Mask = Circular }
 
enum  Interrupt : uint32_t {
  Ready = ADC_IER_ADRDYIE, EndOfSampling = ADC_IER_EOSMPIE, EndOfRegularConversion = ADC_IER_EOCIE, EndOfRegularSequenceOfConversions = ADC_IER_EOSIE,
  Overrun = ADC_IER_OVRIE, EndOfInjectedConversion = ADC_IER_JEOCIE, EndOfInjectedSequenceOfConversions = ADC_IER_JEOSIE, AnalogWatchdog1 = ADC_IER_AWD1IE,
  AnalogWatchdog2 = ADC_IER_AWD2IE, AnalogWatchdog3 = ADC_IER_AWD3IE, InjectedContextQueueOverflow = ADC_IER_JQOVFIE
}
 
enum  InterruptFlag : uint32_t {
  Ready = ADC_ISR_ADRDY, EndOfSampling = ADC_ISR_EOSMP, EndOfRegularConversion = ADC_ISR_EOC, EndOfRegularSequenceOfConversions = ADC_ISR_EOS,
  Overrun = ADC_ISR_OVR, EndOfInjectedConversion = ADC_ISR_JEOC, EndOfInjectedSequenceOfConversions = ADC_ISR_JEOS, AnalogWatchdog1 = ADC_ISR_AWD1,
  AnalogWatchdog2 = ADC_ISR_AWD2, AnalogWatchdog3 = ADC_ISR_AWD3, InjectedContextQueueOverflow = ADC_ISR_JQOVF, All = ADC_ISR_ADRDY | ADC_ISR_EOSMP | ADC_ISR_EOC | ADC_ISR_EOS | ADC_ISR_OVR | ADC_ISR_JEOC | ADC_ISR_JEOS | ADC_ISR_AWD1 | ADC_ISR_AWD2 | ADC_ISR_AWD3 | ADC_ISR_JQOVF
}
 
enum  Prescaler : uint32_t {
  Disabled = 0, Div1 = 0, Div2 = ADC_CCR_PRESC_0, Div4 = ADC_CCR_PRESC_1,
  Div6 = ADC_CCR_PRESC_1 | ADC_CCR_PRESC_0, Div8 = ADC_CCR_PRESC_2, Div10 = ADC_CCR_PRESC_2 | ADC_CCR_PRESC_0, Div12 = ADC_CCR_PRESC_2 | ADC_CCR_PRESC_1,
  Div16 = ADC_CCR_PRESC_2 | ADC_CCR_PRESC_1 | ADC_CCR_PRESC_0, Div32 = ADC_CCR_PRESC_3, Div64 = ADC_CCR_PRESC_3 | ADC_CCR_PRESC_0, Div128 = ADC_CCR_PRESC_3 | ADC_CCR_PRESC_1,
  Div256 = ADC_CCR_PRESC_3 | ADC_CCR_PRESC_1 | ADC_CCR_PRESC_0, Div256AllBits = ADC_CCR_PRESC_3 | ADC_CCR_PRESC_2 | ADC_CCR_PRESC_1 | ADC_CCR_PRESC_0
}
 
enum  SampleTime : uint8_t {
  Cycles2 = 0b000, Cycles7 = 0b001, Cycles13 = 0b010, Cycles25 = 0b011,
  Cycles48 = 0b100, Cycles93 = 0b101, Cycles248 = 0b110, Cycles641 = 0b111
}
 
enum  VoltageRegulatorState : uint32_t { Enabled = ADC_CR_ADVREGEN }
 

Public Member Functions

 MODM_FLAGS32 (Interrupt)
 
 MODM_FLAGS32 (InterruptFlag)
 

Static Public Member Functions

static void attachInterruptHandler (Handler handler)
 
static void acknowledgeInterruptFlags (const InterruptFlag_t flags)
 
static void calibrate (const CalibrationMode mode, const bool blocking=true)
 
template<class... Signals>
static void connect ()
 
static volatile uint32_t * dataRegister ()
 
static void disable (const bool blocking=true)
 
static void disableInterrupt (const Interrupt_t interrupt)
 
static void enableInterrupt (const Interrupt_t interrupt)
 
static void enableInterruptVector (const uint32_t priority, const bool enable=true)
 
static auto getInjectedConversionValue (uint8_t index)
 
static InterruptFlag_t getInterruptFlags ()
 
template<class Gpio >
static constexpr Channel getPinChannel ()
 Get the channel for a Pin.
 
static auto getValue ()
 
static void initialize (const ClockMode clk=ClockMode::DoNotChange, const ClockSource clk_src=ClockSource::SystemClock, const Prescaler pre=Prescaler::Disabled, const CalibrationMode cal=CalibrationMode::DoNotCalibrate, const bool blocking=true)
 
static bool isConversionFinished ()
 
static bool isConversionSequenceFinished ()
 
static bool isInjectedConversionFinished ()
 
static bool isReady ()
 
static bool setChannel (const Channel channel, const SampleTime sampleTime=static_cast< SampleTime >(0b000))
 
static bool setChannelSequence (std::span< const SequenceChannel > sequence)
 
static void setDmaMode (DmaMode mode)
 
static void setFreeRunningMode (const bool enable)
 
static bool setInjectedConversionChannel (uint8_t index, Channel channel, SampleTime sampleTime)
 
template<class Gpio >
static bool setInjectedConversionChannel (uint8_t index, SampleTime sampleTime)
 
static bool setInjectedConversionSequenceLength (uint8_t length)
 
static void setLeftAdjustResult (const bool enable)
 
template<class Gpio >
static bool setPinChannel (SampleTime sampleTime=static_cast< SampleTime >(0b000))
 Setting the channel for a Pin.
 
static void setPrescaler (const Prescaler pre)
 
static void startConversion ()
 
static void startInjectedConversionSequence ()
 
static void stopConversion ()
 
static void acknowledgeInterruptFlag ()
 
template<uint64_t available, uint64_t requested, percent_t tolerance>
static void assertBaudrateInTolerance ()
 
template<double available, double requested, percent_t tolerance>
static void assertDurationInTolerance ()
 
static void configurePurpose ()
 configures a peripheral for a specific purpose
 
template<class... Signals>
static void connect ()
 
static void disable ()
 
static void disableFreeRunningMode ()
 
static void enableFreeRunningMode ()
 
static uint8_t getChannel ()
 
static bool getInterruptFlag ()
 Read an interrupt flag.
 
static void getParameter ()
 returns a parameter
 
static uint16_t getValue ()
 
template<class SystemClock , frequency_t frequency = 200_kHz, percent_t tolerance = 10_pct>
static void initialize ()
 
static bool isConversionFinished ()
 
static uint16_t readChannel (Channel channel)
 
static bool setChannel (Channel channel)
 
static void setLeftAdjustResult ()
 Change the presentation of the ADC conversion result to left adjusted.
 
static void setParameter ()
 sets a parameter
 
static void setRightAdjustResult ()
 Change the presentation of the ADC conversion result to right adjusted.
 
static void startConversion ()
 

Static Public Attributes

static Handler handler
 
static constexpr uint8_t Resolution = 12
 
static constexpr uint8_t Resolution
 describes the maximum resolution in bits
 

Protected Typedefs

typedef void (* Handler) ()
 

Detailed Description

ADC Interrupt module

This class allows you to attach functions to the ADC Conversion Complete Interrupt via function pointers. Be aware however, that this implementation is slower and requires more resources than writing the function code directly into the interrupt service routines.

See also
AnalogSensors uses this implemenation.
Author
Niklas Hauser

Member Function Documentation

static void modm::PeripheralDriver::acknowledgeInterruptFlag ( )
inheritedstatic

Acknowledge an interrupt flag.

We use acknowledge here, since it describes the intention rather than the actual implementation.

template<uint64_t available, uint64_t requested, percent_t tolerance>
static void modm::PeripheralDriver::assertBaudrateInTolerance ( )
inheritedinlinestatic

Since baudrates are usually generated by prescaling a system clock, only several distinct values can be generated. This method checks if the user requested baudrate is within error tolerance of the system achievable baudrate.

template<class... Signals>
static void modm::Adc::connect ( )
inheritedstatic

Configures the input signals and connects them.

Template Parameters
SignalsAt least one input signal is required and can be passed out-of-order.
static volatile uint32_t* modm::platform::Adc1::dataRegister ( )
inheritedinlinestatic
Returns
ADC data register pointer, for DMA use only.
static void modm::Adc::disableFreeRunningMode ( )
inheritedstatic

Disables free running mode

The ADC will do only one sample and stop. The result will be in the ADC register.

static void modm::Adc::enableFreeRunningMode ( )
inheritedstatic

Enables free running mode

The ADC will continously start conversions and provide the most recent result in the ADC register.

static uint8_t modm::Adc::getChannel ( )
inheritedstatic
Returns
the currently selected analog channel
static auto modm::platform::Adc1::getInjectedConversionValue ( uint8_t  index)
inheritedinlinestatic

Get result of injected conversion.

Precondition
The injected conversion sequence is completed.
static uint16_t modm::Adc::getValue ( )
inheritedstatic
Returns
the most recent result of any conversion
static auto modm::platform::Adc1::getValue ( )
inheritedinlinestatic
Returns
The most recent result of the ADC conversion.
Precondition
A conversion should have been started with startConversion()

To have a blocking GET you might do it this way:

{
// Waiting for conversion
}
template<class SystemClock , frequency_t frequency = 200_kHz, percent_t tolerance = 10_pct>
static void modm::Adc::initialize ( )
inheritedstatic

Initializes the hardware and sets the datarate.

Template Parameters
SystemClockthe currently active system clock
frequencythe desired clock frequency in Hz
tolerancethe allowed relative tolerance for the resulting clock frequency
static void modm::platform::Adc1::initialize ( const ClockMode  clk = ClockMode::DoNotChange,
const ClockSource  clk_src = ClockSource::SystemClock,
const Prescaler  pre = Prescaler::Disabled,
const CalibrationMode  cal = CalibrationMode::DoNotCalibrate,
const bool  blocking = true 
)
inheritedinlinestatic

Initialize and enable the A/D converter.

Enables the ADC clock and switches on the ADC. The ADC clock prescaler will be set as well.

The ADC can be clocked

Parameters
clkClock Mode for ADC1/ADC2 or ADC3/ADC4. Set to ClockMode::DoNotChange or leave blank if you want to leave this setting untouched.
preThe prescaler for the asynchronous ADC clock. This parameter is only taken into account if clk == ClockMode::Asynchronous.
static bool modm::Adc::isConversionFinished ( )
inheritedstatic
Returns
true if all conversion have finished, false otherwise
static bool modm::platform::Adc1::isConversionFinished ( )
inheritedinlinestatic
Returns
If the conversion is finished.
Precondition
A conversion should have been started with startConversion()
static bool modm::platform::Adc1::isInjectedConversionFinished ( )
inheritedinlinestatic
Returns
If the injected conversion sequence is finished.
Precondition
An injected conversion should have been started with startInjectedConversionSequence()
static bool modm::platform::Adc1::isReady ( )
inheritedinlinestatic

Returns true if the ADRDY bit of the ISR is set

static uint16_t modm::Adc::readChannel ( Channel  channel)
inheritedstatic

Convenience function:

    >
  1. set the channel
  2. starts the conversion
  3. waits until conversion is complete
    Returns
    result of the conversion
static bool modm::Adc::setChannel ( Channel  channel)
inheritedstatic

Analog channel selection.

Returns
true if the channel exists and was available, false otherwise
static bool modm::platform::Adc1::setChannel ( const Channel  channel,
const SampleTime  sampleTime = static_cast< SampleTime >(0b000) 
)
inheritedinlinestatic

Analog channel selection.

This not for scan mode. The number of channels will be set to 1, the channel selected and the corresponding pin will be set to analog input. If the the channel is modified during a conversion, the current conversion is reset and a new start pulse is sent to the ADC to convert the new chosen channnel / group of channels.

Parameters
channelThe channel which shall be read.
sampleTimeThe sample time to sample the input voltage.
Precondition
The ADC clock must be started and the ADC switched on with initialize()
static void modm::platform::Adc1::setFreeRunningMode ( const bool  enable)
inheritedinlinestatic

Enables free running mode

The ADC will continously start conversions and provide the most recent result in the ADC register.

Precondition
The ADC clock must be started and the ADC switched on with initialize()
static bool modm::platform::Adc1::setInjectedConversionChannel ( uint8_t  index,
Channel  channel,
SampleTime  sampleTime 
)
inheritedinlinestatic
  • index Index of injected conversion in sequence (0..3)
    Returns
    true if configuration is successful, false if arguments are invalid
template<class Gpio >
static bool modm::platform::Adc1::setInjectedConversionChannel ( uint8_t  index,
SampleTime  sampleTime 
)
inheritedinlinestatic
  • index Index of injected conversion in sequence (0..3)
    Returns
    true if configuration is successful, false if arguments are invalid
static bool modm::platform::Adc1::setInjectedConversionSequenceLength ( uint8_t  length)
inheritedinlinestatic
  • length Length of injected conversion sequence (1..4)
    Returns
    true if configuration is successful, false if arguments are invalid
static void modm::platform::Adc1::setLeftAdjustResult ( const bool  enable)
inheritedinlinestatic

Change the presentation of the ADC conversion result.

Parameters
enableSet to true to left adjust the result. Otherwise, the result is right adjusted.
Precondition
The ADC clock must be started and the ADC switched on with initialize()
static void modm::platform::Adc1::setPrescaler ( const Prescaler  pre)
inheritedinlinestatic

Select the frequency of the clock to the ADC. The clock is common for ADC1/ADC2 and ADC3/ADC4.

Precondition
The PLL must be running.
Parameters
prescalerThe prescaler specifies by which factor the system clock will be divided.
static void modm::Adc::startConversion ( )
inheritedstatic

starts a conversion on the selected analog channel

Precondition
A channel must be selected with setChannel().
static void modm::platform::Adc1::startConversion ( )
inheritedinlinestatic

Start a new conversion or continuous conversions.

Precondition
A ADC channel must be selected with setChannel().
Postcondition
The result can be fetched with getValue()

TODO: is there any limitation to when is can be called??

static void modm::platform::Adc1::startInjectedConversionSequence ( )
inheritedinlinestatic

Start a new injected conversion sequence.

Precondition
Channels must be selected with setInjectedConversionChannel().

The documentation for this class was generated from the following files: