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_STM32F7/stm32f7xx_hal_adc.c@610:813dcc80987e, 2015-08-14 (annotated)

Committer:
mbed_official
Date:
Fri Aug 14 13:15:17 2015 +0100
Revision:
610:813dcc80987e
Parent:
573:ad23fe03a082 
Synchronized with git revision 6d84db41c6833e0b9b024741eb0616a5f62d5599



Full URL: https://github.com/mbedmicro/mbed/commit/6d84db41c6833e0b9b024741eb0616a5f62d5599/



DISCO_F746NG - Improvements

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mbed_official 573:ad23fe03a082 1 /**
mbed_official 573:ad23fe03a082 2 ******************************************************************************
mbed_official 573:ad23fe03a082 3 * @file stm32f7xx_hal_adc.c
mbed_official 573:ad23fe03a082 4 * @author MCD Application Team
mbed_official 610:813dcc80987e 5 * @version V1.0.1
mbed_official 610:813dcc80987e 6 * @date 25-June-2015
mbed_official 573:ad23fe03a082 7 * @brief This file provides firmware functions to manage the following
mbed_official 573:ad23fe03a082 8 * functionalities of the Analog to Digital Convertor (ADC) peripheral:
mbed_official 573:ad23fe03a082 9 * + Initialization and de-initialization functions
mbed_official 573:ad23fe03a082 10 * + IO operation functions
mbed_official 573:ad23fe03a082 11 * + State and errors functions
mbed_official 573:ad23fe03a082 12 *
mbed_official 573:ad23fe03a082 13 @verbatim
mbed_official 573:ad23fe03a082 14 ==============================================================================
mbed_official 573:ad23fe03a082 15 ##### ADC Peripheral features #####
mbed_official 573:ad23fe03a082 16 ==============================================================================
mbed_official 573:ad23fe03a082 17 [..]
mbed_official 573:ad23fe03a082 18 (#) 12-bit, 10-bit, 8-bit or 6-bit configurable resolution.
mbed_official 573:ad23fe03a082 19 (#) Interrupt generation at the end of conversion, end of injected conversion,
mbed_official 573:ad23fe03a082 20 and in case of analog watchdog or overrun events
mbed_official 573:ad23fe03a082 21 (#) Single and continuous conversion modes.
mbed_official 573:ad23fe03a082 22 (#) Scan mode for automatic conversion of channel 0 to channel x.
mbed_official 573:ad23fe03a082 23 (#) Data alignment with in-built data coherency.
mbed_official 573:ad23fe03a082 24 (#) Channel-wise programmable sampling time.
mbed_official 573:ad23fe03a082 25 (#) External trigger option with configurable polarity for both regular and
mbed_official 573:ad23fe03a082 26 injected conversion.
mbed_official 573:ad23fe03a082 27 (#) Dual/Triple mode (on devices with 2 ADCs or more).
mbed_official 573:ad23fe03a082 28 (#) Configurable DMA data storage in Dual/Triple ADC mode.
mbed_official 573:ad23fe03a082 29 (#) Configurable delay between conversions in Dual/Triple interleaved mode.
mbed_official 573:ad23fe03a082 30 (#) ADC conversion type (refer to the datasheets).
mbed_official 573:ad23fe03a082 31 (#) ADC supply requirements: 2.4 V to 3.6 V at full speed and down to 1.8 V at
mbed_official 573:ad23fe03a082 32 slower speed.
mbed_official 573:ad23fe03a082 33 (#) ADC input range: VREF(minus) = VIN = VREF(plus).
mbed_official 573:ad23fe03a082 34 (#) DMA request generation during regular channel conversion.
mbed_official 573:ad23fe03a082 35
mbed_official 573:ad23fe03a082 36
mbed_official 573:ad23fe03a082 37 ##### How to use this driver #####
mbed_official 573:ad23fe03a082 38 ==============================================================================
mbed_official 573:ad23fe03a082 39 [..]
mbed_official 573:ad23fe03a082 40 (#)Initialize the ADC low level resources by implementing the HAL_ADC_MspInit():
mbed_official 573:ad23fe03a082 41 (##) Enable the ADC interface clock using __HAL_RCC_ADC_CLK_ENABLE()
mbed_official 573:ad23fe03a082 42 (##) ADC pins configuration
mbed_official 573:ad23fe03a082 43 (+++) Enable the clock for the ADC GPIOs using the following function:
mbed_official 573:ad23fe03a082 44 __HAL_RCC_GPIOx_CLK_ENABLE()
mbed_official 573:ad23fe03a082 45 (+++) Configure these ADC pins in analog mode using HAL_GPIO_Init()
mbed_official 573:ad23fe03a082 46 (##) In case of using interrupts (e.g. HAL_ADC_Start_IT())
mbed_official 573:ad23fe03a082 47 (+++) Configure the ADC interrupt priority using HAL_NVIC_SetPriority()
mbed_official 573:ad23fe03a082 48 (+++) Enable the ADC IRQ handler using HAL_NVIC_EnableIRQ()
mbed_official 573:ad23fe03a082 49 (+++) In ADC IRQ handler, call HAL_ADC_IRQHandler()
mbed_official 573:ad23fe03a082 50 (##) In case of using DMA to control data transfer (e.g. HAL_ADC_Start_DMA())
mbed_official 573:ad23fe03a082 51 (+++) Enable the DMAx interface clock using __HAL_RCC_DMAx_CLK_ENABLE()
mbed_official 573:ad23fe03a082 52 (+++) Configure and enable two DMA streams stream for managing data
mbed_official 573:ad23fe03a082 53 transfer from peripheral to memory (output stream)
mbed_official 573:ad23fe03a082 54 (+++) Associate the initialized DMA handle to the CRYP DMA handle
mbed_official 573:ad23fe03a082 55 using __HAL_LINKDMA()
mbed_official 573:ad23fe03a082 56 (+++) Configure the priority and enable the NVIC for the transfer complete
mbed_official 573:ad23fe03a082 57 interrupt on the two DMA Streams. The output stream should have higher
mbed_official 573:ad23fe03a082 58 priority than the input stream.
mbed_official 573:ad23fe03a082 59
mbed_official 573:ad23fe03a082 60 *** Configuration of ADC, groups regular/injected, channels parameters ***
mbed_official 573:ad23fe03a082 61 ==============================================================================
mbed_official 573:ad23fe03a082 62 [..]
mbed_official 573:ad23fe03a082 63 (#) Configure the ADC parameters (resolution, data alignment, ...)
mbed_official 573:ad23fe03a082 64 and regular group parameters (conversion trigger, sequencer, ...)
mbed_official 573:ad23fe03a082 65 using function HAL_ADC_Init().
mbed_official 573:ad23fe03a082 66
mbed_official 573:ad23fe03a082 67 (#) Configure the channels for regular group parameters (channel number,
mbed_official 573:ad23fe03a082 68 channel rank into sequencer, ..., into regular group)
mbed_official 573:ad23fe03a082 69 using function HAL_ADC_ConfigChannel().
mbed_official 573:ad23fe03a082 70
mbed_official 573:ad23fe03a082 71 (#) Optionally, configure the injected group parameters (conversion trigger,
mbed_official 573:ad23fe03a082 72 sequencer, ..., of injected group)
mbed_official 573:ad23fe03a082 73 and the channels for injected group parameters (channel number,
mbed_official 573:ad23fe03a082 74 channel rank into sequencer, ..., into injected group)
mbed_official 573:ad23fe03a082 75 using function HAL_ADCEx_InjectedConfigChannel().
mbed_official 573:ad23fe03a082 76
mbed_official 573:ad23fe03a082 77 (#) Optionally, configure the analog watchdog parameters (channels
mbed_official 573:ad23fe03a082 78 monitored, thresholds, ...) using function HAL_ADC_AnalogWDGConfig().
mbed_official 573:ad23fe03a082 79
mbed_official 573:ad23fe03a082 80 (#) Optionally, for devices with several ADC instances: configure the
mbed_official 573:ad23fe03a082 81 multimode parameters using function HAL_ADCEx_MultiModeConfigChannel().
mbed_official 573:ad23fe03a082 82
mbed_official 573:ad23fe03a082 83 *** Execution of ADC conversions ***
mbed_official 573:ad23fe03a082 84 ==============================================================================
mbed_official 573:ad23fe03a082 85 [..]
mbed_official 573:ad23fe03a082 86 (#) ADC driver can be used among three modes: polling, interruption,
mbed_official 573:ad23fe03a082 87 transfer by DMA.
mbed_official 573:ad23fe03a082 88
mbed_official 573:ad23fe03a082 89 *** Polling mode IO operation ***
mbed_official 573:ad23fe03a082 90 =================================
mbed_official 573:ad23fe03a082 91 [..]
mbed_official 573:ad23fe03a082 92 (+) Start the ADC peripheral using HAL_ADC_Start()
mbed_official 573:ad23fe03a082 93 (+) Wait for end of conversion using HAL_ADC_PollForConversion(), at this stage
mbed_official 573:ad23fe03a082 94 user can specify the value of timeout according to his end application
mbed_official 573:ad23fe03a082 95 (+) To read the ADC converted values, use the HAL_ADC_GetValue() function.
mbed_official 573:ad23fe03a082 96 (+) Stop the ADC peripheral using HAL_ADC_Stop()
mbed_official 573:ad23fe03a082 97
mbed_official 573:ad23fe03a082 98 *** Interrupt mode IO operation ***
mbed_official 573:ad23fe03a082 99 ===================================
mbed_official 573:ad23fe03a082 100 [..]
mbed_official 573:ad23fe03a082 101 (+) Start the ADC peripheral using HAL_ADC_Start_IT()
mbed_official 573:ad23fe03a082 102 (+) Use HAL_ADC_IRQHandler() called under ADC_IRQHandler() Interrupt subroutine
mbed_official 573:ad23fe03a082 103 (+) At ADC end of conversion HAL_ADC_ConvCpltCallback() function is executed and user can
mbed_official 573:ad23fe03a082 104 add his own code by customization of function pointer HAL_ADC_ConvCpltCallback
mbed_official 573:ad23fe03a082 105 (+) In case of ADC Error, HAL_ADC_ErrorCallback() function is executed and user can
mbed_official 573:ad23fe03a082 106 add his own code by customization of function pointer HAL_ADC_ErrorCallback
mbed_official 573:ad23fe03a082 107 (+) Stop the ADC peripheral using HAL_ADC_Stop_IT()
mbed_official 573:ad23fe03a082 108
mbed_official 573:ad23fe03a082 109 *** DMA mode IO operation ***
mbed_official 573:ad23fe03a082 110 ==============================
mbed_official 573:ad23fe03a082 111 [..]
mbed_official 573:ad23fe03a082 112 (+) Start the ADC peripheral using HAL_ADC_Start_DMA(), at this stage the user specify the length
mbed_official 573:ad23fe03a082 113 of data to be transferred at each end of conversion
mbed_official 573:ad23fe03a082 114 (+) At The end of data transfer by HAL_ADC_ConvCpltCallback() function is executed and user can
mbed_official 573:ad23fe03a082 115 add his own code by customization of function pointer HAL_ADC_ConvCpltCallback
mbed_official 573:ad23fe03a082 116 (+) In case of transfer Error, HAL_ADC_ErrorCallback() function is executed and user can
mbed_official 573:ad23fe03a082 117 add his own code by customization of function pointer HAL_ADC_ErrorCallback
mbed_official 573:ad23fe03a082 118 (+) Stop the ADC peripheral using HAL_ADC_Stop_DMA()
mbed_official 573:ad23fe03a082 119
mbed_official 573:ad23fe03a082 120 *** ADC HAL driver macros list ***
mbed_official 573:ad23fe03a082 121 =============================================
mbed_official 573:ad23fe03a082 122 [..]
mbed_official 573:ad23fe03a082 123 Below the list of most used macros in ADC HAL driver.
mbed_official 573:ad23fe03a082 124
mbed_official 573:ad23fe03a082 125 (+) __HAL_ADC_ENABLE : Enable the ADC peripheral
mbed_official 573:ad23fe03a082 126 (+) __HAL_ADC_DISABLE : Disable the ADC peripheral
mbed_official 573:ad23fe03a082 127 (+) __HAL_ADC_ENABLE_IT: Enable the ADC end of conversion interrupt
mbed_official 573:ad23fe03a082 128 (+) __HAL_ADC_DISABLE_IT: Disable the ADC end of conversion interrupt
mbed_official 573:ad23fe03a082 129 (+) __HAL_ADC_GET_IT_SOURCE: Check if the specified ADC interrupt source is enabled or disabled
mbed_official 573:ad23fe03a082 130 (+) __HAL_ADC_CLEAR_FLAG: Clear the ADC's pending flags
mbed_official 573:ad23fe03a082 131 (+) __HAL_ADC_GET_FLAG: Get the selected ADC's flag status
mbed_official 573:ad23fe03a082 132 (+) ADC_GET_RESOLUTION: Return resolution bits in CR1 register
mbed_official 573:ad23fe03a082 133
mbed_official 573:ad23fe03a082 134 [..]
mbed_official 573:ad23fe03a082 135 (@) You can refer to the ADC HAL driver header file for more useful macros
mbed_official 573:ad23fe03a082 136
mbed_official 573:ad23fe03a082 137 *** Deinitialization of ADC ***
mbed_official 573:ad23fe03a082 138 ==============================================================================
mbed_official 573:ad23fe03a082 139 [..]
mbed_official 573:ad23fe03a082 140 (#) Disable the ADC interface
mbed_official 573:ad23fe03a082 141 (++) ADC clock can be hard reset and disabled at RCC top level.
mbed_official 573:ad23fe03a082 142 (++) Hard reset of ADC peripherals
mbed_official 573:ad23fe03a082 143 using macro __HAL_RCC_ADC_FORCE_RESET(), __HAL_RCC_ADC_RELEASE_RESET().
mbed_official 573:ad23fe03a082 144 (++) ADC clock disable using the equivalent macro/functions as configuration step.
mbed_official 573:ad23fe03a082 145 (+++) Example:
mbed_official 573:ad23fe03a082 146 Into HAL_ADC_MspDeInit() (recommended code location) or with
mbed_official 573:ad23fe03a082 147 other device clock parameters configuration:
mbed_official 573:ad23fe03a082 148 (+++) HAL_RCC_GetOscConfig(&RCC_OscInitStructure);
mbed_official 573:ad23fe03a082 149 (+++) RCC_OscInitStructure.OscillatorType = RCC_OSCILLATORTYPE_HSI;
mbed_official 573:ad23fe03a082 150 (+++) RCC_OscInitStructure.HSIState = RCC_HSI_OFF; (if not used for system clock)
mbed_official 573:ad23fe03a082 151 (+++) HAL_RCC_OscConfig(&RCC_OscInitStructure);
mbed_official 573:ad23fe03a082 152
mbed_official 573:ad23fe03a082 153 (#) ADC pins configuration
mbed_official 573:ad23fe03a082 154 (++) Disable the clock for the ADC GPIOs using macro __HAL_RCC_GPIOx_CLK_DISABLE()
mbed_official 573:ad23fe03a082 155
mbed_official 573:ad23fe03a082 156 (#) Optionally, in case of usage of ADC with interruptions:
mbed_official 573:ad23fe03a082 157 (++) Disable the NVIC for ADC using function HAL_NVIC_DisableIRQ(ADCx_IRQn)
mbed_official 573:ad23fe03a082 158
mbed_official 573:ad23fe03a082 159 (#) Optionally, in case of usage of DMA:
mbed_official 573:ad23fe03a082 160 (++) Deinitialize the DMA using function HAL_DMA_DeInit().
mbed_official 573:ad23fe03a082 161 (++) Disable the NVIC for DMA using function HAL_NVIC_DisableIRQ(DMAx_Channelx_IRQn)
mbed_official 573:ad23fe03a082 162
mbed_official 573:ad23fe03a082 163 @endverbatim
mbed_official 573:ad23fe03a082 164 ******************************************************************************
mbed_official 573:ad23fe03a082 165 * @attention
mbed_official 573:ad23fe03a082 166 *
mbed_official 573:ad23fe03a082 167 * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
mbed_official 573:ad23fe03a082 168 *
mbed_official 573:ad23fe03a082 169 * Redistribution and use in source and binary forms, with or without modification,
mbed_official 573:ad23fe03a082 170 * are permitted provided that the following conditions are met:
mbed_official 573:ad23fe03a082 171 * 1. Redistributions of source code must retain the above copyright notice,
mbed_official 573:ad23fe03a082 172 * this list of conditions and the following disclaimer.
mbed_official 573:ad23fe03a082 173 * 2. Redistributions in binary form must reproduce the above copyright notice,
mbed_official 573:ad23fe03a082 174 * this list of conditions and the following disclaimer in the documentation
mbed_official 573:ad23fe03a082 175 * and/or other materials provided with the distribution.
mbed_official 573:ad23fe03a082 176 * 3. Neither the name of STMicroelectronics nor the names of its contributors
mbed_official 573:ad23fe03a082 177 * may be used to endorse or promote products derived from this software
mbed_official 573:ad23fe03a082 178 * without specific prior written permission.
mbed_official 573:ad23fe03a082 179 *
mbed_official 573:ad23fe03a082 180 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
mbed_official 573:ad23fe03a082 181 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
mbed_official 573:ad23fe03a082 182 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
mbed_official 573:ad23fe03a082 183 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
mbed_official 573:ad23fe03a082 184 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
mbed_official 573:ad23fe03a082 185 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
mbed_official 573:ad23fe03a082 186 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
mbed_official 573:ad23fe03a082 187 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
mbed_official 573:ad23fe03a082 188 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
mbed_official 573:ad23fe03a082 189 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
mbed_official 573:ad23fe03a082 190 *
mbed_official 573:ad23fe03a082 191 ******************************************************************************
mbed_official 573:ad23fe03a082 192 */
mbed_official 573:ad23fe03a082 193
mbed_official 573:ad23fe03a082 194 /* Includes ------------------------------------------------------------------*/
mbed_official 573:ad23fe03a082 195 #include "stm32f7xx_hal.h"
mbed_official 573:ad23fe03a082 196
mbed_official 573:ad23fe03a082 197 /** @addtogroup STM32F7xx_HAL_Driver
mbed_official 573:ad23fe03a082 198 * @{
mbed_official 573:ad23fe03a082 199 */
mbed_official 573:ad23fe03a082 200
mbed_official 573:ad23fe03a082 201 /** @defgroup ADC ADC
mbed_official 573:ad23fe03a082 202 * @brief ADC driver modules
mbed_official 573:ad23fe03a082 203 * @{
mbed_official 573:ad23fe03a082 204 */
mbed_official 573:ad23fe03a082 205
mbed_official 573:ad23fe03a082 206 #ifdef HAL_ADC_MODULE_ENABLED
mbed_official 573:ad23fe03a082 207
mbed_official 573:ad23fe03a082 208 /* Private typedef -----------------------------------------------------------*/
mbed_official 573:ad23fe03a082 209 /* Private define ------------------------------------------------------------*/
mbed_official 573:ad23fe03a082 210 /* Private macro -------------------------------------------------------------*/
mbed_official 573:ad23fe03a082 211 /* Private variables ---------------------------------------------------------*/
mbed_official 573:ad23fe03a082 212 /** @addtogroup ADC_Private_Functions
mbed_official 573:ad23fe03a082 213 * @{
mbed_official 573:ad23fe03a082 214 */
mbed_official 573:ad23fe03a082 215 /* Private function prototypes -----------------------------------------------*/
mbed_official 573:ad23fe03a082 216 static void ADC_Init(ADC_HandleTypeDef* hadc);
mbed_official 573:ad23fe03a082 217 static void ADC_DMAConvCplt(DMA_HandleTypeDef *hdma);
mbed_official 573:ad23fe03a082 218 static void ADC_DMAError(DMA_HandleTypeDef *hdma);
mbed_official 573:ad23fe03a082 219 static void ADC_DMAHalfConvCplt(DMA_HandleTypeDef *hdma);
mbed_official 573:ad23fe03a082 220 /**
mbed_official 573:ad23fe03a082 221 * @}
mbed_official 573:ad23fe03a082 222 */
mbed_official 573:ad23fe03a082 223
mbed_official 573:ad23fe03a082 224 /* Exported functions --------------------------------------------------------*/
mbed_official 573:ad23fe03a082 225 /** @defgroup ADC_Exported_Functions ADC Exported Functions
mbed_official 573:ad23fe03a082 226 * @{
mbed_official 573:ad23fe03a082 227 */
mbed_official 573:ad23fe03a082 228
mbed_official 573:ad23fe03a082 229 /** @defgroup ADC_Exported_Functions_Group1 Initialization and de-initialization functions
mbed_official 573:ad23fe03a082 230 * @brief Initialization and Configuration functions
mbed_official 573:ad23fe03a082 231 *
mbed_official 573:ad23fe03a082 232 @verbatim
mbed_official 573:ad23fe03a082 233 ===============================================================================
mbed_official 573:ad23fe03a082 234 ##### Initialization and de-initialization functions #####
mbed_official 573:ad23fe03a082 235 ===============================================================================
mbed_official 573:ad23fe03a082 236 [..] This section provides functions allowing to:
mbed_official 573:ad23fe03a082 237 (+) Initialize and configure the ADC.
mbed_official 573:ad23fe03a082 238 (+) De-initialize the ADC.
mbed_official 573:ad23fe03a082 239
mbed_official 573:ad23fe03a082 240 @endverbatim
mbed_official 573:ad23fe03a082 241 * @{
mbed_official 573:ad23fe03a082 242 */
mbed_official 573:ad23fe03a082 243
mbed_official 573:ad23fe03a082 244 /**
mbed_official 573:ad23fe03a082 245 * @brief Initializes the ADCx peripheral according to the specified parameters
mbed_official 573:ad23fe03a082 246 * in the ADC_InitStruct and initializes the ADC MSP.
mbed_official 573:ad23fe03a082 247 *
mbed_official 573:ad23fe03a082 248 * @note This function is used to configure the global features of the ADC (
mbed_official 573:ad23fe03a082 249 * ClockPrescaler, Resolution, Data Alignment and number of conversion), however,
mbed_official 573:ad23fe03a082 250 * the rest of the configuration parameters are specific to the regular
mbed_official 573:ad23fe03a082 251 * channels group (scan mode activation, continuous mode activation,
mbed_official 573:ad23fe03a082 252 * External trigger source and edge, DMA continuous request after the
mbed_official 573:ad23fe03a082 253 * last transfer and End of conversion selection).
mbed_official 573:ad23fe03a082 254 *
mbed_official 573:ad23fe03a082 255 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 256 * the configuration information for the specified ADC.
mbed_official 573:ad23fe03a082 257 * @retval HAL status
mbed_official 573:ad23fe03a082 258 */
mbed_official 573:ad23fe03a082 259 HAL_StatusTypeDef HAL_ADC_Init(ADC_HandleTypeDef* hadc)
mbed_official 573:ad23fe03a082 260 {
mbed_official 573:ad23fe03a082 261 /* Check ADC handle */
mbed_official 573:ad23fe03a082 262 if(hadc == NULL)
mbed_official 573:ad23fe03a082 263 {
mbed_official 573:ad23fe03a082 264 return HAL_ERROR;
mbed_official 573:ad23fe03a082 265 }
mbed_official 573:ad23fe03a082 266
mbed_official 573:ad23fe03a082 267 /* Check the parameters */
mbed_official 573:ad23fe03a082 268 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 573:ad23fe03a082 269 assert_param(IS_ADC_CLOCKPRESCALER(hadc->Init.ClockPrescaler));
mbed_official 573:ad23fe03a082 270 assert_param(IS_ADC_RESOLUTION(hadc->Init.Resolution));
mbed_official 573:ad23fe03a082 271 assert_param(IS_FUNCTIONAL_STATE(hadc->Init.ScanConvMode));
mbed_official 573:ad23fe03a082 272 assert_param(IS_FUNCTIONAL_STATE(hadc->Init.ContinuousConvMode));
mbed_official 573:ad23fe03a082 273 assert_param(IS_ADC_EXT_TRIG(hadc->Init.ExternalTrigConv));
mbed_official 573:ad23fe03a082 274 assert_param(IS_ADC_DATA_ALIGN(hadc->Init.DataAlign));
mbed_official 573:ad23fe03a082 275 assert_param(IS_ADC_REGULAR_LENGTH(hadc->Init.NbrOfConversion));
mbed_official 573:ad23fe03a082 276 assert_param(IS_FUNCTIONAL_STATE(hadc->Init.DMAContinuousRequests));
mbed_official 573:ad23fe03a082 277 assert_param(IS_ADC_EOCSelection(hadc->Init.EOCSelection));
mbed_official 573:ad23fe03a082 278 assert_param(IS_FUNCTIONAL_STATE(hadc->Init.DiscontinuousConvMode));
mbed_official 573:ad23fe03a082 279
mbed_official 573:ad23fe03a082 280 if(hadc->Init.ExternalTrigConv != ADC_SOFTWARE_START)
mbed_official 573:ad23fe03a082 281 {
mbed_official 573:ad23fe03a082 282 assert_param(IS_ADC_EXT_TRIG_EDGE(hadc->Init.ExternalTrigConvEdge));
mbed_official 573:ad23fe03a082 283 }
mbed_official 573:ad23fe03a082 284
mbed_official 573:ad23fe03a082 285 if(hadc->State == HAL_ADC_STATE_RESET)
mbed_official 573:ad23fe03a082 286 {
mbed_official 573:ad23fe03a082 287 /* Allocate lock resource and initialize it */
mbed_official 573:ad23fe03a082 288 hadc->Lock = HAL_UNLOCKED;
mbed_official 573:ad23fe03a082 289 /* Init the low level hardware */
mbed_official 573:ad23fe03a082 290 HAL_ADC_MspInit(hadc);
mbed_official 573:ad23fe03a082 291 }
mbed_official 573:ad23fe03a082 292
mbed_official 573:ad23fe03a082 293 /* Initialize the ADC state */
mbed_official 573:ad23fe03a082 294 hadc->State = HAL_ADC_STATE_BUSY;
mbed_official 573:ad23fe03a082 295
mbed_official 573:ad23fe03a082 296 /* Set ADC parameters */
mbed_official 573:ad23fe03a082 297 ADC_Init(hadc);
mbed_official 573:ad23fe03a082 298
mbed_official 573:ad23fe03a082 299 /* Set ADC error code to none */
mbed_official 573:ad23fe03a082 300 hadc->ErrorCode = HAL_ADC_ERROR_NONE;
mbed_official 573:ad23fe03a082 301
mbed_official 573:ad23fe03a082 302 /* Initialize the ADC state */
mbed_official 573:ad23fe03a082 303 hadc->State = HAL_ADC_STATE_READY;
mbed_official 573:ad23fe03a082 304
mbed_official 573:ad23fe03a082 305 /* Release Lock */
mbed_official 573:ad23fe03a082 306 __HAL_UNLOCK(hadc);
mbed_official 573:ad23fe03a082 307
mbed_official 573:ad23fe03a082 308 /* Return function status */
mbed_official 573:ad23fe03a082 309 return HAL_OK;
mbed_official 573:ad23fe03a082 310 }
mbed_official 573:ad23fe03a082 311
mbed_official 573:ad23fe03a082 312 /**
mbed_official 573:ad23fe03a082 313 * @brief Deinitializes the ADCx peripheral registers to their default reset values.
mbed_official 573:ad23fe03a082 314 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 315 * the configuration information for the specified ADC.
mbed_official 573:ad23fe03a082 316 * @retval HAL status
mbed_official 573:ad23fe03a082 317 */
mbed_official 573:ad23fe03a082 318 HAL_StatusTypeDef HAL_ADC_DeInit(ADC_HandleTypeDef* hadc)
mbed_official 573:ad23fe03a082 319 {
mbed_official 573:ad23fe03a082 320 /* Check ADC handle */
mbed_official 573:ad23fe03a082 321 if(hadc == NULL)
mbed_official 573:ad23fe03a082 322 {
mbed_official 573:ad23fe03a082 323 return HAL_ERROR;
mbed_official 573:ad23fe03a082 324 }
mbed_official 573:ad23fe03a082 325
mbed_official 573:ad23fe03a082 326 /* Check the parameters */
mbed_official 573:ad23fe03a082 327 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 573:ad23fe03a082 328
mbed_official 573:ad23fe03a082 329 /* Change ADC state */
mbed_official 573:ad23fe03a082 330 hadc->State = HAL_ADC_STATE_BUSY;
mbed_official 573:ad23fe03a082 331
mbed_official 573:ad23fe03a082 332 /* DeInit the low level hardware */
mbed_official 573:ad23fe03a082 333 HAL_ADC_MspDeInit(hadc);
mbed_official 573:ad23fe03a082 334
mbed_official 573:ad23fe03a082 335 /* Set ADC error code to none */
mbed_official 573:ad23fe03a082 336 hadc->ErrorCode = HAL_ADC_ERROR_NONE;
mbed_official 573:ad23fe03a082 337
mbed_official 573:ad23fe03a082 338 /* Change ADC state */
mbed_official 573:ad23fe03a082 339 hadc->State = HAL_ADC_STATE_RESET;
mbed_official 573:ad23fe03a082 340
mbed_official 573:ad23fe03a082 341 /* Return function status */
mbed_official 573:ad23fe03a082 342 return HAL_OK;
mbed_official 573:ad23fe03a082 343 }
mbed_official 573:ad23fe03a082 344
mbed_official 573:ad23fe03a082 345 /**
mbed_official 573:ad23fe03a082 346 * @brief Initializes the ADC MSP.
mbed_official 573:ad23fe03a082 347 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 348 * the configuration information for the specified ADC.
mbed_official 573:ad23fe03a082 349 * @retval None
mbed_official 573:ad23fe03a082 350 */
mbed_official 573:ad23fe03a082 351 __weak void HAL_ADC_MspInit(ADC_HandleTypeDef* hadc)
mbed_official 573:ad23fe03a082 352 {
mbed_official 573:ad23fe03a082 353 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 573:ad23fe03a082 354 the HAL_ADC_MspInit could be implemented in the user file
mbed_official 573:ad23fe03a082 355 */
mbed_official 573:ad23fe03a082 356 }
mbed_official 573:ad23fe03a082 357
mbed_official 573:ad23fe03a082 358 /**
mbed_official 573:ad23fe03a082 359 * @brief DeInitializes the ADC MSP.
mbed_official 573:ad23fe03a082 360 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 361 * the configuration information for the specified ADC.
mbed_official 573:ad23fe03a082 362 * @retval None
mbed_official 573:ad23fe03a082 363 */
mbed_official 573:ad23fe03a082 364 __weak void HAL_ADC_MspDeInit(ADC_HandleTypeDef* hadc)
mbed_official 573:ad23fe03a082 365 {
mbed_official 573:ad23fe03a082 366 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 573:ad23fe03a082 367 the HAL_ADC_MspDeInit could be implemented in the user file
mbed_official 573:ad23fe03a082 368 */
mbed_official 573:ad23fe03a082 369 }
mbed_official 573:ad23fe03a082 370
mbed_official 573:ad23fe03a082 371 /**
mbed_official 573:ad23fe03a082 372 * @}
mbed_official 573:ad23fe03a082 373 */
mbed_official 573:ad23fe03a082 374
mbed_official 573:ad23fe03a082 375 /** @defgroup ADC_Exported_Functions_Group2 IO operation functions
mbed_official 573:ad23fe03a082 376 * @brief IO operation functions
mbed_official 573:ad23fe03a082 377 *
mbed_official 573:ad23fe03a082 378 @verbatim
mbed_official 573:ad23fe03a082 379 ===============================================================================
mbed_official 573:ad23fe03a082 380 ##### IO operation functions #####
mbed_official 573:ad23fe03a082 381 ===============================================================================
mbed_official 573:ad23fe03a082 382 [..] This section provides functions allowing to:
mbed_official 573:ad23fe03a082 383 (+) Start conversion of regular channel.
mbed_official 573:ad23fe03a082 384 (+) Stop conversion of regular channel.
mbed_official 573:ad23fe03a082 385 (+) Start conversion of regular channel and enable interrupt.
mbed_official 573:ad23fe03a082 386 (+) Stop conversion of regular channel and disable interrupt.
mbed_official 573:ad23fe03a082 387 (+) Start conversion of regular channel and enable DMA transfer.
mbed_official 573:ad23fe03a082 388 (+) Stop conversion of regular channel and disable DMA transfer.
mbed_official 573:ad23fe03a082 389 (+) Handle ADC interrupt request.
mbed_official 573:ad23fe03a082 390
mbed_official 573:ad23fe03a082 391 @endverbatim
mbed_official 573:ad23fe03a082 392 * @{
mbed_official 573:ad23fe03a082 393 */
mbed_official 573:ad23fe03a082 394
mbed_official 573:ad23fe03a082 395 /**
mbed_official 573:ad23fe03a082 396 * @brief Enables ADC and starts conversion of the regular channels.
mbed_official 573:ad23fe03a082 397 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 398 * the configuration information for the specified ADC.
mbed_official 573:ad23fe03a082 399 * @retval HAL status
mbed_official 573:ad23fe03a082 400 */
mbed_official 573:ad23fe03a082 401 HAL_StatusTypeDef HAL_ADC_Start(ADC_HandleTypeDef* hadc)
mbed_official 573:ad23fe03a082 402 {
mbed_official 573:ad23fe03a082 403 __IO uint32_t counter = 0;
mbed_official 573:ad23fe03a082 404
mbed_official 573:ad23fe03a082 405 /* Check the parameters */
mbed_official 573:ad23fe03a082 406 assert_param(IS_FUNCTIONAL_STATE(hadc->Init.ContinuousConvMode));
mbed_official 573:ad23fe03a082 407 assert_param(IS_ADC_EXT_TRIG_EDGE(hadc->Init.ExternalTrigConvEdge));
mbed_official 573:ad23fe03a082 408
mbed_official 573:ad23fe03a082 409 /* Process locked */
mbed_official 573:ad23fe03a082 410 __HAL_LOCK(hadc);
mbed_official 573:ad23fe03a082 411
mbed_official 573:ad23fe03a082 412 /* Check if an injected conversion is ongoing */
mbed_official 573:ad23fe03a082 413 if(hadc->State == HAL_ADC_STATE_BUSY_INJ)
mbed_official 573:ad23fe03a082 414 {
mbed_official 573:ad23fe03a082 415 /* Change ADC state */
mbed_official 573:ad23fe03a082 416 hadc->State = HAL_ADC_STATE_BUSY_INJ_REG;
mbed_official 573:ad23fe03a082 417 }
mbed_official 573:ad23fe03a082 418 else
mbed_official 573:ad23fe03a082 419 {
mbed_official 573:ad23fe03a082 420 /* Change ADC state */
mbed_official 573:ad23fe03a082 421 hadc->State = HAL_ADC_STATE_BUSY_REG;
mbed_official 573:ad23fe03a082 422 }
mbed_official 573:ad23fe03a082 423
mbed_official 573:ad23fe03a082 424 /* Check if ADC peripheral is disabled in order to enable it and wait during
mbed_official 573:ad23fe03a082 425 Tstab time the ADC's stabilization */
mbed_official 573:ad23fe03a082 426 if((hadc->Instance->CR2 & ADC_CR2_ADON) != ADC_CR2_ADON)
mbed_official 573:ad23fe03a082 427 {
mbed_official 573:ad23fe03a082 428 /* Enable the Peripheral */
mbed_official 573:ad23fe03a082 429 __HAL_ADC_ENABLE(hadc);
mbed_official 573:ad23fe03a082 430
mbed_official 573:ad23fe03a082 431 /* Delay for ADC stabilization time */
mbed_official 573:ad23fe03a082 432 /* Compute number of CPU cycles to wait for */
mbed_official 573:ad23fe03a082 433 counter = (ADC_STAB_DELAY_US * (SystemCoreClock / 1000000));
mbed_official 573:ad23fe03a082 434 while(counter != 0)
mbed_official 573:ad23fe03a082 435 {
mbed_official 573:ad23fe03a082 436 counter--;
mbed_official 573:ad23fe03a082 437 }
mbed_official 573:ad23fe03a082 438 }
mbed_official 573:ad23fe03a082 439
mbed_official 573:ad23fe03a082 440 /* Process unlocked */
mbed_official 573:ad23fe03a082 441 __HAL_UNLOCK(hadc);
mbed_official 573:ad23fe03a082 442
mbed_official 573:ad23fe03a082 443 /* Check if Multimode enabled */
mbed_official 573:ad23fe03a082 444 if(HAL_IS_BIT_CLR(ADC->CCR, ADC_CCR_MULTI))
mbed_official 573:ad23fe03a082 445 {
mbed_official 573:ad23fe03a082 446 /* if no external trigger present enable software conversion of regular channels */
mbed_official 573:ad23fe03a082 447 if((hadc->Instance->CR2 & ADC_CR2_EXTEN) == RESET)
mbed_official 573:ad23fe03a082 448 {
mbed_official 573:ad23fe03a082 449 /* Enable the selected ADC software conversion for regular group */
mbed_official 573:ad23fe03a082 450 hadc->Instance->CR2 |= (uint32_t)ADC_CR2_SWSTART;
mbed_official 573:ad23fe03a082 451 }
mbed_official 573:ad23fe03a082 452 }
mbed_official 573:ad23fe03a082 453 else
mbed_official 573:ad23fe03a082 454 {
mbed_official 573:ad23fe03a082 455 /* if instance of handle correspond to ADC1 and no external trigger present enable software conversion of regular channels */
mbed_official 573:ad23fe03a082 456 if((hadc->Instance == ADC1) && ((hadc->Instance->CR2 & ADC_CR2_EXTEN) == RESET))
mbed_official 573:ad23fe03a082 457 {
mbed_official 573:ad23fe03a082 458 /* Enable the selected ADC software conversion for regular group */
mbed_official 573:ad23fe03a082 459 hadc->Instance->CR2 |= (uint32_t)ADC_CR2_SWSTART;
mbed_official 573:ad23fe03a082 460 }
mbed_official 573:ad23fe03a082 461 }
mbed_official 573:ad23fe03a082 462
mbed_official 573:ad23fe03a082 463 /* Return function status */
mbed_official 573:ad23fe03a082 464 return HAL_OK;
mbed_official 573:ad23fe03a082 465 }
mbed_official 573:ad23fe03a082 466
mbed_official 573:ad23fe03a082 467 /**
mbed_official 573:ad23fe03a082 468 * @brief Disables ADC and stop conversion of regular channels.
mbed_official 573:ad23fe03a082 469 *
mbed_official 573:ad23fe03a082 470 * @note Caution: This function will stop also injected channels.
mbed_official 573:ad23fe03a082 471 *
mbed_official 573:ad23fe03a082 472 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 473 * the configuration information for the specified ADC.
mbed_official 573:ad23fe03a082 474 *
mbed_official 573:ad23fe03a082 475 * @retval HAL status.
mbed_official 573:ad23fe03a082 476 */
mbed_official 573:ad23fe03a082 477 HAL_StatusTypeDef HAL_ADC_Stop(ADC_HandleTypeDef* hadc)
mbed_official 573:ad23fe03a082 478 {
mbed_official 573:ad23fe03a082 479 /* Disable the Peripheral */
mbed_official 573:ad23fe03a082 480 __HAL_ADC_DISABLE(hadc);
mbed_official 573:ad23fe03a082 481
mbed_official 573:ad23fe03a082 482 /* Change ADC state */
mbed_official 573:ad23fe03a082 483 hadc->State = HAL_ADC_STATE_READY;
mbed_official 573:ad23fe03a082 484
mbed_official 573:ad23fe03a082 485 /* Return function status */
mbed_official 573:ad23fe03a082 486 return HAL_OK;
mbed_official 573:ad23fe03a082 487 }
mbed_official 573:ad23fe03a082 488
mbed_official 573:ad23fe03a082 489 /**
mbed_official 573:ad23fe03a082 490 * @brief Poll for regular conversion complete
mbed_official 573:ad23fe03a082 491 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 492 * the configuration information for the specified ADC.
mbed_official 573:ad23fe03a082 493 * @param Timeout: Timeout value in millisecond.
mbed_official 573:ad23fe03a082 494 * @retval HAL status
mbed_official 573:ad23fe03a082 495 */
mbed_official 573:ad23fe03a082 496 HAL_StatusTypeDef HAL_ADC_PollForConversion(ADC_HandleTypeDef* hadc, uint32_t Timeout)
mbed_official 573:ad23fe03a082 497 {
mbed_official 573:ad23fe03a082 498 uint32_t tickstart = 0;
mbed_official 573:ad23fe03a082 499
mbed_official 573:ad23fe03a082 500 /* Verification that ADC configuration is compliant with polling for */
mbed_official 573:ad23fe03a082 501 /* each conversion: */
mbed_official 573:ad23fe03a082 502 /* Particular case is ADC configured in DMA mode and ADC sequencer with */
mbed_official 573:ad23fe03a082 503 /* several ranks and polling for end of each conversion. */
mbed_official 573:ad23fe03a082 504 /* For code simplicity sake, this particular case is generalized to */
mbed_official 573:ad23fe03a082 505 /* ADC configured in DMA mode and polling for end of each conversion. */
mbed_official 573:ad23fe03a082 506 if (HAL_IS_BIT_SET(hadc->Instance->CR2, ADC_CR2_EOCS) &&
mbed_official 573:ad23fe03a082 507 HAL_IS_BIT_SET(hadc->Instance->CR2, ADC_CR2_DMA) )
mbed_official 573:ad23fe03a082 508 {
mbed_official 573:ad23fe03a082 509 /* Update ADC state machine to error */
mbed_official 573:ad23fe03a082 510 hadc->State = HAL_ADC_STATE_ERROR;
mbed_official 573:ad23fe03a082 511
mbed_official 573:ad23fe03a082 512 /* Process unlocked */
mbed_official 573:ad23fe03a082 513 __HAL_UNLOCK(hadc);
mbed_official 573:ad23fe03a082 514
mbed_official 573:ad23fe03a082 515 return HAL_ERROR;
mbed_official 573:ad23fe03a082 516 }
mbed_official 573:ad23fe03a082 517
mbed_official 573:ad23fe03a082 518 /* Get tick */
mbed_official 573:ad23fe03a082 519 tickstart = HAL_GetTick();
mbed_official 573:ad23fe03a082 520
mbed_official 573:ad23fe03a082 521 /* Check End of conversion flag */
mbed_official 573:ad23fe03a082 522 while(!(__HAL_ADC_GET_FLAG(hadc, ADC_FLAG_EOC)))
mbed_official 573:ad23fe03a082 523 {
mbed_official 573:ad23fe03a082 524 /* Check for the Timeout */
mbed_official 573:ad23fe03a082 525 if(Timeout != HAL_MAX_DELAY)
mbed_official 573:ad23fe03a082 526 {
mbed_official 573:ad23fe03a082 527 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 573:ad23fe03a082 528 {
mbed_official 573:ad23fe03a082 529 hadc->State= HAL_ADC_STATE_TIMEOUT;
mbed_official 573:ad23fe03a082 530 /* Process unlocked */
mbed_official 573:ad23fe03a082 531 __HAL_UNLOCK(hadc);
mbed_official 573:ad23fe03a082 532 return HAL_TIMEOUT;
mbed_official 573:ad23fe03a082 533 }
mbed_official 573:ad23fe03a082 534 }
mbed_official 573:ad23fe03a082 535 }
mbed_official 573:ad23fe03a082 536
mbed_official 573:ad23fe03a082 537 /* Check if an injected conversion is ready */
mbed_official 573:ad23fe03a082 538 if(hadc->State == HAL_ADC_STATE_EOC_INJ)
mbed_official 573:ad23fe03a082 539 {
mbed_official 573:ad23fe03a082 540 /* Change ADC state */
mbed_official 573:ad23fe03a082 541 hadc->State = HAL_ADC_STATE_EOC_INJ_REG;
mbed_official 573:ad23fe03a082 542 }
mbed_official 573:ad23fe03a082 543 else
mbed_official 573:ad23fe03a082 544 {
mbed_official 573:ad23fe03a082 545 /* Change ADC state */
mbed_official 573:ad23fe03a082 546 hadc->State = HAL_ADC_STATE_EOC_REG;
mbed_official 573:ad23fe03a082 547 }
mbed_official 573:ad23fe03a082 548
mbed_official 573:ad23fe03a082 549 /* Return ADC state */
mbed_official 573:ad23fe03a082 550 return HAL_OK;
mbed_official 573:ad23fe03a082 551 }
mbed_official 573:ad23fe03a082 552
mbed_official 573:ad23fe03a082 553 /**
mbed_official 573:ad23fe03a082 554 * @brief Poll for conversion event
mbed_official 573:ad23fe03a082 555 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 556 * the configuration information for the specified ADC.
mbed_official 573:ad23fe03a082 557 * @param EventType: the ADC event type.
mbed_official 573:ad23fe03a082 558 * This parameter can be one of the following values:
mbed_official 573:ad23fe03a082 559 * @arg ADC_AWD_EVENT: ADC Analog watch Dog event.
mbed_official 573:ad23fe03a082 560 * @arg ADC_OVR_EVENT: ADC Overrun event.
mbed_official 573:ad23fe03a082 561 * @param Timeout: Timeout value in millisecond.
mbed_official 573:ad23fe03a082 562 * @retval HAL status
mbed_official 573:ad23fe03a082 563 */
mbed_official 573:ad23fe03a082 564 HAL_StatusTypeDef HAL_ADC_PollForEvent(ADC_HandleTypeDef* hadc, uint32_t EventType, uint32_t Timeout)
mbed_official 573:ad23fe03a082 565 {
mbed_official 573:ad23fe03a082 566 uint32_t tickstart = 0;
mbed_official 573:ad23fe03a082 567
mbed_official 573:ad23fe03a082 568 /* Check the parameters */
mbed_official 573:ad23fe03a082 569 assert_param(IS_ADC_EVENT_TYPE(EventType));
mbed_official 573:ad23fe03a082 570
mbed_official 573:ad23fe03a082 571 /* Get tick */
mbed_official 573:ad23fe03a082 572 tickstart = HAL_GetTick();
mbed_official 573:ad23fe03a082 573
mbed_official 573:ad23fe03a082 574 /* Check selected event flag */
mbed_official 573:ad23fe03a082 575 while(!(__HAL_ADC_GET_FLAG(hadc,EventType)))
mbed_official 573:ad23fe03a082 576 {
mbed_official 573:ad23fe03a082 577 /* Check for the Timeout */
mbed_official 573:ad23fe03a082 578 if(Timeout != HAL_MAX_DELAY)
mbed_official 573:ad23fe03a082 579 {
mbed_official 573:ad23fe03a082 580 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 573:ad23fe03a082 581 {
mbed_official 573:ad23fe03a082 582 hadc->State= HAL_ADC_STATE_TIMEOUT;
mbed_official 573:ad23fe03a082 583 /* Process unlocked */
mbed_official 573:ad23fe03a082 584 __HAL_UNLOCK(hadc);
mbed_official 573:ad23fe03a082 585 return HAL_TIMEOUT;
mbed_official 573:ad23fe03a082 586 }
mbed_official 573:ad23fe03a082 587 }
mbed_official 573:ad23fe03a082 588 }
mbed_official 573:ad23fe03a082 589
mbed_official 573:ad23fe03a082 590 /* Check analog watchdog flag */
mbed_official 573:ad23fe03a082 591 if(EventType == ADC_AWD_EVENT)
mbed_official 573:ad23fe03a082 592 {
mbed_official 573:ad23fe03a082 593 /* Change ADC state */
mbed_official 573:ad23fe03a082 594 hadc->State = HAL_ADC_STATE_AWD;
mbed_official 573:ad23fe03a082 595
mbed_official 573:ad23fe03a082 596 /* Clear the ADCx's analog watchdog flag */
mbed_official 573:ad23fe03a082 597 __HAL_ADC_CLEAR_FLAG(hadc, ADC_FLAG_AWD);
mbed_official 573:ad23fe03a082 598 }
mbed_official 573:ad23fe03a082 599 else
mbed_official 573:ad23fe03a082 600 {
mbed_official 573:ad23fe03a082 601 /* Change ADC state */
mbed_official 573:ad23fe03a082 602 hadc->State = HAL_ADC_STATE_ERROR;
mbed_official 573:ad23fe03a082 603
mbed_official 573:ad23fe03a082 604 /* Clear the ADCx's Overrun flag */
mbed_official 573:ad23fe03a082 605 __HAL_ADC_CLEAR_FLAG(hadc, ADC_FLAG_OVR);
mbed_official 573:ad23fe03a082 606 }
mbed_official 573:ad23fe03a082 607
mbed_official 573:ad23fe03a082 608 /* Return ADC state */
mbed_official 573:ad23fe03a082 609 return HAL_OK;
mbed_official 573:ad23fe03a082 610 }
mbed_official 573:ad23fe03a082 611
mbed_official 573:ad23fe03a082 612
mbed_official 573:ad23fe03a082 613 /**
mbed_official 573:ad23fe03a082 614 * @brief Enables the interrupt and starts ADC conversion of regular channels.
mbed_official 573:ad23fe03a082 615 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 616 * the configuration information for the specified ADC.
mbed_official 573:ad23fe03a082 617 * @retval HAL status.
mbed_official 573:ad23fe03a082 618 */
mbed_official 573:ad23fe03a082 619 HAL_StatusTypeDef HAL_ADC_Start_IT(ADC_HandleTypeDef* hadc)
mbed_official 573:ad23fe03a082 620 {
mbed_official 573:ad23fe03a082 621 __IO uint32_t counter = 0;
mbed_official 573:ad23fe03a082 622
mbed_official 573:ad23fe03a082 623 /* Check the parameters */
mbed_official 573:ad23fe03a082 624 assert_param(IS_FUNCTIONAL_STATE(hadc->Init.ContinuousConvMode));
mbed_official 573:ad23fe03a082 625 assert_param(IS_ADC_EXT_TRIG_EDGE(hadc->Init.ExternalTrigConvEdge));
mbed_official 573:ad23fe03a082 626
mbed_official 573:ad23fe03a082 627 /* Process locked */
mbed_official 573:ad23fe03a082 628 __HAL_LOCK(hadc);
mbed_official 573:ad23fe03a082 629
mbed_official 573:ad23fe03a082 630 /* Check if an injected conversion is ongoing */
mbed_official 573:ad23fe03a082 631 if(hadc->State == HAL_ADC_STATE_BUSY_INJ)
mbed_official 573:ad23fe03a082 632 {
mbed_official 573:ad23fe03a082 633 /* Change ADC state */
mbed_official 573:ad23fe03a082 634 hadc->State = HAL_ADC_STATE_BUSY_INJ_REG;
mbed_official 573:ad23fe03a082 635 }
mbed_official 573:ad23fe03a082 636 else
mbed_official 573:ad23fe03a082 637 {
mbed_official 573:ad23fe03a082 638 /* Change ADC state */
mbed_official 573:ad23fe03a082 639 hadc->State = HAL_ADC_STATE_BUSY_REG;
mbed_official 573:ad23fe03a082 640 }
mbed_official 573:ad23fe03a082 641
mbed_official 573:ad23fe03a082 642 /* Set ADC error code to none */
mbed_official 573:ad23fe03a082 643 hadc->ErrorCode = HAL_ADC_ERROR_NONE;
mbed_official 573:ad23fe03a082 644
mbed_official 573:ad23fe03a082 645 /* Check if ADC peripheral is disabled in order to enable it and wait during
mbed_official 573:ad23fe03a082 646 Tstab time the ADC's stabilization */
mbed_official 573:ad23fe03a082 647 if((hadc->Instance->CR2 & ADC_CR2_ADON) != ADC_CR2_ADON)
mbed_official 573:ad23fe03a082 648 {
mbed_official 573:ad23fe03a082 649 /* Enable the Peripheral */
mbed_official 573:ad23fe03a082 650 __HAL_ADC_ENABLE(hadc);
mbed_official 573:ad23fe03a082 651
mbed_official 573:ad23fe03a082 652 /* Delay for ADC stabilization time */
mbed_official 573:ad23fe03a082 653 /* Compute number of CPU cycles to wait for */
mbed_official 573:ad23fe03a082 654 counter = (ADC_STAB_DELAY_US * (SystemCoreClock / 1000000));
mbed_official 573:ad23fe03a082 655 while(counter != 0)
mbed_official 573:ad23fe03a082 656 {
mbed_official 573:ad23fe03a082 657 counter--;
mbed_official 573:ad23fe03a082 658 }
mbed_official 573:ad23fe03a082 659 }
mbed_official 573:ad23fe03a082 660
mbed_official 573:ad23fe03a082 661 /* Enable the ADC overrun interrupt */
mbed_official 573:ad23fe03a082 662 __HAL_ADC_ENABLE_IT(hadc, ADC_IT_OVR);
mbed_official 573:ad23fe03a082 663
mbed_official 573:ad23fe03a082 664 /* Enable the ADC end of conversion interrupt for regular group */
mbed_official 573:ad23fe03a082 665 __HAL_ADC_ENABLE_IT(hadc, ADC_IT_EOC);
mbed_official 573:ad23fe03a082 666
mbed_official 573:ad23fe03a082 667 /* Process unlocked */
mbed_official 573:ad23fe03a082 668 __HAL_UNLOCK(hadc);
mbed_official 573:ad23fe03a082 669
mbed_official 573:ad23fe03a082 670 /* Check if Multimode enabled */
mbed_official 573:ad23fe03a082 671 if(HAL_IS_BIT_CLR(ADC->CCR, ADC_CCR_MULTI))
mbed_official 573:ad23fe03a082 672 {
mbed_official 573:ad23fe03a082 673 /* if no external trigger present enable software conversion of regular channels */
mbed_official 573:ad23fe03a082 674 if((hadc->Instance->CR2 & ADC_CR2_EXTEN) == RESET)
mbed_official 573:ad23fe03a082 675 {
mbed_official 573:ad23fe03a082 676 /* Enable the selected ADC software conversion for regular group */
mbed_official 573:ad23fe03a082 677 hadc->Instance->CR2 |= (uint32_t)ADC_CR2_SWSTART;
mbed_official 573:ad23fe03a082 678 }
mbed_official 573:ad23fe03a082 679 }
mbed_official 573:ad23fe03a082 680 else
mbed_official 573:ad23fe03a082 681 {
mbed_official 573:ad23fe03a082 682 /* if instance of handle correspond to ADC1 and no external trigger present enable software conversion of regular channels */
mbed_official 573:ad23fe03a082 683 if((hadc->Instance == (ADC_TypeDef*)0x40012000) && ((hadc->Instance->CR2 & ADC_CR2_EXTEN) == RESET))
mbed_official 573:ad23fe03a082 684 {
mbed_official 573:ad23fe03a082 685 /* Enable the selected ADC software conversion for regular group */
mbed_official 573:ad23fe03a082 686 hadc->Instance->CR2 |= (uint32_t)ADC_CR2_SWSTART;
mbed_official 573:ad23fe03a082 687 }
mbed_official 573:ad23fe03a082 688 }
mbed_official 573:ad23fe03a082 689
mbed_official 573:ad23fe03a082 690 /* Return function status */
mbed_official 573:ad23fe03a082 691 return HAL_OK;
mbed_official 573:ad23fe03a082 692 }
mbed_official 573:ad23fe03a082 693
mbed_official 573:ad23fe03a082 694 /**
mbed_official 573:ad23fe03a082 695 * @brief Disables the interrupt and stop ADC conversion of regular channels.
mbed_official 573:ad23fe03a082 696 *
mbed_official 573:ad23fe03a082 697 * @note Caution: This function will stop also injected channels.
mbed_official 573:ad23fe03a082 698 *
mbed_official 573:ad23fe03a082 699 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 700 * the configuration information for the specified ADC.
mbed_official 573:ad23fe03a082 701 * @retval HAL status.
mbed_official 573:ad23fe03a082 702 */
mbed_official 573:ad23fe03a082 703 HAL_StatusTypeDef HAL_ADC_Stop_IT(ADC_HandleTypeDef* hadc)
mbed_official 573:ad23fe03a082 704 {
mbed_official 573:ad23fe03a082 705 /* Disable the ADC end of conversion interrupt for regular group */
mbed_official 573:ad23fe03a082 706 __HAL_ADC_DISABLE_IT(hadc, ADC_IT_EOC);
mbed_official 573:ad23fe03a082 707
mbed_official 573:ad23fe03a082 708 /* Disable the ADC end of conversion interrupt for injected group */
mbed_official 573:ad23fe03a082 709 __HAL_ADC_DISABLE_IT(hadc, ADC_CR1_JEOCIE);
mbed_official 573:ad23fe03a082 710
mbed_official 573:ad23fe03a082 711 /* Enable the Peripheral */
mbed_official 573:ad23fe03a082 712 __HAL_ADC_DISABLE(hadc);
mbed_official 573:ad23fe03a082 713
mbed_official 573:ad23fe03a082 714 /* Change ADC state */
mbed_official 573:ad23fe03a082 715 hadc->State = HAL_ADC_STATE_READY;
mbed_official 573:ad23fe03a082 716
mbed_official 573:ad23fe03a082 717 /* Return function status */
mbed_official 573:ad23fe03a082 718 return HAL_OK;
mbed_official 573:ad23fe03a082 719 }
mbed_official 573:ad23fe03a082 720
mbed_official 573:ad23fe03a082 721 /**
mbed_official 573:ad23fe03a082 722 * @brief Handles ADC interrupt request
mbed_official 573:ad23fe03a082 723 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 724 * the configuration information for the specified ADC.
mbed_official 573:ad23fe03a082 725 * @retval None
mbed_official 573:ad23fe03a082 726 */
mbed_official 573:ad23fe03a082 727 void HAL_ADC_IRQHandler(ADC_HandleTypeDef* hadc)
mbed_official 573:ad23fe03a082 728 {
mbed_official 573:ad23fe03a082 729 uint32_t tmp1 = 0, tmp2 = 0;
mbed_official 573:ad23fe03a082 730
mbed_official 573:ad23fe03a082 731 /* Check the parameters */
mbed_official 573:ad23fe03a082 732 assert_param(IS_FUNCTIONAL_STATE(hadc->Init.ContinuousConvMode));
mbed_official 573:ad23fe03a082 733 assert_param(IS_ADC_REGULAR_LENGTH(hadc->Init.NbrOfConversion));
mbed_official 573:ad23fe03a082 734 assert_param(IS_ADC_EOCSelection(hadc->Init.EOCSelection));
mbed_official 573:ad23fe03a082 735
mbed_official 573:ad23fe03a082 736 tmp1 = __HAL_ADC_GET_FLAG(hadc, ADC_FLAG_EOC);
mbed_official 573:ad23fe03a082 737 tmp2 = __HAL_ADC_GET_IT_SOURCE(hadc, ADC_IT_EOC);
mbed_official 573:ad23fe03a082 738 /* Check End of conversion flag for regular channels */
mbed_official 573:ad23fe03a082 739 if(tmp1 && tmp2)
mbed_official 573:ad23fe03a082 740 {
mbed_official 573:ad23fe03a082 741 /* Check if an injected conversion is ready */
mbed_official 573:ad23fe03a082 742 if(hadc->State == HAL_ADC_STATE_EOC_INJ)
mbed_official 573:ad23fe03a082 743 {
mbed_official 573:ad23fe03a082 744 /* Change ADC state */
mbed_official 573:ad23fe03a082 745 hadc->State = HAL_ADC_STATE_EOC_INJ_REG;
mbed_official 573:ad23fe03a082 746 }
mbed_official 573:ad23fe03a082 747 else
mbed_official 573:ad23fe03a082 748 {
mbed_official 573:ad23fe03a082 749 /* Change ADC state */
mbed_official 573:ad23fe03a082 750 hadc->State = HAL_ADC_STATE_EOC_REG;
mbed_official 573:ad23fe03a082 751 }
mbed_official 573:ad23fe03a082 752
mbed_official 573:ad23fe03a082 753 if((hadc->Init.ContinuousConvMode == DISABLE) && ((hadc->Instance->CR2 & ADC_CR2_EXTEN) == RESET))
mbed_official 573:ad23fe03a082 754 {
mbed_official 573:ad23fe03a082 755 if(hadc->Init.EOCSelection == ADC_EOC_SEQ_CONV)
mbed_official 573:ad23fe03a082 756 {
mbed_official 573:ad23fe03a082 757 /* DISABLE the ADC end of conversion interrupt for regular group */
mbed_official 573:ad23fe03a082 758 __HAL_ADC_DISABLE_IT(hadc, ADC_IT_EOC);
mbed_official 573:ad23fe03a082 759
mbed_official 573:ad23fe03a082 760 /* DISABLE the ADC overrun interrupt */
mbed_official 573:ad23fe03a082 761 __HAL_ADC_DISABLE_IT(hadc, ADC_IT_OVR);
mbed_official 573:ad23fe03a082 762 }
mbed_official 573:ad23fe03a082 763 else
mbed_official 573:ad23fe03a082 764 {
mbed_official 573:ad23fe03a082 765 if (hadc->NbrOfCurrentConversionRank == 0)
mbed_official 573:ad23fe03a082 766 {
mbed_official 573:ad23fe03a082 767 hadc->NbrOfCurrentConversionRank = hadc->Init.NbrOfConversion;
mbed_official 573:ad23fe03a082 768 }
mbed_official 573:ad23fe03a082 769
mbed_official 573:ad23fe03a082 770 /* Decrement the number of conversion when an interrupt occurs */
mbed_official 573:ad23fe03a082 771 hadc->NbrOfCurrentConversionRank--;
mbed_official 573:ad23fe03a082 772
mbed_official 573:ad23fe03a082 773 /* Check if all conversions are finished */
mbed_official 573:ad23fe03a082 774 if(hadc->NbrOfCurrentConversionRank == 0)
mbed_official 573:ad23fe03a082 775 {
mbed_official 573:ad23fe03a082 776 /* DISABLE the ADC end of conversion interrupt for regular group */
mbed_official 573:ad23fe03a082 777 __HAL_ADC_DISABLE_IT(hadc, ADC_IT_EOC);
mbed_official 573:ad23fe03a082 778
mbed_official 573:ad23fe03a082 779 /* DISABLE the ADC overrun interrupt */
mbed_official 573:ad23fe03a082 780 __HAL_ADC_DISABLE_IT(hadc, ADC_IT_OVR);
mbed_official 573:ad23fe03a082 781 }
mbed_official 573:ad23fe03a082 782 }
mbed_official 573:ad23fe03a082 783 }
mbed_official 573:ad23fe03a082 784
mbed_official 573:ad23fe03a082 785 /* Conversion complete callback */
mbed_official 573:ad23fe03a082 786 HAL_ADC_ConvCpltCallback(hadc);
mbed_official 573:ad23fe03a082 787
mbed_official 573:ad23fe03a082 788 /* Clear the ADCx flag for regular end of conversion */
mbed_official 573:ad23fe03a082 789 __HAL_ADC_CLEAR_FLAG(hadc,ADC_FLAG_EOC);
mbed_official 573:ad23fe03a082 790 }
mbed_official 573:ad23fe03a082 791
mbed_official 573:ad23fe03a082 792 tmp1 = __HAL_ADC_GET_FLAG(hadc, ADC_FLAG_JEOC);
mbed_official 573:ad23fe03a082 793 tmp2 = __HAL_ADC_GET_IT_SOURCE(hadc, ADC_IT_JEOC);
mbed_official 573:ad23fe03a082 794 /* Check End of conversion flag for injected channels */
mbed_official 573:ad23fe03a082 795 if(tmp1 && tmp2)
mbed_official 573:ad23fe03a082 796 {
mbed_official 573:ad23fe03a082 797 /* Check if a regular conversion is ready */
mbed_official 573:ad23fe03a082 798 if(hadc->State == HAL_ADC_STATE_EOC_REG)
mbed_official 573:ad23fe03a082 799 {
mbed_official 573:ad23fe03a082 800 /* Change ADC state */
mbed_official 573:ad23fe03a082 801 hadc->State = HAL_ADC_STATE_EOC_INJ_REG;
mbed_official 573:ad23fe03a082 802 }
mbed_official 573:ad23fe03a082 803 else
mbed_official 573:ad23fe03a082 804 {
mbed_official 573:ad23fe03a082 805 /* Change ADC state */
mbed_official 573:ad23fe03a082 806 hadc->State = HAL_ADC_STATE_EOC_INJ;
mbed_official 573:ad23fe03a082 807 }
mbed_official 573:ad23fe03a082 808
mbed_official 573:ad23fe03a082 809 tmp1 = HAL_IS_BIT_CLR(hadc->Instance->CR1, ADC_CR1_JAUTO);
mbed_official 573:ad23fe03a082 810 tmp2 = HAL_IS_BIT_CLR(hadc->Instance->CR2, ADC_CR2_JEXTEN);
mbed_official 573:ad23fe03a082 811 if(((hadc->Init.ContinuousConvMode == DISABLE) || tmp1) && tmp2)
mbed_official 573:ad23fe03a082 812 {
mbed_official 573:ad23fe03a082 813 /* DISABLE the ADC end of conversion interrupt for injected group */
mbed_official 573:ad23fe03a082 814 __HAL_ADC_DISABLE_IT(hadc, ADC_IT_JEOC);
mbed_official 573:ad23fe03a082 815 }
mbed_official 573:ad23fe03a082 816
mbed_official 573:ad23fe03a082 817 /* Conversion complete callback */
mbed_official 573:ad23fe03a082 818 HAL_ADCEx_InjectedConvCpltCallback(hadc);
mbed_official 573:ad23fe03a082 819
mbed_official 573:ad23fe03a082 820 /* Clear the ADCx flag for injected end of conversion */
mbed_official 573:ad23fe03a082 821 __HAL_ADC_CLEAR_FLAG(hadc,ADC_FLAG_JEOC);
mbed_official 573:ad23fe03a082 822 }
mbed_official 573:ad23fe03a082 823
mbed_official 573:ad23fe03a082 824 tmp1 = __HAL_ADC_GET_FLAG(hadc, ADC_FLAG_AWD);
mbed_official 573:ad23fe03a082 825 tmp2 = __HAL_ADC_GET_IT_SOURCE(hadc, ADC_IT_AWD);
mbed_official 573:ad23fe03a082 826 /* Check Analog watchdog flag */
mbed_official 573:ad23fe03a082 827 if(tmp1 && tmp2)
mbed_official 573:ad23fe03a082 828 {
mbed_official 573:ad23fe03a082 829 /* Change ADC state */
mbed_official 573:ad23fe03a082 830 hadc->State = HAL_ADC_STATE_AWD;
mbed_official 573:ad23fe03a082 831
mbed_official 573:ad23fe03a082 832 /* Clear the ADCx's Analog watchdog flag */
mbed_official 573:ad23fe03a082 833 __HAL_ADC_CLEAR_FLAG(hadc,ADC_FLAG_AWD);
mbed_official 573:ad23fe03a082 834
mbed_official 573:ad23fe03a082 835 /* Level out of window callback */
mbed_official 573:ad23fe03a082 836 HAL_ADC_LevelOutOfWindowCallback(hadc);
mbed_official 573:ad23fe03a082 837 }
mbed_official 573:ad23fe03a082 838
mbed_official 573:ad23fe03a082 839 tmp1 = __HAL_ADC_GET_FLAG(hadc, ADC_FLAG_OVR);
mbed_official 573:ad23fe03a082 840 tmp2 = __HAL_ADC_GET_IT_SOURCE(hadc, ADC_IT_OVR);
mbed_official 573:ad23fe03a082 841 /* Check Overrun flag */
mbed_official 573:ad23fe03a082 842 if(tmp1 && tmp2)
mbed_official 573:ad23fe03a082 843 {
mbed_official 573:ad23fe03a082 844 /* Change ADC state to overrun state */
mbed_official 573:ad23fe03a082 845 hadc->State = HAL_ADC_STATE_ERROR;
mbed_official 573:ad23fe03a082 846
mbed_official 573:ad23fe03a082 847 /* Set ADC error code to overrun */
mbed_official 573:ad23fe03a082 848 hadc->ErrorCode |= HAL_ADC_ERROR_OVR;
mbed_official 573:ad23fe03a082 849
mbed_official 573:ad23fe03a082 850 /* Clear the Overrun flag */
mbed_official 573:ad23fe03a082 851 __HAL_ADC_CLEAR_FLAG(hadc,ADC_FLAG_OVR);
mbed_official 573:ad23fe03a082 852
mbed_official 573:ad23fe03a082 853 /* Error callback */
mbed_official 573:ad23fe03a082 854 HAL_ADC_ErrorCallback(hadc);
mbed_official 573:ad23fe03a082 855 }
mbed_official 573:ad23fe03a082 856 }
mbed_official 573:ad23fe03a082 857
mbed_official 573:ad23fe03a082 858 /**
mbed_official 573:ad23fe03a082 859 * @brief Enables ADC DMA request after last transfer (Single-ADC mode) and enables ADC peripheral
mbed_official 573:ad23fe03a082 860 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 861 * the configuration information for the specified ADC.
mbed_official 573:ad23fe03a082 862 * @param pData: The destination Buffer address.
mbed_official 573:ad23fe03a082 863 * @param Length: The length of data to be transferred from ADC peripheral to memory.
mbed_official 573:ad23fe03a082 864 * @retval HAL status
mbed_official 573:ad23fe03a082 865 */
mbed_official 573:ad23fe03a082 866 HAL_StatusTypeDef HAL_ADC_Start_DMA(ADC_HandleTypeDef* hadc, uint32_t* pData, uint32_t Length)
mbed_official 573:ad23fe03a082 867 {
mbed_official 573:ad23fe03a082 868 __IO uint32_t counter = 0;
mbed_official 573:ad23fe03a082 869
mbed_official 573:ad23fe03a082 870 /* Check the parameters */
mbed_official 573:ad23fe03a082 871 assert_param(IS_FUNCTIONAL_STATE(hadc->Init.ContinuousConvMode));
mbed_official 573:ad23fe03a082 872 assert_param(IS_ADC_EXT_TRIG_EDGE(hadc->Init.ExternalTrigConvEdge));
mbed_official 573:ad23fe03a082 873
mbed_official 573:ad23fe03a082 874 /* Process locked */
mbed_official 573:ad23fe03a082 875 __HAL_LOCK(hadc);
mbed_official 573:ad23fe03a082 876
mbed_official 573:ad23fe03a082 877 /* Enable ADC overrun interrupt */
mbed_official 573:ad23fe03a082 878 __HAL_ADC_ENABLE_IT(hadc, ADC_IT_OVR);
mbed_official 573:ad23fe03a082 879
mbed_official 573:ad23fe03a082 880 /* Enable ADC DMA mode */
mbed_official 573:ad23fe03a082 881 hadc->Instance->CR2 |= ADC_CR2_DMA;
mbed_official 573:ad23fe03a082 882
mbed_official 573:ad23fe03a082 883 /* Set the DMA transfer complete callback */
mbed_official 573:ad23fe03a082 884 hadc->DMA_Handle->XferCpltCallback = ADC_DMAConvCplt;
mbed_official 573:ad23fe03a082 885
mbed_official 573:ad23fe03a082 886 /* Set the DMA half transfer complete callback */
mbed_official 573:ad23fe03a082 887 hadc->DMA_Handle->XferHalfCpltCallback = ADC_DMAHalfConvCplt;
mbed_official 573:ad23fe03a082 888
mbed_official 573:ad23fe03a082 889 /* Set the DMA error callback */
mbed_official 573:ad23fe03a082 890 hadc->DMA_Handle->XferErrorCallback = ADC_DMAError ;
mbed_official 573:ad23fe03a082 891
mbed_official 573:ad23fe03a082 892 /* Enable the DMA Stream */
mbed_official 573:ad23fe03a082 893 HAL_DMA_Start_IT(hadc->DMA_Handle, (uint32_t)&hadc->Instance->DR, (uint32_t)pData, Length);
mbed_official 573:ad23fe03a082 894
mbed_official 573:ad23fe03a082 895 /* Change ADC state */
mbed_official 573:ad23fe03a082 896 hadc->State = HAL_ADC_STATE_BUSY_REG;
mbed_official 573:ad23fe03a082 897
mbed_official 573:ad23fe03a082 898 /* Process unlocked */
mbed_official 573:ad23fe03a082 899 __HAL_UNLOCK(hadc);
mbed_official 573:ad23fe03a082 900
mbed_official 573:ad23fe03a082 901 /* Check if ADC peripheral is disabled in order to enable it and wait during
mbed_official 573:ad23fe03a082 902 Tstab time the ADC's stabilization */
mbed_official 573:ad23fe03a082 903 if((hadc->Instance->CR2 & ADC_CR2_ADON) != ADC_CR2_ADON)
mbed_official 573:ad23fe03a082 904 {
mbed_official 573:ad23fe03a082 905 /* Enable the Peripheral */
mbed_official 573:ad23fe03a082 906 __HAL_ADC_ENABLE(hadc);
mbed_official 573:ad23fe03a082 907
mbed_official 573:ad23fe03a082 908 /* Delay for ADC stabilization time */
mbed_official 573:ad23fe03a082 909 /* Compute number of CPU cycles to wait for */
mbed_official 573:ad23fe03a082 910 counter = (ADC_STAB_DELAY_US * (SystemCoreClock / 1000000));
mbed_official 573:ad23fe03a082 911 while(counter != 0)
mbed_official 573:ad23fe03a082 912 {
mbed_official 573:ad23fe03a082 913 counter--;
mbed_official 573:ad23fe03a082 914 }
mbed_official 573:ad23fe03a082 915 }
mbed_official 573:ad23fe03a082 916
mbed_official 573:ad23fe03a082 917 /* if no external trigger present enable software conversion of regular channels */
mbed_official 573:ad23fe03a082 918 if((hadc->Instance->CR2 & ADC_CR2_EXTEN) == RESET)
mbed_official 573:ad23fe03a082 919 {
mbed_official 573:ad23fe03a082 920 /* Enable the selected ADC software conversion for regular group */
mbed_official 573:ad23fe03a082 921 hadc->Instance->CR2 |= ADC_CR2_SWSTART;
mbed_official 573:ad23fe03a082 922 }
mbed_official 573:ad23fe03a082 923
mbed_official 573:ad23fe03a082 924 /* Return function status */
mbed_official 573:ad23fe03a082 925 return HAL_OK;
mbed_official 573:ad23fe03a082 926 }
mbed_official 573:ad23fe03a082 927
mbed_official 573:ad23fe03a082 928 /**
mbed_official 573:ad23fe03a082 929 * @brief Disables ADC DMA (Single-ADC mode) and disables ADC peripheral
mbed_official 573:ad23fe03a082 930 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 931 * the configuration information for the specified ADC.
mbed_official 573:ad23fe03a082 932 * @retval HAL status
mbed_official 573:ad23fe03a082 933 */
mbed_official 573:ad23fe03a082 934 HAL_StatusTypeDef HAL_ADC_Stop_DMA(ADC_HandleTypeDef* hadc)
mbed_official 573:ad23fe03a082 935 {
mbed_official 573:ad23fe03a082 936 /* Disable the Peripheral */
mbed_official 573:ad23fe03a082 937 __HAL_ADC_DISABLE(hadc);
mbed_official 573:ad23fe03a082 938
mbed_official 573:ad23fe03a082 939 /* Disable ADC overrun interrupt */
mbed_official 573:ad23fe03a082 940 __HAL_ADC_DISABLE_IT(hadc, ADC_IT_OVR);
mbed_official 573:ad23fe03a082 941
mbed_official 573:ad23fe03a082 942 /* Disable the selected ADC DMA mode */
mbed_official 573:ad23fe03a082 943 hadc->Instance->CR2 &= ~ADC_CR2_DMA;
mbed_official 573:ad23fe03a082 944
mbed_official 573:ad23fe03a082 945 /* Disable the ADC DMA Stream */
mbed_official 573:ad23fe03a082 946 HAL_DMA_Abort(hadc->DMA_Handle);
mbed_official 573:ad23fe03a082 947
mbed_official 573:ad23fe03a082 948 /* Change ADC state */
mbed_official 573:ad23fe03a082 949 hadc->State = HAL_ADC_STATE_READY;
mbed_official 573:ad23fe03a082 950
mbed_official 573:ad23fe03a082 951 /* Return function status */
mbed_official 573:ad23fe03a082 952 return HAL_OK;
mbed_official 573:ad23fe03a082 953 }
mbed_official 573:ad23fe03a082 954
mbed_official 573:ad23fe03a082 955 /**
mbed_official 573:ad23fe03a082 956 * @brief Gets the converted value from data register of regular channel.
mbed_official 573:ad23fe03a082 957 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 958 * the configuration information for the specified ADC.
mbed_official 573:ad23fe03a082 959 * @retval Converted value
mbed_official 573:ad23fe03a082 960 */
mbed_official 573:ad23fe03a082 961 uint32_t HAL_ADC_GetValue(ADC_HandleTypeDef* hadc)
mbed_official 573:ad23fe03a082 962 {
mbed_official 573:ad23fe03a082 963 /* Return the selected ADC converted value */
mbed_official 573:ad23fe03a082 964 return hadc->Instance->DR;
mbed_official 573:ad23fe03a082 965 }
mbed_official 573:ad23fe03a082 966
mbed_official 573:ad23fe03a082 967 /**
mbed_official 573:ad23fe03a082 968 * @brief Regular conversion complete callback in non blocking mode
mbed_official 573:ad23fe03a082 969 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 970 * the configuration information for the specified ADC.
mbed_official 573:ad23fe03a082 971 * @retval None
mbed_official 573:ad23fe03a082 972 */
mbed_official 573:ad23fe03a082 973 __weak void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc)
mbed_official 573:ad23fe03a082 974 {
mbed_official 573:ad23fe03a082 975 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 573:ad23fe03a082 976 the HAL_ADC_ConvCpltCallback could be implemented in the user file
mbed_official 573:ad23fe03a082 977 */
mbed_official 573:ad23fe03a082 978 }
mbed_official 573:ad23fe03a082 979
mbed_official 573:ad23fe03a082 980 /**
mbed_official 573:ad23fe03a082 981 * @brief Regular conversion half DMA transfer callback in non blocking mode
mbed_official 573:ad23fe03a082 982 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 983 * the configuration information for the specified ADC.
mbed_official 573:ad23fe03a082 984 * @retval None
mbed_official 573:ad23fe03a082 985 */
mbed_official 573:ad23fe03a082 986 __weak void HAL_ADC_ConvHalfCpltCallback(ADC_HandleTypeDef* hadc)
mbed_official 573:ad23fe03a082 987 {
mbed_official 573:ad23fe03a082 988 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 573:ad23fe03a082 989 the HAL_ADC_ConvHalfCpltCallback could be implemented in the user file
mbed_official 573:ad23fe03a082 990 */
mbed_official 573:ad23fe03a082 991 }
mbed_official 573:ad23fe03a082 992
mbed_official 573:ad23fe03a082 993 /**
mbed_official 573:ad23fe03a082 994 * @brief Analog watchdog callback in non blocking mode
mbed_official 573:ad23fe03a082 995 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 996 * the configuration information for the specified ADC.
mbed_official 573:ad23fe03a082 997 * @retval None
mbed_official 573:ad23fe03a082 998 */
mbed_official 573:ad23fe03a082 999 __weak void HAL_ADC_LevelOutOfWindowCallback(ADC_HandleTypeDef* hadc)
mbed_official 573:ad23fe03a082 1000 {
mbed_official 573:ad23fe03a082 1001 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 573:ad23fe03a082 1002 the HAL_ADC_LevelOoutOfWindowCallback could be implemented in the user file
mbed_official 573:ad23fe03a082 1003 */
mbed_official 573:ad23fe03a082 1004 }
mbed_official 573:ad23fe03a082 1005
mbed_official 573:ad23fe03a082 1006 /**
mbed_official 573:ad23fe03a082 1007 * @brief Error ADC callback.
mbed_official 573:ad23fe03a082 1008 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 1009 * the configuration information for the specified ADC.
mbed_official 573:ad23fe03a082 1010 * @retval None
mbed_official 573:ad23fe03a082 1011 */
mbed_official 573:ad23fe03a082 1012 __weak void HAL_ADC_ErrorCallback(ADC_HandleTypeDef *hadc)
mbed_official 573:ad23fe03a082 1013 {
mbed_official 573:ad23fe03a082 1014 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 573:ad23fe03a082 1015 the HAL_ADC_ErrorCallback could be implemented in the user file
mbed_official 573:ad23fe03a082 1016 */
mbed_official 573:ad23fe03a082 1017 }
mbed_official 573:ad23fe03a082 1018
mbed_official 573:ad23fe03a082 1019 /**
mbed_official 573:ad23fe03a082 1020 * @}
mbed_official 573:ad23fe03a082 1021 */
mbed_official 573:ad23fe03a082 1022
mbed_official 573:ad23fe03a082 1023 /** @defgroup ADC_Exported_Functions_Group3 Peripheral Control functions
mbed_official 573:ad23fe03a082 1024 * @brief Peripheral Control functions
mbed_official 573:ad23fe03a082 1025 *
mbed_official 573:ad23fe03a082 1026 @verbatim
mbed_official 573:ad23fe03a082 1027 ===============================================================================
mbed_official 573:ad23fe03a082 1028 ##### Peripheral Control functions #####
mbed_official 573:ad23fe03a082 1029 ===============================================================================
mbed_official 573:ad23fe03a082 1030 [..] This section provides functions allowing to:
mbed_official 573:ad23fe03a082 1031 (+) Configure regular channels.
mbed_official 573:ad23fe03a082 1032 (+) Configure injected channels.
mbed_official 573:ad23fe03a082 1033 (+) Configure multimode.
mbed_official 573:ad23fe03a082 1034 (+) Configure the analog watch dog.
mbed_official 573:ad23fe03a082 1035
mbed_official 573:ad23fe03a082 1036 @endverbatim
mbed_official 573:ad23fe03a082 1037 * @{
mbed_official 573:ad23fe03a082 1038 */
mbed_official 573:ad23fe03a082 1039
mbed_official 573:ad23fe03a082 1040 /**
mbed_official 573:ad23fe03a082 1041 * @brief Configures for the selected ADC regular channel its corresponding
mbed_official 573:ad23fe03a082 1042 * rank in the sequencer and its sample time.
mbed_official 573:ad23fe03a082 1043 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 1044 * the configuration information for the specified ADC.
mbed_official 573:ad23fe03a082 1045 * @param sConfig: ADC configuration structure.
mbed_official 573:ad23fe03a082 1046 * @retval HAL status
mbed_official 573:ad23fe03a082 1047 */
mbed_official 573:ad23fe03a082 1048 HAL_StatusTypeDef HAL_ADC_ConfigChannel(ADC_HandleTypeDef* hadc, ADC_ChannelConfTypeDef* sConfig)
mbed_official 573:ad23fe03a082 1049 {
mbed_official 573:ad23fe03a082 1050 __IO uint32_t counter = 0;
mbed_official 573:ad23fe03a082 1051
mbed_official 573:ad23fe03a082 1052 /* Check the parameters */
mbed_official 573:ad23fe03a082 1053 assert_param(IS_ADC_CHANNEL(sConfig->Channel));
mbed_official 573:ad23fe03a082 1054 assert_param(IS_ADC_REGULAR_RANK(sConfig->Rank));
mbed_official 573:ad23fe03a082 1055 assert_param(IS_ADC_SAMPLE_TIME(sConfig->SamplingTime));
mbed_official 573:ad23fe03a082 1056
mbed_official 573:ad23fe03a082 1057 /* Process locked */
mbed_official 573:ad23fe03a082 1058 __HAL_LOCK(hadc);
mbed_official 573:ad23fe03a082 1059
mbed_official 573:ad23fe03a082 1060 /* if ADC_Channel_10 ... ADC_Channel_18 is selected */
mbed_official 573:ad23fe03a082 1061 if (sConfig->Channel > ADC_CHANNEL_9)
mbed_official 573:ad23fe03a082 1062 {
mbed_official 573:ad23fe03a082 1063 /* Clear the old sample time */
mbed_official 573:ad23fe03a082 1064 hadc->Instance->SMPR1 &= ~ADC_SMPR1(ADC_SMPR1_SMP10, sConfig->Channel);
mbed_official 573:ad23fe03a082 1065
mbed_official 573:ad23fe03a082 1066 /* Set the new sample time */
mbed_official 573:ad23fe03a082 1067 hadc->Instance->SMPR1 |= ADC_SMPR1(sConfig->SamplingTime, sConfig->Channel);
mbed_official 573:ad23fe03a082 1068 }
mbed_official 573:ad23fe03a082 1069 else /* ADC_Channel include in ADC_Channel_[0..9] */
mbed_official 573:ad23fe03a082 1070 {
mbed_official 573:ad23fe03a082 1071 /* Clear the old sample time */
mbed_official 573:ad23fe03a082 1072 hadc->Instance->SMPR2 &= ~ADC_SMPR2(ADC_SMPR2_SMP0, sConfig->Channel);
mbed_official 573:ad23fe03a082 1073
mbed_official 573:ad23fe03a082 1074 /* Set the new sample time */
mbed_official 573:ad23fe03a082 1075 hadc->Instance->SMPR2 |= ADC_SMPR2(sConfig->SamplingTime, sConfig->Channel);
mbed_official 573:ad23fe03a082 1076 }
mbed_official 573:ad23fe03a082 1077
mbed_official 573:ad23fe03a082 1078 /* For Rank 1 to 6 */
mbed_official 573:ad23fe03a082 1079 if (sConfig->Rank < 7)
mbed_official 573:ad23fe03a082 1080 {
mbed_official 573:ad23fe03a082 1081 /* Clear the old SQx bits for the selected rank */
mbed_official 573:ad23fe03a082 1082 hadc->Instance->SQR3 &= ~ADC_SQR3_RK(ADC_SQR3_SQ1, sConfig->Rank);
mbed_official 573:ad23fe03a082 1083
mbed_official 573:ad23fe03a082 1084 /* Set the SQx bits for the selected rank */
mbed_official 573:ad23fe03a082 1085 hadc->Instance->SQR3 |= ADC_SQR3_RK(sConfig->Channel, sConfig->Rank);
mbed_official 573:ad23fe03a082 1086 }
mbed_official 573:ad23fe03a082 1087 /* For Rank 7 to 12 */
mbed_official 573:ad23fe03a082 1088 else if (sConfig->Rank < 13)
mbed_official 573:ad23fe03a082 1089 {
mbed_official 573:ad23fe03a082 1090 /* Clear the old SQx bits for the selected rank */
mbed_official 573:ad23fe03a082 1091 hadc->Instance->SQR2 &= ~ADC_SQR2_RK(ADC_SQR2_SQ7, sConfig->Rank);
mbed_official 573:ad23fe03a082 1092
mbed_official 573:ad23fe03a082 1093 /* Set the SQx bits for the selected rank */
mbed_official 573:ad23fe03a082 1094 hadc->Instance->SQR2 |= ADC_SQR2_RK(sConfig->Channel, sConfig->Rank);
mbed_official 573:ad23fe03a082 1095 }
mbed_official 573:ad23fe03a082 1096 /* For Rank 13 to 16 */
mbed_official 573:ad23fe03a082 1097 else
mbed_official 573:ad23fe03a082 1098 {
mbed_official 573:ad23fe03a082 1099 /* Clear the old SQx bits for the selected rank */
mbed_official 573:ad23fe03a082 1100 hadc->Instance->SQR1 &= ~ADC_SQR1_RK(ADC_SQR1_SQ13, sConfig->Rank);
mbed_official 573:ad23fe03a082 1101
mbed_official 573:ad23fe03a082 1102 /* Set the SQx bits for the selected rank */
mbed_official 573:ad23fe03a082 1103 hadc->Instance->SQR1 |= ADC_SQR1_RK(sConfig->Channel, sConfig->Rank);
mbed_official 573:ad23fe03a082 1104 }
mbed_official 573:ad23fe03a082 1105
mbed_official 573:ad23fe03a082 1106 /* if ADC1 Channel_18 is selected enable VBAT Channel */
mbed_official 573:ad23fe03a082 1107 if ((hadc->Instance == ADC1) && (sConfig->Channel == ADC_CHANNEL_VBAT))
mbed_official 573:ad23fe03a082 1108 {
mbed_official 573:ad23fe03a082 1109 /* Enable the VBAT channel*/
mbed_official 573:ad23fe03a082 1110 ADC->CCR |= ADC_CCR_VBATE;
mbed_official 573:ad23fe03a082 1111 }
mbed_official 573:ad23fe03a082 1112
mbed_official 573:ad23fe03a082 1113 /* if ADC1 Channel_16 or Channel_17 is selected enable TSVREFE Channel(Temperature sensor and VREFINT) */
mbed_official 573:ad23fe03a082 1114 if ((hadc->Instance == ADC1) && ((sConfig->Channel == ADC_CHANNEL_TEMPSENSOR) || (sConfig->Channel == ADC_CHANNEL_VREFINT)))
mbed_official 573:ad23fe03a082 1115 {
mbed_official 573:ad23fe03a082 1116 /* Enable the TSVREFE channel*/
mbed_official 573:ad23fe03a082 1117 ADC->CCR |= ADC_CCR_TSVREFE;
mbed_official 573:ad23fe03a082 1118
mbed_official 573:ad23fe03a082 1119 if((sConfig->Channel == ADC_CHANNEL_TEMPSENSOR))
mbed_official 573:ad23fe03a082 1120 {
mbed_official 573:ad23fe03a082 1121 /* Delay for temperature sensor stabilization time */
mbed_official 573:ad23fe03a082 1122 /* Compute number of CPU cycles to wait for */
mbed_official 573:ad23fe03a082 1123 counter = (ADC_TEMPSENSOR_DELAY_US * (SystemCoreClock / 1000000));
mbed_official 573:ad23fe03a082 1124 while(counter != 0)
mbed_official 573:ad23fe03a082 1125 {
mbed_official 573:ad23fe03a082 1126 counter--;
mbed_official 573:ad23fe03a082 1127 }
mbed_official 573:ad23fe03a082 1128 }
mbed_official 573:ad23fe03a082 1129 }
mbed_official 573:ad23fe03a082 1130
mbed_official 573:ad23fe03a082 1131 /* Process unlocked */
mbed_official 573:ad23fe03a082 1132 __HAL_UNLOCK(hadc);
mbed_official 573:ad23fe03a082 1133
mbed_official 573:ad23fe03a082 1134 /* Return function status */
mbed_official 573:ad23fe03a082 1135 return HAL_OK;
mbed_official 573:ad23fe03a082 1136 }
mbed_official 573:ad23fe03a082 1137
mbed_official 573:ad23fe03a082 1138 /**
mbed_official 573:ad23fe03a082 1139 * @brief Configures the analog watchdog.
mbed_official 573:ad23fe03a082 1140 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 1141 * the configuration information for the specified ADC.
mbed_official 573:ad23fe03a082 1142 * @param AnalogWDGConfig : pointer to an ADC_AnalogWDGConfTypeDef structure
mbed_official 573:ad23fe03a082 1143 * that contains the configuration information of ADC analog watchdog.
mbed_official 573:ad23fe03a082 1144 * @retval HAL status
mbed_official 573:ad23fe03a082 1145 */
mbed_official 573:ad23fe03a082 1146 HAL_StatusTypeDef HAL_ADC_AnalogWDGConfig(ADC_HandleTypeDef* hadc, ADC_AnalogWDGConfTypeDef* AnalogWDGConfig)
mbed_official 573:ad23fe03a082 1147 {
mbed_official 573:ad23fe03a082 1148 #ifdef USE_FULL_ASSERT
mbed_official 573:ad23fe03a082 1149 uint32_t tmp = 0;
mbed_official 573:ad23fe03a082 1150 #endif /* USE_FULL_ASSERT */
mbed_official 573:ad23fe03a082 1151
mbed_official 573:ad23fe03a082 1152 /* Check the parameters */
mbed_official 573:ad23fe03a082 1153 assert_param(IS_ADC_ANALOG_WATCHDOG(AnalogWDGConfig->WatchdogMode));
mbed_official 573:ad23fe03a082 1154 assert_param(IS_ADC_CHANNEL(AnalogWDGConfig->Channel));
mbed_official 573:ad23fe03a082 1155 assert_param(IS_FUNCTIONAL_STATE(AnalogWDGConfig->ITMode));
mbed_official 573:ad23fe03a082 1156
mbed_official 573:ad23fe03a082 1157 #ifdef USE_FULL_ASSERT
mbed_official 573:ad23fe03a082 1158 tmp = ADC_GET_RESOLUTION(hadc);
mbed_official 573:ad23fe03a082 1159 assert_param(IS_ADC_RANGE(tmp, AnalogWDGConfig->HighThreshold));
mbed_official 573:ad23fe03a082 1160 assert_param(IS_ADC_RANGE(tmp, AnalogWDGConfig->LowThreshold));
mbed_official 573:ad23fe03a082 1161 #endif /* USE_FULL_ASSERT */
mbed_official 573:ad23fe03a082 1162
mbed_official 573:ad23fe03a082 1163 /* Process locked */
mbed_official 573:ad23fe03a082 1164 __HAL_LOCK(hadc);
mbed_official 573:ad23fe03a082 1165
mbed_official 573:ad23fe03a082 1166 if(AnalogWDGConfig->ITMode == ENABLE)
mbed_official 573:ad23fe03a082 1167 {
mbed_official 573:ad23fe03a082 1168 /* Enable the ADC Analog watchdog interrupt */
mbed_official 573:ad23fe03a082 1169 __HAL_ADC_ENABLE_IT(hadc, ADC_IT_AWD);
mbed_official 573:ad23fe03a082 1170 }
mbed_official 573:ad23fe03a082 1171 else
mbed_official 573:ad23fe03a082 1172 {
mbed_official 573:ad23fe03a082 1173 /* Disable the ADC Analog watchdog interrupt */
mbed_official 573:ad23fe03a082 1174 __HAL_ADC_DISABLE_IT(hadc, ADC_IT_AWD);
mbed_official 573:ad23fe03a082 1175 }
mbed_official 573:ad23fe03a082 1176
mbed_official 573:ad23fe03a082 1177 /* Clear AWDEN, JAWDEN and AWDSGL bits */
mbed_official 573:ad23fe03a082 1178 hadc->Instance->CR1 &= ~(ADC_CR1_AWDSGL | ADC_CR1_JAWDEN | ADC_CR1_AWDEN);
mbed_official 573:ad23fe03a082 1179
mbed_official 573:ad23fe03a082 1180 /* Set the analog watchdog enable mode */
mbed_official 573:ad23fe03a082 1181 hadc->Instance->CR1 |= AnalogWDGConfig->WatchdogMode;
mbed_official 573:ad23fe03a082 1182
mbed_official 573:ad23fe03a082 1183 /* Set the high threshold */
mbed_official 573:ad23fe03a082 1184 hadc->Instance->HTR = AnalogWDGConfig->HighThreshold;
mbed_official 573:ad23fe03a082 1185
mbed_official 573:ad23fe03a082 1186 /* Set the low threshold */
mbed_official 573:ad23fe03a082 1187 hadc->Instance->LTR = AnalogWDGConfig->LowThreshold;
mbed_official 573:ad23fe03a082 1188
mbed_official 573:ad23fe03a082 1189 /* Clear the Analog watchdog channel select bits */
mbed_official 573:ad23fe03a082 1190 hadc->Instance->CR1 &= ~ADC_CR1_AWDCH;
mbed_official 573:ad23fe03a082 1191
mbed_official 573:ad23fe03a082 1192 /* Set the Analog watchdog channel */
mbed_official 573:ad23fe03a082 1193 hadc->Instance->CR1 |= (uint32_t)((uint16_t)(AnalogWDGConfig->Channel));
mbed_official 573:ad23fe03a082 1194
mbed_official 573:ad23fe03a082 1195 /* Process unlocked */
mbed_official 573:ad23fe03a082 1196 __HAL_UNLOCK(hadc);
mbed_official 573:ad23fe03a082 1197
mbed_official 573:ad23fe03a082 1198 /* Return function status */
mbed_official 573:ad23fe03a082 1199 return HAL_OK;
mbed_official 573:ad23fe03a082 1200 }
mbed_official 573:ad23fe03a082 1201
mbed_official 573:ad23fe03a082 1202 /**
mbed_official 573:ad23fe03a082 1203 * @}
mbed_official 573:ad23fe03a082 1204 */
mbed_official 573:ad23fe03a082 1205
mbed_official 573:ad23fe03a082 1206 /** @defgroup ADC_Exported_Functions_Group4 ADC Peripheral State functions
mbed_official 573:ad23fe03a082 1207 * @brief ADC Peripheral State functions
mbed_official 573:ad23fe03a082 1208 *
mbed_official 573:ad23fe03a082 1209 @verbatim
mbed_official 573:ad23fe03a082 1210 ===============================================================================
mbed_official 573:ad23fe03a082 1211 ##### Peripheral State and errors functions #####
mbed_official 573:ad23fe03a082 1212 ===============================================================================
mbed_official 573:ad23fe03a082 1213 [..]
mbed_official 573:ad23fe03a082 1214 This subsection provides functions allowing to
mbed_official 573:ad23fe03a082 1215 (+) Check the ADC state
mbed_official 573:ad23fe03a082 1216 (+) Check the ADC Error
mbed_official 573:ad23fe03a082 1217
mbed_official 573:ad23fe03a082 1218 @endverbatim
mbed_official 573:ad23fe03a082 1219 * @{
mbed_official 573:ad23fe03a082 1220 */
mbed_official 573:ad23fe03a082 1221
mbed_official 573:ad23fe03a082 1222 /**
mbed_official 573:ad23fe03a082 1223 * @brief return the ADC state
mbed_official 573:ad23fe03a082 1224 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 1225 * the configuration information for the specified ADC.
mbed_official 573:ad23fe03a082 1226 * @retval HAL state
mbed_official 573:ad23fe03a082 1227 */
mbed_official 573:ad23fe03a082 1228 HAL_ADC_StateTypeDef HAL_ADC_GetState(ADC_HandleTypeDef* hadc)
mbed_official 573:ad23fe03a082 1229 {
mbed_official 573:ad23fe03a082 1230 /* Return ADC state */
mbed_official 573:ad23fe03a082 1231 return hadc->State;
mbed_official 573:ad23fe03a082 1232 }
mbed_official 573:ad23fe03a082 1233
mbed_official 573:ad23fe03a082 1234 /**
mbed_official 573:ad23fe03a082 1235 * @brief Return the ADC error code
mbed_official 573:ad23fe03a082 1236 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 1237 * the configuration information for the specified ADC.
mbed_official 573:ad23fe03a082 1238 * @retval ADC Error Code
mbed_official 573:ad23fe03a082 1239 */
mbed_official 573:ad23fe03a082 1240 uint32_t HAL_ADC_GetError(ADC_HandleTypeDef *hadc)
mbed_official 573:ad23fe03a082 1241 {
mbed_official 573:ad23fe03a082 1242 return hadc->ErrorCode;
mbed_official 573:ad23fe03a082 1243 }
mbed_official 573:ad23fe03a082 1244
mbed_official 573:ad23fe03a082 1245 /**
mbed_official 573:ad23fe03a082 1246 * @}
mbed_official 573:ad23fe03a082 1247 */
mbed_official 573:ad23fe03a082 1248
mbed_official 573:ad23fe03a082 1249 /**
mbed_official 573:ad23fe03a082 1250 * @}
mbed_official 573:ad23fe03a082 1251 */
mbed_official 573:ad23fe03a082 1252
mbed_official 573:ad23fe03a082 1253 /* Private functions ---------------------------------------------------------*/
mbed_official 573:ad23fe03a082 1254
mbed_official 573:ad23fe03a082 1255 /** @defgroup ADC_Private_Functions ADC Private Functions
mbed_official 573:ad23fe03a082 1256 * @{
mbed_official 573:ad23fe03a082 1257 */
mbed_official 573:ad23fe03a082 1258
mbed_official 573:ad23fe03a082 1259 /**
mbed_official 573:ad23fe03a082 1260 * @brief Initializes the ADCx peripheral according to the specified parameters
mbed_official 573:ad23fe03a082 1261 * in the ADC_InitStruct without initializing the ADC MSP.
mbed_official 573:ad23fe03a082 1262 * @param hadc: pointer to a ADC_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 1263 * the configuration information for the specified ADC.
mbed_official 573:ad23fe03a082 1264 * @retval None
mbed_official 573:ad23fe03a082 1265 */
mbed_official 573:ad23fe03a082 1266 static void ADC_Init(ADC_HandleTypeDef* hadc)
mbed_official 573:ad23fe03a082 1267 {
mbed_official 573:ad23fe03a082 1268 /* Set ADC parameters */
mbed_official 573:ad23fe03a082 1269 /* Set the ADC clock prescaler */
mbed_official 573:ad23fe03a082 1270 ADC->CCR &= ~(ADC_CCR_ADCPRE);
mbed_official 573:ad23fe03a082 1271 ADC->CCR |= hadc->Init.ClockPrescaler;
mbed_official 573:ad23fe03a082 1272
mbed_official 573:ad23fe03a082 1273 /* Set ADC scan mode */
mbed_official 573:ad23fe03a082 1274 hadc->Instance->CR1 &= ~(ADC_CR1_SCAN);
mbed_official 573:ad23fe03a082 1275 hadc->Instance->CR1 |= ADC_CR1_SCANCONV(hadc->Init.ScanConvMode);
mbed_official 573:ad23fe03a082 1276
mbed_official 573:ad23fe03a082 1277 /* Set ADC resolution */
mbed_official 573:ad23fe03a082 1278 hadc->Instance->CR1 &= ~(ADC_CR1_RES);
mbed_official 573:ad23fe03a082 1279 hadc->Instance->CR1 |= hadc->Init.Resolution;
mbed_official 573:ad23fe03a082 1280
mbed_official 573:ad23fe03a082 1281 /* Set ADC data alignment */
mbed_official 573:ad23fe03a082 1282 hadc->Instance->CR2 &= ~(ADC_CR2_ALIGN);
mbed_official 573:ad23fe03a082 1283 hadc->Instance->CR2 |= hadc->Init.DataAlign;
mbed_official 573:ad23fe03a082 1284
mbed_official 573:ad23fe03a082 1285 /* Enable external trigger if trigger selection is different of software */
mbed_official 573:ad23fe03a082 1286 /* start. */
mbed_official 573:ad23fe03a082 1287 /* Note: This configuration keeps the hardware feature of parameter */
mbed_official 573:ad23fe03a082 1288 /* ExternalTrigConvEdge "trigger edge none" equivalent to */
mbed_official 573:ad23fe03a082 1289 /* software start. */
mbed_official 573:ad23fe03a082 1290 if(hadc->Init.ExternalTrigConv != ADC_SOFTWARE_START)
mbed_official 573:ad23fe03a082 1291 {
mbed_official 573:ad23fe03a082 1292 /* Select external trigger to start conversion */
mbed_official 573:ad23fe03a082 1293 hadc->Instance->CR2 &= ~(ADC_CR2_EXTSEL);
mbed_official 573:ad23fe03a082 1294 hadc->Instance->CR2 |= hadc->Init.ExternalTrigConv;
mbed_official 573:ad23fe03a082 1295
mbed_official 573:ad23fe03a082 1296 /* Select external trigger polarity */
mbed_official 573:ad23fe03a082 1297 hadc->Instance->CR2 &= ~(ADC_CR2_EXTEN);
mbed_official 573:ad23fe03a082 1298 hadc->Instance->CR2 |= hadc->Init.ExternalTrigConvEdge;
mbed_official 573:ad23fe03a082 1299 }
mbed_official 573:ad23fe03a082 1300 else
mbed_official 573:ad23fe03a082 1301 {
mbed_official 573:ad23fe03a082 1302 /* Reset the external trigger */
mbed_official 573:ad23fe03a082 1303 hadc->Instance->CR2 &= ~(ADC_CR2_EXTSEL);
mbed_official 573:ad23fe03a082 1304 hadc->Instance->CR2 &= ~(ADC_CR2_EXTEN);
mbed_official 573:ad23fe03a082 1305 }
mbed_official 573:ad23fe03a082 1306
mbed_official 573:ad23fe03a082 1307 /* Enable or disable ADC continuous conversion mode */
mbed_official 573:ad23fe03a082 1308 hadc->Instance->CR2 &= ~(ADC_CR2_CONT);
mbed_official 573:ad23fe03a082 1309 hadc->Instance->CR2 |= ADC_CR2_CONTINUOUS(hadc->Init.ContinuousConvMode);
mbed_official 573:ad23fe03a082 1310
mbed_official 573:ad23fe03a082 1311 if(hadc->Init.DiscontinuousConvMode != DISABLE)
mbed_official 573:ad23fe03a082 1312 {
mbed_official 573:ad23fe03a082 1313 assert_param(IS_ADC_REGULAR_DISC_NUMBER(hadc->Init.NbrOfDiscConversion));
mbed_official 573:ad23fe03a082 1314
mbed_official 573:ad23fe03a082 1315 /* Enable the selected ADC regular discontinuous mode */
mbed_official 573:ad23fe03a082 1316 hadc->Instance->CR1 |= (uint32_t)ADC_CR1_DISCEN;
mbed_official 573:ad23fe03a082 1317
mbed_official 573:ad23fe03a082 1318 /* Set the number of channels to be converted in discontinuous mode */
mbed_official 573:ad23fe03a082 1319 hadc->Instance->CR1 &= ~(ADC_CR1_DISCNUM);
mbed_official 573:ad23fe03a082 1320 hadc->Instance->CR1 |= ADC_CR1_DISCONTINUOUS(hadc->Init.NbrOfDiscConversion);
mbed_official 573:ad23fe03a082 1321 }
mbed_official 573:ad23fe03a082 1322 else
mbed_official 573:ad23fe03a082 1323 {
mbed_official 573:ad23fe03a082 1324 /* Disable the selected ADC regular discontinuous mode */
mbed_official 573:ad23fe03a082 1325 hadc->Instance->CR1 &= ~(ADC_CR1_DISCEN);
mbed_official 573:ad23fe03a082 1326 }
mbed_official 573:ad23fe03a082 1327
mbed_official 573:ad23fe03a082 1328 /* Set ADC number of conversion */
mbed_official 573:ad23fe03a082 1329 hadc->Instance->SQR1 &= ~(ADC_SQR1_L);
mbed_official 573:ad23fe03a082 1330 hadc->Instance->SQR1 |= ADC_SQR1(hadc->Init.NbrOfConversion);
mbed_official 573:ad23fe03a082 1331
mbed_official 573:ad23fe03a082 1332 /* Enable or disable ADC DMA continuous request */
mbed_official 573:ad23fe03a082 1333 hadc->Instance->CR2 &= ~(ADC_CR2_DDS);
mbed_official 573:ad23fe03a082 1334 hadc->Instance->CR2 |= ADC_CR2_DMAContReq(hadc->Init.DMAContinuousRequests);
mbed_official 573:ad23fe03a082 1335
mbed_official 573:ad23fe03a082 1336 /* Enable or disable ADC end of conversion selection */
mbed_official 573:ad23fe03a082 1337 hadc->Instance->CR2 &= ~(ADC_CR2_EOCS);
mbed_official 573:ad23fe03a082 1338 hadc->Instance->CR2 |= ADC_CR2_EOCSelection(hadc->Init.EOCSelection);
mbed_official 573:ad23fe03a082 1339 }
mbed_official 573:ad23fe03a082 1340
mbed_official 573:ad23fe03a082 1341 /**
mbed_official 573:ad23fe03a082 1342 * @brief DMA transfer complete callback.
mbed_official 573:ad23fe03a082 1343 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 1344 * the configuration information for the specified DMA module.
mbed_official 573:ad23fe03a082 1345 * @retval None
mbed_official 573:ad23fe03a082 1346 */
mbed_official 573:ad23fe03a082 1347 static void ADC_DMAConvCplt(DMA_HandleTypeDef *hdma)
mbed_official 573:ad23fe03a082 1348 {
mbed_official 573:ad23fe03a082 1349 ADC_HandleTypeDef* hadc = ( ADC_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official 573:ad23fe03a082 1350
mbed_official 573:ad23fe03a082 1351 /* Check if an injected conversion is ready */
mbed_official 573:ad23fe03a082 1352 if(hadc->State == HAL_ADC_STATE_EOC_INJ)
mbed_official 573:ad23fe03a082 1353 {
mbed_official 573:ad23fe03a082 1354 /* Change ADC state */
mbed_official 573:ad23fe03a082 1355 hadc->State = HAL_ADC_STATE_EOC_INJ_REG;
mbed_official 573:ad23fe03a082 1356 }
mbed_official 573:ad23fe03a082 1357 else
mbed_official 573:ad23fe03a082 1358 {
mbed_official 573:ad23fe03a082 1359 /* Change ADC state */
mbed_official 573:ad23fe03a082 1360 hadc->State = HAL_ADC_STATE_EOC_REG;
mbed_official 573:ad23fe03a082 1361 }
mbed_official 573:ad23fe03a082 1362
mbed_official 573:ad23fe03a082 1363 HAL_ADC_ConvCpltCallback(hadc);
mbed_official 573:ad23fe03a082 1364 }
mbed_official 573:ad23fe03a082 1365
mbed_official 573:ad23fe03a082 1366 /**
mbed_official 573:ad23fe03a082 1367 * @brief DMA half transfer complete callback.
mbed_official 573:ad23fe03a082 1368 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 1369 * the configuration information for the specified DMA module.
mbed_official 573:ad23fe03a082 1370 * @retval None
mbed_official 573:ad23fe03a082 1371 */
mbed_official 573:ad23fe03a082 1372 static void ADC_DMAHalfConvCplt(DMA_HandleTypeDef *hdma)
mbed_official 573:ad23fe03a082 1373 {
mbed_official 573:ad23fe03a082 1374 ADC_HandleTypeDef* hadc = ( ADC_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official 573:ad23fe03a082 1375 /* Conversion complete callback */
mbed_official 573:ad23fe03a082 1376 HAL_ADC_ConvHalfCpltCallback(hadc);
mbed_official 573:ad23fe03a082 1377 }
mbed_official 573:ad23fe03a082 1378
mbed_official 573:ad23fe03a082 1379 /**
mbed_official 573:ad23fe03a082 1380 * @brief DMA error callback
mbed_official 573:ad23fe03a082 1381 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 1382 * the configuration information for the specified DMA module.
mbed_official 573:ad23fe03a082 1383 * @retval None
mbed_official 573:ad23fe03a082 1384 */
mbed_official 573:ad23fe03a082 1385 static void ADC_DMAError(DMA_HandleTypeDef *hdma)
mbed_official 573:ad23fe03a082 1386 {
mbed_official 573:ad23fe03a082 1387 ADC_HandleTypeDef* hadc = ( ADC_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official 573:ad23fe03a082 1388 hadc->State= HAL_ADC_STATE_ERROR;
mbed_official 573:ad23fe03a082 1389 /* Set ADC error code to DMA error */
mbed_official 573:ad23fe03a082 1390 hadc->ErrorCode |= HAL_ADC_ERROR_DMA;
mbed_official 573:ad23fe03a082 1391 HAL_ADC_ErrorCallback(hadc);
mbed_official 573:ad23fe03a082 1392 }
mbed_official 573:ad23fe03a082 1393
mbed_official 573:ad23fe03a082 1394
mbed_official 573:ad23fe03a082 1395 /**
mbed_official 573:ad23fe03a082 1396 * @}
mbed_official 573:ad23fe03a082 1397 */
mbed_official 573:ad23fe03a082 1398
mbed_official 573:ad23fe03a082 1399 #endif /* HAL_ADC_MODULE_ENABLED */
mbed_official 573:ad23fe03a082 1400 /**
mbed_official 573:ad23fe03a082 1401 * @}
mbed_official 573:ad23fe03a082 1402 */
mbed_official 573:ad23fe03a082 1403
mbed_official 573:ad23fe03a082 1404 /**
mbed_official 573:ad23fe03a082 1405 * @}
mbed_official 573:ad23fe03a082 1406 */
mbed_official 573:ad23fe03a082 1407
mbed_official 573:ad23fe03a082 1408 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/