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_DISCO_L053C8/stm32l0xx_hal_adc.c@376:cb4d9db17537, 2014-10-31 (annotated)

Committer:
mbed_official
Date:
Fri Oct 31 11:00:10 2014 +0000
Revision:
376:cb4d9db17537
Synchronized with git revision 07b49da75eac883fc8916d3d6b6962664b8db29e



Full URL: https://github.com/mbedmicro/mbed/commit/07b49da75eac883fc8916d3d6b6962664b8db29e/



Targets: DISCO_L053C8 - new platform - STM32L0 Discovery board

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 376:cb4d9db17537 5 * @version V1.1.0
mbed_official 376:cb4d9db17537 6 * @date 18-June-2014
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 376:cb4d9db17537 75 __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 376:cb4d9db17537 80 __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 376:cb4d9db17537 108 * <h2><center>&copy; COPYRIGHT(c) 2014 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 376:cb4d9db17537 151 /* Private macro -------------------------------------------------------------*/
mbed_official 376:cb4d9db17537 152 /* Private variables ---------------------------------------------------------*/
mbed_official 376:cb4d9db17537 153 /* Private function prototypes -----------------------------------------------*/
mbed_official 376:cb4d9db17537 154 static HAL_StatusTypeDef ADC_Enable(ADC_HandleTypeDef* hadc);
mbed_official 376:cb4d9db17537 155 static void ADC_DMAConvCplt(DMA_HandleTypeDef *hdma);
mbed_official 376:cb4d9db17537 156 static void ADC_DMAHalfConvCplt(DMA_HandleTypeDef *hdma);
mbed_official 376:cb4d9db17537 157 static void ADC_DMAError(DMA_HandleTypeDef *hdma);
mbed_official 376:cb4d9db17537 158 static HAL_StatusTypeDef ADC_ConversionStop(ADC_HandleTypeDef* hadc, uint32_t ConversionGroup);
mbed_official 376:cb4d9db17537 159 static HAL_StatusTypeDef ADC_Disable(ADC_HandleTypeDef* hadc);
mbed_official 376:cb4d9db17537 160
mbed_official 376:cb4d9db17537 161 /* Private functions ---------------------------------------------------------*/
mbed_official 376:cb4d9db17537 162
mbed_official 376:cb4d9db17537 163 /** @defgroup ADC_Private_Functions
mbed_official 376:cb4d9db17537 164 * @{
mbed_official 376:cb4d9db17537 165 */
mbed_official 376:cb4d9db17537 166
mbed_official 376:cb4d9db17537 167 /** @defgroup ADC_Group1 Initialization/de-initialization functions
mbed_official 376:cb4d9db17537 168 * @brief Initialization and Configuration functions
mbed_official 376:cb4d9db17537 169 *
mbed_official 376:cb4d9db17537 170 @verbatim
mbed_official 376:cb4d9db17537 171 ===============================================================================
mbed_official 376:cb4d9db17537 172 ##### Initialization and de-initialization functions #####
mbed_official 376:cb4d9db17537 173 ===============================================================================
mbed_official 376:cb4d9db17537 174 [..] This section provides functions allowing to:
mbed_official 376:cb4d9db17537 175 (+) Initialize and configure the ADC.
mbed_official 376:cb4d9db17537 176 (+) De-initialize the ADC.
mbed_official 376:cb4d9db17537 177
mbed_official 376:cb4d9db17537 178 @endverbatim
mbed_official 376:cb4d9db17537 179 * @{
mbed_official 376:cb4d9db17537 180 */
mbed_official 376:cb4d9db17537 181
mbed_official 376:cb4d9db17537 182
mbed_official 376:cb4d9db17537 183 /**
mbed_official 376:cb4d9db17537 184 * @brief Initializes the ADCx peripheral according to the specified parameters
mbed_official 376:cb4d9db17537 185 * in the ADC_InitStruct.
mbed_official 376:cb4d9db17537 186 * @note This function is used to configure the global features of the ADC
mbed_official 376:cb4d9db17537 187 * (ClockPrescaler, Resolution, Data Alignment and number of conversion), however,
mbed_official 376:cb4d9db17537 188 * the rest of the configuration parameters are specific to the regular
mbed_official 376:cb4d9db17537 189 * channels group (scan mode activation, continuous mode activation,
mbed_official 376:cb4d9db17537 190 * External trigger source and edge, DMA continuous request after the
mbed_official 376:cb4d9db17537 191 * last transfer and End of conversion selection).
mbed_official 376:cb4d9db17537 192 *
mbed_official 376:cb4d9db17537 193 * As prerequisite, into HAL_ADC_MspInit(), ADC clock must be
mbed_official 376:cb4d9db17537 194 * configured at RCC top level.
mbed_official 376:cb4d9db17537 195 * See commented example code below that can be copied
mbed_official 376:cb4d9db17537 196 * and uncommented into HAL_ADC_MspInit().
mbed_official 376:cb4d9db17537 197 *
mbed_official 376:cb4d9db17537 198 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 199 * the configuration information for the specified ADC.
mbed_official 376:cb4d9db17537 200 * @retval HAL status
mbed_official 376:cb4d9db17537 201 */
mbed_official 376:cb4d9db17537 202 HAL_StatusTypeDef HAL_ADC_Init(ADC_HandleTypeDef* hadc)
mbed_official 376:cb4d9db17537 203 {
mbed_official 376:cb4d9db17537 204 uint32_t tickstart = 0x00;
mbed_official 376:cb4d9db17537 205
mbed_official 376:cb4d9db17537 206 /* Check ADC handle */
mbed_official 376:cb4d9db17537 207 if(hadc == NULL)
mbed_official 376:cb4d9db17537 208 {
mbed_official 376:cb4d9db17537 209 return HAL_ERROR;
mbed_official 376:cb4d9db17537 210 }
mbed_official 376:cb4d9db17537 211
mbed_official 376:cb4d9db17537 212 /* Check the parameters */
mbed_official 376:cb4d9db17537 213 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 376:cb4d9db17537 214 assert_param(IS_ADC_CLOCKPRESCALER(hadc->Init.ClockPrescaler));
mbed_official 376:cb4d9db17537 215 assert_param(IS_ADC_RESOLUTION(hadc->Init.Resolution));
mbed_official 376:cb4d9db17537 216 assert_param(IS_ADC_SAMPLE_TIME(hadc->Init.SamplingTime));
mbed_official 376:cb4d9db17537 217 assert_param(IS_ADC_SCAN_DIRECTION(hadc->Init.ScanDirection));
mbed_official 376:cb4d9db17537 218 assert_param(IS_ADC_DATA_ALIGN(hadc->Init.DataAlign));
mbed_official 376:cb4d9db17537 219 assert_param(IS_FUNCTIONAL_STATE(hadc->Init.ContinuousConvMode));
mbed_official 376:cb4d9db17537 220 assert_param(IS_FUNCTIONAL_STATE(hadc->Init.DiscontinuousConvMode));
mbed_official 376:cb4d9db17537 221 assert_param(IS_ADC_EXTTRIG_EDGE(hadc->Init.ExternalTrigConvEdge));
mbed_official 376:cb4d9db17537 222 assert_param(IS_ADC_EXTERNAL_TRIG_CONV(hadc->Init.ExternalTrigConv));
mbed_official 376:cb4d9db17537 223 assert_param(IS_FUNCTIONAL_STATE(hadc->Init.DMAContinuousRequests));
mbed_official 376:cb4d9db17537 224 assert_param(IS_ADC_EOC_SELECTION(hadc->Init.EOCSelection));
mbed_official 376:cb4d9db17537 225 assert_param(IS_ADC_OVERRUN(hadc->Init.Overrun));
mbed_official 376:cb4d9db17537 226 assert_param(IS_FUNCTIONAL_STATE(hadc->Init.LowPowerAutoWait));
mbed_official 376:cb4d9db17537 227 assert_param(IS_FUNCTIONAL_STATE(hadc->Init.LowPowerFrequencyMode));
mbed_official 376:cb4d9db17537 228 assert_param(IS_FUNCTIONAL_STATE(hadc->Init.LowPowerAutoOff));
mbed_official 376:cb4d9db17537 229 assert_param(IS_FUNCTIONAL_STATE(hadc->Init.OversamplingMode));
mbed_official 376:cb4d9db17537 230
mbed_official 376:cb4d9db17537 231 if(hadc->State == HAL_ADC_STATE_RESET)
mbed_official 376:cb4d9db17537 232 {
mbed_official 376:cb4d9db17537 233 /* Init the low level hardware */
mbed_official 376:cb4d9db17537 234 HAL_ADC_MspInit(hadc);
mbed_official 376:cb4d9db17537 235 }
mbed_official 376:cb4d9db17537 236
mbed_official 376:cb4d9db17537 237 /* Initialize the ADC state */
mbed_official 376:cb4d9db17537 238 hadc->State = HAL_ADC_STATE_BUSY;
mbed_official 376:cb4d9db17537 239
mbed_official 376:cb4d9db17537 240 /* Configuration of ADC clock: clock source PCLK or asynchronous with
mbed_official 376:cb4d9db17537 241 selectable prescaler */
mbed_official 376:cb4d9db17537 242 __HAL_ADC_CLOCK_PRESCALER(hadc);
mbed_official 376:cb4d9db17537 243
mbed_official 376:cb4d9db17537 244 /* Set the Low Frequency mode */
mbed_official 376:cb4d9db17537 245 ADC->CCR &= (uint32_t)~ADC_CCR_LFMEN;
mbed_official 376:cb4d9db17537 246 ADC->CCR |=__HAL_ADC_CCR_LOWFREQUENCY(hadc->Init.LowPowerFrequencyMode);
mbed_official 376:cb4d9db17537 247
mbed_official 376:cb4d9db17537 248 /* Enable voltage regulator (if disabled at this step) */
mbed_official 376:cb4d9db17537 249 if (HAL_IS_BIT_CLR(hadc->Instance->CR, ADC_CR_ADVREGEN))
mbed_official 376:cb4d9db17537 250 {
mbed_official 376:cb4d9db17537 251 /* Note: The software must wait for the startup time of the ADC voltage */
mbed_official 376:cb4d9db17537 252 /* regulator before launching a calibration or enabling the ADC. */
mbed_official 376:cb4d9db17537 253 /* This temporization must be implemented by software and is equal */
mbed_official 376:cb4d9db17537 254 /* to 10 micro seconds in the worst case process/temperature/power supply. */
mbed_official 376:cb4d9db17537 255
mbed_official 376:cb4d9db17537 256 /* Disable the ADC (if not already disabled) */
mbed_official 376:cb4d9db17537 257 if (__HAL_ADC_IS_ENABLED(hadc) != RESET )
mbed_official 376:cb4d9db17537 258 {
mbed_official 376:cb4d9db17537 259 /* Check if conditions to disable the ADC are fulfilled */
mbed_official 376:cb4d9db17537 260 if (__HAL_ADC_DISABLING_CONDITIONS(hadc) != RESET)
mbed_official 376:cb4d9db17537 261 {
mbed_official 376:cb4d9db17537 262 __HAL_ADC_DISABLE(hadc);
mbed_official 376:cb4d9db17537 263 }
mbed_official 376:cb4d9db17537 264 else
mbed_official 376:cb4d9db17537 265 {
mbed_official 376:cb4d9db17537 266 hadc->State= HAL_ADC_STATE_ERROR;
mbed_official 376:cb4d9db17537 267
mbed_official 376:cb4d9db17537 268 /* Process unlocked */
mbed_official 376:cb4d9db17537 269 __HAL_UNLOCK(hadc);
mbed_official 376:cb4d9db17537 270
mbed_official 376:cb4d9db17537 271 return HAL_ERROR;
mbed_official 376:cb4d9db17537 272 }
mbed_official 376:cb4d9db17537 273
mbed_official 376:cb4d9db17537 274 /* Get timeout */
mbed_official 376:cb4d9db17537 275 tickstart = HAL_GetTick();
mbed_official 376:cb4d9db17537 276
mbed_official 376:cb4d9db17537 277 /* Wait for disabling completion */
mbed_official 376:cb4d9db17537 278 while(HAL_IS_BIT_SET(hadc->Instance->CR, ADC_CR_ADEN))
mbed_official 376:cb4d9db17537 279 {
mbed_official 376:cb4d9db17537 280 /* Check for the Timeout */
mbed_official 376:cb4d9db17537 281 if(ADC_ENABLE_TIMEOUT != HAL_MAX_DELAY)
mbed_official 376:cb4d9db17537 282 {
mbed_official 376:cb4d9db17537 283 if((HAL_GetTick() - tickstart ) > ADC_DISABLE_TIMEOUT)
mbed_official 376:cb4d9db17537 284 {
mbed_official 376:cb4d9db17537 285 hadc->State= HAL_ADC_STATE_TIMEOUT;
mbed_official 376:cb4d9db17537 286
mbed_official 376:cb4d9db17537 287 /* Process unlocked */
mbed_official 376:cb4d9db17537 288 __HAL_UNLOCK(hadc);
mbed_official 376:cb4d9db17537 289
mbed_official 376:cb4d9db17537 290 return HAL_TIMEOUT;
mbed_official 376:cb4d9db17537 291 }
mbed_official 376:cb4d9db17537 292 }
mbed_official 376:cb4d9db17537 293 }
mbed_official 376:cb4d9db17537 294
mbed_official 376:cb4d9db17537 295 }
mbed_official 376:cb4d9db17537 296
mbed_official 376:cb4d9db17537 297 /* Set ADVREGEN bit */
mbed_official 376:cb4d9db17537 298 hadc->Instance->CR |= ADC_CR_ADVREGEN;
mbed_official 376:cb4d9db17537 299 /* Delay of 10 microseconds minimum (value from design, cf reference manual) */
mbed_official 376:cb4d9db17537 300 /* Delay fixed to worst case: maximum CPU frequency */
mbed_official 376:cb4d9db17537 301 HAL_Delay(10);
mbed_official 376:cb4d9db17537 302 }
mbed_official 376:cb4d9db17537 303
mbed_official 376:cb4d9db17537 304 /* Configuration of ADC: */
mbed_official 376:cb4d9db17537 305 /* - Resolution */
mbed_official 376:cb4d9db17537 306 /* - Data alignment */
mbed_official 376:cb4d9db17537 307 /* - Scan direction */
mbed_official 376:cb4d9db17537 308 /* - External trigger to start conversion */
mbed_official 376:cb4d9db17537 309 /* - External trigger polarity */
mbed_official 376:cb4d9db17537 310 /* - Continuous conversion mode */
mbed_official 376:cb4d9db17537 311 /* - DMA continuous request */
mbed_official 376:cb4d9db17537 312 /* - Overrun */
mbed_official 376:cb4d9db17537 313 /* - AutoDelay feature */
mbed_official 376:cb4d9db17537 314 /* - Discontinuous mode */
mbed_official 376:cb4d9db17537 315 hadc->Instance->CFGR1 &= ~( ADC_CFGR1_RES |
mbed_official 376:cb4d9db17537 316 ADC_CFGR1_ALIGN |
mbed_official 376:cb4d9db17537 317 ADC_CFGR1_SCANDIR |
mbed_official 376:cb4d9db17537 318 ADC_CFGR1_EXTSEL |
mbed_official 376:cb4d9db17537 319 ADC_CFGR1_EXTEN |
mbed_official 376:cb4d9db17537 320 ADC_CFGR1_CONT |
mbed_official 376:cb4d9db17537 321 ADC_CFGR1_DMACFG |
mbed_official 376:cb4d9db17537 322 ADC_CFGR1_OVRMOD |
mbed_official 376:cb4d9db17537 323 ADC_CFGR1_AUTDLY |
mbed_official 376:cb4d9db17537 324 ADC_CFGR1_AUTOFF |
mbed_official 376:cb4d9db17537 325 ADC_CFGR1_DISCEN);
mbed_official 376:cb4d9db17537 326
mbed_official 376:cb4d9db17537 327 hadc->Instance->CFGR1 |= ( hadc->Init.Resolution |
mbed_official 376:cb4d9db17537 328 hadc->Init.DataAlign |
mbed_official 376:cb4d9db17537 329 hadc->Init.ScanDirection |
mbed_official 376:cb4d9db17537 330 hadc->Init.ExternalTrigConvEdge |
mbed_official 376:cb4d9db17537 331 __HAL_ADC_CFGR1_CONTINUOUS(hadc->Init.ContinuousConvMode) |
mbed_official 376:cb4d9db17537 332 __HAL_ADC_CFGR1_DMAContReq(hadc->Init.DMAContinuousRequests) |
mbed_official 376:cb4d9db17537 333 hadc->Init.Overrun |
mbed_official 376:cb4d9db17537 334 __HAL_ADC_CFGR1_AutoDelay(hadc->Init.LowPowerAutoWait) |
mbed_official 376:cb4d9db17537 335 __HAL_ADC_CFGR1_AUTOFF(hadc->Init.LowPowerAutoOff));
mbed_official 376:cb4d9db17537 336
mbed_official 376:cb4d9db17537 337 /* Configure the external trigger only if Conversion edge is not "NONE" */
mbed_official 376:cb4d9db17537 338 if (hadc->Init.ExternalTrigConvEdge != ADC_EXTERNALTRIG_EDGE_NONE)
mbed_official 376:cb4d9db17537 339 {
mbed_official 376:cb4d9db17537 340 hadc->Instance->CFGR1 |= hadc->Init.ExternalTrigConv;
mbed_official 376:cb4d9db17537 341 }
mbed_official 376:cb4d9db17537 342
mbed_official 376:cb4d9db17537 343 /* Enable discontinuous mode only if continuous mode is disabled */
mbed_official 376:cb4d9db17537 344 if ((hadc->Init.DiscontinuousConvMode == ENABLE) && (hadc->Init.ContinuousConvMode == DISABLE))
mbed_official 376:cb4d9db17537 345 {
mbed_official 376:cb4d9db17537 346 /* Enable the selected ADC discontinuous mode */
mbed_official 376:cb4d9db17537 347 hadc->Instance->CFGR1 |= ( ADC_CFGR1_DISCEN);
mbed_official 376:cb4d9db17537 348 }
mbed_official 376:cb4d9db17537 349
mbed_official 376:cb4d9db17537 350 if (hadc->Init.OversamplingMode == ENABLE)
mbed_official 376:cb4d9db17537 351 {
mbed_official 376:cb4d9db17537 352 assert_param(IS_ADC_OVERSAMPLING_RATIO(hadc->Init.Oversample.Ratio));
mbed_official 376:cb4d9db17537 353 assert_param(IS_ADC_RIGHT_BIT_SHIFT(hadc->Init.Oversample.RightBitShift));
mbed_official 376:cb4d9db17537 354 assert_param(IS_ADC_TRIGGERED_OVERSAMPLING_MODE(hadc->Init.Oversample.TriggeredMode));
mbed_official 376:cb4d9db17537 355
mbed_official 376:cb4d9db17537 356 /* Configuration of Oversampler: */
mbed_official 376:cb4d9db17537 357 /* - Oversampling Ratio */
mbed_official 376:cb4d9db17537 358 /* - Right bit shift */
mbed_official 376:cb4d9db17537 359 /* - Triggered mode */
mbed_official 376:cb4d9db17537 360
mbed_official 376:cb4d9db17537 361 hadc->Instance->CFGR2 &= ~( ADC_CFGR2_OVSR |
mbed_official 376:cb4d9db17537 362 ADC_CFGR2_OVSS |
mbed_official 376:cb4d9db17537 363 ADC_CFGR2_TOVS );
mbed_official 376:cb4d9db17537 364
mbed_official 376:cb4d9db17537 365 hadc->Instance->CFGR2 |= ( hadc->Init.Oversample.Ratio |
mbed_official 376:cb4d9db17537 366 hadc->Init.Oversample.RightBitShift |
mbed_official 376:cb4d9db17537 367 hadc->Init.Oversample.TriggeredMode );
mbed_official 376:cb4d9db17537 368
mbed_official 376:cb4d9db17537 369 /* Enable OverSampling mode */
mbed_official 376:cb4d9db17537 370 hadc->Instance->CFGR2 |= ADC_CFGR2_OVSE;
mbed_official 376:cb4d9db17537 371 }
mbed_official 376:cb4d9db17537 372 else
mbed_official 376:cb4d9db17537 373 {
mbed_official 376:cb4d9db17537 374 /* Disable OverSampling mode */
mbed_official 376:cb4d9db17537 375 hadc->Instance->CFGR2 &= ~ADC_CFGR2_OVSE;
mbed_official 376:cb4d9db17537 376 }
mbed_official 376:cb4d9db17537 377
mbed_official 376:cb4d9db17537 378 /* Clear the old sampling time */
mbed_official 376:cb4d9db17537 379 hadc->Instance->SMPR &= (uint32_t)(~ADC_SMPR_SMPR);
mbed_official 376:cb4d9db17537 380
mbed_official 376:cb4d9db17537 381 /* Set the new sample time */
mbed_official 376:cb4d9db17537 382 hadc->Instance->SMPR |= hadc->Init.SamplingTime;
mbed_official 376:cb4d9db17537 383
mbed_official 376:cb4d9db17537 384
mbed_official 376:cb4d9db17537 385 /* Set ADC error code to none */
mbed_official 376:cb4d9db17537 386 hadc->ErrorCode = HAL_ADC_ERROR_NONE;
mbed_official 376:cb4d9db17537 387
mbed_official 376:cb4d9db17537 388 /* Initialize the ADC state */
mbed_official 376:cb4d9db17537 389 hadc->State = HAL_ADC_STATE_READY;
mbed_official 376:cb4d9db17537 390
mbed_official 376:cb4d9db17537 391 /* Return function status */
mbed_official 376:cb4d9db17537 392 return HAL_OK;
mbed_official 376:cb4d9db17537 393 }
mbed_official 376:cb4d9db17537 394
mbed_official 376:cb4d9db17537 395 /**
mbed_official 376:cb4d9db17537 396 * @brief Deinitialize the ADC peripheral registers to its default reset values.
mbed_official 376:cb4d9db17537 397 * @note To not impact other ADCs, reset of common ADC registers have been
mbed_official 376:cb4d9db17537 398 * left commented below.
mbed_official 376:cb4d9db17537 399 * If needed, the example code can be copied and uncommented into
mbed_official 376:cb4d9db17537 400 * function HAL_ADC_MspDeInit().
mbed_official 376:cb4d9db17537 401 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 402 * the configuration information for the specified ADC.
mbed_official 376:cb4d9db17537 403 * @retval HAL status
mbed_official 376:cb4d9db17537 404 */
mbed_official 376:cb4d9db17537 405 HAL_StatusTypeDef HAL_ADC_DeInit(ADC_HandleTypeDef* hadc)
mbed_official 376:cb4d9db17537 406 {
mbed_official 376:cb4d9db17537 407 uint32_t tickstart = 0;
mbed_official 376:cb4d9db17537 408
mbed_official 376:cb4d9db17537 409 /* Check ADC handle */
mbed_official 376:cb4d9db17537 410 if(hadc == NULL)
mbed_official 376:cb4d9db17537 411 {
mbed_official 376:cb4d9db17537 412 return HAL_ERROR;
mbed_official 376:cb4d9db17537 413 }
mbed_official 376:cb4d9db17537 414
mbed_official 376:cb4d9db17537 415 /* Check the parameters */
mbed_official 376:cb4d9db17537 416 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 376:cb4d9db17537 417
mbed_official 376:cb4d9db17537 418 /* Change ADC state */
mbed_official 376:cb4d9db17537 419 hadc->State = HAL_ADC_STATE_BUSY;
mbed_official 376:cb4d9db17537 420
mbed_official 376:cb4d9db17537 421 /* Stop potential conversion ongoing */
mbed_official 376:cb4d9db17537 422 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 423 {
mbed_official 376:cb4d9db17537 424 /* Stop regular conversion */
mbed_official 376:cb4d9db17537 425 hadc->Instance->CR |= ADC_CR_ADSTP;
mbed_official 376:cb4d9db17537 426 }
mbed_official 376:cb4d9db17537 427
mbed_official 376:cb4d9db17537 428 /* Disable ADC: Solution to recover from an unknown ADC state (for example, */
mbed_official 376:cb4d9db17537 429 /* in case of forbidden action on register bits) */
mbed_official 376:cb4d9db17537 430 /* Procedure to disable the ADC peripheral: wait for conversions */
mbed_official 376:cb4d9db17537 431 /* effectively stopped, then disable ADC */
mbed_official 376:cb4d9db17537 432 /* 1. Wait until ADSTART = 0 */
mbed_official 376:cb4d9db17537 433
mbed_official 376:cb4d9db17537 434 /* Get timeout */
mbed_official 376:cb4d9db17537 435 tickstart = HAL_GetTick();
mbed_official 376:cb4d9db17537 436
mbed_official 376:cb4d9db17537 437 while(HAL_IS_BIT_SET(hadc->Instance->CR, ADC_CR_ADSTART))
mbed_official 376:cb4d9db17537 438 {
mbed_official 376:cb4d9db17537 439 /* Check for the Timeout */
mbed_official 376:cb4d9db17537 440 if(ADC_STOP_CONVERSION_TIMEOUT != HAL_MAX_DELAY)
mbed_official 376:cb4d9db17537 441 {
mbed_official 376:cb4d9db17537 442 if((HAL_GetTick() - tickstart ) > ADC_STOP_CONVERSION_TIMEOUT)
mbed_official 376:cb4d9db17537 443 {
mbed_official 376:cb4d9db17537 444 hadc->State= HAL_ADC_STATE_TIMEOUT;
mbed_official 376:cb4d9db17537 445
mbed_official 376:cb4d9db17537 446 /* Process unlocked */
mbed_official 376:cb4d9db17537 447 __HAL_UNLOCK(hadc);
mbed_official 376:cb4d9db17537 448
mbed_official 376:cb4d9db17537 449 return HAL_TIMEOUT;
mbed_official 376:cb4d9db17537 450 }
mbed_official 376:cb4d9db17537 451 }
mbed_official 376:cb4d9db17537 452 }
mbed_official 376:cb4d9db17537 453
mbed_official 376:cb4d9db17537 454 /* 2. Disable the ADC peripheral */
mbed_official 376:cb4d9db17537 455 __HAL_ADC_DISABLE(hadc);
mbed_official 376:cb4d9db17537 456
mbed_official 376:cb4d9db17537 457
mbed_official 376:cb4d9db17537 458 /* Reset ADC registers****************/
mbed_official 376:cb4d9db17537 459 /* Reset register IER */
mbed_official 376:cb4d9db17537 460 __HAL_ADC_DISABLE_IT(hadc, (ADC_IT_AWD | ADC_IT_OVR | ADC_IT_EOCAL | ADC_IT_EOS | \
mbed_official 376:cb4d9db17537 461 ADC_IT_EOC | ADC_IT_RDY | ADC_IT_EOSMP ));
mbed_official 376:cb4d9db17537 462
mbed_official 376:cb4d9db17537 463 /* Reset register ISR */
mbed_official 376:cb4d9db17537 464 __HAL_ADC_CLEAR_FLAG(hadc, (ADC_FLAG_AWD | ADC_FLAG_EOCAL | ADC_FLAG_OVR | ADC_FLAG_EOS | \
mbed_official 376:cb4d9db17537 465 ADC_FLAG_EOC | ADC_FLAG_EOSMP | ADC_FLAG_RDY));
mbed_official 376:cb4d9db17537 466
mbed_official 376:cb4d9db17537 467 /* Reset register CR */
mbed_official 376:cb4d9db17537 468 /* Disable voltage regulator */
mbed_official 376:cb4d9db17537 469 /* Note: Regulator disable useful for power saving */
mbed_official 376:cb4d9db17537 470 /* Reset ADVREGEN bit */
mbed_official 376:cb4d9db17537 471 hadc->Instance->CR &= ~ADC_CR_ADVREGEN;
mbed_official 376:cb4d9db17537 472
mbed_official 376:cb4d9db17537 473 /* Bits ADC_CR_ADSTP, ADC_CR_ADSTART are in access mode "read-set": no direct reset applicable */
mbed_official 376:cb4d9db17537 474 /* No action */
mbed_official 376:cb4d9db17537 475
mbed_official 376:cb4d9db17537 476 /* Reset register CFGR1 */
mbed_official 376:cb4d9db17537 477 hadc->Instance->CFGR1 &= ~(ADC_CFGR1_AWDCH | ADC_CFGR1_AWDEN | ADC_CFGR1_AWDSGL | \
mbed_official 376:cb4d9db17537 478 ADC_CFGR1_DISCEN | ADC_CFGR1_AUTOFF | ADC_CFGR1_AUTDLY | \
mbed_official 376:cb4d9db17537 479 ADC_CFGR1_CONT | ADC_CFGR1_OVRMOD | ADC_CFGR1_EXTEN | \
mbed_official 376:cb4d9db17537 480 ADC_CFGR1_EXTSEL | ADC_CFGR1_ALIGN | ADC_CFGR1_RES | \
mbed_official 376:cb4d9db17537 481 ADC_CFGR1_SCANDIR| ADC_CFGR1_DMACFG | ADC_CFGR1_DMAEN);
mbed_official 376:cb4d9db17537 482
mbed_official 376:cb4d9db17537 483 /* Reset register CFGR2 */
mbed_official 376:cb4d9db17537 484 hadc->Instance->CFGR2 &= ~(ADC_CFGR2_TOVS | ADC_CFGR2_OVSS | ADC_CFGR2_OVSR | \
mbed_official 376:cb4d9db17537 485 ADC_CFGR2_OVSE | ADC_CFGR2_CKMODE );
mbed_official 376:cb4d9db17537 486
mbed_official 376:cb4d9db17537 487 /* Reset register SMPR */
mbed_official 376:cb4d9db17537 488 hadc->Instance->SMPR &= ~(ADC_SMPR_SMPR);
mbed_official 376:cb4d9db17537 489
mbed_official 376:cb4d9db17537 490 /* Reset register TR */
mbed_official 376:cb4d9db17537 491 hadc->Instance->TR &= ~(ADC_TR_LT | ADC_TR_HT);
mbed_official 376:cb4d9db17537 492
mbed_official 376:cb4d9db17537 493 /* Reset register CALFACT */
mbed_official 376:cb4d9db17537 494 hadc->Instance->CALFACT &= ~(ADC_CALFACT_CALFACT);
mbed_official 376:cb4d9db17537 495
mbed_official 376:cb4d9db17537 496 /* Reset register DR */
mbed_official 376:cb4d9db17537 497 /* bits in access mode read only, no direct reset applicable*/
mbed_official 376:cb4d9db17537 498
mbed_official 376:cb4d9db17537 499 /* Reset register CALFACT */
mbed_official 376:cb4d9db17537 500 hadc->Instance->CALFACT &= ~(ADC_CALFACT_CALFACT);
mbed_official 376:cb4d9db17537 501
mbed_official 376:cb4d9db17537 502
mbed_official 376:cb4d9db17537 503 /* DeInit the low level hardware */
mbed_official 376:cb4d9db17537 504 HAL_ADC_MspDeInit(hadc);
mbed_official 376:cb4d9db17537 505
mbed_official 376:cb4d9db17537 506 /* Set ADC error code to none */
mbed_official 376:cb4d9db17537 507 hadc->ErrorCode = HAL_ADC_ERROR_NONE;
mbed_official 376:cb4d9db17537 508
mbed_official 376:cb4d9db17537 509 /* Change ADC state */
mbed_official 376:cb4d9db17537 510 hadc->State = HAL_ADC_STATE_RESET;
mbed_official 376:cb4d9db17537 511
mbed_official 376:cb4d9db17537 512 /* Return function status */
mbed_official 376:cb4d9db17537 513 return HAL_OK;
mbed_official 376:cb4d9db17537 514 }
mbed_official 376:cb4d9db17537 515
mbed_official 376:cb4d9db17537 516 /**
mbed_official 376:cb4d9db17537 517 * @brief Initializes the ADC MSP.
mbed_official 376:cb4d9db17537 518 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 519 * the configuration information for the specified ADC.
mbed_official 376:cb4d9db17537 520 * @retval None
mbed_official 376:cb4d9db17537 521 */
mbed_official 376:cb4d9db17537 522 __weak void HAL_ADC_MspInit(ADC_HandleTypeDef* hadc)
mbed_official 376:cb4d9db17537 523 {
mbed_official 376:cb4d9db17537 524 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 376:cb4d9db17537 525 the HAL_ADC_MspInit could be implemented in the user file
mbed_official 376:cb4d9db17537 526 */
mbed_official 376:cb4d9db17537 527 }
mbed_official 376:cb4d9db17537 528
mbed_official 376:cb4d9db17537 529 /**
mbed_official 376:cb4d9db17537 530 * @brief DeInitializes the ADC MSP.
mbed_official 376:cb4d9db17537 531 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 532 * the configuration information for the specified ADC.
mbed_official 376:cb4d9db17537 533 * @retval None
mbed_official 376:cb4d9db17537 534 */
mbed_official 376:cb4d9db17537 535 __weak void HAL_ADC_MspDeInit(ADC_HandleTypeDef* hadc)
mbed_official 376:cb4d9db17537 536 {
mbed_official 376:cb4d9db17537 537 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 376:cb4d9db17537 538 the HAL_ADC_MspDeInit could be implemented in the user file
mbed_official 376:cb4d9db17537 539 */
mbed_official 376:cb4d9db17537 540 }
mbed_official 376:cb4d9db17537 541
mbed_official 376:cb4d9db17537 542 /**
mbed_official 376:cb4d9db17537 543 * @}
mbed_official 376:cb4d9db17537 544 */
mbed_official 376:cb4d9db17537 545
mbed_official 376:cb4d9db17537 546 /** @defgroup ADC_Group2 I/O operation functions
mbed_official 376:cb4d9db17537 547 * @brief I/O operation functions
mbed_official 376:cb4d9db17537 548 *
mbed_official 376:cb4d9db17537 549 @verbatim
mbed_official 376:cb4d9db17537 550 ===============================================================================
mbed_official 376:cb4d9db17537 551 ##### IO operation functions #####
mbed_official 376:cb4d9db17537 552 ===============================================================================
mbed_official 376:cb4d9db17537 553 [..] This section provides functions allowing to:
mbed_official 376:cb4d9db17537 554 (+) Start conversion.
mbed_official 376:cb4d9db17537 555 (+) Stop conversion.
mbed_official 376:cb4d9db17537 556 (+) poll for conversion complete.
mbed_official 376:cb4d9db17537 557 (+) poll for conversion event.
mbed_official 376:cb4d9db17537 558 (+) Start conversion and enable interrupt.
mbed_official 376:cb4d9db17537 559 (+) Stop conversion and disable interrupt.
mbed_official 376:cb4d9db17537 560 (+) handle ADC interrupt request.
mbed_official 376:cb4d9db17537 561 (+) Start conversion of regular channel and enable DMA transfer.
mbed_official 376:cb4d9db17537 562 (+) Stop conversion of regular channel and disable DMA transfer.
mbed_official 376:cb4d9db17537 563 (+) Get result of regular channel conversion.
mbed_official 376:cb4d9db17537 564 (+) Handle ADC interrupt request.
mbed_official 376:cb4d9db17537 565
mbed_official 376:cb4d9db17537 566 @endverbatim
mbed_official 376:cb4d9db17537 567 * @{
mbed_official 376:cb4d9db17537 568 */
mbed_official 376:cb4d9db17537 569
mbed_official 376:cb4d9db17537 570
mbed_official 376:cb4d9db17537 571 /**
mbed_official 376:cb4d9db17537 572 * @brief Enables ADC and starts conversion of the regular channels.
mbed_official 376:cb4d9db17537 573 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 574 * the configuration information for the specified ADC.
mbed_official 376:cb4d9db17537 575 * @retval HAL status
mbed_official 376:cb4d9db17537 576 */
mbed_official 376:cb4d9db17537 577 HAL_StatusTypeDef HAL_ADC_Start(ADC_HandleTypeDef* hadc)
mbed_official 376:cb4d9db17537 578 {
mbed_official 376:cb4d9db17537 579 HAL_StatusTypeDef tmpHALStatus = HAL_OK;
mbed_official 376:cb4d9db17537 580
mbed_official 376:cb4d9db17537 581 /* Check the parameters */
mbed_official 376:cb4d9db17537 582 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 376:cb4d9db17537 583
mbed_official 376:cb4d9db17537 584 /* Process locked */
mbed_official 376:cb4d9db17537 585 __HAL_LOCK(hadc);
mbed_official 376:cb4d9db17537 586
mbed_official 376:cb4d9db17537 587 /* Change ADC state */
mbed_official 376:cb4d9db17537 588 hadc->State = HAL_ADC_STATE_BUSY_REG;
mbed_official 376:cb4d9db17537 589
mbed_official 376:cb4d9db17537 590 /* Set ADC error code to none */
mbed_official 376:cb4d9db17537 591 hadc->ErrorCode = HAL_ADC_ERROR_NONE;
mbed_official 376:cb4d9db17537 592
mbed_official 376:cb4d9db17537 593 /* Enable ADC */
mbed_official 376:cb4d9db17537 594 tmpHALStatus = ADC_Enable(hadc);
mbed_official 376:cb4d9db17537 595
mbed_official 376:cb4d9db17537 596 /* Start conversion if ADC is effectively enabled */
mbed_official 376:cb4d9db17537 597 if (tmpHALStatus != HAL_ERROR)
mbed_official 376:cb4d9db17537 598 {
mbed_official 376:cb4d9db17537 599 /* ADC start conversion command */
mbed_official 376:cb4d9db17537 600 hadc->Instance->CR |= ADC_CR_ADSTART;
mbed_official 376:cb4d9db17537 601 }
mbed_official 376:cb4d9db17537 602
mbed_official 376:cb4d9db17537 603 /* Process unlocked */
mbed_official 376:cb4d9db17537 604 __HAL_UNLOCK(hadc);
mbed_official 376:cb4d9db17537 605
mbed_official 376:cb4d9db17537 606 /* Return function status */
mbed_official 376:cb4d9db17537 607 return HAL_OK;
mbed_official 376:cb4d9db17537 608 }
mbed_official 376:cb4d9db17537 609
mbed_official 376:cb4d9db17537 610 /**
mbed_official 376:cb4d9db17537 611 * @brief Stop ADC conversion of regular channels, disable ADC peripheral.
mbed_official 376:cb4d9db17537 612 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 613 * the configuration information for the specified ADC.
mbed_official 376:cb4d9db17537 614 * @retval None
mbed_official 376:cb4d9db17537 615 */
mbed_official 376:cb4d9db17537 616 HAL_StatusTypeDef HAL_ADC_Stop(ADC_HandleTypeDef* hadc)
mbed_official 376:cb4d9db17537 617 {
mbed_official 376:cb4d9db17537 618 HAL_StatusTypeDef tmpHALStatus = HAL_OK;
mbed_official 376:cb4d9db17537 619
mbed_official 376:cb4d9db17537 620 /* Process locked */
mbed_official 376:cb4d9db17537 621 __HAL_LOCK(hadc);
mbed_official 376:cb4d9db17537 622
mbed_official 376:cb4d9db17537 623 /* 1. Stop potential conversion ongoing (regular conversion) */
mbed_official 376:cb4d9db17537 624 tmpHALStatus = ADC_ConversionStop(hadc, REGULAR_GROUP);
mbed_official 376:cb4d9db17537 625
mbed_official 376:cb4d9db17537 626 /* 2. Disable ADC peripheral if conversions are effectively stopped */
mbed_official 376:cb4d9db17537 627 if (tmpHALStatus != HAL_ERROR)
mbed_official 376:cb4d9db17537 628 {
mbed_official 376:cb4d9db17537 629 /* Disable the ADC peripheral */
mbed_official 376:cb4d9db17537 630 ADC_Disable(hadc);
mbed_official 376:cb4d9db17537 631
mbed_official 376:cb4d9db17537 632 /* Check if ADC is effectively disabled */
mbed_official 376:cb4d9db17537 633 if (hadc->State != HAL_ADC_STATE_ERROR)
mbed_official 376:cb4d9db17537 634 {
mbed_official 376:cb4d9db17537 635 /* Change ADC state */
mbed_official 376:cb4d9db17537 636 hadc->State = HAL_ADC_STATE_READY;
mbed_official 376:cb4d9db17537 637 }
mbed_official 376:cb4d9db17537 638 else
mbed_official 376:cb4d9db17537 639 {
mbed_official 376:cb4d9db17537 640 return HAL_ERROR;
mbed_official 376:cb4d9db17537 641 }
mbed_official 376:cb4d9db17537 642 }
mbed_official 376:cb4d9db17537 643 else
mbed_official 376:cb4d9db17537 644 {
mbed_official 376:cb4d9db17537 645 return HAL_ERROR;
mbed_official 376:cb4d9db17537 646 }
mbed_official 376:cb4d9db17537 647
mbed_official 376:cb4d9db17537 648 /* Process unlocked */
mbed_official 376:cb4d9db17537 649 __HAL_UNLOCK(hadc);
mbed_official 376:cb4d9db17537 650
mbed_official 376:cb4d9db17537 651 /* Return function status */
mbed_official 376:cb4d9db17537 652 return HAL_OK;
mbed_official 376:cb4d9db17537 653 }
mbed_official 376:cb4d9db17537 654
mbed_official 376:cb4d9db17537 655 /**
mbed_official 376:cb4d9db17537 656 * @brief Poll for conversion complete.
mbed_official 376:cb4d9db17537 657 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 658 * the configuration information for the specified ADC.
mbed_official 376:cb4d9db17537 659 * @param Timeout: Timeout value in millisecond.
mbed_official 376:cb4d9db17537 660 * @retval HAL status
mbed_official 376:cb4d9db17537 661 */
mbed_official 376:cb4d9db17537 662 HAL_StatusTypeDef HAL_ADC_PollForConversion(ADC_HandleTypeDef* hadc, uint32_t Timeout)
mbed_official 376:cb4d9db17537 663 {
mbed_official 376:cb4d9db17537 664 uint32_t tickstart = 0;
mbed_official 376:cb4d9db17537 665 uint32_t tmp_Flag_EOC;
mbed_official 376:cb4d9db17537 666
mbed_official 376:cb4d9db17537 667 /* Check the parameters */
mbed_official 376:cb4d9db17537 668 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 376:cb4d9db17537 669
mbed_official 376:cb4d9db17537 670 /* If interruption after each sequence */
mbed_official 376:cb4d9db17537 671 if (hadc->Init.EOCSelection == EOC_SEQ_CONV)
mbed_official 376:cb4d9db17537 672 {
mbed_official 376:cb4d9db17537 673 tmp_Flag_EOC = ADC_FLAG_EOS;
mbed_official 376:cb4d9db17537 674 }
mbed_official 376:cb4d9db17537 675 /* If interruption after each conversion */
mbed_official 376:cb4d9db17537 676 else /* EOC_SINGLE_CONV */
mbed_official 376:cb4d9db17537 677 {
mbed_official 376:cb4d9db17537 678 tmp_Flag_EOC = (ADC_FLAG_EOC | ADC_FLAG_EOS);
mbed_official 376:cb4d9db17537 679 }
mbed_official 376:cb4d9db17537 680
mbed_official 376:cb4d9db17537 681 /* Get timeout */
mbed_official 376:cb4d9db17537 682 tickstart = HAL_GetTick();
mbed_official 376:cb4d9db17537 683
mbed_official 376:cb4d9db17537 684 /* Wait until End of Conversion flag is raised */
mbed_official 376:cb4d9db17537 685 while(HAL_IS_BIT_CLR(hadc->Instance->ISR, tmp_Flag_EOC))
mbed_official 376:cb4d9db17537 686 {
mbed_official 376:cb4d9db17537 687 /* Check for the Timeout */
mbed_official 376:cb4d9db17537 688 if(Timeout != HAL_MAX_DELAY)
mbed_official 376:cb4d9db17537 689 {
mbed_official 376:cb4d9db17537 690 if((Timeout == 0)|| ((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 376:cb4d9db17537 691 {
mbed_official 376:cb4d9db17537 692 hadc->State= HAL_ADC_STATE_TIMEOUT;
mbed_official 376:cb4d9db17537 693
mbed_official 376:cb4d9db17537 694 /* Process unlocked */
mbed_official 376:cb4d9db17537 695 __HAL_UNLOCK(hadc);
mbed_official 376:cb4d9db17537 696
mbed_official 376:cb4d9db17537 697 return HAL_TIMEOUT;
mbed_official 376:cb4d9db17537 698 }
mbed_official 376:cb4d9db17537 699 }
mbed_official 376:cb4d9db17537 700 }
mbed_official 376:cb4d9db17537 701
mbed_official 376:cb4d9db17537 702 /* Clear end of conversion flag of regular group if low power feature */
mbed_official 376:cb4d9db17537 703 /* "LowPowerAutoWait " is disabled, to not interfere with this feature */
mbed_official 376:cb4d9db17537 704 /* until data register is read using function HAL_ADC_GetValue(). */
mbed_official 376:cb4d9db17537 705 if (hadc->Init.LowPowerAutoWait == DISABLE)
mbed_official 376:cb4d9db17537 706 {
mbed_official 376:cb4d9db17537 707 /* Clear regular group conversion flag */
mbed_official 376:cb4d9db17537 708 __HAL_ADC_CLEAR_FLAG(hadc, (ADC_FLAG_EOC | ADC_FLAG_EOS));
mbed_official 376:cb4d9db17537 709 }
mbed_official 376:cb4d9db17537 710
mbed_official 376:cb4d9db17537 711 /* Change ADC state */
mbed_official 376:cb4d9db17537 712 hadc->State = HAL_ADC_STATE_EOC;
mbed_official 376:cb4d9db17537 713
mbed_official 376:cb4d9db17537 714 /* Return ADC state */
mbed_official 376:cb4d9db17537 715 return HAL_OK;
mbed_official 376:cb4d9db17537 716 }
mbed_official 376:cb4d9db17537 717
mbed_official 376:cb4d9db17537 718 /**
mbed_official 376:cb4d9db17537 719 * @brief Poll for conversion event.
mbed_official 376:cb4d9db17537 720 * @param hadc: ADC handle.
mbed_official 376:cb4d9db17537 721 * @param EventType: the ADC event type.
mbed_official 376:cb4d9db17537 722 * This parameter can be one of the following values:
mbed_official 376:cb4d9db17537 723 * @arg AWD_EVENT: ADC Analog watchdog event.
mbed_official 376:cb4d9db17537 724 * @arg OVR_EVENT: ADC Overrun event.
mbed_official 376:cb4d9db17537 725 * @param Timeout: Timeout value in millisecond.
mbed_official 376:cb4d9db17537 726 * @retval HAL status
mbed_official 376:cb4d9db17537 727 */
mbed_official 376:cb4d9db17537 728 HAL_StatusTypeDef HAL_ADC_PollForEvent(ADC_HandleTypeDef* hadc, uint32_t EventType, uint32_t Timeout)
mbed_official 376:cb4d9db17537 729 {
mbed_official 376:cb4d9db17537 730 uint32_t tickstart = 0;
mbed_official 376:cb4d9db17537 731
mbed_official 376:cb4d9db17537 732 /* Check the parameters */
mbed_official 376:cb4d9db17537 733 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 376:cb4d9db17537 734 assert_param(IS_ADC_EVENT_TYPE(EventType));
mbed_official 376:cb4d9db17537 735
mbed_official 376:cb4d9db17537 736 /* Get timeout */
mbed_official 376:cb4d9db17537 737 tickstart = HAL_GetTick();
mbed_official 376:cb4d9db17537 738
mbed_official 376:cb4d9db17537 739 /* Check selected event flag */
mbed_official 376:cb4d9db17537 740 while(!(__HAL_ADC_GET_FLAG(hadc,EventType)))
mbed_official 376:cb4d9db17537 741 {
mbed_official 376:cb4d9db17537 742 /* Check if timeout is disabled (set to infinite wait) */
mbed_official 376:cb4d9db17537 743 if(Timeout != HAL_MAX_DELAY)
mbed_official 376:cb4d9db17537 744 {
mbed_official 376:cb4d9db17537 745 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 376:cb4d9db17537 746 {
mbed_official 376:cb4d9db17537 747 /* Update ADC state machine to timeout */
mbed_official 376:cb4d9db17537 748 hadc->State = HAL_ADC_STATE_TIMEOUT;
mbed_official 376:cb4d9db17537 749
mbed_official 376:cb4d9db17537 750 /* Process unlocked */
mbed_official 376:cb4d9db17537 751 __HAL_UNLOCK(hadc);
mbed_official 376:cb4d9db17537 752
mbed_official 376:cb4d9db17537 753 return HAL_TIMEOUT;
mbed_official 376:cb4d9db17537 754 }
mbed_official 376:cb4d9db17537 755 }
mbed_official 376:cb4d9db17537 756 }
mbed_official 376:cb4d9db17537 757
mbed_official 376:cb4d9db17537 758 switch(EventType)
mbed_official 376:cb4d9db17537 759 {
mbed_official 376:cb4d9db17537 760 /* Check analog watchdog flag */
mbed_official 376:cb4d9db17537 761 case AWD_EVENT:
mbed_official 376:cb4d9db17537 762 /* Change ADC state */
mbed_official 376:cb4d9db17537 763 hadc->State = HAL_ADC_STATE_AWD;
mbed_official 376:cb4d9db17537 764
mbed_official 376:cb4d9db17537 765 /* Clear ADC analog watchdog flag */
mbed_official 376:cb4d9db17537 766 __HAL_ADC_CLEAR_FLAG(hadc, ADC_FLAG_AWD);
mbed_official 376:cb4d9db17537 767 break;
mbed_official 376:cb4d9db17537 768
mbed_official 376:cb4d9db17537 769 /* Case OVR_EVENT */
mbed_official 376:cb4d9db17537 770 default:
mbed_official 376:cb4d9db17537 771 /* Change ADC state */
mbed_official 376:cb4d9db17537 772 hadc->State = HAL_ADC_STATE_ERROR;
mbed_official 376:cb4d9db17537 773
mbed_official 376:cb4d9db17537 774 /* Clear ADC Overrun flag */
mbed_official 376:cb4d9db17537 775 __HAL_ADC_CLEAR_FLAG(hadc, ADC_FLAG_OVR);
mbed_official 376:cb4d9db17537 776 break;
mbed_official 376:cb4d9db17537 777 }
mbed_official 376:cb4d9db17537 778
mbed_official 376:cb4d9db17537 779 /* Return ADC state */
mbed_official 376:cb4d9db17537 780 return HAL_OK;
mbed_official 376:cb4d9db17537 781 }
mbed_official 376:cb4d9db17537 782
mbed_official 376:cb4d9db17537 783 /**
mbed_official 376:cb4d9db17537 784 * @brief Enables the interrupt and starts ADC conversion of regular channels.
mbed_official 376:cb4d9db17537 785 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 786 * the configuration information for the specified ADC.
mbed_official 376:cb4d9db17537 787 * @retval HAL status.
mbed_official 376:cb4d9db17537 788 */
mbed_official 376:cb4d9db17537 789 HAL_StatusTypeDef HAL_ADC_Start_IT(ADC_HandleTypeDef* hadc)
mbed_official 376:cb4d9db17537 790 {
mbed_official 376:cb4d9db17537 791 HAL_StatusTypeDef tmpHALStatus = HAL_OK;
mbed_official 376:cb4d9db17537 792
mbed_official 376:cb4d9db17537 793 /* Check the parameters */
mbed_official 376:cb4d9db17537 794 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 376:cb4d9db17537 795
mbed_official 376:cb4d9db17537 796 /* Process locked */
mbed_official 376:cb4d9db17537 797 __HAL_LOCK(hadc);
mbed_official 376:cb4d9db17537 798
mbed_official 376:cb4d9db17537 799 /* State machine update: Change ADC state */
mbed_official 376:cb4d9db17537 800 hadc->State = HAL_ADC_STATE_BUSY_REG;
mbed_official 376:cb4d9db17537 801
mbed_official 376:cb4d9db17537 802 /* Set ADC error code to none */
mbed_official 376:cb4d9db17537 803 hadc->ErrorCode = HAL_ADC_ERROR_NONE;
mbed_official 376:cb4d9db17537 804
mbed_official 376:cb4d9db17537 805 /* Enable the ADC peripheral */
mbed_official 376:cb4d9db17537 806 tmpHALStatus = ADC_Enable(hadc);
mbed_official 376:cb4d9db17537 807
mbed_official 376:cb4d9db17537 808 /* Start conversion if ADC is effectively enabled */
mbed_official 376:cb4d9db17537 809 if (tmpHALStatus != HAL_ERROR)
mbed_official 376:cb4d9db17537 810 {
mbed_official 376:cb4d9db17537 811 /* Enable ADC overrun interrupt */
mbed_official 376:cb4d9db17537 812 __HAL_ADC_ENABLE_IT(hadc, ADC_IT_OVR);
mbed_official 376:cb4d9db17537 813
mbed_official 376:cb4d9db17537 814 /* Enable ADC end of conversion interrupt */
mbed_official 376:cb4d9db17537 815 switch(hadc->Init.EOCSelection)
mbed_official 376:cb4d9db17537 816 {
mbed_official 376:cb4d9db17537 817 case EOC_SEQ_CONV:
mbed_official 376:cb4d9db17537 818 __HAL_ADC_DISABLE_IT(hadc, ADC_IT_EOC);
mbed_official 376:cb4d9db17537 819 __HAL_ADC_ENABLE_IT(hadc, ADC_IT_EOS);
mbed_official 376:cb4d9db17537 820 break;
mbed_official 376:cb4d9db17537 821 /* case EOC_SINGLE_CONV */
mbed_official 376:cb4d9db17537 822 default:
mbed_official 376:cb4d9db17537 823 __HAL_ADC_DISABLE_IT(hadc, ADC_IT_EOS);
mbed_official 376:cb4d9db17537 824 __HAL_ADC_ENABLE_IT(hadc, ADC_IT_EOC);
mbed_official 376:cb4d9db17537 825 break;
mbed_official 376:cb4d9db17537 826 }
mbed_official 376:cb4d9db17537 827
mbed_official 376:cb4d9db17537 828 /* ADC start conversion command */
mbed_official 376:cb4d9db17537 829 hadc->Instance->CR |= ADC_CR_ADSTART;
mbed_official 376:cb4d9db17537 830 }
mbed_official 376:cb4d9db17537 831
mbed_official 376:cb4d9db17537 832 else
mbed_official 376:cb4d9db17537 833 {
mbed_official 376:cb4d9db17537 834 return HAL_ERROR;
mbed_official 376:cb4d9db17537 835 }
mbed_official 376:cb4d9db17537 836
mbed_official 376:cb4d9db17537 837 /* Process unlocked */
mbed_official 376:cb4d9db17537 838 __HAL_UNLOCK(hadc);
mbed_official 376:cb4d9db17537 839
mbed_official 376:cb4d9db17537 840 /* Return function status */
mbed_official 376:cb4d9db17537 841 return HAL_OK;
mbed_official 376:cb4d9db17537 842 }
mbed_official 376:cb4d9db17537 843
mbed_official 376:cb4d9db17537 844 /**
mbed_official 376:cb4d9db17537 845 * @brief Stop ADC conversion of regular channels, disable interruptions
mbed_official 376:cb4d9db17537 846 * EOC/EOS/OVR, disable ADC peripheral.
mbed_official 376:cb4d9db17537 847 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 848 * the configuration information for the specified ADC.
mbed_official 376:cb4d9db17537 849 * @retval None
mbed_official 376:cb4d9db17537 850 */
mbed_official 376:cb4d9db17537 851 HAL_StatusTypeDef HAL_ADC_Stop_IT(ADC_HandleTypeDef* hadc)
mbed_official 376:cb4d9db17537 852 {
mbed_official 376:cb4d9db17537 853 HAL_StatusTypeDef tmpHALStatus = HAL_OK;
mbed_official 376:cb4d9db17537 854
mbed_official 376:cb4d9db17537 855 /* Process locked */
mbed_official 376:cb4d9db17537 856 __HAL_LOCK(hadc);
mbed_official 376:cb4d9db17537 857
mbed_official 376:cb4d9db17537 858 /* 1. Stop potential conversion ongoing (regular conversion) */
mbed_official 376:cb4d9db17537 859 tmpHALStatus = ADC_ConversionStop(hadc, REGULAR_GROUP);
mbed_official 376:cb4d9db17537 860
mbed_official 376:cb4d9db17537 861 /* 2. Disable ADC peripheral if conversions are effectively stopped */
mbed_official 376:cb4d9db17537 862 if (tmpHALStatus != HAL_ERROR)
mbed_official 376:cb4d9db17537 863 {
mbed_official 376:cb4d9db17537 864 /* Disable ADC interrupts */
mbed_official 376:cb4d9db17537 865 __HAL_ADC_DISABLE_IT(hadc, (ADC_IT_EOC | ADC_IT_EOS | ADC_IT_OVR));
mbed_official 376:cb4d9db17537 866
mbed_official 376:cb4d9db17537 867 /* Disable the ADC peripheral */
mbed_official 376:cb4d9db17537 868 ADC_Disable(hadc);
mbed_official 376:cb4d9db17537 869
mbed_official 376:cb4d9db17537 870 /* Check if ADC is effectively disabled */
mbed_official 376:cb4d9db17537 871 if (hadc->State != HAL_ADC_STATE_ERROR)
mbed_official 376:cb4d9db17537 872 {
mbed_official 376:cb4d9db17537 873 /* Change ADC state */
mbed_official 376:cb4d9db17537 874 hadc->State = HAL_ADC_STATE_READY;
mbed_official 376:cb4d9db17537 875 }
mbed_official 376:cb4d9db17537 876 else
mbed_official 376:cb4d9db17537 877 {
mbed_official 376:cb4d9db17537 878 return HAL_ERROR;
mbed_official 376:cb4d9db17537 879 }
mbed_official 376:cb4d9db17537 880 }
mbed_official 376:cb4d9db17537 881 else
mbed_official 376:cb4d9db17537 882 {
mbed_official 376:cb4d9db17537 883 return HAL_ERROR;
mbed_official 376:cb4d9db17537 884 }
mbed_official 376:cb4d9db17537 885
mbed_official 376:cb4d9db17537 886
mbed_official 376:cb4d9db17537 887 /* Process unlocked */
mbed_official 376:cb4d9db17537 888 __HAL_UNLOCK(hadc);
mbed_official 376:cb4d9db17537 889
mbed_official 376:cb4d9db17537 890 /* Return function status */
mbed_official 376:cb4d9db17537 891 return HAL_OK;
mbed_official 376:cb4d9db17537 892 }
mbed_official 376:cb4d9db17537 893
mbed_official 376:cb4d9db17537 894 /**
mbed_official 376:cb4d9db17537 895 * @brief Handles ADC interrupt request
mbed_official 376:cb4d9db17537 896 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 897 * the configuration information for the specified ADC.
mbed_official 376:cb4d9db17537 898 * @retval None
mbed_official 376:cb4d9db17537 899 */
mbed_official 376:cb4d9db17537 900 void HAL_ADC_IRQHandler(ADC_HandleTypeDef* hadc)
mbed_official 376:cb4d9db17537 901 {
mbed_official 376:cb4d9db17537 902 /* Check the parameters */
mbed_official 376:cb4d9db17537 903 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 376:cb4d9db17537 904 assert_param(IS_ADC_EOC_SELECTION(hadc->Init.EOCSelection));
mbed_official 376:cb4d9db17537 905
mbed_official 376:cb4d9db17537 906
mbed_official 376:cb4d9db17537 907 /* Check End of Conversion flag for regular channels */
mbed_official 376:cb4d9db17537 908 if( (__HAL_ADC_GET_FLAG(hadc, ADC_FLAG_EOC) && __HAL_ADC_GET_IT_SOURCE(hadc, ADC_IT_EOC)) || \
mbed_official 376:cb4d9db17537 909 (__HAL_ADC_GET_FLAG(hadc, ADC_FLAG_EOS) && __HAL_ADC_GET_IT_SOURCE(hadc, ADC_IT_EOS)) )
mbed_official 376:cb4d9db17537 910 {
mbed_official 376:cb4d9db17537 911 /* Change ADC state */
mbed_official 376:cb4d9db17537 912 hadc->State = HAL_ADC_STATE_EOC;
mbed_official 376:cb4d9db17537 913
mbed_official 376:cb4d9db17537 914
mbed_official 376:cb4d9db17537 915 /* Disable interruption if no further conversion upcoming by continuous mode or external trigger */
mbed_official 376:cb4d9db17537 916 if((hadc->Init.ContinuousConvMode == DISABLE) && \
mbed_official 376:cb4d9db17537 917 (hadc->Init.ExternalTrigConvEdge == ADC_EXTERNALTRIG_EDGE_NONE)
mbed_official 376:cb4d9db17537 918 )
mbed_official 376:cb4d9db17537 919 {
mbed_official 376:cb4d9db17537 920 /* Allowed to modify bits ADC_IT_EOC/ADC_IT_EOS only if bit ADSTART==0 (no conversion on going) */
mbed_official 376:cb4d9db17537 921 if (HAL_IS_BIT_CLR(hadc->Instance->CR, ADC_CR_ADSTART))
mbed_official 376:cb4d9db17537 922 {
mbed_official 376:cb4d9db17537 923 /* Cases of interruption after each conversion or after each sequence */
mbed_official 376:cb4d9db17537 924 /* If interruption after each sequence */
mbed_official 376:cb4d9db17537 925 if (hadc->Init.EOCSelection == EOC_SEQ_CONV)
mbed_official 376:cb4d9db17537 926 {
mbed_official 376:cb4d9db17537 927 /* If End of Sequence is reached, disable interrupts */
mbed_official 376:cb4d9db17537 928 if( __HAL_ADC_GET_FLAG(hadc, ADC_FLAG_EOS) )
mbed_official 376:cb4d9db17537 929 {
mbed_official 376:cb4d9db17537 930 /* DISABLE ADC end of sequence conversion interrupt */
mbed_official 376:cb4d9db17537 931 /* DISABLE ADC overrun interrupt */
mbed_official 376:cb4d9db17537 932 __HAL_ADC_DISABLE_IT(hadc, ADC_IT_EOC | ADC_IT_EOS | ADC_IT_OVR);
mbed_official 376:cb4d9db17537 933 }
mbed_official 376:cb4d9db17537 934 }
mbed_official 376:cb4d9db17537 935 /* If interruption after each conversion */
mbed_official 376:cb4d9db17537 936 else
mbed_official 376:cb4d9db17537 937 {
mbed_official 376:cb4d9db17537 938 /* DISABLE ADC end of single conversion interrupt */
mbed_official 376:cb4d9db17537 939 /* DISABLE ADC overrun interrupt */
mbed_official 376:cb4d9db17537 940 __HAL_ADC_DISABLE_IT(hadc, ADC_IT_EOC | ADC_IT_OVR);
mbed_official 376:cb4d9db17537 941 }
mbed_official 376:cb4d9db17537 942 }
mbed_official 376:cb4d9db17537 943 else
mbed_official 376:cb4d9db17537 944 {
mbed_official 376:cb4d9db17537 945 /* Change ADC state to error state */
mbed_official 376:cb4d9db17537 946 hadc->State = HAL_ADC_STATE_ERROR;
mbed_official 376:cb4d9db17537 947 }
mbed_official 376:cb4d9db17537 948 }
mbed_official 376:cb4d9db17537 949
mbed_official 376:cb4d9db17537 950 /* Conversion complete callback */
mbed_official 376:cb4d9db17537 951 /* Note: into callback, to determine if callback has been triggered from EOC or EOS, */
mbed_official 376:cb4d9db17537 952 /* it is possible to use: if( __HAL_ADC_GET_FLAG(hadc, ADC_FLAG_EOS)) */
mbed_official 376:cb4d9db17537 953 HAL_ADC_ConvCpltCallback(hadc);
mbed_official 376:cb4d9db17537 954
mbed_official 376:cb4d9db17537 955 /* Clear regular channels conversion flag */
mbed_official 376:cb4d9db17537 956 if (hadc->Init.LowPowerAutoWait != ENABLE)
mbed_official 376:cb4d9db17537 957 {
mbed_official 376:cb4d9db17537 958 __HAL_ADC_CLEAR_FLAG(hadc, (ADC_FLAG_EOC | ADC_FLAG_EOS) );
mbed_official 376:cb4d9db17537 959 }
mbed_official 376:cb4d9db17537 960 }
mbed_official 376:cb4d9db17537 961
mbed_official 376:cb4d9db17537 962
mbed_official 376:cb4d9db17537 963 /* Check Analog watchdog flags */
mbed_official 376:cb4d9db17537 964 if( (__HAL_ADC_GET_FLAG(hadc, ADC_FLAG_AWD) && __HAL_ADC_GET_IT_SOURCE(hadc, ADC_IT_AWD)))
mbed_official 376:cb4d9db17537 965 {
mbed_official 376:cb4d9db17537 966 /* Change ADC state */
mbed_official 376:cb4d9db17537 967 hadc->State = HAL_ADC_STATE_AWD;
mbed_official 376:cb4d9db17537 968
mbed_official 376:cb4d9db17537 969 /* Level out of window callback */
mbed_official 376:cb4d9db17537 970 HAL_ADC_LevelOutOfWindowCallback(hadc);
mbed_official 376:cb4d9db17537 971
mbed_official 376:cb4d9db17537 972 /* Clear ADC Analog watchdog flag */
mbed_official 376:cb4d9db17537 973 __HAL_ADC_CLEAR_FLAG(hadc, ADC_FLAG_AWD);
mbed_official 376:cb4d9db17537 974 }
mbed_official 376:cb4d9db17537 975
mbed_official 376:cb4d9db17537 976 /* Check Overrun flag */
mbed_official 376:cb4d9db17537 977 if(__HAL_ADC_GET_FLAG(hadc, ADC_FLAG_OVR) && __HAL_ADC_GET_IT_SOURCE(hadc, ADC_IT_OVR))
mbed_official 376:cb4d9db17537 978 {
mbed_official 376:cb4d9db17537 979 /* Change ADC state to overrun state */
mbed_official 376:cb4d9db17537 980 hadc->State = HAL_ADC_STATE_ERROR;
mbed_official 376:cb4d9db17537 981
mbed_official 376:cb4d9db17537 982 /* Set ADC error code to overrun */
mbed_official 376:cb4d9db17537 983 hadc->ErrorCode |= HAL_ADC_ERROR_OVR;
mbed_official 376:cb4d9db17537 984
mbed_official 376:cb4d9db17537 985 /* Clear the Overrun flag */
mbed_official 376:cb4d9db17537 986 __HAL_ADC_CLEAR_FLAG(hadc,ADC_FLAG_OVR);
mbed_official 376:cb4d9db17537 987
mbed_official 376:cb4d9db17537 988 /* Error callback */
mbed_official 376:cb4d9db17537 989 HAL_ADC_ErrorCallback(hadc);
mbed_official 376:cb4d9db17537 990 }
mbed_official 376:cb4d9db17537 991 }
mbed_official 376:cb4d9db17537 992
mbed_official 376:cb4d9db17537 993 /**
mbed_official 376:cb4d9db17537 994 * @brief Enables ADC DMA request after last transfer (Single-ADC mode) and enables ADC peripheral
mbed_official 376:cb4d9db17537 995 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 996 * the configuration information for the specified ADC.
mbed_official 376:cb4d9db17537 997 * @param pData: The destination Buffer address.
mbed_official 376:cb4d9db17537 998 * @param Length: The length of data to be transferred from ADC peripheral to memory.
mbed_official 376:cb4d9db17537 999 * @retval None
mbed_official 376:cb4d9db17537 1000 */
mbed_official 376:cb4d9db17537 1001 HAL_StatusTypeDef HAL_ADC_Start_DMA(ADC_HandleTypeDef* hadc, uint32_t* pData, uint32_t Length)
mbed_official 376:cb4d9db17537 1002 {
mbed_official 376:cb4d9db17537 1003 HAL_StatusTypeDef tmpHALStatus = HAL_OK;
mbed_official 376:cb4d9db17537 1004
mbed_official 376:cb4d9db17537 1005 /* Check the parameters */
mbed_official 376:cb4d9db17537 1006 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 376:cb4d9db17537 1007
mbed_official 376:cb4d9db17537 1008 /* Process locked */
mbed_official 376:cb4d9db17537 1009 __HAL_LOCK(hadc);
mbed_official 376:cb4d9db17537 1010
mbed_official 376:cb4d9db17537 1011 /* Change ADC state */
mbed_official 376:cb4d9db17537 1012 hadc->State = HAL_ADC_STATE_BUSY_REG;
mbed_official 376:cb4d9db17537 1013
mbed_official 376:cb4d9db17537 1014 /* Set ADC error code to none */
mbed_official 376:cb4d9db17537 1015 hadc->ErrorCode = HAL_ADC_ERROR_NONE;
mbed_official 376:cb4d9db17537 1016
mbed_official 376:cb4d9db17537 1017 /* Enable ADC */
mbed_official 376:cb4d9db17537 1018 tmpHALStatus = ADC_Enable(hadc);
mbed_official 376:cb4d9db17537 1019
mbed_official 376:cb4d9db17537 1020 /* Start conversion if ADC is effectively enabled */
mbed_official 376:cb4d9db17537 1021 if (tmpHALStatus != HAL_ERROR)
mbed_official 376:cb4d9db17537 1022 {
mbed_official 376:cb4d9db17537 1023 /* Enable ADC DMA mode */
mbed_official 376:cb4d9db17537 1024 hadc->Instance->CFGR1 |= ADC_CFGR1_DMAEN;
mbed_official 376:cb4d9db17537 1025
mbed_official 376:cb4d9db17537 1026 /* Set the DMA transfer complete callback */
mbed_official 376:cb4d9db17537 1027 hadc->DMA_Handle->XferCpltCallback = ADC_DMAConvCplt;
mbed_official 376:cb4d9db17537 1028
mbed_official 376:cb4d9db17537 1029 /* Set the DMA half transfer complete callback */
mbed_official 376:cb4d9db17537 1030 hadc->DMA_Handle->XferHalfCpltCallback = ADC_DMAHalfConvCplt;
mbed_official 376:cb4d9db17537 1031
mbed_official 376:cb4d9db17537 1032 /* Set the DMA error callback */
mbed_official 376:cb4d9db17537 1033 hadc->DMA_Handle->XferErrorCallback = ADC_DMAError;
mbed_official 376:cb4d9db17537 1034
mbed_official 376:cb4d9db17537 1035 /* Manage ADC and DMA start: ADC overrun interruption, DMA start,
mbed_official 376:cb4d9db17537 1036 ADC start (in case of SW start) */
mbed_official 376:cb4d9db17537 1037
mbed_official 376:cb4d9db17537 1038 /* Enable ADC overrun interrupt */
mbed_official 376:cb4d9db17537 1039 __HAL_ADC_ENABLE_IT(hadc, ADC_IT_OVR);
mbed_official 376:cb4d9db17537 1040
mbed_official 376:cb4d9db17537 1041 /* Enable the DMA Stream */
mbed_official 376:cb4d9db17537 1042 HAL_DMA_Start_IT(hadc->DMA_Handle, (uint32_t)&hadc->Instance->DR, (uint32_t)pData, Length);
mbed_official 376:cb4d9db17537 1043
mbed_official 376:cb4d9db17537 1044
mbed_official 376:cb4d9db17537 1045 /* ADC start conversion command */
mbed_official 376:cb4d9db17537 1046 hadc->Instance->CR |= ADC_CR_ADSTART;
mbed_official 376:cb4d9db17537 1047 }
mbed_official 376:cb4d9db17537 1048
mbed_official 376:cb4d9db17537 1049 /* Process unlocked */
mbed_official 376:cb4d9db17537 1050 __HAL_UNLOCK(hadc);
mbed_official 376:cb4d9db17537 1051
mbed_official 376:cb4d9db17537 1052 /* Return function status */
mbed_official 376:cb4d9db17537 1053 return HAL_OK;
mbed_official 376:cb4d9db17537 1054 }
mbed_official 376:cb4d9db17537 1055
mbed_official 376:cb4d9db17537 1056 /**
mbed_official 376:cb4d9db17537 1057 * @brief Disable ADC DMA (Single-ADC mode), disable ADC peripheral
mbed_official 376:cb4d9db17537 1058 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1059 * the configuration information for the specified ADC.
mbed_official 376:cb4d9db17537 1060 * @retval None
mbed_official 376:cb4d9db17537 1061 */
mbed_official 376:cb4d9db17537 1062 HAL_StatusTypeDef HAL_ADC_Stop_DMA(ADC_HandleTypeDef* hadc)
mbed_official 376:cb4d9db17537 1063 {
mbed_official 376:cb4d9db17537 1064 HAL_StatusTypeDef tmpHALStatus = HAL_OK;
mbed_official 376:cb4d9db17537 1065
mbed_official 376:cb4d9db17537 1066 /* Process locked */
mbed_official 376:cb4d9db17537 1067 __HAL_LOCK(hadc);
mbed_official 376:cb4d9db17537 1068
mbed_official 376:cb4d9db17537 1069 /* 1. Stop potential conversion ongoing (regular conversion) */
mbed_official 376:cb4d9db17537 1070 tmpHALStatus = ADC_ConversionStop(hadc, REGULAR_GROUP);
mbed_official 376:cb4d9db17537 1071
mbed_official 376:cb4d9db17537 1072 /* 2. Disable ADC peripheral if conversions are effectively stopped */
mbed_official 376:cb4d9db17537 1073 if (tmpHALStatus != HAL_ERROR)
mbed_official 376:cb4d9db17537 1074 {
mbed_official 376:cb4d9db17537 1075 /* Disable ADC DMA (ADC DMA configuration ADC_CFGR_DMACFG is kept) */
mbed_official 376:cb4d9db17537 1076 hadc->Instance->CFGR1 &= ~ADC_CFGR1_DMAEN;
mbed_official 376:cb4d9db17537 1077
mbed_official 376:cb4d9db17537 1078 /* Disable the DMA Stream */
mbed_official 376:cb4d9db17537 1079 if (HAL_DMA_Abort(hadc->DMA_Handle) != HAL_OK)
mbed_official 376:cb4d9db17537 1080 {
mbed_official 376:cb4d9db17537 1081 /* Update ADC state machine to error */
mbed_official 376:cb4d9db17537 1082 hadc->State = HAL_ADC_STATE_ERROR;
mbed_official 376:cb4d9db17537 1083
mbed_official 376:cb4d9db17537 1084 /* Process unlocked */
mbed_official 376:cb4d9db17537 1085 __HAL_UNLOCK(hadc);
mbed_official 376:cb4d9db17537 1086
mbed_official 376:cb4d9db17537 1087 return HAL_ERROR;
mbed_official 376:cb4d9db17537 1088 }
mbed_official 376:cb4d9db17537 1089
mbed_official 376:cb4d9db17537 1090 /* Disable ADC overrun interrupt */
mbed_official 376:cb4d9db17537 1091 __HAL_ADC_DISABLE_IT(hadc, ADC_IT_OVR);
mbed_official 376:cb4d9db17537 1092
mbed_official 376:cb4d9db17537 1093 /* Disable the ADC peripheral */
mbed_official 376:cb4d9db17537 1094 ADC_Disable(hadc);
mbed_official 376:cb4d9db17537 1095
mbed_official 376:cb4d9db17537 1096 /* Check if ADC is effectively disabled */
mbed_official 376:cb4d9db17537 1097 if (hadc->State != HAL_ADC_STATE_ERROR)
mbed_official 376:cb4d9db17537 1098 {
mbed_official 376:cb4d9db17537 1099 /* Change ADC state */
mbed_official 376:cb4d9db17537 1100 hadc->State = HAL_ADC_STATE_READY;
mbed_official 376:cb4d9db17537 1101 }
mbed_official 376:cb4d9db17537 1102 else
mbed_official 376:cb4d9db17537 1103 {
mbed_official 376:cb4d9db17537 1104 return HAL_ERROR;
mbed_official 376:cb4d9db17537 1105 }
mbed_official 376:cb4d9db17537 1106 }
mbed_official 376:cb4d9db17537 1107 else
mbed_official 376:cb4d9db17537 1108 {
mbed_official 376:cb4d9db17537 1109 return HAL_ERROR;
mbed_official 376:cb4d9db17537 1110 }
mbed_official 376:cb4d9db17537 1111
mbed_official 376:cb4d9db17537 1112 /* Process unlocked */
mbed_official 376:cb4d9db17537 1113 __HAL_UNLOCK(hadc);
mbed_official 376:cb4d9db17537 1114
mbed_official 376:cb4d9db17537 1115 /* Return function status */
mbed_official 376:cb4d9db17537 1116 return HAL_OK;
mbed_official 376:cb4d9db17537 1117 }
mbed_official 376:cb4d9db17537 1118
mbed_official 376:cb4d9db17537 1119 /**
mbed_official 376:cb4d9db17537 1120 * @brief Gets the converted value from data register of regular channel.
mbed_official 376:cb4d9db17537 1121 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1122 * the configuration information for the specified ADC.
mbed_official 376:cb4d9db17537 1123 * @retval Converted value
mbed_official 376:cb4d9db17537 1124 */
mbed_official 376:cb4d9db17537 1125 uint32_t HAL_ADC_GetValue(ADC_HandleTypeDef* hadc)
mbed_official 376:cb4d9db17537 1126 {
mbed_official 376:cb4d9db17537 1127 /* Return the selected ADC converted value */
mbed_official 376:cb4d9db17537 1128 return hadc->Instance->DR;
mbed_official 376:cb4d9db17537 1129 }
mbed_official 376:cb4d9db17537 1130
mbed_official 376:cb4d9db17537 1131 /**
mbed_official 376:cb4d9db17537 1132 * @brief Regular conversion complete callback in non blocking mode
mbed_official 376:cb4d9db17537 1133 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1134 * the configuration information for the specified ADC.
mbed_official 376:cb4d9db17537 1135 * @retval None
mbed_official 376:cb4d9db17537 1136 */
mbed_official 376:cb4d9db17537 1137 __weak void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc)
mbed_official 376:cb4d9db17537 1138 {
mbed_official 376:cb4d9db17537 1139 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 376:cb4d9db17537 1140 the HAL_ADC_ConvCpltCallback could be implemented in the user file
mbed_official 376:cb4d9db17537 1141 */
mbed_official 376:cb4d9db17537 1142 }
mbed_official 376:cb4d9db17537 1143
mbed_official 376:cb4d9db17537 1144 /**
mbed_official 376:cb4d9db17537 1145 * @brief Regular conversion half DMA transfer callback in non blocking mode
mbed_official 376:cb4d9db17537 1146 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1147 * the configuration information for the specified ADC.
mbed_official 376:cb4d9db17537 1148 * @retval None
mbed_official 376:cb4d9db17537 1149 */
mbed_official 376:cb4d9db17537 1150 __weak void HAL_ADC_ConvHalfCpltCallback(ADC_HandleTypeDef* hadc)
mbed_official 376:cb4d9db17537 1151 {
mbed_official 376:cb4d9db17537 1152 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 376:cb4d9db17537 1153 the HAL_ADC_ConvHalfCpltCallback could be implemented in the user file
mbed_official 376:cb4d9db17537 1154 */
mbed_official 376:cb4d9db17537 1155 }
mbed_official 376:cb4d9db17537 1156
mbed_official 376:cb4d9db17537 1157 /**
mbed_official 376:cb4d9db17537 1158 * @brief Analog watchdog callback in non blocking mode
mbed_official 376:cb4d9db17537 1159 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1160 * the configuration information for the specified ADC.
mbed_official 376:cb4d9db17537 1161 * @retval None
mbed_official 376:cb4d9db17537 1162 */
mbed_official 376:cb4d9db17537 1163 __weak void HAL_ADC_LevelOutOfWindowCallback(ADC_HandleTypeDef* hadc)
mbed_official 376:cb4d9db17537 1164 {
mbed_official 376:cb4d9db17537 1165 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 376:cb4d9db17537 1166 the HAL_ADC_LevelOoutOfWindowCallback could be implemented in the user file
mbed_official 376:cb4d9db17537 1167 */
mbed_official 376:cb4d9db17537 1168 }
mbed_official 376:cb4d9db17537 1169
mbed_official 376:cb4d9db17537 1170 /**
mbed_official 376:cb4d9db17537 1171 * @brief Error ADC callback.
mbed_official 376:cb4d9db17537 1172 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1173 * the configuration information for the specified ADC.
mbed_official 376:cb4d9db17537 1174 * @retval None
mbed_official 376:cb4d9db17537 1175 */
mbed_official 376:cb4d9db17537 1176 __weak void HAL_ADC_ErrorCallback(ADC_HandleTypeDef *hadc)
mbed_official 376:cb4d9db17537 1177 {
mbed_official 376:cb4d9db17537 1178 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 376:cb4d9db17537 1179 the HAL_ADC_ErrorCallback could be implemented in the user file
mbed_official 376:cb4d9db17537 1180 */
mbed_official 376:cb4d9db17537 1181 }
mbed_official 376:cb4d9db17537 1182
mbed_official 376:cb4d9db17537 1183 /**
mbed_official 376:cb4d9db17537 1184 * @}
mbed_official 376:cb4d9db17537 1185 */
mbed_official 376:cb4d9db17537 1186
mbed_official 376:cb4d9db17537 1187 /** @defgroup ADC_Group3 Peripheral Control functions
mbed_official 376:cb4d9db17537 1188 * @brief Peripheral Control functions
mbed_official 376:cb4d9db17537 1189 *
mbed_official 376:cb4d9db17537 1190 @verbatim
mbed_official 376:cb4d9db17537 1191 ===============================================================================
mbed_official 376:cb4d9db17537 1192 ##### Peripheral Control functions #####
mbed_official 376:cb4d9db17537 1193 ===============================================================================
mbed_official 376:cb4d9db17537 1194 [..] This section provides functions allowing to:
mbed_official 376:cb4d9db17537 1195 (+) Configure channels.
mbed_official 376:cb4d9db17537 1196 (+) Configure the analog watch dog.
mbed_official 376:cb4d9db17537 1197
mbed_official 376:cb4d9db17537 1198 @endverbatim
mbed_official 376:cb4d9db17537 1199 * @{
mbed_official 376:cb4d9db17537 1200 */
mbed_official 376:cb4d9db17537 1201
mbed_official 376:cb4d9db17537 1202
mbed_official 376:cb4d9db17537 1203 /**
mbed_official 376:cb4d9db17537 1204 * @brief Configures the selected ADC regular channel: sampling time,
mbed_official 376:cb4d9db17537 1205 * offset,.
mbed_official 376:cb4d9db17537 1206 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1207 * the configuration information for the specified ADC.
mbed_official 376:cb4d9db17537 1208 * @param sConfig: ADC regular channel configuration structure.
mbed_official 376:cb4d9db17537 1209 * @retval HAL status
mbed_official 376:cb4d9db17537 1210 */
mbed_official 376:cb4d9db17537 1211 HAL_StatusTypeDef HAL_ADC_ConfigChannel(ADC_HandleTypeDef* hadc, ADC_ChannelConfTypeDef* sConfig)
mbed_official 376:cb4d9db17537 1212 {
mbed_official 376:cb4d9db17537 1213
mbed_official 376:cb4d9db17537 1214 /* Check the parameters */
mbed_official 376:cb4d9db17537 1215 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 376:cb4d9db17537 1216 assert_param(IS_ADC_CHANNEL(sConfig->Channel));
mbed_official 376:cb4d9db17537 1217
mbed_official 376:cb4d9db17537 1218 /* Process locked */
mbed_official 376:cb4d9db17537 1219 __HAL_LOCK(hadc);
mbed_official 376:cb4d9db17537 1220
mbed_official 376:cb4d9db17537 1221 /* Enable selected channels */
mbed_official 376:cb4d9db17537 1222 hadc->Instance->CHSELR |= (uint32_t)(sConfig->Channel & ADC_CHANNEL_MASK);
mbed_official 376:cb4d9db17537 1223
mbed_official 376:cb4d9db17537 1224 /* Management of internal measurement channels: Vlcd/VrefInt/TempSensor */
mbed_official 376:cb4d9db17537 1225 /* internal measurement paths enable: If internal channel selected, enable */
mbed_official 376:cb4d9db17537 1226 /* dedicated internal buffers and path. */
mbed_official 376:cb4d9db17537 1227
mbed_official 376:cb4d9db17537 1228 /* If Temperature sensor channel is selected, then enable the internal */
mbed_official 376:cb4d9db17537 1229 /* buffers and path */
mbed_official 376:cb4d9db17537 1230 if (((sConfig->Channel & ADC_CHANNEL_MASK) & ADC_CHANNEL_TEMPSENSOR ) == (ADC_CHANNEL_TEMPSENSOR & ADC_CHANNEL_MASK))
mbed_official 376:cb4d9db17537 1231 {
mbed_official 376:cb4d9db17537 1232 ADC->CCR |= ADC_CCR_TSEN;
mbed_official 376:cb4d9db17537 1233 }
mbed_official 376:cb4d9db17537 1234
mbed_official 376:cb4d9db17537 1235 /* If VRefInt channel is selected, then enable the internal buffers and path */
mbed_official 376:cb4d9db17537 1236 if (((sConfig->Channel & ADC_CHANNEL_MASK) & ADC_CHANNEL_VREFINT) == (ADC_CHANNEL_VREFINT & ADC_CHANNEL_MASK))
mbed_official 376:cb4d9db17537 1237 {
mbed_official 376:cb4d9db17537 1238 ADC->CCR |= ADC_CCR_VREFEN;
mbed_official 376:cb4d9db17537 1239 }
mbed_official 376:cb4d9db17537 1240
mbed_official 376:cb4d9db17537 1241 /* If Vlcd channel is selected, then enable the internal buffers and path */
mbed_official 376:cb4d9db17537 1242 if (((sConfig->Channel & ADC_CHANNEL_MASK) & ADC_CHANNEL_VLCD) == (ADC_CHANNEL_VLCD & ADC_CHANNEL_MASK))
mbed_official 376:cb4d9db17537 1243 {
mbed_official 376:cb4d9db17537 1244 ADC->CCR |= ADC_CCR_VLCDEN;
mbed_official 376:cb4d9db17537 1245 }
mbed_official 376:cb4d9db17537 1246
mbed_official 376:cb4d9db17537 1247 /* Process unlocked */
mbed_official 376:cb4d9db17537 1248 __HAL_UNLOCK(hadc);
mbed_official 376:cb4d9db17537 1249
mbed_official 376:cb4d9db17537 1250 /* Return function status */
mbed_official 376:cb4d9db17537 1251 return HAL_OK;
mbed_official 376:cb4d9db17537 1252 }
mbed_official 376:cb4d9db17537 1253
mbed_official 376:cb4d9db17537 1254 /**
mbed_official 376:cb4d9db17537 1255 * @brief Configures the analog watchdog.
mbed_official 376:cb4d9db17537 1256 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1257 * the configuration information for the specified ADC.
mbed_official 376:cb4d9db17537 1258 * @param AnalogWDGConfig : pointer to an ADC_AnalogWDGConfTypeDef structure
mbed_official 376:cb4d9db17537 1259 * that contains the configuration information of ADC analog watchdog.
mbed_official 376:cb4d9db17537 1260 * @retval HAL status
mbed_official 376:cb4d9db17537 1261 */
mbed_official 376:cb4d9db17537 1262 HAL_StatusTypeDef HAL_ADC_AnalogWDGConfig(ADC_HandleTypeDef* hadc, ADC_AnalogWDGConfTypeDef* AnalogWDGConfig)
mbed_official 376:cb4d9db17537 1263 {
mbed_official 376:cb4d9db17537 1264 uint32_t tmpAWDHighThresholdShifted;
mbed_official 376:cb4d9db17537 1265 uint32_t tmpAWDLowThresholdShifted;
mbed_official 376:cb4d9db17537 1266
mbed_official 376:cb4d9db17537 1267 /* Check the parameters */
mbed_official 376:cb4d9db17537 1268 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 376:cb4d9db17537 1269 assert_param(IS_ADC_ANALOG_WATCHDOG_MODE(AnalogWDGConfig->WatchdogMode));
mbed_official 376:cb4d9db17537 1270 assert_param(IS_ADC_CHANNEL(AnalogWDGConfig->Channel));
mbed_official 376:cb4d9db17537 1271 assert_param(IS_FUNCTIONAL_STATE(AnalogWDGConfig->ITMode));
mbed_official 376:cb4d9db17537 1272
mbed_official 376:cb4d9db17537 1273 assert_param(IS_ADC_RANGE(__HAL_ADC_GET_RESOLUTION(hadc), AnalogWDGConfig->HighThreshold));
mbed_official 376:cb4d9db17537 1274 assert_param(IS_ADC_RANGE(__HAL_ADC_GET_RESOLUTION(hadc), AnalogWDGConfig->LowThreshold));
mbed_official 376:cb4d9db17537 1275
mbed_official 376:cb4d9db17537 1276 /* Process locked */
mbed_official 376:cb4d9db17537 1277 __HAL_LOCK(hadc);
mbed_official 376:cb4d9db17537 1278
mbed_official 376:cb4d9db17537 1279 /* Configure ADC Analog watchdog interrupt */
mbed_official 376:cb4d9db17537 1280 if(AnalogWDGConfig->ITMode == ENABLE)
mbed_official 376:cb4d9db17537 1281 {
mbed_official 376:cb4d9db17537 1282 /* Enable the ADC Analog watchdog interrupt */
mbed_official 376:cb4d9db17537 1283 __HAL_ADC_ENABLE_IT(hadc, ADC_IT_AWD);
mbed_official 376:cb4d9db17537 1284 }
mbed_official 376:cb4d9db17537 1285 else
mbed_official 376:cb4d9db17537 1286 {
mbed_official 376:cb4d9db17537 1287 /* Disable the ADC Analog watchdog interrupt */
mbed_official 376:cb4d9db17537 1288 __HAL_ADC_DISABLE_IT(hadc, ADC_IT_AWD);
mbed_official 376:cb4d9db17537 1289 }
mbed_official 376:cb4d9db17537 1290
mbed_official 376:cb4d9db17537 1291 /* Configuration of analog watchdog: */
mbed_official 376:cb4d9db17537 1292 /* - Set the analog watchdog mode */
mbed_official 376:cb4d9db17537 1293 /* - Set the Analog watchdog channel (is not used if watchdog */
mbed_official 376:cb4d9db17537 1294 /* mode "all channels": ADC_CFGR1_AWD1SGL=0) */
mbed_official 376:cb4d9db17537 1295 hadc->Instance->CFGR1 &= ~( ADC_CFGR1_AWDSGL |
mbed_official 376:cb4d9db17537 1296 ADC_CFGR1_AWDEN |
mbed_official 376:cb4d9db17537 1297 ADC_CFGR1_AWDCH );
mbed_official 376:cb4d9db17537 1298
mbed_official 376:cb4d9db17537 1299 hadc->Instance->CFGR1 |= ( AnalogWDGConfig->WatchdogMode |
mbed_official 376:cb4d9db17537 1300 (AnalogWDGConfig->Channel & ADC_CHANNEL_AWD_MASK));
mbed_official 376:cb4d9db17537 1301
mbed_official 376:cb4d9db17537 1302
mbed_official 376:cb4d9db17537 1303 /* Shift the offset in function of the selected ADC resolution: Thresholds */
mbed_official 376:cb4d9db17537 1304 /* have to be left-aligned on bit 11, the LSB (right bits) are set to 0 */
mbed_official 376:cb4d9db17537 1305 tmpAWDHighThresholdShifted = __HAL_ADC_AWD1Threshold_shift_resolution(hadc, AnalogWDGConfig->HighThreshold);
mbed_official 376:cb4d9db17537 1306 tmpAWDLowThresholdShifted = __HAL_ADC_AWD1Threshold_shift_resolution(hadc, AnalogWDGConfig->LowThreshold);
mbed_official 376:cb4d9db17537 1307
mbed_official 376:cb4d9db17537 1308 /* Clear High & Low high thresholds */
mbed_official 376:cb4d9db17537 1309 hadc->Instance->TR &= (uint32_t) ~ (ADC_TR_HT | ADC_TR_LT);
mbed_official 376:cb4d9db17537 1310
mbed_official 376:cb4d9db17537 1311 /* Set the high threshold */
mbed_official 376:cb4d9db17537 1312 hadc->Instance->TR = __HAL_ADC_TRx_HighThreshold (tmpAWDHighThresholdShifted);
mbed_official 376:cb4d9db17537 1313 /* Set the low threshold */
mbed_official 376:cb4d9db17537 1314 hadc->Instance->TR |= tmpAWDLowThresholdShifted;
mbed_official 376:cb4d9db17537 1315
mbed_official 376:cb4d9db17537 1316 /* Process unlocked */
mbed_official 376:cb4d9db17537 1317 __HAL_UNLOCK(hadc);
mbed_official 376:cb4d9db17537 1318
mbed_official 376:cb4d9db17537 1319 /* Return function status */
mbed_official 376:cb4d9db17537 1320 return HAL_OK;
mbed_official 376:cb4d9db17537 1321 }
mbed_official 376:cb4d9db17537 1322
mbed_official 376:cb4d9db17537 1323 /**
mbed_official 376:cb4d9db17537 1324 * @}
mbed_official 376:cb4d9db17537 1325 */
mbed_official 376:cb4d9db17537 1326
mbed_official 376:cb4d9db17537 1327 /** @defgroup ADC_Group4 ADC Peripheral State functions
mbed_official 376:cb4d9db17537 1328 * @brief ADC Peripheral State functions
mbed_official 376:cb4d9db17537 1329 *
mbed_official 376:cb4d9db17537 1330 @verbatim
mbed_official 376:cb4d9db17537 1331 ===============================================================================
mbed_official 376:cb4d9db17537 1332 ##### ADC Peripheral State functions #####
mbed_official 376:cb4d9db17537 1333 ===============================================================================
mbed_official 376:cb4d9db17537 1334 [..]
mbed_official 376:cb4d9db17537 1335 This subsection provides functions allowing to
mbed_official 376:cb4d9db17537 1336 (+) Check the ADC state.
mbed_official 376:cb4d9db17537 1337 (+) handle ADC interrupt request.
mbed_official 376:cb4d9db17537 1338
mbed_official 376:cb4d9db17537 1339 @endverbatim
mbed_official 376:cb4d9db17537 1340 * @{
mbed_official 376:cb4d9db17537 1341 */
mbed_official 376:cb4d9db17537 1342
mbed_official 376:cb4d9db17537 1343 /**
mbed_official 376:cb4d9db17537 1344 * @brief return the ADC state
mbed_official 376:cb4d9db17537 1345 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1346 * the configuration information for the specified ADC.
mbed_official 376:cb4d9db17537 1347 * @retval HAL state
mbed_official 376:cb4d9db17537 1348 */
mbed_official 376:cb4d9db17537 1349 HAL_ADC_StateTypeDef HAL_ADC_GetState(ADC_HandleTypeDef* hadc)
mbed_official 376:cb4d9db17537 1350 {
mbed_official 376:cb4d9db17537 1351 /* Return ADC state */
mbed_official 376:cb4d9db17537 1352 return hadc->State;
mbed_official 376:cb4d9db17537 1353 }
mbed_official 376:cb4d9db17537 1354
mbed_official 376:cb4d9db17537 1355 /**
mbed_official 376:cb4d9db17537 1356 * @brief Return the ADC error code
mbed_official 376:cb4d9db17537 1357 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1358 * the configuration information for the specified ADC.
mbed_official 376:cb4d9db17537 1359 * @retval ADC Error Code
mbed_official 376:cb4d9db17537 1360 */
mbed_official 376:cb4d9db17537 1361 uint32_t HAL_ADC_GetError(ADC_HandleTypeDef *hadc)
mbed_official 376:cb4d9db17537 1362 {
mbed_official 376:cb4d9db17537 1363 return hadc->ErrorCode;
mbed_official 376:cb4d9db17537 1364 }
mbed_official 376:cb4d9db17537 1365
mbed_official 376:cb4d9db17537 1366
mbed_official 376:cb4d9db17537 1367 /**
mbed_official 376:cb4d9db17537 1368 * @}
mbed_official 376:cb4d9db17537 1369 */
mbed_official 376:cb4d9db17537 1370
mbed_official 376:cb4d9db17537 1371 /**
mbed_official 376:cb4d9db17537 1372 * @brief Enable the selected ADC.
mbed_official 376:cb4d9db17537 1373 * @note Prerequisite condition to use this function: ADC must be disabled
mbed_official 376:cb4d9db17537 1374 * and voltage regulator must be enabled (done into HAL_ADC_Init()).
mbed_official 376:cb4d9db17537 1375 * @param hadc: ADC handle
mbed_official 376:cb4d9db17537 1376 * @retval HAL status.
mbed_official 376:cb4d9db17537 1377 */
mbed_official 376:cb4d9db17537 1378 static HAL_StatusTypeDef ADC_Enable(ADC_HandleTypeDef* hadc)
mbed_official 376:cb4d9db17537 1379 {
mbed_official 376:cb4d9db17537 1380 uint32_t tickstart = 0;
mbed_official 376:cb4d9db17537 1381
mbed_official 376:cb4d9db17537 1382 /* ADC enable and wait for ADC ready (in case of ADC is disabled or */
mbed_official 376:cb4d9db17537 1383 /* enabling phase not yet completed: flag ADC ready not yet set). */
mbed_official 376:cb4d9db17537 1384 /* Timeout implemented to not be stuck if ADC cannot be enabled (possible */
mbed_official 376:cb4d9db17537 1385 /* causes: ADC clock not running, ...). */
mbed_official 376:cb4d9db17537 1386 if (__HAL_ADC_IS_ENABLED(hadc) == RESET)
mbed_official 376:cb4d9db17537 1387 {
mbed_official 376:cb4d9db17537 1388 /* Check if conditions to enable the ADC are fulfilled */
mbed_official 376:cb4d9db17537 1389 if (__HAL_ADC_ENABLING_CONDITIONS(hadc) == RESET)
mbed_official 376:cb4d9db17537 1390 {
mbed_official 376:cb4d9db17537 1391 /* Update ADC state machine to error */
mbed_official 376:cb4d9db17537 1392 hadc->State = HAL_ADC_STATE_ERROR;
mbed_official 376:cb4d9db17537 1393
mbed_official 376:cb4d9db17537 1394 /* Set ADC error code to ADC IP internal error */
mbed_official 376:cb4d9db17537 1395 hadc->ErrorCode |= HAL_ADC_ERROR_INTERNAL;
mbed_official 376:cb4d9db17537 1396
mbed_official 376:cb4d9db17537 1397 return HAL_ERROR;
mbed_official 376:cb4d9db17537 1398 }
mbed_official 376:cb4d9db17537 1399
mbed_official 376:cb4d9db17537 1400 /* Enable the ADC peripheral */
mbed_official 376:cb4d9db17537 1401 __HAL_ADC_ENABLE(hadc);
mbed_official 376:cb4d9db17537 1402
mbed_official 376:cb4d9db17537 1403 /* Wait for ADC effectively enabled */
mbed_official 376:cb4d9db17537 1404 /* Get timeout */
mbed_official 376:cb4d9db17537 1405 tickstart = HAL_GetTick();
mbed_official 376:cb4d9db17537 1406
mbed_official 376:cb4d9db17537 1407 /* Skip polling for RDY ADRDY when AutoOFF is enabled */
mbed_official 376:cb4d9db17537 1408 if (hadc->Init.LowPowerAutoOff != ENABLE)
mbed_official 376:cb4d9db17537 1409 {
mbed_official 376:cb4d9db17537 1410 while(__HAL_ADC_GET_FLAG(hadc, ADC_FLAG_RDY) == RESET)
mbed_official 376:cb4d9db17537 1411 {
mbed_official 376:cb4d9db17537 1412 /* Check for the Timeout */
mbed_official 376:cb4d9db17537 1413 if(ADC_ENABLE_TIMEOUT != HAL_MAX_DELAY)
mbed_official 376:cb4d9db17537 1414 {
mbed_official 376:cb4d9db17537 1415 if((HAL_GetTick() - tickstart ) > ADC_ENABLE_TIMEOUT)
mbed_official 376:cb4d9db17537 1416 {
mbed_official 376:cb4d9db17537 1417 /* Update ADC state machine to error */
mbed_official 376:cb4d9db17537 1418 hadc->State = HAL_ADC_STATE_ERROR;
mbed_official 376:cb4d9db17537 1419
mbed_official 376:cb4d9db17537 1420 /* Set ADC error code to ADC IP internal error */
mbed_official 376:cb4d9db17537 1421 hadc->ErrorCode |= HAL_ADC_ERROR_INTERNAL;
mbed_official 376:cb4d9db17537 1422
mbed_official 376:cb4d9db17537 1423 return HAL_ERROR;
mbed_official 376:cb4d9db17537 1424 }
mbed_official 376:cb4d9db17537 1425 }
mbed_official 376:cb4d9db17537 1426 }
mbed_official 376:cb4d9db17537 1427 }
mbed_official 376:cb4d9db17537 1428 }
mbed_official 376:cb4d9db17537 1429
mbed_official 376:cb4d9db17537 1430 /* Return HAL status */
mbed_official 376:cb4d9db17537 1431 return HAL_OK;
mbed_official 376:cb4d9db17537 1432 }
mbed_official 376:cb4d9db17537 1433
mbed_official 376:cb4d9db17537 1434 /**
mbed_official 376:cb4d9db17537 1435 * @brief Disable the selected ADC.
mbed_official 376:cb4d9db17537 1436 * @note Prerequisite condition to use this function: ADC conversions must be
mbed_official 376:cb4d9db17537 1437 * stopped to disable the ADC.
mbed_official 376:cb4d9db17537 1438 * @param hadc: ADC handle
mbed_official 376:cb4d9db17537 1439 * @retval HAL status.
mbed_official 376:cb4d9db17537 1440 */
mbed_official 376:cb4d9db17537 1441 static HAL_StatusTypeDef ADC_Disable(ADC_HandleTypeDef* hadc)
mbed_official 376:cb4d9db17537 1442 {
mbed_official 376:cb4d9db17537 1443 uint32_t tickstart = 0;
mbed_official 376:cb4d9db17537 1444
mbed_official 376:cb4d9db17537 1445 /* Verification if ADC is not already disabled: */
mbed_official 376:cb4d9db17537 1446 /* forbidden to disable ADC (set bit ADC_CR_ADDIS) if ADC is already */
mbed_official 376:cb4d9db17537 1447 /* disabled. */
mbed_official 376:cb4d9db17537 1448 if (__HAL_ADC_IS_ENABLED(hadc) != RESET )
mbed_official 376:cb4d9db17537 1449 {
mbed_official 376:cb4d9db17537 1450 /* Check if conditions to disable the ADC are fulfilled */
mbed_official 376:cb4d9db17537 1451 if (__HAL_ADC_DISABLING_CONDITIONS(hadc) != RESET)
mbed_official 376:cb4d9db17537 1452 {
mbed_official 376:cb4d9db17537 1453 /* Disable the ADC peripheral */
mbed_official 376:cb4d9db17537 1454 __HAL_ADC_DISABLE(hadc);
mbed_official 376:cb4d9db17537 1455 }
mbed_official 376:cb4d9db17537 1456 else
mbed_official 376:cb4d9db17537 1457 {
mbed_official 376:cb4d9db17537 1458 /* Update ADC state machine to error */
mbed_official 376:cb4d9db17537 1459 hadc->State = HAL_ADC_STATE_ERROR;
mbed_official 376:cb4d9db17537 1460
mbed_official 376:cb4d9db17537 1461 /* Set ADC error code to ADC internal error */
mbed_official 376:cb4d9db17537 1462 hadc->ErrorCode |= HAL_ADC_ERROR_INTERNAL;
mbed_official 376:cb4d9db17537 1463
mbed_official 376:cb4d9db17537 1464 return HAL_ERROR;
mbed_official 376:cb4d9db17537 1465 }
mbed_official 376:cb4d9db17537 1466
mbed_official 376:cb4d9db17537 1467 /* Wait for ADC effectively disabled */
mbed_official 376:cb4d9db17537 1468 /* Get timeout */
mbed_official 376:cb4d9db17537 1469 tickstart = HAL_GetTick();
mbed_official 376:cb4d9db17537 1470
mbed_official 376:cb4d9db17537 1471 while(HAL_IS_BIT_SET(hadc->Instance->CR, ADC_CR_ADEN))
mbed_official 376:cb4d9db17537 1472 {
mbed_official 376:cb4d9db17537 1473 /* Check for the Timeout */
mbed_official 376:cb4d9db17537 1474 if(ADC_ENABLE_TIMEOUT != HAL_MAX_DELAY)
mbed_official 376:cb4d9db17537 1475 {
mbed_official 376:cb4d9db17537 1476 if((HAL_GetTick() - tickstart ) > ADC_DISABLE_TIMEOUT)
mbed_official 376:cb4d9db17537 1477 {
mbed_official 376:cb4d9db17537 1478 /* Update ADC state machine to error */
mbed_official 376:cb4d9db17537 1479 hadc->State = HAL_ADC_STATE_ERROR;
mbed_official 376:cb4d9db17537 1480
mbed_official 376:cb4d9db17537 1481 /* Set ADC error code to ADC internal error */
mbed_official 376:cb4d9db17537 1482 hadc->ErrorCode |= HAL_ADC_ERROR_INTERNAL;
mbed_official 376:cb4d9db17537 1483
mbed_official 376:cb4d9db17537 1484 return HAL_ERROR;
mbed_official 376:cb4d9db17537 1485 }
mbed_official 376:cb4d9db17537 1486 }
mbed_official 376:cb4d9db17537 1487 }
mbed_official 376:cb4d9db17537 1488 }
mbed_official 376:cb4d9db17537 1489
mbed_official 376:cb4d9db17537 1490 /* Return HAL status */
mbed_official 376:cb4d9db17537 1491 return HAL_OK;
mbed_official 376:cb4d9db17537 1492 }
mbed_official 376:cb4d9db17537 1493
mbed_official 376:cb4d9db17537 1494 /**
mbed_official 376:cb4d9db17537 1495 * @brief Stop ADC conversion.
mbed_official 376:cb4d9db17537 1496 * @note Prerequisite condition to use this function: ADC conversions must be
mbed_official 376:cb4d9db17537 1497 * stopped to disable the ADC.
mbed_official 376:cb4d9db17537 1498 * @param hadc: ADC handle
mbed_official 376:cb4d9db17537 1499 * @param ConversionGroup: Only ADC group regular.
mbed_official 376:cb4d9db17537 1500 * This parameter can be one of the following values:
mbed_official 376:cb4d9db17537 1501 * @arg REGULAR_GROUP: ADC regular conversion type.
mbed_official 376:cb4d9db17537 1502 * @retval HAL status.
mbed_official 376:cb4d9db17537 1503 */
mbed_official 376:cb4d9db17537 1504 static HAL_StatusTypeDef ADC_ConversionStop(ADC_HandleTypeDef* hadc, uint32_t ConversionGroup)
mbed_official 376:cb4d9db17537 1505 {
mbed_official 376:cb4d9db17537 1506 uint32_t tickstart = 0 ;
mbed_official 376:cb4d9db17537 1507
mbed_official 376:cb4d9db17537 1508 /* Check the parameters */
mbed_official 376:cb4d9db17537 1509 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 376:cb4d9db17537 1510 assert_param(IS_ADC_CONVERSION_GROUP(ConversionGroup));
mbed_official 376:cb4d9db17537 1511
mbed_official 376:cb4d9db17537 1512 /* Verification: if ADC is not already stopped, bypass this function */
mbed_official 376:cb4d9db17537 1513 if (HAL_IS_BIT_SET(hadc->Instance->CR, ADC_CR_ADSTART))
mbed_official 376:cb4d9db17537 1514 {
mbed_official 376:cb4d9db17537 1515 /* Stop potential conversion on regular group */
mbed_official 376:cb4d9db17537 1516 if (ConversionGroup == REGULAR_GROUP)
mbed_official 376:cb4d9db17537 1517 {
mbed_official 376:cb4d9db17537 1518 /* Software is allowed to set ADSTP only when ADSTART=1 and ADDIS=0 */
mbed_official 376:cb4d9db17537 1519 if (HAL_IS_BIT_SET(hadc->Instance->CR, ADC_CR_ADSTART) && \
mbed_official 376:cb4d9db17537 1520 HAL_IS_BIT_CLR(hadc->Instance->CR, ADC_CR_ADDIS) )
mbed_official 376:cb4d9db17537 1521 {
mbed_official 376:cb4d9db17537 1522 /* Stop conversions on regular group */
mbed_official 376:cb4d9db17537 1523 hadc->Instance->CR |= ADC_CR_ADSTP;
mbed_official 376:cb4d9db17537 1524 }
mbed_official 376:cb4d9db17537 1525 }
mbed_official 376:cb4d9db17537 1526
mbed_official 376:cb4d9db17537 1527 /* Wait for conversion effectively stopped */
mbed_official 376:cb4d9db17537 1528 /* Get timeout */
mbed_official 376:cb4d9db17537 1529 tickstart = HAL_GetTick();
mbed_official 376:cb4d9db17537 1530
mbed_official 376:cb4d9db17537 1531 while((hadc->Instance->CR & ADC_CR_ADSTART) != RESET)
mbed_official 376:cb4d9db17537 1532 {
mbed_official 376:cb4d9db17537 1533 /* Check for the Timeout */
mbed_official 376:cb4d9db17537 1534 if(ADC_STOP_CONVERSION_TIMEOUT != HAL_MAX_DELAY)
mbed_official 376:cb4d9db17537 1535 {
mbed_official 376:cb4d9db17537 1536 if((HAL_GetTick() - tickstart ) > ADC_STOP_CONVERSION_TIMEOUT)
mbed_official 376:cb4d9db17537 1537 {
mbed_official 376:cb4d9db17537 1538 /* Update ADC state machine to error */
mbed_official 376:cb4d9db17537 1539 hadc->State = HAL_ADC_STATE_ERROR;
mbed_official 376:cb4d9db17537 1540
mbed_official 376:cb4d9db17537 1541 /* Set ADC error code to ADC IP internal error */
mbed_official 376:cb4d9db17537 1542 hadc->ErrorCode |= HAL_ADC_ERROR_INTERNAL;
mbed_official 376:cb4d9db17537 1543
mbed_official 376:cb4d9db17537 1544 return HAL_ERROR;
mbed_official 376:cb4d9db17537 1545 }
mbed_official 376:cb4d9db17537 1546 }
mbed_official 376:cb4d9db17537 1547 }
mbed_official 376:cb4d9db17537 1548 }
mbed_official 376:cb4d9db17537 1549
mbed_official 376:cb4d9db17537 1550 /* Return HAL status */
mbed_official 376:cb4d9db17537 1551 return HAL_OK;
mbed_official 376:cb4d9db17537 1552 }
mbed_official 376:cb4d9db17537 1553
mbed_official 376:cb4d9db17537 1554 /**
mbed_official 376:cb4d9db17537 1555 * @brief DMA transfer complete callback.
mbed_official 376:cb4d9db17537 1556 * @param hdma: pointer to DMA handle.
mbed_official 376:cb4d9db17537 1557 * @retval None
mbed_official 376:cb4d9db17537 1558 */
mbed_official 376:cb4d9db17537 1559 static void ADC_DMAConvCplt(DMA_HandleTypeDef *hdma)
mbed_official 376:cb4d9db17537 1560 {
mbed_official 376:cb4d9db17537 1561 ADC_HandleTypeDef* hadc = ( ADC_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official 376:cb4d9db17537 1562
mbed_official 376:cb4d9db17537 1563 /* Change ADC state */
mbed_official 376:cb4d9db17537 1564 hadc->State = HAL_ADC_STATE_EOC;
mbed_official 376:cb4d9db17537 1565
mbed_official 376:cb4d9db17537 1566 HAL_ADC_ConvCpltCallback(hadc);
mbed_official 376:cb4d9db17537 1567 }
mbed_official 376:cb4d9db17537 1568
mbed_official 376:cb4d9db17537 1569 /**
mbed_official 376:cb4d9db17537 1570 * @brief DMA half transfer complete callback.
mbed_official 376:cb4d9db17537 1571 * @param hdma: pointer to DMA handle.
mbed_official 376:cb4d9db17537 1572 * @retval None
mbed_official 376:cb4d9db17537 1573 */
mbed_official 376:cb4d9db17537 1574 static void ADC_DMAHalfConvCplt(DMA_HandleTypeDef *hdma)
mbed_official 376:cb4d9db17537 1575 {
mbed_official 376:cb4d9db17537 1576 ADC_HandleTypeDef* hadc = ( ADC_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official 376:cb4d9db17537 1577
mbed_official 376:cb4d9db17537 1578 /* Conversion complete callback */
mbed_official 376:cb4d9db17537 1579 HAL_ADC_ConvHalfCpltCallback(hadc);
mbed_official 376:cb4d9db17537 1580 }
mbed_official 376:cb4d9db17537 1581
mbed_official 376:cb4d9db17537 1582 /**
mbed_official 376:cb4d9db17537 1583 * @brief DMA error callback
mbed_official 376:cb4d9db17537 1584 * @param hdma: pointer to DMA handle.
mbed_official 376:cb4d9db17537 1585 * @retval None
mbed_official 376:cb4d9db17537 1586 */
mbed_official 376:cb4d9db17537 1587 static void ADC_DMAError(DMA_HandleTypeDef *hdma)
mbed_official 376:cb4d9db17537 1588 {
mbed_official 376:cb4d9db17537 1589 ADC_HandleTypeDef* hadc = ( ADC_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official 376:cb4d9db17537 1590 hadc->State= HAL_ADC_STATE_ERROR;
mbed_official 376:cb4d9db17537 1591 /* Set ADC error code to DMA error */
mbed_official 376:cb4d9db17537 1592 hadc->ErrorCode |= HAL_ADC_ERROR_DMA;
mbed_official 376:cb4d9db17537 1593 HAL_ADC_ErrorCallback(hadc);
mbed_official 376:cb4d9db17537 1594 }
mbed_official 376:cb4d9db17537 1595
mbed_official 376:cb4d9db17537 1596 /**
mbed_official 376:cb4d9db17537 1597 * @}
mbed_official 376:cb4d9db17537 1598 */
mbed_official 376:cb4d9db17537 1599
mbed_official 376:cb4d9db17537 1600 #endif /* HAL_ADC_MODULE_ENABLED */
mbed_official 376:cb4d9db17537 1601 /**
mbed_official 376:cb4d9db17537 1602 * @}
mbed_official 376:cb4d9db17537 1603 */
mbed_official 376:cb4d9db17537 1604
mbed_official 376:cb4d9db17537 1605 /**
mbed_official 376:cb4d9db17537 1606 * @}
mbed_official 376:cb4d9db17537 1607 */
mbed_official 376:cb4d9db17537 1608
mbed_official 376:cb4d9db17537 1609 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/