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_STM32L1/stm32l1xx_hal_adc.c@579:53297373a894, 2015-07-01 (annotated)

Committer:
mbed_official
Date:
Wed Jul 01 09:45:11 2015 +0100
Revision:
579:53297373a894
Parent:
394:83f921546702 
Synchronized with git revision d5b4d2ab9c47edb4dc5776e7177b0c2263459081



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



Initial version of drivers for SAMR21

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mbed_official 354:e67efb2aab0e 1 /**
mbed_official 354:e67efb2aab0e 2 ******************************************************************************
mbed_official 354:e67efb2aab0e 3 * @file stm32l1xx_hal_adc.c
mbed_official 354:e67efb2aab0e 4 * @author MCD Application conversion
mbed_official 354:e67efb2aab0e 5 * @version V1.0.0
mbed_official 354:e67efb2aab0e 6 * @date 5-September-2014
mbed_official 354:e67efb2aab0e 7 * @brief This file provides firmware functions to manage the following
mbed_official 354:e67efb2aab0e 8 * functionalities of the Analog to Digital Convertor (ADC)
mbed_official 354:e67efb2aab0e 9 * peripheral:
mbed_official 354:e67efb2aab0e 10 * + Initialization and de-initialization functions
mbed_official 354:e67efb2aab0e 11 * ++ Initialization and Configuration of ADC
mbed_official 354:e67efb2aab0e 12 * + Operation functions
mbed_official 354:e67efb2aab0e 13 * ++ Start, stop, get result of conversions of regular
mbed_official 354:e67efb2aab0e 14 * group, using 3 possible modes: polling, interruption or DMA.
mbed_official 354:e67efb2aab0e 15 * + Control functions
mbed_official 354:e67efb2aab0e 16 * ++ Analog Watchdog configuration
mbed_official 354:e67efb2aab0e 17 * ++ Channels configuration on regular group
mbed_official 354:e67efb2aab0e 18 * + State functions
mbed_official 354:e67efb2aab0e 19 * ++ ADC state machine management
mbed_official 354:e67efb2aab0e 20 * ++ Interrupts and flags management
mbed_official 354:e67efb2aab0e 21 * Other functions (extended functions) are available in file
mbed_official 354:e67efb2aab0e 22 * "stm32l1xx_hal_adc_ex.c".
mbed_official 354:e67efb2aab0e 23 *
mbed_official 354:e67efb2aab0e 24 @verbatim
mbed_official 354:e67efb2aab0e 25 ==============================================================================
mbed_official 354:e67efb2aab0e 26 ##### ADC specific features #####
mbed_official 354:e67efb2aab0e 27 ==============================================================================
mbed_official 354:e67efb2aab0e 28 [..]
mbed_official 354:e67efb2aab0e 29 (#) 12-bit, 10-bit, 8-bit or 6-bit configurable resolution
mbed_official 354:e67efb2aab0e 30
mbed_official 354:e67efb2aab0e 31 (#) Interrupt generation at the end of regular conversion, end of injected
mbed_official 354:e67efb2aab0e 32 conversion, and in case of analog watchdog or overrun events.
mbed_official 354:e67efb2aab0e 33
mbed_official 354:e67efb2aab0e 34 (#) Single and continuous conversion modes.
mbed_official 354:e67efb2aab0e 35
mbed_official 354:e67efb2aab0e 36 (#) Scan mode for automatic conversion of channel 0 to channel 'n'.
mbed_official 354:e67efb2aab0e 37
mbed_official 354:e67efb2aab0e 38 (#) Data alignment with in-built data coherency.
mbed_official 354:e67efb2aab0e 39
mbed_official 354:e67efb2aab0e 40 (#) Channel-wise programmable sampling time.
mbed_official 354:e67efb2aab0e 41
mbed_official 354:e67efb2aab0e 42 (#) ADC conversion Regular or Injected groups.
mbed_official 354:e67efb2aab0e 43
mbed_official 354:e67efb2aab0e 44 (#) External trigger (timer or EXTI) with configurable polarity for both
mbed_official 354:e67efb2aab0e 45 regular and injected groups.
mbed_official 354:e67efb2aab0e 46
mbed_official 354:e67efb2aab0e 47 (#) DMA request generation for transfer of conversions data of regular group.
mbed_official 354:e67efb2aab0e 48
mbed_official 354:e67efb2aab0e 49 (#) ADC calibration
mbed_official 354:e67efb2aab0e 50
mbed_official 354:e67efb2aab0e 51 (#) ADC offset on injected channels
mbed_official 354:e67efb2aab0e 52
mbed_official 354:e67efb2aab0e 53 (#) ADC supply requirements: 2.4 V to 3.6 V at full speed and down to 1.8 V at
mbed_official 354:e67efb2aab0e 54 slower speed.
mbed_official 354:e67efb2aab0e 55
mbed_official 354:e67efb2aab0e 56 (#) ADC input range: from Vref– (connected to Vssa) to Vref+ (connected to
mbed_official 354:e67efb2aab0e 57 Vdda or to an external voltage reference).
mbed_official 354:e67efb2aab0e 58
mbed_official 354:e67efb2aab0e 59
mbed_official 354:e67efb2aab0e 60 ##### How to use this driver #####
mbed_official 354:e67efb2aab0e 61 ==============================================================================
mbed_official 354:e67efb2aab0e 62 [..]
mbed_official 354:e67efb2aab0e 63
mbed_official 354:e67efb2aab0e 64 (#) Enable the ADC interface
mbed_official 354:e67efb2aab0e 65 As prerequisite, ADC clock must be configured at RCC top level.
mbed_official 354:e67efb2aab0e 66 Two clocks settings are mandatory:
mbed_official 354:e67efb2aab0e 67 - ADC clock (core clock):
mbed_official 354:e67efb2aab0e 68 Example:
mbed_official 354:e67efb2aab0e 69 Into HAL_ADC_MspInit() (recommended code location):
mbed_official 354:e67efb2aab0e 70 __ADC1_CLK_ENABLE();
mbed_official 354:e67efb2aab0e 71
mbed_official 354:e67efb2aab0e 72 - ADC clock (conversions clock):
mbed_official 354:e67efb2aab0e 73 Only one possible clock source: derived from HSI RC 16MHz oscillator
mbed_official 354:e67efb2aab0e 74 (HSI).
mbed_official 354:e67efb2aab0e 75 Example:
mbed_official 354:e67efb2aab0e 76 Into HAL_ADC_MspInit() or with main setting of RCC:
mbed_official 354:e67efb2aab0e 77 RCC_OscInitTypeDef RCC_OscInitStructure;
mbed_official 354:e67efb2aab0e 78 HAL_RCC_GetOscConfig(&RCC_OscInitStructure);
mbed_official 354:e67efb2aab0e 79 RCC_OscInitStructure.OscillatorType = (... | RCC_OSCILLATORTYPE_HSI);
mbed_official 354:e67efb2aab0e 80 RCC_OscInitStructure.HSIState = RCC_HSI_ON;
mbed_official 354:e67efb2aab0e 81 RCC_OscInitStructure.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
mbed_official 354:e67efb2aab0e 82 RCC_OscInitStructure.PLL.PLLState = RCC_PLL_NONE;
mbed_official 354:e67efb2aab0e 83 RCC_OscInitStructure.PLL.PLLSource = ...
mbed_official 354:e67efb2aab0e 84 RCC_OscInitStructure.PLL...
mbed_official 354:e67efb2aab0e 85 HAL_RCC_OscConfig(&RCC_OscInitStructure);
mbed_official 354:e67efb2aab0e 86
mbed_official 354:e67efb2aab0e 87 Note: ADC is connected directly to HSI RC 16MHz oscillator.
mbed_official 354:e67efb2aab0e 88 Therefore, RCC PLL setting has no impact on ADC.
mbed_official 354:e67efb2aab0e 89 PLL can be disabled (".PLL.PLLState = RCC_PLL_NONE") or
mbed_official 354:e67efb2aab0e 90 enabled with HSI16 as clock source
mbed_official 354:e67efb2aab0e 91 (".PLL.PLLSource = RCC_PLLSOURCE_HSI") to be used as device
mbed_official 354:e67efb2aab0e 92 main clock source SYSCLK.
mbed_official 354:e67efb2aab0e 93 The only mandatory setting is ".HSIState = RCC_HSI_ON"
mbed_official 354:e67efb2aab0e 94
mbed_official 354:e67efb2aab0e 95 Note: ADC clock prescaler is configured at ADC level with
mbed_official 354:e67efb2aab0e 96 parameter "ClockPrescaler" using function HAL_ADC_Init().
mbed_official 354:e67efb2aab0e 97
mbed_official 354:e67efb2aab0e 98 (#) ADC pins configuration
mbed_official 354:e67efb2aab0e 99 (++) Enable the clock for the ADC GPIOs using the following function:
mbed_official 354:e67efb2aab0e 100 __GPIOx_CLK_ENABLE();
mbed_official 354:e67efb2aab0e 101 (++) Configure these ADC pins in analog mode using HAL_GPIO_Init();
mbed_official 354:e67efb2aab0e 102
mbed_official 354:e67efb2aab0e 103 (#) Configure the ADC parameters (conversion resolution, data alignment,
mbed_official 354:e67efb2aab0e 104 continuous mode, ...) using the HAL_ADC_Init() function.
mbed_official 354:e67efb2aab0e 105
mbed_official 354:e67efb2aab0e 106 (#) Activate the ADC peripheral using one of the start functions:
mbed_official 354:e67efb2aab0e 107 HAL_ADC_Start(), HAL_ADC_Start_IT(), HAL_ADC_Start_DMA().
mbed_official 354:e67efb2aab0e 108
mbed_official 354:e67efb2aab0e 109 *** Channels configuration to regular group ***
mbed_official 354:e67efb2aab0e 110 ================================================
mbed_official 354:e67efb2aab0e 111 [..]
mbed_official 354:e67efb2aab0e 112 (+) To configure the ADC regular group features, use
mbed_official 354:e67efb2aab0e 113 HAL_ADC_Init() and HAL_ADC_ConfigChannel() functions.
mbed_official 354:e67efb2aab0e 114 (+) To read the ADC converted values, use the HAL_ADC_GetValue() function.
mbed_official 354:e67efb2aab0e 115
mbed_official 354:e67efb2aab0e 116 *** DMA for regular group configuration ***
mbed_official 354:e67efb2aab0e 117 ===========================================
mbed_official 354:e67efb2aab0e 118 [..]
mbed_official 354:e67efb2aab0e 119 (+) To enable the DMA mode for regular group, use the
mbed_official 354:e67efb2aab0e 120 HAL_ADC_Start_DMA() function.
mbed_official 354:e67efb2aab0e 121 (+) To enable the generation of DMA requests continuously at the end of
mbed_official 354:e67efb2aab0e 122 the last DMA transfer, use the HAL_ADC_Init() function.
mbed_official 354:e67efb2aab0e 123
mbed_official 354:e67efb2aab0e 124 @endverbatim
mbed_official 354:e67efb2aab0e 125 ******************************************************************************
mbed_official 354:e67efb2aab0e 126 * @attention
mbed_official 354:e67efb2aab0e 127 *
mbed_official 354:e67efb2aab0e 128 * <h2><center>&copy; COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
mbed_official 354:e67efb2aab0e 129 *
mbed_official 354:e67efb2aab0e 130 * Redistribution and use in source and binary forms, with or without modification,
mbed_official 354:e67efb2aab0e 131 * are permitted provided that the following conditions are met:
mbed_official 354:e67efb2aab0e 132 * 1. Redistributions of source code must retain the above copyright notice,
mbed_official 354:e67efb2aab0e 133 * this list of conditions and the following disclaimer.
mbed_official 354:e67efb2aab0e 134 * 2. Redistributions in binary form must reproduce the above copyright notice,
mbed_official 354:e67efb2aab0e 135 * this list of conditions and the following disclaimer in the documentation
mbed_official 354:e67efb2aab0e 136 * and/or other materials provided with the distribution.
mbed_official 354:e67efb2aab0e 137 * 3. Neither the name of STMicroelectronics nor the names of its contributors
mbed_official 354:e67efb2aab0e 138 * may be used to endorse or promote products derived from this software
mbed_official 354:e67efb2aab0e 139 * without specific prior written permission.
mbed_official 354:e67efb2aab0e 140 *
mbed_official 354:e67efb2aab0e 141 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
mbed_official 354:e67efb2aab0e 142 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
mbed_official 354:e67efb2aab0e 143 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
mbed_official 354:e67efb2aab0e 144 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
mbed_official 354:e67efb2aab0e 145 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
mbed_official 354:e67efb2aab0e 146 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
mbed_official 354:e67efb2aab0e 147 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
mbed_official 354:e67efb2aab0e 148 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
mbed_official 354:e67efb2aab0e 149 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
mbed_official 354:e67efb2aab0e 150 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
mbed_official 354:e67efb2aab0e 151 *
mbed_official 354:e67efb2aab0e 152 ******************************************************************************
mbed_official 354:e67efb2aab0e 153 */
mbed_official 354:e67efb2aab0e 154
mbed_official 354:e67efb2aab0e 155 /* Includes ------------------------------------------------------------------*/
mbed_official 354:e67efb2aab0e 156 #include "stm32l1xx_hal.h"
mbed_official 354:e67efb2aab0e 157
mbed_official 354:e67efb2aab0e 158 /** @addtogroup STM32L1xx_HAL_Driver
mbed_official 354:e67efb2aab0e 159 * @{
mbed_official 354:e67efb2aab0e 160 */
mbed_official 354:e67efb2aab0e 161
mbed_official 354:e67efb2aab0e 162 /** @defgroup ADC ADC
mbed_official 354:e67efb2aab0e 163 * @brief ADC HAL module driver
mbed_official 354:e67efb2aab0e 164 * @{
mbed_official 354:e67efb2aab0e 165 */
mbed_official 354:e67efb2aab0e 166
mbed_official 354:e67efb2aab0e 167 #ifdef HAL_ADC_MODULE_ENABLED
mbed_official 354:e67efb2aab0e 168
mbed_official 354:e67efb2aab0e 169 /* Private typedef -----------------------------------------------------------*/
mbed_official 354:e67efb2aab0e 170 /* Private define ------------------------------------------------------------*/
mbed_official 354:e67efb2aab0e 171 /** @defgroup ADC_Private_Constants ADC Private Constants
mbed_official 354:e67efb2aab0e 172 * @{
mbed_official 354:e67efb2aab0e 173 */
mbed_official 354:e67efb2aab0e 174
mbed_official 354:e67efb2aab0e 175 /* Fixed timeout values for ADC calibration, enable settling time. */
mbed_official 354:e67efb2aab0e 176 /* Values defined to be higher than worst cases: low clocks freq, */
mbed_official 354:e67efb2aab0e 177 /* maximum prescaler. */
mbed_official 354:e67efb2aab0e 178 /* Ex of profile low frequency : Clock source at 0.1 MHz, ADC clock */
mbed_official 354:e67efb2aab0e 179 /* prescaler 4, sampling time 7.5 ADC clock cycles, resolution 12 bits. */
mbed_official 354:e67efb2aab0e 180 /* Unit: ms */
mbed_official 354:e67efb2aab0e 181 #define ADC_ENABLE_TIMEOUT ((uint32_t) 2)
mbed_official 354:e67efb2aab0e 182 #define ADC_DISABLE_TIMEOUT ((uint32_t) 2)
mbed_official 354:e67efb2aab0e 183
mbed_official 354:e67efb2aab0e 184 /* Delay for ADC stabilization time. */
mbed_official 354:e67efb2aab0e 185 /* Maximum delay is 3.5us (refer to device datasheet, parameter tSTAB). */
mbed_official 354:e67efb2aab0e 186 /* Delay in CPU cycles, fixed to worst case: maximum CPU frequency 32MHz to */
mbed_official 354:e67efb2aab0e 187 /* have the minimum number of CPU cycles to fulfill this delay. */
mbed_official 354:e67efb2aab0e 188 #define ADC_STAB_DELAY_CPU_CYCLES ((uint32_t)112)
mbed_official 354:e67efb2aab0e 189 /**
mbed_official 354:e67efb2aab0e 190 * @}
mbed_official 354:e67efb2aab0e 191 */
mbed_official 354:e67efb2aab0e 192
mbed_official 354:e67efb2aab0e 193 /* Private macro -------------------------------------------------------------*/
mbed_official 354:e67efb2aab0e 194 /* Private variables ---------------------------------------------------------*/
mbed_official 354:e67efb2aab0e 195 /* Private function prototypes -----------------------------------------------*/
mbed_official 354:e67efb2aab0e 196 /** @defgroup ADC_Private_Functions ADC Private Functions
mbed_official 354:e67efb2aab0e 197 * @{
mbed_official 354:e67efb2aab0e 198 */
mbed_official 354:e67efb2aab0e 199 static void ADC_DMAConvCplt(DMA_HandleTypeDef *hdma);
mbed_official 354:e67efb2aab0e 200 static void ADC_DMAHalfConvCplt(DMA_HandleTypeDef *hdma);
mbed_official 354:e67efb2aab0e 201 static void ADC_DMAError(DMA_HandleTypeDef *hdma);
mbed_official 354:e67efb2aab0e 202 /**
mbed_official 354:e67efb2aab0e 203 * @}
mbed_official 354:e67efb2aab0e 204 */
mbed_official 354:e67efb2aab0e 205
mbed_official 354:e67efb2aab0e 206 /* Exported functions ---------------------------------------------------------*/
mbed_official 354:e67efb2aab0e 207
mbed_official 354:e67efb2aab0e 208 /** @defgroup ADC_Exported_Functions ADC Exported Functions
mbed_official 354:e67efb2aab0e 209 * @{
mbed_official 354:e67efb2aab0e 210 */
mbed_official 354:e67efb2aab0e 211
mbed_official 354:e67efb2aab0e 212 /** @defgroup ADC_Exported_Functions_Group1 Initialization/de-initialization functions
mbed_official 354:e67efb2aab0e 213 * @brief Initialization and Configuration functions
mbed_official 354:e67efb2aab0e 214 *
mbed_official 354:e67efb2aab0e 215 @verbatim
mbed_official 354:e67efb2aab0e 216 ===============================================================================
mbed_official 354:e67efb2aab0e 217 ##### Initialization and de-initialization functions #####
mbed_official 354:e67efb2aab0e 218 ===============================================================================
mbed_official 354:e67efb2aab0e 219 [..] This section provides functions allowing to:
mbed_official 354:e67efb2aab0e 220 (+) Initialize and configure the ADC.
mbed_official 354:e67efb2aab0e 221 (+) De-initialize the ADC
mbed_official 354:e67efb2aab0e 222 @endverbatim
mbed_official 354:e67efb2aab0e 223 * @{
mbed_official 354:e67efb2aab0e 224 */
mbed_official 354:e67efb2aab0e 225
mbed_official 354:e67efb2aab0e 226 /**
mbed_official 354:e67efb2aab0e 227 * @brief Initializes the ADC peripheral and regular group according to
mbed_official 354:e67efb2aab0e 228 * parameters specified in structure "ADC_InitTypeDef".
mbed_official 354:e67efb2aab0e 229 * @note As prerequisite, ADC clock must be configured at RCC top level
mbed_official 354:e67efb2aab0e 230 * (clock source APB2).
mbed_official 354:e67efb2aab0e 231 * See commented example code below that can be copied and uncommented
mbed_official 354:e67efb2aab0e 232 * into HAL_ADC_MspInit().
mbed_official 354:e67efb2aab0e 233 * @note Possibility to update parameters on the fly:
mbed_official 354:e67efb2aab0e 234 * This function initializes the ADC MSP (HAL_ADC_MspInit()) only when
mbed_official 354:e67efb2aab0e 235 * coming from ADC state reset. Following calls to this function can
mbed_official 354:e67efb2aab0e 236 * be used to reconfigure some parameters of ADC_InitTypeDef
mbed_official 354:e67efb2aab0e 237 * structure on the fly, without modifying MSP configuration. If ADC
mbed_official 354:e67efb2aab0e 238 * MSP has to be modified again, HAL_ADC_DeInit() must be called
mbed_official 354:e67efb2aab0e 239 * before HAL_ADC_Init().
mbed_official 354:e67efb2aab0e 240 * The setting of these parameters is conditioned to ADC state.
mbed_official 354:e67efb2aab0e 241 * For parameters constraints, see comments of structure
mbed_official 354:e67efb2aab0e 242 * "ADC_InitTypeDef".
mbed_official 354:e67efb2aab0e 243 * @note This function configures the ADC within 2 scopes: scope of entire
mbed_official 354:e67efb2aab0e 244 * ADC and scope of regular group. For parameters details, see comments
mbed_official 354:e67efb2aab0e 245 * of structure "ADC_InitTypeDef".
mbed_official 354:e67efb2aab0e 246 * @param hadc: ADC handle
mbed_official 354:e67efb2aab0e 247 * @retval HAL status
mbed_official 354:e67efb2aab0e 248 */
mbed_official 354:e67efb2aab0e 249 HAL_StatusTypeDef HAL_ADC_Init(ADC_HandleTypeDef* hadc)
mbed_official 354:e67efb2aab0e 250 {
mbed_official 354:e67efb2aab0e 251 HAL_StatusTypeDef tmpHALStatus = HAL_OK;
mbed_official 354:e67efb2aab0e 252 uint32_t tmp_cr1 = 0;
mbed_official 354:e67efb2aab0e 253 uint32_t tmp_cr2 = 0;
mbed_official 354:e67efb2aab0e 254
mbed_official 354:e67efb2aab0e 255 /* Check ADC handle */
mbed_official 354:e67efb2aab0e 256 if(hadc == HAL_NULL)
mbed_official 354:e67efb2aab0e 257 {
mbed_official 354:e67efb2aab0e 258 return HAL_ERROR;
mbed_official 354:e67efb2aab0e 259 }
mbed_official 354:e67efb2aab0e 260
mbed_official 354:e67efb2aab0e 261 /* Check the parameters */
mbed_official 354:e67efb2aab0e 262 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 354:e67efb2aab0e 263 assert_param(IS_ADC_CLOCKPRESCALER(hadc->Init.ClockPrescaler));
mbed_official 354:e67efb2aab0e 264 assert_param(IS_ADC_RESOLUTION(hadc->Init.Resolution));
mbed_official 354:e67efb2aab0e 265 assert_param(IS_ADC_DATA_ALIGN(hadc->Init.DataAlign));
mbed_official 354:e67efb2aab0e 266 assert_param(IS_ADC_SCAN_MODE(hadc->Init.ScanConvMode));
mbed_official 354:e67efb2aab0e 267 assert_param(IS_ADC_EOC_SELECTION(hadc->Init.EOCSelection));
mbed_official 354:e67efb2aab0e 268 assert_param(IS_ADC_AUTOWAIT(hadc->Init.LowPowerAutoWait));
mbed_official 354:e67efb2aab0e 269 assert_param(IS_ADC_AUTOPOWEROFF(hadc->Init.LowPowerAutoPowerOff));
mbed_official 354:e67efb2aab0e 270 assert_param(IS_ADC_CHANNELSBANK(hadc->Init.ChannelsBank));
mbed_official 354:e67efb2aab0e 271 assert_param(IS_FUNCTIONAL_STATE(hadc->Init.ContinuousConvMode));
mbed_official 354:e67efb2aab0e 272 assert_param(IS_ADC_EXTTRIG(hadc->Init.ExternalTrigConv));
mbed_official 354:e67efb2aab0e 273 assert_param(IS_FUNCTIONAL_STATE(hadc->Init.DMAContinuousRequests));
mbed_official 354:e67efb2aab0e 274
mbed_official 354:e67efb2aab0e 275 if(hadc->Init.ScanConvMode != ADC_SCAN_DISABLE)
mbed_official 354:e67efb2aab0e 276 {
mbed_official 354:e67efb2aab0e 277 assert_param(IS_ADC_REGULAR_NB_CONV(hadc->Init.NbrOfConversion));
mbed_official 354:e67efb2aab0e 278 assert_param(IS_FUNCTIONAL_STATE(hadc->Init.DiscontinuousConvMode));
mbed_official 354:e67efb2aab0e 279 assert_param(IS_ADC_REGULAR_DISCONT_NUMBER(hadc->Init.NbrOfDiscConversion));
mbed_official 354:e67efb2aab0e 280 }
mbed_official 354:e67efb2aab0e 281
mbed_official 354:e67efb2aab0e 282 if(hadc->Init.ExternalTrigConv != ADC_SOFTWARE_START)
mbed_official 354:e67efb2aab0e 283 {
mbed_official 354:e67efb2aab0e 284 assert_param(IS_ADC_EXTTRIG_EDGE(hadc->Init.ExternalTrigConvEdge));
mbed_official 354:e67efb2aab0e 285 }
mbed_official 354:e67efb2aab0e 286
mbed_official 354:e67efb2aab0e 287
mbed_official 354:e67efb2aab0e 288 /* As prerequisite, into HAL_ADC_MspInit(), ADC clock must be configured */
mbed_official 354:e67efb2aab0e 289 /* at RCC top level. */
mbed_official 354:e67efb2aab0e 290 /* Refer to header of this file for more details on clock enabling */
mbed_official 354:e67efb2aab0e 291 /* procedure. */
mbed_official 354:e67efb2aab0e 292
mbed_official 354:e67efb2aab0e 293 /* Actions performed only if ADC is coming from state reset: */
mbed_official 354:e67efb2aab0e 294 /* - Initialization of ADC MSP */
mbed_official 354:e67efb2aab0e 295 if (hadc->State == HAL_ADC_STATE_RESET)
mbed_official 354:e67efb2aab0e 296 {
mbed_official 354:e67efb2aab0e 297 /* Enable SYSCFG clock to control the routing Interface (RI) */
mbed_official 354:e67efb2aab0e 298 __SYSCFG_CLK_ENABLE();
mbed_official 354:e67efb2aab0e 299
mbed_official 354:e67efb2aab0e 300 /* Init the low level hardware */
mbed_official 354:e67efb2aab0e 301 HAL_ADC_MspInit(hadc);
mbed_official 354:e67efb2aab0e 302 }
mbed_official 354:e67efb2aab0e 303
mbed_official 354:e67efb2aab0e 304 /* Configuration of ADC parameters if previous preliminary actions are */
mbed_official 354:e67efb2aab0e 305 /* correctly completed. */
mbed_official 354:e67efb2aab0e 306 if (tmpHALStatus != HAL_ERROR)
mbed_official 354:e67efb2aab0e 307 {
mbed_official 354:e67efb2aab0e 308 /* Initialize the ADC state */
mbed_official 354:e67efb2aab0e 309 hadc->State = HAL_ADC_STATE_BUSY;
mbed_official 354:e67efb2aab0e 310
mbed_official 354:e67efb2aab0e 311 /* Set ADC parameters */
mbed_official 354:e67efb2aab0e 312
mbed_official 354:e67efb2aab0e 313 /* Configuration of common ADC clock: clock source HSI with selectable */
mbed_official 354:e67efb2aab0e 314 /* prescaler */
mbed_official 354:e67efb2aab0e 315 MODIFY_REG(ADC->CCR ,
mbed_official 354:e67efb2aab0e 316 ADC_CCR_ADCPRE ,
mbed_official 354:e67efb2aab0e 317 hadc->Init.ClockPrescaler );
mbed_official 354:e67efb2aab0e 318
mbed_official 354:e67efb2aab0e 319 /* Configuration of ADC: */
mbed_official 354:e67efb2aab0e 320 /* - external trigger polarity */
mbed_official 354:e67efb2aab0e 321 /* - End of conversion selection */
mbed_official 354:e67efb2aab0e 322 /* - DMA continuous request */
mbed_official 354:e67efb2aab0e 323 /* - Channels bank (Banks availability depends on devices categories) */
mbed_official 354:e67efb2aab0e 324 /* - continuous conversion mode */
mbed_official 354:e67efb2aab0e 325 tmp_cr2 |= (hadc->Init.DataAlign |
mbed_official 354:e67efb2aab0e 326 hadc->Init.EOCSelection |
mbed_official 354:e67efb2aab0e 327 __ADC_CR2_DMACONTREQ(hadc->Init.DMAContinuousRequests) |
mbed_official 354:e67efb2aab0e 328 hadc->Init.ChannelsBank |
mbed_official 354:e67efb2aab0e 329 __ADC_CR2_CONTINUOUS(hadc->Init.ContinuousConvMode) );
mbed_official 354:e67efb2aab0e 330
mbed_official 354:e67efb2aab0e 331 /* Enable external trigger if trigger selection is different of software */
mbed_official 354:e67efb2aab0e 332 /* start. */
mbed_official 354:e67efb2aab0e 333 /* Note: This configuration keeps the hardware feature of parameter */
mbed_official 354:e67efb2aab0e 334 /* ExternalTrigConvEdge "trigger edge none" equivalent to */
mbed_official 354:e67efb2aab0e 335 /* software start. */
mbed_official 354:e67efb2aab0e 336 if (hadc->Init.ExternalTrigConv != ADC_SOFTWARE_START)
mbed_official 354:e67efb2aab0e 337 {
mbed_official 354:e67efb2aab0e 338 tmp_cr2 |= ( hadc->Init.ExternalTrigConv |
mbed_official 354:e67efb2aab0e 339 hadc->Init.ExternalTrigConvEdge );
mbed_official 354:e67efb2aab0e 340 }
mbed_official 354:e67efb2aab0e 341
mbed_official 354:e67efb2aab0e 342 /* Parameters update conditioned to ADC state: */
mbed_official 354:e67efb2aab0e 343 /* Parameters that can be updated only when ADC is disabled: */
mbed_official 354:e67efb2aab0e 344 /* - delay selection (LowPowerAutoWait mode) */
mbed_official 354:e67efb2aab0e 345 /* - resolution */
mbed_official 354:e67efb2aab0e 346 /* - auto power off (LowPowerAutoPowerOff mode) */
mbed_official 354:e67efb2aab0e 347 /* - scan mode */
mbed_official 354:e67efb2aab0e 348 /* - discontinuous mode disable/enable */
mbed_official 354:e67efb2aab0e 349 /* - discontinuous mode number of conversions */
mbed_official 354:e67efb2aab0e 350 if ((__HAL_ADC_IS_ENABLED(hadc) == RESET))
mbed_official 354:e67efb2aab0e 351 {
mbed_official 354:e67efb2aab0e 352 tmp_cr2 |= hadc->Init.LowPowerAutoWait;
mbed_official 354:e67efb2aab0e 353
mbed_official 354:e67efb2aab0e 354 tmp_cr1 |= (hadc->Init.Resolution |
mbed_official 354:e67efb2aab0e 355 hadc->Init.LowPowerAutoPowerOff |
mbed_official 354:e67efb2aab0e 356 __ADC_CR1_SCAN(hadc->Init.ScanConvMode) );
mbed_official 354:e67efb2aab0e 357
mbed_official 354:e67efb2aab0e 358 /* Enable discontinuous mode only if continuous mode is disabled */
mbed_official 354:e67efb2aab0e 359 if ((hadc->Init.DiscontinuousConvMode == ENABLE) &&
mbed_official 354:e67efb2aab0e 360 (hadc->Init.ContinuousConvMode == DISABLE) )
mbed_official 354:e67efb2aab0e 361 {
mbed_official 354:e67efb2aab0e 362 /* Enable discontinuous mode of regular group */
mbed_official 354:e67efb2aab0e 363 /* Set the number of channels to be converted in discontinuous mode */
mbed_official 354:e67efb2aab0e 364 tmp_cr1 |= ((ADC_CR1_DISCEN) |
mbed_official 354:e67efb2aab0e 365 __ADC_CR1_DISCONTINUOUS_NUM(hadc->Init.NbrOfDiscConversion));
mbed_official 354:e67efb2aab0e 366 }
mbed_official 354:e67efb2aab0e 367
mbed_official 354:e67efb2aab0e 368 /* Update ADC configuration register CR1 with previous settings */
mbed_official 354:e67efb2aab0e 369 MODIFY_REG(hadc->Instance->CR1,
mbed_official 354:e67efb2aab0e 370 ADC_CR1_RES |
mbed_official 354:e67efb2aab0e 371 ADC_CR1_PDI |
mbed_official 354:e67efb2aab0e 372 ADC_CR1_PDD |
mbed_official 354:e67efb2aab0e 373 ADC_CR1_DISCNUM |
mbed_official 354:e67efb2aab0e 374 ADC_CR1_DISCEN |
mbed_official 354:e67efb2aab0e 375 ADC_CR1_SCAN ,
mbed_official 354:e67efb2aab0e 376 tmp_cr1 );
mbed_official 354:e67efb2aab0e 377 }
mbed_official 354:e67efb2aab0e 378
mbed_official 354:e67efb2aab0e 379 /* Update ADC configuration register CR2 with previous settings */
mbed_official 354:e67efb2aab0e 380 MODIFY_REG(hadc->Instance->CR2 ,
mbed_official 354:e67efb2aab0e 381 __ADC_CR2_MASK_ADCINIT() ,
mbed_official 354:e67efb2aab0e 382 tmp_cr2 );
mbed_official 354:e67efb2aab0e 383
mbed_official 354:e67efb2aab0e 384 /* Configuration of regular group sequencer: */
mbed_official 354:e67efb2aab0e 385 /* - if scan mode is disabled, regular channels sequence length is set to */
mbed_official 354:e67efb2aab0e 386 /* 0x00: 1 channel converted (channel on regular rank 1) */
mbed_official 354:e67efb2aab0e 387 /* Parameter "NbrOfConversion" is discarded. */
mbed_official 354:e67efb2aab0e 388 /* Note: Scan mode is present by hardware on this device and, if */
mbed_official 354:e67efb2aab0e 389 /* disabled, discards automatically nb of conversions. Anyway, nb of */
mbed_official 354:e67efb2aab0e 390 /* conversions is forced to 0x00 for alignment over all STM32 devices. */
mbed_official 354:e67efb2aab0e 391 /* - if scan mode is enabled, regular channels sequence length is set to */
mbed_official 354:e67efb2aab0e 392 /* parameter "NbrOfConversion" */
mbed_official 354:e67efb2aab0e 393 if (hadc->Init.ScanConvMode == ADC_SCAN_ENABLE)
mbed_official 354:e67efb2aab0e 394 {
mbed_official 354:e67efb2aab0e 395 MODIFY_REG(hadc->Instance->SQR1 ,
mbed_official 354:e67efb2aab0e 396 ADC_SQR1_L ,
mbed_official 354:e67efb2aab0e 397 __ADC_SQR1_L(hadc->Init.NbrOfConversion) );
mbed_official 354:e67efb2aab0e 398 }
mbed_official 354:e67efb2aab0e 399 else
mbed_official 354:e67efb2aab0e 400 {
mbed_official 354:e67efb2aab0e 401 MODIFY_REG(hadc->Instance->SQR1,
mbed_official 354:e67efb2aab0e 402 ADC_SQR1_L ,
mbed_official 354:e67efb2aab0e 403 0x00000000 );
mbed_official 354:e67efb2aab0e 404 }
mbed_official 354:e67efb2aab0e 405
mbed_official 354:e67efb2aab0e 406 /* Check back that ADC registers have effectively been configured to */
mbed_official 354:e67efb2aab0e 407 /* ensure of no potential problem of ADC core IP clocking. */
mbed_official 354:e67efb2aab0e 408 /* Check through register CR2 (excluding execution control bits ADON, */
mbed_official 354:e67efb2aab0e 409 /* JSWSTART, SWSTART and injected trigger bits JEXTEN and JEXTSEL). */
mbed_official 354:e67efb2aab0e 410 if ((READ_REG(hadc->Instance->CR2) & ~(ADC_CR2_ADON |
mbed_official 354:e67efb2aab0e 411 ADC_CR2_SWSTART | ADC_CR2_JSWSTART |
mbed_official 354:e67efb2aab0e 412 ADC_CR2_JEXTEN | ADC_CR2_JEXTSEL ))
mbed_official 354:e67efb2aab0e 413 == tmp_cr2)
mbed_official 354:e67efb2aab0e 414 {
mbed_official 354:e67efb2aab0e 415 /* Set ADC error code to none */
mbed_official 354:e67efb2aab0e 416 __HAL_ADC_CLEAR_ERRORCODE(hadc);
mbed_official 354:e67efb2aab0e 417
mbed_official 354:e67efb2aab0e 418 /* Initialize the ADC state */
mbed_official 354:e67efb2aab0e 419 hadc->State = HAL_ADC_STATE_READY;
mbed_official 354:e67efb2aab0e 420 }
mbed_official 354:e67efb2aab0e 421 else
mbed_official 354:e67efb2aab0e 422 {
mbed_official 354:e67efb2aab0e 423 /* Update ADC state machine to error */
mbed_official 354:e67efb2aab0e 424 hadc->State = HAL_ADC_STATE_ERROR;
mbed_official 354:e67efb2aab0e 425
mbed_official 354:e67efb2aab0e 426 /* Set ADC error code to ADC IP internal error */
mbed_official 354:e67efb2aab0e 427 hadc->ErrorCode |= HAL_ADC_ERROR_INTERNAL;
mbed_official 354:e67efb2aab0e 428
mbed_official 354:e67efb2aab0e 429 tmpHALStatus = HAL_ERROR;
mbed_official 354:e67efb2aab0e 430 }
mbed_official 354:e67efb2aab0e 431
mbed_official 354:e67efb2aab0e 432 }
mbed_official 354:e67efb2aab0e 433 else
mbed_official 354:e67efb2aab0e 434 {
mbed_official 354:e67efb2aab0e 435 /* Update ADC state machine to error */
mbed_official 354:e67efb2aab0e 436 hadc->State = HAL_ADC_STATE_ERROR;
mbed_official 354:e67efb2aab0e 437
mbed_official 354:e67efb2aab0e 438 tmpHALStatus = HAL_ERROR;
mbed_official 354:e67efb2aab0e 439 }
mbed_official 354:e67efb2aab0e 440
mbed_official 354:e67efb2aab0e 441 /* Return function status */
mbed_official 354:e67efb2aab0e 442 return tmpHALStatus;
mbed_official 354:e67efb2aab0e 443 }
mbed_official 354:e67efb2aab0e 444
mbed_official 354:e67efb2aab0e 445 /**
mbed_official 354:e67efb2aab0e 446 * @brief Deinitialize the ADC peripheral registers to its default reset values.
mbed_official 354:e67efb2aab0e 447 * @note To not impact other ADCs, reset of common ADC registers have been
mbed_official 354:e67efb2aab0e 448 * left commented below.
mbed_official 354:e67efb2aab0e 449 * If needed, the example code can be copied and uncommented into
mbed_official 354:e67efb2aab0e 450 * function HAL_ADC_MspDeInit().
mbed_official 354:e67efb2aab0e 451 * @param hadc: ADC handle
mbed_official 354:e67efb2aab0e 452 * @retval HAL status
mbed_official 354:e67efb2aab0e 453 */
mbed_official 354:e67efb2aab0e 454 HAL_StatusTypeDef HAL_ADC_DeInit(ADC_HandleTypeDef* hadc)
mbed_official 354:e67efb2aab0e 455 {
mbed_official 354:e67efb2aab0e 456 HAL_StatusTypeDef tmpHALStatus = HAL_OK;
mbed_official 354:e67efb2aab0e 457
mbed_official 354:e67efb2aab0e 458 /* Check ADC handle */
mbed_official 354:e67efb2aab0e 459 if(hadc == HAL_NULL)
mbed_official 354:e67efb2aab0e 460 {
mbed_official 354:e67efb2aab0e 461 return HAL_ERROR;
mbed_official 354:e67efb2aab0e 462 }
mbed_official 354:e67efb2aab0e 463
mbed_official 354:e67efb2aab0e 464 /* Check the parameters */
mbed_official 354:e67efb2aab0e 465 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 354:e67efb2aab0e 466
mbed_official 354:e67efb2aab0e 467 /* Change ADC state */
mbed_official 354:e67efb2aab0e 468 hadc->State = HAL_ADC_STATE_BUSY;
mbed_official 354:e67efb2aab0e 469
mbed_official 354:e67efb2aab0e 470 /* Stop potential conversion on going, on regular and injected groups */
mbed_official 354:e67efb2aab0e 471 /* Disable ADC peripheral */
mbed_official 354:e67efb2aab0e 472 tmpHALStatus = ADC_ConversionStop_Disable(hadc);
mbed_official 354:e67efb2aab0e 473
mbed_official 354:e67efb2aab0e 474
mbed_official 354:e67efb2aab0e 475 /* Configuration of ADC parameters if previous preliminary actions are */
mbed_official 354:e67efb2aab0e 476 /* correctly completed. */
mbed_official 354:e67efb2aab0e 477 if (tmpHALStatus != HAL_ERROR)
mbed_official 354:e67efb2aab0e 478 {
mbed_official 354:e67efb2aab0e 479 /* ========== Reset ADC registers ========== */
mbed_official 354:e67efb2aab0e 480 /* Reset register SR */
mbed_official 354:e67efb2aab0e 481 __HAL_ADC_CLEAR_FLAG(hadc, (ADC_FLAG_AWD | ADC_FLAG_JEOC | ADC_FLAG_EOC |
mbed_official 354:e67efb2aab0e 482 ADC_FLAG_JSTRT | ADC_FLAG_STRT));
mbed_official 354:e67efb2aab0e 483
mbed_official 354:e67efb2aab0e 484 /* Reset register CR1 */
mbed_official 354:e67efb2aab0e 485 CLEAR_BIT(hadc->Instance->CR1, (ADC_CR1_OVRIE | ADC_CR1_RES | ADC_CR1_AWDEN |
mbed_official 354:e67efb2aab0e 486 ADC_CR1_JAWDEN | ADC_CR1_PDI | ADC_CR1_PDD |
mbed_official 354:e67efb2aab0e 487 ADC_CR1_DISCNUM | ADC_CR1_JDISCEN | ADC_CR1_DISCEN |
mbed_official 354:e67efb2aab0e 488 ADC_CR1_JAUTO | ADC_CR1_AWDSGL | ADC_CR1_SCAN |
mbed_official 354:e67efb2aab0e 489 ADC_CR1_JEOCIE | ADC_CR1_AWDIE | ADC_CR1_EOCIE |
mbed_official 354:e67efb2aab0e 490 ADC_CR1_AWDCH ));
mbed_official 354:e67efb2aab0e 491
mbed_official 354:e67efb2aab0e 492 /* Reset register CR2 */
mbed_official 354:e67efb2aab0e 493 __ADC_CR2_CLEAR(hadc);
mbed_official 354:e67efb2aab0e 494
mbed_official 354:e67efb2aab0e 495 /* Reset register SMPR0 */
mbed_official 354:e67efb2aab0e 496 __ADC_SMPR0_CLEAR(hadc);
mbed_official 354:e67efb2aab0e 497
mbed_official 354:e67efb2aab0e 498 /* Reset register SMPR1 */
mbed_official 354:e67efb2aab0e 499 CLEAR_BIT(hadc->Instance->SMPR1, (ADC_SMPR1_SMP29 | ADC_SMPR1_SMP28 | ADC_SMPR1_SMP27 |
mbed_official 354:e67efb2aab0e 500 ADC_SMPR1_SMP26 | ADC_SMPR1_SMP25 | ADC_SMPR1_SMP24 |
mbed_official 354:e67efb2aab0e 501 ADC_SMPR1_SMP23 | ADC_SMPR1_SMP22 | ADC_SMPR1_SMP21 |
mbed_official 354:e67efb2aab0e 502 ADC_SMPR1_SMP20 ));
mbed_official 354:e67efb2aab0e 503
mbed_official 354:e67efb2aab0e 504 /* Reset register SMPR2 */
mbed_official 354:e67efb2aab0e 505 CLEAR_BIT(hadc->Instance->SMPR2, (ADC_SMPR2_SMP19 | ADC_SMPR2_SMP18 | ADC_SMPR2_SMP17 |
mbed_official 354:e67efb2aab0e 506 ADC_SMPR2_SMP16 | ADC_SMPR2_SMP15 | ADC_SMPR2_SMP14 |
mbed_official 354:e67efb2aab0e 507 ADC_SMPR2_SMP13 | ADC_SMPR2_SMP12 | ADC_SMPR2_SMP11 |
mbed_official 354:e67efb2aab0e 508 ADC_SMPR2_SMP10 ));
mbed_official 354:e67efb2aab0e 509
mbed_official 354:e67efb2aab0e 510 /* Reset register SMPR3 */
mbed_official 354:e67efb2aab0e 511 CLEAR_BIT(hadc->Instance->SMPR3, (ADC_SMPR3_SMP9 | ADC_SMPR3_SMP8 | ADC_SMPR3_SMP7 |
mbed_official 354:e67efb2aab0e 512 ADC_SMPR3_SMP6 | ADC_SMPR3_SMP5 | ADC_SMPR3_SMP4 |
mbed_official 354:e67efb2aab0e 513 ADC_SMPR3_SMP3 | ADC_SMPR3_SMP2 | ADC_SMPR3_SMP1 |
mbed_official 354:e67efb2aab0e 514 ADC_SMPR3_SMP0 ));
mbed_official 354:e67efb2aab0e 515
mbed_official 354:e67efb2aab0e 516 /* Reset register JOFR1 */
mbed_official 354:e67efb2aab0e 517 CLEAR_BIT(hadc->Instance->JOFR1, ADC_JOFR1_JOFFSET1);
mbed_official 354:e67efb2aab0e 518 /* Reset register JOFR2 */
mbed_official 354:e67efb2aab0e 519 CLEAR_BIT(hadc->Instance->JOFR2, ADC_JOFR2_JOFFSET2);
mbed_official 354:e67efb2aab0e 520 /* Reset register JOFR3 */
mbed_official 354:e67efb2aab0e 521 CLEAR_BIT(hadc->Instance->JOFR3, ADC_JOFR3_JOFFSET3);
mbed_official 354:e67efb2aab0e 522 /* Reset register JOFR4 */
mbed_official 354:e67efb2aab0e 523 CLEAR_BIT(hadc->Instance->JOFR4, ADC_JOFR4_JOFFSET4);
mbed_official 354:e67efb2aab0e 524
mbed_official 354:e67efb2aab0e 525 /* Reset register HTR */
mbed_official 354:e67efb2aab0e 526 CLEAR_BIT(hadc->Instance->HTR, ADC_HTR_HT);
mbed_official 354:e67efb2aab0e 527 /* Reset register LTR */
mbed_official 354:e67efb2aab0e 528 CLEAR_BIT(hadc->Instance->LTR, ADC_LTR_LT);
mbed_official 354:e67efb2aab0e 529
mbed_official 354:e67efb2aab0e 530 /* Reset register SQR1 */
mbed_official 354:e67efb2aab0e 531 CLEAR_BIT(hadc->Instance->SQR1, (ADC_SQR1_L | __ADC_SQR1_SQXX));
mbed_official 354:e67efb2aab0e 532
mbed_official 354:e67efb2aab0e 533 /* Reset register SQR2 */
mbed_official 354:e67efb2aab0e 534 CLEAR_BIT(hadc->Instance->SQR2, (ADC_SQR2_SQ24 | ADC_SQR2_SQ23 | ADC_SQR2_SQ22 |
mbed_official 354:e67efb2aab0e 535 ADC_SQR2_SQ21 | ADC_SQR2_SQ20 | ADC_SQR2_SQ19 ));
mbed_official 354:e67efb2aab0e 536
mbed_official 354:e67efb2aab0e 537 /* Reset register SQR3 */
mbed_official 354:e67efb2aab0e 538 CLEAR_BIT(hadc->Instance->SQR3, (ADC_SQR3_SQ18 | ADC_SQR3_SQ17 | ADC_SQR3_SQ16 |
mbed_official 354:e67efb2aab0e 539 ADC_SQR3_SQ15 | ADC_SQR3_SQ14 | ADC_SQR3_SQ13 ));
mbed_official 354:e67efb2aab0e 540
mbed_official 354:e67efb2aab0e 541 /* Reset register SQR4 */
mbed_official 354:e67efb2aab0e 542 CLEAR_BIT(hadc->Instance->SQR4, (ADC_SQR4_SQ12 | ADC_SQR4_SQ11 | ADC_SQR4_SQ10 |
mbed_official 354:e67efb2aab0e 543 ADC_SQR4_SQ9 | ADC_SQR4_SQ8 | ADC_SQR4_SQ7 ));
mbed_official 354:e67efb2aab0e 544
mbed_official 354:e67efb2aab0e 545 /* Reset register SQR5 */
mbed_official 354:e67efb2aab0e 546 CLEAR_BIT(hadc->Instance->SQR5, (ADC_SQR5_SQ6 | ADC_SQR5_SQ5 | ADC_SQR5_SQ4 |
mbed_official 354:e67efb2aab0e 547 ADC_SQR5_SQ3 | ADC_SQR5_SQ2 | ADC_SQR5_SQ1 ));
mbed_official 354:e67efb2aab0e 548
mbed_official 354:e67efb2aab0e 549
mbed_official 354:e67efb2aab0e 550 /* Reset register JSQR */
mbed_official 354:e67efb2aab0e 551 CLEAR_BIT(hadc->Instance->JSQR, (ADC_JSQR_JL |
mbed_official 354:e67efb2aab0e 552 ADC_JSQR_JSQ4 | ADC_JSQR_JSQ3 |
mbed_official 354:e67efb2aab0e 553 ADC_JSQR_JSQ2 | ADC_JSQR_JSQ1 ));
mbed_official 354:e67efb2aab0e 554
mbed_official 354:e67efb2aab0e 555 /* Reset register JSQR */
mbed_official 354:e67efb2aab0e 556 CLEAR_BIT(hadc->Instance->JSQR, (ADC_JSQR_JL |
mbed_official 354:e67efb2aab0e 557 ADC_JSQR_JSQ4 | ADC_JSQR_JSQ3 |
mbed_official 354:e67efb2aab0e 558 ADC_JSQR_JSQ2 | ADC_JSQR_JSQ1 ));
mbed_official 354:e67efb2aab0e 559
mbed_official 354:e67efb2aab0e 560 /* Reset register DR */
mbed_official 354:e67efb2aab0e 561 /* bits in access mode read only, no direct reset applicable*/
mbed_official 354:e67efb2aab0e 562
mbed_official 354:e67efb2aab0e 563 /* Reset registers JDR1, JDR2, JDR3, JDR4 */
mbed_official 354:e67efb2aab0e 564 /* bits in access mode read only, no direct reset applicable*/
mbed_official 354:e67efb2aab0e 565
mbed_official 354:e67efb2aab0e 566 /* Reset register CCR */
mbed_official 354:e67efb2aab0e 567 CLEAR_BIT(ADC->CCR, ADC_CCR_TSVREFE);
mbed_official 354:e67efb2aab0e 568
mbed_official 354:e67efb2aab0e 569 /* ========== Hard reset ADC peripheral ========== */
mbed_official 354:e67efb2aab0e 570 /* Performs a global reset of the entire ADC peripheral: ADC state is */
mbed_official 354:e67efb2aab0e 571 /* forced to a similar state after device power-on. */
mbed_official 354:e67efb2aab0e 572 /* If needed, copy-paste and uncomment the following reset code into */
mbed_official 354:e67efb2aab0e 573 /* function "void HAL_ADC_MspInit(ADC_HandleTypeDef* hadc)": */
mbed_official 354:e67efb2aab0e 574 /* */
mbed_official 354:e67efb2aab0e 575 /* __ADC1_FORCE_RESET() */
mbed_official 354:e67efb2aab0e 576 /* __ADC1_RELEASE_RESET() */
mbed_official 354:e67efb2aab0e 577
mbed_official 354:e67efb2aab0e 578 /* DeInit the low level hardware */
mbed_official 354:e67efb2aab0e 579 HAL_ADC_MspDeInit(hadc);
mbed_official 354:e67efb2aab0e 580
mbed_official 354:e67efb2aab0e 581 /* Set ADC error code to none */
mbed_official 354:e67efb2aab0e 582 __HAL_ADC_CLEAR_ERRORCODE(hadc);
mbed_official 354:e67efb2aab0e 583
mbed_official 354:e67efb2aab0e 584 /* Change ADC state */
mbed_official 354:e67efb2aab0e 585 hadc->State = HAL_ADC_STATE_RESET;
mbed_official 354:e67efb2aab0e 586
mbed_official 354:e67efb2aab0e 587 }
mbed_official 354:e67efb2aab0e 588
mbed_official 354:e67efb2aab0e 589 /* Process unlocked */
mbed_official 354:e67efb2aab0e 590 __HAL_UNLOCK(hadc);
mbed_official 354:e67efb2aab0e 591
mbed_official 354:e67efb2aab0e 592 /* Return function status */
mbed_official 354:e67efb2aab0e 593 return tmpHALStatus;
mbed_official 354:e67efb2aab0e 594 }
mbed_official 354:e67efb2aab0e 595
mbed_official 354:e67efb2aab0e 596 /**
mbed_official 354:e67efb2aab0e 597 * @brief Initializes the ADC MSP.
mbed_official 354:e67efb2aab0e 598 * @param hadc: ADC handle
mbed_official 354:e67efb2aab0e 599 * @retval None
mbed_official 354:e67efb2aab0e 600 */
mbed_official 354:e67efb2aab0e 601 __weak void HAL_ADC_MspInit(ADC_HandleTypeDef* hadc)
mbed_official 354:e67efb2aab0e 602 {
mbed_official 354:e67efb2aab0e 603 /* NOTE : This function should not be modified. When the callback is needed,
mbed_official 354:e67efb2aab0e 604 function HAL_ADC_MspInit must be implemented in the user file.
mbed_official 354:e67efb2aab0e 605 */
mbed_official 354:e67efb2aab0e 606 }
mbed_official 354:e67efb2aab0e 607
mbed_official 354:e67efb2aab0e 608 /**
mbed_official 354:e67efb2aab0e 609 * @brief DeInitializes the ADC MSP.
mbed_official 354:e67efb2aab0e 610 * @param hadc: ADC handle
mbed_official 354:e67efb2aab0e 611 * @retval None
mbed_official 354:e67efb2aab0e 612 */
mbed_official 354:e67efb2aab0e 613 __weak void HAL_ADC_MspDeInit(ADC_HandleTypeDef* hadc)
mbed_official 354:e67efb2aab0e 614 {
mbed_official 354:e67efb2aab0e 615 /* NOTE : This function should not be modified. When the callback is needed,
mbed_official 354:e67efb2aab0e 616 function HAL_ADC_MspDeInit must be implemented in the user file.
mbed_official 354:e67efb2aab0e 617 */
mbed_official 354:e67efb2aab0e 618 }
mbed_official 354:e67efb2aab0e 619
mbed_official 354:e67efb2aab0e 620 /**
mbed_official 354:e67efb2aab0e 621 * @}
mbed_official 354:e67efb2aab0e 622 */
mbed_official 354:e67efb2aab0e 623
mbed_official 354:e67efb2aab0e 624 /** @defgroup ADC_Exported_Functions_Group2 IO operation functions
mbed_official 354:e67efb2aab0e 625 * @brief IO operation functions
mbed_official 354:e67efb2aab0e 626 *
mbed_official 354:e67efb2aab0e 627 @verbatim
mbed_official 354:e67efb2aab0e 628 ===============================================================================
mbed_official 354:e67efb2aab0e 629 ##### IO operation functions #####
mbed_official 354:e67efb2aab0e 630 ===============================================================================
mbed_official 354:e67efb2aab0e 631 [..] This section provides functions allowing to:
mbed_official 354:e67efb2aab0e 632 (+) Start conversion of regular group.
mbed_official 354:e67efb2aab0e 633 (+) Stop conversion of regular group.
mbed_official 354:e67efb2aab0e 634 (+) Poll for conversion complete on regular group.
mbed_official 354:e67efb2aab0e 635 (+) Poll for conversion event.
mbed_official 354:e67efb2aab0e 636 (+) Get result of regular channel conversion.
mbed_official 354:e67efb2aab0e 637 (+) Start conversion of regular group and enable interruptions.
mbed_official 354:e67efb2aab0e 638 (+) Stop conversion of regular group and disable interruptions.
mbed_official 354:e67efb2aab0e 639 (+) Handle ADC interrupt request
mbed_official 354:e67efb2aab0e 640 (+) Start conversion of regular group and enable DMA transfer.
mbed_official 354:e67efb2aab0e 641 (+) Stop conversion of regular group and disable ADC DMA transfer.
mbed_official 354:e67efb2aab0e 642 @endverbatim
mbed_official 354:e67efb2aab0e 643 * @{
mbed_official 354:e67efb2aab0e 644 */
mbed_official 354:e67efb2aab0e 645
mbed_official 354:e67efb2aab0e 646 /**
mbed_official 354:e67efb2aab0e 647 * @brief Enables ADC, starts conversion of regular group.
mbed_official 354:e67efb2aab0e 648 * Interruptions enabled in this function: None.
mbed_official 354:e67efb2aab0e 649 * @param hadc: ADC handle
mbed_official 354:e67efb2aab0e 650 * @retval HAL status
mbed_official 354:e67efb2aab0e 651 */
mbed_official 354:e67efb2aab0e 652 HAL_StatusTypeDef HAL_ADC_Start(ADC_HandleTypeDef* hadc)
mbed_official 354:e67efb2aab0e 653 {
mbed_official 354:e67efb2aab0e 654 HAL_StatusTypeDef tmpHALStatus = HAL_OK;
mbed_official 354:e67efb2aab0e 655
mbed_official 354:e67efb2aab0e 656 /* Check the parameters */
mbed_official 354:e67efb2aab0e 657 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 354:e67efb2aab0e 658
mbed_official 354:e67efb2aab0e 659 /* Process locked */
mbed_official 354:e67efb2aab0e 660 __HAL_LOCK(hadc);
mbed_official 354:e67efb2aab0e 661
mbed_official 354:e67efb2aab0e 662 /* Enable the ADC peripheral */
mbed_official 354:e67efb2aab0e 663 tmpHALStatus = ADC_Enable(hadc);
mbed_official 354:e67efb2aab0e 664
mbed_official 354:e67efb2aab0e 665 /* Start conversion if ADC is effectively enabled */
mbed_official 354:e67efb2aab0e 666 if (tmpHALStatus != HAL_ERROR)
mbed_official 354:e67efb2aab0e 667 {
mbed_official 354:e67efb2aab0e 668 /* State machine update: Check if an injected conversion is ongoing */
mbed_official 354:e67efb2aab0e 669 if(hadc->State == HAL_ADC_STATE_BUSY_INJ)
mbed_official 354:e67efb2aab0e 670 {
mbed_official 354:e67efb2aab0e 671 /* Change ADC state */
mbed_official 354:e67efb2aab0e 672 hadc->State = HAL_ADC_STATE_BUSY_INJ_REG;
mbed_official 354:e67efb2aab0e 673 }
mbed_official 354:e67efb2aab0e 674 else
mbed_official 354:e67efb2aab0e 675 {
mbed_official 354:e67efb2aab0e 676 /* Change ADC state */
mbed_official 354:e67efb2aab0e 677 hadc->State = HAL_ADC_STATE_BUSY_REG;
mbed_official 354:e67efb2aab0e 678 }
mbed_official 354:e67efb2aab0e 679
mbed_official 354:e67efb2aab0e 680 /* Set ADC error code to none */
mbed_official 354:e67efb2aab0e 681 __HAL_ADC_CLEAR_ERRORCODE(hadc);
mbed_official 354:e67efb2aab0e 682
mbed_official 354:e67efb2aab0e 683 /* Clear regular group conversion flag and overrun flag */
mbed_official 354:e67efb2aab0e 684 /* (To ensure of no unknown state from potential previous ADC operations) */
mbed_official 354:e67efb2aab0e 685 __HAL_ADC_CLEAR_FLAG(hadc, ADC_FLAG_EOC);
mbed_official 354:e67efb2aab0e 686
mbed_official 354:e67efb2aab0e 687 /* Start conversion of regular group if software start has been selected. */
mbed_official 354:e67efb2aab0e 688 /* If external trigger has been selected, conversion will start at next */
mbed_official 354:e67efb2aab0e 689 /* trigger event. */
mbed_official 354:e67efb2aab0e 690 if (__HAL_ADC_IS_SOFTWARE_START_REGULAR(hadc))
mbed_official 354:e67efb2aab0e 691 {
mbed_official 354:e67efb2aab0e 692 /* Start ADC conversion on regular group */
mbed_official 354:e67efb2aab0e 693 SET_BIT(hadc->Instance->CR2, ADC_CR2_SWSTART);
mbed_official 354:e67efb2aab0e 694 }
mbed_official 354:e67efb2aab0e 695 }
mbed_official 354:e67efb2aab0e 696
mbed_official 354:e67efb2aab0e 697 /* Process unlocked */
mbed_official 354:e67efb2aab0e 698 __HAL_UNLOCK(hadc);
mbed_official 354:e67efb2aab0e 699
mbed_official 354:e67efb2aab0e 700 /* Return function status */
mbed_official 354:e67efb2aab0e 701 return tmpHALStatus;
mbed_official 354:e67efb2aab0e 702 }
mbed_official 354:e67efb2aab0e 703
mbed_official 354:e67efb2aab0e 704 /**
mbed_official 354:e67efb2aab0e 705 * @brief Stop ADC conversion of regular group (and injected channels in
mbed_official 354:e67efb2aab0e 706 * case of auto_injection mode), disable ADC peripheral.
mbed_official 354:e67efb2aab0e 707 * @note: ADC peripheral disable is forcing interruption of potential
mbed_official 354:e67efb2aab0e 708 * conversion on injected group. If injected group is under use, it
mbed_official 354:e67efb2aab0e 709 * should be preliminarily stopped using HAL_ADCEx_InjectedStop function.
mbed_official 354:e67efb2aab0e 710 * @param hadc: ADC handle
mbed_official 354:e67efb2aab0e 711 * @retval HAL status.
mbed_official 354:e67efb2aab0e 712 */
mbed_official 354:e67efb2aab0e 713 HAL_StatusTypeDef HAL_ADC_Stop(ADC_HandleTypeDef* hadc)
mbed_official 354:e67efb2aab0e 714 {
mbed_official 354:e67efb2aab0e 715 HAL_StatusTypeDef tmpHALStatus = HAL_OK;
mbed_official 354:e67efb2aab0e 716
mbed_official 354:e67efb2aab0e 717 /* Check the parameters */
mbed_official 354:e67efb2aab0e 718 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 354:e67efb2aab0e 719
mbed_official 354:e67efb2aab0e 720 /* Process locked */
mbed_official 354:e67efb2aab0e 721 __HAL_LOCK(hadc);
mbed_official 354:e67efb2aab0e 722
mbed_official 354:e67efb2aab0e 723 /* Stop potential conversion on going, on regular and injected groups */
mbed_official 354:e67efb2aab0e 724 /* Disable ADC peripheral */
mbed_official 354:e67efb2aab0e 725 tmpHALStatus = ADC_ConversionStop_Disable(hadc);
mbed_official 354:e67efb2aab0e 726
mbed_official 354:e67efb2aab0e 727 /* Check if ADC is effectively disabled */
mbed_official 354:e67efb2aab0e 728 if (tmpHALStatus != HAL_ERROR)
mbed_official 354:e67efb2aab0e 729 {
mbed_official 354:e67efb2aab0e 730 /* Change ADC state */
mbed_official 354:e67efb2aab0e 731 hadc->State = HAL_ADC_STATE_READY;
mbed_official 354:e67efb2aab0e 732 }
mbed_official 354:e67efb2aab0e 733
mbed_official 354:e67efb2aab0e 734 /* Process unlocked */
mbed_official 354:e67efb2aab0e 735 __HAL_UNLOCK(hadc);
mbed_official 354:e67efb2aab0e 736
mbed_official 354:e67efb2aab0e 737 /* Return function status */
mbed_official 354:e67efb2aab0e 738 return tmpHALStatus;
mbed_official 354:e67efb2aab0e 739 }
mbed_official 354:e67efb2aab0e 740
mbed_official 354:e67efb2aab0e 741 /**
mbed_official 354:e67efb2aab0e 742 * @brief Wait for regular group conversion to be completed.
mbed_official 354:e67efb2aab0e 743 * @param hadc: ADC handle
mbed_official 354:e67efb2aab0e 744 * @param Timeout: Timeout value in millisecond.
mbed_official 354:e67efb2aab0e 745 * @retval HAL status
mbed_official 354:e67efb2aab0e 746 */
mbed_official 354:e67efb2aab0e 747 HAL_StatusTypeDef HAL_ADC_PollForConversion(ADC_HandleTypeDef* hadc, uint32_t Timeout)
mbed_official 354:e67efb2aab0e 748 {
mbed_official 354:e67efb2aab0e 749 uint32_t tickstart = 0;
mbed_official 354:e67efb2aab0e 750
mbed_official 354:e67efb2aab0e 751 /* Check the parameters */
mbed_official 354:e67efb2aab0e 752 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 354:e67efb2aab0e 753
mbed_official 354:e67efb2aab0e 754 /* Get timeout */
mbed_official 354:e67efb2aab0e 755 tickstart = HAL_GetTick();
mbed_official 354:e67efb2aab0e 756
mbed_official 354:e67efb2aab0e 757 /* Wait until End of Conversion flag is raised */
mbed_official 354:e67efb2aab0e 758 while(HAL_IS_BIT_CLR(hadc->Instance->SR, ADC_FLAG_EOC))
mbed_official 354:e67efb2aab0e 759 {
mbed_official 354:e67efb2aab0e 760 /* Check if timeout is disabled (set to infinite wait) */
mbed_official 354:e67efb2aab0e 761 if(Timeout != HAL_MAX_DELAY)
mbed_official 354:e67efb2aab0e 762 {
mbed_official 354:e67efb2aab0e 763 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 354:e67efb2aab0e 764 {
mbed_official 354:e67efb2aab0e 765 /* Update ADC state machine to timeout */
mbed_official 354:e67efb2aab0e 766 hadc->State = HAL_ADC_STATE_TIMEOUT;
mbed_official 354:e67efb2aab0e 767
mbed_official 354:e67efb2aab0e 768 /* Process unlocked */
mbed_official 354:e67efb2aab0e 769 __HAL_UNLOCK(hadc);
mbed_official 354:e67efb2aab0e 770
mbed_official 354:e67efb2aab0e 771 return HAL_ERROR;
mbed_official 354:e67efb2aab0e 772 }
mbed_official 354:e67efb2aab0e 773 }
mbed_official 354:e67efb2aab0e 774 }
mbed_official 354:e67efb2aab0e 775
mbed_official 354:e67efb2aab0e 776 /* Clear end of conversion flag of regular group if low power feature "Auto */
mbed_official 354:e67efb2aab0e 777 /* Wait" is disabled, to not interfere with this feature until data */
mbed_official 354:e67efb2aab0e 778 /* register is read using function HAL_ADC_GetValue(). */
mbed_official 354:e67efb2aab0e 779 if (hadc->Init.LowPowerAutoWait == DISABLE)
mbed_official 354:e67efb2aab0e 780 {
mbed_official 354:e67efb2aab0e 781 /* Clear regular group conversion flag */
mbed_official 354:e67efb2aab0e 782 __HAL_ADC_CLEAR_FLAG(hadc, ADC_FLAG_STRT | ADC_FLAG_EOC);
mbed_official 354:e67efb2aab0e 783 }
mbed_official 354:e67efb2aab0e 784
mbed_official 354:e67efb2aab0e 785 /* Update state machine on conversion status if not in error state */
mbed_official 354:e67efb2aab0e 786 if(hadc->State != HAL_ADC_STATE_ERROR)
mbed_official 354:e67efb2aab0e 787 {
mbed_official 354:e67efb2aab0e 788 /* Update ADC state machine */
mbed_official 354:e67efb2aab0e 789 if(hadc->State != HAL_ADC_STATE_EOC_INJ_REG)
mbed_official 354:e67efb2aab0e 790 {
mbed_official 354:e67efb2aab0e 791 /* Check if a conversion is ready on injected group */
mbed_official 354:e67efb2aab0e 792 if(hadc->State == HAL_ADC_STATE_EOC_INJ)
mbed_official 354:e67efb2aab0e 793 {
mbed_official 354:e67efb2aab0e 794 /* Change ADC state */
mbed_official 354:e67efb2aab0e 795 hadc->State = HAL_ADC_STATE_EOC_INJ_REG;
mbed_official 354:e67efb2aab0e 796 }
mbed_official 354:e67efb2aab0e 797 else
mbed_official 354:e67efb2aab0e 798 {
mbed_official 354:e67efb2aab0e 799 /* Change ADC state */
mbed_official 354:e67efb2aab0e 800 hadc->State = HAL_ADC_STATE_EOC_REG;
mbed_official 354:e67efb2aab0e 801 }
mbed_official 354:e67efb2aab0e 802 }
mbed_official 354:e67efb2aab0e 803 }
mbed_official 354:e67efb2aab0e 804
mbed_official 354:e67efb2aab0e 805 /* Return ADC state */
mbed_official 354:e67efb2aab0e 806 return HAL_OK;
mbed_official 354:e67efb2aab0e 807 }
mbed_official 354:e67efb2aab0e 808
mbed_official 354:e67efb2aab0e 809 /**
mbed_official 354:e67efb2aab0e 810 * @brief Poll for conversion event.
mbed_official 354:e67efb2aab0e 811 * @param hadc: ADC handle
mbed_official 354:e67efb2aab0e 812 * @param EventType: the ADC event type.
mbed_official 354:e67efb2aab0e 813 * This parameter can be one of the following values:
mbed_official 354:e67efb2aab0e 814 * @arg AWD_EVENT: ADC Analog watchdog event.
mbed_official 354:e67efb2aab0e 815 * @arg OVR_EVENT: ADC Overrun event
mbed_official 354:e67efb2aab0e 816 * @param Timeout: Timeout value in millisecond.
mbed_official 354:e67efb2aab0e 817 * @retval HAL status
mbed_official 354:e67efb2aab0e 818 */
mbed_official 354:e67efb2aab0e 819 HAL_StatusTypeDef HAL_ADC_PollForEvent(ADC_HandleTypeDef* hadc, uint32_t EventType, uint32_t Timeout)
mbed_official 354:e67efb2aab0e 820 {
mbed_official 354:e67efb2aab0e 821 uint32_t tickstart = 0;
mbed_official 354:e67efb2aab0e 822
mbed_official 354:e67efb2aab0e 823 /* Check the parameters */
mbed_official 354:e67efb2aab0e 824 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 354:e67efb2aab0e 825 assert_param(IS_ADC_EVENT_TYPE(EventType));
mbed_official 354:e67efb2aab0e 826
mbed_official 354:e67efb2aab0e 827 /* Get timeout */
mbed_official 354:e67efb2aab0e 828 tickstart = HAL_GetTick();
mbed_official 354:e67efb2aab0e 829
mbed_official 354:e67efb2aab0e 830 /* Check selected event flag */
mbed_official 354:e67efb2aab0e 831 while(__HAL_ADC_GET_FLAG(hadc, EventType) == RESET)
mbed_official 354:e67efb2aab0e 832 {
mbed_official 354:e67efb2aab0e 833 /* Check if timeout is disabled (set to infinite wait) */
mbed_official 354:e67efb2aab0e 834 if(Timeout != HAL_MAX_DELAY)
mbed_official 354:e67efb2aab0e 835 {
mbed_official 354:e67efb2aab0e 836 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 354:e67efb2aab0e 837 {
mbed_official 354:e67efb2aab0e 838 /* Update ADC state machine to timeout */
mbed_official 354:e67efb2aab0e 839 hadc->State = HAL_ADC_STATE_TIMEOUT;
mbed_official 354:e67efb2aab0e 840
mbed_official 354:e67efb2aab0e 841 /* Process unlocked */
mbed_official 354:e67efb2aab0e 842 __HAL_UNLOCK(hadc);
mbed_official 354:e67efb2aab0e 843
mbed_official 354:e67efb2aab0e 844 return HAL_ERROR;
mbed_official 354:e67efb2aab0e 845 }
mbed_official 354:e67efb2aab0e 846 }
mbed_official 354:e67efb2aab0e 847 }
mbed_official 354:e67efb2aab0e 848
mbed_official 354:e67efb2aab0e 849 switch(EventType)
mbed_official 354:e67efb2aab0e 850 {
mbed_official 354:e67efb2aab0e 851 /* Analog watchdog (level out of window) event */
mbed_official 354:e67efb2aab0e 852 case AWD_EVENT:
mbed_official 354:e67efb2aab0e 853 /* Change ADC state */
mbed_official 354:e67efb2aab0e 854 hadc->State = HAL_ADC_STATE_AWD;
mbed_official 354:e67efb2aab0e 855
mbed_official 354:e67efb2aab0e 856 /* Clear ADC analog watchdog flag */
mbed_official 354:e67efb2aab0e 857 __HAL_ADC_CLEAR_FLAG(hadc, ADC_FLAG_AWD);
mbed_official 354:e67efb2aab0e 858 break;
mbed_official 354:e67efb2aab0e 859
mbed_official 354:e67efb2aab0e 860 /* Overrun event */
mbed_official 354:e67efb2aab0e 861 default: /* Case OVR_EVENT */
mbed_official 354:e67efb2aab0e 862 /* Change ADC state */
mbed_official 354:e67efb2aab0e 863 hadc->State = HAL_ADC_STATE_ERROR;
mbed_official 354:e67efb2aab0e 864
mbed_official 354:e67efb2aab0e 865 /* Set ADC error code to overrun */
mbed_official 354:e67efb2aab0e 866 hadc->ErrorCode |= HAL_ADC_ERROR_OVR;
mbed_official 354:e67efb2aab0e 867
mbed_official 354:e67efb2aab0e 868 /* Clear ADC Overrun flag */
mbed_official 354:e67efb2aab0e 869 __HAL_ADC_CLEAR_FLAG(hadc, ADC_FLAG_OVR);
mbed_official 354:e67efb2aab0e 870 break;
mbed_official 354:e67efb2aab0e 871 }
mbed_official 354:e67efb2aab0e 872
mbed_official 354:e67efb2aab0e 873 /* Return ADC state */
mbed_official 354:e67efb2aab0e 874 return HAL_OK;
mbed_official 354:e67efb2aab0e 875 }
mbed_official 354:e67efb2aab0e 876
mbed_official 354:e67efb2aab0e 877 /**
mbed_official 354:e67efb2aab0e 878 * @brief Enables ADC, starts conversion of regular group with interruption.
mbed_official 354:e67efb2aab0e 879 * Interruptions enabled in this function: EOC (end of conversion),
mbed_official 354:e67efb2aab0e 880 * overrun.
mbed_official 354:e67efb2aab0e 881 * Each of these interruptions has its dedicated callback function.
mbed_official 354:e67efb2aab0e 882 * @param hadc: ADC handle
mbed_official 354:e67efb2aab0e 883 * @retval HAL status
mbed_official 354:e67efb2aab0e 884 */
mbed_official 354:e67efb2aab0e 885 HAL_StatusTypeDef HAL_ADC_Start_IT(ADC_HandleTypeDef* hadc)
mbed_official 354:e67efb2aab0e 886 {
mbed_official 354:e67efb2aab0e 887 HAL_StatusTypeDef tmpHALStatus = HAL_OK;
mbed_official 354:e67efb2aab0e 888
mbed_official 354:e67efb2aab0e 889 /* Check the parameters */
mbed_official 354:e67efb2aab0e 890 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 354:e67efb2aab0e 891
mbed_official 354:e67efb2aab0e 892 /* Process locked */
mbed_official 354:e67efb2aab0e 893 __HAL_LOCK(hadc);
mbed_official 354:e67efb2aab0e 894
mbed_official 354:e67efb2aab0e 895 /* Enable the ADC peripheral */
mbed_official 354:e67efb2aab0e 896 tmpHALStatus = ADC_Enable(hadc);
mbed_official 354:e67efb2aab0e 897
mbed_official 354:e67efb2aab0e 898 /* Start conversion if ADC is effectively enabled */
mbed_official 354:e67efb2aab0e 899 if (tmpHALStatus != HAL_ERROR)
mbed_official 354:e67efb2aab0e 900 {
mbed_official 354:e67efb2aab0e 901 /* State machine update: Check if an injected conversion is ongoing */
mbed_official 354:e67efb2aab0e 902 if(hadc->State == HAL_ADC_STATE_BUSY_INJ)
mbed_official 354:e67efb2aab0e 903 {
mbed_official 354:e67efb2aab0e 904 /* Change ADC state */
mbed_official 354:e67efb2aab0e 905 hadc->State = HAL_ADC_STATE_BUSY_INJ_REG;
mbed_official 354:e67efb2aab0e 906 }
mbed_official 354:e67efb2aab0e 907 else
mbed_official 354:e67efb2aab0e 908 {
mbed_official 354:e67efb2aab0e 909 /* Change ADC state */
mbed_official 354:e67efb2aab0e 910 hadc->State = HAL_ADC_STATE_BUSY_REG;
mbed_official 354:e67efb2aab0e 911 }
mbed_official 354:e67efb2aab0e 912
mbed_official 354:e67efb2aab0e 913 /* Set ADC error code to none */
mbed_official 354:e67efb2aab0e 914 __HAL_ADC_CLEAR_ERRORCODE(hadc);
mbed_official 354:e67efb2aab0e 915
mbed_official 354:e67efb2aab0e 916 /* Clear regular group conversion flag and overrun flag */
mbed_official 354:e67efb2aab0e 917 /* (To ensure of no unknown state from potential previous ADC operations) */
mbed_official 354:e67efb2aab0e 918 __HAL_ADC_CLEAR_FLAG(hadc, ADC_FLAG_EOC);
mbed_official 354:e67efb2aab0e 919
mbed_official 354:e67efb2aab0e 920 /* Enable end of conversion interrupt for regular group */
mbed_official 354:e67efb2aab0e 921 __HAL_ADC_ENABLE_IT(hadc, (ADC_IT_EOC | ADC_IT_OVR));
mbed_official 354:e67efb2aab0e 922
mbed_official 354:e67efb2aab0e 923 /* Start conversion of regular group if software start has been selected. */
mbed_official 354:e67efb2aab0e 924 /* If external trigger has been selected, conversion will start at next */
mbed_official 354:e67efb2aab0e 925 /* trigger event. */
mbed_official 354:e67efb2aab0e 926 if (__HAL_ADC_IS_SOFTWARE_START_REGULAR(hadc))
mbed_official 354:e67efb2aab0e 927 {
mbed_official 354:e67efb2aab0e 928 /* Start ADC conversion on regular group */
mbed_official 354:e67efb2aab0e 929 SET_BIT(hadc->Instance->CR2, ADC_CR2_SWSTART);
mbed_official 354:e67efb2aab0e 930 }
mbed_official 354:e67efb2aab0e 931
mbed_official 354:e67efb2aab0e 932 }
mbed_official 354:e67efb2aab0e 933
mbed_official 354:e67efb2aab0e 934 /* Process unlocked */
mbed_official 354:e67efb2aab0e 935 __HAL_UNLOCK(hadc);
mbed_official 354:e67efb2aab0e 936
mbed_official 354:e67efb2aab0e 937 /* Return function status */
mbed_official 354:e67efb2aab0e 938 return tmpHALStatus;
mbed_official 354:e67efb2aab0e 939 }
mbed_official 354:e67efb2aab0e 940
mbed_official 354:e67efb2aab0e 941 /**
mbed_official 354:e67efb2aab0e 942 * @brief Stop ADC conversion of regular group (and injected group in
mbed_official 354:e67efb2aab0e 943 * case of auto_injection mode), disable interrution of
mbed_official 354:e67efb2aab0e 944 * end-of-conversion, disable ADC peripheral.
mbed_official 354:e67efb2aab0e 945 * @param hadc: ADC handle
mbed_official 354:e67efb2aab0e 946 * @retval None
mbed_official 354:e67efb2aab0e 947 */
mbed_official 354:e67efb2aab0e 948 HAL_StatusTypeDef HAL_ADC_Stop_IT(ADC_HandleTypeDef* hadc)
mbed_official 354:e67efb2aab0e 949 {
mbed_official 354:e67efb2aab0e 950 HAL_StatusTypeDef tmpHALStatus = HAL_OK;
mbed_official 354:e67efb2aab0e 951
mbed_official 354:e67efb2aab0e 952 /* Check the parameters */
mbed_official 354:e67efb2aab0e 953 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 354:e67efb2aab0e 954
mbed_official 354:e67efb2aab0e 955 /* Process locked */
mbed_official 354:e67efb2aab0e 956 __HAL_LOCK(hadc);
mbed_official 354:e67efb2aab0e 957
mbed_official 354:e67efb2aab0e 958 /* Stop potential conversion on going, on regular and injected groups */
mbed_official 354:e67efb2aab0e 959 /* Disable ADC peripheral */
mbed_official 354:e67efb2aab0e 960 tmpHALStatus = ADC_ConversionStop_Disable(hadc);
mbed_official 354:e67efb2aab0e 961
mbed_official 354:e67efb2aab0e 962 /* Check if ADC is effectively disabled */
mbed_official 354:e67efb2aab0e 963 if (tmpHALStatus != HAL_ERROR)
mbed_official 354:e67efb2aab0e 964 {
mbed_official 354:e67efb2aab0e 965 /* Disable ADC end of conversion interrupt for regular group */
mbed_official 354:e67efb2aab0e 966 __HAL_ADC_DISABLE_IT(hadc, ADC_IT_EOC);
mbed_official 354:e67efb2aab0e 967
mbed_official 354:e67efb2aab0e 968 /* Change ADC state */
mbed_official 354:e67efb2aab0e 969 hadc->State = HAL_ADC_STATE_READY;
mbed_official 354:e67efb2aab0e 970 }
mbed_official 354:e67efb2aab0e 971
mbed_official 354:e67efb2aab0e 972 /* Process unlocked */
mbed_official 354:e67efb2aab0e 973 __HAL_UNLOCK(hadc);
mbed_official 354:e67efb2aab0e 974
mbed_official 354:e67efb2aab0e 975 /* Return function status */
mbed_official 354:e67efb2aab0e 976 return tmpHALStatus;
mbed_official 354:e67efb2aab0e 977 }
mbed_official 354:e67efb2aab0e 978
mbed_official 354:e67efb2aab0e 979 /**
mbed_official 354:e67efb2aab0e 980 * @brief Enables ADC, starts conversion of regular group and transfers result
mbed_official 354:e67efb2aab0e 981 * through DMA.
mbed_official 354:e67efb2aab0e 982 * Interruptions enabled in this function:
mbed_official 354:e67efb2aab0e 983 * overrun, DMA half transfer, DMA transfer complete.
mbed_official 354:e67efb2aab0e 984 * Each of these interruptions has its dedicated callback function.
mbed_official 354:e67efb2aab0e 985 * @param hadc: ADC handle
mbed_official 354:e67efb2aab0e 986 * @param pData: The destination Buffer address.
mbed_official 354:e67efb2aab0e 987 * @param Length: The length of data to be transferred from ADC peripheral to memory.
mbed_official 354:e67efb2aab0e 988 * @retval None
mbed_official 354:e67efb2aab0e 989 */
mbed_official 354:e67efb2aab0e 990 HAL_StatusTypeDef HAL_ADC_Start_DMA(ADC_HandleTypeDef* hadc, uint32_t* pData, uint32_t Length)
mbed_official 354:e67efb2aab0e 991 {
mbed_official 354:e67efb2aab0e 992 HAL_StatusTypeDef tmpHALStatus = HAL_OK;
mbed_official 354:e67efb2aab0e 993
mbed_official 354:e67efb2aab0e 994 /* Check the parameters */
mbed_official 354:e67efb2aab0e 995 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 354:e67efb2aab0e 996
mbed_official 354:e67efb2aab0e 997 /* Process locked */
mbed_official 354:e67efb2aab0e 998 __HAL_LOCK(hadc);
mbed_official 354:e67efb2aab0e 999
mbed_official 354:e67efb2aab0e 1000 /* Enable the ADC peripheral */
mbed_official 354:e67efb2aab0e 1001 tmpHALStatus = ADC_Enable(hadc);
mbed_official 354:e67efb2aab0e 1002
mbed_official 354:e67efb2aab0e 1003 /* Start conversion if ADC is effectively enabled */
mbed_official 354:e67efb2aab0e 1004 if (tmpHALStatus != HAL_ERROR)
mbed_official 354:e67efb2aab0e 1005 {
mbed_official 354:e67efb2aab0e 1006 /* State machine update: Check if an injected conversion is ongoing */
mbed_official 354:e67efb2aab0e 1007 if(hadc->State == HAL_ADC_STATE_BUSY_INJ)
mbed_official 354:e67efb2aab0e 1008 {
mbed_official 354:e67efb2aab0e 1009 /* Change ADC state */
mbed_official 354:e67efb2aab0e 1010 hadc->State = HAL_ADC_STATE_BUSY_INJ_REG;
mbed_official 354:e67efb2aab0e 1011 }
mbed_official 354:e67efb2aab0e 1012 else
mbed_official 354:e67efb2aab0e 1013 {
mbed_official 354:e67efb2aab0e 1014 /* Change ADC state */
mbed_official 354:e67efb2aab0e 1015 hadc->State = HAL_ADC_STATE_BUSY_REG;
mbed_official 354:e67efb2aab0e 1016 }
mbed_official 354:e67efb2aab0e 1017
mbed_official 354:e67efb2aab0e 1018 /* Set ADC error code to none */
mbed_official 354:e67efb2aab0e 1019 __HAL_ADC_CLEAR_ERRORCODE(hadc);
mbed_official 354:e67efb2aab0e 1020
mbed_official 354:e67efb2aab0e 1021
mbed_official 354:e67efb2aab0e 1022 /* Set the DMA transfer complete callback */
mbed_official 354:e67efb2aab0e 1023 hadc->DMA_Handle->XferCpltCallback = ADC_DMAConvCplt;
mbed_official 354:e67efb2aab0e 1024
mbed_official 354:e67efb2aab0e 1025 /* Set the DMA half transfer complete callback */
mbed_official 354:e67efb2aab0e 1026 hadc->DMA_Handle->XferHalfCpltCallback = ADC_DMAHalfConvCplt;
mbed_official 354:e67efb2aab0e 1027
mbed_official 354:e67efb2aab0e 1028 /* Set the DMA error callback */
mbed_official 354:e67efb2aab0e 1029 hadc->DMA_Handle->XferErrorCallback = ADC_DMAError;
mbed_official 354:e67efb2aab0e 1030
mbed_official 354:e67efb2aab0e 1031
mbed_official 354:e67efb2aab0e 1032 /* Manage ADC and DMA start: ADC overrun interruption, DMA start, ADC */
mbed_official 354:e67efb2aab0e 1033 /* start (in case of SW start): */
mbed_official 354:e67efb2aab0e 1034
mbed_official 354:e67efb2aab0e 1035 /* Clear regular group conversion flag and overrun flag */
mbed_official 354:e67efb2aab0e 1036 /* (To ensure of no unknown state from potential previous ADC operations) */
mbed_official 354:e67efb2aab0e 1037 __HAL_ADC_CLEAR_FLAG(hadc, ADC_FLAG_EOC);
mbed_official 354:e67efb2aab0e 1038
mbed_official 354:e67efb2aab0e 1039 /* Enable ADC overrun interrupt */
mbed_official 354:e67efb2aab0e 1040 __HAL_ADC_ENABLE_IT(hadc, ADC_IT_OVR);
mbed_official 354:e67efb2aab0e 1041
mbed_official 354:e67efb2aab0e 1042 /* Enable ADC DMA mode */
mbed_official 354:e67efb2aab0e 1043 hadc->Instance->CR2 |= ADC_CR2_DMA;
mbed_official 354:e67efb2aab0e 1044
mbed_official 354:e67efb2aab0e 1045 /* Start the DMA channel */
mbed_official 354:e67efb2aab0e 1046 HAL_DMA_Start_IT(hadc->DMA_Handle, (uint32_t)&hadc->Instance->DR, (uint32_t)pData, Length);
mbed_official 354:e67efb2aab0e 1047
mbed_official 354:e67efb2aab0e 1048 /* Start conversion of regular group if software start has been selected. */
mbed_official 354:e67efb2aab0e 1049 /* If external trigger has been selected, conversion will start at next */
mbed_official 354:e67efb2aab0e 1050 /* trigger event. */
mbed_official 354:e67efb2aab0e 1051 /* Note: Alternate trigger for single conversion could be to force an */
mbed_official 354:e67efb2aab0e 1052 /* additional set of bit ADON "hadc->Instance->CR2 |= ADC_CR2_ADON;"*/
mbed_official 354:e67efb2aab0e 1053 if (__HAL_ADC_IS_SOFTWARE_START_REGULAR(hadc))
mbed_official 354:e67efb2aab0e 1054 {
mbed_official 354:e67efb2aab0e 1055 /* Start ADC conversion on regular group */
mbed_official 354:e67efb2aab0e 1056 SET_BIT(hadc->Instance->CR2, ADC_CR2_SWSTART);
mbed_official 354:e67efb2aab0e 1057 }
mbed_official 354:e67efb2aab0e 1058 }
mbed_official 354:e67efb2aab0e 1059
mbed_official 354:e67efb2aab0e 1060 /* Process unlocked */
mbed_official 354:e67efb2aab0e 1061 __HAL_UNLOCK(hadc);
mbed_official 354:e67efb2aab0e 1062
mbed_official 354:e67efb2aab0e 1063 /* Return function status */
mbed_official 354:e67efb2aab0e 1064 return tmpHALStatus;
mbed_official 354:e67efb2aab0e 1065 }
mbed_official 354:e67efb2aab0e 1066
mbed_official 354:e67efb2aab0e 1067 /**
mbed_official 354:e67efb2aab0e 1068 * @brief Stop ADC conversion of regular group (and injected group in
mbed_official 354:e67efb2aab0e 1069 * case of auto_injection mode), disable ADC DMA transfer, disable
mbed_official 354:e67efb2aab0e 1070 * ADC peripheral.
mbed_official 354:e67efb2aab0e 1071 * @note: ADC peripheral disable is forcing interruption of potential
mbed_official 354:e67efb2aab0e 1072 * conversion on injected group. If injected group is under use, it
mbed_official 354:e67efb2aab0e 1073 * should be preliminarily stopped using HAL_ADCEx_InjectedStop function.
mbed_official 354:e67efb2aab0e 1074 * @param hadc: ADC handle
mbed_official 354:e67efb2aab0e 1075 * @retval HAL status.
mbed_official 354:e67efb2aab0e 1076 */
mbed_official 354:e67efb2aab0e 1077 HAL_StatusTypeDef HAL_ADC_Stop_DMA(ADC_HandleTypeDef* hadc)
mbed_official 354:e67efb2aab0e 1078 {
mbed_official 354:e67efb2aab0e 1079 HAL_StatusTypeDef tmpHALStatus = HAL_OK;
mbed_official 354:e67efb2aab0e 1080
mbed_official 354:e67efb2aab0e 1081 /* Check the parameters */
mbed_official 354:e67efb2aab0e 1082 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 354:e67efb2aab0e 1083
mbed_official 354:e67efb2aab0e 1084 /* Process locked */
mbed_official 354:e67efb2aab0e 1085 __HAL_LOCK(hadc);
mbed_official 354:e67efb2aab0e 1086
mbed_official 354:e67efb2aab0e 1087 /* Stop potential conversion on going, on regular and injected groups */
mbed_official 354:e67efb2aab0e 1088 /* Disable ADC peripheral */
mbed_official 354:e67efb2aab0e 1089 tmpHALStatus = ADC_ConversionStop_Disable(hadc);
mbed_official 354:e67efb2aab0e 1090
mbed_official 354:e67efb2aab0e 1091 /* Check if ADC is effectively disabled */
mbed_official 354:e67efb2aab0e 1092 if (tmpHALStatus != HAL_ERROR)
mbed_official 354:e67efb2aab0e 1093 {
mbed_official 354:e67efb2aab0e 1094 /* Disable ADC DMA mode */
mbed_official 354:e67efb2aab0e 1095 hadc->Instance->CR2 &= ~ADC_CR2_DMA;
mbed_official 354:e67efb2aab0e 1096
mbed_official 354:e67efb2aab0e 1097 /* Disable the DMA channel (in case of DMA in circular mode or stop while */
mbed_official 354:e67efb2aab0e 1098 /* DMA transfer is on going) */
mbed_official 354:e67efb2aab0e 1099 tmpHALStatus = HAL_DMA_Abort(hadc->DMA_Handle);
mbed_official 354:e67efb2aab0e 1100
mbed_official 354:e67efb2aab0e 1101 /* Check if DMA channel effectively disabled */
mbed_official 354:e67efb2aab0e 1102 if (tmpHALStatus != HAL_ERROR)
mbed_official 354:e67efb2aab0e 1103 {
mbed_official 354:e67efb2aab0e 1104 /* Change ADC state */
mbed_official 354:e67efb2aab0e 1105 hadc->State = HAL_ADC_STATE_READY;
mbed_official 354:e67efb2aab0e 1106 }
mbed_official 354:e67efb2aab0e 1107 else
mbed_official 354:e67efb2aab0e 1108 {
mbed_official 354:e67efb2aab0e 1109 /* Update ADC state machine to error */
mbed_official 354:e67efb2aab0e 1110 hadc->State = HAL_ADC_STATE_ERROR;
mbed_official 354:e67efb2aab0e 1111 }
mbed_official 354:e67efb2aab0e 1112 }
mbed_official 354:e67efb2aab0e 1113
mbed_official 354:e67efb2aab0e 1114 /* Process unlocked */
mbed_official 354:e67efb2aab0e 1115 __HAL_UNLOCK(hadc);
mbed_official 354:e67efb2aab0e 1116
mbed_official 354:e67efb2aab0e 1117 /* Return function status */
mbed_official 354:e67efb2aab0e 1118 return tmpHALStatus;
mbed_official 354:e67efb2aab0e 1119 }
mbed_official 354:e67efb2aab0e 1120
mbed_official 354:e67efb2aab0e 1121 /**
mbed_official 354:e67efb2aab0e 1122 * @brief Get ADC regular group conversion result.
mbed_official 354:e67efb2aab0e 1123 * @param hadc: ADC handle
mbed_official 354:e67efb2aab0e 1124 * @retval Converted value
mbed_official 354:e67efb2aab0e 1125 */
mbed_official 354:e67efb2aab0e 1126 uint32_t HAL_ADC_GetValue(ADC_HandleTypeDef* hadc)
mbed_official 354:e67efb2aab0e 1127 {
mbed_official 354:e67efb2aab0e 1128 /* Check the parameters */
mbed_official 354:e67efb2aab0e 1129 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 354:e67efb2aab0e 1130
mbed_official 354:e67efb2aab0e 1131 /* Note: EOC flag is not cleared here by software because automatically */
mbed_official 354:e67efb2aab0e 1132 /* cleared by hardware when reading register DR. */
mbed_official 354:e67efb2aab0e 1133
mbed_official 354:e67efb2aab0e 1134 /* Return ADC converted value */
mbed_official 354:e67efb2aab0e 1135 return hadc->Instance->DR;
mbed_official 354:e67efb2aab0e 1136 }
mbed_official 354:e67efb2aab0e 1137
mbed_official 354:e67efb2aab0e 1138 /**
mbed_official 354:e67efb2aab0e 1139 * @brief DMA transfer complete callback.
mbed_official 354:e67efb2aab0e 1140 * @param hdma: pointer to DMA handle.
mbed_official 354:e67efb2aab0e 1141 * @retval None
mbed_official 354:e67efb2aab0e 1142 */
mbed_official 354:e67efb2aab0e 1143 static void ADC_DMAConvCplt(DMA_HandleTypeDef *hdma)
mbed_official 354:e67efb2aab0e 1144 {
mbed_official 354:e67efb2aab0e 1145 /* Retrieve ADC handle corresponding to current DMA handle */
mbed_official 354:e67efb2aab0e 1146 ADC_HandleTypeDef* hadc = ( ADC_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official 354:e67efb2aab0e 1147
mbed_official 354:e67efb2aab0e 1148 /* Update state machine on conversion status if not in error state */
mbed_official 354:e67efb2aab0e 1149 if(hadc->State != HAL_ADC_STATE_ERROR)
mbed_official 354:e67efb2aab0e 1150 {
mbed_official 354:e67efb2aab0e 1151 /* Update ADC state machine */
mbed_official 354:e67efb2aab0e 1152 if(hadc->State != HAL_ADC_STATE_EOC_INJ_REG)
mbed_official 354:e67efb2aab0e 1153 {
mbed_official 354:e67efb2aab0e 1154 /* Check if a conversion is ready on injected group */
mbed_official 354:e67efb2aab0e 1155 if(hadc->State == HAL_ADC_STATE_EOC_INJ)
mbed_official 354:e67efb2aab0e 1156 {
mbed_official 354:e67efb2aab0e 1157 /* Change ADC state */
mbed_official 354:e67efb2aab0e 1158 hadc->State = HAL_ADC_STATE_EOC_INJ_REG;
mbed_official 354:e67efb2aab0e 1159 }
mbed_official 354:e67efb2aab0e 1160 else
mbed_official 354:e67efb2aab0e 1161 {
mbed_official 354:e67efb2aab0e 1162 /* Change ADC state */
mbed_official 354:e67efb2aab0e 1163 hadc->State = HAL_ADC_STATE_EOC_REG;
mbed_official 354:e67efb2aab0e 1164 }
mbed_official 354:e67efb2aab0e 1165 }
mbed_official 354:e67efb2aab0e 1166 }
mbed_official 354:e67efb2aab0e 1167
mbed_official 354:e67efb2aab0e 1168 /* Conversion complete callback */
mbed_official 354:e67efb2aab0e 1169 HAL_ADC_ConvCpltCallback(hadc);
mbed_official 354:e67efb2aab0e 1170 }
mbed_official 354:e67efb2aab0e 1171
mbed_official 354:e67efb2aab0e 1172 /**
mbed_official 354:e67efb2aab0e 1173 * @brief DMA half transfer complete callback.
mbed_official 354:e67efb2aab0e 1174 * @param hdma: pointer to DMA handle.
mbed_official 354:e67efb2aab0e 1175 * @retval None
mbed_official 354:e67efb2aab0e 1176 */
mbed_official 354:e67efb2aab0e 1177 static void ADC_DMAHalfConvCplt(DMA_HandleTypeDef *hdma)
mbed_official 354:e67efb2aab0e 1178 {
mbed_official 354:e67efb2aab0e 1179 /* Retrieve ADC handle corresponding to current DMA handle */
mbed_official 354:e67efb2aab0e 1180 ADC_HandleTypeDef* hadc = ( ADC_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official 354:e67efb2aab0e 1181
mbed_official 354:e67efb2aab0e 1182 /* Half conversion callback */
mbed_official 354:e67efb2aab0e 1183 HAL_ADC_ConvHalfCpltCallback(hadc);
mbed_official 354:e67efb2aab0e 1184 }
mbed_official 354:e67efb2aab0e 1185
mbed_official 354:e67efb2aab0e 1186 /**
mbed_official 354:e67efb2aab0e 1187 * @brief DMA error callback
mbed_official 354:e67efb2aab0e 1188 * @param hdma: pointer to DMA handle.
mbed_official 354:e67efb2aab0e 1189 * @retval None
mbed_official 354:e67efb2aab0e 1190 */
mbed_official 354:e67efb2aab0e 1191 static void ADC_DMAError(DMA_HandleTypeDef *hdma)
mbed_official 354:e67efb2aab0e 1192 {
mbed_official 354:e67efb2aab0e 1193 /* Retrieve ADC handle corresponding to current DMA handle */
mbed_official 354:e67efb2aab0e 1194 ADC_HandleTypeDef* hadc = ( ADC_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official 354:e67efb2aab0e 1195
mbed_official 354:e67efb2aab0e 1196 /* Change ADC state */
mbed_official 354:e67efb2aab0e 1197 hadc->State = HAL_ADC_STATE_ERROR;
mbed_official 354:e67efb2aab0e 1198
mbed_official 354:e67efb2aab0e 1199 /* Set ADC error code to DMA error */
mbed_official 354:e67efb2aab0e 1200 hadc->ErrorCode |= HAL_ADC_ERROR_DMA;
mbed_official 354:e67efb2aab0e 1201
mbed_official 354:e67efb2aab0e 1202 /* Error callback */
mbed_official 354:e67efb2aab0e 1203 HAL_ADC_ErrorCallback(hadc);
mbed_official 354:e67efb2aab0e 1204 }
mbed_official 354:e67efb2aab0e 1205
mbed_official 354:e67efb2aab0e 1206 /**
mbed_official 354:e67efb2aab0e 1207 * @brief Handles ADC interrupt request
mbed_official 354:e67efb2aab0e 1208 * @param hadc: ADC handle
mbed_official 354:e67efb2aab0e 1209 * @retval None
mbed_official 354:e67efb2aab0e 1210 */
mbed_official 354:e67efb2aab0e 1211 void HAL_ADC_IRQHandler(ADC_HandleTypeDef* hadc)
mbed_official 354:e67efb2aab0e 1212 {
mbed_official 354:e67efb2aab0e 1213 /* Check the parameters */
mbed_official 354:e67efb2aab0e 1214 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 354:e67efb2aab0e 1215 assert_param(IS_FUNCTIONAL_STATE(hadc->Init.ContinuousConvMode));
mbed_official 354:e67efb2aab0e 1216 assert_param(IS_ADC_REGULAR_NB_CONV(hadc->Init.NbrOfConversion));
mbed_official 354:e67efb2aab0e 1217
mbed_official 354:e67efb2aab0e 1218
mbed_official 354:e67efb2aab0e 1219 /* ========== Check End of Conversion flag for regular group ========== */
mbed_official 354:e67efb2aab0e 1220 if(__HAL_ADC_GET_IT_SOURCE(hadc, ADC_IT_EOC))
mbed_official 354:e67efb2aab0e 1221 {
mbed_official 354:e67efb2aab0e 1222 if(__HAL_ADC_GET_FLAG(hadc, ADC_FLAG_EOC) )
mbed_official 354:e67efb2aab0e 1223 {
mbed_official 354:e67efb2aab0e 1224 /* Update state machine on conversion status if not in error state */
mbed_official 354:e67efb2aab0e 1225 if(hadc->State != HAL_ADC_STATE_ERROR)
mbed_official 354:e67efb2aab0e 1226 {
mbed_official 354:e67efb2aab0e 1227 /* Update ADC state machine */
mbed_official 354:e67efb2aab0e 1228 if(hadc->State != HAL_ADC_STATE_EOC_INJ_REG)
mbed_official 354:e67efb2aab0e 1229 {
mbed_official 354:e67efb2aab0e 1230 /* Check if a conversion is ready on injected group */
mbed_official 354:e67efb2aab0e 1231 if(hadc->State == HAL_ADC_STATE_EOC_INJ)
mbed_official 354:e67efb2aab0e 1232 {
mbed_official 354:e67efb2aab0e 1233 /* Change ADC state */
mbed_official 354:e67efb2aab0e 1234 hadc->State = HAL_ADC_STATE_EOC_INJ_REG;
mbed_official 354:e67efb2aab0e 1235 }
mbed_official 354:e67efb2aab0e 1236 else
mbed_official 354:e67efb2aab0e 1237 {
mbed_official 354:e67efb2aab0e 1238 /* Change ADC state */
mbed_official 354:e67efb2aab0e 1239 hadc->State = HAL_ADC_STATE_EOC_REG;
mbed_official 354:e67efb2aab0e 1240 }
mbed_official 354:e67efb2aab0e 1241 }
mbed_official 354:e67efb2aab0e 1242 }
mbed_official 354:e67efb2aab0e 1243
mbed_official 354:e67efb2aab0e 1244 /* Disable interruption if no further conversion upcoming regular */
mbed_official 354:e67efb2aab0e 1245 /* external trigger or by continuous mode */
mbed_official 354:e67efb2aab0e 1246 if(__HAL_ADC_IS_SOFTWARE_START_REGULAR(hadc) &&
mbed_official 354:e67efb2aab0e 1247 (hadc->Init.ContinuousConvMode == DISABLE) )
mbed_official 354:e67efb2aab0e 1248 {
mbed_official 354:e67efb2aab0e 1249 /* Disable ADC end of single conversion interrupt */
mbed_official 354:e67efb2aab0e 1250 /* Note: Overrun interrupt was enabled with EOC interrupt in */
mbed_official 354:e67efb2aab0e 1251 /* HAL_ADC_Start_IT(), but is not disabled here because can be used by */
mbed_official 354:e67efb2aab0e 1252 /* overrun IRQ process below. */
mbed_official 354:e67efb2aab0e 1253 __HAL_ADC_DISABLE_IT(hadc, ADC_IT_EOC);
mbed_official 354:e67efb2aab0e 1254 }
mbed_official 354:e67efb2aab0e 1255
mbed_official 354:e67efb2aab0e 1256 /* Conversion complete callback */
mbed_official 354:e67efb2aab0e 1257 HAL_ADC_ConvCpltCallback(hadc);
mbed_official 354:e67efb2aab0e 1258
mbed_official 354:e67efb2aab0e 1259 /* Clear regular group conversion flag */
mbed_official 354:e67efb2aab0e 1260 __HAL_ADC_CLEAR_FLAG(hadc, ADC_FLAG_STRT | ADC_FLAG_EOC);
mbed_official 354:e67efb2aab0e 1261 }
mbed_official 354:e67efb2aab0e 1262 }
mbed_official 354:e67efb2aab0e 1263
mbed_official 354:e67efb2aab0e 1264 /* ========== Check End of Conversion flag for injected group ========== */
mbed_official 354:e67efb2aab0e 1265 if(__HAL_ADC_GET_IT_SOURCE(hadc, ADC_IT_JEOC))
mbed_official 354:e67efb2aab0e 1266 {
mbed_official 354:e67efb2aab0e 1267 if(__HAL_ADC_GET_FLAG(hadc, ADC_FLAG_JEOC))
mbed_official 354:e67efb2aab0e 1268 {
mbed_official 354:e67efb2aab0e 1269 /* Update state machine on conversion status if not in error state */
mbed_official 354:e67efb2aab0e 1270 if(hadc->State != HAL_ADC_STATE_ERROR)
mbed_official 354:e67efb2aab0e 1271 {
mbed_official 354:e67efb2aab0e 1272 /* Update ADC state machine */
mbed_official 354:e67efb2aab0e 1273 if(hadc->State != HAL_ADC_STATE_EOC_INJ_REG)
mbed_official 354:e67efb2aab0e 1274 {
mbed_official 354:e67efb2aab0e 1275
mbed_official 354:e67efb2aab0e 1276 if(hadc->State == HAL_ADC_STATE_EOC_REG)
mbed_official 354:e67efb2aab0e 1277 {
mbed_official 354:e67efb2aab0e 1278 /* Change ADC state */
mbed_official 354:e67efb2aab0e 1279 hadc->State = HAL_ADC_STATE_EOC_INJ_REG;
mbed_official 354:e67efb2aab0e 1280 }
mbed_official 354:e67efb2aab0e 1281 else
mbed_official 354:e67efb2aab0e 1282 {
mbed_official 354:e67efb2aab0e 1283 /* Change ADC state */
mbed_official 354:e67efb2aab0e 1284 hadc->State = HAL_ADC_STATE_EOC_INJ;
mbed_official 354:e67efb2aab0e 1285 }
mbed_official 354:e67efb2aab0e 1286 }
mbed_official 354:e67efb2aab0e 1287 }
mbed_official 354:e67efb2aab0e 1288
mbed_official 354:e67efb2aab0e 1289 /* Disable interruption if no further conversion upcoming injected */
mbed_official 354:e67efb2aab0e 1290 /* external trigger or by automatic injected conversion with regular */
mbed_official 354:e67efb2aab0e 1291 /* group having no further conversion upcoming (same conditions as */
mbed_official 354:e67efb2aab0e 1292 /* regular group interruption disabling above). */
mbed_official 354:e67efb2aab0e 1293 if(__HAL_ADC_IS_SOFTWARE_START_INJECTED(hadc) ||
mbed_official 354:e67efb2aab0e 1294 (HAL_IS_BIT_CLR(hadc->Instance->CR1, ADC_CR1_JAUTO) &&
mbed_official 354:e67efb2aab0e 1295 (__HAL_ADC_IS_SOFTWARE_START_REGULAR(hadc) &&
mbed_official 354:e67efb2aab0e 1296 (hadc->Init.ContinuousConvMode == DISABLE) ) ) )
mbed_official 354:e67efb2aab0e 1297 {
mbed_official 354:e67efb2aab0e 1298 /* Disable ADC end of single conversion interrupt */
mbed_official 354:e67efb2aab0e 1299 __HAL_ADC_DISABLE_IT(hadc, ADC_IT_JEOC);
mbed_official 354:e67efb2aab0e 1300 }
mbed_official 354:e67efb2aab0e 1301
mbed_official 354:e67efb2aab0e 1302 /* Conversion complete callback */
mbed_official 354:e67efb2aab0e 1303 HAL_ADCEx_InjectedConvCpltCallback(hadc);
mbed_official 354:e67efb2aab0e 1304
mbed_official 354:e67efb2aab0e 1305 /* Clear injected group conversion flag */
mbed_official 354:e67efb2aab0e 1306 __HAL_ADC_CLEAR_FLAG(hadc, (ADC_FLAG_JSTRT | ADC_FLAG_JEOC));
mbed_official 354:e67efb2aab0e 1307 }
mbed_official 354:e67efb2aab0e 1308 }
mbed_official 354:e67efb2aab0e 1309
mbed_official 354:e67efb2aab0e 1310 /* ========== Check Analog watchdog flags ========== */
mbed_official 354:e67efb2aab0e 1311 if(__HAL_ADC_GET_IT_SOURCE(hadc, ADC_IT_AWD))
mbed_official 354:e67efb2aab0e 1312 {
mbed_official 354:e67efb2aab0e 1313 if(__HAL_ADC_GET_FLAG(hadc, ADC_FLAG_AWD))
mbed_official 354:e67efb2aab0e 1314 {
mbed_official 354:e67efb2aab0e 1315 /* Change ADC state */
mbed_official 354:e67efb2aab0e 1316 hadc->State = HAL_ADC_STATE_AWD;
mbed_official 354:e67efb2aab0e 1317
mbed_official 354:e67efb2aab0e 1318 /* Clear the ADCx's Analog watchdog flag */
mbed_official 354:e67efb2aab0e 1319 __HAL_ADC_CLEAR_FLAG(hadc,ADC_FLAG_AWD);
mbed_official 354:e67efb2aab0e 1320
mbed_official 354:e67efb2aab0e 1321 /* Level out of window callback */
mbed_official 354:e67efb2aab0e 1322 HAL_ADC_LevelOutOfWindowCallback(hadc);
mbed_official 354:e67efb2aab0e 1323 }
mbed_official 354:e67efb2aab0e 1324 }
mbed_official 354:e67efb2aab0e 1325
mbed_official 354:e67efb2aab0e 1326 /* ========== Check Overrun flag ========== */
mbed_official 354:e67efb2aab0e 1327 if(__HAL_ADC_GET_IT_SOURCE(hadc, ADC_IT_OVR))
mbed_official 354:e67efb2aab0e 1328 {
mbed_official 354:e67efb2aab0e 1329 if(__HAL_ADC_GET_FLAG(hadc, ADC_FLAG_OVR))
mbed_official 354:e67efb2aab0e 1330 {
mbed_official 354:e67efb2aab0e 1331 /* Change ADC state to error state */
mbed_official 354:e67efb2aab0e 1332 hadc->State = HAL_ADC_STATE_ERROR;
mbed_official 354:e67efb2aab0e 1333
mbed_official 354:e67efb2aab0e 1334 /* Set ADC error code to overrun */
mbed_official 354:e67efb2aab0e 1335 hadc->ErrorCode |= HAL_ADC_ERROR_OVR;
mbed_official 354:e67efb2aab0e 1336
mbed_official 354:e67efb2aab0e 1337 /* Error callback */
mbed_official 354:e67efb2aab0e 1338 HAL_ADC_ErrorCallback(hadc);
mbed_official 354:e67efb2aab0e 1339
mbed_official 354:e67efb2aab0e 1340 /* Clear the Overrun flag */
mbed_official 354:e67efb2aab0e 1341 __HAL_ADC_CLEAR_FLAG(hadc, ADC_FLAG_OVR);
mbed_official 354:e67efb2aab0e 1342 }
mbed_official 354:e67efb2aab0e 1343 }
mbed_official 354:e67efb2aab0e 1344
mbed_official 354:e67efb2aab0e 1345 }
mbed_official 354:e67efb2aab0e 1346
mbed_official 354:e67efb2aab0e 1347 /**
mbed_official 354:e67efb2aab0e 1348 * @brief Conversion complete callback in non blocking mode
mbed_official 354:e67efb2aab0e 1349 * @param hadc: ADC handle
mbed_official 354:e67efb2aab0e 1350 * @retval None
mbed_official 354:e67efb2aab0e 1351 */
mbed_official 354:e67efb2aab0e 1352 __weak void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc)
mbed_official 354:e67efb2aab0e 1353 {
mbed_official 354:e67efb2aab0e 1354 /* NOTE : This function should not be modified. When the callback is needed,
mbed_official 354:e67efb2aab0e 1355 function HAL_ADC_ConvCpltCallback must be implemented in the user file.
mbed_official 354:e67efb2aab0e 1356 */
mbed_official 354:e67efb2aab0e 1357 }
mbed_official 354:e67efb2aab0e 1358
mbed_official 354:e67efb2aab0e 1359 /**
mbed_official 354:e67efb2aab0e 1360 * @brief Conversion DMA half-transfer callback in non blocking mode
mbed_official 354:e67efb2aab0e 1361 * @param hadc: ADC handle
mbed_official 354:e67efb2aab0e 1362 * @retval None
mbed_official 354:e67efb2aab0e 1363 */
mbed_official 354:e67efb2aab0e 1364 __weak void HAL_ADC_ConvHalfCpltCallback(ADC_HandleTypeDef* hadc)
mbed_official 354:e67efb2aab0e 1365 {
mbed_official 354:e67efb2aab0e 1366 /* NOTE : This function should not be modified. When the callback is needed,
mbed_official 354:e67efb2aab0e 1367 function HAL_ADC_ConvHalfCpltCallback must be implemented in the user file.
mbed_official 354:e67efb2aab0e 1368 */
mbed_official 354:e67efb2aab0e 1369 }
mbed_official 354:e67efb2aab0e 1370
mbed_official 354:e67efb2aab0e 1371 /**
mbed_official 354:e67efb2aab0e 1372 * @brief Analog watchdog callback in non blocking mode.
mbed_official 354:e67efb2aab0e 1373 * @param hadc: ADC handle
mbed_official 354:e67efb2aab0e 1374 * @retval None
mbed_official 354:e67efb2aab0e 1375 */
mbed_official 354:e67efb2aab0e 1376 __weak void HAL_ADC_LevelOutOfWindowCallback(ADC_HandleTypeDef* hadc)
mbed_official 354:e67efb2aab0e 1377 {
mbed_official 354:e67efb2aab0e 1378 /* NOTE : This function should not be modified. When the callback is needed,
mbed_official 354:e67efb2aab0e 1379 function HAL_ADC_LevelOutOfWindowCallback must be implemented in the user file.
mbed_official 354:e67efb2aab0e 1380 */
mbed_official 354:e67efb2aab0e 1381 }
mbed_official 354:e67efb2aab0e 1382
mbed_official 354:e67efb2aab0e 1383 /**
mbed_official 354:e67efb2aab0e 1384 * @brief ADC error callback in non blocking mode
mbed_official 354:e67efb2aab0e 1385 * (ADC conversion with interruption or transfer by DMA)
mbed_official 354:e67efb2aab0e 1386 * @param hadc: ADC handle
mbed_official 354:e67efb2aab0e 1387 * @retval None
mbed_official 354:e67efb2aab0e 1388 */
mbed_official 354:e67efb2aab0e 1389 __weak void HAL_ADC_ErrorCallback(ADC_HandleTypeDef *hadc)
mbed_official 354:e67efb2aab0e 1390 {
mbed_official 354:e67efb2aab0e 1391 /* NOTE : This function should not be modified. When the callback is needed,
mbed_official 354:e67efb2aab0e 1392 function HAL_ADC_ErrorCallback must be implemented in the user file.
mbed_official 354:e67efb2aab0e 1393 */
mbed_official 354:e67efb2aab0e 1394 }
mbed_official 354:e67efb2aab0e 1395
mbed_official 354:e67efb2aab0e 1396
mbed_official 354:e67efb2aab0e 1397 /**
mbed_official 354:e67efb2aab0e 1398 * @}
mbed_official 354:e67efb2aab0e 1399 */
mbed_official 354:e67efb2aab0e 1400
mbed_official 354:e67efb2aab0e 1401 /** @defgroup ADC_Exported_Functions_Group3 Peripheral Control functions
mbed_official 354:e67efb2aab0e 1402 * @brief Peripheral Control functions
mbed_official 354:e67efb2aab0e 1403 *
mbed_official 354:e67efb2aab0e 1404 @verbatim
mbed_official 354:e67efb2aab0e 1405 ===============================================================================
mbed_official 354:e67efb2aab0e 1406 ##### Peripheral Control functions #####
mbed_official 354:e67efb2aab0e 1407 ===============================================================================
mbed_official 354:e67efb2aab0e 1408 [..] This section provides functions allowing to:
mbed_official 354:e67efb2aab0e 1409 (+) Configure channels on regular group
mbed_official 354:e67efb2aab0e 1410 (+) Configure the analog watchdog
mbed_official 354:e67efb2aab0e 1411
mbed_official 354:e67efb2aab0e 1412 @endverbatim
mbed_official 354:e67efb2aab0e 1413 * @{
mbed_official 354:e67efb2aab0e 1414 */
mbed_official 354:e67efb2aab0e 1415
mbed_official 354:e67efb2aab0e 1416 /**
mbed_official 354:e67efb2aab0e 1417 * @brief Configures the the selected channel to be linked to the regular
mbed_official 354:e67efb2aab0e 1418 * group.
mbed_official 354:e67efb2aab0e 1419 * @note In case of usage of internal measurement channels:
mbed_official 354:e67efb2aab0e 1420 * Vbat/VrefInt/TempSensor.
mbed_official 354:e67efb2aab0e 1421 * These internal paths can be be disabled using function
mbed_official 354:e67efb2aab0e 1422 * HAL_ADC_DeInit().
mbed_official 354:e67efb2aab0e 1423 * @note Possibility to update parameters on the fly:
mbed_official 354:e67efb2aab0e 1424 * This function initializes channel into regular group, following
mbed_official 354:e67efb2aab0e 1425 * calls to this function can be used to reconfigure some parameters
mbed_official 354:e67efb2aab0e 1426 * of structure "ADC_ChannelConfTypeDef" on the fly, without reseting
mbed_official 354:e67efb2aab0e 1427 * the ADC.
mbed_official 354:e67efb2aab0e 1428 * The setting of these parameters is conditioned to ADC state.
mbed_official 354:e67efb2aab0e 1429 * For parameters constraints, see comments of structure
mbed_official 354:e67efb2aab0e 1430 * "ADC_ChannelConfTypeDef".
mbed_official 354:e67efb2aab0e 1431 * @param hadc: ADC handle
mbed_official 354:e67efb2aab0e 1432 * @param sConfig: Structure of ADC channel for regular group.
mbed_official 354:e67efb2aab0e 1433 * @retval HAL status
mbed_official 354:e67efb2aab0e 1434 */
mbed_official 354:e67efb2aab0e 1435 HAL_StatusTypeDef HAL_ADC_ConfigChannel(ADC_HandleTypeDef* hadc, ADC_ChannelConfTypeDef* sConfig)
mbed_official 354:e67efb2aab0e 1436 {
mbed_official 354:e67efb2aab0e 1437 HAL_StatusTypeDef tmpHALStatus = HAL_OK;
mbed_official 354:e67efb2aab0e 1438
mbed_official 354:e67efb2aab0e 1439 /* Check the parameters */
mbed_official 354:e67efb2aab0e 1440 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 354:e67efb2aab0e 1441 assert_param(IS_ADC_CHANNEL(sConfig->Channel));
mbed_official 354:e67efb2aab0e 1442 assert_param(IS_ADC_REGULAR_RANK(sConfig->Rank));
mbed_official 354:e67efb2aab0e 1443 assert_param(IS_ADC_SAMPLE_TIME(sConfig->SamplingTime));
mbed_official 354:e67efb2aab0e 1444
mbed_official 354:e67efb2aab0e 1445 /* Process locked */
mbed_official 354:e67efb2aab0e 1446 __HAL_LOCK(hadc);
mbed_official 354:e67efb2aab0e 1447
mbed_official 354:e67efb2aab0e 1448
mbed_official 354:e67efb2aab0e 1449 /* Regular sequence configuration */
mbed_official 354:e67efb2aab0e 1450 /* For Rank 1 to 6 */
mbed_official 354:e67efb2aab0e 1451 if (sConfig->Rank < 7)
mbed_official 354:e67efb2aab0e 1452 {
mbed_official 354:e67efb2aab0e 1453 MODIFY_REG(hadc->Instance->SQR5,
mbed_official 354:e67efb2aab0e 1454 __ADC_SQR5_RK(ADC_SQR5_SQ1, sConfig->Rank),
mbed_official 354:e67efb2aab0e 1455 __ADC_SQR5_RK(sConfig->Channel, sConfig->Rank) );
mbed_official 354:e67efb2aab0e 1456 }
mbed_official 354:e67efb2aab0e 1457 /* For Rank 7 to 12 */
mbed_official 354:e67efb2aab0e 1458 else if (sConfig->Rank < 13)
mbed_official 354:e67efb2aab0e 1459 {
mbed_official 354:e67efb2aab0e 1460 MODIFY_REG(hadc->Instance->SQR4,
mbed_official 354:e67efb2aab0e 1461 __ADC_SQR4_RK(ADC_SQR4_SQ7, sConfig->Rank),
mbed_official 354:e67efb2aab0e 1462 __ADC_SQR4_RK(sConfig->Channel, sConfig->Rank) );
mbed_official 354:e67efb2aab0e 1463 }
mbed_official 354:e67efb2aab0e 1464 /* For Rank 13 to 18 */
mbed_official 354:e67efb2aab0e 1465 else if (sConfig->Rank < 19)
mbed_official 354:e67efb2aab0e 1466 {
mbed_official 354:e67efb2aab0e 1467 MODIFY_REG(hadc->Instance->SQR3,
mbed_official 354:e67efb2aab0e 1468 __ADC_SQR3_RK(ADC_SQR3_SQ13, sConfig->Rank),
mbed_official 354:e67efb2aab0e 1469 __ADC_SQR3_RK(sConfig->Channel, sConfig->Rank) );
mbed_official 354:e67efb2aab0e 1470 }
mbed_official 354:e67efb2aab0e 1471 /* For Rank 19 to 24 */
mbed_official 354:e67efb2aab0e 1472 else if (sConfig->Rank < 25)
mbed_official 354:e67efb2aab0e 1473 {
mbed_official 354:e67efb2aab0e 1474 MODIFY_REG(hadc->Instance->SQR2,
mbed_official 354:e67efb2aab0e 1475 __ADC_SQR2_RK(ADC_SQR2_SQ19, sConfig->Rank),
mbed_official 354:e67efb2aab0e 1476 __ADC_SQR2_RK(sConfig->Channel, sConfig->Rank) );
mbed_official 354:e67efb2aab0e 1477 }
mbed_official 354:e67efb2aab0e 1478 /* For Rank 25 to 28 */
mbed_official 354:e67efb2aab0e 1479 else
mbed_official 354:e67efb2aab0e 1480 {
mbed_official 354:e67efb2aab0e 1481 MODIFY_REG(hadc->Instance->SQR1,
mbed_official 354:e67efb2aab0e 1482 __ADC_SQR1_RK(ADC_SQR1_SQ25, sConfig->Rank),
mbed_official 354:e67efb2aab0e 1483 __ADC_SQR1_RK(sConfig->Channel, sConfig->Rank) );
mbed_official 354:e67efb2aab0e 1484 }
mbed_official 354:e67efb2aab0e 1485
mbed_official 354:e67efb2aab0e 1486
mbed_official 354:e67efb2aab0e 1487 /* Channel sampling time configuration */
mbed_official 354:e67efb2aab0e 1488 /* For channels 0 to 9 */
mbed_official 354:e67efb2aab0e 1489 if (sConfig->Channel < ADC_CHANNEL_10)
mbed_official 354:e67efb2aab0e 1490 {
mbed_official 354:e67efb2aab0e 1491 MODIFY_REG(hadc->Instance->SMPR3,
mbed_official 354:e67efb2aab0e 1492 __ADC_SMPR3(ADC_SMPR3_SMP0, sConfig->Channel),
mbed_official 354:e67efb2aab0e 1493 __ADC_SMPR3(sConfig->SamplingTime, sConfig->Channel) );
mbed_official 354:e67efb2aab0e 1494 }
mbed_official 354:e67efb2aab0e 1495 /* For channels 10 to 19 */
mbed_official 354:e67efb2aab0e 1496 else if (sConfig->Channel < ADC_CHANNEL_20)
mbed_official 354:e67efb2aab0e 1497 {
mbed_official 354:e67efb2aab0e 1498 MODIFY_REG(hadc->Instance->SMPR2,
mbed_official 354:e67efb2aab0e 1499 __ADC_SMPR2(ADC_SMPR2_SMP10, sConfig->Channel),
mbed_official 354:e67efb2aab0e 1500 __ADC_SMPR2(sConfig->SamplingTime, sConfig->Channel) );
mbed_official 354:e67efb2aab0e 1501 }
mbed_official 354:e67efb2aab0e 1502 /* For channels 20 to 26 for devices Cat.1, Cat.2, Cat.3 */
mbed_official 354:e67efb2aab0e 1503 /* For channels 20 to 29 for devices Cat4, Cat.5 */
mbed_official 354:e67efb2aab0e 1504 else if (sConfig->Channel <= ADC_SMPR1_CHANNEL_MAX)
mbed_official 354:e67efb2aab0e 1505 {
mbed_official 354:e67efb2aab0e 1506 MODIFY_REG(hadc->Instance->SMPR1,
mbed_official 354:e67efb2aab0e 1507 __ADC_SMPR1(ADC_SMPR1_SMP20, sConfig->Channel),
mbed_official 354:e67efb2aab0e 1508 __ADC_SMPR1(sConfig->SamplingTime, sConfig->Channel) );
mbed_official 354:e67efb2aab0e 1509 }
mbed_official 354:e67efb2aab0e 1510 /* For channels 30 to 31 for devices Cat4, Cat.5 */
mbed_official 354:e67efb2aab0e 1511 else
mbed_official 354:e67efb2aab0e 1512 {
mbed_official 354:e67efb2aab0e 1513 __ADC_SMPR0_CHANNEL_SET(hadc, sConfig->SamplingTime, sConfig->Channel);
mbed_official 354:e67efb2aab0e 1514 }
mbed_official 354:e67efb2aab0e 1515
mbed_official 354:e67efb2aab0e 1516 /* If ADC1 Channel_16 or Channel_17 is selected, enable Temperature sensor */
mbed_official 354:e67efb2aab0e 1517 /* and VREFINT measurement path. */
mbed_official 354:e67efb2aab0e 1518 if ((sConfig->Channel == ADC_CHANNEL_TEMPSENSOR) ||
mbed_official 354:e67efb2aab0e 1519 (sConfig->Channel == ADC_CHANNEL_VREFINT) )
mbed_official 354:e67efb2aab0e 1520 {
mbed_official 354:e67efb2aab0e 1521 SET_BIT(ADC->CCR, ADC_CCR_TSVREFE);
mbed_official 354:e67efb2aab0e 1522 }
mbed_official 354:e67efb2aab0e 1523
mbed_official 354:e67efb2aab0e 1524 /* Process unlocked */
mbed_official 354:e67efb2aab0e 1525 __HAL_UNLOCK(hadc);
mbed_official 354:e67efb2aab0e 1526
mbed_official 354:e67efb2aab0e 1527 /* Return function status */
mbed_official 354:e67efb2aab0e 1528 return tmpHALStatus;
mbed_official 354:e67efb2aab0e 1529 }
mbed_official 354:e67efb2aab0e 1530
mbed_official 354:e67efb2aab0e 1531 /**
mbed_official 354:e67efb2aab0e 1532 * @brief Configures the analog watchdog.
mbed_official 354:e67efb2aab0e 1533 * @param hadc: ADC handle
mbed_official 354:e67efb2aab0e 1534 * @param AnalogWDGConfig: Structure of ADC analog watchdog configuration
mbed_official 354:e67efb2aab0e 1535 * @retval HAL status
mbed_official 354:e67efb2aab0e 1536 */
mbed_official 354:e67efb2aab0e 1537 HAL_StatusTypeDef HAL_ADC_AnalogWDGConfig(ADC_HandleTypeDef* hadc, ADC_AnalogWDGConfTypeDef* AnalogWDGConfig)
mbed_official 354:e67efb2aab0e 1538 {
mbed_official 354:e67efb2aab0e 1539 /* Check the parameters */
mbed_official 354:e67efb2aab0e 1540 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 354:e67efb2aab0e 1541 assert_param(IS_ADC_ANALOG_WATCHDOG_MODE(AnalogWDGConfig->WatchdogMode));
mbed_official 354:e67efb2aab0e 1542 assert_param(IS_FUNCTIONAL_STATE(AnalogWDGConfig->ITMode));
mbed_official 354:e67efb2aab0e 1543 assert_param(IS_ADC_RANGE(AnalogWDGConfig->HighThreshold));
mbed_official 354:e67efb2aab0e 1544 assert_param(IS_ADC_RANGE(AnalogWDGConfig->LowThreshold));
mbed_official 354:e67efb2aab0e 1545
mbed_official 354:e67efb2aab0e 1546 if((AnalogWDGConfig->WatchdogMode == ADC_ANALOGWATCHDOG_SINGLE_REG) ||
mbed_official 354:e67efb2aab0e 1547 (AnalogWDGConfig->WatchdogMode == ADC_ANALOGWATCHDOG_SINGLE_INJEC) ||
mbed_official 354:e67efb2aab0e 1548 (AnalogWDGConfig->WatchdogMode == ADC_ANALOGWATCHDOG_SINGLE_REGINJEC) )
mbed_official 354:e67efb2aab0e 1549 {
mbed_official 354:e67efb2aab0e 1550 assert_param(IS_ADC_CHANNEL(AnalogWDGConfig->Channel));
mbed_official 354:e67efb2aab0e 1551 }
mbed_official 354:e67efb2aab0e 1552
mbed_official 354:e67efb2aab0e 1553 /* Process locked */
mbed_official 354:e67efb2aab0e 1554 __HAL_LOCK(hadc);
mbed_official 354:e67efb2aab0e 1555
mbed_official 354:e67efb2aab0e 1556 /* Analog watchdog configuration */
mbed_official 354:e67efb2aab0e 1557
mbed_official 354:e67efb2aab0e 1558 /* Configure ADC Analog watchdog interrupt */
mbed_official 354:e67efb2aab0e 1559 if(AnalogWDGConfig->ITMode == ENABLE)
mbed_official 354:e67efb2aab0e 1560 {
mbed_official 354:e67efb2aab0e 1561 /* Enable the ADC Analog watchdog interrupt */
mbed_official 354:e67efb2aab0e 1562 __HAL_ADC_ENABLE_IT(hadc, ADC_IT_AWD);
mbed_official 354:e67efb2aab0e 1563 }
mbed_official 354:e67efb2aab0e 1564 else
mbed_official 354:e67efb2aab0e 1565 {
mbed_official 354:e67efb2aab0e 1566 /* Disable the ADC Analog watchdog interrupt */
mbed_official 354:e67efb2aab0e 1567 __HAL_ADC_DISABLE_IT(hadc, ADC_IT_AWD);
mbed_official 354:e67efb2aab0e 1568 }
mbed_official 354:e67efb2aab0e 1569
mbed_official 354:e67efb2aab0e 1570 /* Configuration of analog watchdog: */
mbed_official 354:e67efb2aab0e 1571 /* - Set the analog watchdog enable mode: regular and/or injected groups, */
mbed_official 354:e67efb2aab0e 1572 /* one or all channels. */
mbed_official 354:e67efb2aab0e 1573 /* - Set the Analog watchdog channel (is not used if watchdog */
mbed_official 354:e67efb2aab0e 1574 /* mode "all channels": ADC_CFGR_AWD1SGL=0). */
mbed_official 354:e67efb2aab0e 1575 hadc->Instance->CR1 &= ~( ADC_CR1_AWDSGL |
mbed_official 354:e67efb2aab0e 1576 ADC_CR1_JAWDEN |
mbed_official 354:e67efb2aab0e 1577 ADC_CR1_AWDEN |
mbed_official 354:e67efb2aab0e 1578 ADC_CR1_AWDCH );
mbed_official 354:e67efb2aab0e 1579
mbed_official 354:e67efb2aab0e 1580 hadc->Instance->CR1 |= ( AnalogWDGConfig->WatchdogMode |
mbed_official 354:e67efb2aab0e 1581 AnalogWDGConfig->Channel );
mbed_official 354:e67efb2aab0e 1582
mbed_official 354:e67efb2aab0e 1583 /* Set the high threshold */
mbed_official 354:e67efb2aab0e 1584 hadc->Instance->HTR = AnalogWDGConfig->HighThreshold;
mbed_official 354:e67efb2aab0e 1585
mbed_official 354:e67efb2aab0e 1586 /* Set the low threshold */
mbed_official 354:e67efb2aab0e 1587 hadc->Instance->LTR = AnalogWDGConfig->LowThreshold;
mbed_official 354:e67efb2aab0e 1588
mbed_official 354:e67efb2aab0e 1589 /* Process unlocked */
mbed_official 354:e67efb2aab0e 1590 __HAL_UNLOCK(hadc);
mbed_official 354:e67efb2aab0e 1591
mbed_official 354:e67efb2aab0e 1592 /* Return function status */
mbed_official 354:e67efb2aab0e 1593 return HAL_OK;
mbed_official 354:e67efb2aab0e 1594 }
mbed_official 354:e67efb2aab0e 1595
mbed_official 354:e67efb2aab0e 1596
mbed_official 354:e67efb2aab0e 1597 /**
mbed_official 354:e67efb2aab0e 1598 * @}
mbed_official 354:e67efb2aab0e 1599 */
mbed_official 354:e67efb2aab0e 1600
mbed_official 354:e67efb2aab0e 1601
mbed_official 354:e67efb2aab0e 1602 /** @defgroup ADC_Exported_Functions_Group4 Peripheral State functions
mbed_official 354:e67efb2aab0e 1603 * @brief Peripheral State functions
mbed_official 354:e67efb2aab0e 1604 *
mbed_official 354:e67efb2aab0e 1605 @verbatim
mbed_official 354:e67efb2aab0e 1606 ===============================================================================
mbed_official 354:e67efb2aab0e 1607 ##### Peripheral State and Errors functions #####
mbed_official 354:e67efb2aab0e 1608 ===============================================================================
mbed_official 354:e67efb2aab0e 1609 [..]
mbed_official 354:e67efb2aab0e 1610 This subsection provides functions to get in run-time the status of the
mbed_official 354:e67efb2aab0e 1611 peripheral.
mbed_official 354:e67efb2aab0e 1612 (+) Check the ADC state
mbed_official 354:e67efb2aab0e 1613 (+) Check the ADC error code
mbed_official 354:e67efb2aab0e 1614
mbed_official 354:e67efb2aab0e 1615 @endverbatim
mbed_official 354:e67efb2aab0e 1616 * @{
mbed_official 354:e67efb2aab0e 1617 */
mbed_official 354:e67efb2aab0e 1618
mbed_official 354:e67efb2aab0e 1619 /**
mbed_official 354:e67efb2aab0e 1620 * @brief return the ADC state
mbed_official 354:e67efb2aab0e 1621 * @param hadc: ADC handle
mbed_official 354:e67efb2aab0e 1622 * @retval HAL state
mbed_official 354:e67efb2aab0e 1623 */
mbed_official 354:e67efb2aab0e 1624 HAL_ADC_StateTypeDef HAL_ADC_GetState(ADC_HandleTypeDef* hadc)
mbed_official 354:e67efb2aab0e 1625 {
mbed_official 354:e67efb2aab0e 1626 /* Return ADC state */
mbed_official 354:e67efb2aab0e 1627 return hadc->State;
mbed_official 354:e67efb2aab0e 1628 }
mbed_official 354:e67efb2aab0e 1629
mbed_official 354:e67efb2aab0e 1630 /**
mbed_official 354:e67efb2aab0e 1631 * @brief Return the ADC error code
mbed_official 354:e67efb2aab0e 1632 * @param hadc: ADC handle
mbed_official 354:e67efb2aab0e 1633 * @retval ADC Error Code
mbed_official 354:e67efb2aab0e 1634 */
mbed_official 354:e67efb2aab0e 1635 uint32_t HAL_ADC_GetError(ADC_HandleTypeDef *hadc)
mbed_official 354:e67efb2aab0e 1636 {
mbed_official 354:e67efb2aab0e 1637 return hadc->ErrorCode;
mbed_official 354:e67efb2aab0e 1638 }
mbed_official 354:e67efb2aab0e 1639
mbed_official 354:e67efb2aab0e 1640 /**
mbed_official 354:e67efb2aab0e 1641 * @}
mbed_official 354:e67efb2aab0e 1642 */
mbed_official 354:e67efb2aab0e 1643
mbed_official 354:e67efb2aab0e 1644 /**
mbed_official 354:e67efb2aab0e 1645 * @}
mbed_official 354:e67efb2aab0e 1646 */
mbed_official 354:e67efb2aab0e 1647
mbed_official 354:e67efb2aab0e 1648 /** @defgroup ADC_Private_Functions ADC Private Functions
mbed_official 354:e67efb2aab0e 1649 * @{
mbed_official 354:e67efb2aab0e 1650 */
mbed_official 354:e67efb2aab0e 1651
mbed_official 354:e67efb2aab0e 1652 /**
mbed_official 354:e67efb2aab0e 1653 * @brief Enable the selected ADC.
mbed_official 354:e67efb2aab0e 1654 * @note Prerequisite condition to use this function: ADC must be disabled
mbed_official 354:e67efb2aab0e 1655 * and voltage regulator must be enabled (done into HAL_ADC_Init()).
mbed_official 354:e67efb2aab0e 1656 * @param hadc: ADC handle
mbed_official 354:e67efb2aab0e 1657 * @retval HAL status.
mbed_official 354:e67efb2aab0e 1658 */
mbed_official 354:e67efb2aab0e 1659 HAL_StatusTypeDef ADC_Enable(ADC_HandleTypeDef* hadc)
mbed_official 354:e67efb2aab0e 1660 {
mbed_official 354:e67efb2aab0e 1661 uint32_t wait_loop_index = 0;
mbed_official 354:e67efb2aab0e 1662 uint32_t tickstart = 0;
mbed_official 354:e67efb2aab0e 1663
mbed_official 354:e67efb2aab0e 1664 /* ADC enable and wait for ADC ready (in case of ADC is disabled or */
mbed_official 354:e67efb2aab0e 1665 /* enabling phase not yet completed: flag ADC ready not yet set). */
mbed_official 354:e67efb2aab0e 1666 /* Timeout implemented to not be stuck if ADC cannot be enabled (possible */
mbed_official 354:e67efb2aab0e 1667 /* causes: ADC clock not running, ...). */
mbed_official 354:e67efb2aab0e 1668 if (__HAL_ADC_IS_ENABLED(hadc) == RESET)
mbed_official 354:e67efb2aab0e 1669 {
mbed_official 354:e67efb2aab0e 1670 /* Enable the Peripheral */
mbed_official 354:e67efb2aab0e 1671 __ADC_ENABLE(hadc);
mbed_official 354:e67efb2aab0e 1672
mbed_official 354:e67efb2aab0e 1673 /* Delay for ADC stabilization time. */
mbed_official 354:e67efb2aab0e 1674 /* Delay fixed to worst case: maximum CPU frequency */
mbed_official 354:e67efb2aab0e 1675 while(wait_loop_index < ADC_STAB_DELAY_CPU_CYCLES)
mbed_official 354:e67efb2aab0e 1676 {
mbed_official 354:e67efb2aab0e 1677 wait_loop_index++;
mbed_official 354:e67efb2aab0e 1678 }
mbed_official 354:e67efb2aab0e 1679
mbed_official 354:e67efb2aab0e 1680 /* Get timeout */
mbed_official 354:e67efb2aab0e 1681 tickstart = HAL_GetTick();
mbed_official 354:e67efb2aab0e 1682
mbed_official 354:e67efb2aab0e 1683 /* Wait for ADC effectively enabled */
mbed_official 354:e67efb2aab0e 1684 while(__HAL_ADC_IS_ENABLED(hadc) == RESET)
mbed_official 354:e67efb2aab0e 1685 {
mbed_official 354:e67efb2aab0e 1686 if((HAL_GetTick() - tickstart ) > ADC_ENABLE_TIMEOUT)
mbed_official 354:e67efb2aab0e 1687 {
mbed_official 354:e67efb2aab0e 1688 /* Update ADC state machine to error */
mbed_official 354:e67efb2aab0e 1689 hadc->State = HAL_ADC_STATE_ERROR;
mbed_official 354:e67efb2aab0e 1690
mbed_official 354:e67efb2aab0e 1691 /* Set ADC error code to ADC IP internal error */
mbed_official 354:e67efb2aab0e 1692 hadc->ErrorCode |= HAL_ADC_ERROR_INTERNAL;
mbed_official 354:e67efb2aab0e 1693
mbed_official 354:e67efb2aab0e 1694 /* Process unlocked */
mbed_official 354:e67efb2aab0e 1695 __HAL_UNLOCK(hadc);
mbed_official 354:e67efb2aab0e 1696
mbed_official 354:e67efb2aab0e 1697 return HAL_ERROR;
mbed_official 354:e67efb2aab0e 1698 }
mbed_official 354:e67efb2aab0e 1699 }
mbed_official 354:e67efb2aab0e 1700 }
mbed_official 354:e67efb2aab0e 1701
mbed_official 354:e67efb2aab0e 1702 /* Return HAL status */
mbed_official 354:e67efb2aab0e 1703 return HAL_OK;
mbed_official 354:e67efb2aab0e 1704 }
mbed_official 354:e67efb2aab0e 1705
mbed_official 354:e67efb2aab0e 1706 /**
mbed_official 354:e67efb2aab0e 1707 * @brief Stop ADC conversion and disable the selected ADC
mbed_official 354:e67efb2aab0e 1708 * @note Prerequisite condition to use this function: ADC conversions must be
mbed_official 354:e67efb2aab0e 1709 * stopped to disable the ADC.
mbed_official 354:e67efb2aab0e 1710 * @param hadc: ADC handle
mbed_official 354:e67efb2aab0e 1711 * @retval HAL status.
mbed_official 354:e67efb2aab0e 1712 */
mbed_official 354:e67efb2aab0e 1713 HAL_StatusTypeDef ADC_ConversionStop_Disable(ADC_HandleTypeDef* hadc)
mbed_official 354:e67efb2aab0e 1714 {
mbed_official 354:e67efb2aab0e 1715 uint32_t tickstart = 0;
mbed_official 354:e67efb2aab0e 1716
mbed_official 354:e67efb2aab0e 1717 /* Verification if ADC is not already disabled: */
mbed_official 354:e67efb2aab0e 1718 if (__HAL_ADC_IS_ENABLED(hadc) != RESET)
mbed_official 354:e67efb2aab0e 1719 {
mbed_official 354:e67efb2aab0e 1720 /* Disable the ADC peripheral */
mbed_official 354:e67efb2aab0e 1721 __ADC_DISABLE(hadc);
mbed_official 354:e67efb2aab0e 1722
mbed_official 354:e67efb2aab0e 1723 /* Get timeout */
mbed_official 354:e67efb2aab0e 1724 tickstart = HAL_GetTick();
mbed_official 354:e67efb2aab0e 1725
mbed_official 354:e67efb2aab0e 1726 /* Wait for ADC effectively disabled */
mbed_official 354:e67efb2aab0e 1727 while(__HAL_ADC_IS_ENABLED(hadc) != RESET)
mbed_official 354:e67efb2aab0e 1728 {
mbed_official 354:e67efb2aab0e 1729 if((HAL_GetTick() - tickstart ) > ADC_DISABLE_TIMEOUT)
mbed_official 354:e67efb2aab0e 1730 {
mbed_official 354:e67efb2aab0e 1731 /* Update ADC state machine to error */
mbed_official 354:e67efb2aab0e 1732 hadc->State = HAL_ADC_STATE_ERROR;
mbed_official 354:e67efb2aab0e 1733
mbed_official 354:e67efb2aab0e 1734 /* Set ADC error code to ADC IP internal error */
mbed_official 354:e67efb2aab0e 1735 hadc->ErrorCode |= HAL_ADC_ERROR_INTERNAL;
mbed_official 354:e67efb2aab0e 1736
mbed_official 354:e67efb2aab0e 1737 return HAL_ERROR;
mbed_official 354:e67efb2aab0e 1738 }
mbed_official 354:e67efb2aab0e 1739 }
mbed_official 354:e67efb2aab0e 1740 }
mbed_official 354:e67efb2aab0e 1741
mbed_official 354:e67efb2aab0e 1742 /* Return HAL status */
mbed_official 354:e67efb2aab0e 1743 return HAL_OK;
mbed_official 354:e67efb2aab0e 1744 }
mbed_official 354:e67efb2aab0e 1745
mbed_official 354:e67efb2aab0e 1746 /**
mbed_official 354:e67efb2aab0e 1747 * @}
mbed_official 354:e67efb2aab0e 1748 */
mbed_official 354:e67efb2aab0e 1749
mbed_official 354:e67efb2aab0e 1750 #endif /* HAL_ADC_MODULE_ENABLED */
mbed_official 354:e67efb2aab0e 1751 /**
mbed_official 354:e67efb2aab0e 1752 * @}
mbed_official 354:e67efb2aab0e 1753 */
mbed_official 354:e67efb2aab0e 1754
mbed_official 354:e67efb2aab0e 1755 /**
mbed_official 354:e67efb2aab0e 1756 * @}
mbed_official 354:e67efb2aab0e 1757 */
mbed_official 354:e67efb2aab0e 1758
mbed_official 354:e67efb2aab0e 1759 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/