Paul Paterson / mbed-src-CanNucleoF0

mbed library sources, include can_api for nucleo-f091rc

Dependents:   CanNucleoF0_example

Fork of mbed-src by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32F7/stm32f7xx_hal_adc.c@645:13c87cbecd54, 2016-01-07 (annotated)

Committer:
ptpaterson
Date:
Thu Jan 07 05:49:05 2016 +0000
Revision:
645:13c87cbecd54
Parent:
610:813dcc80987e 
corrected freeze on CAN_RECEIVE_IT

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****/