mbed official / mbed-src

mbed library sources

Dependents:   Encrypted my_mbed lklk CyaSSL_DTLS_Cellular ... more

Superseded

This library was superseded by mbed-dev - https://os.mbed.com/users/mbed_official/code/mbed-dev/.

Development branch of the mbed library sources. This library is kept in synch with the latest changes from the mbed SDK and it is not guaranteed to work.

If you are looking for a stable and tested release, please import one of the official mbed library releases:

Import librarymbed

The official Mbed 2 C/C++ SDK provides the software platform and libraries to build your applications.

Last commit 20 Feb 2019 by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32L0/stm32l0xx_hal_adc.c@579:53297373a894, 2015-07-01 (annotated)

Committer:
mbed_official
Date:
Wed Jul 01 09:45:11 2015 +0100
Revision:
579:53297373a894
Parent:
489:119543c9f674 
Synchronized with git revision d5b4d2ab9c47edb4dc5776e7177b0c2263459081



Full URL: https://github.com/mbedmicro/mbed/commit/d5b4d2ab9c47edb4dc5776e7177b0c2263459081/



Initial version of drivers for SAMR21

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mbed_official 376:cb4d9db17537 1 /**
mbed_official 376:cb4d9db17537 2 ******************************************************************************
mbed_official 376:cb4d9db17537 3 * @file stm32l0xx_hal_adc.c
mbed_official 376:cb4d9db17537 4 * @author MCD Application Team
mbed_official 489:119543c9f674 5 * @version V1.2.0
mbed_official 489:119543c9f674 6 * @date 06-February-2015
mbed_official 376:cb4d9db17537 7 * @brief This file provides firmware functions to manage the following
mbed_official 376:cb4d9db17537 8 * functionalities of the Analog to Digital Convertor (ADC)
mbed_official 376:cb4d9db17537 9 * peripheral:
mbed_official 376:cb4d9db17537 10 * + Initialization and de-initialization functions
mbed_official 376:cb4d9db17537 11 * ++ Initialization and Configuration of ADC
mbed_official 376:cb4d9db17537 12 * + Operation functions
mbed_official 376:cb4d9db17537 13 * ++ Start, stop, get result of conversions of regular
mbed_official 376:cb4d9db17537 14 * groups, using 3 possible modes : polling, interruption or DMA.
mbed_official 376:cb4d9db17537 15 * ++ Calibration feature
mbed_official 376:cb4d9db17537 16 * + Control functions
mbed_official 376:cb4d9db17537 17 * ++ Analog Watchdog configuration
mbed_official 376:cb4d9db17537 18 * ++ Regular Channels Configuration
mbed_official 376:cb4d9db17537 19 * + State functions
mbed_official 376:cb4d9db17537 20 * ++ ADC state machine management
mbed_official 376:cb4d9db17537 21 * ++ Interrupts and flags management
mbed_official 376:cb4d9db17537 22 *
mbed_official 376:cb4d9db17537 23 @verbatim
mbed_official 376:cb4d9db17537 24 ==============================================================================
mbed_official 376:cb4d9db17537 25 ##### ADC specific features #####
mbed_official 376:cb4d9db17537 26 ==============================================================================
mbed_official 376:cb4d9db17537 27 [..]
mbed_official 376:cb4d9db17537 28 (#) 12-bit, 10-bit, 8-bit or 6-bit configurable resolution.
mbed_official 376:cb4d9db17537 29
mbed_official 376:cb4d9db17537 30 (#) A built-in hardware oversampler allows to improve analog performances
mbed_official 376:cb4d9db17537 31 while off-loading the related computational burden from the CPU.
mbed_official 376:cb4d9db17537 32
mbed_official 376:cb4d9db17537 33 (#) Interrupt generation at the end of conversion and in case of analog
mbed_official 376:cb4d9db17537 34 watchdog or overrun events.
mbed_official 376:cb4d9db17537 35
mbed_official 376:cb4d9db17537 36 (#) Single and continuous conversion modes.
mbed_official 376:cb4d9db17537 37
mbed_official 376:cb4d9db17537 38 (#) Scan or discontinuous mode conversion of channel 0 to channel 18.
mbed_official 376:cb4d9db17537 39
mbed_official 376:cb4d9db17537 40 (#) Configurable scan direction (Upward from channel 0 to 18 or Backward from
mbed_official 376:cb4d9db17537 41 channel 18 to channel 0)
mbed_official 376:cb4d9db17537 42
mbed_official 376:cb4d9db17537 43 (#) Data alignment with in-built data coherency.
mbed_official 376:cb4d9db17537 44
mbed_official 376:cb4d9db17537 45 (#) Channel-wise programmable sampling time.
mbed_official 376:cb4d9db17537 46
mbed_official 376:cb4d9db17537 47 (#) External trigger option with configurable polarity.
mbed_official 376:cb4d9db17537 48
mbed_official 376:cb4d9db17537 49 (#) DMA request generation during regular channel conversion.
mbed_official 376:cb4d9db17537 50
mbed_official 376:cb4d9db17537 51 (#) ADC supply requirements: 2.4 V to 3.6 V at full speed and down to 1.8 V at
mbed_official 376:cb4d9db17537 52 slower speed.
mbed_official 376:cb4d9db17537 53
mbed_official 376:cb4d9db17537 54 (#) ADC input range: VREF- =VIN =VREF+.
mbed_official 376:cb4d9db17537 55
mbed_official 376:cb4d9db17537 56 (#) ADC self-calibration.
mbed_official 376:cb4d9db17537 57
mbed_official 376:cb4d9db17537 58 (#) ADC is automatically powered off (AutoOff mode) except during the active
mbed_official 376:cb4d9db17537 59 conversion phase. This dramatically reduces the power consumption of the
mbed_official 376:cb4d9db17537 60 ADC.
mbed_official 376:cb4d9db17537 61
mbed_official 376:cb4d9db17537 62 (#) Wait mode to prevent ADC overrun in applications with low frequency.
mbed_official 376:cb4d9db17537 63
mbed_official 376:cb4d9db17537 64
mbed_official 376:cb4d9db17537 65 ##### How to use this driver #####
mbed_official 376:cb4d9db17537 66 ==============================================================================
mbed_official 376:cb4d9db17537 67 [..]
mbed_official 376:cb4d9db17537 68
mbed_official 376:cb4d9db17537 69 (#) Enable the ADC interface
mbed_official 376:cb4d9db17537 70 As prerequisite, into HAL_ADC_MspInit(), ADC clock must be configured
mbed_official 376:cb4d9db17537 71 at RCC top level.
mbed_official 376:cb4d9db17537 72
mbed_official 376:cb4d9db17537 73 Depending on both possible clock sources: PCLK clock or ADC asynchronous
mbed_official 376:cb4d9db17537 74 clock.
mbed_official 489:119543c9f674 75 __HAL_RCC_ADC1_CLK_ENABLE();
mbed_official 376:cb4d9db17537 76
mbed_official 376:cb4d9db17537 77
mbed_official 376:cb4d9db17537 78 (#) ADC pins configuration
mbed_official 376:cb4d9db17537 79 (++) Enable the clock for the ADC GPIOs using the following function:
mbed_official 489:119543c9f674 80 __HAL_RCC_GPIOx_CLK_ENABLE();
mbed_official 376:cb4d9db17537 81 (++) Configure these ADC pins in analog mode using HAL_GPIO_Init();
mbed_official 376:cb4d9db17537 82
mbed_official 376:cb4d9db17537 83 (#) Configure the ADC parameters (conversion resolution, oversampler,
mbed_official 376:cb4d9db17537 84 data alignment, continuous mode,...) using the HAL_ADC_Init() function.
mbed_official 376:cb4d9db17537 85
mbed_official 376:cb4d9db17537 86 (#) Activate the ADC peripheral using one of the start functions:
mbed_official 376:cb4d9db17537 87 HAL_ADC_Start(), HAL_ADC_Start_IT() or HAL_ADC_Start_DMA()
mbed_official 376:cb4d9db17537 88
mbed_official 376:cb4d9db17537 89 *** Channels configuration ***
mbed_official 376:cb4d9db17537 90 ===============================
mbed_official 376:cb4d9db17537 91 [..]
mbed_official 376:cb4d9db17537 92 (+) To configure the ADC channels group, use HAL_ADC_ConfigChannel() function.
mbed_official 376:cb4d9db17537 93 (+) To read the ADC converted values, use the HAL_ADC_GetValue() function.
mbed_official 376:cb4d9db17537 94
mbed_official 376:cb4d9db17537 95 *** DMA feature configuration ***
mbed_official 376:cb4d9db17537 96 =================================
mbed_official 376:cb4d9db17537 97 [..]
mbed_official 376:cb4d9db17537 98 (+) To enable the DMA mode, use the HAL_ADC_Start_DMA() function.
mbed_official 376:cb4d9db17537 99 (+) To enable the generation of DMA requests continuously at the end of
mbed_official 376:cb4d9db17537 100 the last DMA transfer, set .Init.DMAContinuousRequests to ENABLE and
mbed_official 376:cb4d9db17537 101 call HAL_ADC_Init() function.
mbed_official 376:cb4d9db17537 102
mbed_official 376:cb4d9db17537 103
mbed_official 376:cb4d9db17537 104 @endverbatim
mbed_official 376:cb4d9db17537 105 ******************************************************************************
mbed_official 376:cb4d9db17537 106 * @attention
mbed_official 376:cb4d9db17537 107 *
mbed_official 489:119543c9f674 108 * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
mbed_official 376:cb4d9db17537 109 *
mbed_official 376:cb4d9db17537 110 * Redistribution and use in source and binary forms, with or without modification,
mbed_official 376:cb4d9db17537 111 * are permitted provided that the following conditions are met:
mbed_official 376:cb4d9db17537 112 * 1. Redistributions of source code must retain the above copyright notice,
mbed_official 376:cb4d9db17537 113 * this list of conditions and the following disclaimer.
mbed_official 376:cb4d9db17537 114 * 2. Redistributions in binary form must reproduce the above copyright notice,
mbed_official 376:cb4d9db17537 115 * this list of conditions and the following disclaimer in the documentation
mbed_official 376:cb4d9db17537 116 * and/or other materials provided with the distribution.
mbed_official 376:cb4d9db17537 117 * 3. Neither the name of STMicroelectronics nor the names of its contributors
mbed_official 376:cb4d9db17537 118 * may be used to endorse or promote products derived from this software
mbed_official 376:cb4d9db17537 119 * without specific prior written permission.
mbed_official 376:cb4d9db17537 120 *
mbed_official 376:cb4d9db17537 121 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
mbed_official 376:cb4d9db17537 122 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
mbed_official 376:cb4d9db17537 123 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
mbed_official 376:cb4d9db17537 124 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
mbed_official 376:cb4d9db17537 125 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
mbed_official 376:cb4d9db17537 126 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
mbed_official 376:cb4d9db17537 127 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
mbed_official 376:cb4d9db17537 128 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
mbed_official 376:cb4d9db17537 129 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
mbed_official 376:cb4d9db17537 130 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
mbed_official 376:cb4d9db17537 131 *
mbed_official 376:cb4d9db17537 132 ******************************************************************************
mbed_official 376:cb4d9db17537 133 */
mbed_official 376:cb4d9db17537 134
mbed_official 376:cb4d9db17537 135 /* Includes ------------------------------------------------------------------*/
mbed_official 376:cb4d9db17537 136 #include "stm32l0xx_hal.h"
mbed_official 376:cb4d9db17537 137
mbed_official 376:cb4d9db17537 138 /** @addtogroup STM32L0xx_HAL_Driver
mbed_official 376:cb4d9db17537 139 * @{
mbed_official 376:cb4d9db17537 140 */
mbed_official 376:cb4d9db17537 141
mbed_official 376:cb4d9db17537 142 /** @addtogroup ADC
mbed_official 376:cb4d9db17537 143 * @brief ADC driver modules
mbed_official 376:cb4d9db17537 144 * @{
mbed_official 376:cb4d9db17537 145 */
mbed_official 376:cb4d9db17537 146
mbed_official 376:cb4d9db17537 147 #ifdef HAL_ADC_MODULE_ENABLED
mbed_official 376:cb4d9db17537 148
mbed_official 376:cb4d9db17537 149 /* Private typedef -----------------------------------------------------------*/
mbed_official 376:cb4d9db17537 150 /* Private define ------------------------------------------------------------*/
mbed_official 489:119543c9f674 151
mbed_official 489:119543c9f674 152 /* Delay for ADC stabilization time. */
mbed_official 489:119543c9f674 153 /* Maximum delay is 1us (refer to device datasheet, parameter tSTART). */
mbed_official 489:119543c9f674 154 /* Unit: us */
mbed_official 489:119543c9f674 155 #define ADC_STAB_DELAY_US ((uint32_t) 1)
mbed_official 489:119543c9f674 156
mbed_official 489:119543c9f674 157 /* Delay for temperature sensor stabilization time. */
mbed_official 489:119543c9f674 158 /* Maximum delay is 10us (refer to device datasheet, parameter tSTART). */
mbed_official 489:119543c9f674 159 /* Unit: us */
mbed_official 489:119543c9f674 160 #define ADC_TEMPSENSOR_DELAY_US ((uint32_t) 10)
mbed_official 489:119543c9f674 161
mbed_official 376:cb4d9db17537 162 /* Private macro -------------------------------------------------------------*/
mbed_official 376:cb4d9db17537 163 /* Private variables ---------------------------------------------------------*/
mbed_official 376:cb4d9db17537 164 /* Private function prototypes -----------------------------------------------*/
mbed_official 376:cb4d9db17537 165 static HAL_StatusTypeDef ADC_Enable(ADC_HandleTypeDef* hadc);
mbed_official 376:cb4d9db17537 166 static void ADC_DMAConvCplt(DMA_HandleTypeDef *hdma);
mbed_official 376:cb4d9db17537 167 static void ADC_DMAHalfConvCplt(DMA_HandleTypeDef *hdma);
mbed_official 376:cb4d9db17537 168 static void ADC_DMAError(DMA_HandleTypeDef *hdma);
mbed_official 376:cb4d9db17537 169 static HAL_StatusTypeDef ADC_ConversionStop(ADC_HandleTypeDef* hadc, uint32_t ConversionGroup);
mbed_official 376:cb4d9db17537 170 static HAL_StatusTypeDef ADC_Disable(ADC_HandleTypeDef* hadc);
mbed_official 489:119543c9f674 171 static void ADC_DelayMicroSecond(uint32_t microSecond);
mbed_official 376:cb4d9db17537 172
mbed_official 376:cb4d9db17537 173 /* Private functions ---------------------------------------------------------*/
mbed_official 376:cb4d9db17537 174
mbed_official 376:cb4d9db17537 175 /** @defgroup ADC_Private_Functions
mbed_official 376:cb4d9db17537 176 * @{
mbed_official 376:cb4d9db17537 177 */
mbed_official 376:cb4d9db17537 178
mbed_official 376:cb4d9db17537 179 /** @defgroup ADC_Group1 Initialization/de-initialization functions
mbed_official 376:cb4d9db17537 180 * @brief Initialization and Configuration functions
mbed_official 376:cb4d9db17537 181 *
mbed_official 376:cb4d9db17537 182 @verbatim
mbed_official 376:cb4d9db17537 183 ===============================================================================
mbed_official 376:cb4d9db17537 184 ##### Initialization and de-initialization functions #####
mbed_official 376:cb4d9db17537 185 ===============================================================================
mbed_official 376:cb4d9db17537 186 [..] This section provides functions allowing to:
mbed_official 376:cb4d9db17537 187 (+) Initialize and configure the ADC.
mbed_official 376:cb4d9db17537 188 (+) De-initialize the ADC.
mbed_official 376:cb4d9db17537 189
mbed_official 376:cb4d9db17537 190 @endverbatim
mbed_official 376:cb4d9db17537 191 * @{
mbed_official 376:cb4d9db17537 192 */
mbed_official 376:cb4d9db17537 193
mbed_official 376:cb4d9db17537 194
mbed_official 376:cb4d9db17537 195 /**
mbed_official 376:cb4d9db17537 196 * @brief Initializes the ADCx peripheral according to the specified parameters
mbed_official 376:cb4d9db17537 197 * in the ADC_InitStruct.
mbed_official 376:cb4d9db17537 198 * @note This function is used to configure the global features of the ADC
mbed_official 376:cb4d9db17537 199 * (ClockPrescaler, Resolution, Data Alignment and number of conversion), however,
mbed_official 376:cb4d9db17537 200 * the rest of the configuration parameters are specific to the regular
mbed_official 376:cb4d9db17537 201 * channels group (scan mode activation, continuous mode activation,
mbed_official 376:cb4d9db17537 202 * External trigger source and edge, DMA continuous request after the
mbed_official 376:cb4d9db17537 203 * last transfer and End of conversion selection).
mbed_official 376:cb4d9db17537 204 *
mbed_official 376:cb4d9db17537 205 * As prerequisite, into HAL_ADC_MspInit(), ADC clock must be
mbed_official 376:cb4d9db17537 206 * configured at RCC top level.
mbed_official 376:cb4d9db17537 207 * See commented example code below that can be copied
mbed_official 376:cb4d9db17537 208 * and uncommented into HAL_ADC_MspInit().
mbed_official 376:cb4d9db17537 209 *
mbed_official 376:cb4d9db17537 210 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 211 * the configuration information for the specified ADC.
mbed_official 376:cb4d9db17537 212 * @retval HAL status
mbed_official 376:cb4d9db17537 213 */
mbed_official 376:cb4d9db17537 214 HAL_StatusTypeDef HAL_ADC_Init(ADC_HandleTypeDef* hadc)
mbed_official 376:cb4d9db17537 215 {
mbed_official 376:cb4d9db17537 216 uint32_t tickstart = 0x00;
mbed_official 376:cb4d9db17537 217
mbed_official 376:cb4d9db17537 218 /* Check ADC handle */
mbed_official 489:119543c9f674 219 if(hadc == NULL)
mbed_official 376:cb4d9db17537 220 {
mbed_official 376:cb4d9db17537 221 return HAL_ERROR;
mbed_official 376:cb4d9db17537 222 }
mbed_official 376:cb4d9db17537 223
mbed_official 376:cb4d9db17537 224 /* Check the parameters */
mbed_official 376:cb4d9db17537 225 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 376:cb4d9db17537 226 assert_param(IS_ADC_CLOCKPRESCALER(hadc->Init.ClockPrescaler));
mbed_official 376:cb4d9db17537 227 assert_param(IS_ADC_RESOLUTION(hadc->Init.Resolution));
mbed_official 376:cb4d9db17537 228 assert_param(IS_ADC_SAMPLE_TIME(hadc->Init.SamplingTime));
mbed_official 489:119543c9f674 229 assert_param(IS_ADC_SCAN_MODE(hadc->Init.ScanConvMode));
mbed_official 376:cb4d9db17537 230 assert_param(IS_ADC_DATA_ALIGN(hadc->Init.DataAlign));
mbed_official 376:cb4d9db17537 231 assert_param(IS_FUNCTIONAL_STATE(hadc->Init.ContinuousConvMode));
mbed_official 376:cb4d9db17537 232 assert_param(IS_FUNCTIONAL_STATE(hadc->Init.DiscontinuousConvMode));
mbed_official 376:cb4d9db17537 233 assert_param(IS_ADC_EXTTRIG_EDGE(hadc->Init.ExternalTrigConvEdge));
mbed_official 376:cb4d9db17537 234 assert_param(IS_ADC_EXTERNAL_TRIG_CONV(hadc->Init.ExternalTrigConv));
mbed_official 376:cb4d9db17537 235 assert_param(IS_FUNCTIONAL_STATE(hadc->Init.DMAContinuousRequests));
mbed_official 376:cb4d9db17537 236 assert_param(IS_ADC_EOC_SELECTION(hadc->Init.EOCSelection));
mbed_official 376:cb4d9db17537 237 assert_param(IS_ADC_OVERRUN(hadc->Init.Overrun));
mbed_official 376:cb4d9db17537 238 assert_param(IS_FUNCTIONAL_STATE(hadc->Init.LowPowerAutoWait));
mbed_official 376:cb4d9db17537 239 assert_param(IS_FUNCTIONAL_STATE(hadc->Init.LowPowerFrequencyMode));
mbed_official 489:119543c9f674 240 assert_param(IS_FUNCTIONAL_STATE(hadc->Init.LowPowerAutoPowerOff));
mbed_official 376:cb4d9db17537 241 assert_param(IS_FUNCTIONAL_STATE(hadc->Init.OversamplingMode));
mbed_official 376:cb4d9db17537 242
mbed_official 376:cb4d9db17537 243 if(hadc->State == HAL_ADC_STATE_RESET)
mbed_official 376:cb4d9db17537 244 {
mbed_official 376:cb4d9db17537 245 /* Init the low level hardware */
mbed_official 376:cb4d9db17537 246 HAL_ADC_MspInit(hadc);
mbed_official 376:cb4d9db17537 247 }
mbed_official 376:cb4d9db17537 248
mbed_official 489:119543c9f674 249 /* Configuration of ADC parameters if previous preliminary actions are */
mbed_official 489:119543c9f674 250 /* correctly completed. */
mbed_official 489:119543c9f674 251 /* and if there is no conversion on going (ADC can be enabled anyway, */
mbed_official 489:119543c9f674 252 /* in case of call of this function to update a parameter */
mbed_official 489:119543c9f674 253 /* on the fly). */
mbed_official 489:119543c9f674 254 if ((hadc->State == HAL_ADC_STATE_ERROR) ||
mbed_official 489:119543c9f674 255 (ADC_IS_CONVERSION_ONGOING(hadc) != RESET) )
mbed_official 489:119543c9f674 256 {
mbed_official 489:119543c9f674 257 /* Update ADC state machine to error */
mbed_official 489:119543c9f674 258 hadc->State = HAL_ADC_STATE_ERROR;
mbed_official 489:119543c9f674 259 /* Process unlocked */
mbed_official 489:119543c9f674 260 __HAL_UNLOCK(hadc);
mbed_official 489:119543c9f674 261 return HAL_ERROR;
mbed_official 489:119543c9f674 262 }
mbed_official 489:119543c9f674 263
mbed_official 376:cb4d9db17537 264 /* Initialize the ADC state */
mbed_official 376:cb4d9db17537 265 hadc->State = HAL_ADC_STATE_BUSY;
mbed_official 376:cb4d9db17537 266
mbed_official 376:cb4d9db17537 267 /* Configuration of ADC clock: clock source PCLK or asynchronous with
mbed_official 376:cb4d9db17537 268 selectable prescaler */
mbed_official 376:cb4d9db17537 269 __HAL_ADC_CLOCK_PRESCALER(hadc);
mbed_official 376:cb4d9db17537 270
mbed_official 376:cb4d9db17537 271 /* Set the Low Frequency mode */
mbed_official 376:cb4d9db17537 272 ADC->CCR &= (uint32_t)~ADC_CCR_LFMEN;
mbed_official 376:cb4d9db17537 273 ADC->CCR |=__HAL_ADC_CCR_LOWFREQUENCY(hadc->Init.LowPowerFrequencyMode);
mbed_official 376:cb4d9db17537 274
mbed_official 376:cb4d9db17537 275 /* Enable voltage regulator (if disabled at this step) */
mbed_official 376:cb4d9db17537 276 if (HAL_IS_BIT_CLR(hadc->Instance->CR, ADC_CR_ADVREGEN))
mbed_official 376:cb4d9db17537 277 {
mbed_official 376:cb4d9db17537 278 /* Disable the ADC (if not already disabled) */
mbed_official 489:119543c9f674 279 if (ADC_IS_ENABLE(hadc) != RESET )
mbed_official 376:cb4d9db17537 280 {
mbed_official 376:cb4d9db17537 281 /* Check if conditions to disable the ADC are fulfilled */
mbed_official 489:119543c9f674 282 if (ADC_DISABLING_CONDITIONS(hadc) != RESET)
mbed_official 376:cb4d9db17537 283 {
mbed_official 376:cb4d9db17537 284 __HAL_ADC_DISABLE(hadc);
mbed_official 376:cb4d9db17537 285 }
mbed_official 376:cb4d9db17537 286 else
mbed_official 376:cb4d9db17537 287 {
mbed_official 376:cb4d9db17537 288 hadc->State= HAL_ADC_STATE_ERROR;
mbed_official 376:cb4d9db17537 289
mbed_official 376:cb4d9db17537 290 /* Process unlocked */
mbed_official 376:cb4d9db17537 291 __HAL_UNLOCK(hadc);
mbed_official 376:cb4d9db17537 292
mbed_official 376:cb4d9db17537 293 return HAL_ERROR;
mbed_official 376:cb4d9db17537 294 }
mbed_official 376:cb4d9db17537 295
mbed_official 376:cb4d9db17537 296 /* Get timeout */
mbed_official 376:cb4d9db17537 297 tickstart = HAL_GetTick();
mbed_official 376:cb4d9db17537 298
mbed_official 376:cb4d9db17537 299 /* Wait for disabling completion */
mbed_official 376:cb4d9db17537 300 while(HAL_IS_BIT_SET(hadc->Instance->CR, ADC_CR_ADEN))
mbed_official 376:cb4d9db17537 301 {
mbed_official 376:cb4d9db17537 302 /* Check for the Timeout */
mbed_official 376:cb4d9db17537 303 if(ADC_ENABLE_TIMEOUT != HAL_MAX_DELAY)
mbed_official 376:cb4d9db17537 304 {
mbed_official 376:cb4d9db17537 305 if((HAL_GetTick() - tickstart ) > ADC_DISABLE_TIMEOUT)
mbed_official 376:cb4d9db17537 306 {
mbed_official 376:cb4d9db17537 307 hadc->State= HAL_ADC_STATE_TIMEOUT;
mbed_official 376:cb4d9db17537 308
mbed_official 376:cb4d9db17537 309 /* Process unlocked */
mbed_official 376:cb4d9db17537 310 __HAL_UNLOCK(hadc);
mbed_official 376:cb4d9db17537 311
mbed_official 376:cb4d9db17537 312 return HAL_TIMEOUT;
mbed_official 376:cb4d9db17537 313 }
mbed_official 376:cb4d9db17537 314 }
mbed_official 376:cb4d9db17537 315 }
mbed_official 376:cb4d9db17537 316
mbed_official 376:cb4d9db17537 317 }
mbed_official 376:cb4d9db17537 318
mbed_official 376:cb4d9db17537 319 /* Set ADVREGEN bit */
mbed_official 376:cb4d9db17537 320 hadc->Instance->CR |= ADC_CR_ADVREGEN;
mbed_official 376:cb4d9db17537 321 }
mbed_official 376:cb4d9db17537 322
mbed_official 376:cb4d9db17537 323 /* Configuration of ADC: */
mbed_official 376:cb4d9db17537 324 /* - Resolution */
mbed_official 376:cb4d9db17537 325 /* - Data alignment */
mbed_official 376:cb4d9db17537 326 /* - Scan direction */
mbed_official 376:cb4d9db17537 327 /* - External trigger to start conversion */
mbed_official 376:cb4d9db17537 328 /* - External trigger polarity */
mbed_official 376:cb4d9db17537 329 /* - Continuous conversion mode */
mbed_official 376:cb4d9db17537 330 /* - DMA continuous request */
mbed_official 376:cb4d9db17537 331 /* - Overrun */
mbed_official 376:cb4d9db17537 332 /* - AutoDelay feature */
mbed_official 376:cb4d9db17537 333 /* - Discontinuous mode */
mbed_official 376:cb4d9db17537 334 hadc->Instance->CFGR1 &= ~( ADC_CFGR1_RES |
mbed_official 376:cb4d9db17537 335 ADC_CFGR1_ALIGN |
mbed_official 376:cb4d9db17537 336 ADC_CFGR1_SCANDIR |
mbed_official 376:cb4d9db17537 337 ADC_CFGR1_EXTSEL |
mbed_official 376:cb4d9db17537 338 ADC_CFGR1_EXTEN |
mbed_official 376:cb4d9db17537 339 ADC_CFGR1_CONT |
mbed_official 376:cb4d9db17537 340 ADC_CFGR1_DMACFG |
mbed_official 376:cb4d9db17537 341 ADC_CFGR1_OVRMOD |
mbed_official 376:cb4d9db17537 342 ADC_CFGR1_AUTDLY |
mbed_official 376:cb4d9db17537 343 ADC_CFGR1_AUTOFF |
mbed_official 376:cb4d9db17537 344 ADC_CFGR1_DISCEN);
mbed_official 376:cb4d9db17537 345
mbed_official 376:cb4d9db17537 346 hadc->Instance->CFGR1 |= ( hadc->Init.Resolution |
mbed_official 376:cb4d9db17537 347 hadc->Init.DataAlign |
mbed_official 489:119543c9f674 348 ADC_SCANDIR(hadc->Init.ScanConvMode) |
mbed_official 376:cb4d9db17537 349 hadc->Init.ExternalTrigConvEdge |
mbed_official 489:119543c9f674 350 ADC_CONTINUOUS(hadc->Init.ContinuousConvMode) |
mbed_official 489:119543c9f674 351 ADC_DMACONTREQ(hadc->Init.DMAContinuousRequests) |
mbed_official 376:cb4d9db17537 352 hadc->Init.Overrun |
mbed_official 376:cb4d9db17537 353 __HAL_ADC_CFGR1_AutoDelay(hadc->Init.LowPowerAutoWait) |
mbed_official 489:119543c9f674 354 __HAL_ADC_CFGR1_AUTOFF(hadc->Init.LowPowerAutoPowerOff));
mbed_official 376:cb4d9db17537 355
mbed_official 376:cb4d9db17537 356 /* Configure the external trigger only if Conversion edge is not "NONE" */
mbed_official 489:119543c9f674 357 if (hadc->Init.ExternalTrigConvEdge != ADC_EXTERNALTRIGCONVEDGE_NONE)
mbed_official 376:cb4d9db17537 358 {
mbed_official 376:cb4d9db17537 359 hadc->Instance->CFGR1 |= hadc->Init.ExternalTrigConv;
mbed_official 376:cb4d9db17537 360 }
mbed_official 376:cb4d9db17537 361
mbed_official 376:cb4d9db17537 362 /* Enable discontinuous mode only if continuous mode is disabled */
mbed_official 376:cb4d9db17537 363 if ((hadc->Init.DiscontinuousConvMode == ENABLE) && (hadc->Init.ContinuousConvMode == DISABLE))
mbed_official 376:cb4d9db17537 364 {
mbed_official 376:cb4d9db17537 365 /* Enable the selected ADC discontinuous mode */
mbed_official 376:cb4d9db17537 366 hadc->Instance->CFGR1 |= ( ADC_CFGR1_DISCEN);
mbed_official 376:cb4d9db17537 367 }
mbed_official 376:cb4d9db17537 368
mbed_official 376:cb4d9db17537 369 if (hadc->Init.OversamplingMode == ENABLE)
mbed_official 376:cb4d9db17537 370 {
mbed_official 376:cb4d9db17537 371 assert_param(IS_ADC_OVERSAMPLING_RATIO(hadc->Init.Oversample.Ratio));
mbed_official 376:cb4d9db17537 372 assert_param(IS_ADC_RIGHT_BIT_SHIFT(hadc->Init.Oversample.RightBitShift));
mbed_official 376:cb4d9db17537 373 assert_param(IS_ADC_TRIGGERED_OVERSAMPLING_MODE(hadc->Init.Oversample.TriggeredMode));
mbed_official 376:cb4d9db17537 374
mbed_official 376:cb4d9db17537 375 /* Configuration of Oversampler: */
mbed_official 376:cb4d9db17537 376 /* - Oversampling Ratio */
mbed_official 376:cb4d9db17537 377 /* - Right bit shift */
mbed_official 376:cb4d9db17537 378 /* - Triggered mode */
mbed_official 376:cb4d9db17537 379
mbed_official 376:cb4d9db17537 380 hadc->Instance->CFGR2 &= ~( ADC_CFGR2_OVSR |
mbed_official 376:cb4d9db17537 381 ADC_CFGR2_OVSS |
mbed_official 376:cb4d9db17537 382 ADC_CFGR2_TOVS );
mbed_official 376:cb4d9db17537 383
mbed_official 376:cb4d9db17537 384 hadc->Instance->CFGR2 |= ( hadc->Init.Oversample.Ratio |
mbed_official 376:cb4d9db17537 385 hadc->Init.Oversample.RightBitShift |
mbed_official 376:cb4d9db17537 386 hadc->Init.Oversample.TriggeredMode );
mbed_official 376:cb4d9db17537 387
mbed_official 376:cb4d9db17537 388 /* Enable OverSampling mode */
mbed_official 376:cb4d9db17537 389 hadc->Instance->CFGR2 |= ADC_CFGR2_OVSE;
mbed_official 376:cb4d9db17537 390 }
mbed_official 376:cb4d9db17537 391 else
mbed_official 376:cb4d9db17537 392 {
mbed_official 376:cb4d9db17537 393 /* Disable OverSampling mode */
mbed_official 376:cb4d9db17537 394 hadc->Instance->CFGR2 &= ~ADC_CFGR2_OVSE;
mbed_official 376:cb4d9db17537 395 }
mbed_official 376:cb4d9db17537 396
mbed_official 376:cb4d9db17537 397 /* Clear the old sampling time */
mbed_official 376:cb4d9db17537 398 hadc->Instance->SMPR &= (uint32_t)(~ADC_SMPR_SMPR);
mbed_official 376:cb4d9db17537 399
mbed_official 376:cb4d9db17537 400 /* Set the new sample time */
mbed_official 376:cb4d9db17537 401 hadc->Instance->SMPR |= hadc->Init.SamplingTime;
mbed_official 376:cb4d9db17537 402
mbed_official 376:cb4d9db17537 403
mbed_official 376:cb4d9db17537 404 /* Set ADC error code to none */
mbed_official 376:cb4d9db17537 405 hadc->ErrorCode = HAL_ADC_ERROR_NONE;
mbed_official 376:cb4d9db17537 406
mbed_official 376:cb4d9db17537 407 /* Initialize the ADC state */
mbed_official 376:cb4d9db17537 408 hadc->State = HAL_ADC_STATE_READY;
mbed_official 376:cb4d9db17537 409
mbed_official 376:cb4d9db17537 410 /* Return function status */
mbed_official 376:cb4d9db17537 411 return HAL_OK;
mbed_official 376:cb4d9db17537 412 }
mbed_official 376:cb4d9db17537 413
mbed_official 376:cb4d9db17537 414 /**
mbed_official 376:cb4d9db17537 415 * @brief Deinitialize the ADC peripheral registers to its default reset values.
mbed_official 376:cb4d9db17537 416 * @note To not impact other ADCs, reset of common ADC registers have been
mbed_official 376:cb4d9db17537 417 * left commented below.
mbed_official 376:cb4d9db17537 418 * If needed, the example code can be copied and uncommented into
mbed_official 376:cb4d9db17537 419 * function HAL_ADC_MspDeInit().
mbed_official 376:cb4d9db17537 420 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 421 * the configuration information for the specified ADC.
mbed_official 376:cb4d9db17537 422 * @retval HAL status
mbed_official 376:cb4d9db17537 423 */
mbed_official 376:cb4d9db17537 424 HAL_StatusTypeDef HAL_ADC_DeInit(ADC_HandleTypeDef* hadc)
mbed_official 376:cb4d9db17537 425 {
mbed_official 376:cb4d9db17537 426 uint32_t tickstart = 0;
mbed_official 376:cb4d9db17537 427
mbed_official 376:cb4d9db17537 428 /* Check ADC handle */
mbed_official 489:119543c9f674 429 if(hadc == NULL)
mbed_official 376:cb4d9db17537 430 {
mbed_official 376:cb4d9db17537 431 return HAL_ERROR;
mbed_official 376:cb4d9db17537 432 }
mbed_official 376:cb4d9db17537 433
mbed_official 376:cb4d9db17537 434 /* Check the parameters */
mbed_official 376:cb4d9db17537 435 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 376:cb4d9db17537 436
mbed_official 376:cb4d9db17537 437 /* Change ADC state */
mbed_official 376:cb4d9db17537 438 hadc->State = HAL_ADC_STATE_BUSY;
mbed_official 376:cb4d9db17537 439
mbed_official 376:cb4d9db17537 440 /* Stop potential conversion ongoing */
mbed_official 376:cb4d9db17537 441 if (HAL_IS_BIT_SET(hadc->Instance->CR, ADC_CR_ADSTART) && HAL_IS_BIT_CLR(hadc->Instance->CR, ADC_CR_ADDIS))
mbed_official 376:cb4d9db17537 442 {
mbed_official 376:cb4d9db17537 443 /* Stop regular conversion */
mbed_official 376:cb4d9db17537 444 hadc->Instance->CR |= ADC_CR_ADSTP;
mbed_official 376:cb4d9db17537 445 }
mbed_official 376:cb4d9db17537 446
mbed_official 376:cb4d9db17537 447 /* Disable ADC: Solution to recover from an unknown ADC state (for example, */
mbed_official 376:cb4d9db17537 448 /* in case of forbidden action on register bits) */
mbed_official 376:cb4d9db17537 449 /* Procedure to disable the ADC peripheral: wait for conversions */
mbed_official 376:cb4d9db17537 450 /* effectively stopped, then disable ADC */
mbed_official 376:cb4d9db17537 451 /* 1. Wait until ADSTART = 0 */
mbed_official 376:cb4d9db17537 452
mbed_official 376:cb4d9db17537 453 /* Get timeout */
mbed_official 376:cb4d9db17537 454 tickstart = HAL_GetTick();
mbed_official 376:cb4d9db17537 455
mbed_official 376:cb4d9db17537 456 while(HAL_IS_BIT_SET(hadc->Instance->CR, ADC_CR_ADSTART))
mbed_official 376:cb4d9db17537 457 {
mbed_official 376:cb4d9db17537 458 /* Check for the Timeout */
mbed_official 376:cb4d9db17537 459 if(ADC_STOP_CONVERSION_TIMEOUT != HAL_MAX_DELAY)
mbed_official 376:cb4d9db17537 460 {
mbed_official 376:cb4d9db17537 461 if((HAL_GetTick() - tickstart ) > ADC_STOP_CONVERSION_TIMEOUT)
mbed_official 376:cb4d9db17537 462 {
mbed_official 376:cb4d9db17537 463 hadc->State= HAL_ADC_STATE_TIMEOUT;
mbed_official 376:cb4d9db17537 464
mbed_official 376:cb4d9db17537 465 /* Process unlocked */
mbed_official 376:cb4d9db17537 466 __HAL_UNLOCK(hadc);
mbed_official 376:cb4d9db17537 467
mbed_official 376:cb4d9db17537 468 return HAL_TIMEOUT;
mbed_official 376:cb4d9db17537 469 }
mbed_official 376:cb4d9db17537 470 }
mbed_official 376:cb4d9db17537 471 }
mbed_official 376:cb4d9db17537 472
mbed_official 376:cb4d9db17537 473 /* 2. Disable the ADC peripheral */
mbed_official 376:cb4d9db17537 474 __HAL_ADC_DISABLE(hadc);
mbed_official 376:cb4d9db17537 475
mbed_official 376:cb4d9db17537 476
mbed_official 376:cb4d9db17537 477 /* Reset ADC registers****************/
mbed_official 376:cb4d9db17537 478 /* Reset register IER */
mbed_official 376:cb4d9db17537 479 __HAL_ADC_DISABLE_IT(hadc, (ADC_IT_AWD | ADC_IT_OVR | ADC_IT_EOCAL | ADC_IT_EOS | \
mbed_official 376:cb4d9db17537 480 ADC_IT_EOC | ADC_IT_RDY | ADC_IT_EOSMP ));
mbed_official 376:cb4d9db17537 481
mbed_official 376:cb4d9db17537 482 /* Reset register ISR */
mbed_official 376:cb4d9db17537 483 __HAL_ADC_CLEAR_FLAG(hadc, (ADC_FLAG_AWD | ADC_FLAG_EOCAL | ADC_FLAG_OVR | ADC_FLAG_EOS | \
mbed_official 376:cb4d9db17537 484 ADC_FLAG_EOC | ADC_FLAG_EOSMP | ADC_FLAG_RDY));
mbed_official 376:cb4d9db17537 485
mbed_official 376:cb4d9db17537 486 /* Reset register CR */
mbed_official 376:cb4d9db17537 487 /* Disable voltage regulator */
mbed_official 376:cb4d9db17537 488 /* Note: Regulator disable useful for power saving */
mbed_official 376:cb4d9db17537 489 /* Reset ADVREGEN bit */
mbed_official 376:cb4d9db17537 490 hadc->Instance->CR &= ~ADC_CR_ADVREGEN;
mbed_official 376:cb4d9db17537 491
mbed_official 376:cb4d9db17537 492 /* Bits ADC_CR_ADSTP, ADC_CR_ADSTART are in access mode "read-set": no direct reset applicable */
mbed_official 376:cb4d9db17537 493 /* No action */
mbed_official 376:cb4d9db17537 494
mbed_official 376:cb4d9db17537 495 /* Reset register CFGR1 */
mbed_official 376:cb4d9db17537 496 hadc->Instance->CFGR1 &= ~(ADC_CFGR1_AWDCH | ADC_CFGR1_AWDEN | ADC_CFGR1_AWDSGL | \
mbed_official 376:cb4d9db17537 497 ADC_CFGR1_DISCEN | ADC_CFGR1_AUTOFF | ADC_CFGR1_AUTDLY | \
mbed_official 376:cb4d9db17537 498 ADC_CFGR1_CONT | ADC_CFGR1_OVRMOD | ADC_CFGR1_EXTEN | \
mbed_official 376:cb4d9db17537 499 ADC_CFGR1_EXTSEL | ADC_CFGR1_ALIGN | ADC_CFGR1_RES | \
mbed_official 376:cb4d9db17537 500 ADC_CFGR1_SCANDIR| ADC_CFGR1_DMACFG | ADC_CFGR1_DMAEN);
mbed_official 376:cb4d9db17537 501
mbed_official 376:cb4d9db17537 502 /* Reset register CFGR2 */
mbed_official 376:cb4d9db17537 503 hadc->Instance->CFGR2 &= ~(ADC_CFGR2_TOVS | ADC_CFGR2_OVSS | ADC_CFGR2_OVSR | \
mbed_official 376:cb4d9db17537 504 ADC_CFGR2_OVSE | ADC_CFGR2_CKMODE );
mbed_official 376:cb4d9db17537 505
mbed_official 376:cb4d9db17537 506 /* Reset register SMPR */
mbed_official 376:cb4d9db17537 507 hadc->Instance->SMPR &= ~(ADC_SMPR_SMPR);
mbed_official 376:cb4d9db17537 508
mbed_official 376:cb4d9db17537 509 /* Reset register TR */
mbed_official 376:cb4d9db17537 510 hadc->Instance->TR &= ~(ADC_TR_LT | ADC_TR_HT);
mbed_official 376:cb4d9db17537 511
mbed_official 376:cb4d9db17537 512 /* Reset register CALFACT */
mbed_official 376:cb4d9db17537 513 hadc->Instance->CALFACT &= ~(ADC_CALFACT_CALFACT);
mbed_official 376:cb4d9db17537 514
mbed_official 376:cb4d9db17537 515 /* Reset register DR */
mbed_official 376:cb4d9db17537 516 /* bits in access mode read only, no direct reset applicable*/
mbed_official 376:cb4d9db17537 517
mbed_official 376:cb4d9db17537 518 /* Reset register CALFACT */
mbed_official 376:cb4d9db17537 519 hadc->Instance->CALFACT &= ~(ADC_CALFACT_CALFACT);
mbed_official 376:cb4d9db17537 520
mbed_official 376:cb4d9db17537 521
mbed_official 376:cb4d9db17537 522 /* DeInit the low level hardware */
mbed_official 376:cb4d9db17537 523 HAL_ADC_MspDeInit(hadc);
mbed_official 376:cb4d9db17537 524
mbed_official 376:cb4d9db17537 525 /* Set ADC error code to none */
mbed_official 376:cb4d9db17537 526 hadc->ErrorCode = HAL_ADC_ERROR_NONE;
mbed_official 376:cb4d9db17537 527
mbed_official 376:cb4d9db17537 528 /* Change ADC state */
mbed_official 376:cb4d9db17537 529 hadc->State = HAL_ADC_STATE_RESET;
mbed_official 376:cb4d9db17537 530
mbed_official 376:cb4d9db17537 531 /* Return function status */
mbed_official 376:cb4d9db17537 532 return HAL_OK;
mbed_official 376:cb4d9db17537 533 }
mbed_official 376:cb4d9db17537 534
mbed_official 376:cb4d9db17537 535 /**
mbed_official 376:cb4d9db17537 536 * @brief Initializes the ADC MSP.
mbed_official 376:cb4d9db17537 537 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 538 * the configuration information for the specified ADC.
mbed_official 376:cb4d9db17537 539 * @retval None
mbed_official 376:cb4d9db17537 540 */
mbed_official 376:cb4d9db17537 541 __weak void HAL_ADC_MspInit(ADC_HandleTypeDef* hadc)
mbed_official 376:cb4d9db17537 542 {
mbed_official 376:cb4d9db17537 543 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 376:cb4d9db17537 544 the HAL_ADC_MspInit could be implemented in the user file
mbed_official 376:cb4d9db17537 545 */
mbed_official 376:cb4d9db17537 546 }
mbed_official 376:cb4d9db17537 547
mbed_official 376:cb4d9db17537 548 /**
mbed_official 376:cb4d9db17537 549 * @brief DeInitializes the ADC MSP.
mbed_official 376:cb4d9db17537 550 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 551 * the configuration information for the specified ADC.
mbed_official 376:cb4d9db17537 552 * @retval None
mbed_official 376:cb4d9db17537 553 */
mbed_official 376:cb4d9db17537 554 __weak void HAL_ADC_MspDeInit(ADC_HandleTypeDef* hadc)
mbed_official 376:cb4d9db17537 555 {
mbed_official 376:cb4d9db17537 556 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 376:cb4d9db17537 557 the HAL_ADC_MspDeInit could be implemented in the user file
mbed_official 376:cb4d9db17537 558 */
mbed_official 376:cb4d9db17537 559 }
mbed_official 376:cb4d9db17537 560
mbed_official 376:cb4d9db17537 561 /**
mbed_official 376:cb4d9db17537 562 * @}
mbed_official 376:cb4d9db17537 563 */
mbed_official 376:cb4d9db17537 564
mbed_official 376:cb4d9db17537 565 /** @defgroup ADC_Group2 I/O operation functions
mbed_official 376:cb4d9db17537 566 * @brief I/O operation functions
mbed_official 376:cb4d9db17537 567 *
mbed_official 376:cb4d9db17537 568 @verbatim
mbed_official 376:cb4d9db17537 569 ===============================================================================
mbed_official 376:cb4d9db17537 570 ##### IO operation functions #####
mbed_official 376:cb4d9db17537 571 ===============================================================================
mbed_official 376:cb4d9db17537 572 [..] This section provides functions allowing to:
mbed_official 376:cb4d9db17537 573 (+) Start conversion.
mbed_official 376:cb4d9db17537 574 (+) Stop conversion.
mbed_official 376:cb4d9db17537 575 (+) poll for conversion complete.
mbed_official 376:cb4d9db17537 576 (+) poll for conversion event.
mbed_official 376:cb4d9db17537 577 (+) Start conversion and enable interrupt.
mbed_official 376:cb4d9db17537 578 (+) Stop conversion and disable interrupt.
mbed_official 376:cb4d9db17537 579 (+) handle ADC interrupt request.
mbed_official 376:cb4d9db17537 580 (+) Start conversion of regular channel and enable DMA transfer.
mbed_official 376:cb4d9db17537 581 (+) Stop conversion of regular channel and disable DMA transfer.
mbed_official 376:cb4d9db17537 582 (+) Get result of regular channel conversion.
mbed_official 376:cb4d9db17537 583 (+) Handle ADC interrupt request.
mbed_official 376:cb4d9db17537 584
mbed_official 376:cb4d9db17537 585 @endverbatim
mbed_official 376:cb4d9db17537 586 * @{
mbed_official 376:cb4d9db17537 587 */
mbed_official 376:cb4d9db17537 588
mbed_official 376:cb4d9db17537 589
mbed_official 376:cb4d9db17537 590 /**
mbed_official 376:cb4d9db17537 591 * @brief Enables ADC and starts conversion of the regular channels.
mbed_official 376:cb4d9db17537 592 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 593 * the configuration information for the specified ADC.
mbed_official 376:cb4d9db17537 594 * @retval HAL status
mbed_official 376:cb4d9db17537 595 */
mbed_official 376:cb4d9db17537 596 HAL_StatusTypeDef HAL_ADC_Start(ADC_HandleTypeDef* hadc)
mbed_official 376:cb4d9db17537 597 {
mbed_official 376:cb4d9db17537 598 HAL_StatusTypeDef tmpHALStatus = HAL_OK;
mbed_official 376:cb4d9db17537 599
mbed_official 376:cb4d9db17537 600 /* Check the parameters */
mbed_official 376:cb4d9db17537 601 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 376:cb4d9db17537 602
mbed_official 489:119543c9f674 603 /* Perform ADC enable and conversion start if no conversion is on going */
mbed_official 489:119543c9f674 604 if (ADC_IS_CONVERSION_ONGOING(hadc) == RESET)
mbed_official 489:119543c9f674 605 {
mbed_official 489:119543c9f674 606 /* Process locked */
mbed_official 489:119543c9f674 607 __HAL_LOCK(hadc);
mbed_official 489:119543c9f674 608
mbed_official 489:119543c9f674 609 /* Change ADC state */
mbed_official 489:119543c9f674 610 hadc->State = HAL_ADC_STATE_BUSY_REG;
mbed_official 489:119543c9f674 611
mbed_official 489:119543c9f674 612 /* Set ADC error code to none */
mbed_official 489:119543c9f674 613 hadc->ErrorCode = HAL_ADC_ERROR_NONE;
mbed_official 376:cb4d9db17537 614
mbed_official 489:119543c9f674 615 /* Enable the ADC peripheral */
mbed_official 489:119543c9f674 616 /* If low power mode AutoPowerOff is enabled, power-on/off phases are */
mbed_official 489:119543c9f674 617 /* performed automatically by hardware. */
mbed_official 489:119543c9f674 618 if (hadc->Init.LowPowerAutoPowerOff != ENABLE)
mbed_official 489:119543c9f674 619 {
mbed_official 489:119543c9f674 620 tmpHALStatus = ADC_Enable(hadc);
mbed_official 489:119543c9f674 621 }
mbed_official 489:119543c9f674 622
mbed_official 489:119543c9f674 623 /* Start conversion if ADC is effectively enabled */
mbed_official 489:119543c9f674 624 if (tmpHALStatus != HAL_ERROR)
mbed_official 489:119543c9f674 625 {
mbed_official 489:119543c9f674 626 /* ADC start conversion command */
mbed_official 489:119543c9f674 627 hadc->Instance->CR |= ADC_CR_ADSTART;
mbed_official 489:119543c9f674 628 }
mbed_official 489:119543c9f674 629
mbed_official 489:119543c9f674 630 /* Process unlocked */
mbed_official 489:119543c9f674 631 __HAL_UNLOCK(hadc);
mbed_official 489:119543c9f674 632 }
mbed_official 489:119543c9f674 633 else
mbed_official 376:cb4d9db17537 634 {
mbed_official 489:119543c9f674 635 tmpHALStatus = HAL_BUSY;
mbed_official 376:cb4d9db17537 636 }
mbed_official 376:cb4d9db17537 637
mbed_official 376:cb4d9db17537 638 /* Return function status */
mbed_official 489:119543c9f674 639 return tmpHALStatus;
mbed_official 376:cb4d9db17537 640 }
mbed_official 376:cb4d9db17537 641
mbed_official 376:cb4d9db17537 642 /**
mbed_official 376:cb4d9db17537 643 * @brief Stop ADC conversion of regular channels, disable ADC peripheral.
mbed_official 376:cb4d9db17537 644 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 645 * the configuration information for the specified ADC.
mbed_official 376:cb4d9db17537 646 * @retval None
mbed_official 376:cb4d9db17537 647 */
mbed_official 376:cb4d9db17537 648 HAL_StatusTypeDef HAL_ADC_Stop(ADC_HandleTypeDef* hadc)
mbed_official 376:cb4d9db17537 649 {
mbed_official 376:cb4d9db17537 650 HAL_StatusTypeDef tmpHALStatus = HAL_OK;
mbed_official 376:cb4d9db17537 651
mbed_official 376:cb4d9db17537 652 /* Process locked */
mbed_official 376:cb4d9db17537 653 __HAL_LOCK(hadc);
mbed_official 376:cb4d9db17537 654
mbed_official 376:cb4d9db17537 655 /* 1. Stop potential conversion ongoing (regular conversion) */
mbed_official 489:119543c9f674 656 tmpHALStatus = ADC_ConversionStop(hadc, ADC_REGULAR_GROUP);
mbed_official 376:cb4d9db17537 657
mbed_official 376:cb4d9db17537 658 /* 2. Disable ADC peripheral if conversions are effectively stopped */
mbed_official 376:cb4d9db17537 659 if (tmpHALStatus != HAL_ERROR)
mbed_official 376:cb4d9db17537 660 {
mbed_official 376:cb4d9db17537 661 /* Disable the ADC peripheral */
mbed_official 489:119543c9f674 662 tmpHALStatus = ADC_Disable(hadc);
mbed_official 376:cb4d9db17537 663
mbed_official 376:cb4d9db17537 664 /* Check if ADC is effectively disabled */
mbed_official 489:119543c9f674 665 if ((hadc->State != HAL_ADC_STATE_ERROR) && (tmpHALStatus != HAL_ERROR))
mbed_official 376:cb4d9db17537 666 {
mbed_official 376:cb4d9db17537 667 /* Change ADC state */
mbed_official 376:cb4d9db17537 668 hadc->State = HAL_ADC_STATE_READY;
mbed_official 376:cb4d9db17537 669 }
mbed_official 376:cb4d9db17537 670 else
mbed_official 376:cb4d9db17537 671 {
mbed_official 376:cb4d9db17537 672 return HAL_ERROR;
mbed_official 376:cb4d9db17537 673 }
mbed_official 376:cb4d9db17537 674 }
mbed_official 376:cb4d9db17537 675 else
mbed_official 376:cb4d9db17537 676 {
mbed_official 376:cb4d9db17537 677 return HAL_ERROR;
mbed_official 376:cb4d9db17537 678 }
mbed_official 376:cb4d9db17537 679
mbed_official 376:cb4d9db17537 680 /* Process unlocked */
mbed_official 376:cb4d9db17537 681 __HAL_UNLOCK(hadc);
mbed_official 376:cb4d9db17537 682
mbed_official 376:cb4d9db17537 683 /* Return function status */
mbed_official 376:cb4d9db17537 684 return HAL_OK;
mbed_official 376:cb4d9db17537 685 }
mbed_official 376:cb4d9db17537 686
mbed_official 376:cb4d9db17537 687 /**
mbed_official 489:119543c9f674 688 * @brief Wait for regular group conversion to be completed.
mbed_official 489:119543c9f674 689 * @note ADC conversion flags EOS (end of sequence) and EOC (end of
mbed_official 489:119543c9f674 690 * conversion) are cleared by this function, with an exception:
mbed_official 489:119543c9f674 691 * if low power feature "LowPowerAutoWait" is enabled, flags are
mbed_official 489:119543c9f674 692 * not cleared to not interfere with this feature until data register
mbed_official 489:119543c9f674 693 * is read using function HAL_ADC_GetValue().
mbed_official 489:119543c9f674 694 * @note This function cannot be used in a particular setup: ADC configured
mbed_official 489:119543c9f674 695 * in DMA mode and polling for end of each conversion (ADC init
mbed_official 489:119543c9f674 696 * parameter "EOCSelection" set to ADC_EOC_SINGLE_CONV).
mbed_official 489:119543c9f674 697 * In this case, DMA resets the flag EOC and polling cannot be
mbed_official 489:119543c9f674 698 * performed on each conversion. Nevertheless, polling can still
mbed_official 489:119543c9f674 699 * be performed on the complete sequence.
mbed_official 489:119543c9f674 700 * @param hadc: ADC handle
mbed_official 489:119543c9f674 701 * @param Timeout: Timeout value in millisecond.
mbed_official 376:cb4d9db17537 702 * @retval HAL status
mbed_official 376:cb4d9db17537 703 */
mbed_official 376:cb4d9db17537 704 HAL_StatusTypeDef HAL_ADC_PollForConversion(ADC_HandleTypeDef* hadc, uint32_t Timeout)
mbed_official 376:cb4d9db17537 705 {
mbed_official 376:cb4d9db17537 706 uint32_t tickstart = 0;
mbed_official 376:cb4d9db17537 707 uint32_t tmp_Flag_EOC;
mbed_official 376:cb4d9db17537 708
mbed_official 376:cb4d9db17537 709 /* Check the parameters */
mbed_official 376:cb4d9db17537 710 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 489:119543c9f674 711
mbed_official 489:119543c9f674 712 /* If end of conversion selected to end of sequence */
mbed_official 489:119543c9f674 713 if (hadc->Init.EOCSelection == ADC_EOC_SEQ_CONV)
mbed_official 376:cb4d9db17537 714 {
mbed_official 376:cb4d9db17537 715 tmp_Flag_EOC = ADC_FLAG_EOS;
mbed_official 376:cb4d9db17537 716 }
mbed_official 489:119543c9f674 717 /* If end of conversion selected to end of each conversion */
mbed_official 489:119543c9f674 718 else /* ADC_EOC_SINGLE_CONV */
mbed_official 376:cb4d9db17537 719 {
mbed_official 489:119543c9f674 720 /* Verification that ADC configuration is compliant with polling for */
mbed_official 489:119543c9f674 721 /* each conversion: */
mbed_official 489:119543c9f674 722 /* Particular case is ADC configured in DMA mode and ADC sequencer with */
mbed_official 489:119543c9f674 723 /* several ranks and polling for end of each conversion. */
mbed_official 489:119543c9f674 724 /* For code simplicity sake, this particular case is generalized to */
mbed_official 489:119543c9f674 725 /* ADC configured in DMA mode and and polling for end of each conversion. */
mbed_official 489:119543c9f674 726 if (HAL_IS_BIT_SET(hadc->Instance->CFGR1, ADC_CFGR1_DMAEN))
mbed_official 489:119543c9f674 727 {
mbed_official 489:119543c9f674 728 /* Update ADC state machine to error */
mbed_official 489:119543c9f674 729 hadc->State = HAL_ADC_STATE_ERROR;
mbed_official 489:119543c9f674 730
mbed_official 489:119543c9f674 731 /* Process unlocked */
mbed_official 489:119543c9f674 732 __HAL_UNLOCK(hadc);
mbed_official 489:119543c9f674 733
mbed_official 489:119543c9f674 734 return HAL_ERROR;
mbed_official 489:119543c9f674 735 }
mbed_official 489:119543c9f674 736 else
mbed_official 489:119543c9f674 737 {
mbed_official 489:119543c9f674 738 tmp_Flag_EOC = (ADC_FLAG_EOC | ADC_FLAG_EOS);
mbed_official 489:119543c9f674 739 }
mbed_official 376:cb4d9db17537 740 }
mbed_official 489:119543c9f674 741
mbed_official 489:119543c9f674 742 /* Get tick */
mbed_official 376:cb4d9db17537 743 tickstart = HAL_GetTick();
mbed_official 489:119543c9f674 744
mbed_official 376:cb4d9db17537 745 /* Wait until End of Conversion flag is raised */
mbed_official 376:cb4d9db17537 746 while(HAL_IS_BIT_CLR(hadc->Instance->ISR, tmp_Flag_EOC))
mbed_official 376:cb4d9db17537 747 {
mbed_official 489:119543c9f674 748 /* Check if timeout is disabled (set to infinite wait) */
mbed_official 376:cb4d9db17537 749 if(Timeout != HAL_MAX_DELAY)
mbed_official 376:cb4d9db17537 750 {
mbed_official 489:119543c9f674 751 if((Timeout == 0) || ((HAL_GetTick()-tickstart) > Timeout))
mbed_official 376:cb4d9db17537 752 {
mbed_official 489:119543c9f674 753 /* Update ADC state machine to timeout */
mbed_official 489:119543c9f674 754 hadc->State = HAL_ADC_STATE_TIMEOUT;
mbed_official 376:cb4d9db17537 755
mbed_official 376:cb4d9db17537 756 /* Process unlocked */
mbed_official 376:cb4d9db17537 757 __HAL_UNLOCK(hadc);
mbed_official 376:cb4d9db17537 758
mbed_official 376:cb4d9db17537 759 return HAL_TIMEOUT;
mbed_official 376:cb4d9db17537 760 }
mbed_official 376:cb4d9db17537 761 }
mbed_official 376:cb4d9db17537 762 }
mbed_official 376:cb4d9db17537 763
mbed_official 376:cb4d9db17537 764 /* Clear end of conversion flag of regular group if low power feature */
mbed_official 376:cb4d9db17537 765 /* "LowPowerAutoWait " is disabled, to not interfere with this feature */
mbed_official 376:cb4d9db17537 766 /* until data register is read using function HAL_ADC_GetValue(). */
mbed_official 376:cb4d9db17537 767 if (hadc->Init.LowPowerAutoWait == DISABLE)
mbed_official 376:cb4d9db17537 768 {
mbed_official 376:cb4d9db17537 769 /* Clear regular group conversion flag */
mbed_official 376:cb4d9db17537 770 __HAL_ADC_CLEAR_FLAG(hadc, (ADC_FLAG_EOC | ADC_FLAG_EOS));
mbed_official 376:cb4d9db17537 771 }
mbed_official 489:119543c9f674 772
mbed_official 489:119543c9f674 773 /* Update state machine on conversion status if not in error state */
mbed_official 489:119543c9f674 774 if(hadc->State != HAL_ADC_STATE_ERROR)
mbed_official 489:119543c9f674 775 {
mbed_official 489:119543c9f674 776 /* Change ADC state */
mbed_official 489:119543c9f674 777 hadc->State = HAL_ADC_STATE_EOC;
mbed_official 489:119543c9f674 778 }
mbed_official 376:cb4d9db17537 779
mbed_official 376:cb4d9db17537 780 /* Return ADC state */
mbed_official 376:cb4d9db17537 781 return HAL_OK;
mbed_official 376:cb4d9db17537 782 }
mbed_official 376:cb4d9db17537 783
mbed_official 376:cb4d9db17537 784 /**
mbed_official 376:cb4d9db17537 785 * @brief Poll for conversion event.
mbed_official 376:cb4d9db17537 786 * @param hadc: ADC handle.
mbed_official 376:cb4d9db17537 787 * @param EventType: the ADC event type.
mbed_official 376:cb4d9db17537 788 * This parameter can be one of the following values:
mbed_official 489:119543c9f674 789 * @arg ADC_AWD_EVENT: ADC Analog watchdog event.
mbed_official 489:119543c9f674 790 * @arg ADC_OVR_EVENT: ADC Overrun event.
mbed_official 376:cb4d9db17537 791 * @param Timeout: Timeout value in millisecond.
mbed_official 376:cb4d9db17537 792 * @retval HAL status
mbed_official 376:cb4d9db17537 793 */
mbed_official 376:cb4d9db17537 794 HAL_StatusTypeDef HAL_ADC_PollForEvent(ADC_HandleTypeDef* hadc, uint32_t EventType, uint32_t Timeout)
mbed_official 376:cb4d9db17537 795 {
mbed_official 376:cb4d9db17537 796 uint32_t tickstart = 0;
mbed_official 376:cb4d9db17537 797
mbed_official 376:cb4d9db17537 798 /* Check the parameters */
mbed_official 376:cb4d9db17537 799 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 376:cb4d9db17537 800 assert_param(IS_ADC_EVENT_TYPE(EventType));
mbed_official 376:cb4d9db17537 801
mbed_official 376:cb4d9db17537 802 /* Get timeout */
mbed_official 376:cb4d9db17537 803 tickstart = HAL_GetTick();
mbed_official 376:cb4d9db17537 804
mbed_official 376:cb4d9db17537 805 /* Check selected event flag */
mbed_official 376:cb4d9db17537 806 while(!(__HAL_ADC_GET_FLAG(hadc,EventType)))
mbed_official 376:cb4d9db17537 807 {
mbed_official 376:cb4d9db17537 808 /* Check if timeout is disabled (set to infinite wait) */
mbed_official 376:cb4d9db17537 809 if(Timeout != HAL_MAX_DELAY)
mbed_official 376:cb4d9db17537 810 {
mbed_official 376:cb4d9db17537 811 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 376:cb4d9db17537 812 {
mbed_official 376:cb4d9db17537 813 /* Update ADC state machine to timeout */
mbed_official 376:cb4d9db17537 814 hadc->State = HAL_ADC_STATE_TIMEOUT;
mbed_official 376:cb4d9db17537 815
mbed_official 376:cb4d9db17537 816 /* Process unlocked */
mbed_official 376:cb4d9db17537 817 __HAL_UNLOCK(hadc);
mbed_official 376:cb4d9db17537 818
mbed_official 376:cb4d9db17537 819 return HAL_TIMEOUT;
mbed_official 376:cb4d9db17537 820 }
mbed_official 376:cb4d9db17537 821 }
mbed_official 376:cb4d9db17537 822 }
mbed_official 376:cb4d9db17537 823
mbed_official 376:cb4d9db17537 824 switch(EventType)
mbed_official 376:cb4d9db17537 825 {
mbed_official 376:cb4d9db17537 826 /* Check analog watchdog flag */
mbed_official 489:119543c9f674 827 case ADC_AWD_EVENT:
mbed_official 376:cb4d9db17537 828 /* Change ADC state */
mbed_official 376:cb4d9db17537 829 hadc->State = HAL_ADC_STATE_AWD;
mbed_official 376:cb4d9db17537 830
mbed_official 376:cb4d9db17537 831 /* Clear ADC analog watchdog flag */
mbed_official 376:cb4d9db17537 832 __HAL_ADC_CLEAR_FLAG(hadc, ADC_FLAG_AWD);
mbed_official 376:cb4d9db17537 833 break;
mbed_official 376:cb4d9db17537 834
mbed_official 489:119543c9f674 835 /* Case ADC_OVR_EVENT */
mbed_official 376:cb4d9db17537 836 default:
mbed_official 376:cb4d9db17537 837 /* Change ADC state */
mbed_official 376:cb4d9db17537 838 hadc->State = HAL_ADC_STATE_ERROR;
mbed_official 376:cb4d9db17537 839
mbed_official 376:cb4d9db17537 840 /* Clear ADC Overrun flag */
mbed_official 376:cb4d9db17537 841 __HAL_ADC_CLEAR_FLAG(hadc, ADC_FLAG_OVR);
mbed_official 376:cb4d9db17537 842 break;
mbed_official 376:cb4d9db17537 843 }
mbed_official 376:cb4d9db17537 844
mbed_official 376:cb4d9db17537 845 /* Return ADC state */
mbed_official 376:cb4d9db17537 846 return HAL_OK;
mbed_official 376:cb4d9db17537 847 }
mbed_official 376:cb4d9db17537 848
mbed_official 376:cb4d9db17537 849 /**
mbed_official 376:cb4d9db17537 850 * @brief Enables the interrupt and starts ADC conversion of regular channels.
mbed_official 376:cb4d9db17537 851 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 852 * the configuration information for the specified ADC.
mbed_official 376:cb4d9db17537 853 * @retval HAL status.
mbed_official 376:cb4d9db17537 854 */
mbed_official 376:cb4d9db17537 855 HAL_StatusTypeDef HAL_ADC_Start_IT(ADC_HandleTypeDef* hadc)
mbed_official 376:cb4d9db17537 856 {
mbed_official 376:cb4d9db17537 857 HAL_StatusTypeDef tmpHALStatus = HAL_OK;
mbed_official 376:cb4d9db17537 858
mbed_official 376:cb4d9db17537 859 /* Check the parameters */
mbed_official 376:cb4d9db17537 860 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 376:cb4d9db17537 861
mbed_official 489:119543c9f674 862 /* Perform ADC enable and conversion start if no conversion is on going */
mbed_official 489:119543c9f674 863 if (ADC_IS_CONVERSION_ONGOING(hadc) == RESET)
mbed_official 376:cb4d9db17537 864 {
mbed_official 489:119543c9f674 865 /* Process locked */
mbed_official 489:119543c9f674 866 __HAL_LOCK(hadc);
mbed_official 489:119543c9f674 867
mbed_official 489:119543c9f674 868 /* State machine update: Change ADC state */
mbed_official 489:119543c9f674 869 hadc->State = HAL_ADC_STATE_BUSY_REG;
mbed_official 376:cb4d9db17537 870
mbed_official 489:119543c9f674 871 /* Set ADC error code to none */
mbed_official 489:119543c9f674 872 hadc->ErrorCode = HAL_ADC_ERROR_NONE;
mbed_official 489:119543c9f674 873
mbed_official 489:119543c9f674 874 /* Enable the ADC peripheral */
mbed_official 489:119543c9f674 875 /* If low power mode AutoPowerOff is enabled, power-on/off phases are */
mbed_official 489:119543c9f674 876 /* performed automatically by hardware. */
mbed_official 489:119543c9f674 877 if (hadc->Init.LowPowerAutoPowerOff != ENABLE)
mbed_official 376:cb4d9db17537 878 {
mbed_official 489:119543c9f674 879 tmpHALStatus = ADC_Enable(hadc);
mbed_official 376:cb4d9db17537 880 }
mbed_official 376:cb4d9db17537 881
mbed_official 489:119543c9f674 882 /* Start conversion if ADC is effectively enabled */
mbed_official 489:119543c9f674 883 if (tmpHALStatus != HAL_ERROR)
mbed_official 489:119543c9f674 884 {
mbed_official 489:119543c9f674 885 /* Enable ADC overrun interrupt */
mbed_official 489:119543c9f674 886 __HAL_ADC_ENABLE_IT(hadc, ADC_IT_OVR);
mbed_official 489:119543c9f674 887
mbed_official 489:119543c9f674 888 /* Enable ADC end of conversion interrupt */
mbed_official 489:119543c9f674 889 switch(hadc->Init.EOCSelection)
mbed_official 489:119543c9f674 890 {
mbed_official 489:119543c9f674 891 case ADC_EOC_SEQ_CONV:
mbed_official 489:119543c9f674 892 __HAL_ADC_DISABLE_IT(hadc, ADC_IT_EOC);
mbed_official 489:119543c9f674 893 __HAL_ADC_ENABLE_IT(hadc, ADC_IT_EOS);
mbed_official 489:119543c9f674 894 break;
mbed_official 489:119543c9f674 895 /* case ADC_EOC_SINGLE_CONV */
mbed_official 489:119543c9f674 896 default:
mbed_official 489:119543c9f674 897 __HAL_ADC_DISABLE_IT(hadc, ADC_IT_EOS);
mbed_official 489:119543c9f674 898 __HAL_ADC_ENABLE_IT(hadc, ADC_IT_EOC);
mbed_official 489:119543c9f674 899 break;
mbed_official 489:119543c9f674 900 }
mbed_official 489:119543c9f674 901
mbed_official 489:119543c9f674 902 /* ADC start conversion command */
mbed_official 489:119543c9f674 903 hadc->Instance->CR |= ADC_CR_ADSTART;
mbed_official 489:119543c9f674 904 }
mbed_official 489:119543c9f674 905
mbed_official 489:119543c9f674 906 else
mbed_official 489:119543c9f674 907 {
mbed_official 489:119543c9f674 908 tmpHALStatus = HAL_ERROR;
mbed_official 489:119543c9f674 909 }
mbed_official 489:119543c9f674 910
mbed_official 489:119543c9f674 911 /* Process unlocked */
mbed_official 489:119543c9f674 912 __HAL_UNLOCK(hadc);
mbed_official 376:cb4d9db17537 913 }
mbed_official 376:cb4d9db17537 914 else
mbed_official 376:cb4d9db17537 915 {
mbed_official 489:119543c9f674 916 tmpHALStatus = HAL_BUSY;
mbed_official 376:cb4d9db17537 917 }
mbed_official 489:119543c9f674 918
mbed_official 376:cb4d9db17537 919 /* Return function status */
mbed_official 489:119543c9f674 920 return tmpHALStatus;
mbed_official 376:cb4d9db17537 921 }
mbed_official 376:cb4d9db17537 922
mbed_official 376:cb4d9db17537 923 /**
mbed_official 376:cb4d9db17537 924 * @brief Stop ADC conversion of regular channels, disable interruptions
mbed_official 376:cb4d9db17537 925 * EOC/EOS/OVR, disable ADC peripheral.
mbed_official 376:cb4d9db17537 926 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 927 * the configuration information for the specified ADC.
mbed_official 376:cb4d9db17537 928 * @retval None
mbed_official 376:cb4d9db17537 929 */
mbed_official 376:cb4d9db17537 930 HAL_StatusTypeDef HAL_ADC_Stop_IT(ADC_HandleTypeDef* hadc)
mbed_official 376:cb4d9db17537 931 {
mbed_official 376:cb4d9db17537 932 HAL_StatusTypeDef tmpHALStatus = HAL_OK;
mbed_official 376:cb4d9db17537 933
mbed_official 376:cb4d9db17537 934 /* Process locked */
mbed_official 376:cb4d9db17537 935 __HAL_LOCK(hadc);
mbed_official 376:cb4d9db17537 936
mbed_official 376:cb4d9db17537 937 /* 1. Stop potential conversion ongoing (regular conversion) */
mbed_official 489:119543c9f674 938 tmpHALStatus = ADC_ConversionStop(hadc, ADC_REGULAR_GROUP);
mbed_official 376:cb4d9db17537 939
mbed_official 376:cb4d9db17537 940 /* 2. Disable ADC peripheral if conversions are effectively stopped */
mbed_official 376:cb4d9db17537 941 if (tmpHALStatus != HAL_ERROR)
mbed_official 376:cb4d9db17537 942 {
mbed_official 376:cb4d9db17537 943 /* Disable ADC interrupts */
mbed_official 376:cb4d9db17537 944 __HAL_ADC_DISABLE_IT(hadc, (ADC_IT_EOC | ADC_IT_EOS | ADC_IT_OVR));
mbed_official 376:cb4d9db17537 945
mbed_official 376:cb4d9db17537 946 /* Disable the ADC peripheral */
mbed_official 489:119543c9f674 947 tmpHALStatus = ADC_Disable(hadc);
mbed_official 376:cb4d9db17537 948
mbed_official 376:cb4d9db17537 949 /* Check if ADC is effectively disabled */
mbed_official 489:119543c9f674 950 if ((hadc->State != HAL_ADC_STATE_ERROR) && (tmpHALStatus != HAL_ERROR))
mbed_official 376:cb4d9db17537 951 {
mbed_official 376:cb4d9db17537 952 /* Change ADC state */
mbed_official 376:cb4d9db17537 953 hadc->State = HAL_ADC_STATE_READY;
mbed_official 376:cb4d9db17537 954 }
mbed_official 376:cb4d9db17537 955 else
mbed_official 376:cb4d9db17537 956 {
mbed_official 376:cb4d9db17537 957 return HAL_ERROR;
mbed_official 376:cb4d9db17537 958 }
mbed_official 376:cb4d9db17537 959 }
mbed_official 376:cb4d9db17537 960 else
mbed_official 376:cb4d9db17537 961 {
mbed_official 376:cb4d9db17537 962 return HAL_ERROR;
mbed_official 376:cb4d9db17537 963 }
mbed_official 376:cb4d9db17537 964
mbed_official 376:cb4d9db17537 965
mbed_official 376:cb4d9db17537 966 /* Process unlocked */
mbed_official 376:cb4d9db17537 967 __HAL_UNLOCK(hadc);
mbed_official 376:cb4d9db17537 968
mbed_official 376:cb4d9db17537 969 /* Return function status */
mbed_official 376:cb4d9db17537 970 return HAL_OK;
mbed_official 376:cb4d9db17537 971 }
mbed_official 376:cb4d9db17537 972
mbed_official 376:cb4d9db17537 973 /**
mbed_official 376:cb4d9db17537 974 * @brief Handles ADC interrupt request
mbed_official 376:cb4d9db17537 975 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 976 * the configuration information for the specified ADC.
mbed_official 376:cb4d9db17537 977 * @retval None
mbed_official 376:cb4d9db17537 978 */
mbed_official 376:cb4d9db17537 979 void HAL_ADC_IRQHandler(ADC_HandleTypeDef* hadc)
mbed_official 376:cb4d9db17537 980 {
mbed_official 376:cb4d9db17537 981 /* Check the parameters */
mbed_official 376:cb4d9db17537 982 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 376:cb4d9db17537 983 assert_param(IS_ADC_EOC_SELECTION(hadc->Init.EOCSelection));
mbed_official 376:cb4d9db17537 984
mbed_official 376:cb4d9db17537 985
mbed_official 376:cb4d9db17537 986 /* Check End of Conversion flag for regular channels */
mbed_official 376:cb4d9db17537 987 if( (__HAL_ADC_GET_FLAG(hadc, ADC_FLAG_EOC) && __HAL_ADC_GET_IT_SOURCE(hadc, ADC_IT_EOC)) || \
mbed_official 376:cb4d9db17537 988 (__HAL_ADC_GET_FLAG(hadc, ADC_FLAG_EOS) && __HAL_ADC_GET_IT_SOURCE(hadc, ADC_IT_EOS)) )
mbed_official 376:cb4d9db17537 989 {
mbed_official 376:cb4d9db17537 990 /* Change ADC state */
mbed_official 376:cb4d9db17537 991 hadc->State = HAL_ADC_STATE_EOC;
mbed_official 376:cb4d9db17537 992
mbed_official 376:cb4d9db17537 993
mbed_official 376:cb4d9db17537 994 /* Disable interruption if no further conversion upcoming by continuous mode or external trigger */
mbed_official 376:cb4d9db17537 995 if((hadc->Init.ContinuousConvMode == DISABLE) && \
mbed_official 489:119543c9f674 996 (hadc->Init.ExternalTrigConvEdge == ADC_EXTERNALTRIGCONVEDGE_NONE)
mbed_official 376:cb4d9db17537 997 )
mbed_official 376:cb4d9db17537 998 {
mbed_official 376:cb4d9db17537 999 /* Allowed to modify bits ADC_IT_EOC/ADC_IT_EOS only if bit ADSTART==0 (no conversion on going) */
mbed_official 376:cb4d9db17537 1000 if (HAL_IS_BIT_CLR(hadc->Instance->CR, ADC_CR_ADSTART))
mbed_official 376:cb4d9db17537 1001 {
mbed_official 376:cb4d9db17537 1002 /* Cases of interruption after each conversion or after each sequence */
mbed_official 376:cb4d9db17537 1003 /* If interruption after each sequence */
mbed_official 489:119543c9f674 1004 if (hadc->Init.EOCSelection == ADC_EOC_SEQ_CONV)
mbed_official 376:cb4d9db17537 1005 {
mbed_official 489:119543c9f674 1006 /* Allowed to modify bits ADC_IT_EOC/ADC_IT_EOS/ADC_IT_OVR only if bit*/
mbed_official 489:119543c9f674 1007 /* ADSTART==0 (no conversion on going) */
mbed_official 489:119543c9f674 1008 if (ADC_IS_CONVERSION_ONGOING(hadc) == RESET)
mbed_official 376:cb4d9db17537 1009 {
mbed_official 489:119543c9f674 1010 /* If End of Sequence is reached, disable interrupts */
mbed_official 489:119543c9f674 1011 if( __HAL_ADC_GET_FLAG(hadc, ADC_FLAG_EOS) )
mbed_official 489:119543c9f674 1012 {
mbed_official 489:119543c9f674 1013 /* DISABLE ADC end of sequence conversion interrupt */
mbed_official 489:119543c9f674 1014 /* DISABLE ADC overrun interrupt */
mbed_official 489:119543c9f674 1015 __HAL_ADC_DISABLE_IT(hadc, ADC_IT_EOC | ADC_IT_EOS | ADC_IT_OVR);
mbed_official 489:119543c9f674 1016 }
mbed_official 489:119543c9f674 1017 }
mbed_official 489:119543c9f674 1018 else
mbed_official 489:119543c9f674 1019 {
mbed_official 489:119543c9f674 1020 /* Change ADC state to error state */
mbed_official 489:119543c9f674 1021 hadc->State = HAL_ADC_STATE_ERROR;
mbed_official 489:119543c9f674 1022 /* Set ADC error code to ADC IP internal error */
mbed_official 489:119543c9f674 1023 hadc->ErrorCode |= HAL_ADC_ERROR_INTERNAL;
mbed_official 376:cb4d9db17537 1024 }
mbed_official 376:cb4d9db17537 1025 }
mbed_official 376:cb4d9db17537 1026 /* If interruption after each conversion */
mbed_official 376:cb4d9db17537 1027 else
mbed_official 376:cb4d9db17537 1028 {
mbed_official 376:cb4d9db17537 1029 /* DISABLE ADC end of single conversion interrupt */
mbed_official 376:cb4d9db17537 1030 /* DISABLE ADC overrun interrupt */
mbed_official 376:cb4d9db17537 1031 __HAL_ADC_DISABLE_IT(hadc, ADC_IT_EOC | ADC_IT_OVR);
mbed_official 376:cb4d9db17537 1032 }
mbed_official 376:cb4d9db17537 1033 }
mbed_official 376:cb4d9db17537 1034 else
mbed_official 376:cb4d9db17537 1035 {
mbed_official 376:cb4d9db17537 1036 /* Change ADC state to error state */
mbed_official 376:cb4d9db17537 1037 hadc->State = HAL_ADC_STATE_ERROR;
mbed_official 376:cb4d9db17537 1038 }
mbed_official 376:cb4d9db17537 1039 }
mbed_official 376:cb4d9db17537 1040
mbed_official 376:cb4d9db17537 1041 /* Conversion complete callback */
mbed_official 376:cb4d9db17537 1042 /* Note: into callback, to determine if callback has been triggered from EOC or EOS, */
mbed_official 376:cb4d9db17537 1043 /* it is possible to use: if( __HAL_ADC_GET_FLAG(hadc, ADC_FLAG_EOS)) */
mbed_official 376:cb4d9db17537 1044 HAL_ADC_ConvCpltCallback(hadc);
mbed_official 376:cb4d9db17537 1045
mbed_official 376:cb4d9db17537 1046 /* Clear regular channels conversion flag */
mbed_official 376:cb4d9db17537 1047 if (hadc->Init.LowPowerAutoWait != ENABLE)
mbed_official 376:cb4d9db17537 1048 {
mbed_official 376:cb4d9db17537 1049 __HAL_ADC_CLEAR_FLAG(hadc, (ADC_FLAG_EOC | ADC_FLAG_EOS) );
mbed_official 376:cb4d9db17537 1050 }
mbed_official 376:cb4d9db17537 1051 }
mbed_official 376:cb4d9db17537 1052
mbed_official 376:cb4d9db17537 1053
mbed_official 376:cb4d9db17537 1054 /* Check Analog watchdog flags */
mbed_official 376:cb4d9db17537 1055 if( (__HAL_ADC_GET_FLAG(hadc, ADC_FLAG_AWD) && __HAL_ADC_GET_IT_SOURCE(hadc, ADC_IT_AWD)))
mbed_official 376:cb4d9db17537 1056 {
mbed_official 376:cb4d9db17537 1057 /* Change ADC state */
mbed_official 376:cb4d9db17537 1058 hadc->State = HAL_ADC_STATE_AWD;
mbed_official 376:cb4d9db17537 1059
mbed_official 376:cb4d9db17537 1060 /* Level out of window callback */
mbed_official 376:cb4d9db17537 1061 HAL_ADC_LevelOutOfWindowCallback(hadc);
mbed_official 376:cb4d9db17537 1062
mbed_official 376:cb4d9db17537 1063 /* Clear ADC Analog watchdog flag */
mbed_official 376:cb4d9db17537 1064 __HAL_ADC_CLEAR_FLAG(hadc, ADC_FLAG_AWD);
mbed_official 376:cb4d9db17537 1065 }
mbed_official 376:cb4d9db17537 1066
mbed_official 376:cb4d9db17537 1067 /* Check Overrun flag */
mbed_official 376:cb4d9db17537 1068 if(__HAL_ADC_GET_FLAG(hadc, ADC_FLAG_OVR) && __HAL_ADC_GET_IT_SOURCE(hadc, ADC_IT_OVR))
mbed_official 376:cb4d9db17537 1069 {
mbed_official 376:cb4d9db17537 1070 /* Change ADC state to overrun state */
mbed_official 376:cb4d9db17537 1071 hadc->State = HAL_ADC_STATE_ERROR;
mbed_official 376:cb4d9db17537 1072
mbed_official 376:cb4d9db17537 1073 /* Set ADC error code to overrun */
mbed_official 376:cb4d9db17537 1074 hadc->ErrorCode |= HAL_ADC_ERROR_OVR;
mbed_official 376:cb4d9db17537 1075
mbed_official 376:cb4d9db17537 1076 /* Clear the Overrun flag */
mbed_official 376:cb4d9db17537 1077 __HAL_ADC_CLEAR_FLAG(hadc,ADC_FLAG_OVR);
mbed_official 376:cb4d9db17537 1078
mbed_official 376:cb4d9db17537 1079 /* Error callback */
mbed_official 376:cb4d9db17537 1080 HAL_ADC_ErrorCallback(hadc);
mbed_official 376:cb4d9db17537 1081 }
mbed_official 376:cb4d9db17537 1082 }
mbed_official 376:cb4d9db17537 1083
mbed_official 376:cb4d9db17537 1084 /**
mbed_official 376:cb4d9db17537 1085 * @brief Enables ADC DMA request after last transfer (Single-ADC mode) and enables ADC peripheral
mbed_official 376:cb4d9db17537 1086 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1087 * the configuration information for the specified ADC.
mbed_official 376:cb4d9db17537 1088 * @param pData: The destination Buffer address.
mbed_official 376:cb4d9db17537 1089 * @param Length: The length of data to be transferred from ADC peripheral to memory.
mbed_official 376:cb4d9db17537 1090 * @retval None
mbed_official 376:cb4d9db17537 1091 */
mbed_official 376:cb4d9db17537 1092 HAL_StatusTypeDef HAL_ADC_Start_DMA(ADC_HandleTypeDef* hadc, uint32_t* pData, uint32_t Length)
mbed_official 376:cb4d9db17537 1093 {
mbed_official 376:cb4d9db17537 1094 HAL_StatusTypeDef tmpHALStatus = HAL_OK;
mbed_official 376:cb4d9db17537 1095
mbed_official 376:cb4d9db17537 1096 /* Check the parameters */
mbed_official 376:cb4d9db17537 1097 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 376:cb4d9db17537 1098
mbed_official 489:119543c9f674 1099 /* Perform ADC enable and conversion start if no conversion is on going */
mbed_official 489:119543c9f674 1100 if (ADC_IS_CONVERSION_ONGOING(hadc) == RESET)
mbed_official 489:119543c9f674 1101 {
mbed_official 489:119543c9f674 1102 /* Process locked */
mbed_official 489:119543c9f674 1103 __HAL_LOCK(hadc);
mbed_official 489:119543c9f674 1104
mbed_official 489:119543c9f674 1105 /* Change ADC state */
mbed_official 489:119543c9f674 1106 hadc->State = HAL_ADC_STATE_BUSY_REG;
mbed_official 489:119543c9f674 1107
mbed_official 489:119543c9f674 1108 /* Set ADC error code to none */
mbed_official 489:119543c9f674 1109 hadc->ErrorCode = HAL_ADC_ERROR_NONE;
mbed_official 376:cb4d9db17537 1110
mbed_official 489:119543c9f674 1111 /* Enable the ADC peripheral */
mbed_official 489:119543c9f674 1112 /* If low power mode AutoPowerOff is enabled, power-on/off phases are */
mbed_official 489:119543c9f674 1113 /* performed automatically by hardware. */
mbed_official 489:119543c9f674 1114 if (hadc->Init.LowPowerAutoPowerOff != ENABLE)
mbed_official 489:119543c9f674 1115 {
mbed_official 489:119543c9f674 1116 tmpHALStatus = ADC_Enable(hadc);
mbed_official 489:119543c9f674 1117 }
mbed_official 376:cb4d9db17537 1118
mbed_official 489:119543c9f674 1119 /* Start conversion if ADC is effectively enabled */
mbed_official 489:119543c9f674 1120 if (tmpHALStatus != HAL_ERROR)
mbed_official 489:119543c9f674 1121 {
mbed_official 489:119543c9f674 1122 /* Enable ADC DMA mode */
mbed_official 489:119543c9f674 1123 hadc->Instance->CFGR1 |= ADC_CFGR1_DMAEN;
mbed_official 489:119543c9f674 1124
mbed_official 489:119543c9f674 1125 /* Set the DMA transfer complete callback */
mbed_official 489:119543c9f674 1126 hadc->DMA_Handle->XferCpltCallback = ADC_DMAConvCplt;
mbed_official 489:119543c9f674 1127
mbed_official 489:119543c9f674 1128 /* Set the DMA half transfer complete callback */
mbed_official 489:119543c9f674 1129 hadc->DMA_Handle->XferHalfCpltCallback = ADC_DMAHalfConvCplt;
mbed_official 489:119543c9f674 1130
mbed_official 489:119543c9f674 1131 /* Set the DMA error callback */
mbed_official 489:119543c9f674 1132 hadc->DMA_Handle->XferErrorCallback = ADC_DMAError;
mbed_official 489:119543c9f674 1133
mbed_official 489:119543c9f674 1134 /* Manage ADC and DMA start: ADC overrun interruption, DMA start,
mbed_official 489:119543c9f674 1135 ADC start (in case of SW start) */
mbed_official 489:119543c9f674 1136
mbed_official 489:119543c9f674 1137 /* Enable ADC overrun interrupt */
mbed_official 489:119543c9f674 1138 __HAL_ADC_ENABLE_IT(hadc, ADC_IT_OVR);
mbed_official 489:119543c9f674 1139
mbed_official 489:119543c9f674 1140 /* Enable the DMA Stream */
mbed_official 489:119543c9f674 1141 HAL_DMA_Start_IT(hadc->DMA_Handle, (uint32_t)&hadc->Instance->DR, (uint32_t)pData, Length);
mbed_official 489:119543c9f674 1142
mbed_official 489:119543c9f674 1143 /* ADC start conversion command */
mbed_official 489:119543c9f674 1144 hadc->Instance->CR |= ADC_CR_ADSTART;
mbed_official 489:119543c9f674 1145 }
mbed_official 489:119543c9f674 1146
mbed_official 489:119543c9f674 1147 /* Process unlocked */
mbed_official 489:119543c9f674 1148 __HAL_UNLOCK(hadc);
mbed_official 376:cb4d9db17537 1149 }
mbed_official 489:119543c9f674 1150 else
mbed_official 489:119543c9f674 1151 {
mbed_official 489:119543c9f674 1152 tmpHALStatus = HAL_BUSY;
mbed_official 489:119543c9f674 1153 }
mbed_official 376:cb4d9db17537 1154
mbed_official 376:cb4d9db17537 1155 /* Return function status */
mbed_official 489:119543c9f674 1156 return tmpHALStatus;
mbed_official 376:cb4d9db17537 1157 }
mbed_official 376:cb4d9db17537 1158
mbed_official 376:cb4d9db17537 1159 /**
mbed_official 376:cb4d9db17537 1160 * @brief Disable ADC DMA (Single-ADC mode), disable ADC peripheral
mbed_official 376:cb4d9db17537 1161 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1162 * the configuration information for the specified ADC.
mbed_official 376:cb4d9db17537 1163 * @retval None
mbed_official 376:cb4d9db17537 1164 */
mbed_official 376:cb4d9db17537 1165 HAL_StatusTypeDef HAL_ADC_Stop_DMA(ADC_HandleTypeDef* hadc)
mbed_official 376:cb4d9db17537 1166 {
mbed_official 376:cb4d9db17537 1167 HAL_StatusTypeDef tmpHALStatus = HAL_OK;
mbed_official 376:cb4d9db17537 1168
mbed_official 376:cb4d9db17537 1169 /* Process locked */
mbed_official 376:cb4d9db17537 1170 __HAL_LOCK(hadc);
mbed_official 376:cb4d9db17537 1171
mbed_official 376:cb4d9db17537 1172 /* 1. Stop potential conversion ongoing (regular conversion) */
mbed_official 489:119543c9f674 1173 tmpHALStatus = ADC_ConversionStop(hadc, ADC_REGULAR_GROUP);
mbed_official 376:cb4d9db17537 1174
mbed_official 376:cb4d9db17537 1175 /* 2. Disable ADC peripheral if conversions are effectively stopped */
mbed_official 376:cb4d9db17537 1176 if (tmpHALStatus != HAL_ERROR)
mbed_official 376:cb4d9db17537 1177 {
mbed_official 376:cb4d9db17537 1178 /* Disable ADC DMA (ADC DMA configuration ADC_CFGR_DMACFG is kept) */
mbed_official 376:cb4d9db17537 1179 hadc->Instance->CFGR1 &= ~ADC_CFGR1_DMAEN;
mbed_official 376:cb4d9db17537 1180
mbed_official 376:cb4d9db17537 1181 /* Disable the DMA Stream */
mbed_official 376:cb4d9db17537 1182 if (HAL_DMA_Abort(hadc->DMA_Handle) != HAL_OK)
mbed_official 376:cb4d9db17537 1183 {
mbed_official 376:cb4d9db17537 1184 /* Update ADC state machine to error */
mbed_official 376:cb4d9db17537 1185 hadc->State = HAL_ADC_STATE_ERROR;
mbed_official 376:cb4d9db17537 1186
mbed_official 376:cb4d9db17537 1187 /* Process unlocked */
mbed_official 376:cb4d9db17537 1188 __HAL_UNLOCK(hadc);
mbed_official 376:cb4d9db17537 1189
mbed_official 376:cb4d9db17537 1190 return HAL_ERROR;
mbed_official 376:cb4d9db17537 1191 }
mbed_official 376:cb4d9db17537 1192
mbed_official 376:cb4d9db17537 1193 /* Disable ADC overrun interrupt */
mbed_official 376:cb4d9db17537 1194 __HAL_ADC_DISABLE_IT(hadc, ADC_IT_OVR);
mbed_official 376:cb4d9db17537 1195
mbed_official 376:cb4d9db17537 1196 /* Disable the ADC peripheral */
mbed_official 489:119543c9f674 1197 tmpHALStatus = ADC_Disable(hadc);
mbed_official 376:cb4d9db17537 1198
mbed_official 376:cb4d9db17537 1199 /* Check if ADC is effectively disabled */
mbed_official 489:119543c9f674 1200 if ((hadc->State != HAL_ADC_STATE_ERROR) && (tmpHALStatus != HAL_ERROR))
mbed_official 376:cb4d9db17537 1201 {
mbed_official 376:cb4d9db17537 1202 /* Change ADC state */
mbed_official 376:cb4d9db17537 1203 hadc->State = HAL_ADC_STATE_READY;
mbed_official 376:cb4d9db17537 1204 }
mbed_official 376:cb4d9db17537 1205 else
mbed_official 376:cb4d9db17537 1206 {
mbed_official 376:cb4d9db17537 1207 return HAL_ERROR;
mbed_official 376:cb4d9db17537 1208 }
mbed_official 376:cb4d9db17537 1209 }
mbed_official 376:cb4d9db17537 1210 else
mbed_official 376:cb4d9db17537 1211 {
mbed_official 376:cb4d9db17537 1212 return HAL_ERROR;
mbed_official 376:cb4d9db17537 1213 }
mbed_official 376:cb4d9db17537 1214
mbed_official 376:cb4d9db17537 1215 /* Process unlocked */
mbed_official 376:cb4d9db17537 1216 __HAL_UNLOCK(hadc);
mbed_official 376:cb4d9db17537 1217
mbed_official 376:cb4d9db17537 1218 /* Return function status */
mbed_official 376:cb4d9db17537 1219 return HAL_OK;
mbed_official 376:cb4d9db17537 1220 }
mbed_official 376:cb4d9db17537 1221
mbed_official 376:cb4d9db17537 1222 /**
mbed_official 376:cb4d9db17537 1223 * @brief Gets the converted value from data register of regular channel.
mbed_official 376:cb4d9db17537 1224 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1225 * the configuration information for the specified ADC.
mbed_official 376:cb4d9db17537 1226 * @retval Converted value
mbed_official 376:cb4d9db17537 1227 */
mbed_official 376:cb4d9db17537 1228 uint32_t HAL_ADC_GetValue(ADC_HandleTypeDef* hadc)
mbed_official 376:cb4d9db17537 1229 {
mbed_official 376:cb4d9db17537 1230 /* Return the selected ADC converted value */
mbed_official 376:cb4d9db17537 1231 return hadc->Instance->DR;
mbed_official 376:cb4d9db17537 1232 }
mbed_official 376:cb4d9db17537 1233
mbed_official 376:cb4d9db17537 1234 /**
mbed_official 376:cb4d9db17537 1235 * @brief Regular conversion complete callback in non blocking mode
mbed_official 376:cb4d9db17537 1236 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1237 * the configuration information for the specified ADC.
mbed_official 376:cb4d9db17537 1238 * @retval None
mbed_official 376:cb4d9db17537 1239 */
mbed_official 376:cb4d9db17537 1240 __weak void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc)
mbed_official 376:cb4d9db17537 1241 {
mbed_official 376:cb4d9db17537 1242 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 376:cb4d9db17537 1243 the HAL_ADC_ConvCpltCallback could be implemented in the user file
mbed_official 376:cb4d9db17537 1244 */
mbed_official 376:cb4d9db17537 1245 }
mbed_official 376:cb4d9db17537 1246
mbed_official 376:cb4d9db17537 1247 /**
mbed_official 376:cb4d9db17537 1248 * @brief Regular conversion half DMA transfer callback in non blocking mode
mbed_official 376:cb4d9db17537 1249 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1250 * the configuration information for the specified ADC.
mbed_official 376:cb4d9db17537 1251 * @retval None
mbed_official 376:cb4d9db17537 1252 */
mbed_official 376:cb4d9db17537 1253 __weak void HAL_ADC_ConvHalfCpltCallback(ADC_HandleTypeDef* hadc)
mbed_official 376:cb4d9db17537 1254 {
mbed_official 376:cb4d9db17537 1255 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 376:cb4d9db17537 1256 the HAL_ADC_ConvHalfCpltCallback could be implemented in the user file
mbed_official 376:cb4d9db17537 1257 */
mbed_official 376:cb4d9db17537 1258 }
mbed_official 376:cb4d9db17537 1259
mbed_official 376:cb4d9db17537 1260 /**
mbed_official 376:cb4d9db17537 1261 * @brief Analog watchdog callback in non blocking mode
mbed_official 376:cb4d9db17537 1262 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1263 * the configuration information for the specified ADC.
mbed_official 376:cb4d9db17537 1264 * @retval None
mbed_official 376:cb4d9db17537 1265 */
mbed_official 376:cb4d9db17537 1266 __weak void HAL_ADC_LevelOutOfWindowCallback(ADC_HandleTypeDef* hadc)
mbed_official 376:cb4d9db17537 1267 {
mbed_official 376:cb4d9db17537 1268 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 376:cb4d9db17537 1269 the HAL_ADC_LevelOoutOfWindowCallback could be implemented in the user file
mbed_official 376:cb4d9db17537 1270 */
mbed_official 376:cb4d9db17537 1271 }
mbed_official 376:cb4d9db17537 1272
mbed_official 376:cb4d9db17537 1273 /**
mbed_official 376:cb4d9db17537 1274 * @brief Error ADC callback.
mbed_official 376:cb4d9db17537 1275 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1276 * the configuration information for the specified ADC.
mbed_official 376:cb4d9db17537 1277 * @retval None
mbed_official 376:cb4d9db17537 1278 */
mbed_official 376:cb4d9db17537 1279 __weak void HAL_ADC_ErrorCallback(ADC_HandleTypeDef *hadc)
mbed_official 376:cb4d9db17537 1280 {
mbed_official 376:cb4d9db17537 1281 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 376:cb4d9db17537 1282 the HAL_ADC_ErrorCallback could be implemented in the user file
mbed_official 376:cb4d9db17537 1283 */
mbed_official 376:cb4d9db17537 1284 }
mbed_official 376:cb4d9db17537 1285
mbed_official 376:cb4d9db17537 1286 /**
mbed_official 376:cb4d9db17537 1287 * @}
mbed_official 376:cb4d9db17537 1288 */
mbed_official 376:cb4d9db17537 1289
mbed_official 376:cb4d9db17537 1290 /** @defgroup ADC_Group3 Peripheral Control functions
mbed_official 376:cb4d9db17537 1291 * @brief Peripheral Control functions
mbed_official 376:cb4d9db17537 1292 *
mbed_official 376:cb4d9db17537 1293 @verbatim
mbed_official 376:cb4d9db17537 1294 ===============================================================================
mbed_official 376:cb4d9db17537 1295 ##### Peripheral Control functions #####
mbed_official 376:cb4d9db17537 1296 ===============================================================================
mbed_official 376:cb4d9db17537 1297 [..] This section provides functions allowing to:
mbed_official 376:cb4d9db17537 1298 (+) Configure channels.
mbed_official 376:cb4d9db17537 1299 (+) Configure the analog watch dog.
mbed_official 376:cb4d9db17537 1300
mbed_official 376:cb4d9db17537 1301 @endverbatim
mbed_official 376:cb4d9db17537 1302 * @{
mbed_official 376:cb4d9db17537 1303 */
mbed_official 376:cb4d9db17537 1304
mbed_official 376:cb4d9db17537 1305
mbed_official 376:cb4d9db17537 1306 /**
mbed_official 376:cb4d9db17537 1307 * @brief Configures the selected ADC regular channel: sampling time,
mbed_official 376:cb4d9db17537 1308 * offset,.
mbed_official 376:cb4d9db17537 1309 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1310 * the configuration information for the specified ADC.
mbed_official 376:cb4d9db17537 1311 * @param sConfig: ADC regular channel configuration structure.
mbed_official 376:cb4d9db17537 1312 * @retval HAL status
mbed_official 376:cb4d9db17537 1313 */
mbed_official 376:cb4d9db17537 1314 HAL_StatusTypeDef HAL_ADC_ConfigChannel(ADC_HandleTypeDef* hadc, ADC_ChannelConfTypeDef* sConfig)
mbed_official 376:cb4d9db17537 1315 {
mbed_official 376:cb4d9db17537 1316 /* Check the parameters */
mbed_official 376:cb4d9db17537 1317 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 376:cb4d9db17537 1318 assert_param(IS_ADC_CHANNEL(sConfig->Channel));
mbed_official 376:cb4d9db17537 1319
mbed_official 376:cb4d9db17537 1320 /* Process locked */
mbed_official 376:cb4d9db17537 1321 __HAL_LOCK(hadc);
mbed_official 376:cb4d9db17537 1322
mbed_official 489:119543c9f674 1323 /* Parameters update conditioned to ADC state: */
mbed_official 489:119543c9f674 1324 /* Parameters that can be updated when ADC is disabled or enabled without */
mbed_official 489:119543c9f674 1325 /* conversion on going : */
mbed_official 489:119543c9f674 1326 /* - Channel number */
mbed_official 489:119543c9f674 1327 /* - Management of internal measurement channels: Vbat/VrefInt/TempSensor */
mbed_official 489:119543c9f674 1328 if (ADC_IS_CONVERSION_ONGOING(hadc) != RESET)
mbed_official 489:119543c9f674 1329 {
mbed_official 489:119543c9f674 1330 /* Update ADC state machine to error */
mbed_official 489:119543c9f674 1331 hadc->State = HAL_ADC_STATE_ERROR;
mbed_official 489:119543c9f674 1332 /* Process unlocked */
mbed_official 489:119543c9f674 1333 __HAL_UNLOCK(hadc);
mbed_official 489:119543c9f674 1334 return HAL_ERROR;
mbed_official 489:119543c9f674 1335 }
mbed_official 489:119543c9f674 1336
mbed_official 376:cb4d9db17537 1337 /* Enable selected channels */
mbed_official 376:cb4d9db17537 1338 hadc->Instance->CHSELR |= (uint32_t)(sConfig->Channel & ADC_CHANNEL_MASK);
mbed_official 376:cb4d9db17537 1339
mbed_official 376:cb4d9db17537 1340 /* Management of internal measurement channels: Vlcd/VrefInt/TempSensor */
mbed_official 376:cb4d9db17537 1341 /* internal measurement paths enable: If internal channel selected, enable */
mbed_official 376:cb4d9db17537 1342 /* dedicated internal buffers and path. */
mbed_official 376:cb4d9db17537 1343
mbed_official 376:cb4d9db17537 1344 /* If Temperature sensor channel is selected, then enable the internal */
mbed_official 376:cb4d9db17537 1345 /* buffers and path */
mbed_official 376:cb4d9db17537 1346 if (((sConfig->Channel & ADC_CHANNEL_MASK) & ADC_CHANNEL_TEMPSENSOR ) == (ADC_CHANNEL_TEMPSENSOR & ADC_CHANNEL_MASK))
mbed_official 376:cb4d9db17537 1347 {
mbed_official 376:cb4d9db17537 1348 ADC->CCR |= ADC_CCR_TSEN;
mbed_official 489:119543c9f674 1349
mbed_official 489:119543c9f674 1350 /* Delay for temperature sensor stabilization time */
mbed_official 489:119543c9f674 1351 ADC_DelayMicroSecond(ADC_TEMPSENSOR_DELAY_US);
mbed_official 376:cb4d9db17537 1352 }
mbed_official 376:cb4d9db17537 1353
mbed_official 376:cb4d9db17537 1354 /* If VRefInt channel is selected, then enable the internal buffers and path */
mbed_official 376:cb4d9db17537 1355 if (((sConfig->Channel & ADC_CHANNEL_MASK) & ADC_CHANNEL_VREFINT) == (ADC_CHANNEL_VREFINT & ADC_CHANNEL_MASK))
mbed_official 376:cb4d9db17537 1356 {
mbed_official 376:cb4d9db17537 1357 ADC->CCR |= ADC_CCR_VREFEN;
mbed_official 376:cb4d9db17537 1358 }
mbed_official 376:cb4d9db17537 1359
mbed_official 376:cb4d9db17537 1360 /* If Vlcd channel is selected, then enable the internal buffers and path */
mbed_official 376:cb4d9db17537 1361 if (((sConfig->Channel & ADC_CHANNEL_MASK) & ADC_CHANNEL_VLCD) == (ADC_CHANNEL_VLCD & ADC_CHANNEL_MASK))
mbed_official 376:cb4d9db17537 1362 {
mbed_official 376:cb4d9db17537 1363 ADC->CCR |= ADC_CCR_VLCDEN;
mbed_official 376:cb4d9db17537 1364 }
mbed_official 376:cb4d9db17537 1365
mbed_official 376:cb4d9db17537 1366 /* Process unlocked */
mbed_official 376:cb4d9db17537 1367 __HAL_UNLOCK(hadc);
mbed_official 376:cb4d9db17537 1368
mbed_official 376:cb4d9db17537 1369 /* Return function status */
mbed_official 376:cb4d9db17537 1370 return HAL_OK;
mbed_official 376:cb4d9db17537 1371 }
mbed_official 376:cb4d9db17537 1372
mbed_official 376:cb4d9db17537 1373 /**
mbed_official 376:cb4d9db17537 1374 * @brief Configures the analog watchdog.
mbed_official 376:cb4d9db17537 1375 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1376 * the configuration information for the specified ADC.
mbed_official 376:cb4d9db17537 1377 * @param AnalogWDGConfig : pointer to an ADC_AnalogWDGConfTypeDef structure
mbed_official 376:cb4d9db17537 1378 * that contains the configuration information of ADC analog watchdog.
mbed_official 376:cb4d9db17537 1379 * @retval HAL status
mbed_official 376:cb4d9db17537 1380 */
mbed_official 376:cb4d9db17537 1381 HAL_StatusTypeDef HAL_ADC_AnalogWDGConfig(ADC_HandleTypeDef* hadc, ADC_AnalogWDGConfTypeDef* AnalogWDGConfig)
mbed_official 376:cb4d9db17537 1382 {
mbed_official 376:cb4d9db17537 1383 uint32_t tmpAWDHighThresholdShifted;
mbed_official 376:cb4d9db17537 1384 uint32_t tmpAWDLowThresholdShifted;
mbed_official 376:cb4d9db17537 1385
mbed_official 376:cb4d9db17537 1386 /* Check the parameters */
mbed_official 376:cb4d9db17537 1387 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 376:cb4d9db17537 1388 assert_param(IS_ADC_ANALOG_WATCHDOG_MODE(AnalogWDGConfig->WatchdogMode));
mbed_official 376:cb4d9db17537 1389 assert_param(IS_ADC_CHANNEL(AnalogWDGConfig->Channel));
mbed_official 376:cb4d9db17537 1390 assert_param(IS_FUNCTIONAL_STATE(AnalogWDGConfig->ITMode));
mbed_official 376:cb4d9db17537 1391
mbed_official 489:119543c9f674 1392 assert_param(IS_ADC_RANGE(ADC_GET_RESOLUTION(hadc), AnalogWDGConfig->HighThreshold));
mbed_official 489:119543c9f674 1393 assert_param(IS_ADC_RANGE(ADC_GET_RESOLUTION(hadc), AnalogWDGConfig->LowThreshold));
mbed_official 376:cb4d9db17537 1394
mbed_official 376:cb4d9db17537 1395 /* Process locked */
mbed_official 376:cb4d9db17537 1396 __HAL_LOCK(hadc);
mbed_official 376:cb4d9db17537 1397
mbed_official 489:119543c9f674 1398 /* Parameters update conditioned to ADC state: */
mbed_official 489:119543c9f674 1399 /* Parameters that can be updated when ADC is disabled or enabled without */
mbed_official 489:119543c9f674 1400 /* conversion on going : */
mbed_official 489:119543c9f674 1401 /* - Analog watchdog channels */
mbed_official 489:119543c9f674 1402 /* - Analog watchdog thresholds */
mbed_official 489:119543c9f674 1403 if (ADC_IS_CONVERSION_ONGOING(hadc) != RESET)
mbed_official 489:119543c9f674 1404 {
mbed_official 489:119543c9f674 1405 /* Update ADC state machine to error */
mbed_official 489:119543c9f674 1406 hadc->State = HAL_ADC_STATE_ERROR;
mbed_official 489:119543c9f674 1407 /* Process unlocked */
mbed_official 489:119543c9f674 1408 __HAL_UNLOCK(hadc);
mbed_official 489:119543c9f674 1409 return HAL_ERROR;
mbed_official 489:119543c9f674 1410 }
mbed_official 489:119543c9f674 1411
mbed_official 376:cb4d9db17537 1412 /* Configure ADC Analog watchdog interrupt */
mbed_official 376:cb4d9db17537 1413 if(AnalogWDGConfig->ITMode == ENABLE)
mbed_official 376:cb4d9db17537 1414 {
mbed_official 376:cb4d9db17537 1415 /* Enable the ADC Analog watchdog interrupt */
mbed_official 376:cb4d9db17537 1416 __HAL_ADC_ENABLE_IT(hadc, ADC_IT_AWD);
mbed_official 376:cb4d9db17537 1417 }
mbed_official 376:cb4d9db17537 1418 else
mbed_official 376:cb4d9db17537 1419 {
mbed_official 376:cb4d9db17537 1420 /* Disable the ADC Analog watchdog interrupt */
mbed_official 376:cb4d9db17537 1421 __HAL_ADC_DISABLE_IT(hadc, ADC_IT_AWD);
mbed_official 376:cb4d9db17537 1422 }
mbed_official 376:cb4d9db17537 1423
mbed_official 376:cb4d9db17537 1424 /* Configuration of analog watchdog: */
mbed_official 376:cb4d9db17537 1425 /* - Set the analog watchdog mode */
mbed_official 376:cb4d9db17537 1426 /* - Set the Analog watchdog channel (is not used if watchdog */
mbed_official 376:cb4d9db17537 1427 /* mode "all channels": ADC_CFGR1_AWD1SGL=0) */
mbed_official 376:cb4d9db17537 1428 hadc->Instance->CFGR1 &= ~( ADC_CFGR1_AWDSGL |
mbed_official 376:cb4d9db17537 1429 ADC_CFGR1_AWDEN |
mbed_official 489:119543c9f674 1430 ADC_CFGR1_AWDCH);
mbed_official 376:cb4d9db17537 1431
mbed_official 376:cb4d9db17537 1432 hadc->Instance->CFGR1 |= ( AnalogWDGConfig->WatchdogMode |
mbed_official 376:cb4d9db17537 1433 (AnalogWDGConfig->Channel & ADC_CHANNEL_AWD_MASK));
mbed_official 376:cb4d9db17537 1434
mbed_official 376:cb4d9db17537 1435
mbed_official 376:cb4d9db17537 1436 /* Shift the offset in function of the selected ADC resolution: Thresholds */
mbed_official 376:cb4d9db17537 1437 /* have to be left-aligned on bit 11, the LSB (right bits) are set to 0 */
mbed_official 489:119543c9f674 1438 tmpAWDHighThresholdShifted = ADC_AWD1THRESHOLD_SHIFT_RESOLUTION(hadc, AnalogWDGConfig->HighThreshold);
mbed_official 489:119543c9f674 1439 tmpAWDLowThresholdShifted = ADC_AWD1THRESHOLD_SHIFT_RESOLUTION(hadc, AnalogWDGConfig->LowThreshold);
mbed_official 376:cb4d9db17537 1440
mbed_official 376:cb4d9db17537 1441 /* Clear High & Low high thresholds */
mbed_official 376:cb4d9db17537 1442 hadc->Instance->TR &= (uint32_t) ~ (ADC_TR_HT | ADC_TR_LT);
mbed_official 376:cb4d9db17537 1443
mbed_official 376:cb4d9db17537 1444 /* Set the high threshold */
mbed_official 489:119543c9f674 1445 hadc->Instance->TR = ADC_TRX_HIGHTHRESHOLD (tmpAWDHighThresholdShifted);
mbed_official 376:cb4d9db17537 1446 /* Set the low threshold */
mbed_official 376:cb4d9db17537 1447 hadc->Instance->TR |= tmpAWDLowThresholdShifted;
mbed_official 376:cb4d9db17537 1448
mbed_official 376:cb4d9db17537 1449 /* Process unlocked */
mbed_official 376:cb4d9db17537 1450 __HAL_UNLOCK(hadc);
mbed_official 376:cb4d9db17537 1451
mbed_official 376:cb4d9db17537 1452 /* Return function status */
mbed_official 376:cb4d9db17537 1453 return HAL_OK;
mbed_official 376:cb4d9db17537 1454 }
mbed_official 376:cb4d9db17537 1455
mbed_official 376:cb4d9db17537 1456 /**
mbed_official 376:cb4d9db17537 1457 * @}
mbed_official 376:cb4d9db17537 1458 */
mbed_official 376:cb4d9db17537 1459
mbed_official 376:cb4d9db17537 1460 /** @defgroup ADC_Group4 ADC Peripheral State functions
mbed_official 376:cb4d9db17537 1461 * @brief ADC Peripheral State functions
mbed_official 376:cb4d9db17537 1462 *
mbed_official 376:cb4d9db17537 1463 @verbatim
mbed_official 376:cb4d9db17537 1464 ===============================================================================
mbed_official 376:cb4d9db17537 1465 ##### ADC Peripheral State functions #####
mbed_official 376:cb4d9db17537 1466 ===============================================================================
mbed_official 376:cb4d9db17537 1467 [..]
mbed_official 376:cb4d9db17537 1468 This subsection provides functions allowing to
mbed_official 376:cb4d9db17537 1469 (+) Check the ADC state.
mbed_official 376:cb4d9db17537 1470 (+) handle ADC interrupt request.
mbed_official 376:cb4d9db17537 1471
mbed_official 376:cb4d9db17537 1472 @endverbatim
mbed_official 376:cb4d9db17537 1473 * @{
mbed_official 376:cb4d9db17537 1474 */
mbed_official 376:cb4d9db17537 1475
mbed_official 376:cb4d9db17537 1476 /**
mbed_official 376:cb4d9db17537 1477 * @brief return the ADC state
mbed_official 376:cb4d9db17537 1478 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1479 * the configuration information for the specified ADC.
mbed_official 376:cb4d9db17537 1480 * @retval HAL state
mbed_official 376:cb4d9db17537 1481 */
mbed_official 376:cb4d9db17537 1482 HAL_ADC_StateTypeDef HAL_ADC_GetState(ADC_HandleTypeDef* hadc)
mbed_official 376:cb4d9db17537 1483 {
mbed_official 376:cb4d9db17537 1484 /* Return ADC state */
mbed_official 376:cb4d9db17537 1485 return hadc->State;
mbed_official 376:cb4d9db17537 1486 }
mbed_official 376:cb4d9db17537 1487
mbed_official 376:cb4d9db17537 1488 /**
mbed_official 376:cb4d9db17537 1489 * @brief Return the ADC error code
mbed_official 376:cb4d9db17537 1490 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1491 * the configuration information for the specified ADC.
mbed_official 376:cb4d9db17537 1492 * @retval ADC Error Code
mbed_official 376:cb4d9db17537 1493 */
mbed_official 376:cb4d9db17537 1494 uint32_t HAL_ADC_GetError(ADC_HandleTypeDef *hadc)
mbed_official 376:cb4d9db17537 1495 {
mbed_official 376:cb4d9db17537 1496 return hadc->ErrorCode;
mbed_official 376:cb4d9db17537 1497 }
mbed_official 376:cb4d9db17537 1498
mbed_official 376:cb4d9db17537 1499
mbed_official 376:cb4d9db17537 1500 /**
mbed_official 376:cb4d9db17537 1501 * @}
mbed_official 376:cb4d9db17537 1502 */
mbed_official 376:cb4d9db17537 1503
mbed_official 376:cb4d9db17537 1504 /**
mbed_official 376:cb4d9db17537 1505 * @brief Enable the selected ADC.
mbed_official 376:cb4d9db17537 1506 * @note Prerequisite condition to use this function: ADC must be disabled
mbed_official 376:cb4d9db17537 1507 * and voltage regulator must be enabled (done into HAL_ADC_Init()).
mbed_official 489:119543c9f674 1508 * @note If low power mode AutoPowerOff is enabled, power-on/off phases are
mbed_official 489:119543c9f674 1509 * performed automatically by hardware.
mbed_official 489:119543c9f674 1510 * In this mode, this function is useless and must not be called because
mbed_official 489:119543c9f674 1511 * flag ADC_FLAG_RDY is not usable.
mbed_official 489:119543c9f674 1512 * Therefore, this function must be called under condition of
mbed_official 489:119543c9f674 1513 * "if (hadc->Init.LowPowerAutoPowerOff != ENABLE)".
mbed_official 376:cb4d9db17537 1514 * @param hadc: ADC handle
mbed_official 376:cb4d9db17537 1515 * @retval HAL status.
mbed_official 376:cb4d9db17537 1516 */
mbed_official 376:cb4d9db17537 1517 static HAL_StatusTypeDef ADC_Enable(ADC_HandleTypeDef* hadc)
mbed_official 376:cb4d9db17537 1518 {
mbed_official 376:cb4d9db17537 1519 uint32_t tickstart = 0;
mbed_official 489:119543c9f674 1520
mbed_official 376:cb4d9db17537 1521 /* ADC enable and wait for ADC ready (in case of ADC is disabled or */
mbed_official 376:cb4d9db17537 1522 /* enabling phase not yet completed: flag ADC ready not yet set). */
mbed_official 376:cb4d9db17537 1523 /* Timeout implemented to not be stuck if ADC cannot be enabled (possible */
mbed_official 376:cb4d9db17537 1524 /* causes: ADC clock not running, ...). */
mbed_official 489:119543c9f674 1525 if (ADC_IS_ENABLE(hadc) == RESET)
mbed_official 376:cb4d9db17537 1526 {
mbed_official 376:cb4d9db17537 1527 /* Check if conditions to enable the ADC are fulfilled */
mbed_official 489:119543c9f674 1528 if (ADC_ENABLING_CONDITIONS(hadc) == RESET)
mbed_official 376:cb4d9db17537 1529 {
mbed_official 376:cb4d9db17537 1530 /* Update ADC state machine to error */
mbed_official 376:cb4d9db17537 1531 hadc->State = HAL_ADC_STATE_ERROR;
mbed_official 376:cb4d9db17537 1532
mbed_official 376:cb4d9db17537 1533 /* Set ADC error code to ADC IP internal error */
mbed_official 376:cb4d9db17537 1534 hadc->ErrorCode |= HAL_ADC_ERROR_INTERNAL;
mbed_official 376:cb4d9db17537 1535
mbed_official 376:cb4d9db17537 1536 return HAL_ERROR;
mbed_official 376:cb4d9db17537 1537 }
mbed_official 376:cb4d9db17537 1538
mbed_official 376:cb4d9db17537 1539 /* Enable the ADC peripheral */
mbed_official 376:cb4d9db17537 1540 __HAL_ADC_ENABLE(hadc);
mbed_official 376:cb4d9db17537 1541
mbed_official 489:119543c9f674 1542 /* Delay for ADC stabilization time. */
mbed_official 489:119543c9f674 1543 ADC_DelayMicroSecond(ADC_STAB_DELAY_US);
mbed_official 489:119543c9f674 1544
mbed_official 376:cb4d9db17537 1545 /* Wait for ADC effectively enabled */
mbed_official 376:cb4d9db17537 1546 /* Get timeout */
mbed_official 376:cb4d9db17537 1547 tickstart = HAL_GetTick();
mbed_official 376:cb4d9db17537 1548
mbed_official 376:cb4d9db17537 1549 /* Skip polling for RDY ADRDY when AutoOFF is enabled */
mbed_official 489:119543c9f674 1550 if (hadc->Init.LowPowerAutoPowerOff != ENABLE)
mbed_official 376:cb4d9db17537 1551 {
mbed_official 376:cb4d9db17537 1552 while(__HAL_ADC_GET_FLAG(hadc, ADC_FLAG_RDY) == RESET)
mbed_official 376:cb4d9db17537 1553 {
mbed_official 376:cb4d9db17537 1554 /* Check for the Timeout */
mbed_official 376:cb4d9db17537 1555 if(ADC_ENABLE_TIMEOUT != HAL_MAX_DELAY)
mbed_official 376:cb4d9db17537 1556 {
mbed_official 376:cb4d9db17537 1557 if((HAL_GetTick() - tickstart ) > ADC_ENABLE_TIMEOUT)
mbed_official 376:cb4d9db17537 1558 {
mbed_official 376:cb4d9db17537 1559 /* Update ADC state machine to error */
mbed_official 376:cb4d9db17537 1560 hadc->State = HAL_ADC_STATE_ERROR;
mbed_official 376:cb4d9db17537 1561
mbed_official 376:cb4d9db17537 1562 /* Set ADC error code to ADC IP internal error */
mbed_official 376:cb4d9db17537 1563 hadc->ErrorCode |= HAL_ADC_ERROR_INTERNAL;
mbed_official 376:cb4d9db17537 1564
mbed_official 376:cb4d9db17537 1565 return HAL_ERROR;
mbed_official 376:cb4d9db17537 1566 }
mbed_official 376:cb4d9db17537 1567 }
mbed_official 376:cb4d9db17537 1568 }
mbed_official 376:cb4d9db17537 1569 }
mbed_official 376:cb4d9db17537 1570 }
mbed_official 376:cb4d9db17537 1571
mbed_official 376:cb4d9db17537 1572 /* Return HAL status */
mbed_official 376:cb4d9db17537 1573 return HAL_OK;
mbed_official 376:cb4d9db17537 1574 }
mbed_official 376:cb4d9db17537 1575
mbed_official 376:cb4d9db17537 1576 /**
mbed_official 376:cb4d9db17537 1577 * @brief Disable the selected ADC.
mbed_official 376:cb4d9db17537 1578 * @note Prerequisite condition to use this function: ADC conversions must be
mbed_official 376:cb4d9db17537 1579 * stopped to disable the ADC.
mbed_official 376:cb4d9db17537 1580 * @param hadc: ADC handle
mbed_official 376:cb4d9db17537 1581 * @retval HAL status.
mbed_official 376:cb4d9db17537 1582 */
mbed_official 376:cb4d9db17537 1583 static HAL_StatusTypeDef ADC_Disable(ADC_HandleTypeDef* hadc)
mbed_official 376:cb4d9db17537 1584 {
mbed_official 376:cb4d9db17537 1585 uint32_t tickstart = 0;
mbed_official 376:cb4d9db17537 1586
mbed_official 376:cb4d9db17537 1587 /* Verification if ADC is not already disabled: */
mbed_official 376:cb4d9db17537 1588 /* forbidden to disable ADC (set bit ADC_CR_ADDIS) if ADC is already */
mbed_official 376:cb4d9db17537 1589 /* disabled. */
mbed_official 489:119543c9f674 1590 if (ADC_IS_ENABLE(hadc) != RESET )
mbed_official 376:cb4d9db17537 1591 {
mbed_official 376:cb4d9db17537 1592 /* Check if conditions to disable the ADC are fulfilled */
mbed_official 489:119543c9f674 1593 if (ADC_DISABLING_CONDITIONS(hadc) != RESET)
mbed_official 376:cb4d9db17537 1594 {
mbed_official 376:cb4d9db17537 1595 /* Disable the ADC peripheral */
mbed_official 376:cb4d9db17537 1596 __HAL_ADC_DISABLE(hadc);
mbed_official 376:cb4d9db17537 1597 }
mbed_official 376:cb4d9db17537 1598 else
mbed_official 376:cb4d9db17537 1599 {
mbed_official 376:cb4d9db17537 1600 /* Update ADC state machine to error */
mbed_official 376:cb4d9db17537 1601 hadc->State = HAL_ADC_STATE_ERROR;
mbed_official 376:cb4d9db17537 1602
mbed_official 376:cb4d9db17537 1603 /* Set ADC error code to ADC internal error */
mbed_official 376:cb4d9db17537 1604 hadc->ErrorCode |= HAL_ADC_ERROR_INTERNAL;
mbed_official 376:cb4d9db17537 1605
mbed_official 376:cb4d9db17537 1606 return HAL_ERROR;
mbed_official 376:cb4d9db17537 1607 }
mbed_official 376:cb4d9db17537 1608
mbed_official 376:cb4d9db17537 1609 /* Wait for ADC effectively disabled */
mbed_official 376:cb4d9db17537 1610 /* Get timeout */
mbed_official 376:cb4d9db17537 1611 tickstart = HAL_GetTick();
mbed_official 376:cb4d9db17537 1612
mbed_official 376:cb4d9db17537 1613 while(HAL_IS_BIT_SET(hadc->Instance->CR, ADC_CR_ADEN))
mbed_official 376:cb4d9db17537 1614 {
mbed_official 376:cb4d9db17537 1615 /* Check for the Timeout */
mbed_official 376:cb4d9db17537 1616 if(ADC_ENABLE_TIMEOUT != HAL_MAX_DELAY)
mbed_official 376:cb4d9db17537 1617 {
mbed_official 376:cb4d9db17537 1618 if((HAL_GetTick() - tickstart ) > ADC_DISABLE_TIMEOUT)
mbed_official 376:cb4d9db17537 1619 {
mbed_official 376:cb4d9db17537 1620 /* Update ADC state machine to error */
mbed_official 376:cb4d9db17537 1621 hadc->State = HAL_ADC_STATE_ERROR;
mbed_official 376:cb4d9db17537 1622
mbed_official 376:cb4d9db17537 1623 /* Set ADC error code to ADC internal error */
mbed_official 376:cb4d9db17537 1624 hadc->ErrorCode |= HAL_ADC_ERROR_INTERNAL;
mbed_official 376:cb4d9db17537 1625
mbed_official 376:cb4d9db17537 1626 return HAL_ERROR;
mbed_official 376:cb4d9db17537 1627 }
mbed_official 376:cb4d9db17537 1628 }
mbed_official 376:cb4d9db17537 1629 }
mbed_official 376:cb4d9db17537 1630 }
mbed_official 376:cb4d9db17537 1631
mbed_official 376:cb4d9db17537 1632 /* Return HAL status */
mbed_official 376:cb4d9db17537 1633 return HAL_OK;
mbed_official 376:cb4d9db17537 1634 }
mbed_official 376:cb4d9db17537 1635
mbed_official 376:cb4d9db17537 1636 /**
mbed_official 376:cb4d9db17537 1637 * @brief Stop ADC conversion.
mbed_official 376:cb4d9db17537 1638 * @note Prerequisite condition to use this function: ADC conversions must be
mbed_official 376:cb4d9db17537 1639 * stopped to disable the ADC.
mbed_official 376:cb4d9db17537 1640 * @param hadc: ADC handle
mbed_official 376:cb4d9db17537 1641 * @param ConversionGroup: Only ADC group regular.
mbed_official 376:cb4d9db17537 1642 * This parameter can be one of the following values:
mbed_official 489:119543c9f674 1643 * @arg ADC_REGULAR_GROUP: ADC regular conversion type.
mbed_official 376:cb4d9db17537 1644 * @retval HAL status.
mbed_official 376:cb4d9db17537 1645 */
mbed_official 376:cb4d9db17537 1646 static HAL_StatusTypeDef ADC_ConversionStop(ADC_HandleTypeDef* hadc, uint32_t ConversionGroup)
mbed_official 376:cb4d9db17537 1647 {
mbed_official 376:cb4d9db17537 1648 uint32_t tickstart = 0 ;
mbed_official 376:cb4d9db17537 1649
mbed_official 376:cb4d9db17537 1650 /* Check the parameters */
mbed_official 376:cb4d9db17537 1651 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 376:cb4d9db17537 1652 assert_param(IS_ADC_CONVERSION_GROUP(ConversionGroup));
mbed_official 489:119543c9f674 1653
mbed_official 489:119543c9f674 1654 /* Parameters update conditioned to ADC state: */
mbed_official 489:119543c9f674 1655 /* Parameters that can be updated when ADC is disabled or enabled without */
mbed_official 489:119543c9f674 1656 /* conversion on going : */
mbed_official 489:119543c9f674 1657 if (ADC_IS_CONVERSION_ONGOING(hadc) != RESET)
mbed_official 489:119543c9f674 1658 {
mbed_official 489:119543c9f674 1659 /* Update ADC state machine to error */
mbed_official 489:119543c9f674 1660 hadc->State = HAL_ADC_STATE_ERROR;
mbed_official 489:119543c9f674 1661 /* Process unlocked */
mbed_official 489:119543c9f674 1662 return HAL_ERROR;
mbed_official 489:119543c9f674 1663 }
mbed_official 489:119543c9f674 1664
mbed_official 376:cb4d9db17537 1665 /* Verification: if ADC is not already stopped, bypass this function */
mbed_official 376:cb4d9db17537 1666 if (HAL_IS_BIT_SET(hadc->Instance->CR, ADC_CR_ADSTART))
mbed_official 376:cb4d9db17537 1667 {
mbed_official 376:cb4d9db17537 1668 /* Stop potential conversion on regular group */
mbed_official 489:119543c9f674 1669 if (ConversionGroup == ADC_REGULAR_GROUP)
mbed_official 376:cb4d9db17537 1670 {
mbed_official 376:cb4d9db17537 1671 /* Software is allowed to set ADSTP only when ADSTART=1 and ADDIS=0 */
mbed_official 376:cb4d9db17537 1672 if (HAL_IS_BIT_SET(hadc->Instance->CR, ADC_CR_ADSTART) && \
mbed_official 376:cb4d9db17537 1673 HAL_IS_BIT_CLR(hadc->Instance->CR, ADC_CR_ADDIS) )
mbed_official 376:cb4d9db17537 1674 {
mbed_official 376:cb4d9db17537 1675 /* Stop conversions on regular group */
mbed_official 376:cb4d9db17537 1676 hadc->Instance->CR |= ADC_CR_ADSTP;
mbed_official 376:cb4d9db17537 1677 }
mbed_official 376:cb4d9db17537 1678 }
mbed_official 376:cb4d9db17537 1679
mbed_official 376:cb4d9db17537 1680 /* Wait for conversion effectively stopped */
mbed_official 376:cb4d9db17537 1681 /* Get timeout */
mbed_official 376:cb4d9db17537 1682 tickstart = HAL_GetTick();
mbed_official 376:cb4d9db17537 1683
mbed_official 376:cb4d9db17537 1684 while((hadc->Instance->CR & ADC_CR_ADSTART) != RESET)
mbed_official 376:cb4d9db17537 1685 {
mbed_official 376:cb4d9db17537 1686 /* Check for the Timeout */
mbed_official 376:cb4d9db17537 1687 if(ADC_STOP_CONVERSION_TIMEOUT != HAL_MAX_DELAY)
mbed_official 376:cb4d9db17537 1688 {
mbed_official 376:cb4d9db17537 1689 if((HAL_GetTick() - tickstart ) > ADC_STOP_CONVERSION_TIMEOUT)
mbed_official 376:cb4d9db17537 1690 {
mbed_official 376:cb4d9db17537 1691 /* Update ADC state machine to error */
mbed_official 376:cb4d9db17537 1692 hadc->State = HAL_ADC_STATE_ERROR;
mbed_official 376:cb4d9db17537 1693
mbed_official 376:cb4d9db17537 1694 /* Set ADC error code to ADC IP internal error */
mbed_official 376:cb4d9db17537 1695 hadc->ErrorCode |= HAL_ADC_ERROR_INTERNAL;
mbed_official 376:cb4d9db17537 1696
mbed_official 376:cb4d9db17537 1697 return HAL_ERROR;
mbed_official 376:cb4d9db17537 1698 }
mbed_official 376:cb4d9db17537 1699 }
mbed_official 376:cb4d9db17537 1700 }
mbed_official 376:cb4d9db17537 1701 }
mbed_official 376:cb4d9db17537 1702
mbed_official 376:cb4d9db17537 1703 /* Return HAL status */
mbed_official 376:cb4d9db17537 1704 return HAL_OK;
mbed_official 376:cb4d9db17537 1705 }
mbed_official 376:cb4d9db17537 1706
mbed_official 376:cb4d9db17537 1707 /**
mbed_official 376:cb4d9db17537 1708 * @brief DMA transfer complete callback.
mbed_official 376:cb4d9db17537 1709 * @param hdma: pointer to DMA handle.
mbed_official 376:cb4d9db17537 1710 * @retval None
mbed_official 376:cb4d9db17537 1711 */
mbed_official 376:cb4d9db17537 1712 static void ADC_DMAConvCplt(DMA_HandleTypeDef *hdma)
mbed_official 376:cb4d9db17537 1713 {
mbed_official 376:cb4d9db17537 1714 ADC_HandleTypeDef* hadc = ( ADC_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official 376:cb4d9db17537 1715
mbed_official 376:cb4d9db17537 1716 /* Change ADC state */
mbed_official 376:cb4d9db17537 1717 hadc->State = HAL_ADC_STATE_EOC;
mbed_official 376:cb4d9db17537 1718
mbed_official 376:cb4d9db17537 1719 HAL_ADC_ConvCpltCallback(hadc);
mbed_official 376:cb4d9db17537 1720 }
mbed_official 376:cb4d9db17537 1721
mbed_official 376:cb4d9db17537 1722 /**
mbed_official 376:cb4d9db17537 1723 * @brief DMA half transfer complete callback.
mbed_official 376:cb4d9db17537 1724 * @param hdma: pointer to DMA handle.
mbed_official 376:cb4d9db17537 1725 * @retval None
mbed_official 376:cb4d9db17537 1726 */
mbed_official 376:cb4d9db17537 1727 static void ADC_DMAHalfConvCplt(DMA_HandleTypeDef *hdma)
mbed_official 376:cb4d9db17537 1728 {
mbed_official 376:cb4d9db17537 1729 ADC_HandleTypeDef* hadc = ( ADC_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official 376:cb4d9db17537 1730
mbed_official 376:cb4d9db17537 1731 /* Conversion complete callback */
mbed_official 376:cb4d9db17537 1732 HAL_ADC_ConvHalfCpltCallback(hadc);
mbed_official 376:cb4d9db17537 1733 }
mbed_official 376:cb4d9db17537 1734
mbed_official 376:cb4d9db17537 1735 /**
mbed_official 376:cb4d9db17537 1736 * @brief DMA error callback
mbed_official 376:cb4d9db17537 1737 * @param hdma: pointer to DMA handle.
mbed_official 376:cb4d9db17537 1738 * @retval None
mbed_official 376:cb4d9db17537 1739 */
mbed_official 376:cb4d9db17537 1740 static void ADC_DMAError(DMA_HandleTypeDef *hdma)
mbed_official 376:cb4d9db17537 1741 {
mbed_official 376:cb4d9db17537 1742 ADC_HandleTypeDef* hadc = ( ADC_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official 376:cb4d9db17537 1743 hadc->State= HAL_ADC_STATE_ERROR;
mbed_official 376:cb4d9db17537 1744 /* Set ADC error code to DMA error */
mbed_official 376:cb4d9db17537 1745 hadc->ErrorCode |= HAL_ADC_ERROR_DMA;
mbed_official 376:cb4d9db17537 1746 HAL_ADC_ErrorCallback(hadc);
mbed_official 376:cb4d9db17537 1747 }
mbed_official 376:cb4d9db17537 1748
mbed_official 376:cb4d9db17537 1749 /**
mbed_official 489:119543c9f674 1750 * @brief Delay micro seconds
mbed_official 489:119543c9f674 1751 * @param microSecond : delay
mbed_official 489:119543c9f674 1752 * @retval None
mbed_official 489:119543c9f674 1753 */
mbed_official 489:119543c9f674 1754 static void ADC_DelayMicroSecond(uint32_t microSecond)
mbed_official 489:119543c9f674 1755 {
mbed_official 489:119543c9f674 1756 /* Compute number of CPU cycles to wait for */
mbed_official 489:119543c9f674 1757 __IO uint32_t waitLoopIndex = (microSecond * (SystemCoreClock / 1000000));
mbed_official 489:119543c9f674 1758
mbed_official 489:119543c9f674 1759 while(waitLoopIndex != 0)
mbed_official 489:119543c9f674 1760 {
mbed_official 489:119543c9f674 1761 waitLoopIndex--;
mbed_official 489:119543c9f674 1762 }
mbed_official 489:119543c9f674 1763 }
mbed_official 489:119543c9f674 1764
mbed_official 489:119543c9f674 1765 /**
mbed_official 376:cb4d9db17537 1766 * @}
mbed_official 376:cb4d9db17537 1767 */
mbed_official 376:cb4d9db17537 1768
mbed_official 376:cb4d9db17537 1769 #endif /* HAL_ADC_MODULE_ENABLED */
mbed_official 376:cb4d9db17537 1770 /**
mbed_official 376:cb4d9db17537 1771 * @}
mbed_official 376:cb4d9db17537 1772 */
mbed_official 376:cb4d9db17537 1773
mbed_official 376:cb4d9db17537 1774 /**
mbed_official 376:cb4d9db17537 1775 * @}
mbed_official 376:cb4d9db17537 1776 */
mbed_official 376:cb4d9db17537 1777
mbed_official 376:cb4d9db17537 1778 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/