Arti Zirk
054740c5de
subrepo: subdir: "libopencm3" merged: "88e91c9a7cce" upstream: origin: "https://github.com/libopencm3/libopencm3.git" branch: "master" commit: "88e91c9a7cce" git-subrepo: version: "0.4.3" origin: "???" commit: "???"
731 lines
23 KiB
C
731 lines
23 KiB
C
/** @addtogroup adc_file ADC peripheral API
|
|
* @ingroup peripheral_apis
|
|
*
|
|
* @author @htmlonly © @endhtmlonly 2012
|
|
* Ken Sarkies <ksarkies@internode.on.net>
|
|
*
|
|
* @date 30 August 2012
|
|
*
|
|
* This library supports the A/D Converter Control System in the STM32 series
|
|
* of ARM Cortex Microcontrollers by ST Microelectronics.
|
|
*
|
|
* Devices can have up to three A/D converters each with their own set of
|
|
* registers. However all the A/D converters share a common clock which is
|
|
* prescaled from the APB2 clock by default by a minimum factor of 2 to a
|
|
* maximum of 8. The ADC resolution can be set to 12, 10, 8 or 6 bits.
|
|
*
|
|
* Each A/D converter has up to 19 channels:
|
|
* @li On ADC1 the analog channels 16 is internally connected to the
|
|
* temperature sensor, channel 17 to V<sub>REFINT</sub>, and channel 18
|
|
* to V<sub>BATT</sub>.
|
|
* @li On ADC2 and ADC3 the analog channels 16 - 18 are not used.
|
|
*
|
|
* The conversions can occur as a one-off conversion whereby the process stops
|
|
* once conversion is complete. The conversions can also be continuous wherein
|
|
* a new conversion starts immediately the previous conversion has ended.
|
|
*
|
|
* Conversion can occur as a single channel conversion or a scan of a group of
|
|
* channels in either continuous or one-off mode. If more than one channel is
|
|
* converted in a scan group, DMA must be used to transfer the data as there is
|
|
* only one result register available. An interrupt can be set to occur at the
|
|
* end*
|
|
* of conversion, which occurs after all channels have been scanned.
|
|
*
|
|
* A discontinuous mode allows a subgroup of group of a channels to be
|
|
* converted in bursts of a given length.
|
|
*
|
|
* Injected conversions allow a second group of channels to be converted
|
|
* separately from the regular group. An interrupt can be set to occur at the
|
|
* end of conversion, which occurs after all channels have been scanned.
|
|
*
|
|
* @section adc_f3_api_ex Basic ADC Handling API.
|
|
*
|
|
* Example 1: Simple single channel conversion polled. Enable the peripheral
|
|
* clock and ADC, reset ADC and set the prescaler divider. Set multiple mode to
|
|
* independent.
|
|
*
|
|
* @code
|
|
* gpio_mode_setup(GPIOA, GPIO_MODE_ANALOG, GPIO_PUPD_NONE, GPIO1);
|
|
* rcc_periph_clock_enable(RCC_ADC1);
|
|
* adc_set_clk_prescale(RCC_CFGR_ADCPRE_BY2);
|
|
* adc_disable_scan_mode(ADC1);
|
|
* adc_set_single_conversion_mode(ADC1);
|
|
* adc_set_sample_time(ADC1, ADC_CHANNEL0, ADC_SMPR1_SMP_1DOT5CYC);
|
|
* uint8_t channels[] = ADC_CHANNEL0;
|
|
* adc_set_regular_sequence(ADC1, 1, channels);
|
|
* adc_set_multi_mode(ADC_CCR_DUAL_INDEPENDENT);
|
|
* adc_power_on(ADC1);
|
|
* adc_start_conversion_regular(ADC1);
|
|
* while (! adc_eoc(ADC1));
|
|
* reg16 = adc_read_regular(ADC1);
|
|
* @endcode
|
|
*
|
|
* LGPL License Terms @ref lgpl_license
|
|
*/
|
|
/*
|
|
* This file is part of the libopencm3 project.
|
|
*
|
|
* Copyright (C) 2012 Ken Sarkies <ksarkies@internode.on.net>
|
|
*
|
|
* This library is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Lesser General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
* along with this library. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include <libopencm3/stm32/adc.h>
|
|
|
|
/**@{*/
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
/** @brief ADC Enable Analog Watchdog for Regular Conversions
|
|
*
|
|
* The analog watchdog allows the monitoring of an analog signal between two
|
|
* threshold levels. The thresholds must be preset. Comparison is done before
|
|
* data alignment takes place, so the thresholds are left-aligned.
|
|
*
|
|
* @param[in] adc Unsigned int32. ADC block register address base @ref
|
|
* adc_reg_base
|
|
*/
|
|
|
|
void adc_enable_analog_watchdog_regular(uint32_t adc)
|
|
{
|
|
ADC_CFGR1(adc) |= ADC_CFGR1_AWD1EN;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
/** @brief ADC Enable Analog Watchdog for Regular Conversions
|
|
*
|
|
* The analog watchdog allows the monitoring of an analog signal between two
|
|
* threshold levels. The thresholds must be preset. Comparison is done before
|
|
* data alignment takes place, so the thresholds are left-aligned.
|
|
*
|
|
* @param[in] adc Unsigned int32. ADC block register address base @ref
|
|
* adc_reg_base
|
|
*/
|
|
void adc_disable_analog_watchdog_regular(uint32_t adc)
|
|
{
|
|
ADC_CFGR1(adc) &= ~ADC_CFGR1_AWD1EN;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
/** @brief ADC Enable Analog Watchdog for Injected Conversions
|
|
*
|
|
* The analog watchdog allows the monitoring of an analog signal between two
|
|
* threshold levels. The thresholds must be preset. Comparison is done before
|
|
* data alignment takes place, so the thresholds are left-aligned.
|
|
*
|
|
* @param[in] adc Unsigned int32. ADC block register address base @ref
|
|
* adc_reg_base
|
|
*/
|
|
|
|
void adc_enable_analog_watchdog_injected(uint32_t adc)
|
|
{
|
|
ADC_CFGR1(adc) |= ADC_CFGR1_JAWD1EN;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
/** @brief ADC Disable Analog Watchdog for Injected Conversions
|
|
*
|
|
* @param[in] adc Unsigned int32. ADC block register address base @ref
|
|
* adc_reg_base
|
|
*/
|
|
|
|
void adc_disable_analog_watchdog_injected(uint32_t adc)
|
|
{
|
|
ADC_CFGR1(adc) &= ~ADC_CFGR1_JAWD1EN;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
/** @brief ADC Enable Discontinuous Mode for Regular Conversions
|
|
*
|
|
* In this mode the ADC converts, on each trigger, a subgroup of up to 8 of the
|
|
* defined regular channel group. The subgroup is defined by the number of
|
|
* consecutive channels to be converted. After a subgroup has been converted
|
|
* the next trigger will start conversion of the immediately following subgroup
|
|
* of the same length or until the whole group has all been converted. When the
|
|
* whole group has been converted, the next trigger will restart conversion of
|
|
* the subgroup at the beginning of the whole group.
|
|
*
|
|
* @param[in] adc ADC block register address base @ref adc_reg_base
|
|
* @param[in] length Number of channels in the group @ref adc_cr1_discnum
|
|
*/
|
|
void adc_enable_discontinuous_mode_regular(uint32_t adc, uint8_t length)
|
|
{
|
|
if ((length-1) > 7) {
|
|
return;
|
|
}
|
|
ADC_CFGR1(adc) |= ADC_CFGR1_DISCEN;
|
|
ADC_CFGR1(adc) |= ((length-1) << ADC_CFGR1_DISCNUM_SHIFT);
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
/** @brief ADC Disable Discontinuous Mode for Regular Conversions
|
|
*
|
|
* @param[in] adc Unsigned int32. ADC block register address base @ref
|
|
* adc_reg_base
|
|
*/
|
|
|
|
void adc_disable_discontinuous_mode_regular(uint32_t adc)
|
|
{
|
|
ADC_CFGR1(adc) &= ~ADC_CFGR1_DISCEN;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
/** @brief ADC Enable Discontinuous Mode for Injected Conversions
|
|
*
|
|
* In this mode the ADC converts sequentially one channel of the defined group
|
|
* of injected channels, cycling back to the first channel in the group once
|
|
* the entire group has been converted.
|
|
*
|
|
* @param[in] adc Unsigned int32. ADC block register address base @ref
|
|
* adc_reg_base
|
|
*/
|
|
|
|
void adc_enable_discontinuous_mode_injected(uint32_t adc)
|
|
{
|
|
ADC_CFGR1(adc) |= ADC_CFGR1_JDISCEN;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
/** @brief ADC Disable Discontinuous Mode for Injected Conversions
|
|
*
|
|
* @param[in] adc Unsigned int32. ADC block register address base @ref
|
|
* adc_reg_base
|
|
*/
|
|
|
|
void adc_disable_discontinuous_mode_injected(uint32_t adc)
|
|
{
|
|
ADC_CFGR1(adc) &= ~ADC_CFGR1_JDISCEN;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
/** @brief ADC Enable Automatic Injected Conversions
|
|
*
|
|
* The ADC converts a defined injected group of channels immediately after the
|
|
* regular channels have been converted. The external trigger on the injected
|
|
* channels is disabled as required.
|
|
*
|
|
* @param[in] adc Unsigned int32. ADC block register address base @ref
|
|
* adc_reg_base
|
|
*/
|
|
|
|
void adc_enable_automatic_injected_group_conversion(uint32_t adc)
|
|
{
|
|
adc_disable_external_trigger_injected(adc);
|
|
ADC_CFGR1(adc) |= ADC_CFGR1_JAUTO;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
/** @brief ADC Disable Automatic Injected Conversions
|
|
*
|
|
* @param[in] adc Unsigned int32. ADC block register address base @ref
|
|
* adc_reg_base
|
|
*/
|
|
|
|
void adc_disable_automatic_injected_group_conversion(uint32_t adc)
|
|
{
|
|
ADC_CFGR1(adc) &= ~ADC_CFGR1_JAUTO;
|
|
}
|
|
/*---------------------------------------------------------------------------*/
|
|
/** @brief ADC Enable Analog Watchdog for All Regular and/or Injected Channels
|
|
*
|
|
* The analog watchdog allows the monitoring of an analog signal between two
|
|
* threshold levels. The thresholds must be preset. Comparison is done before
|
|
* data alignment takes place, so the thresholds are left-aligned.
|
|
*
|
|
* @note The analog watchdog must be enabled for either or both of the regular
|
|
* or injected channels. If neither are enabled, the analog watchdog feature
|
|
* will be disabled.
|
|
*
|
|
* @ref adc_enable_analog_watchdog_injected, @ref
|
|
* adc_enable_analog_watchdog_regular.
|
|
*
|
|
* @param[in] adc Unsigned int32. ADC block register address base @ref
|
|
* adc_reg_base
|
|
*/
|
|
|
|
void adc_enable_analog_watchdog_on_all_channels(uint32_t adc)
|
|
{
|
|
ADC_CFGR1(adc) &= ~ADC_CFGR1_AWD1SGL;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
/** @brief ADC Enable Analog Watchdog for a Selected Channel
|
|
*
|
|
* The analog watchdog allows the monitoring of an analog signal between two
|
|
* threshold levels. The thresholds must be preset. Comparison is done before
|
|
* data alignment takes place, so the thresholds are left-aligned.
|
|
*
|
|
* @note The analog watchdog must be enabled for either or both of the regular
|
|
* or injected channels. If neither are enabled, the analog watchdog feature
|
|
* will be disabled. If both are enabled, the same channel number is monitored
|
|
* @ref adc_enable_analog_watchdog_injected, @ref
|
|
* adc_enable_analog_watchdog_regular.
|
|
*
|
|
* @param[in] adc Unsigned int32. ADC block register address base @ref
|
|
* adc_reg_base
|
|
* @param[in] channel Unsigned int8. ADC channel numbe
|
|
* @ref adc_watchdog_channel
|
|
*/
|
|
|
|
void adc_enable_analog_watchdog_on_selected_channel(uint32_t adc,
|
|
uint8_t channel)
|
|
{
|
|
ADC_CFGR1(adc) = (ADC_CFGR1(adc) & ~ADC_CFGR1_AWD1CH) |
|
|
ADC_CFGR1_AWD1CH_VAL(channel);
|
|
|
|
ADC_CFGR1(adc) |= ADC_CFGR1_AWD1EN | ADC_CFGR1_AWD1SGL;
|
|
}
|
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
/** @brief ADC Enable Injected End-Of-Conversion Interrupt
|
|
*
|
|
* @param[in] adc Unsigned int32. ADC block register address base @ref
|
|
* adc_reg_base
|
|
*/
|
|
|
|
void adc_enable_eoc_interrupt_injected(uint32_t adc)
|
|
{
|
|
ADC_IER(adc) |= ADC_IER_JEOCIE;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
/** @brief ADC Disable Injected End-Of-Conversion Interrupt
|
|
*
|
|
* @param[in] adc Unsigned int32. ADC block register address base @ref
|
|
* adc_reg_base
|
|
*/
|
|
|
|
void adc_disable_eoc_interrupt_injected(uint32_t adc)
|
|
{
|
|
ADC_IER(adc) &= ~ADC_IER_JEOCIE;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
/** @brief ADC Enable Injected End-Of-Sequence Interrupt
|
|
*
|
|
* @param[in] adc Unsigned int32. ADC block register address base @ref
|
|
* adc_reg_base
|
|
*/
|
|
|
|
void adc_enable_eos_interrupt_injected(uint32_t adc)
|
|
{
|
|
ADC_IER(adc) |= ADC_IER_JEOSIE;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
/** @brief ADC Disable Injected End-Of-Sequence Interrupt
|
|
*
|
|
* @param[in] adc Unsigned int32. ADC block register address base @ref
|
|
* adc_reg_base
|
|
*/
|
|
|
|
void adc_disable_eos_interrupt_injected(uint32_t adc)
|
|
{
|
|
ADC_IER(adc) &= ~ADC_IER_JEOSIE;
|
|
}
|
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
/** @brief ADC Enable Analog Watchdog Interrupt
|
|
*
|
|
* @param[in] adc Unsigned int32. ADC block register address base @ref
|
|
* adc_reg_base
|
|
*/
|
|
|
|
void adc_enable_all_awd_interrupt(uint32_t adc)
|
|
{
|
|
ADC_IER(adc) |= ADC_IER_AWD1IE;
|
|
ADC_IER(adc) |= ADC_IER_AWD2IE;
|
|
ADC_IER(adc) |= ADC_IER_AWD3IE;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
/** @brief ADC Disable Analog Watchdog Interrupt
|
|
*
|
|
* @param[in] adc Unsigned int32. ADC block register address base @ref
|
|
* adc_reg_base
|
|
*/
|
|
|
|
void adc_disable_all_awd_interrupt(uint32_t adc)
|
|
{
|
|
ADC_IER(adc) &= ~ADC_IER_AWD1IE;
|
|
ADC_IER(adc) &= ~ADC_IER_AWD2IE;
|
|
ADC_IER(adc) &= ~ADC_IER_AWD3IE;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
/** @brief ADC Enable Regular End-Of-Sequence Interrupt
|
|
*
|
|
* @param[in] adc Unsigned int32. ADC block register address base @ref
|
|
* adc_reg_base
|
|
*/
|
|
|
|
void adc_enable_eos_interrupt(uint32_t adc)
|
|
{
|
|
ADC_IER(adc) |= ADC_IER_EOSIE;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
/** @brief ADC Disable Regular End-Of-Sequence Interrupt
|
|
*
|
|
* @param[in] adc Unsigned int32. ADC block register address base @ref
|
|
* adc_reg_base
|
|
*/
|
|
|
|
void adc_disable_eos_interrupt(uint32_t adc)
|
|
{
|
|
ADC_IER(adc) &= ~ADC_IER_EOSIE;
|
|
}
|
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
/** @brief ADC Software Triggered Conversion on Injected Channels
|
|
*
|
|
* This starts conversion on a set of defined injected channels.
|
|
* Depending on the configuration bits JEXTEN, a conversion will start
|
|
* immediately (software trigger configuration) or once an injected hardware
|
|
* trigger event occurs (hardware trigger configuration).
|
|
*
|
|
* @param[in] adc Unsigned int32. ADC block register address base @ref
|
|
* adc_reg_base
|
|
*/
|
|
|
|
void adc_start_conversion_injected(uint32_t adc)
|
|
{
|
|
/* Start conversion on injected channels. */
|
|
ADC_CR(adc) |= ADC_CR_JADSTART;
|
|
}
|
|
|
|
|
|
/** ADC Set Analog Watchdog Upper Threshold.
|
|
* @param[in] adc ADC block register address base
|
|
* @ref adc_reg_base
|
|
* @param[in] threshold Upper threshold value
|
|
*/
|
|
void adc_set_watchdog_high_threshold(uint32_t adc, uint16_t threshold)
|
|
{
|
|
uint32_t reg32 = 0;
|
|
uint32_t mask = 0xf000ffff;
|
|
|
|
reg32 |= (threshold << 16);
|
|
reg32 &= ~mask; /* clear masked bits. */
|
|
|
|
ADC_TR1(adc) = (ADC_TR1(adc) & mask) | reg32;
|
|
ADC_TR2(adc) = (ADC_TR2(adc) & mask) | reg32;
|
|
ADC_TR3(adc) = (ADC_TR3(adc) & mask) | reg32;
|
|
}
|
|
|
|
/** ADC Set Analog Watchdog Lower Threshold.
|
|
* @param[in] adc ADC block register address base
|
|
* @ref adc_reg_base
|
|
* @param[in] threshold Lower threshold value
|
|
*/
|
|
void adc_set_watchdog_low_threshold(uint32_t adc, uint16_t threshold)
|
|
{
|
|
uint32_t reg32 = 0;
|
|
uint32_t mask = 0xfffff000;
|
|
reg32 = (uint32_t)threshold;
|
|
reg32 &= ~mask; /* clear masked bits. */
|
|
|
|
ADC_TR1(adc) = (ADC_TR1(adc) & mask) | reg32;
|
|
ADC_TR2(adc) = (ADC_TR2(adc) & mask) | reg32;
|
|
ADC_TR3(adc) = (ADC_TR3(adc) & mask) | reg32;
|
|
}
|
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
/** @brief ADC Set an Injected Channel Conversion Sequence
|
|
*
|
|
* Defines a sequence of channels to be converted as an injected group with a
|
|
* length from 1 to 4 channels. If this is called during conversion, the current
|
|
* conversion is reset and conversion begins again with the newly defined group.
|
|
*
|
|
* @param[in] adc Unsigned int32. ADC block register address base
|
|
* @ref adc_reg_base
|
|
* @param[in] length Unsigned int8. Number of channels in the group.
|
|
* @param[in] channel Unsigned int8[]. Set of channels in sequence, integers
|
|
* 0..18
|
|
*/
|
|
|
|
void adc_set_injected_sequence(uint32_t adc, uint8_t length, uint8_t channel[])
|
|
{
|
|
uint32_t reg32 = 0;
|
|
uint8_t i = 0;
|
|
|
|
/* Maximum sequence length is 4 channels. Minimum sequence is 1.*/
|
|
if ((length - 1) > 3) {
|
|
return;
|
|
}
|
|
|
|
for (i = 0; i < length; i++) {
|
|
reg32 |= ADC_JSQR_JSQ_VAL(4 - i, channel[length - i - 1]);
|
|
}
|
|
|
|
reg32 |= ADC_JSQR_JL_VAL(length);
|
|
|
|
ADC_JSQR(adc) = reg32;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
/** @brief ADC Read the End-of-Conversion Flag for Injected Conversion
|
|
*
|
|
* This flag is set by hardware at the end of each injected conversion of a
|
|
* channel when a new data is available in the corresponding ADCx_JDRy register.
|
|
*
|
|
* @param[in] adc Unsigned int32. ADC block register address base
|
|
* @ref adc_reg_base
|
|
* @returns bool. End of conversion flag.
|
|
*/
|
|
|
|
bool adc_eoc_injected(uint32_t adc)
|
|
{
|
|
return ADC_ISR(adc) & ADC_ISR_JEOC;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
/** @brief ADC Read the End-of-Sequence Flag for Injected Conversions
|
|
*
|
|
* This flag is set after all channels of an injected group have been
|
|
* converted.
|
|
*
|
|
* @param[in] adc Unsigned int32. ADC block register address base
|
|
* @ref adc_reg_base
|
|
* @returns bool. End of conversion flag.
|
|
*/
|
|
bool adc_eos_injected(uint32_t adc)
|
|
{
|
|
return ADC_ISR(adc) & ADC_ISR_JEOS;
|
|
}
|
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
/** @brief ADC Read from an Injected Conversion Result Register
|
|
*
|
|
* The result read back from the selected injected result register (one of four)
|
|
* is 12 bits, right or left aligned within the first 16 bits. The result can
|
|
* have a negative value if the injected channel offset has been set @see
|
|
* adc_set_injected_offset.
|
|
*
|
|
* @param[in] adc Unsigned int32. ADC block register address base @ref
|
|
* adc_reg_base
|
|
* @param[in] reg Unsigned int8. Register number (1 ... 4).
|
|
* @returns Unsigned int32 conversion result.
|
|
*/
|
|
|
|
uint32_t adc_read_injected(uint32_t adc, uint8_t reg)
|
|
{
|
|
switch (reg) {
|
|
case 1:
|
|
return ADC_JDR1(adc);
|
|
case 2:
|
|
return ADC_JDR2(adc);
|
|
case 3:
|
|
return ADC_JDR3(adc);
|
|
case 4:
|
|
return ADC_JDR4(adc);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
/** @brief ADC Set the Injected Channel Data Offset
|
|
*
|
|
* This value is subtracted from the injected channel results after conversion
|
|
* is complete, and can result in negative results. A separate value can be
|
|
* specified for each injected data register.
|
|
*
|
|
* @param[in] adc Unsigned int32. ADC block register address base
|
|
* @ref adc_reg_base
|
|
* @param[in] reg Unsigned int8. Register number (1 ... 4).
|
|
* @param[in] offset Unsigned int32.
|
|
*/
|
|
|
|
void adc_set_injected_offset(uint32_t adc, uint8_t reg, uint32_t offset)
|
|
{
|
|
switch (reg) {
|
|
case 1:
|
|
ADC_OFR1(adc) |= ADC_OFR1_OFFSET1_EN;
|
|
ADC_OFR1(adc) |= offset;
|
|
break;
|
|
case 2:
|
|
ADC_OFR2(adc) |= ADC_OFR2_OFFSET2_EN;
|
|
ADC_OFR2(adc) |= offset;
|
|
break;
|
|
case 3:
|
|
ADC_OFR3(adc) |= ADC_OFR3_OFFSET3_EN;
|
|
ADC_OFR3(adc) |= offset;
|
|
break;
|
|
case 4:
|
|
ADC_OFR4(adc) |= ADC_OFR4_OFFSET4_EN;
|
|
ADC_OFR4(adc) |= offset;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
/** @brief ADC Set Clock Prescale
|
|
*
|
|
* The ADC clock taken from the APB2 clock can be scaled down by 2, 4, 6 or 8.
|
|
*
|
|
* @param adc peripheral of choice @ref adc_reg_base
|
|
* @param[in] prescale Unsigned int32. Prescale value for ADC Clock @ref
|
|
* adc_ccr_adcpre
|
|
*/
|
|
void adc_set_clk_prescale(uint32_t adc, uint32_t prescale)
|
|
{
|
|
uint32_t reg32 = ((ADC_CCR(adc) & ~ADC_CCR_CKMODE_MASK) | prescale);
|
|
ADC_CCR(adc) = reg32;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
/** @brief ADC set multi mode
|
|
*
|
|
* The multiple mode can uses these arrangement:
|
|
* - ADC1 as master and ADC2 as slave
|
|
* - ADC3 as master and ADC4 as slave
|
|
*
|
|
* This setting is applied to ADC master only (ADC1 or ADC3).
|
|
*
|
|
* The various modes possible are described in the reference manual.
|
|
*
|
|
* @param adc peripheral of choice @ref adc_reg_base
|
|
* @param[in] mode Multiple mode selection from @ref adc_multi_mode
|
|
*/
|
|
void adc_set_multi_mode(uint32_t adc, uint32_t mode)
|
|
{
|
|
ADC_CCR(adc) &= ~(ADC_CCR_DUAL_MASK << ADC_CCR_DUAL_SHIFT);
|
|
ADC_CCR(adc) |= (mode << ADC_CCR_DUAL_SHIFT);
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
/** @brief ADC Enable an External Trigger for Regular Channels
|
|
*
|
|
* This enables an external trigger for set of defined regular channels, and
|
|
* sets the polarity of the trigger event: rising or falling edge or both. Note
|
|
* that if the trigger polarity is zero, triggering is disabled.
|
|
*
|
|
* @param[in] adc Unsigned int32. ADC block register address base @ref
|
|
* adc_reg_base
|
|
* @param[in] trigger Unsigned int32. Trigger identifier
|
|
* @ref adc_trigger_regular
|
|
* @param[in] polarity Unsigned int32. Trigger polarity @ref
|
|
* adc_trigger_polarity_regular
|
|
*/
|
|
|
|
void adc_enable_external_trigger_regular(uint32_t adc, uint32_t trigger,
|
|
uint32_t polarity)
|
|
{
|
|
uint32_t reg32 = ADC_CFGR1(adc);
|
|
|
|
reg32 &= ~(ADC_CFGR1_EXTSEL_MASK | ADC_CFGR1_EXTEN_MASK);
|
|
reg32 |= (trigger | polarity);
|
|
ADC_CFGR1(adc) = reg32;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
/** @brief ADC Disable an External Trigger for Regular Channels
|
|
*
|
|
* @param[in] adc Unsigned int32. ADC block register address base
|
|
* @ref adc_reg_base
|
|
*/
|
|
|
|
void adc_disable_external_trigger_regular(uint32_t adc)
|
|
{
|
|
ADC_CFGR1(adc) &= ~ADC_CFGR1_EXTEN_MASK;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
/** @brief ADC Enable an External Trigger for Injected Channels
|
|
*
|
|
* This enables an external trigger for set of defined injected channels, and
|
|
* sets the polarity of the trigger event: rising or falling edge or both.
|
|
*
|
|
* @param[in] adc Unsigned int32. ADC block register address base
|
|
* @ref adc_reg_base
|
|
* @param[in] trigger Unsigned int8. Trigger identifier
|
|
* @ref adc_trigger_injected
|
|
* @param[in] polarity Unsigned int32. Trigger polarity
|
|
* @ref adc_trigger_polarity_injected
|
|
*/
|
|
|
|
void adc_enable_external_trigger_injected(uint32_t adc, uint32_t trigger,
|
|
uint32_t polarity)
|
|
{
|
|
uint32_t reg32 = ADC_JSQR(adc);
|
|
|
|
reg32 &= ~(ADC_JSQR_JEXTSEL_MASK | ADC_JSQR_JEXTEN_MASK);
|
|
reg32 |= (trigger | polarity);
|
|
ADC_JSQR(adc) = reg32;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
/** @brief ADC Disable an External Trigger for Injected Channels
|
|
*
|
|
* @param[in] adc Unsigned int32. ADC block register address base @ref
|
|
* adc_reg_base
|
|
*/
|
|
|
|
void adc_disable_external_trigger_injected(uint32_t adc)
|
|
{
|
|
ADC_JSQR(adc) &= ~ADC_JSQR_JEXTEN_MASK;
|
|
}
|
|
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
/** @brief ADC Read the Analog Watchdog Flag
|
|
*
|
|
* This flag is set when the converted voltage crosses the high or low
|
|
* thresholds.
|
|
*
|
|
* @param[in] adc Unsigned int32. ADC block register address base
|
|
* @ref adc_reg_base
|
|
* @returns bool. AWD flag.
|
|
*/
|
|
|
|
bool adc_awd(uint32_t adc)
|
|
{
|
|
return (ADC_ISR(adc) & ADC_ISR_AWD1) &&
|
|
(ADC_ISR(adc) & ADC_ISR_AWD2) &&
|
|
(ADC_ISR(adc) & ADC_ISR_AWD3);
|
|
}
|
|
|
|
|
|
/**
|
|
* Enable the ADC Voltage regulator
|
|
* Before any use of the ADC, the ADC Voltage regulator must be enabled.
|
|
* You must wait up to 10uSecs afterwards before trying anything else.
|
|
* @param[in] adc ADC block register address base
|
|
* @sa adc_disable_regulator
|
|
*/
|
|
void adc_enable_regulator(uint32_t adc)
|
|
{
|
|
ADC_CR(adc) &= ~ADC_CR_ADVREGEN_MASK;
|
|
ADC_CR(adc) |= ADC_CR_ADVREGEN_ENABLE;
|
|
}
|
|
|
|
/**
|
|
* Disable the ADC Voltage regulator
|
|
* You can disable the adc vreg when not in use to save power
|
|
* @param[in] adc ADC block register address base
|
|
* @sa adc_enable_regulator
|
|
*/
|
|
void adc_disable_regulator(uint32_t adc)
|
|
{
|
|
ADC_CR(adc) &= ~ADC_CR_ADVREGEN_MASK;
|
|
ADC_CR(adc) |= ADC_CR_ADVREGEN_DISABLE;
|
|
}
|
|
|
|
/**@}*/
|
|
|