Joris Aerts / mbed-src

mbed library sources

Dependents:   Marvino mbot

Fork of mbed-src by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32L4/stm32l4xx_hal_adc_ex.c@637:ed69428d4850, 2015-12-22 (annotated)

Committer:
jaerts
Date:
Tue Dec 22 13:22:16 2015 +0000
Revision:
637:ed69428d4850
Parent:
610:813dcc80987e 
Add very shady LPC1768 CAN Filter implementation

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mbed_official 610:813dcc80987e 1 /**
mbed_official 610:813dcc80987e 2 ******************************************************************************
mbed_official 610:813dcc80987e 3 * @file stm32l4xx_hal_adc_ex.c
mbed_official 610:813dcc80987e 4 * @author MCD Application Team
mbed_official 610:813dcc80987e 5 * @version V1.0.0
mbed_official 610:813dcc80987e 6 * @date 26-June-2015
mbed_official 610:813dcc80987e 7 * @brief This file provides firmware functions to manage the following
mbed_official 610:813dcc80987e 8 * functionalities of the Analog to Digital Convertor (ADC)
mbed_official 610:813dcc80987e 9 * peripheral:
mbed_official 610:813dcc80987e 10 * + Calibration functions
mbed_official 610:813dcc80987e 11 * ++ Calibration start-up
mbed_official 610:813dcc80987e 12 * ++ Calibration value reading or setting
mbed_official 610:813dcc80987e 13 * + Operation functions
mbed_official 610:813dcc80987e 14 * ++ Start, stop, get result of conversions of injected
mbed_official 610:813dcc80987e 15 * groups, using 3 possible modes: polling or interruption.
mbed_official 610:813dcc80987e 16 * ++ Multimode feature
mbed_official 610:813dcc80987e 17 * + Control functions
mbed_official 610:813dcc80987e 18 * ++ Configure channels on injected group
mbed_official 610:813dcc80987e 19 * + State functions
mbed_official 610:813dcc80987e 20 * ++ Injected group queues management
mbed_official 610:813dcc80987e 21 *
mbed_official 610:813dcc80987e 22 @verbatim
mbed_official 610:813dcc80987e 23 ==============================================================================
mbed_official 610:813dcc80987e 24 ##### ADC specific features #####
mbed_official 610:813dcc80987e 25 ==============================================================================
mbed_official 610:813dcc80987e 26 [..]
mbed_official 610:813dcc80987e 27 (#) Interrupt generation at the end of injected conversion and in case of
mbed_official 610:813dcc80987e 28 injected queues overflow.
mbed_official 610:813dcc80987e 29
mbed_official 610:813dcc80987e 30 (#) External trigger (timer or EXTI) with configurable polarity for
mbed_official 610:813dcc80987e 31 injected groups.
mbed_official 610:813dcc80987e 32
mbed_official 610:813dcc80987e 33 (#) Multimode Dual mode.
mbed_official 610:813dcc80987e 34
mbed_official 610:813dcc80987e 35 (#) Configurable DMA data storage in Multimode Dual mode.
mbed_official 610:813dcc80987e 36
mbed_official 610:813dcc80987e 37 (#) Configurable delay between conversions in Dual interleaved mode.
mbed_official 610:813dcc80987e 38
mbed_official 610:813dcc80987e 39 (#) ADC calibration.
mbed_official 610:813dcc80987e 40
mbed_official 610:813dcc80987e 41 (#) ADC channels selectable single/differential input.
mbed_official 610:813dcc80987e 42
mbed_official 610:813dcc80987e 43 (#) ADC Injected sequencer&channels configuration context queue.
mbed_official 610:813dcc80987e 44
mbed_official 610:813dcc80987e 45 (#) ADC offset on injected groups.
mbed_official 610:813dcc80987e 46
mbed_official 610:813dcc80987e 47 (#) ADC oversampling.
mbed_official 610:813dcc80987e 48
mbed_official 610:813dcc80987e 49
mbed_official 610:813dcc80987e 50 ##### How to use this driver #####
mbed_official 610:813dcc80987e 51 ==============================================================================
mbed_official 610:813dcc80987e 52 [..]
mbed_official 610:813dcc80987e 53
mbed_official 610:813dcc80987e 54 (#) Configure the ADC parameters (conversion resolution, data alignment,
mbed_official 610:813dcc80987e 55 continuous mode, ...) using the HAL_ADC_Init() function.
mbed_official 610:813dcc80987e 56
mbed_official 610:813dcc80987e 57 (#) Activate the ADC peripheral using one of the start functions:
mbed_official 610:813dcc80987e 58 HAL_ADCEx_InjectedStart(), HAL_ADCEx_InjectedStart_IT() for injected conversions
mbed_official 610:813dcc80987e 59 or
mbed_official 610:813dcc80987e 60 HAL_ADC_MultiModeStart_DMA() for multimode conversions.
mbed_official 610:813dcc80987e 61
mbed_official 610:813dcc80987e 62
mbed_official 610:813dcc80987e 63 *** Channels to injected group configuration ***
mbed_official 610:813dcc80987e 64 =============================================
mbed_official 610:813dcc80987e 65 [..]
mbed_official 610:813dcc80987e 66 (+) To configure the ADC Injected channels group features, use
mbed_official 610:813dcc80987e 67 HAL_ADCEx_InjectedConfigChannel() functions.
mbed_official 610:813dcc80987e 68 (+) To read the ADC converted values, use the HAL_ADCEx_InjectedGetValue()
mbed_official 610:813dcc80987e 69 function.
mbed_official 610:813dcc80987e 70
mbed_official 610:813dcc80987e 71
mbed_official 610:813dcc80987e 72 *** Multimode ADCs configuration ***
mbed_official 610:813dcc80987e 73 ======================================================
mbed_official 610:813dcc80987e 74 [..]
mbed_official 610:813dcc80987e 75 (+) Multimode feature is available and applicable to ADC1 (Master)
mbed_official 610:813dcc80987e 76 and ADC2 (Slave).
mbed_official 610:813dcc80987e 77 (+) Refer to "Channels to regular group configuration" description to
mbed_official 610:813dcc80987e 78 configure the ADC1 and ADC2 regular groups.
mbed_official 610:813dcc80987e 79 (+) Select the Multi mode ADC features (dual mode
mbed_official 610:813dcc80987e 80 simultaneous, interleaved, ...) and configure the DMA mode using
mbed_official 610:813dcc80987e 81 HAL_ADCEx_MultiModeConfigChannel() functions.
mbed_official 610:813dcc80987e 82 (+) Read the ADCs converted values using the HAL_ADCEx_MultiModeGetValue()
mbed_official 610:813dcc80987e 83 function.
mbed_official 610:813dcc80987e 84
mbed_official 610:813dcc80987e 85
mbed_official 610:813dcc80987e 86 @endverbatim
mbed_official 610:813dcc80987e 87 ******************************************************************************
mbed_official 610:813dcc80987e 88 * @attention
mbed_official 610:813dcc80987e 89 *
mbed_official 610:813dcc80987e 90 * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
mbed_official 610:813dcc80987e 91 *
mbed_official 610:813dcc80987e 92 * Redistribution and use in source and binary forms, with or without modification,
mbed_official 610:813dcc80987e 93 * are permitted provided that the following conditions are met:
mbed_official 610:813dcc80987e 94 * 1. Redistributions of source code must retain the above copyright notice,
mbed_official 610:813dcc80987e 95 * this list of conditions and the following disclaimer.
mbed_official 610:813dcc80987e 96 * 2. Redistributions in binary form must reproduce the above copyright notice,
mbed_official 610:813dcc80987e 97 * this list of conditions and the following disclaimer in the documentation
mbed_official 610:813dcc80987e 98 * and/or other materials provided with the distribution.
mbed_official 610:813dcc80987e 99 * 3. Neither the name of STMicroelectronics nor the names of its contributors
mbed_official 610:813dcc80987e 100 * may be used to endorse or promote products derived from this software
mbed_official 610:813dcc80987e 101 * without specific prior written permission.
mbed_official 610:813dcc80987e 102 *
mbed_official 610:813dcc80987e 103 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
mbed_official 610:813dcc80987e 104 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
mbed_official 610:813dcc80987e 105 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
mbed_official 610:813dcc80987e 106 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
mbed_official 610:813dcc80987e 107 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
mbed_official 610:813dcc80987e 108 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
mbed_official 610:813dcc80987e 109 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
mbed_official 610:813dcc80987e 110 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
mbed_official 610:813dcc80987e 111 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
mbed_official 610:813dcc80987e 112 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
mbed_official 610:813dcc80987e 113 *
mbed_official 610:813dcc80987e 114 ******************************************************************************
mbed_official 610:813dcc80987e 115 */
mbed_official 610:813dcc80987e 116
mbed_official 610:813dcc80987e 117 /* Includes ------------------------------------------------------------------*/
mbed_official 610:813dcc80987e 118 #include "stm32l4xx_hal.h"
mbed_official 610:813dcc80987e 119
mbed_official 610:813dcc80987e 120 /** @addtogroup STM32L4xx_HAL_Driver
mbed_official 610:813dcc80987e 121 * @{
mbed_official 610:813dcc80987e 122 */
mbed_official 610:813dcc80987e 123
mbed_official 610:813dcc80987e 124 /** @defgroup ADCEx ADCEx
mbed_official 610:813dcc80987e 125 * @brief ADC Extended HAL module driver
mbed_official 610:813dcc80987e 126 * @{
mbed_official 610:813dcc80987e 127 */
mbed_official 610:813dcc80987e 128
mbed_official 610:813dcc80987e 129 #ifdef HAL_ADC_MODULE_ENABLED
mbed_official 610:813dcc80987e 130
mbed_official 610:813dcc80987e 131 /* Private typedef -----------------------------------------------------------*/
mbed_official 610:813dcc80987e 132 /* Private define ------------------------------------------------------------*/
mbed_official 610:813dcc80987e 133
mbed_official 610:813dcc80987e 134 /** @defgroup ADCEx_Private_Constants ADC Extended Private Constants
mbed_official 610:813dcc80987e 135 * @{
mbed_official 610:813dcc80987e 136 */
mbed_official 610:813dcc80987e 137
mbed_official 610:813dcc80987e 138 #define ADC_JSQR_FIELDS ((uint32_t)(ADC_JSQR_JL | ADC_JSQR_JEXTSEL | ADC_JSQR_JEXTEN |\
mbed_official 610:813dcc80987e 139 ADC_JSQR_JSQ1 | ADC_JSQR_JSQ2 |\
mbed_official 610:813dcc80987e 140 ADC_JSQR_JSQ3 | ADC_JSQR_JSQ4 )) /*!< ADC_JSQR fields of parameters that can be updated anytime
mbed_official 610:813dcc80987e 141 once the ADC is enabled */
mbed_official 610:813dcc80987e 142
mbed_official 610:813dcc80987e 143 #define ADC_CFGR2_INJ_FIELDS ((uint32_t)(ADC_CFGR2_JOVSE | ADC_CFGR2_OVSR |\
mbed_official 610:813dcc80987e 144 ADC_CFGR2_OVSS )) /*!< ADC_CFGR2 injected oversampling parameters that can be updated
mbed_official 610:813dcc80987e 145 when no conversion is on-going (neither regular nor injected) */
mbed_official 610:813dcc80987e 146
mbed_official 610:813dcc80987e 147 /* Fixed timeout value for ADC calibration. */
mbed_official 610:813dcc80987e 148 /* Values defined to be higher than worst cases: low clock frequency, */
mbed_official 610:813dcc80987e 149 /* maximum prescalers. */
mbed_official 610:813dcc80987e 150 /* Ex of profile low frequency : f_ADC at 0.14 MHz (minimum value */
mbed_official 610:813dcc80987e 151 /* according to Data sheet), calibration_time MAX = 112 / f_ADC */
mbed_official 610:813dcc80987e 152 /* 112 / 140,000 = 0.8 ms */
mbed_official 610:813dcc80987e 153 /* At maximum CPU speed (80 MHz), this means */
mbed_official 610:813dcc80987e 154 /* 0.8 ms * 80 MHz = 64000 CPU cycles */
mbed_official 610:813dcc80987e 155 #define ADC_CALIBRATION_TIMEOUT ((uint32_t) 64000) /*!< ADC calibration time-out value */
mbed_official 610:813dcc80987e 156
mbed_official 610:813dcc80987e 157 /**
mbed_official 610:813dcc80987e 158 * @}
mbed_official 610:813dcc80987e 159 */
mbed_official 610:813dcc80987e 160
mbed_official 610:813dcc80987e 161 /* Private macro -------------------------------------------------------------*/
mbed_official 610:813dcc80987e 162 /* Private variables ---------------------------------------------------------*/
mbed_official 610:813dcc80987e 163 /* Private function prototypes -----------------------------------------------*/
mbed_official 610:813dcc80987e 164 /* Exported functions --------------------------------------------------------*/
mbed_official 610:813dcc80987e 165
mbed_official 610:813dcc80987e 166 /** @defgroup ADCEx_Exported_Functions ADC Extended Exported Functions
mbed_official 610:813dcc80987e 167 * @{
mbed_official 610:813dcc80987e 168 */
mbed_official 610:813dcc80987e 169
mbed_official 610:813dcc80987e 170
mbed_official 610:813dcc80987e 171
mbed_official 610:813dcc80987e 172 /** @defgroup ADCEx_Exported_Functions_Group1 Extended Input and Output operation functions
mbed_official 610:813dcc80987e 173 * @brief Extended IO operation functions
mbed_official 610:813dcc80987e 174 *
mbed_official 610:813dcc80987e 175 @verbatim
mbed_official 610:813dcc80987e 176 ===============================================================================
mbed_official 610:813dcc80987e 177 ##### IO operation functions #####
mbed_official 610:813dcc80987e 178 ===============================================================================
mbed_official 610:813dcc80987e 179 [..] This section provides functions allowing to:
mbed_official 610:813dcc80987e 180
mbed_official 610:813dcc80987e 181 (+) Perform the ADC self-calibration for single or differential ending.
mbed_official 610:813dcc80987e 182 (+) Get calibration factors for single or differential ending.
mbed_official 610:813dcc80987e 183 (+) Set calibration factors for single or differential ending.
mbed_official 610:813dcc80987e 184
mbed_official 610:813dcc80987e 185 (+) Start conversion of injected group.
mbed_official 610:813dcc80987e 186 (+) Stop conversion of injected group.
mbed_official 610:813dcc80987e 187 (+) Poll for conversion complete on injected group.
mbed_official 610:813dcc80987e 188 (+) Get result of injected channel conversion.
mbed_official 610:813dcc80987e 189 (+) Start conversion of injected group and enable interruptions.
mbed_official 610:813dcc80987e 190 (+) Stop conversion of injected group and disable interruptions.
mbed_official 610:813dcc80987e 191
mbed_official 610:813dcc80987e 192 (+) Start multimode and enable DMA transfer.
mbed_official 610:813dcc80987e 193 (+) Stop multimode and disable ADC DMA transfer.
mbed_official 610:813dcc80987e 194 (+) Get result of multimode conversion.
mbed_official 610:813dcc80987e 195
mbed_official 610:813dcc80987e 196
mbed_official 610:813dcc80987e 197
mbed_official 610:813dcc80987e 198 @endverbatim
mbed_official 610:813dcc80987e 199 * @{
mbed_official 610:813dcc80987e 200 */
mbed_official 610:813dcc80987e 201
mbed_official 610:813dcc80987e 202
mbed_official 610:813dcc80987e 203
mbed_official 610:813dcc80987e 204 /**
mbed_official 610:813dcc80987e 205 * @brief Perform an ADC automatic self-calibration
mbed_official 610:813dcc80987e 206 * Calibration prerequisite: ADC must be disabled (execute this
mbed_official 610:813dcc80987e 207 * function before HAL_ADC_Start() or after HAL_ADC_Stop() ).
mbed_official 610:813dcc80987e 208 * @param hadc: ADC handle.
mbed_official 610:813dcc80987e 209 * @param SingleDiff: Selection of single-ended or differential input
mbed_official 610:813dcc80987e 210 * This parameter can be one of the following values:
mbed_official 610:813dcc80987e 211 * @arg ADC_SINGLE_ENDED: Channel in mode input single ended
mbed_official 610:813dcc80987e 212 * @arg ADC_DIFFERENTIAL_ENDED: Channel in mode input differential ended
mbed_official 610:813dcc80987e 213 * @retval HAL status
mbed_official 610:813dcc80987e 214 */
mbed_official 610:813dcc80987e 215 HAL_StatusTypeDef HAL_ADCEx_Calibration_Start(ADC_HandleTypeDef* hadc, uint32_t SingleDiff)
mbed_official 610:813dcc80987e 216 {
mbed_official 610:813dcc80987e 217 HAL_StatusTypeDef tmp_status = HAL_OK;
mbed_official 610:813dcc80987e 218 uint32_t WaitLoopIndex = 0;
mbed_official 610:813dcc80987e 219
mbed_official 610:813dcc80987e 220 /* Check the parameters */
mbed_official 610:813dcc80987e 221 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 610:813dcc80987e 222 assert_param(IS_ADC_SINGLE_DIFFERENTIAL(SingleDiff));
mbed_official 610:813dcc80987e 223
mbed_official 610:813dcc80987e 224 /* Process locked */
mbed_official 610:813dcc80987e 225 __HAL_LOCK(hadc);
mbed_official 610:813dcc80987e 226
mbed_official 610:813dcc80987e 227 /* Calibration prerequisite: ADC must be disabled. */
mbed_official 610:813dcc80987e 228
mbed_official 610:813dcc80987e 229 /* Disable the ADC (if not already disabled) */
mbed_official 610:813dcc80987e 230 tmp_status = ADC_Disable(hadc);
mbed_official 610:813dcc80987e 231
mbed_official 610:813dcc80987e 232 /* Check if ADC is effectively disabled */
mbed_official 610:813dcc80987e 233 if (tmp_status == HAL_OK)
mbed_official 610:813dcc80987e 234 {
mbed_official 610:813dcc80987e 235 /* Change ADC state */
mbed_official 610:813dcc80987e 236 /* Clear HAL_ADC_STATE_REG_BUSY and HAL_ADC_STATE_INJ_BUSY bits, set HAL_ADC_STATE_BUSY_INTERNAL bit */
mbed_official 610:813dcc80987e 237 ADC_STATE_CLR_SET(hadc->State, (HAL_ADC_STATE_REG_BUSY|HAL_ADC_STATE_INJ_BUSY), HAL_ADC_STATE_BUSY_INTERNAL);
mbed_official 610:813dcc80987e 238
mbed_official 610:813dcc80987e 239 /* Select calibration mode single ended or differential ended */
mbed_official 610:813dcc80987e 240 MODIFY_REG(hadc->Instance->CR, ADC_CR_ADCALDIF, SingleDiff);
mbed_official 610:813dcc80987e 241
mbed_official 610:813dcc80987e 242 /* Start ADC calibration */
mbed_official 610:813dcc80987e 243 SET_BIT(hadc->Instance->CR, ADC_CR_ADCAL);
mbed_official 610:813dcc80987e 244
mbed_official 610:813dcc80987e 245
mbed_official 610:813dcc80987e 246 /* Wait for calibration completion */
mbed_official 610:813dcc80987e 247 while(HAL_IS_BIT_SET(hadc->Instance->CR, ADC_CR_ADCAL))
mbed_official 610:813dcc80987e 248 {
mbed_official 610:813dcc80987e 249 WaitLoopIndex++;
mbed_official 610:813dcc80987e 250 if (WaitLoopIndex >= ADC_CALIBRATION_TIMEOUT)
mbed_official 610:813dcc80987e 251 {
mbed_official 610:813dcc80987e 252 /* Update ADC state machine to error */
mbed_official 610:813dcc80987e 253 /* Clear HAL_ADC_STATE_BUSY_INTERNAL bit, set HAL_ADC_STATE_ERROR_INTERNAL bit */
mbed_official 610:813dcc80987e 254 ADC_STATE_CLR_SET(hadc->State, HAL_ADC_STATE_BUSY_INTERNAL, HAL_ADC_STATE_ERROR_INTERNAL);
mbed_official 610:813dcc80987e 255
mbed_official 610:813dcc80987e 256 /* Process unlocked */
mbed_official 610:813dcc80987e 257 __HAL_UNLOCK(hadc);
mbed_official 610:813dcc80987e 258
mbed_official 610:813dcc80987e 259 return HAL_ERROR;
mbed_official 610:813dcc80987e 260 }
mbed_official 610:813dcc80987e 261 }
mbed_official 610:813dcc80987e 262
mbed_official 610:813dcc80987e 263 /* Clear HAL_ADC_STATE_BUSY_INTERNAL bit, set HAL_ADC_STATE_READY bit */
mbed_official 610:813dcc80987e 264 ADC_STATE_CLR_SET(hadc->State, HAL_ADC_STATE_BUSY_INTERNAL, HAL_ADC_STATE_READY);
mbed_official 610:813dcc80987e 265 }
mbed_official 610:813dcc80987e 266 else
mbed_official 610:813dcc80987e 267 {
mbed_official 610:813dcc80987e 268 SET_BIT(hadc->State, HAL_ADC_STATE_ERROR_INTERNAL);
mbed_official 610:813dcc80987e 269
mbed_official 610:813dcc80987e 270 /* Update ADC state machine to error */
mbed_official 610:813dcc80987e 271 tmp_status = HAL_ERROR;
mbed_official 610:813dcc80987e 272 }
mbed_official 610:813dcc80987e 273
mbed_official 610:813dcc80987e 274
mbed_official 610:813dcc80987e 275 /* Process unlocked */
mbed_official 610:813dcc80987e 276 __HAL_UNLOCK(hadc);
mbed_official 610:813dcc80987e 277
mbed_official 610:813dcc80987e 278 /* Return function status */
mbed_official 610:813dcc80987e 279 return tmp_status;
mbed_official 610:813dcc80987e 280 }
mbed_official 610:813dcc80987e 281
mbed_official 610:813dcc80987e 282
mbed_official 610:813dcc80987e 283
mbed_official 610:813dcc80987e 284
mbed_official 610:813dcc80987e 285 /**
mbed_official 610:813dcc80987e 286 * @brief Get the calibration factor from automatic conversion result.
mbed_official 610:813dcc80987e 287 * @param hadc: ADC handle.
mbed_official 610:813dcc80987e 288 * @param SingleDiff: Selection of single-ended or differential input
mbed_official 610:813dcc80987e 289 * This parameter can be one of the following values:
mbed_official 610:813dcc80987e 290 * @arg ADC_SINGLE_ENDED: Channel in mode input single ended
mbed_official 610:813dcc80987e 291 * @arg ADC_DIFFERENTIAL_ENDED: Channel in mode input differential ended
mbed_official 610:813dcc80987e 292 * @retval Converted value
mbed_official 610:813dcc80987e 293 */
mbed_official 610:813dcc80987e 294 uint32_t HAL_ADCEx_Calibration_GetValue(ADC_HandleTypeDef* hadc, uint32_t SingleDiff)
mbed_official 610:813dcc80987e 295 {
mbed_official 610:813dcc80987e 296 /* Check the parameters */
mbed_official 610:813dcc80987e 297 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 610:813dcc80987e 298 assert_param(IS_ADC_SINGLE_DIFFERENTIAL(SingleDiff));
mbed_official 610:813dcc80987e 299
mbed_official 610:813dcc80987e 300 /* Return the selected ADC calibration value */
mbed_official 610:813dcc80987e 301 if (SingleDiff == ADC_DIFFERENTIAL_ENDED)
mbed_official 610:813dcc80987e 302 {
mbed_official 610:813dcc80987e 303 return ADC_CALFACT_DIFF_GET(hadc->Instance->CALFACT);
mbed_official 610:813dcc80987e 304 }
mbed_official 610:813dcc80987e 305 else
mbed_official 610:813dcc80987e 306 {
mbed_official 610:813dcc80987e 307 return ((hadc->Instance->CALFACT) & ADC_CALFACT_CALFACT_S);
mbed_official 610:813dcc80987e 308 }
mbed_official 610:813dcc80987e 309 }
mbed_official 610:813dcc80987e 310
mbed_official 610:813dcc80987e 311
mbed_official 610:813dcc80987e 312
mbed_official 610:813dcc80987e 313 /**
mbed_official 610:813dcc80987e 314 * @brief Set the calibration factor to overwrite automatic conversion result. ADC must be enabled and no conversion on going.
mbed_official 610:813dcc80987e 315 * @param hadc: ADC handle.
mbed_official 610:813dcc80987e 316 * @param SingleDiff: Selection of single-ended or differential input.
mbed_official 610:813dcc80987e 317 * This parameter can be one of the following values:
mbed_official 610:813dcc80987e 318 * @arg ADC_SINGLE_ENDED: Channel in mode input single ended
mbed_official 610:813dcc80987e 319 * @arg ADC_DIFFERENTIAL_ENDED: Channel in mode input differential ended
mbed_official 610:813dcc80987e 320 * @param CalibrationFactor: Calibration factor (coded on 7 bits maximum)
mbed_official 610:813dcc80987e 321 * @retval HAL state
mbed_official 610:813dcc80987e 322 */
mbed_official 610:813dcc80987e 323 HAL_StatusTypeDef HAL_ADCEx_Calibration_SetValue(ADC_HandleTypeDef* hadc, uint32_t SingleDiff, uint32_t CalibrationFactor)
mbed_official 610:813dcc80987e 324 {
mbed_official 610:813dcc80987e 325 HAL_StatusTypeDef tmp_status = HAL_OK;
mbed_official 610:813dcc80987e 326
mbed_official 610:813dcc80987e 327 /* Check the parameters */
mbed_official 610:813dcc80987e 328 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 610:813dcc80987e 329 assert_param(IS_ADC_SINGLE_DIFFERENTIAL(SingleDiff));
mbed_official 610:813dcc80987e 330 assert_param(IS_ADC_CALFACT(CalibrationFactor));
mbed_official 610:813dcc80987e 331
mbed_official 610:813dcc80987e 332 /* Process locked */
mbed_official 610:813dcc80987e 333 __HAL_LOCK(hadc);
mbed_official 610:813dcc80987e 334
mbed_official 610:813dcc80987e 335 /* Verification of hardware constraints before modifying the calibration */
mbed_official 610:813dcc80987e 336 /* factors register: ADC must be enabled, no conversion on going. */
mbed_official 610:813dcc80987e 337 if ( (ADC_IS_ENABLE(hadc) != RESET) &&
mbed_official 610:813dcc80987e 338 (ADC_IS_CONVERSION_ONGOING_REGULAR_INJECTED(hadc) == RESET) )
mbed_official 610:813dcc80987e 339 {
mbed_official 610:813dcc80987e 340 /* Set the selected ADC calibration value */
mbed_official 610:813dcc80987e 341 if (SingleDiff == ADC_DIFFERENTIAL_ENDED)
mbed_official 610:813dcc80987e 342 {
mbed_official 610:813dcc80987e 343 MODIFY_REG(hadc->Instance->CALFACT, ADC_CALFACT_CALFACT_D, ADC_CALFACT_DIFF_SET(CalibrationFactor));
mbed_official 610:813dcc80987e 344 }
mbed_official 610:813dcc80987e 345 else
mbed_official 610:813dcc80987e 346 {
mbed_official 610:813dcc80987e 347 MODIFY_REG(hadc->Instance->CALFACT, ADC_CALFACT_CALFACT_S, CalibrationFactor);
mbed_official 610:813dcc80987e 348 }
mbed_official 610:813dcc80987e 349 }
mbed_official 610:813dcc80987e 350 else
mbed_official 610:813dcc80987e 351 {
mbed_official 610:813dcc80987e 352 /* Update ADC state machine */
mbed_official 610:813dcc80987e 353 SET_BIT(hadc->State, HAL_ADC_STATE_ERROR_CONFIG);
mbed_official 610:813dcc80987e 354
mbed_official 610:813dcc80987e 355 /* Update ADC state machine to error */
mbed_official 610:813dcc80987e 356 tmp_status = HAL_ERROR;
mbed_official 610:813dcc80987e 357 }
mbed_official 610:813dcc80987e 358
mbed_official 610:813dcc80987e 359 /* Process unlocked */
mbed_official 610:813dcc80987e 360 __HAL_UNLOCK(hadc);
mbed_official 610:813dcc80987e 361
mbed_official 610:813dcc80987e 362 /* Return function status */
mbed_official 610:813dcc80987e 363 return tmp_status;
mbed_official 610:813dcc80987e 364 }
mbed_official 610:813dcc80987e 365
mbed_official 610:813dcc80987e 366
mbed_official 610:813dcc80987e 367
mbed_official 610:813dcc80987e 368 /**
mbed_official 610:813dcc80987e 369 * @brief Enables ADC, starts conversion of injected group.
mbed_official 610:813dcc80987e 370 * @note Interruptions enabled in this function: None.
mbed_official 610:813dcc80987e 371 * @note Case of multimode enabled: HAL_ADCEx_InjectedStart() API
mbed_official 610:813dcc80987e 372 * must be called for ADC slave first, then ADC master.
mbed_official 610:813dcc80987e 373 * For ADC slave, ADC is enabled only (conversion is not started).
mbed_official 610:813dcc80987e 374 * For ADC master, ADC is enabled and multimode conversion is started.
mbed_official 610:813dcc80987e 375 * @param hadc: ADC handle.
mbed_official 610:813dcc80987e 376 * @retval HAL status
mbed_official 610:813dcc80987e 377 */
mbed_official 610:813dcc80987e 378 HAL_StatusTypeDef HAL_ADCEx_InjectedStart(ADC_HandleTypeDef* hadc)
mbed_official 610:813dcc80987e 379 {
mbed_official 610:813dcc80987e 380 HAL_StatusTypeDef tmp_status = HAL_OK;
mbed_official 610:813dcc80987e 381
mbed_official 610:813dcc80987e 382 /* Check the parameters */
mbed_official 610:813dcc80987e 383 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 610:813dcc80987e 384
mbed_official 610:813dcc80987e 385 if (ADC_IS_CONVERSION_ONGOING_INJECTED(hadc))
mbed_official 610:813dcc80987e 386 {
mbed_official 610:813dcc80987e 387 return HAL_BUSY;
mbed_official 610:813dcc80987e 388 }
mbed_official 610:813dcc80987e 389 else
mbed_official 610:813dcc80987e 390 {
mbed_official 610:813dcc80987e 391
mbed_official 610:813dcc80987e 392 /* In case of software trigger detection enabled, JQDIS must be set
mbed_official 610:813dcc80987e 393 (which can be done only if ADSTART and JADSTART are both cleared).
mbed_official 610:813dcc80987e 394 If JQDIS is not set at that point, returns an error
mbed_official 610:813dcc80987e 395 - since software trigger detection is disabled. User needs to
mbed_official 610:813dcc80987e 396 resort to HAL_ADCEx_DisableInjectedQueue() API to set JQDIS.
mbed_official 610:813dcc80987e 397 - or (if JQDIS is intentionally reset) since JEXTEN = 0 which means
mbed_official 610:813dcc80987e 398 the queue is empty */
mbed_official 610:813dcc80987e 399 if ((READ_BIT(hadc->Instance->JSQR, ADC_JSQR_JEXTEN) == RESET)
mbed_official 610:813dcc80987e 400 && (READ_BIT(hadc->Instance->CFGR, ADC_CFGR_JQDIS) == RESET))
mbed_official 610:813dcc80987e 401 {
mbed_official 610:813dcc80987e 402 SET_BIT(hadc->State, HAL_ADC_STATE_ERROR_CONFIG);
mbed_official 610:813dcc80987e 403 return HAL_ERROR;
mbed_official 610:813dcc80987e 404 }
mbed_official 610:813dcc80987e 405
mbed_official 610:813dcc80987e 406
mbed_official 610:813dcc80987e 407 /* Process locked */
mbed_official 610:813dcc80987e 408 __HAL_LOCK(hadc);
mbed_official 610:813dcc80987e 409
mbed_official 610:813dcc80987e 410 /* Enable the ADC peripheral */
mbed_official 610:813dcc80987e 411 tmp_status = ADC_Enable(hadc);
mbed_official 610:813dcc80987e 412
mbed_official 610:813dcc80987e 413 /* Start conversion if ADC is effectively enabled */
mbed_official 610:813dcc80987e 414 if (tmp_status == HAL_OK)
mbed_official 610:813dcc80987e 415 {
mbed_official 610:813dcc80987e 416 /* Check if a regular conversion is ongoing */
mbed_official 610:813dcc80987e 417 if (HAL_IS_BIT_SET(hadc->State, HAL_ADC_STATE_REG_BUSY))
mbed_official 610:813dcc80987e 418 {
mbed_official 610:813dcc80987e 419 /* Reset ADC error code field related to injected conversions only */
mbed_official 610:813dcc80987e 420 CLEAR_BIT(hadc->ErrorCode, HAL_ADC_ERROR_JQOVF);
mbed_official 610:813dcc80987e 421 }
mbed_official 610:813dcc80987e 422 else
mbed_official 610:813dcc80987e 423 {
mbed_official 610:813dcc80987e 424 /* Set ADC error code to none */
mbed_official 610:813dcc80987e 425 ADC_CLEAR_ERRORCODE(hadc);
mbed_official 610:813dcc80987e 426 }
mbed_official 610:813dcc80987e 427 /* Update ADC state */
mbed_official 610:813dcc80987e 428 /* Clear HAL_ADC_STATE_READY and HAL_ADC_STATE_INJ_EOC bits, set HAL_ADC_STATE_INJ_BUSY bit */
mbed_official 610:813dcc80987e 429 ADC_STATE_CLR_SET(hadc->State, (HAL_ADC_STATE_READY|HAL_ADC_STATE_INJ_EOC), HAL_ADC_STATE_INJ_BUSY);
mbed_official 610:813dcc80987e 430
mbed_official 610:813dcc80987e 431 /* Reset HAL_ADC_STATE_MULTIMODE_SLAVE bit
mbed_official 610:813dcc80987e 432 - by default if ADC is Master or Independent
mbed_official 610:813dcc80987e 433 - if MultiMode setting is set to independent mode (no dual regular or injected conversions are configured) */
mbed_official 610:813dcc80987e 434 if (ADC_NONMULTIMODE_OR_MULTIMODEMASTER(hadc))
mbed_official 610:813dcc80987e 435 {
mbed_official 610:813dcc80987e 436 CLEAR_BIT(hadc->State, HAL_ADC_STATE_MULTIMODE_SLAVE);
mbed_official 610:813dcc80987e 437 }
mbed_official 610:813dcc80987e 438
mbed_official 610:813dcc80987e 439
mbed_official 610:813dcc80987e 440 /* Clear injected group conversion flag */
mbed_official 610:813dcc80987e 441 /* (To ensure of no unknown state from potential previous ADC operations) */
mbed_official 610:813dcc80987e 442 __HAL_ADC_CLEAR_FLAG(hadc, (ADC_FLAG_JEOC | ADC_FLAG_JEOS));
mbed_official 610:813dcc80987e 443
mbed_official 610:813dcc80987e 444 /* Enable conversion of injected group, if automatic injected conversion */
mbed_official 610:813dcc80987e 445 /* is disabled. */
mbed_official 610:813dcc80987e 446 /* If software start has been selected, conversion starts immediately. */
mbed_official 610:813dcc80987e 447 /* If external trigger has been selected, conversion will start at next */
mbed_official 610:813dcc80987e 448 /* trigger event. */
mbed_official 610:813dcc80987e 449 /* Case of multimode enabled: */
mbed_official 610:813dcc80987e 450 /* if ADC is slave, */
mbed_official 610:813dcc80987e 451 /* - ADC is enabled only (conversion is not started). */
mbed_official 610:813dcc80987e 452 /* - if multimode only concerns regular conversion, ADC is enabled */
mbed_official 610:813dcc80987e 453 /* and conversion is started. */
mbed_official 610:813dcc80987e 454 /* If ADC is master or independent, */
mbed_official 610:813dcc80987e 455 /* - ADC is enabled and conversion is started. */
mbed_official 610:813dcc80987e 456
mbed_official 610:813dcc80987e 457 /* Are injected conversions that of a dual Slave ? */
mbed_official 610:813dcc80987e 458 if (ADC_INDEPENDENT_OR_NONMULTIMODEINJECTED_SLAVE(hadc))
mbed_official 610:813dcc80987e 459 {
mbed_official 610:813dcc80987e 460 /* hadc is not the handle of a Slave ADC with dual injected conversions enabled:
mbed_official 610:813dcc80987e 461 set ADSTART only if JAUTO is cleared */
mbed_official 610:813dcc80987e 462 /* Process unlocked */
mbed_official 610:813dcc80987e 463 __HAL_UNLOCK(hadc);
mbed_official 610:813dcc80987e 464 if (HAL_IS_BIT_CLR(hadc->Instance->CFGR, ADC_CFGR_JAUTO))
mbed_official 610:813dcc80987e 465 {
mbed_official 610:813dcc80987e 466 SET_BIT(hadc->Instance->CR, ADC_CR_JADSTART) ;
mbed_official 610:813dcc80987e 467 }
mbed_official 610:813dcc80987e 468 }
mbed_official 610:813dcc80987e 469 else
mbed_official 610:813dcc80987e 470 {
mbed_official 610:813dcc80987e 471 /* hadc is the handle of a Slave ADC with dual injected conversions enabled:
mbed_official 610:813dcc80987e 472 ADSTART is not set */
mbed_official 610:813dcc80987e 473 SET_BIT(hadc->State, HAL_ADC_STATE_MULTIMODE_SLAVE);
mbed_official 610:813dcc80987e 474 /* Process unlocked */
mbed_official 610:813dcc80987e 475 __HAL_UNLOCK(hadc);
mbed_official 610:813dcc80987e 476 }
mbed_official 610:813dcc80987e 477 }
mbed_official 610:813dcc80987e 478 else
mbed_official 610:813dcc80987e 479 {
mbed_official 610:813dcc80987e 480 /* Process unlocked */
mbed_official 610:813dcc80987e 481 __HAL_UNLOCK(hadc);
mbed_official 610:813dcc80987e 482 } /* if (tmp_status == HAL_OK) */
mbed_official 610:813dcc80987e 483
mbed_official 610:813dcc80987e 484
mbed_official 610:813dcc80987e 485 /* Return function status */
mbed_official 610:813dcc80987e 486 return tmp_status;
mbed_official 610:813dcc80987e 487 } /* if (ADC_IS_CONVERSION_ONGOING_INJECTED(hadc)) */
mbed_official 610:813dcc80987e 488 }
mbed_official 610:813dcc80987e 489
mbed_official 610:813dcc80987e 490
mbed_official 610:813dcc80987e 491
mbed_official 610:813dcc80987e 492 /**
mbed_official 610:813dcc80987e 493 * @brief Stop conversion of injected channels, disable ADC peripheral if no regular conversion is on going.
mbed_official 610:813dcc80987e 494 * @note If ADC must be disabled and if regular conversion
mbed_official 610:813dcc80987e 495 * is on going, function HAL_ADC_Stop() must be used.
mbed_official 610:813dcc80987e 496 * @note In case of auto-injection mode, HAL_ADC_Stop() must be used.
mbed_official 610:813dcc80987e 497 * @note In case of multimode enabled, HAL_ADCEx_InjectedStop()
mbed_official 610:813dcc80987e 498 * must be called for ADC master first, then ADC slave.
mbed_official 610:813dcc80987e 499 * For ADC master, conversion is stopped and ADC is disabled.
mbed_official 610:813dcc80987e 500 * For ADC slave, ADC is disabled only (conversion stop of ADC master
mbed_official 610:813dcc80987e 501 * has already stopped conversion of ADC slave).
mbed_official 610:813dcc80987e 502 * @param hadc: ADC handle.
mbed_official 610:813dcc80987e 503 * @retval None
mbed_official 610:813dcc80987e 504 */
mbed_official 610:813dcc80987e 505 HAL_StatusTypeDef HAL_ADCEx_InjectedStop(ADC_HandleTypeDef* hadc)
mbed_official 610:813dcc80987e 506 {
mbed_official 610:813dcc80987e 507 HAL_StatusTypeDef tmp_status = HAL_OK;
mbed_official 610:813dcc80987e 508
mbed_official 610:813dcc80987e 509 /* Check the parameters */
mbed_official 610:813dcc80987e 510 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 610:813dcc80987e 511
mbed_official 610:813dcc80987e 512 /* Process locked */
mbed_official 610:813dcc80987e 513 __HAL_LOCK(hadc);
mbed_official 610:813dcc80987e 514
mbed_official 610:813dcc80987e 515 /* 1. Stop potential conversion on going on injected group only. */
mbed_official 610:813dcc80987e 516 tmp_status = ADC_ConversionStop(hadc, ADC_INJECTED_GROUP);
mbed_official 610:813dcc80987e 517
mbed_official 610:813dcc80987e 518 /* Disable ADC peripheral if injected conversions are effectively stopped */
mbed_official 610:813dcc80987e 519 /* and if no conversion on regular group is on-going */
mbed_official 610:813dcc80987e 520 if (tmp_status == HAL_OK)
mbed_official 610:813dcc80987e 521 {
mbed_official 610:813dcc80987e 522 if (ADC_IS_CONVERSION_ONGOING_REGULAR(hadc) == RESET)
mbed_official 610:813dcc80987e 523 {
mbed_official 610:813dcc80987e 524 /* 2. Disable the ADC peripheral */
mbed_official 610:813dcc80987e 525 tmp_status = ADC_Disable(hadc);
mbed_official 610:813dcc80987e 526
mbed_official 610:813dcc80987e 527 /* Check if ADC is effectively disabled */
mbed_official 610:813dcc80987e 528 if (tmp_status == HAL_OK)
mbed_official 610:813dcc80987e 529 {
mbed_official 610:813dcc80987e 530 /* Change ADC state */
mbed_official 610:813dcc80987e 531 /* Clear HAL_ADC_STATE_REG_BUSY and HAL_ADC_STATE_INJ_BUSY bits, set HAL_ADC_STATE_READY bit */
mbed_official 610:813dcc80987e 532 ADC_STATE_CLR_SET(hadc->State, (HAL_ADC_STATE_REG_BUSY|HAL_ADC_STATE_INJ_BUSY), HAL_ADC_STATE_READY);
mbed_official 610:813dcc80987e 533 }
mbed_official 610:813dcc80987e 534 }
mbed_official 610:813dcc80987e 535 /* Conversion on injected group is stopped, but ADC not disabled since */
mbed_official 610:813dcc80987e 536 /* conversion on regular group is still running. */
mbed_official 610:813dcc80987e 537 else
mbed_official 610:813dcc80987e 538 {
mbed_official 610:813dcc80987e 539 /* Clear HAL_ADC_STATE_INJ_BUSY bit */
mbed_official 610:813dcc80987e 540 CLEAR_BIT(hadc->State, HAL_ADC_STATE_INJ_BUSY);
mbed_official 610:813dcc80987e 541 }
mbed_official 610:813dcc80987e 542 }
mbed_official 610:813dcc80987e 543
mbed_official 610:813dcc80987e 544 /* Process unlocked */
mbed_official 610:813dcc80987e 545 __HAL_UNLOCK(hadc);
mbed_official 610:813dcc80987e 546
mbed_official 610:813dcc80987e 547 /* Return function status */
mbed_official 610:813dcc80987e 548 return tmp_status;
mbed_official 610:813dcc80987e 549 }
mbed_official 610:813dcc80987e 550
mbed_official 610:813dcc80987e 551
mbed_official 610:813dcc80987e 552
mbed_official 610:813dcc80987e 553 /**
mbed_official 610:813dcc80987e 554 * @brief Wait for injected group conversion to be completed.
mbed_official 610:813dcc80987e 555 * @param hadc: ADC handle
mbed_official 610:813dcc80987e 556 * @param Timeout: Timeout value in millisecond.
mbed_official 610:813dcc80987e 557 * @note Depending on hadc->Init.EOCSelection, JEOS or JEOC is
mbed_official 610:813dcc80987e 558 * checked and cleared depending on AUTDLY bit status.
mbed_official 610:813dcc80987e 559 * @retval HAL status
mbed_official 610:813dcc80987e 560 */
mbed_official 610:813dcc80987e 561 HAL_StatusTypeDef HAL_ADCEx_InjectedPollForConversion(ADC_HandleTypeDef* hadc, uint32_t Timeout)
mbed_official 610:813dcc80987e 562 {
mbed_official 610:813dcc80987e 563 uint32_t tickstart;
mbed_official 610:813dcc80987e 564 uint32_t tmp_Flag_End = 0x00;
mbed_official 610:813dcc80987e 565 ADC_TypeDef *tmpADC_Master;
mbed_official 610:813dcc80987e 566 uint32_t tmp_cfgr = 0x00;
mbed_official 610:813dcc80987e 567 uint32_t tmp_cfgr_jqm_autdly = 0x00;
mbed_official 610:813dcc80987e 568 uint32_t tmp_jeos_raised = 0x01; /* by default, assume that JEOS is set,
mbed_official 610:813dcc80987e 569 tmp_jeos_raised will be corrected
mbed_official 610:813dcc80987e 570 accordingly during API execution */
mbed_official 610:813dcc80987e 571
mbed_official 610:813dcc80987e 572 /* Check the parameters */
mbed_official 610:813dcc80987e 573 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 610:813dcc80987e 574
mbed_official 610:813dcc80987e 575 /* If end of sequence selected */
mbed_official 610:813dcc80987e 576 if (hadc->Init.EOCSelection == ADC_EOC_SEQ_CONV)
mbed_official 610:813dcc80987e 577 {
mbed_official 610:813dcc80987e 578 tmp_Flag_End = ADC_FLAG_JEOS;
mbed_official 610:813dcc80987e 579 }
mbed_official 610:813dcc80987e 580 else /* end of conversion selected */
mbed_official 610:813dcc80987e 581 {
mbed_official 610:813dcc80987e 582 tmp_Flag_End = ADC_FLAG_JEOC;
mbed_official 610:813dcc80987e 583 }
mbed_official 610:813dcc80987e 584
mbed_official 610:813dcc80987e 585 /* Get timeout */
mbed_official 610:813dcc80987e 586 tickstart = HAL_GetTick();
mbed_official 610:813dcc80987e 587
mbed_official 610:813dcc80987e 588 /* Wait until End of Conversion or Sequence flag is raised */
mbed_official 610:813dcc80987e 589 while(HAL_IS_BIT_CLR(hadc->Instance->ISR, tmp_Flag_End))
mbed_official 610:813dcc80987e 590 {
mbed_official 610:813dcc80987e 591 /* Check if timeout is disabled (set to infinite wait) */
mbed_official 610:813dcc80987e 592 if(Timeout != HAL_MAX_DELAY)
mbed_official 610:813dcc80987e 593 {
mbed_official 610:813dcc80987e 594 if((Timeout == 0) || ((HAL_GetTick()-tickstart) > Timeout))
mbed_official 610:813dcc80987e 595 {
mbed_official 610:813dcc80987e 596 /* Update ADC state machine to timeout */
mbed_official 610:813dcc80987e 597 SET_BIT(hadc->State, HAL_ADC_STATE_TIMEOUT);
mbed_official 610:813dcc80987e 598
mbed_official 610:813dcc80987e 599 /* Process unlocked */
mbed_official 610:813dcc80987e 600 __HAL_UNLOCK(hadc);
mbed_official 610:813dcc80987e 601
mbed_official 610:813dcc80987e 602 return HAL_TIMEOUT;
mbed_official 610:813dcc80987e 603 }
mbed_official 610:813dcc80987e 604 }
mbed_official 610:813dcc80987e 605 }
mbed_official 610:813dcc80987e 606
mbed_official 610:813dcc80987e 607 /* Next, to clear the polled flag as well as to update the handle State,
mbed_official 610:813dcc80987e 608 JEOS is checked and the relevant configuration registers are retrieved.
mbed_official 610:813dcc80987e 609 JQM, JAUTO and CONT bits will have to be read for the State update,
mbed_official 610:813dcc80987e 610 AUTDLY for JEOS clearing. */
mbed_official 610:813dcc80987e 611 /* 1. Check whether or not JEOS is set */
mbed_official 610:813dcc80987e 612 if (HAL_IS_BIT_CLR(hadc->Instance->ISR, ADC_FLAG_JEOS))
mbed_official 610:813dcc80987e 613 {
mbed_official 610:813dcc80987e 614 tmp_jeos_raised = 0;
mbed_official 610:813dcc80987e 615 }
mbed_official 610:813dcc80987e 616 /* 2. Check whether or not hadc is the handle of a Slave ADC with dual
mbed_official 610:813dcc80987e 617 injected conversions enabled. */
mbed_official 610:813dcc80987e 618 if (ADC_INDEPENDENT_OR_NONMULTIMODEINJECTED_SLAVE(hadc) == RESET)
mbed_official 610:813dcc80987e 619 {
mbed_official 610:813dcc80987e 620 /* hadc is not the handle of a Slave ADC with dual injected conversions enabled:
mbed_official 610:813dcc80987e 621 check JQM and AUTDLY bits directly in ADC CFGR register */
mbed_official 610:813dcc80987e 622 tmp_cfgr_jqm_autdly = READ_REG(hadc->Instance->CFGR);
mbed_official 610:813dcc80987e 623 }
mbed_official 610:813dcc80987e 624 else
mbed_official 610:813dcc80987e 625 {
mbed_official 610:813dcc80987e 626 /* hadc is the handle of a Slave ADC with dual injected conversions enabled:
mbed_official 610:813dcc80987e 627 need to check JQM and AUTDLY bits of Master ADC CFGR register */
mbed_official 610:813dcc80987e 628 tmpADC_Master = ADC_MASTER_REGISTER(hadc);
mbed_official 610:813dcc80987e 629 tmp_cfgr_jqm_autdly = READ_REG(tmpADC_Master->CFGR);
mbed_official 610:813dcc80987e 630 }
mbed_official 610:813dcc80987e 631 /* 3. Check whether or not hadc is the handle of a Slave ADC with dual
mbed_official 610:813dcc80987e 632 regular conversions enabled. */
mbed_official 610:813dcc80987e 633 if (ADC_INDEPENDENT_OR_NONMULTIMODEREGULAR_SLAVE(hadc))
mbed_official 610:813dcc80987e 634 {
mbed_official 610:813dcc80987e 635 /* hadc is not the handle of a Slave ADC with dual regular conversions enabled:
mbed_official 610:813dcc80987e 636 check JAUTO and CONT bits directly in ADC CFGR register */
mbed_official 610:813dcc80987e 637 tmp_cfgr = READ_REG(hadc->Instance->CFGR);
mbed_official 610:813dcc80987e 638 }
mbed_official 610:813dcc80987e 639 else
mbed_official 610:813dcc80987e 640 {
mbed_official 610:813dcc80987e 641 /* hadc is not the handle of a Slave ADC with dual regular conversions enabled:
mbed_official 610:813dcc80987e 642 check JAUTO and CONT bits of Master ADC CFGR register */
mbed_official 610:813dcc80987e 643 tmpADC_Master = ADC_MASTER_REGISTER(hadc);
mbed_official 610:813dcc80987e 644 tmp_cfgr = READ_REG(tmpADC_Master->CFGR);
mbed_official 610:813dcc80987e 645 }
mbed_official 610:813dcc80987e 646
mbed_official 610:813dcc80987e 647
mbed_official 610:813dcc80987e 648
mbed_official 610:813dcc80987e 649 /* Clear polled flag */
mbed_official 610:813dcc80987e 650 if (tmp_Flag_End == ADC_FLAG_JEOS)
mbed_official 610:813dcc80987e 651 {
mbed_official 610:813dcc80987e 652 /* Clear end of sequence JEOS flag of injected group if low power feature */
mbed_official 610:813dcc80987e 653 /* "LowPowerAutoWait " is disabled, to not interfere with this feature. */
mbed_official 610:813dcc80987e 654 /* For injected groups, no new conversion will start before JEOS is */
mbed_official 610:813dcc80987e 655 /* cleared. */
mbed_official 610:813dcc80987e 656 /* Note that 1. reading ADCx_JDRy clears JEOC. */
mbed_official 610:813dcc80987e 657 /* 2. in MultiMode with dual injected conversions enabled, */
mbed_official 610:813dcc80987e 658 /* Master AUTDLY bit must be checked */
mbed_official 610:813dcc80987e 659
mbed_official 610:813dcc80987e 660 if (READ_BIT (tmp_cfgr_jqm_autdly, ADC_CFGR_AUTDLY) == RESET)
mbed_official 610:813dcc80987e 661 {
mbed_official 610:813dcc80987e 662 __HAL_ADC_CLEAR_FLAG(hadc, ADC_FLAG_EOC);
mbed_official 610:813dcc80987e 663 }
mbed_official 610:813dcc80987e 664 }
mbed_official 610:813dcc80987e 665 else
mbed_official 610:813dcc80987e 666 {
mbed_official 610:813dcc80987e 667 __HAL_ADC_CLEAR_FLAG(hadc, ADC_FLAG_JEOC);
mbed_official 610:813dcc80987e 668 }
mbed_official 610:813dcc80987e 669
mbed_official 610:813dcc80987e 670
mbed_official 610:813dcc80987e 671 /* Update ADC state machine */
mbed_official 610:813dcc80987e 672 SET_BIT(hadc->State, HAL_ADC_STATE_INJ_EOC);
mbed_official 610:813dcc80987e 673 /* Are injected conversions over ? This is the case if JEOS is set AND
mbed_official 610:813dcc80987e 674 - injected conversions are software-triggered when injected queue management is disabled
mbed_official 610:813dcc80987e 675 OR
mbed_official 610:813dcc80987e 676 - auto-injection is enabled, continuous mode is disabled,
mbed_official 610:813dcc80987e 677 and regular conversions are software-triggered */
mbed_official 610:813dcc80987e 678
mbed_official 610:813dcc80987e 679 if (tmp_jeos_raised)
mbed_official 610:813dcc80987e 680 {
mbed_official 610:813dcc80987e 681 if ((ADC_IS_SOFTWARE_START_INJECTED(hadc) && (READ_BIT(tmp_cfgr_jqm_autdly, ADC_CFGR_JQM) != ADC_CFGR_JQM))
mbed_official 610:813dcc80987e 682 && (!((READ_BIT(tmp_cfgr, (ADC_CFGR_JAUTO|ADC_CFGR_CONT)) == (ADC_CFGR_JAUTO|ADC_CFGR_CONT)) &&
mbed_official 610:813dcc80987e 683 (ADC_IS_SOFTWARE_START_REGULAR(hadc))) ))
mbed_official 610:813dcc80987e 684 {
mbed_official 610:813dcc80987e 685 /* Clear HAL_ADC_STATE_INJ_BUSY bit */
mbed_official 610:813dcc80987e 686 CLEAR_BIT(hadc->State, HAL_ADC_STATE_INJ_BUSY);
mbed_official 610:813dcc80987e 687 /* If no regular conversion on-going, set HAL_ADC_STATE_READY bit */
mbed_official 610:813dcc80987e 688 if (HAL_IS_BIT_CLR(hadc->State, HAL_ADC_STATE_REG_BUSY))
mbed_official 610:813dcc80987e 689 {
mbed_official 610:813dcc80987e 690 SET_BIT(hadc->State, HAL_ADC_STATE_READY);
mbed_official 610:813dcc80987e 691 }
mbed_official 610:813dcc80987e 692 }
mbed_official 610:813dcc80987e 693 }
mbed_official 610:813dcc80987e 694
mbed_official 610:813dcc80987e 695
mbed_official 610:813dcc80987e 696
mbed_official 610:813dcc80987e 697 /* Return API HAL status */
mbed_official 610:813dcc80987e 698 return HAL_OK;
mbed_official 610:813dcc80987e 699 }
mbed_official 610:813dcc80987e 700
mbed_official 610:813dcc80987e 701
mbed_official 610:813dcc80987e 702
mbed_official 610:813dcc80987e 703 /**
mbed_official 610:813dcc80987e 704 * @brief Enable ADC, start conversion of injected group with interruption.
mbed_official 610:813dcc80987e 705 * @note Interruptions enabled in this function according to initialization
mbed_official 610:813dcc80987e 706 * setting : JEOC (end of conversion) or JEOS (end of sequence)
mbed_official 610:813dcc80987e 707 * @note Case of multimode enabled: HAL_ADCEx_InjectedStart_IT() API
mbed_official 610:813dcc80987e 708 * must be called for ADC slave first, then ADC master.
mbed_official 610:813dcc80987e 709 * For ADC slave, ADC is enabled only (conversion is not started).
mbed_official 610:813dcc80987e 710 * For ADC master, ADC is enabled and multimode conversion is started.
mbed_official 610:813dcc80987e 711 * @param hadc: ADC handle.
mbed_official 610:813dcc80987e 712 * @retval HAL status.
mbed_official 610:813dcc80987e 713 */
mbed_official 610:813dcc80987e 714 HAL_StatusTypeDef HAL_ADCEx_InjectedStart_IT(ADC_HandleTypeDef* hadc)
mbed_official 610:813dcc80987e 715 {
mbed_official 610:813dcc80987e 716 HAL_StatusTypeDef tmp_status = HAL_OK;
mbed_official 610:813dcc80987e 717
mbed_official 610:813dcc80987e 718 /* Check the parameters */
mbed_official 610:813dcc80987e 719 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 610:813dcc80987e 720
mbed_official 610:813dcc80987e 721 if (ADC_IS_CONVERSION_ONGOING_INJECTED(hadc))
mbed_official 610:813dcc80987e 722 {
mbed_official 610:813dcc80987e 723 return HAL_BUSY;
mbed_official 610:813dcc80987e 724 }
mbed_official 610:813dcc80987e 725 else
mbed_official 610:813dcc80987e 726 {
mbed_official 610:813dcc80987e 727
mbed_official 610:813dcc80987e 728 /* In case of software trigger detection enabled, JQDIS must be set
mbed_official 610:813dcc80987e 729 (which can be done only if ADSTART and JADSTART are both cleared).
mbed_official 610:813dcc80987e 730 If JQDIS is not set at that point, returns an error
mbed_official 610:813dcc80987e 731 - since software trigger detection is disabled. User needs to
mbed_official 610:813dcc80987e 732 resort to HAL_ADCEx_DisableInjectedQueue() API to set JQDIS.
mbed_official 610:813dcc80987e 733 - or (if JQDIS is intentionally reset) since JEXTEN = 0 which means
mbed_official 610:813dcc80987e 734 the queue is empty */
mbed_official 610:813dcc80987e 735 if ((READ_BIT(hadc->Instance->JSQR, ADC_JSQR_JEXTEN) == RESET)
mbed_official 610:813dcc80987e 736 && (READ_BIT(hadc->Instance->CFGR, ADC_CFGR_JQDIS) == RESET))
mbed_official 610:813dcc80987e 737 {
mbed_official 610:813dcc80987e 738 SET_BIT(hadc->State, HAL_ADC_STATE_ERROR_CONFIG);
mbed_official 610:813dcc80987e 739 return HAL_ERROR;
mbed_official 610:813dcc80987e 740 }
mbed_official 610:813dcc80987e 741
mbed_official 610:813dcc80987e 742 /* Process locked */
mbed_official 610:813dcc80987e 743 __HAL_LOCK(hadc);
mbed_official 610:813dcc80987e 744
mbed_official 610:813dcc80987e 745 /* Enable the ADC peripheral */
mbed_official 610:813dcc80987e 746 tmp_status = ADC_Enable(hadc);
mbed_official 610:813dcc80987e 747
mbed_official 610:813dcc80987e 748 /* Start conversion if ADC is effectively enabled */
mbed_official 610:813dcc80987e 749 if (tmp_status == HAL_OK)
mbed_official 610:813dcc80987e 750 {
mbed_official 610:813dcc80987e 751 /* Check if a regular conversion is ongoing */
mbed_official 610:813dcc80987e 752 if (HAL_IS_BIT_SET(hadc->State, HAL_ADC_STATE_REG_BUSY))
mbed_official 610:813dcc80987e 753 {
mbed_official 610:813dcc80987e 754 /* Reset ADC error code field related to injected conversions only */
mbed_official 610:813dcc80987e 755 CLEAR_BIT(hadc->ErrorCode, HAL_ADC_ERROR_JQOVF);
mbed_official 610:813dcc80987e 756 }
mbed_official 610:813dcc80987e 757 else
mbed_official 610:813dcc80987e 758 {
mbed_official 610:813dcc80987e 759 /* Set ADC error code to none */
mbed_official 610:813dcc80987e 760 ADC_CLEAR_ERRORCODE(hadc);
mbed_official 610:813dcc80987e 761 }
mbed_official 610:813dcc80987e 762 /* Clear HAL_ADC_STATE_READY and HAL_ADC_STATE_INJ_EOC bits, set HAL_ADC_STATE_INJ_BUSY bit */
mbed_official 610:813dcc80987e 763 ADC_STATE_CLR_SET(hadc->State, (HAL_ADC_STATE_READY|HAL_ADC_STATE_INJ_EOC), HAL_ADC_STATE_INJ_BUSY);
mbed_official 610:813dcc80987e 764
mbed_official 610:813dcc80987e 765 /* Reset HAL_ADC_STATE_MULTIMODE_SLAVE bit
mbed_official 610:813dcc80987e 766 - by default if ADC is Master or Independent
mbed_official 610:813dcc80987e 767 - if MultiMode setting is set to independent mode (no dual regular or injected conversions are configured) */
mbed_official 610:813dcc80987e 768 if (ADC_NONMULTIMODE_OR_MULTIMODEMASTER(hadc))
mbed_official 610:813dcc80987e 769 {
mbed_official 610:813dcc80987e 770 CLEAR_BIT(hadc->State, HAL_ADC_STATE_MULTIMODE_SLAVE);
mbed_official 610:813dcc80987e 771 }
mbed_official 610:813dcc80987e 772
mbed_official 610:813dcc80987e 773 /* Clear injected group conversion flag */
mbed_official 610:813dcc80987e 774 /* (To ensure of no unknown state from potential previous ADC operations) */
mbed_official 610:813dcc80987e 775 __HAL_ADC_CLEAR_FLAG(hadc, (ADC_FLAG_JEOC | ADC_FLAG_JEOS));
mbed_official 610:813dcc80987e 776
mbed_official 610:813dcc80987e 777 /* Enable ADC Injected context queue overflow interrupt if this feature */
mbed_official 610:813dcc80987e 778 /* is enabled. */
mbed_official 610:813dcc80987e 779 if ((hadc->Instance->CFGR & ADC_CFGR_JQM) != RESET)
mbed_official 610:813dcc80987e 780 {
mbed_official 610:813dcc80987e 781 __HAL_ADC_ENABLE_IT(hadc, ADC_FLAG_JQOVF);
mbed_official 610:813dcc80987e 782 }
mbed_official 610:813dcc80987e 783
mbed_official 610:813dcc80987e 784 /* Enable ADC end of conversion interrupt */
mbed_official 610:813dcc80987e 785 switch(hadc->Init.EOCSelection)
mbed_official 610:813dcc80987e 786 {
mbed_official 610:813dcc80987e 787 case ADC_EOC_SEQ_CONV:
mbed_official 610:813dcc80987e 788 __HAL_ADC_DISABLE_IT(hadc, ADC_IT_JEOC);
mbed_official 610:813dcc80987e 789 __HAL_ADC_ENABLE_IT(hadc, ADC_IT_JEOS);
mbed_official 610:813dcc80987e 790 break;
mbed_official 610:813dcc80987e 791 /* case ADC_EOC_SINGLE_CONV */
mbed_official 610:813dcc80987e 792 default:
mbed_official 610:813dcc80987e 793 __HAL_ADC_DISABLE_IT(hadc, ADC_IT_JEOS);
mbed_official 610:813dcc80987e 794 __HAL_ADC_ENABLE_IT(hadc, ADC_IT_JEOC);
mbed_official 610:813dcc80987e 795 break;
mbed_official 610:813dcc80987e 796 }
mbed_official 610:813dcc80987e 797
mbed_official 610:813dcc80987e 798 /* Enable conversion of injected group, if automatic injected conversion */
mbed_official 610:813dcc80987e 799 /* is disabled. */
mbed_official 610:813dcc80987e 800 /* If software start has been selected, conversion starts immediately. */
mbed_official 610:813dcc80987e 801 /* If external trigger has been selected, conversion will start at next */
mbed_official 610:813dcc80987e 802 /* trigger event. */
mbed_official 610:813dcc80987e 803 /* Case of multimode enabled: */
mbed_official 610:813dcc80987e 804 /* if ADC is slave, */
mbed_official 610:813dcc80987e 805 /* - ADC is enabled only (conversion is not started), */
mbed_official 610:813dcc80987e 806 /* - if multimode only concerns regular conversion, ADC is enabled */
mbed_official 610:813dcc80987e 807 /* and conversion is started. */
mbed_official 610:813dcc80987e 808 /* If ADC is master or independent, */
mbed_official 610:813dcc80987e 809 /* - ADC is enabled and conversion is started. */
mbed_official 610:813dcc80987e 810
mbed_official 610:813dcc80987e 811 /* Are injected conversions that of a dual Slave ? */
mbed_official 610:813dcc80987e 812 if (ADC_INDEPENDENT_OR_NONMULTIMODEINJECTED_SLAVE(hadc))
mbed_official 610:813dcc80987e 813 {
mbed_official 610:813dcc80987e 814 /* hadc is not the handle of a Slave ADC with dual injected conversions enabled:
mbed_official 610:813dcc80987e 815 set ADSTART only if JAUTO is cleared */
mbed_official 610:813dcc80987e 816 /* Process unlocked */
mbed_official 610:813dcc80987e 817 __HAL_UNLOCK(hadc);
mbed_official 610:813dcc80987e 818 if (HAL_IS_BIT_CLR(hadc->Instance->CFGR, ADC_CFGR_JAUTO))
mbed_official 610:813dcc80987e 819 {
mbed_official 610:813dcc80987e 820 SET_BIT(hadc->Instance->CR, ADC_CR_JADSTART) ;
mbed_official 610:813dcc80987e 821 }
mbed_official 610:813dcc80987e 822 }
mbed_official 610:813dcc80987e 823 else
mbed_official 610:813dcc80987e 824 {
mbed_official 610:813dcc80987e 825 /* hadc is the handle of a Slave ADC with dual injected conversions enabled:
mbed_official 610:813dcc80987e 826 ADSTART is not set */
mbed_official 610:813dcc80987e 827 SET_BIT(hadc->State, HAL_ADC_STATE_MULTIMODE_SLAVE);
mbed_official 610:813dcc80987e 828 /* Process unlocked */
mbed_official 610:813dcc80987e 829 __HAL_UNLOCK(hadc);
mbed_official 610:813dcc80987e 830 }
mbed_official 610:813dcc80987e 831 }
mbed_official 610:813dcc80987e 832 else
mbed_official 610:813dcc80987e 833 {
mbed_official 610:813dcc80987e 834 /* Process unlocked */
mbed_official 610:813dcc80987e 835 __HAL_UNLOCK(hadc);
mbed_official 610:813dcc80987e 836 }
mbed_official 610:813dcc80987e 837
mbed_official 610:813dcc80987e 838 /* Return function status */
mbed_official 610:813dcc80987e 839 return tmp_status;
mbed_official 610:813dcc80987e 840 }
mbed_official 610:813dcc80987e 841 }
mbed_official 610:813dcc80987e 842
mbed_official 610:813dcc80987e 843
mbed_official 610:813dcc80987e 844
mbed_official 610:813dcc80987e 845 /**
mbed_official 610:813dcc80987e 846 * @brief Stop conversion of injected channels, disable interruption of end-of-conversion.
mbed_official 610:813dcc80987e 847 * @note Disable ADC peripheral if no regular conversion
mbed_official 610:813dcc80987e 848 * is on going.
mbed_official 610:813dcc80987e 849 * @note If ADC must be disabled and if regular conversion
mbed_official 610:813dcc80987e 850 * is on going, function HAL_ADC_Stop must be used first.
mbed_official 610:813dcc80987e 851 * @note Case of multimode enabled: HAL_ADCEx_InjectedStop_IT() API
mbed_official 610:813dcc80987e 852 * must be called for ADC master first, then ADC slave.
mbed_official 610:813dcc80987e 853 * For ADC master, conversion is stopped and ADC is disabled.
mbed_official 610:813dcc80987e 854 * For ADC slave, ADC is disabled only (conversion stop of ADC master
mbed_official 610:813dcc80987e 855 * has already stopped conversion of ADC slave).
mbed_official 610:813dcc80987e 856 * @note In case of auto-injection mode, HAL_ADC_Stop() must be used.
mbed_official 610:813dcc80987e 857 * @param hadc: ADC handle
mbed_official 610:813dcc80987e 858 * @retval None
mbed_official 610:813dcc80987e 859 */
mbed_official 610:813dcc80987e 860 HAL_StatusTypeDef HAL_ADCEx_InjectedStop_IT(ADC_HandleTypeDef* hadc)
mbed_official 610:813dcc80987e 861 {
mbed_official 610:813dcc80987e 862 HAL_StatusTypeDef tmp_status = HAL_OK;
mbed_official 610:813dcc80987e 863
mbed_official 610:813dcc80987e 864 /* Check the parameters */
mbed_official 610:813dcc80987e 865 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 610:813dcc80987e 866
mbed_official 610:813dcc80987e 867 /* Process locked */
mbed_official 610:813dcc80987e 868 __HAL_LOCK(hadc);
mbed_official 610:813dcc80987e 869
mbed_official 610:813dcc80987e 870 /* 1. Stop potential conversion on going on injected group only. */
mbed_official 610:813dcc80987e 871 tmp_status = ADC_ConversionStop(hadc, ADC_INJECTED_GROUP);
mbed_official 610:813dcc80987e 872
mbed_official 610:813dcc80987e 873 /* Disable ADC peripheral if injected conversions are effectively stopped */
mbed_official 610:813dcc80987e 874 /* and if no conversion on the other group (regular group) is intended to */
mbed_official 610:813dcc80987e 875 /* continue. */
mbed_official 610:813dcc80987e 876 if (tmp_status == HAL_OK)
mbed_official 610:813dcc80987e 877 {
mbed_official 610:813dcc80987e 878 /* Disable ADC end of conversion interrupt for injected channels */
mbed_official 610:813dcc80987e 879 __HAL_ADC_DISABLE_IT(hadc, (ADC_IT_JEOC | ADC_IT_JEOS | ADC_FLAG_JQOVF));
mbed_official 610:813dcc80987e 880
mbed_official 610:813dcc80987e 881 if ((ADC_IS_CONVERSION_ONGOING_REGULAR(hadc) == RESET))
mbed_official 610:813dcc80987e 882 {
mbed_official 610:813dcc80987e 883 /* 2. Disable the ADC peripheral */
mbed_official 610:813dcc80987e 884 tmp_status = ADC_Disable(hadc);
mbed_official 610:813dcc80987e 885
mbed_official 610:813dcc80987e 886 /* Check if ADC is effectively disabled */
mbed_official 610:813dcc80987e 887 if (tmp_status == HAL_OK)
mbed_official 610:813dcc80987e 888 {
mbed_official 610:813dcc80987e 889 /* Change ADC state */
mbed_official 610:813dcc80987e 890 /* Clear HAL_ADC_STATE_REG_BUSY and HAL_ADC_STATE_INJ_BUSY bits, set HAL_ADC_STATE_READY bit */
mbed_official 610:813dcc80987e 891 ADC_STATE_CLR_SET(hadc->State, (HAL_ADC_STATE_REG_BUSY|HAL_ADC_STATE_INJ_BUSY), HAL_ADC_STATE_READY);
mbed_official 610:813dcc80987e 892 }
mbed_official 610:813dcc80987e 893 }
mbed_official 610:813dcc80987e 894 /* Conversion on injected group is stopped, but ADC not disabled since */
mbed_official 610:813dcc80987e 895 /* conversion on regular group is still running. */
mbed_official 610:813dcc80987e 896 else
mbed_official 610:813dcc80987e 897 {
mbed_official 610:813dcc80987e 898 /* Clear HAL_ADC_STATE_INJ_BUSY bit */
mbed_official 610:813dcc80987e 899 CLEAR_BIT(hadc->State, HAL_ADC_STATE_INJ_BUSY);
mbed_official 610:813dcc80987e 900 }
mbed_official 610:813dcc80987e 901 }
mbed_official 610:813dcc80987e 902
mbed_official 610:813dcc80987e 903 /* Process unlocked */
mbed_official 610:813dcc80987e 904 __HAL_UNLOCK(hadc);
mbed_official 610:813dcc80987e 905
mbed_official 610:813dcc80987e 906 /* Return function status */
mbed_official 610:813dcc80987e 907 return tmp_status;
mbed_official 610:813dcc80987e 908 }
mbed_official 610:813dcc80987e 909
mbed_official 610:813dcc80987e 910
mbed_official 610:813dcc80987e 911
mbed_official 610:813dcc80987e 912 /**
mbed_official 610:813dcc80987e 913 * @brief Enable ADC, start MultiMode conversion and transfer regular results through DMA.
mbed_official 610:813dcc80987e 914 * @note Multimode must have been previously configured using
mbed_official 610:813dcc80987e 915 * HAL_ADCEx_MultiModeConfigChannel() function.
mbed_official 610:813dcc80987e 916 * Interruptions enabled in this function:
mbed_official 610:813dcc80987e 917 * overrun, DMA half transfer, DMA transfer complete.
mbed_official 610:813dcc80987e 918 * Each of these interruptions has its dedicated callback function.
mbed_official 610:813dcc80987e 919 * @note State field of Slave ADC handle is not updated in this configuration:
mbed_official 610:813dcc80987e 920 * user should not rely on it for information related to Slave regular
mbed_official 610:813dcc80987e 921 * conversions.
mbed_official 610:813dcc80987e 922 * @param hadc: ADC handle of ADC master (handle of ADC slave must not be used)
mbed_official 610:813dcc80987e 923 * @param pData: Destination Buffer address.
mbed_official 610:813dcc80987e 924 * @param Length: Length of data to be transferred from ADC peripheral to memory (in bytes).
mbed_official 610:813dcc80987e 925 * @retval None
mbed_official 610:813dcc80987e 926 */
mbed_official 610:813dcc80987e 927 HAL_StatusTypeDef HAL_ADCEx_MultiModeStart_DMA(ADC_HandleTypeDef* hadc, uint32_t* pData, uint32_t Length)
mbed_official 610:813dcc80987e 928 {
mbed_official 610:813dcc80987e 929 HAL_StatusTypeDef tmp_status = HAL_OK;
mbed_official 610:813dcc80987e 930 ADC_HandleTypeDef tmphadcSlave;
mbed_official 610:813dcc80987e 931 ADC_Common_TypeDef *tmpADC_Common;
mbed_official 610:813dcc80987e 932
mbed_official 610:813dcc80987e 933 /* Check the parameters */
mbed_official 610:813dcc80987e 934 assert_param(IS_ADC_MULTIMODE_MASTER_INSTANCE(hadc->Instance));
mbed_official 610:813dcc80987e 935 assert_param(IS_FUNCTIONAL_STATE(hadc->Init.ContinuousConvMode));
mbed_official 610:813dcc80987e 936 assert_param(IS_ADC_EXTTRIG_EDGE(hadc->Init.ExternalTrigConvEdge));
mbed_official 610:813dcc80987e 937 assert_param(IS_FUNCTIONAL_STATE(hadc->Init.DMAContinuousRequests));
mbed_official 610:813dcc80987e 938
mbed_official 610:813dcc80987e 939 if (ADC_IS_CONVERSION_ONGOING_REGULAR(hadc))
mbed_official 610:813dcc80987e 940 {
mbed_official 610:813dcc80987e 941 return HAL_BUSY;
mbed_official 610:813dcc80987e 942 }
mbed_official 610:813dcc80987e 943 else
mbed_official 610:813dcc80987e 944 {
mbed_official 610:813dcc80987e 945 /* Process locked */
mbed_official 610:813dcc80987e 946 __HAL_LOCK(hadc);
mbed_official 610:813dcc80987e 947
mbed_official 610:813dcc80987e 948 /* Set a temporary handle of the ADC slave associated to the ADC master */
mbed_official 610:813dcc80987e 949 ADC_MULTI_SLAVE(hadc, &tmphadcSlave);
mbed_official 610:813dcc80987e 950
mbed_official 610:813dcc80987e 951 if (tmphadcSlave.Instance == NULL)
mbed_official 610:813dcc80987e 952 {
mbed_official 610:813dcc80987e 953 /* Update ADC state machine to error */
mbed_official 610:813dcc80987e 954 SET_BIT(hadc->State, HAL_ADC_STATE_ERROR_CONFIG);
mbed_official 610:813dcc80987e 955
mbed_official 610:813dcc80987e 956 /* Process unlocked */
mbed_official 610:813dcc80987e 957 __HAL_UNLOCK(hadc);
mbed_official 610:813dcc80987e 958
mbed_official 610:813dcc80987e 959 return HAL_ERROR;
mbed_official 610:813dcc80987e 960 }
mbed_official 610:813dcc80987e 961
mbed_official 610:813dcc80987e 962
mbed_official 610:813dcc80987e 963 /* Enable the ADC peripherals: master and slave (in case if not already */
mbed_official 610:813dcc80987e 964 /* enabled previously) */
mbed_official 610:813dcc80987e 965 tmp_status = ADC_Enable(hadc);
mbed_official 610:813dcc80987e 966 if (tmp_status == HAL_OK)
mbed_official 610:813dcc80987e 967 {
mbed_official 610:813dcc80987e 968 tmp_status = ADC_Enable(&tmphadcSlave);
mbed_official 610:813dcc80987e 969 }
mbed_official 610:813dcc80987e 970
mbed_official 610:813dcc80987e 971 /* Start multimode conversion of ADCs pair */
mbed_official 610:813dcc80987e 972 if (tmp_status == HAL_OK)
mbed_official 610:813dcc80987e 973 {
mbed_official 610:813dcc80987e 974 /* Update Master State */
mbed_official 610:813dcc80987e 975 /* Clear HAL_ADC_STATE_READY and regular conversion results bits, set HAL_ADC_STATE_REG_BUSY bit */
mbed_official 610:813dcc80987e 976 ADC_STATE_CLR_SET(hadc->State, (HAL_ADC_STATE_READY|HAL_ADC_STATE_REG_EOC|HAL_ADC_STATE_REG_OVR|HAL_ADC_STATE_REG_EOSMP), HAL_ADC_STATE_REG_BUSY);
mbed_official 610:813dcc80987e 977
mbed_official 610:813dcc80987e 978
mbed_official 610:813dcc80987e 979 /* Set ADC error code to none */
mbed_official 610:813dcc80987e 980 ADC_CLEAR_ERRORCODE(hadc);
mbed_official 610:813dcc80987e 981
mbed_official 610:813dcc80987e 982
mbed_official 610:813dcc80987e 983 /* Set the DMA transfer complete callback */
mbed_official 610:813dcc80987e 984 hadc->DMA_Handle->XferCpltCallback = ADC_DMAConvCplt;
mbed_official 610:813dcc80987e 985
mbed_official 610:813dcc80987e 986 /* Set the DMA half transfer complete callback */
mbed_official 610:813dcc80987e 987 hadc->DMA_Handle->XferHalfCpltCallback = ADC_DMAHalfConvCplt;
mbed_official 610:813dcc80987e 988
mbed_official 610:813dcc80987e 989 /* Set the DMA error callback */
mbed_official 610:813dcc80987e 990 hadc->DMA_Handle->XferErrorCallback = ADC_DMAError ;
mbed_official 610:813dcc80987e 991
mbed_official 610:813dcc80987e 992 /* Pointer to the common control register */
mbed_official 610:813dcc80987e 993 tmpADC_Common = ADC_COMMON_REGISTER(hadc);
mbed_official 610:813dcc80987e 994
mbed_official 610:813dcc80987e 995
mbed_official 610:813dcc80987e 996 /* Manage ADC and DMA start: ADC overrun interruption, DMA start, ADC */
mbed_official 610:813dcc80987e 997 /* start (in case of SW start): */
mbed_official 610:813dcc80987e 998
mbed_official 610:813dcc80987e 999 /* Clear regular group conversion flag and overrun flag */
mbed_official 610:813dcc80987e 1000 /* (To ensure of no unknown state from potential previous ADC operations) */
mbed_official 610:813dcc80987e 1001 __HAL_ADC_CLEAR_FLAG(hadc, (ADC_FLAG_EOC | ADC_FLAG_EOS | ADC_FLAG_OVR));
mbed_official 610:813dcc80987e 1002
mbed_official 610:813dcc80987e 1003 /* Enable ADC overrun interrupt */
mbed_official 610:813dcc80987e 1004 __HAL_ADC_ENABLE_IT(hadc, ADC_IT_OVR);
mbed_official 610:813dcc80987e 1005
mbed_official 610:813dcc80987e 1006 /* Start the DMA channel */
mbed_official 610:813dcc80987e 1007 HAL_DMA_Start_IT(hadc->DMA_Handle, (uint32_t)&tmpADC_Common->CDR, (uint32_t)pData, Length);
mbed_official 610:813dcc80987e 1008
mbed_official 610:813dcc80987e 1009 /* Enable conversion of regular group. */
mbed_official 610:813dcc80987e 1010 /* Process unlocked */
mbed_official 610:813dcc80987e 1011 __HAL_UNLOCK(hadc);
mbed_official 610:813dcc80987e 1012 /* If software start has been selected, conversion starts immediately. */
mbed_official 610:813dcc80987e 1013 /* If external trigger has been selected, conversion will start at next */
mbed_official 610:813dcc80987e 1014 /* trigger event. */
mbed_official 610:813dcc80987e 1015 SET_BIT(hadc->Instance->CR, ADC_CR_ADSTART);
mbed_official 610:813dcc80987e 1016
mbed_official 610:813dcc80987e 1017 }
mbed_official 610:813dcc80987e 1018 else
mbed_official 610:813dcc80987e 1019 {
mbed_official 610:813dcc80987e 1020 /* Process unlocked */
mbed_official 610:813dcc80987e 1021 __HAL_UNLOCK(hadc);
mbed_official 610:813dcc80987e 1022 }
mbed_official 610:813dcc80987e 1023
mbed_official 610:813dcc80987e 1024 /* Return function status */
mbed_official 610:813dcc80987e 1025 return tmp_status;
mbed_official 610:813dcc80987e 1026 }
mbed_official 610:813dcc80987e 1027 }
mbed_official 610:813dcc80987e 1028
mbed_official 610:813dcc80987e 1029 /**
mbed_official 610:813dcc80987e 1030 * @brief Stop MultiMode ADC conversion, disable ADC DMA transfer, disable ADC peripheral.
mbed_official 610:813dcc80987e 1031 * @note MultiMode is kept enabled after this function. MultiMode DMA bits
mbed_official 610:813dcc80987e 1032 * (MDMA and DMACFG bits of common CCR register) are maintained. To disable
mbed_official 610:813dcc80987e 1033 * MultiMode (set with HAL_ADCEx_MultiModeConfigChannel()), ADC must be
mbed_official 610:813dcc80987e 1034 * reinitialized using HAL_ADC_Init() or HAL_ADC_DeInit(), or the user can
mbed_official 610:813dcc80987e 1035 * resort to HAL_ADCEx_DisableMultiMode() API.
mbed_official 610:813dcc80987e 1036 * @note In case of DMA configured in circular mode, function
mbed_official 610:813dcc80987e 1037 * HAL_ADC_Stop_DMA() must be called after this function with handle of
mbed_official 610:813dcc80987e 1038 * ADC slave, to properly disable the DMA channel.
mbed_official 610:813dcc80987e 1039 * @param hadc: ADC handle of ADC master (handle of ADC slave must not be used)
mbed_official 610:813dcc80987e 1040 * @retval None
mbed_official 610:813dcc80987e 1041 */
mbed_official 610:813dcc80987e 1042 HAL_StatusTypeDef HAL_ADCEx_MultiModeStop_DMA(ADC_HandleTypeDef* hadc)
mbed_official 610:813dcc80987e 1043 {
mbed_official 610:813dcc80987e 1044 HAL_StatusTypeDef tmp_status = HAL_OK;
mbed_official 610:813dcc80987e 1045 uint32_t tickstart;
mbed_official 610:813dcc80987e 1046 ADC_HandleTypeDef tmphadcSlave;
mbed_official 610:813dcc80987e 1047
mbed_official 610:813dcc80987e 1048 /* Check the parameters */
mbed_official 610:813dcc80987e 1049 assert_param(IS_ADC_MULTIMODE_MASTER_INSTANCE(hadc->Instance));
mbed_official 610:813dcc80987e 1050
mbed_official 610:813dcc80987e 1051 /* Process locked */
mbed_official 610:813dcc80987e 1052 __HAL_LOCK(hadc);
mbed_official 610:813dcc80987e 1053
mbed_official 610:813dcc80987e 1054
mbed_official 610:813dcc80987e 1055 /* 1. Stop potential multimode conversion on going, on regular and injected groups */
mbed_official 610:813dcc80987e 1056 tmp_status = ADC_ConversionStop(hadc, ADC_REGULAR_INJECTED_GROUP);
mbed_official 610:813dcc80987e 1057
mbed_official 610:813dcc80987e 1058 /* Disable ADC peripheral if conversions are effectively stopped */
mbed_official 610:813dcc80987e 1059 if (tmp_status == HAL_OK)
mbed_official 610:813dcc80987e 1060 {
mbed_official 610:813dcc80987e 1061 /* Set a temporary handle of the ADC slave associated to the ADC master */
mbed_official 610:813dcc80987e 1062 ADC_MULTI_SLAVE(hadc, &tmphadcSlave);
mbed_official 610:813dcc80987e 1063
mbed_official 610:813dcc80987e 1064 if (tmphadcSlave.Instance == NULL)
mbed_official 610:813dcc80987e 1065 {
mbed_official 610:813dcc80987e 1066 /* Update ADC state machine to error */
mbed_official 610:813dcc80987e 1067 SET_BIT(hadc->State, HAL_ADC_STATE_ERROR_CONFIG);
mbed_official 610:813dcc80987e 1068
mbed_official 610:813dcc80987e 1069 /* Process unlocked */
mbed_official 610:813dcc80987e 1070 __HAL_UNLOCK(hadc);
mbed_official 610:813dcc80987e 1071
mbed_official 610:813dcc80987e 1072 return HAL_ERROR;
mbed_official 610:813dcc80987e 1073 }
mbed_official 610:813dcc80987e 1074
mbed_official 610:813dcc80987e 1075 /* Procedure to disable the ADC peripheral: wait for conversions */
mbed_official 610:813dcc80987e 1076 /* effectively stopped (ADC master and ADC slave), then disable ADC */
mbed_official 610:813dcc80987e 1077
mbed_official 610:813dcc80987e 1078 /* 1. Wait until ADSTP=0 for ADC master and ADC slave*/
mbed_official 610:813dcc80987e 1079 tickstart = HAL_GetTick();
mbed_official 610:813dcc80987e 1080
mbed_official 610:813dcc80987e 1081 while(ADC_IS_CONVERSION_ONGOING_REGULAR(hadc) ||
mbed_official 610:813dcc80987e 1082 ADC_IS_CONVERSION_ONGOING_REGULAR(&tmphadcSlave) )
mbed_official 610:813dcc80987e 1083 {
mbed_official 610:813dcc80987e 1084 if((HAL_GetTick()-tickstart) > ADC_STOP_CONVERSION_TIMEOUT)
mbed_official 610:813dcc80987e 1085 {
mbed_official 610:813dcc80987e 1086 /* Update ADC state machine to error */
mbed_official 610:813dcc80987e 1087 SET_BIT(hadc->State, HAL_ADC_STATE_ERROR_INTERNAL);
mbed_official 610:813dcc80987e 1088
mbed_official 610:813dcc80987e 1089 /* Process unlocked */
mbed_official 610:813dcc80987e 1090 __HAL_UNLOCK(hadc);
mbed_official 610:813dcc80987e 1091
mbed_official 610:813dcc80987e 1092 return HAL_ERROR;
mbed_official 610:813dcc80987e 1093 }
mbed_official 610:813dcc80987e 1094 }
mbed_official 610:813dcc80987e 1095
mbed_official 610:813dcc80987e 1096 /* Disable the DMA channel (in case of DMA in circular mode or stop */
mbed_official 610:813dcc80987e 1097 /* while DMA transfer is on going) */
mbed_official 610:813dcc80987e 1098 /* Note: DMA channel of ADC slave should be stopped after this function */
mbed_official 610:813dcc80987e 1099 /* with HAL_ADC_Stop_DMA() API. */
mbed_official 610:813dcc80987e 1100 tmp_status = HAL_DMA_Abort(hadc->DMA_Handle);
mbed_official 610:813dcc80987e 1101
mbed_official 610:813dcc80987e 1102 /* Check if DMA channel effectively disabled */
mbed_official 610:813dcc80987e 1103 if (tmp_status == HAL_ERROR)
mbed_official 610:813dcc80987e 1104 {
mbed_official 610:813dcc80987e 1105 /* Update ADC state machine to error */
mbed_official 610:813dcc80987e 1106 SET_BIT(hadc->State, HAL_ADC_STATE_ERROR_DMA);
mbed_official 610:813dcc80987e 1107 }
mbed_official 610:813dcc80987e 1108
mbed_official 610:813dcc80987e 1109 /* Disable ADC overrun interrupt */
mbed_official 610:813dcc80987e 1110 __HAL_ADC_DISABLE_IT(hadc, ADC_IT_OVR);
mbed_official 610:813dcc80987e 1111
mbed_official 610:813dcc80987e 1112
mbed_official 610:813dcc80987e 1113
mbed_official 610:813dcc80987e 1114 /* 2. Disable the ADC peripherals: master and slave */
mbed_official 610:813dcc80987e 1115 /* Update "tmp_status" only if DMA channel disabling passed, to keep in */
mbed_official 610:813dcc80987e 1116 /* memory a potential failing status. */
mbed_official 610:813dcc80987e 1117 if (tmp_status == HAL_OK)
mbed_official 610:813dcc80987e 1118 {
mbed_official 610:813dcc80987e 1119 /* Check if ADC are effectively disabled */
mbed_official 610:813dcc80987e 1120 if ((ADC_Disable(hadc) == HAL_OK) &&
mbed_official 610:813dcc80987e 1121 (ADC_Disable(&tmphadcSlave) == HAL_OK) )
mbed_official 610:813dcc80987e 1122 {
mbed_official 610:813dcc80987e 1123 tmp_status = HAL_OK;
mbed_official 610:813dcc80987e 1124 }
mbed_official 610:813dcc80987e 1125 }
mbed_official 610:813dcc80987e 1126 else
mbed_official 610:813dcc80987e 1127 {
mbed_official 610:813dcc80987e 1128 ADC_Disable(hadc);
mbed_official 610:813dcc80987e 1129 ADC_Disable(&tmphadcSlave);
mbed_official 610:813dcc80987e 1130 }
mbed_official 610:813dcc80987e 1131 /* Change ADC state (ADC master) */
mbed_official 610:813dcc80987e 1132 /* Clear HAL_ADC_STATE_REG_BUSY and HAL_ADC_STATE_INJ_BUSY bits, set HAL_ADC_STATE_READY bit */
mbed_official 610:813dcc80987e 1133 ADC_STATE_CLR_SET(hadc->State, (HAL_ADC_STATE_REG_BUSY|HAL_ADC_STATE_INJ_BUSY), HAL_ADC_STATE_READY);
mbed_official 610:813dcc80987e 1134
mbed_official 610:813dcc80987e 1135 }
mbed_official 610:813dcc80987e 1136
mbed_official 610:813dcc80987e 1137 /* Process unlocked */
mbed_official 610:813dcc80987e 1138 __HAL_UNLOCK(hadc);
mbed_official 610:813dcc80987e 1139
mbed_official 610:813dcc80987e 1140 /* Return function status */
mbed_official 610:813dcc80987e 1141 return tmp_status;
mbed_official 610:813dcc80987e 1142 }
mbed_official 610:813dcc80987e 1143
mbed_official 610:813dcc80987e 1144
mbed_official 610:813dcc80987e 1145 /**
mbed_official 610:813dcc80987e 1146 * @brief Return the last ADC Master and Slave regular conversions results when in MultiMode configuration.
mbed_official 610:813dcc80987e 1147 * @param hadc: ADC handle of ADC Master (handle of ADC Slave must not be used)
mbed_official 610:813dcc80987e 1148 * @retval The converted data values.
mbed_official 610:813dcc80987e 1149 */
mbed_official 610:813dcc80987e 1150 uint32_t HAL_ADCEx_MultiModeGetValue(ADC_HandleTypeDef* hadc)
mbed_official 610:813dcc80987e 1151 {
mbed_official 610:813dcc80987e 1152 ADC_Common_TypeDef *tmpADC_Common;
mbed_official 610:813dcc80987e 1153
mbed_official 610:813dcc80987e 1154 /* Check the parameters */
mbed_official 610:813dcc80987e 1155 assert_param(IS_ADC_MULTIMODE_MASTER_INSTANCE(hadc->Instance));
mbed_official 610:813dcc80987e 1156
mbed_official 610:813dcc80987e 1157 /* Pointer to the common control register */
mbed_official 610:813dcc80987e 1158 tmpADC_Common = ADC_COMMON_REGISTER(hadc);
mbed_official 610:813dcc80987e 1159
mbed_official 610:813dcc80987e 1160 /* Return the multi mode conversion value */
mbed_official 610:813dcc80987e 1161 return tmpADC_Common->CDR;
mbed_official 610:813dcc80987e 1162 }
mbed_official 610:813dcc80987e 1163
mbed_official 610:813dcc80987e 1164
mbed_official 610:813dcc80987e 1165 /**
mbed_official 610:813dcc80987e 1166 * @brief Get ADC injected group conversion result.
mbed_official 610:813dcc80987e 1167 * @param hadc: ADC handle
mbed_official 610:813dcc80987e 1168 * @param InjectedRank: the converted ADC injected rank.
mbed_official 610:813dcc80987e 1169 * This parameter can be one of the following values:
mbed_official 610:813dcc80987e 1170 * @arg ADC_INJECTED_RANK_1: Injected Channel1 selected
mbed_official 610:813dcc80987e 1171 * @arg ADC_INJECTED_RANK_2: Injected Channel2 selected
mbed_official 610:813dcc80987e 1172 * @arg ADC_INJECTED_RANK_3: Injected Channel3 selected
mbed_official 610:813dcc80987e 1173 * @arg ADC_INJECTED_RANK_4: Injected Channel4 selected
mbed_official 610:813dcc80987e 1174 * @note Reading JDRy register automatically clears JEOC flag. To reset JEOS
mbed_official 610:813dcc80987e 1175 * flag the user must resort to the macro
mbed_official 610:813dcc80987e 1176 * __HAL_ADC_CLEAR_FLAG(hadc, ADC_FLAG_JEOS).
mbed_official 610:813dcc80987e 1177 * @retval None
mbed_official 610:813dcc80987e 1178 */
mbed_official 610:813dcc80987e 1179 uint32_t HAL_ADCEx_InjectedGetValue(ADC_HandleTypeDef* hadc, uint32_t InjectedRank)
mbed_official 610:813dcc80987e 1180 {
mbed_official 610:813dcc80987e 1181 uint32_t tmp_jdr = 0;
mbed_official 610:813dcc80987e 1182
mbed_official 610:813dcc80987e 1183 /* Check the parameters */
mbed_official 610:813dcc80987e 1184 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 610:813dcc80987e 1185 assert_param(IS_ADC_INJECTED_RANK(InjectedRank));
mbed_official 610:813dcc80987e 1186
mbed_official 610:813dcc80987e 1187
mbed_official 610:813dcc80987e 1188 /* Get ADC converted value */
mbed_official 610:813dcc80987e 1189 switch(InjectedRank)
mbed_official 610:813dcc80987e 1190 {
mbed_official 610:813dcc80987e 1191 case ADC_INJECTED_RANK_4:
mbed_official 610:813dcc80987e 1192 tmp_jdr = hadc->Instance->JDR4;
mbed_official 610:813dcc80987e 1193 break;
mbed_official 610:813dcc80987e 1194 case ADC_INJECTED_RANK_3:
mbed_official 610:813dcc80987e 1195 tmp_jdr = hadc->Instance->JDR3;
mbed_official 610:813dcc80987e 1196 break;
mbed_official 610:813dcc80987e 1197 case ADC_INJECTED_RANK_2:
mbed_official 610:813dcc80987e 1198 tmp_jdr = hadc->Instance->JDR2;
mbed_official 610:813dcc80987e 1199 break;
mbed_official 610:813dcc80987e 1200 case ADC_INJECTED_RANK_1:
mbed_official 610:813dcc80987e 1201 default:
mbed_official 610:813dcc80987e 1202 tmp_jdr = hadc->Instance->JDR1;
mbed_official 610:813dcc80987e 1203 break;
mbed_official 610:813dcc80987e 1204 }
mbed_official 610:813dcc80987e 1205
mbed_official 610:813dcc80987e 1206 /* Return ADC converted value */
mbed_official 610:813dcc80987e 1207 return tmp_jdr;
mbed_official 610:813dcc80987e 1208 }
mbed_official 610:813dcc80987e 1209
mbed_official 610:813dcc80987e 1210 /**
mbed_official 610:813dcc80987e 1211 * @brief Injected conversion complete callback in non-blocking mode.
mbed_official 610:813dcc80987e 1212 * @param hadc: ADC handle
mbed_official 610:813dcc80987e 1213 * @retval None
mbed_official 610:813dcc80987e 1214 */
mbed_official 610:813dcc80987e 1215 __weak void HAL_ADCEx_InjectedConvCpltCallback(ADC_HandleTypeDef* hadc)
mbed_official 610:813dcc80987e 1216 {
mbed_official 610:813dcc80987e 1217 /* NOTE : This function should not be modified. When the callback is needed,
mbed_official 610:813dcc80987e 1218 function HAL_ADCEx_InjectedConvCpltCallback must be implemented in the user file.
mbed_official 610:813dcc80987e 1219 */
mbed_official 610:813dcc80987e 1220 }
mbed_official 610:813dcc80987e 1221
mbed_official 610:813dcc80987e 1222
mbed_official 610:813dcc80987e 1223 /**
mbed_official 610:813dcc80987e 1224 * @brief Injected context queue overflow callback.
mbed_official 610:813dcc80987e 1225 * @note This callback is called if injected context queue is enabled
mbed_official 610:813dcc80987e 1226 (parameter "QueueInjectedContext" in injected channel configuration)
mbed_official 610:813dcc80987e 1227 and if a new injected context is set when queue is full (maximum 2
mbed_official 610:813dcc80987e 1228 contexts).
mbed_official 610:813dcc80987e 1229 * @param hadc: ADC handle
mbed_official 610:813dcc80987e 1230 * @retval None
mbed_official 610:813dcc80987e 1231 */
mbed_official 610:813dcc80987e 1232 __weak void HAL_ADCEx_InjectedQueueOverflowCallback(ADC_HandleTypeDef* hadc)
mbed_official 610:813dcc80987e 1233 {
mbed_official 610:813dcc80987e 1234 /* NOTE : This function should not be modified. When the callback is needed,
mbed_official 610:813dcc80987e 1235 function HAL_ADCEx_InjectedQueueOverflowCallback must be implemented in the user file.
mbed_official 610:813dcc80987e 1236 */
mbed_official 610:813dcc80987e 1237 }
mbed_official 610:813dcc80987e 1238
mbed_official 610:813dcc80987e 1239 /**
mbed_official 610:813dcc80987e 1240 * @brief Analog watchdog 2 callback in non-blocking mode.
mbed_official 610:813dcc80987e 1241 * @param hadc: ADC handle
mbed_official 610:813dcc80987e 1242 * @retval None
mbed_official 610:813dcc80987e 1243 */
mbed_official 610:813dcc80987e 1244 __weak void HAL_ADCEx_LevelOutOfWindow2Callback(ADC_HandleTypeDef* hadc)
mbed_official 610:813dcc80987e 1245 {
mbed_official 610:813dcc80987e 1246 /* NOTE : This function should not be modified. When the callback is needed,
mbed_official 610:813dcc80987e 1247 function HAL_ADCEx_LevelOutOfWindow2Callback must be implemented in the user file.
mbed_official 610:813dcc80987e 1248 */
mbed_official 610:813dcc80987e 1249 }
mbed_official 610:813dcc80987e 1250
mbed_official 610:813dcc80987e 1251 /**
mbed_official 610:813dcc80987e 1252 * @brief Analog watchdog 3 callback in non-blocking mode.
mbed_official 610:813dcc80987e 1253 * @param hadc: ADC handle
mbed_official 610:813dcc80987e 1254 * @retval None
mbed_official 610:813dcc80987e 1255 */
mbed_official 610:813dcc80987e 1256 __weak void HAL_ADCEx_LevelOutOfWindow3Callback(ADC_HandleTypeDef* hadc)
mbed_official 610:813dcc80987e 1257 {
mbed_official 610:813dcc80987e 1258 /* NOTE : This function should not be modified. When the callback is needed,
mbed_official 610:813dcc80987e 1259 function HAL_ADCEx_LevelOutOfWindow3Callback must be implemented in the user file.
mbed_official 610:813dcc80987e 1260 */
mbed_official 610:813dcc80987e 1261 }
mbed_official 610:813dcc80987e 1262
mbed_official 610:813dcc80987e 1263
mbed_official 610:813dcc80987e 1264 /**
mbed_official 610:813dcc80987e 1265 * @brief End Of Sampling callback in non-blocking mode.
mbed_official 610:813dcc80987e 1266 * @param hadc: ADC handle
mbed_official 610:813dcc80987e 1267 * @retval None
mbed_official 610:813dcc80987e 1268 */
mbed_official 610:813dcc80987e 1269 __weak void HAL_ADCEx_EndOfSamplingCallback(ADC_HandleTypeDef* hadc)
mbed_official 610:813dcc80987e 1270 {
mbed_official 610:813dcc80987e 1271 /* NOTE : This function should not be modified. When the callback is needed,
mbed_official 610:813dcc80987e 1272 function HAL_ADCEx_EndOfSamplingCallback must be implemented in the user file.
mbed_official 610:813dcc80987e 1273 */
mbed_official 610:813dcc80987e 1274 }
mbed_official 610:813dcc80987e 1275
mbed_official 610:813dcc80987e 1276
mbed_official 610:813dcc80987e 1277
mbed_official 610:813dcc80987e 1278 /**
mbed_official 610:813dcc80987e 1279 * @brief Stop ADC conversion of regular groups, disable ADC peripheral if no injected conversion is on-going.
mbed_official 610:813dcc80987e 1280 * @param hadc: ADC handle
mbed_official 610:813dcc80987e 1281 * @retval HAL status.
mbed_official 610:813dcc80987e 1282 */
mbed_official 610:813dcc80987e 1283 HAL_StatusTypeDef HAL_ADCEx_RegularStop(ADC_HandleTypeDef* hadc)
mbed_official 610:813dcc80987e 1284 {
mbed_official 610:813dcc80987e 1285 HAL_StatusTypeDef tmp_status = HAL_OK;
mbed_official 610:813dcc80987e 1286
mbed_official 610:813dcc80987e 1287 /* Check the parameters */
mbed_official 610:813dcc80987e 1288 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 610:813dcc80987e 1289
mbed_official 610:813dcc80987e 1290 /* Process locked */
mbed_official 610:813dcc80987e 1291 __HAL_LOCK(hadc);
mbed_official 610:813dcc80987e 1292
mbed_official 610:813dcc80987e 1293 /* 1. Stop potential regular conversion on going */
mbed_official 610:813dcc80987e 1294 tmp_status = ADC_ConversionStop(hadc, ADC_REGULAR_GROUP);
mbed_official 610:813dcc80987e 1295
mbed_official 610:813dcc80987e 1296 /* Disable ADC peripheral if regular conversions are effectively stopped
mbed_official 610:813dcc80987e 1297 and if no injected conversions are on-going */
mbed_official 610:813dcc80987e 1298 if (tmp_status == HAL_OK)
mbed_official 610:813dcc80987e 1299 {
mbed_official 610:813dcc80987e 1300 /* Clear HAL_ADC_STATE_REG_BUSY bit */
mbed_official 610:813dcc80987e 1301 CLEAR_BIT(hadc->State, HAL_ADC_STATE_REG_BUSY);
mbed_official 610:813dcc80987e 1302
mbed_official 610:813dcc80987e 1303 if (ADC_IS_CONVERSION_ONGOING_INJECTED(hadc) == RESET)
mbed_official 610:813dcc80987e 1304 {
mbed_official 610:813dcc80987e 1305 /* 2. Disable the ADC peripheral */
mbed_official 610:813dcc80987e 1306 tmp_status = ADC_Disable(hadc);
mbed_official 610:813dcc80987e 1307
mbed_official 610:813dcc80987e 1308 /* Check if ADC is effectively disabled */
mbed_official 610:813dcc80987e 1309 if (tmp_status == HAL_OK)
mbed_official 610:813dcc80987e 1310 {
mbed_official 610:813dcc80987e 1311 /* Change ADC state */
mbed_official 610:813dcc80987e 1312 /* Clear HAL_ADC_STATE_INJ_BUSY bit, set HAL_ADC_STATE_READY bit */
mbed_official 610:813dcc80987e 1313 ADC_STATE_CLR_SET(hadc->State, HAL_ADC_STATE_INJ_BUSY, HAL_ADC_STATE_READY);
mbed_official 610:813dcc80987e 1314 }
mbed_official 610:813dcc80987e 1315 }
mbed_official 610:813dcc80987e 1316 /* Conversion on injected group is stopped, but ADC not disabled since */
mbed_official 610:813dcc80987e 1317 /* conversion on regular group is still running. */
mbed_official 610:813dcc80987e 1318 else
mbed_official 610:813dcc80987e 1319 {
mbed_official 610:813dcc80987e 1320 SET_BIT(hadc->State, HAL_ADC_STATE_INJ_BUSY);
mbed_official 610:813dcc80987e 1321 }
mbed_official 610:813dcc80987e 1322 }
mbed_official 610:813dcc80987e 1323
mbed_official 610:813dcc80987e 1324 /* Process unlocked */
mbed_official 610:813dcc80987e 1325 __HAL_UNLOCK(hadc);
mbed_official 610:813dcc80987e 1326
mbed_official 610:813dcc80987e 1327 /* Return function status */
mbed_official 610:813dcc80987e 1328 return tmp_status;
mbed_official 610:813dcc80987e 1329 }
mbed_official 610:813dcc80987e 1330
mbed_official 610:813dcc80987e 1331
mbed_official 610:813dcc80987e 1332 /**
mbed_official 610:813dcc80987e 1333 * @brief Stop ADC conversion of regular groups when interruptions are enabled, disable ADC peripheral if no injected conversion is on-going.
mbed_official 610:813dcc80987e 1334 * @param hadc: ADC handle
mbed_official 610:813dcc80987e 1335 * @retval HAL status.
mbed_official 610:813dcc80987e 1336 */
mbed_official 610:813dcc80987e 1337 HAL_StatusTypeDef HAL_ADCEx_RegularStop_IT(ADC_HandleTypeDef* hadc)
mbed_official 610:813dcc80987e 1338 {
mbed_official 610:813dcc80987e 1339 HAL_StatusTypeDef tmp_status = HAL_OK;
mbed_official 610:813dcc80987e 1340
mbed_official 610:813dcc80987e 1341 /* Check the parameters */
mbed_official 610:813dcc80987e 1342 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 610:813dcc80987e 1343
mbed_official 610:813dcc80987e 1344 /* Process locked */
mbed_official 610:813dcc80987e 1345 __HAL_LOCK(hadc);
mbed_official 610:813dcc80987e 1346
mbed_official 610:813dcc80987e 1347 /* 1. Stop potential regular conversion on going */
mbed_official 610:813dcc80987e 1348 tmp_status = ADC_ConversionStop(hadc, ADC_REGULAR_GROUP);
mbed_official 610:813dcc80987e 1349
mbed_official 610:813dcc80987e 1350 /* Disable ADC peripheral if conversions are effectively stopped
mbed_official 610:813dcc80987e 1351 and if no injected conversion is on-going */
mbed_official 610:813dcc80987e 1352 if (tmp_status == HAL_OK)
mbed_official 610:813dcc80987e 1353 {
mbed_official 610:813dcc80987e 1354 /* Clear HAL_ADC_STATE_REG_BUSY bit */
mbed_official 610:813dcc80987e 1355 CLEAR_BIT(hadc->State, HAL_ADC_STATE_REG_BUSY);
mbed_official 610:813dcc80987e 1356
mbed_official 610:813dcc80987e 1357 /* Disable all regular-related interrupts */
mbed_official 610:813dcc80987e 1358 __HAL_ADC_DISABLE_IT(hadc, (ADC_IT_EOC | ADC_IT_EOS | ADC_IT_OVR));
mbed_official 610:813dcc80987e 1359
mbed_official 610:813dcc80987e 1360 /* 2. Disable ADC peripheral if no injected conversions are on-going */
mbed_official 610:813dcc80987e 1361 if (ADC_IS_CONVERSION_ONGOING_INJECTED(hadc) == RESET)
mbed_official 610:813dcc80987e 1362 {
mbed_official 610:813dcc80987e 1363 tmp_status = ADC_Disable(hadc);
mbed_official 610:813dcc80987e 1364 /* if no issue reported */
mbed_official 610:813dcc80987e 1365 if (tmp_status == HAL_OK)
mbed_official 610:813dcc80987e 1366 {
mbed_official 610:813dcc80987e 1367 /* Change ADC state */
mbed_official 610:813dcc80987e 1368 /* Clear HAL_ADC_STATE_INJ_BUSY bit, set HAL_ADC_STATE_READY bit */
mbed_official 610:813dcc80987e 1369 ADC_STATE_CLR_SET(hadc->State, HAL_ADC_STATE_INJ_BUSY, HAL_ADC_STATE_READY);
mbed_official 610:813dcc80987e 1370 }
mbed_official 610:813dcc80987e 1371 }
mbed_official 610:813dcc80987e 1372 else
mbed_official 610:813dcc80987e 1373 {
mbed_official 610:813dcc80987e 1374 SET_BIT(hadc->State, HAL_ADC_STATE_INJ_BUSY);
mbed_official 610:813dcc80987e 1375 }
mbed_official 610:813dcc80987e 1376 }
mbed_official 610:813dcc80987e 1377
mbed_official 610:813dcc80987e 1378 /* Process unlocked */
mbed_official 610:813dcc80987e 1379 __HAL_UNLOCK(hadc);
mbed_official 610:813dcc80987e 1380
mbed_official 610:813dcc80987e 1381 /* Return function status */
mbed_official 610:813dcc80987e 1382 return tmp_status;
mbed_official 610:813dcc80987e 1383 }
mbed_official 610:813dcc80987e 1384
mbed_official 610:813dcc80987e 1385
mbed_official 610:813dcc80987e 1386 /**
mbed_official 610:813dcc80987e 1387 * @brief Stop ADC conversion of regular groups and disable ADC DMA transfer, disable ADC peripheral if no injected conversion is on-going.
mbed_official 610:813dcc80987e 1388 * @note HAL_ADCEx_RegularStop_DMA() function is dedicated to single-ADC mode only.
mbed_official 610:813dcc80987e 1389 * For multimode, use HAL_ADCEx_RegularMultiModeStop_DMA() API.
mbed_official 610:813dcc80987e 1390 * @param hadc: ADC handle
mbed_official 610:813dcc80987e 1391 * @retval HAL status.
mbed_official 610:813dcc80987e 1392 */
mbed_official 610:813dcc80987e 1393 HAL_StatusTypeDef HAL_ADCEx_RegularStop_DMA(ADC_HandleTypeDef* hadc)
mbed_official 610:813dcc80987e 1394 {
mbed_official 610:813dcc80987e 1395 HAL_StatusTypeDef tmp_status = HAL_OK;
mbed_official 610:813dcc80987e 1396
mbed_official 610:813dcc80987e 1397 /* Check the parameters */
mbed_official 610:813dcc80987e 1398 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 610:813dcc80987e 1399
mbed_official 610:813dcc80987e 1400 /* Process locked */
mbed_official 610:813dcc80987e 1401 __HAL_LOCK(hadc);
mbed_official 610:813dcc80987e 1402
mbed_official 610:813dcc80987e 1403 /* 1. Stop potential regular conversion on going */
mbed_official 610:813dcc80987e 1404 tmp_status = ADC_ConversionStop(hadc, ADC_REGULAR_GROUP);
mbed_official 610:813dcc80987e 1405
mbed_official 610:813dcc80987e 1406 /* Disable ADC peripheral if conversions are effectively stopped
mbed_official 610:813dcc80987e 1407 and if no injected conversion is on-going */
mbed_official 610:813dcc80987e 1408 if (tmp_status == HAL_OK)
mbed_official 610:813dcc80987e 1409 {
mbed_official 610:813dcc80987e 1410 /* Clear HAL_ADC_STATE_REG_BUSY bit */
mbed_official 610:813dcc80987e 1411 CLEAR_BIT(hadc->State, HAL_ADC_STATE_REG_BUSY);
mbed_official 610:813dcc80987e 1412
mbed_official 610:813dcc80987e 1413 /* Disable ADC DMA (ADC DMA configuration ADC_CFGR_DMACFG is kept) */
mbed_official 610:813dcc80987e 1414 CLEAR_BIT(hadc->Instance->CFGR, ADC_CFGR_DMAEN);
mbed_official 610:813dcc80987e 1415
mbed_official 610:813dcc80987e 1416 /* Disable the DMA channel (in case of DMA in circular mode or stop while */
mbed_official 610:813dcc80987e 1417 /* while DMA transfer is on going) */
mbed_official 610:813dcc80987e 1418 tmp_status = HAL_DMA_Abort(hadc->DMA_Handle);
mbed_official 610:813dcc80987e 1419
mbed_official 610:813dcc80987e 1420 /* Check if DMA channel effectively disabled */
mbed_official 610:813dcc80987e 1421 if (tmp_status != HAL_OK)
mbed_official 610:813dcc80987e 1422 {
mbed_official 610:813dcc80987e 1423 /* Update ADC state machine to error */
mbed_official 610:813dcc80987e 1424 SET_BIT(hadc->State, HAL_ADC_STATE_ERROR_DMA);
mbed_official 610:813dcc80987e 1425 }
mbed_official 610:813dcc80987e 1426
mbed_official 610:813dcc80987e 1427 /* Disable ADC overrun interrupt */
mbed_official 610:813dcc80987e 1428 __HAL_ADC_DISABLE_IT(hadc, ADC_IT_OVR);
mbed_official 610:813dcc80987e 1429
mbed_official 610:813dcc80987e 1430 /* 2. Disable the ADC peripheral */
mbed_official 610:813dcc80987e 1431 /* Update "tmp_status" only if DMA channel disabling passed, to keep in */
mbed_official 610:813dcc80987e 1432 /* memory a potential failing status. */
mbed_official 610:813dcc80987e 1433 if (ADC_IS_CONVERSION_ONGOING_INJECTED(hadc) == RESET)
mbed_official 610:813dcc80987e 1434 {
mbed_official 610:813dcc80987e 1435 if (tmp_status == HAL_OK)
mbed_official 610:813dcc80987e 1436 {
mbed_official 610:813dcc80987e 1437 tmp_status = ADC_Disable(hadc);
mbed_official 610:813dcc80987e 1438 }
mbed_official 610:813dcc80987e 1439 else
mbed_official 610:813dcc80987e 1440 {
mbed_official 610:813dcc80987e 1441 ADC_Disable(hadc);
mbed_official 610:813dcc80987e 1442 }
mbed_official 610:813dcc80987e 1443
mbed_official 610:813dcc80987e 1444 /* Check if ADC is effectively disabled */
mbed_official 610:813dcc80987e 1445 if (tmp_status == HAL_OK)
mbed_official 610:813dcc80987e 1446 {
mbed_official 610:813dcc80987e 1447 /* Change ADC state */
mbed_official 610:813dcc80987e 1448 /* Clear HAL_ADC_STATE_INJ_BUSY bit, set HAL_ADC_STATE_READY bit */
mbed_official 610:813dcc80987e 1449 ADC_STATE_CLR_SET(hadc->State, HAL_ADC_STATE_INJ_BUSY, HAL_ADC_STATE_READY);
mbed_official 610:813dcc80987e 1450 }
mbed_official 610:813dcc80987e 1451 }
mbed_official 610:813dcc80987e 1452 else
mbed_official 610:813dcc80987e 1453 {
mbed_official 610:813dcc80987e 1454 SET_BIT(hadc->State, HAL_ADC_STATE_INJ_BUSY);
mbed_official 610:813dcc80987e 1455 }
mbed_official 610:813dcc80987e 1456 }
mbed_official 610:813dcc80987e 1457
mbed_official 610:813dcc80987e 1458 /* Process unlocked */
mbed_official 610:813dcc80987e 1459 __HAL_UNLOCK(hadc);
mbed_official 610:813dcc80987e 1460
mbed_official 610:813dcc80987e 1461 /* Return function status */
mbed_official 610:813dcc80987e 1462 return tmp_status;
mbed_official 610:813dcc80987e 1463 }
mbed_official 610:813dcc80987e 1464
mbed_official 610:813dcc80987e 1465
mbed_official 610:813dcc80987e 1466
mbed_official 610:813dcc80987e 1467 /**
mbed_official 610:813dcc80987e 1468 * @brief Stop DMA-based MultiMode ADC conversion, disable ADC DMA transfer, disable ADC peripheral if no injected conversion is on-going.
mbed_official 610:813dcc80987e 1469 * @note MultiMode is kept enabled after this function. MultiMode DMA bits
mbed_official 610:813dcc80987e 1470 * (MDMA and DMACFG bits of common CCR register) are maintained. To disable
mbed_official 610:813dcc80987e 1471 * MultiMode (set with HAL_ADCEx_MultiModeConfigChannel()), ADC must be
mbed_official 610:813dcc80987e 1472 * reinitialized using HAL_ADC_Init() or HAL_ADC_DeInit(), or the user can
mbed_official 610:813dcc80987e 1473 * resort to HAL_ADCEx_DisableMultiMode() API.
mbed_official 610:813dcc80987e 1474 * @note In case of DMA configured in circular mode, function
mbed_official 610:813dcc80987e 1475 * HAL_ADCEx_RegularStop_DMA() must be called after this function with handle of
mbed_official 610:813dcc80987e 1476 * ADC slave, to properly disable the DMA channel.
mbed_official 610:813dcc80987e 1477 * @param hadc: ADC handle of ADC master (handle of ADC slave must not be used)
mbed_official 610:813dcc80987e 1478 * @retval None
mbed_official 610:813dcc80987e 1479 */
mbed_official 610:813dcc80987e 1480 HAL_StatusTypeDef HAL_ADCEx_RegularMultiModeStop_DMA(ADC_HandleTypeDef* hadc)
mbed_official 610:813dcc80987e 1481 {
mbed_official 610:813dcc80987e 1482 HAL_StatusTypeDef tmp_status = HAL_OK;
mbed_official 610:813dcc80987e 1483 uint32_t tickstart;
mbed_official 610:813dcc80987e 1484 ADC_HandleTypeDef tmphadcSlave;
mbed_official 610:813dcc80987e 1485
mbed_official 610:813dcc80987e 1486 /* Check the parameters */
mbed_official 610:813dcc80987e 1487 assert_param(IS_ADC_MULTIMODE_MASTER_INSTANCE(hadc->Instance));
mbed_official 610:813dcc80987e 1488
mbed_official 610:813dcc80987e 1489 /* Process locked */
mbed_official 610:813dcc80987e 1490 __HAL_LOCK(hadc);
mbed_official 610:813dcc80987e 1491
mbed_official 610:813dcc80987e 1492
mbed_official 610:813dcc80987e 1493 /* 1. Stop potential multimode conversion on going, on regular groups */
mbed_official 610:813dcc80987e 1494 tmp_status = ADC_ConversionStop(hadc, ADC_REGULAR_GROUP);
mbed_official 610:813dcc80987e 1495
mbed_official 610:813dcc80987e 1496 /* Disable ADC peripheral if conversions are effectively stopped */
mbed_official 610:813dcc80987e 1497 if (tmp_status == HAL_OK)
mbed_official 610:813dcc80987e 1498 {
mbed_official 610:813dcc80987e 1499 /* Clear HAL_ADC_STATE_REG_BUSY bit */
mbed_official 610:813dcc80987e 1500 CLEAR_BIT(hadc->State, HAL_ADC_STATE_REG_BUSY);
mbed_official 610:813dcc80987e 1501
mbed_official 610:813dcc80987e 1502 /* Set a temporary handle of the ADC slave associated to the ADC master */
mbed_official 610:813dcc80987e 1503 ADC_MULTI_SLAVE(hadc, &tmphadcSlave);
mbed_official 610:813dcc80987e 1504
mbed_official 610:813dcc80987e 1505 if (tmphadcSlave.Instance == NULL)
mbed_official 610:813dcc80987e 1506 {
mbed_official 610:813dcc80987e 1507 /* Update ADC state machine to error */
mbed_official 610:813dcc80987e 1508 SET_BIT(hadc->State, HAL_ADC_STATE_ERROR_CONFIG);
mbed_official 610:813dcc80987e 1509
mbed_official 610:813dcc80987e 1510 /* Process unlocked */
mbed_official 610:813dcc80987e 1511 __HAL_UNLOCK(hadc);
mbed_official 610:813dcc80987e 1512
mbed_official 610:813dcc80987e 1513 return HAL_ERROR;
mbed_official 610:813dcc80987e 1514 }
mbed_official 610:813dcc80987e 1515
mbed_official 610:813dcc80987e 1516 /* Procedure to disable the ADC peripheral: wait for conversions */
mbed_official 610:813dcc80987e 1517 /* effectively stopped (ADC master and ADC slave), then disable ADC */
mbed_official 610:813dcc80987e 1518
mbed_official 610:813dcc80987e 1519 /* 1. Wait until ADSTP=0 for ADC master and ADC slave*/
mbed_official 610:813dcc80987e 1520 tickstart = HAL_GetTick();
mbed_official 610:813dcc80987e 1521
mbed_official 610:813dcc80987e 1522 while(ADC_IS_CONVERSION_ONGOING_REGULAR(hadc) ||
mbed_official 610:813dcc80987e 1523 ADC_IS_CONVERSION_ONGOING_REGULAR(&tmphadcSlave) )
mbed_official 610:813dcc80987e 1524 {
mbed_official 610:813dcc80987e 1525 if((HAL_GetTick()-tickstart) > ADC_STOP_CONVERSION_TIMEOUT)
mbed_official 610:813dcc80987e 1526 {
mbed_official 610:813dcc80987e 1527 /* Update ADC state machine to error */
mbed_official 610:813dcc80987e 1528 SET_BIT(hadc->State, HAL_ADC_STATE_ERROR_INTERNAL);
mbed_official 610:813dcc80987e 1529
mbed_official 610:813dcc80987e 1530 /* Process unlocked */
mbed_official 610:813dcc80987e 1531 __HAL_UNLOCK(hadc);
mbed_official 610:813dcc80987e 1532
mbed_official 610:813dcc80987e 1533 return HAL_ERROR;
mbed_official 610:813dcc80987e 1534 }
mbed_official 610:813dcc80987e 1535 }
mbed_official 610:813dcc80987e 1536
mbed_official 610:813dcc80987e 1537 /* Disable the DMA channel (in case of DMA in circular mode or stop */
mbed_official 610:813dcc80987e 1538 /* while DMA transfer is on going) */
mbed_official 610:813dcc80987e 1539 /* Note: DMA channel of ADC slave should be stopped after this function */
mbed_official 610:813dcc80987e 1540 /* with HAL_ADCEx_RegularStop_DMA() API. */
mbed_official 610:813dcc80987e 1541 tmp_status = HAL_DMA_Abort(hadc->DMA_Handle);
mbed_official 610:813dcc80987e 1542
mbed_official 610:813dcc80987e 1543 /* Check if DMA channel effectively disabled */
mbed_official 610:813dcc80987e 1544 if (tmp_status != HAL_OK)
mbed_official 610:813dcc80987e 1545 {
mbed_official 610:813dcc80987e 1546 /* Update ADC state machine to error */
mbed_official 610:813dcc80987e 1547 SET_BIT(hadc->State, HAL_ADC_STATE_ERROR_DMA);
mbed_official 610:813dcc80987e 1548 }
mbed_official 610:813dcc80987e 1549
mbed_official 610:813dcc80987e 1550 /* Disable ADC overrun interrupt */
mbed_official 610:813dcc80987e 1551 __HAL_ADC_DISABLE_IT(hadc, ADC_IT_OVR);
mbed_official 610:813dcc80987e 1552
mbed_official 610:813dcc80987e 1553
mbed_official 610:813dcc80987e 1554
mbed_official 610:813dcc80987e 1555 /* 2. Disable the ADC peripherals: master and slave if no injected */
mbed_official 610:813dcc80987e 1556 /* conversion is on-going. */
mbed_official 610:813dcc80987e 1557 /* Update "tmp_status" only if DMA channel disabling passed, to keep in */
mbed_official 610:813dcc80987e 1558 /* memory a potential failing status. */
mbed_official 610:813dcc80987e 1559 if (tmp_status == HAL_OK)
mbed_official 610:813dcc80987e 1560 {
mbed_official 610:813dcc80987e 1561 if (ADC_IS_CONVERSION_ONGOING_INJECTED(hadc) == RESET)
mbed_official 610:813dcc80987e 1562 {
mbed_official 610:813dcc80987e 1563 tmp_status = ADC_Disable(hadc);
mbed_official 610:813dcc80987e 1564 if (tmp_status == HAL_OK)
mbed_official 610:813dcc80987e 1565 {
mbed_official 610:813dcc80987e 1566 if (ADC_IS_CONVERSION_ONGOING_INJECTED(&tmphadcSlave) == RESET)
mbed_official 610:813dcc80987e 1567 {
mbed_official 610:813dcc80987e 1568 tmp_status = ADC_Disable(&tmphadcSlave);
mbed_official 610:813dcc80987e 1569 }
mbed_official 610:813dcc80987e 1570 }
mbed_official 610:813dcc80987e 1571 }
mbed_official 610:813dcc80987e 1572
mbed_official 610:813dcc80987e 1573 if (tmp_status == HAL_OK)
mbed_official 610:813dcc80987e 1574 {
mbed_official 610:813dcc80987e 1575 /* Both Master and Slave ADC's could be disabled. Update Master State */
mbed_official 610:813dcc80987e 1576 /* Clear HAL_ADC_STATE_INJ_BUSY bit, set HAL_ADC_STATE_READY bit */
mbed_official 610:813dcc80987e 1577 ADC_STATE_CLR_SET(hadc->State, HAL_ADC_STATE_INJ_BUSY, HAL_ADC_STATE_READY);
mbed_official 610:813dcc80987e 1578 }
mbed_official 610:813dcc80987e 1579 else
mbed_official 610:813dcc80987e 1580 {
mbed_official 610:813dcc80987e 1581 /* injected (Master or Slave) conversions are still on-going,
mbed_official 610:813dcc80987e 1582 no Master State change */
mbed_official 610:813dcc80987e 1583 }
mbed_official 610:813dcc80987e 1584
mbed_official 610:813dcc80987e 1585
mbed_official 610:813dcc80987e 1586 }
mbed_official 610:813dcc80987e 1587
mbed_official 610:813dcc80987e 1588
mbed_official 610:813dcc80987e 1589 }
mbed_official 610:813dcc80987e 1590
mbed_official 610:813dcc80987e 1591 /* Process unlocked */
mbed_official 610:813dcc80987e 1592 __HAL_UNLOCK(hadc);
mbed_official 610:813dcc80987e 1593
mbed_official 610:813dcc80987e 1594 /* Return function status */
mbed_official 610:813dcc80987e 1595 return tmp_status;
mbed_official 610:813dcc80987e 1596 }
mbed_official 610:813dcc80987e 1597
mbed_official 610:813dcc80987e 1598 /**
mbed_official 610:813dcc80987e 1599 * @}
mbed_official 610:813dcc80987e 1600 */
mbed_official 610:813dcc80987e 1601
mbed_official 610:813dcc80987e 1602 /** @defgroup ADCEx_Exported_Functions_Group2 Extended Peripheral Control functions
mbed_official 610:813dcc80987e 1603 * @brief Extended Peripheral Control functions
mbed_official 610:813dcc80987e 1604 *
mbed_official 610:813dcc80987e 1605 @verbatim
mbed_official 610:813dcc80987e 1606 ===============================================================================
mbed_official 610:813dcc80987e 1607 ##### Peripheral Control functions #####
mbed_official 610:813dcc80987e 1608 ===============================================================================
mbed_official 610:813dcc80987e 1609 [..] This section provides functions allowing to:
mbed_official 610:813dcc80987e 1610 (+) Configure channels on injected group
mbed_official 610:813dcc80987e 1611 (+) Configure MultiMode
mbed_official 610:813dcc80987e 1612 (+) Enable or Disable Injected Queue
mbed_official 610:813dcc80987e 1613 (+) Disable ADC voltage regulator
mbed_official 610:813dcc80987e 1614 (+) Enter ADC deep-power-down mode
mbed_official 610:813dcc80987e 1615
mbed_official 610:813dcc80987e 1616
mbed_official 610:813dcc80987e 1617 @endverbatim
mbed_official 610:813dcc80987e 1618 * @{
mbed_official 610:813dcc80987e 1619 */
mbed_official 610:813dcc80987e 1620
mbed_official 610:813dcc80987e 1621
mbed_official 610:813dcc80987e 1622 /**
mbed_official 610:813dcc80987e 1623 * @brief Configure the ADC injected group and the selected channel to be linked to the injected group.
mbed_official 610:813dcc80987e 1624 * @note Possibility to update parameters on the fly:
mbed_official 610:813dcc80987e 1625 * This function initializes injected group, consecutive calls to this
mbed_official 610:813dcc80987e 1626 * function can be used to reconfigure some parameters of structure
mbed_official 610:813dcc80987e 1627 * "ADC_InjectionConfTypeDef" on the fly, without resetting the ADC.
mbed_official 610:813dcc80987e 1628 * The setting of these parameters is conditioned to ADC state.
mbed_official 610:813dcc80987e 1629 * For parameters constraints, see comments of structure
mbed_official 610:813dcc80987e 1630 * "ADC_InjectionConfTypeDef".
mbed_official 610:813dcc80987e 1631 * @note In case of usage of internal measurement channels (Vbat/VrefInt/TempSensor),
mbed_official 610:813dcc80987e 1632 * The internal paths can be disabled using function HAL_ADC_DeInit().
mbed_official 610:813dcc80987e 1633 * @note To reset injected sequencer, function HAL_ADCEx_InjectedStop() can
mbed_official 610:813dcc80987e 1634 * be used.
mbed_official 610:813dcc80987e 1635 * @note Caution: For Injected Context Queue use, a context must be fully
mbed_official 610:813dcc80987e 1636 * defined before start of injected conversion. All channels are configured
mbed_official 610:813dcc80987e 1637 * consecutively for the same ADC instance. Therefore, the number of calls to
mbed_official 610:813dcc80987e 1638 * HAL_ADCEx_InjectedConfigChannel() must be equal to the value of parameter
mbed_official 610:813dcc80987e 1639 * InjectedNbrOfConversion for each context.
mbed_official 610:813dcc80987e 1640 * - Example 1: If 1 context is intended to be used (or if there is no use of the
mbed_official 610:813dcc80987e 1641 * Injected Queue Context feature) and if the context contains 3 injected ranks
mbed_official 610:813dcc80987e 1642 * (InjectedNbrOfConversion = 3), HAL_ADCEx_InjectedConfigChannel() must be
mbed_official 610:813dcc80987e 1643 * called once for each channel (i.e. 3 times) before starting a conversion.
mbed_official 610:813dcc80987e 1644 * This function must not be called to configure a 4th injected channel:
mbed_official 610:813dcc80987e 1645 * it would start a new context into context queue.
mbed_official 610:813dcc80987e 1646 * - Example 2: If 2 contexts are intended to be used and each of them contains
mbed_official 610:813dcc80987e 1647 * 3 injected ranks (InjectedNbrOfConversion = 3),
mbed_official 610:813dcc80987e 1648 * HAL_ADCEx_InjectedConfigChannel() must be called once for each channel and
mbed_official 610:813dcc80987e 1649 * for each context (3 channels x 2 contexts = 6 calls). Conversion can
mbed_official 610:813dcc80987e 1650 * start once the 1st context is set, that is after the first three
mbed_official 610:813dcc80987e 1651 * HAL_ADCEx_InjectedConfigChannel() calls. The 2nd context can be set on the fly.
mbed_official 610:813dcc80987e 1652 * @param hadc: ADC handle
mbed_official 610:813dcc80987e 1653 * @param sConfigInjected: Structure of ADC injected group and ADC channel for
mbed_official 610:813dcc80987e 1654 * injected group.
mbed_official 610:813dcc80987e 1655 * @retval None
mbed_official 610:813dcc80987e 1656 */
mbed_official 610:813dcc80987e 1657 HAL_StatusTypeDef HAL_ADCEx_InjectedConfigChannel(ADC_HandleTypeDef* hadc, ADC_InjectionConfTypeDef* sConfigInjected)
mbed_official 610:813dcc80987e 1658 {
mbed_official 610:813dcc80987e 1659 HAL_StatusTypeDef tmp_status = HAL_OK;
mbed_official 610:813dcc80987e 1660 ADC_Common_TypeDef *tmpADC_Common;
mbed_official 610:813dcc80987e 1661 uint32_t tmpOffsetShifted;
mbed_official 610:813dcc80987e 1662 uint32_t WaitLoopIndex = 0;
mbed_official 610:813dcc80987e 1663
mbed_official 610:813dcc80987e 1664
mbed_official 610:813dcc80987e 1665 uint32_t tmp_JSQR_ContextQueueBeingBuilt = 0;
mbed_official 610:813dcc80987e 1666
mbed_official 610:813dcc80987e 1667 /* Check the parameters */
mbed_official 610:813dcc80987e 1668 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 610:813dcc80987e 1669 assert_param(IS_ADC_INJECTED_RANK(sConfigInjected->InjectedRank));
mbed_official 610:813dcc80987e 1670 assert_param(IS_ADC_SAMPLE_TIME(sConfigInjected->InjectedSamplingTime));
mbed_official 610:813dcc80987e 1671 assert_param(IS_ADC_SINGLE_DIFFERENTIAL(sConfigInjected->InjectedSingleDiff));
mbed_official 610:813dcc80987e 1672 assert_param(IS_ADC_INJECTED_NB_CONV(sConfigInjected->InjectedNbrOfConversion));
mbed_official 610:813dcc80987e 1673 assert_param(IS_FUNCTIONAL_STATE(sConfigInjected->InjectedDiscontinuousConvMode));
mbed_official 610:813dcc80987e 1674 assert_param(IS_FUNCTIONAL_STATE(sConfigInjected->AutoInjectedConv));
mbed_official 610:813dcc80987e 1675 assert_param(IS_FUNCTIONAL_STATE(sConfigInjected->QueueInjectedContext));
mbed_official 610:813dcc80987e 1676 assert_param(IS_ADC_EXTTRIGINJEC_EDGE(sConfigInjected->ExternalTrigInjecConvEdge));
mbed_official 610:813dcc80987e 1677 assert_param(IS_ADC_EXTTRIGINJEC(sConfigInjected->ExternalTrigInjecConv));
mbed_official 610:813dcc80987e 1678 assert_param(IS_ADC_OFFSET_NUMBER(sConfigInjected->InjectedOffsetNumber));
mbed_official 610:813dcc80987e 1679 assert_param(IS_ADC_RANGE(ADC_GET_RESOLUTION(hadc), sConfigInjected->InjectedOffset));
mbed_official 610:813dcc80987e 1680 assert_param(IS_FUNCTIONAL_STATE(sConfigInjected->InjecOversamplingMode));
mbed_official 610:813dcc80987e 1681
mbed_official 610:813dcc80987e 1682 if(hadc->Init.ScanConvMode != ADC_SCAN_DISABLE)
mbed_official 610:813dcc80987e 1683 {
mbed_official 610:813dcc80987e 1684 assert_param(IS_ADC_INJECTED_RANK(sConfigInjected->InjectedRank));
mbed_official 610:813dcc80987e 1685 assert_param(IS_ADC_INJECTED_NB_CONV(sConfigInjected->InjectedNbrOfConversion));
mbed_official 610:813dcc80987e 1686 assert_param(IS_FUNCTIONAL_STATE(sConfigInjected->InjectedDiscontinuousConvMode));
mbed_official 610:813dcc80987e 1687 }
mbed_official 610:813dcc80987e 1688
mbed_official 610:813dcc80987e 1689
mbed_official 610:813dcc80987e 1690 /* if JOVSE is set, the value of the OFFSETy_EN bit in ADCx_OFRy register is
mbed_official 610:813dcc80987e 1691 ignored (considered as reset) */
mbed_official 610:813dcc80987e 1692 assert_param(!((sConfigInjected->InjectedOffsetNumber != ADC_OFFSET_NONE) && (sConfigInjected->InjecOversamplingMode == ENABLE)));
mbed_official 610:813dcc80987e 1693
mbed_official 610:813dcc80987e 1694 /* JDISCEN and JAUTO bits can't be set at the same time */
mbed_official 610:813dcc80987e 1695 assert_param(!((sConfigInjected->InjectedDiscontinuousConvMode == ENABLE) && (sConfigInjected->AutoInjectedConv == ENABLE)));
mbed_official 610:813dcc80987e 1696
mbed_official 610:813dcc80987e 1697 /* DISCEN and JAUTO bits can't be set at the same time */
mbed_official 610:813dcc80987e 1698 assert_param(!((hadc->Init.DiscontinuousConvMode == ENABLE) && (sConfigInjected->AutoInjectedConv == ENABLE)));
mbed_official 610:813dcc80987e 1699
mbed_official 610:813dcc80987e 1700 /* Only rank 1 can be configured if there is only one conversion or if Scan conversion mode is disabled */
mbed_official 610:813dcc80987e 1701 assert_param(!(((hadc->Init.ScanConvMode == ADC_SCAN_DISABLE) || (sConfigInjected->InjectedNbrOfConversion == 1) ) && (sConfigInjected->InjectedRank != ADC_INJECTED_RANK_1)));
mbed_official 610:813dcc80987e 1702
mbed_official 610:813dcc80987e 1703
mbed_official 610:813dcc80987e 1704 /* Verification of channel number.
mbed_official 610:813dcc80987e 1705 For ADC1 and ADC2, channels 1 to 15 are available in differential mode,
mbed_official 610:813dcc80987e 1706 channels 16 to 18 can be only used in single-ended mode.
mbed_official 610:813dcc80987e 1707 For ADC3, channels 1 to 11 are available in differential mode,
mbed_official 610:813dcc80987e 1708 channels 12 to 18 can only be used in single-ended mode. */
mbed_official 610:813dcc80987e 1709 if (sConfigInjected->InjectedSingleDiff != ADC_DIFFERENTIAL_ENDED)
mbed_official 610:813dcc80987e 1710 {
mbed_official 610:813dcc80987e 1711 assert_param(IS_ADC_CHANNEL(sConfigInjected->InjectedChannel));
mbed_official 610:813dcc80987e 1712 }
mbed_official 610:813dcc80987e 1713 else
mbed_official 610:813dcc80987e 1714 {
mbed_official 610:813dcc80987e 1715 if (hadc->Instance == ADC3)
mbed_official 610:813dcc80987e 1716 {
mbed_official 610:813dcc80987e 1717 assert_param(IS_ADC3_DIFF_CHANNEL(sConfigInjected->InjectedChannel));
mbed_official 610:813dcc80987e 1718 }
mbed_official 610:813dcc80987e 1719 else
mbed_official 610:813dcc80987e 1720 {
mbed_official 610:813dcc80987e 1721 assert_param(IS_ADC12_DIFF_CHANNEL(sConfigInjected->InjectedChannel));
mbed_official 610:813dcc80987e 1722 }
mbed_official 610:813dcc80987e 1723 }
mbed_official 610:813dcc80987e 1724
mbed_official 610:813dcc80987e 1725 /* Process locked */
mbed_official 610:813dcc80987e 1726 __HAL_LOCK(hadc);
mbed_official 610:813dcc80987e 1727
mbed_official 610:813dcc80987e 1728
mbed_official 610:813dcc80987e 1729
mbed_official 610:813dcc80987e 1730 /* Configuration of Injected group sequencer. */
mbed_official 610:813dcc80987e 1731 /* Hardware constraint: Must fully define injected context register JSQR */
mbed_official 610:813dcc80987e 1732 /* before make it entering into injected sequencer queue. */
mbed_official 610:813dcc80987e 1733 /* */
mbed_official 610:813dcc80987e 1734 /* - if scan mode is disabled: */
mbed_official 610:813dcc80987e 1735 /* * Injected channels sequence length is set to 0x00: 1 channel */
mbed_official 610:813dcc80987e 1736 /* converted (channel on injected rank 1) */
mbed_official 610:813dcc80987e 1737 /* Parameter "InjectedNbrOfConversion" is discarded. */
mbed_official 610:813dcc80987e 1738 /* * Injected context register JSQR setting is simple: register is fully */
mbed_official 610:813dcc80987e 1739 /* defined on one call of this function (for injected rank 1) and can */
mbed_official 610:813dcc80987e 1740 /* be entered into queue directly. */
mbed_official 610:813dcc80987e 1741 /* - if scan mode is enabled: */
mbed_official 610:813dcc80987e 1742 /* * Injected channels sequence length is set to parameter */
mbed_official 610:813dcc80987e 1743 /* "InjectedNbrOfConversion". */
mbed_official 610:813dcc80987e 1744 /* * Injected context register JSQR setting more complex: register is */
mbed_official 610:813dcc80987e 1745 /* fully defined over successive calls of this function, for each */
mbed_official 610:813dcc80987e 1746 /* injected channel rank. It is entered into queue only when all */
mbed_official 610:813dcc80987e 1747 /* injected ranks have been set. */
mbed_official 610:813dcc80987e 1748 /* Note: Scan mode is not present by hardware on this device, but used */
mbed_official 610:813dcc80987e 1749 /* by software for alignment over all STM32 devices. */
mbed_official 610:813dcc80987e 1750
mbed_official 610:813dcc80987e 1751 if ((hadc->Init.ScanConvMode == ADC_SCAN_DISABLE) ||
mbed_official 610:813dcc80987e 1752 (sConfigInjected->InjectedNbrOfConversion == 1) )
mbed_official 610:813dcc80987e 1753 {
mbed_official 610:813dcc80987e 1754 /* Configuration of context register JSQR: */
mbed_official 610:813dcc80987e 1755 /* - number of ranks in injected group sequencer: fixed to 1st rank */
mbed_official 610:813dcc80987e 1756 /* (scan mode disabled, only rank 1 used) */
mbed_official 610:813dcc80987e 1757 /* - external trigger to start conversion */
mbed_official 610:813dcc80987e 1758 /* - external trigger polarity */
mbed_official 610:813dcc80987e 1759 /* - channel set to rank 1 (scan mode disabled, only rank 1 can be used) */
mbed_official 610:813dcc80987e 1760
mbed_official 610:813dcc80987e 1761 if (sConfigInjected->InjectedRank == ADC_INJECTED_RANK_1)
mbed_official 610:813dcc80987e 1762 {
mbed_official 610:813dcc80987e 1763 /* Enable external trigger if trigger selection is different of */
mbed_official 610:813dcc80987e 1764 /* software start. */
mbed_official 610:813dcc80987e 1765 /* Note: This configuration keeps the hardware feature of parameter */
mbed_official 610:813dcc80987e 1766 /* ExternalTrigInjecConvEdge "trigger edge none" equivalent to */
mbed_official 610:813dcc80987e 1767 /* software start. */
mbed_official 610:813dcc80987e 1768 if ((sConfigInjected->ExternalTrigInjecConv != ADC_INJECTED_SOFTWARE_START)
mbed_official 610:813dcc80987e 1769 && (sConfigInjected->ExternalTrigInjecConvEdge != ADC_EXTERNALTRIGINJECCONV_EDGE_NONE))
mbed_official 610:813dcc80987e 1770 {
mbed_official 610:813dcc80987e 1771 tmp_JSQR_ContextQueueBeingBuilt = ( ADC_JSQR_RK(sConfigInjected->InjectedChannel, ADC_INJECTED_RANK_1) |
mbed_official 610:813dcc80987e 1772 sConfigInjected->ExternalTrigInjecConv |
mbed_official 610:813dcc80987e 1773 sConfigInjected->ExternalTrigInjecConvEdge );
mbed_official 610:813dcc80987e 1774 }
mbed_official 610:813dcc80987e 1775 else
mbed_official 610:813dcc80987e 1776 {
mbed_official 610:813dcc80987e 1777 tmp_JSQR_ContextQueueBeingBuilt = ( ADC_JSQR_RK(sConfigInjected->InjectedChannel, ADC_INJECTED_RANK_1) );
mbed_official 610:813dcc80987e 1778 }
mbed_official 610:813dcc80987e 1779
mbed_official 610:813dcc80987e 1780
mbed_official 610:813dcc80987e 1781 MODIFY_REG(hadc->Instance->JSQR, ADC_JSQR_FIELDS, tmp_JSQR_ContextQueueBeingBuilt);
mbed_official 610:813dcc80987e 1782 /* For debug and informative reasons, hadc handle saves JSQR setting */
mbed_official 610:813dcc80987e 1783 hadc->InjectionConfig.ContextQueue = tmp_JSQR_ContextQueueBeingBuilt;
mbed_official 610:813dcc80987e 1784
mbed_official 610:813dcc80987e 1785 }
mbed_official 610:813dcc80987e 1786 }
mbed_official 610:813dcc80987e 1787 else
mbed_official 610:813dcc80987e 1788 {
mbed_official 610:813dcc80987e 1789 /* Case of scan mode enabled, several channels to set into injected group */
mbed_official 610:813dcc80987e 1790 /* sequencer. */
mbed_official 610:813dcc80987e 1791 /* */
mbed_official 610:813dcc80987e 1792 /* Procedure to define injected context register JSQR over successive */
mbed_official 610:813dcc80987e 1793 /* calls of this function, for each injected channel rank: */
mbed_official 610:813dcc80987e 1794 /* 1. Start new context and set parameters related to all injected */
mbed_official 610:813dcc80987e 1795 /* channels: injected sequence length and trigger. */
mbed_official 610:813dcc80987e 1796
mbed_official 610:813dcc80987e 1797 /* if hadc->InjectionConfig.ChannelCount is equal to 0, this is the first */
mbed_official 610:813dcc80987e 1798 /* call of the context under setting */
mbed_official 610:813dcc80987e 1799 if (hadc->InjectionConfig.ChannelCount == 0)
mbed_official 610:813dcc80987e 1800 {
mbed_official 610:813dcc80987e 1801 /* Initialize number of channels that will be configured on the context */
mbed_official 610:813dcc80987e 1802 /* being built */
mbed_official 610:813dcc80987e 1803 hadc->InjectionConfig.ChannelCount = sConfigInjected->InjectedNbrOfConversion;
mbed_official 610:813dcc80987e 1804 /* Handle hadc saves the context under build up over each HAL_ADCEx_InjectedConfigChannel()
mbed_official 610:813dcc80987e 1805 call, this context will be written in JSQR register at the last call.
mbed_official 610:813dcc80987e 1806 At this point, the context is merely reset */
mbed_official 610:813dcc80987e 1807 hadc->InjectionConfig.ContextQueue = (uint32_t)0x00000000;
mbed_official 610:813dcc80987e 1808
mbed_official 610:813dcc80987e 1809 /* Configuration of context register JSQR: */
mbed_official 610:813dcc80987e 1810 /* - number of ranks in injected group sequencer */
mbed_official 610:813dcc80987e 1811 /* - external trigger to start conversion */
mbed_official 610:813dcc80987e 1812 /* - external trigger polarity */
mbed_official 610:813dcc80987e 1813
mbed_official 610:813dcc80987e 1814 /* Enable external trigger if trigger selection is different of */
mbed_official 610:813dcc80987e 1815 /* software start. */
mbed_official 610:813dcc80987e 1816 /* Note: This configuration keeps the hardware feature of parameter */
mbed_official 610:813dcc80987e 1817 /* ExternalTrigInjecConvEdge "trigger edge none" equivalent to */
mbed_official 610:813dcc80987e 1818 /* software start. */
mbed_official 610:813dcc80987e 1819 if ((sConfigInjected->ExternalTrigInjecConv != ADC_INJECTED_SOFTWARE_START)
mbed_official 610:813dcc80987e 1820 && (sConfigInjected->ExternalTrigInjecConvEdge != ADC_EXTERNALTRIGINJECCONV_EDGE_NONE))
mbed_official 610:813dcc80987e 1821 {
mbed_official 610:813dcc80987e 1822 tmp_JSQR_ContextQueueBeingBuilt = ((sConfigInjected->InjectedNbrOfConversion - (uint32_t)1) |
mbed_official 610:813dcc80987e 1823 sConfigInjected->ExternalTrigInjecConv |
mbed_official 610:813dcc80987e 1824 sConfigInjected->ExternalTrigInjecConvEdge );
mbed_official 610:813dcc80987e 1825 }
mbed_official 610:813dcc80987e 1826 else
mbed_official 610:813dcc80987e 1827 {
mbed_official 610:813dcc80987e 1828 tmp_JSQR_ContextQueueBeingBuilt = ((sConfigInjected->InjectedNbrOfConversion - (uint32_t)1) );
mbed_official 610:813dcc80987e 1829 }
mbed_official 610:813dcc80987e 1830
mbed_official 610:813dcc80987e 1831
mbed_official 610:813dcc80987e 1832 } /* if (hadc->InjectionConfig.ChannelCount == 0) */
mbed_official 610:813dcc80987e 1833
mbed_official 610:813dcc80987e 1834
mbed_official 610:813dcc80987e 1835 /* 2. Continue setting of context under definition with parameter */
mbed_official 610:813dcc80987e 1836 /* related to each channel: channel rank sequence */
mbed_official 610:813dcc80987e 1837 /* Clear the old JSQx bits for the selected rank */
mbed_official 610:813dcc80987e 1838 tmp_JSQR_ContextQueueBeingBuilt &= ~ADC_JSQR_RK(ADC_SQR3_SQ10, sConfigInjected->InjectedRank);
mbed_official 610:813dcc80987e 1839
mbed_official 610:813dcc80987e 1840 /* Set the JSQx bits for the selected rank */
mbed_official 610:813dcc80987e 1841 tmp_JSQR_ContextQueueBeingBuilt |= ADC_JSQR_RK(sConfigInjected->InjectedChannel, sConfigInjected->InjectedRank);
mbed_official 610:813dcc80987e 1842
mbed_official 610:813dcc80987e 1843 /* Decrease channel count */
mbed_official 610:813dcc80987e 1844 hadc->InjectionConfig.ChannelCount--;
mbed_official 610:813dcc80987e 1845
mbed_official 610:813dcc80987e 1846
mbed_official 610:813dcc80987e 1847 /* 3. tmp_JSQR_ContextQueueBeingBuilt is fully built for this HAL_ADCEx_InjectedConfigChannel()
mbed_official 610:813dcc80987e 1848 call, aggregate the setting to those already built during the previous
mbed_official 610:813dcc80987e 1849 HAL_ADCEx_InjectedConfigChannel() calls (for the same context of course) */
mbed_official 610:813dcc80987e 1850 hadc->InjectionConfig.ContextQueue |= tmp_JSQR_ContextQueueBeingBuilt;
mbed_official 610:813dcc80987e 1851
mbed_official 610:813dcc80987e 1852 /* 4. End of context setting: if this is the last channel set, then write context
mbed_official 610:813dcc80987e 1853 into register JSQR and make it enter into queue */
mbed_official 610:813dcc80987e 1854 if (hadc->InjectionConfig.ChannelCount == 0)
mbed_official 610:813dcc80987e 1855 {
mbed_official 610:813dcc80987e 1856 MODIFY_REG(hadc->Instance->JSQR, ADC_JSQR_FIELDS, hadc->InjectionConfig.ContextQueue);
mbed_official 610:813dcc80987e 1857 }
mbed_official 610:813dcc80987e 1858
mbed_official 610:813dcc80987e 1859
mbed_official 610:813dcc80987e 1860 }
mbed_official 610:813dcc80987e 1861
mbed_official 610:813dcc80987e 1862 /* Parameters update conditioned to ADC state: */
mbed_official 610:813dcc80987e 1863 /* Parameters that can be updated when ADC is disabled or enabled without */
mbed_official 610:813dcc80987e 1864 /* conversion on going on injected group: */
mbed_official 610:813dcc80987e 1865 /* - Injected context queue: Queue disable (active context is kept) or */
mbed_official 610:813dcc80987e 1866 /* enable (context decremented, up to 2 contexts queued) */
mbed_official 610:813dcc80987e 1867 /* - Injected discontinuous mode: can be enabled only if auto-injected */
mbed_official 610:813dcc80987e 1868 /* mode is disabled. */
mbed_official 610:813dcc80987e 1869 if (ADC_IS_CONVERSION_ONGOING_INJECTED(hadc) == RESET)
mbed_official 610:813dcc80987e 1870 {
mbed_official 610:813dcc80987e 1871
mbed_official 610:813dcc80987e 1872 /* If auto-injected mode is disabled: no constraint */
mbed_official 610:813dcc80987e 1873 if (sConfigInjected->AutoInjectedConv == DISABLE)
mbed_official 610:813dcc80987e 1874 {
mbed_official 610:813dcc80987e 1875 MODIFY_REG(hadc->Instance->CFGR, ADC_CFGR_JQM | ADC_CFGR_JDISCEN,
mbed_official 610:813dcc80987e 1876 ADC_CFGR_INJECT_CONTEXT_QUEUE(sConfigInjected->QueueInjectedContext) |
mbed_official 610:813dcc80987e 1877 ADC_CFGR_INJECT_DISCCONTINUOUS(sConfigInjected->InjectedDiscontinuousConvMode) );
mbed_official 610:813dcc80987e 1878 }
mbed_official 610:813dcc80987e 1879 /* If auto-injected mode is enabled: Injected discontinuous setting is */
mbed_official 610:813dcc80987e 1880 /* discarded. */
mbed_official 610:813dcc80987e 1881 else
mbed_official 610:813dcc80987e 1882 {
mbed_official 610:813dcc80987e 1883 MODIFY_REG(hadc->Instance->CFGR, ADC_CFGR_JQM | ADC_CFGR_JDISCEN,
mbed_official 610:813dcc80987e 1884 ADC_CFGR_INJECT_CONTEXT_QUEUE(sConfigInjected->QueueInjectedContext) );
mbed_official 610:813dcc80987e 1885 }
mbed_official 610:813dcc80987e 1886
mbed_official 610:813dcc80987e 1887 }
mbed_official 610:813dcc80987e 1888
mbed_official 610:813dcc80987e 1889
mbed_official 610:813dcc80987e 1890 /* Parameters update conditioned to ADC state: */
mbed_official 610:813dcc80987e 1891 /* Parameters that can be updated when ADC is disabled or enabled without */
mbed_official 610:813dcc80987e 1892 /* conversion on going on regular and injected groups: */
mbed_official 610:813dcc80987e 1893 /* - Automatic injected conversion: can be enabled if injected group */
mbed_official 610:813dcc80987e 1894 /* external triggers are disabled. */
mbed_official 610:813dcc80987e 1895 /* - Channel sampling time */
mbed_official 610:813dcc80987e 1896 /* - Channel offset */
mbed_official 610:813dcc80987e 1897 if (ADC_IS_CONVERSION_ONGOING_REGULAR_INJECTED(hadc) == RESET)
mbed_official 610:813dcc80987e 1898 {
mbed_official 610:813dcc80987e 1899 /* If injected group external triggers are disabled (set to injected */
mbed_official 610:813dcc80987e 1900 /* software start): no constraint */
mbed_official 610:813dcc80987e 1901 if ((sConfigInjected->ExternalTrigInjecConv == ADC_INJECTED_SOFTWARE_START)
mbed_official 610:813dcc80987e 1902 || (sConfigInjected->ExternalTrigInjecConvEdge == ADC_EXTERNALTRIGINJECCONV_EDGE_NONE))
mbed_official 610:813dcc80987e 1903 {
mbed_official 610:813dcc80987e 1904 if (sConfigInjected->AutoInjectedConv == ENABLE)
mbed_official 610:813dcc80987e 1905 {
mbed_official 610:813dcc80987e 1906 SET_BIT(hadc->Instance->CFGR, ADC_CFGR_JAUTO);
mbed_official 610:813dcc80987e 1907 }
mbed_official 610:813dcc80987e 1908 else
mbed_official 610:813dcc80987e 1909 {
mbed_official 610:813dcc80987e 1910 CLEAR_BIT(hadc->Instance->CFGR, ADC_CFGR_JAUTO);
mbed_official 610:813dcc80987e 1911 }
mbed_official 610:813dcc80987e 1912 }
mbed_official 610:813dcc80987e 1913 /* If Automatic injected conversion was intended to be set and could not */
mbed_official 610:813dcc80987e 1914 /* due to injected group external triggers enabled, error is reported. */
mbed_official 610:813dcc80987e 1915 else
mbed_official 610:813dcc80987e 1916 {
mbed_official 610:813dcc80987e 1917 if (sConfigInjected->AutoInjectedConv == ENABLE)
mbed_official 610:813dcc80987e 1918 {
mbed_official 610:813dcc80987e 1919 /* Update ADC state machine to error */
mbed_official 610:813dcc80987e 1920 SET_BIT(hadc->State, HAL_ADC_STATE_ERROR_CONFIG);
mbed_official 610:813dcc80987e 1921
mbed_official 610:813dcc80987e 1922 tmp_status = HAL_ERROR;
mbed_official 610:813dcc80987e 1923 }
mbed_official 610:813dcc80987e 1924 else
mbed_official 610:813dcc80987e 1925 {
mbed_official 610:813dcc80987e 1926 CLEAR_BIT(hadc->Instance->CFGR, ADC_CFGR_JAUTO);
mbed_official 610:813dcc80987e 1927 }
mbed_official 610:813dcc80987e 1928 }
mbed_official 610:813dcc80987e 1929
mbed_official 610:813dcc80987e 1930
mbed_official 610:813dcc80987e 1931
mbed_official 610:813dcc80987e 1932 if (sConfigInjected->InjecOversamplingMode == ENABLE)
mbed_official 610:813dcc80987e 1933 {
mbed_official 610:813dcc80987e 1934 assert_param(IS_ADC_OVERSAMPLING_RATIO(sConfigInjected->InjecOversampling.Ratio));
mbed_official 610:813dcc80987e 1935 assert_param(IS_ADC_RIGHT_BIT_SHIFT(sConfigInjected->InjecOversampling.RightBitShift));
mbed_official 610:813dcc80987e 1936
mbed_official 610:813dcc80987e 1937 /* JOVSE must be reset in case of triggered regular mode */
mbed_official 610:813dcc80987e 1938 assert_param(!(READ_BIT(hadc->Instance->CFGR2, ADC_CFGR2_ROVSE|ADC_CFGR2_TROVS) == (ADC_CFGR2_ROVSE|ADC_CFGR2_TROVS)));
mbed_official 610:813dcc80987e 1939
mbed_official 610:813dcc80987e 1940 /* Configuration of Injected Oversampler: */
mbed_official 610:813dcc80987e 1941 /* - Oversampling Ratio */
mbed_official 610:813dcc80987e 1942 /* - Right bit shift */
mbed_official 610:813dcc80987e 1943
mbed_official 610:813dcc80987e 1944 /* Enable OverSampling mode */
mbed_official 610:813dcc80987e 1945
mbed_official 610:813dcc80987e 1946 MODIFY_REG(hadc->Instance->CFGR2, ADC_CFGR2_INJ_FIELDS,
mbed_official 610:813dcc80987e 1947 ADC_CFGR2_JOVSE |
mbed_official 610:813dcc80987e 1948 sConfigInjected->InjecOversampling.Ratio |
mbed_official 610:813dcc80987e 1949 sConfigInjected->InjecOversampling.RightBitShift );
mbed_official 610:813dcc80987e 1950 }
mbed_official 610:813dcc80987e 1951 else
mbed_official 610:813dcc80987e 1952 {
mbed_official 610:813dcc80987e 1953 /* Disable Regular OverSampling */
mbed_official 610:813dcc80987e 1954 CLEAR_BIT( hadc->Instance->CFGR2, ADC_CFGR2_JOVSE);
mbed_official 610:813dcc80987e 1955 }
mbed_official 610:813dcc80987e 1956
mbed_official 610:813dcc80987e 1957
mbed_official 610:813dcc80987e 1958 /* Sampling time configuration of the selected channel */
mbed_official 610:813dcc80987e 1959 /* if ADC_Channel_10 ... ADC_Channel_18 is selected */
mbed_official 610:813dcc80987e 1960 if (sConfigInjected->InjectedChannel >= ADC_CHANNEL_10)
mbed_official 610:813dcc80987e 1961 {
mbed_official 610:813dcc80987e 1962 /* Clear the old sample time and set the new one */
mbed_official 610:813dcc80987e 1963 MODIFY_REG(hadc->Instance->SMPR2,
mbed_official 610:813dcc80987e 1964 ADC_SMPR2(ADC_SMPR2_SMP10, sConfigInjected->InjectedChannel),
mbed_official 610:813dcc80987e 1965 ADC_SMPR2(sConfigInjected->InjectedSamplingTime, sConfigInjected->InjectedChannel));
mbed_official 610:813dcc80987e 1966 }
mbed_official 610:813dcc80987e 1967 else /* if ADC_Channel_0 ... ADC_Channel_9 is selected */
mbed_official 610:813dcc80987e 1968 {
mbed_official 610:813dcc80987e 1969 /* Clear the old sample time and set the new one */
mbed_official 610:813dcc80987e 1970 MODIFY_REG(hadc->Instance->SMPR1,
mbed_official 610:813dcc80987e 1971 ADC_SMPR1(ADC_SMPR1_SMP0, sConfigInjected->InjectedChannel),
mbed_official 610:813dcc80987e 1972 ADC_SMPR1(sConfigInjected->InjectedSamplingTime, sConfigInjected->InjectedChannel));
mbed_official 610:813dcc80987e 1973 }
mbed_official 610:813dcc80987e 1974
mbed_official 610:813dcc80987e 1975
mbed_official 610:813dcc80987e 1976 /* Configure the offset: offset enable/disable, channel, offset value */
mbed_official 610:813dcc80987e 1977
mbed_official 610:813dcc80987e 1978 /* Shift the offset with respect to the selected ADC resolution. */
mbed_official 610:813dcc80987e 1979 /* Offset has to be left-aligned on bit 11, the LSB (right bits) are set to 0 */
mbed_official 610:813dcc80987e 1980 tmpOffsetShifted = ADC_OFFSET_SHIFT_RESOLUTION(hadc, sConfigInjected->InjectedOffset);
mbed_official 610:813dcc80987e 1981
mbed_official 610:813dcc80987e 1982 switch (sConfigInjected->InjectedOffsetNumber)
mbed_official 610:813dcc80987e 1983 {
mbed_official 610:813dcc80987e 1984 case ADC_OFFSET_1:
mbed_official 610:813dcc80987e 1985 /* Configure offset register 1: */
mbed_official 610:813dcc80987e 1986 /* - Enable offset */
mbed_official 610:813dcc80987e 1987 /* - Set channel number */
mbed_official 610:813dcc80987e 1988 /* - Set offset value */
mbed_official 610:813dcc80987e 1989 MODIFY_REG(hadc->Instance->OFR1,
mbed_official 610:813dcc80987e 1990 ADC_OFR1_OFFSET1 | ADC_OFR1_OFFSET1_CH | ADC_OFR1_OFFSET1_EN,
mbed_official 610:813dcc80987e 1991 ADC_OFR1_OFFSET1_EN | ADC_OFR_CHANNEL(sConfigInjected->InjectedChannel) | tmpOffsetShifted);
mbed_official 610:813dcc80987e 1992 break;
mbed_official 610:813dcc80987e 1993
mbed_official 610:813dcc80987e 1994 case ADC_OFFSET_2:
mbed_official 610:813dcc80987e 1995 /* Configure offset register 2: */
mbed_official 610:813dcc80987e 1996 /* - Enable offset */
mbed_official 610:813dcc80987e 1997 /* - Set channel number */
mbed_official 610:813dcc80987e 1998 /* - Set offset value */
mbed_official 610:813dcc80987e 1999 MODIFY_REG(hadc->Instance->OFR2,
mbed_official 610:813dcc80987e 2000 ADC_OFR2_OFFSET2 | ADC_OFR2_OFFSET2_CH | ADC_OFR2_OFFSET2_EN,
mbed_official 610:813dcc80987e 2001 ADC_OFR2_OFFSET2_EN | ADC_OFR_CHANNEL(sConfigInjected->InjectedChannel) | tmpOffsetShifted);
mbed_official 610:813dcc80987e 2002 break;
mbed_official 610:813dcc80987e 2003
mbed_official 610:813dcc80987e 2004 case ADC_OFFSET_3:
mbed_official 610:813dcc80987e 2005 /* Configure offset register 3: */
mbed_official 610:813dcc80987e 2006 /* - Enable offset */
mbed_official 610:813dcc80987e 2007 /* - Set channel number */
mbed_official 610:813dcc80987e 2008 /* - Set offset value */
mbed_official 610:813dcc80987e 2009 MODIFY_REG(hadc->Instance->OFR3,
mbed_official 610:813dcc80987e 2010 ADC_OFR3_OFFSET3 | ADC_OFR3_OFFSET3_CH | ADC_OFR3_OFFSET3_EN,
mbed_official 610:813dcc80987e 2011 ADC_OFR3_OFFSET3_EN | ADC_OFR_CHANNEL(sConfigInjected->InjectedChannel) | tmpOffsetShifted);
mbed_official 610:813dcc80987e 2012 break;
mbed_official 610:813dcc80987e 2013
mbed_official 610:813dcc80987e 2014 case ADC_OFFSET_4:
mbed_official 610:813dcc80987e 2015 /* Configure offset register 1: */
mbed_official 610:813dcc80987e 2016 /* - Enable offset */
mbed_official 610:813dcc80987e 2017 /* - Set channel number */
mbed_official 610:813dcc80987e 2018 /* - Set offset value */
mbed_official 610:813dcc80987e 2019 MODIFY_REG(hadc->Instance->OFR4,
mbed_official 610:813dcc80987e 2020 ADC_OFR4_OFFSET4 | ADC_OFR4_OFFSET4_CH | ADC_OFR4_OFFSET4_EN,
mbed_official 610:813dcc80987e 2021 ADC_OFR4_OFFSET4_EN | ADC_OFR_CHANNEL(sConfigInjected->InjectedChannel) | tmpOffsetShifted);
mbed_official 610:813dcc80987e 2022 break;
mbed_official 610:813dcc80987e 2023
mbed_official 610:813dcc80987e 2024 /* Case ADC_OFFSET_NONE */
mbed_official 610:813dcc80987e 2025 default :
mbed_official 610:813dcc80987e 2026 /* Scan OFR1, OFR2, OFR3, OFR4 to check if the selected channel is enabled. If this is the case, offset OFRx is disabled. */
mbed_official 610:813dcc80987e 2027 if (((hadc->Instance->OFR1) & ADC_OFR1_OFFSET1_CH) == ADC_OFR_CHANNEL(sConfigInjected->InjectedChannel))
mbed_official 610:813dcc80987e 2028 {
mbed_official 610:813dcc80987e 2029 /* Disable offset OFR1*/
mbed_official 610:813dcc80987e 2030 CLEAR_BIT(hadc->Instance->OFR1, ADC_OFR1_OFFSET1_EN);
mbed_official 610:813dcc80987e 2031 }
mbed_official 610:813dcc80987e 2032 if (((hadc->Instance->OFR2) & ADC_OFR2_OFFSET2_CH) == ADC_OFR_CHANNEL(sConfigInjected->InjectedChannel))
mbed_official 610:813dcc80987e 2033 {
mbed_official 610:813dcc80987e 2034 /* Disable offset OFR2*/
mbed_official 610:813dcc80987e 2035 CLEAR_BIT(hadc->Instance->OFR2, ADC_OFR2_OFFSET2_EN);
mbed_official 610:813dcc80987e 2036 }
mbed_official 610:813dcc80987e 2037 if (((hadc->Instance->OFR3) & ADC_OFR3_OFFSET3_CH) == ADC_OFR_CHANNEL(sConfigInjected->InjectedChannel))
mbed_official 610:813dcc80987e 2038 {
mbed_official 610:813dcc80987e 2039 /* Disable offset OFR3*/
mbed_official 610:813dcc80987e 2040 CLEAR_BIT(hadc->Instance->OFR3, ADC_OFR3_OFFSET3_EN);
mbed_official 610:813dcc80987e 2041 }
mbed_official 610:813dcc80987e 2042 if (((hadc->Instance->OFR4) & ADC_OFR4_OFFSET4_CH) == ADC_OFR_CHANNEL(sConfigInjected->InjectedChannel))
mbed_official 610:813dcc80987e 2043 {
mbed_official 610:813dcc80987e 2044 /* Disable offset OFR4*/
mbed_official 610:813dcc80987e 2045 CLEAR_BIT(hadc->Instance->OFR4, ADC_OFR4_OFFSET4_EN);
mbed_official 610:813dcc80987e 2046 }
mbed_official 610:813dcc80987e 2047 break;
mbed_official 610:813dcc80987e 2048 }
mbed_official 610:813dcc80987e 2049
mbed_official 610:813dcc80987e 2050 } /* if (ADC_IS_CONVERSION_ONGOING_REGULAR_INJECTED(hadc) == RESET) */
mbed_official 610:813dcc80987e 2051
mbed_official 610:813dcc80987e 2052
mbed_official 610:813dcc80987e 2053 /* Parameters update conditioned to ADC state: */
mbed_official 610:813dcc80987e 2054 /* Parameters that can be updated only when ADC is disabled: */
mbed_official 610:813dcc80987e 2055 /* - Single or differential mode */
mbed_official 610:813dcc80987e 2056 /* - Internal measurement channels: Vbat/VrefInt/TempSensor */
mbed_official 610:813dcc80987e 2057 if (ADC_IS_ENABLE(hadc) == RESET)
mbed_official 610:813dcc80987e 2058 {
mbed_official 610:813dcc80987e 2059 /* Configuration of differential mode */
mbed_official 610:813dcc80987e 2060 if (sConfigInjected->InjectedSingleDiff != ADC_DIFFERENTIAL_ENDED)
mbed_official 610:813dcc80987e 2061 {
mbed_official 610:813dcc80987e 2062 /* Disable differential mode (default mode: single-ended) */
mbed_official 610:813dcc80987e 2063 CLEAR_BIT(hadc->Instance->DIFSEL, ADC_DIFSEL_CHANNEL(sConfigInjected->InjectedChannel));
mbed_official 610:813dcc80987e 2064 }
mbed_official 610:813dcc80987e 2065 else
mbed_official 610:813dcc80987e 2066 {
mbed_official 610:813dcc80987e 2067 /* Enable differential mode */
mbed_official 610:813dcc80987e 2068 SET_BIT(hadc->Instance->DIFSEL, ADC_DIFSEL_CHANNEL(sConfigInjected->InjectedChannel));
mbed_official 610:813dcc80987e 2069
mbed_official 610:813dcc80987e 2070 /* Sampling time configuration of channel ADC_IN+1 (negative input) */
mbed_official 610:813dcc80987e 2071 /* For channels 9 to 15 for ADC1, ADC2, 9 to 11 for ADC3 */
mbed_official 610:813dcc80987e 2072 if (sConfigInjected->InjectedChannel >= ADC_CHANNEL_9)
mbed_official 610:813dcc80987e 2073 {
mbed_official 610:813dcc80987e 2074 /* Clear the old sample time and set the new one */
mbed_official 610:813dcc80987e 2075 MODIFY_REG(hadc->Instance->SMPR2,
mbed_official 610:813dcc80987e 2076 ADC_SMPR2(ADC_SMPR2_SMP10, sConfigInjected->InjectedChannel +1),
mbed_official 610:813dcc80987e 2077 ADC_SMPR2(sConfigInjected->InjectedSamplingTime, sConfigInjected->InjectedChannel +1));
mbed_official 610:813dcc80987e 2078 }
mbed_official 610:813dcc80987e 2079 else /* For channels 0 to 8 */
mbed_official 610:813dcc80987e 2080 {
mbed_official 610:813dcc80987e 2081 /* Clear the old sample time and set the new one */
mbed_official 610:813dcc80987e 2082 MODIFY_REG(hadc->Instance->SMPR1,
mbed_official 610:813dcc80987e 2083 ADC_SMPR1(ADC_SMPR1_SMP0, sConfigInjected->InjectedChannel +1),
mbed_official 610:813dcc80987e 2084 ADC_SMPR1(sConfigInjected->InjectedSamplingTime, sConfigInjected->InjectedChannel +1));
mbed_official 610:813dcc80987e 2085 }
mbed_official 610:813dcc80987e 2086 }
mbed_official 610:813dcc80987e 2087
mbed_official 610:813dcc80987e 2088
mbed_official 610:813dcc80987e 2089 /* Management of internal measurement channels: Vbat/VrefInt/TempSensor */
mbed_official 610:813dcc80987e 2090 /* internal measurement paths enable: If internal channel selected, */
mbed_official 610:813dcc80987e 2091 /* enable dedicated internal buffers and path. */
mbed_official 610:813dcc80987e 2092 /* Note: these internal measurement paths can be disabled using */
mbed_official 610:813dcc80987e 2093 /* HAL_ADC_DeInit(). */
mbed_official 610:813dcc80987e 2094
mbed_official 610:813dcc80987e 2095 /* Configuration of common ADC parameters */
mbed_official 610:813dcc80987e 2096
mbed_official 610:813dcc80987e 2097 tmpADC_Common = ADC_COMMON_REGISTER(hadc);
mbed_official 610:813dcc80987e 2098
mbed_official 610:813dcc80987e 2099 /* If the requested internal measurement path has already been enabled, */
mbed_official 610:813dcc80987e 2100 /* bypass the configuration processing. */
mbed_official 610:813dcc80987e 2101 if (( (sConfigInjected->InjectedChannel == ADC_CHANNEL_TEMPSENSOR) &&
mbed_official 610:813dcc80987e 2102 (HAL_IS_BIT_CLR(tmpADC_Common->CCR, ADC_CCR_TSEN)) ) ||
mbed_official 610:813dcc80987e 2103 ( (sConfigInjected->InjectedChannel == ADC_CHANNEL_VBAT) &&
mbed_official 610:813dcc80987e 2104 (HAL_IS_BIT_CLR(tmpADC_Common->CCR, ADC_CCR_VBATEN)) ) ||
mbed_official 610:813dcc80987e 2105 ( (sConfigInjected->InjectedChannel == ADC_CHANNEL_VREFINT) &&
mbed_official 610:813dcc80987e 2106 (HAL_IS_BIT_CLR(tmpADC_Common->CCR, ADC_CCR_VREFEN)))
mbed_official 610:813dcc80987e 2107 )
mbed_official 610:813dcc80987e 2108 {
mbed_official 610:813dcc80987e 2109 /* Configuration of common ADC parameters (continuation) */
mbed_official 610:813dcc80987e 2110 /* Software is allowed to change common parameters only when all ADCs */
mbed_official 610:813dcc80987e 2111 /* of the common group are disabled. */
mbed_official 610:813dcc80987e 2112 if ((ADC_IS_ENABLE(hadc) == RESET) &&
mbed_official 610:813dcc80987e 2113 (ADC_ANY_OTHER_ENABLED(hadc) == RESET) )
mbed_official 610:813dcc80987e 2114 {
mbed_official 610:813dcc80987e 2115 /* If Channel 17 is selected, enable Temp. sensor measurement path */
mbed_official 610:813dcc80987e 2116 /* Note: Temp. sensor internal channels available on ADC1 and ADC3 */
mbed_official 610:813dcc80987e 2117 if ((sConfigInjected->InjectedChannel == ADC_CHANNEL_TEMPSENSOR) &&
mbed_official 610:813dcc80987e 2118 ((hadc->Instance == ADC1) || (hadc->Instance == ADC3)))
mbed_official 610:813dcc80987e 2119 {
mbed_official 610:813dcc80987e 2120 SET_BIT(tmpADC_Common->CCR, ADC_CCR_TSEN);
mbed_official 610:813dcc80987e 2121
mbed_official 610:813dcc80987e 2122 /* Delay for temperature sensor stabilization time */
mbed_official 610:813dcc80987e 2123 while(WaitLoopIndex < ADC_TEMPSENSOR_DELAY_CPU_CYCLES)
mbed_official 610:813dcc80987e 2124 {
mbed_official 610:813dcc80987e 2125 WaitLoopIndex++;
mbed_official 610:813dcc80987e 2126 }
mbed_official 610:813dcc80987e 2127 }
mbed_official 610:813dcc80987e 2128 /* If Channel 18 is selected, enable VBAT measurement path */
mbed_official 610:813dcc80987e 2129 /* Note: VBAT internal channels available on ADC1 and ADC3 */
mbed_official 610:813dcc80987e 2130 else if ((sConfigInjected->InjectedChannel == ADC_CHANNEL_VBAT) &&
mbed_official 610:813dcc80987e 2131 ((hadc->Instance == ADC1) || (hadc->Instance == ADC3)))
mbed_official 610:813dcc80987e 2132 {
mbed_official 610:813dcc80987e 2133 SET_BIT(tmpADC_Common->CCR, ADC_CCR_VBATEN);
mbed_official 610:813dcc80987e 2134 }
mbed_official 610:813dcc80987e 2135 /* If Channel 0 is selected, enable VREFINT measurement path */
mbed_official 610:813dcc80987e 2136 /* Note: VREFINT internal channels available only on ADC1 */
mbed_official 610:813dcc80987e 2137 else if ((sConfigInjected->InjectedChannel == ADC_CHANNEL_VREFINT)
mbed_official 610:813dcc80987e 2138 && (hadc->Instance == ADC1))
mbed_official 610:813dcc80987e 2139 {
mbed_official 610:813dcc80987e 2140 SET_BIT(tmpADC_Common->CCR, ADC_CCR_VREFEN);
mbed_official 610:813dcc80987e 2141 }
mbed_official 610:813dcc80987e 2142 else
mbed_official 610:813dcc80987e 2143 {
mbed_official 610:813dcc80987e 2144 /* Discrepancy found out between ADC instance and internal
mbed_official 610:813dcc80987e 2145 channel request */
mbed_official 610:813dcc80987e 2146 SET_BIT(hadc->State, HAL_ADC_STATE_ERROR_CONFIG);
mbed_official 610:813dcc80987e 2147 tmp_status = HAL_ERROR;
mbed_official 610:813dcc80987e 2148 }
mbed_official 610:813dcc80987e 2149 }
mbed_official 610:813dcc80987e 2150 /* If the requested internal measurement path has already been enabled */
mbed_official 610:813dcc80987e 2151 /* and other ADC of the common group are enabled, internal */
mbed_official 610:813dcc80987e 2152 /* measurement paths cannot be enabled. */
mbed_official 610:813dcc80987e 2153 else
mbed_official 610:813dcc80987e 2154 {
mbed_official 610:813dcc80987e 2155 /* Update ADC state machine to error */
mbed_official 610:813dcc80987e 2156 SET_BIT(hadc->State, HAL_ADC_STATE_ERROR_CONFIG);
mbed_official 610:813dcc80987e 2157
mbed_official 610:813dcc80987e 2158 tmp_status = HAL_ERROR;
mbed_official 610:813dcc80987e 2159 }
mbed_official 610:813dcc80987e 2160 }
mbed_official 610:813dcc80987e 2161
mbed_official 610:813dcc80987e 2162 } /* if (ADC_IS_ENABLE(hadc) == RESET) */
mbed_official 610:813dcc80987e 2163
mbed_official 610:813dcc80987e 2164 /* Process unlocked */
mbed_official 610:813dcc80987e 2165 __HAL_UNLOCK(hadc);
mbed_official 610:813dcc80987e 2166
mbed_official 610:813dcc80987e 2167 /* Return function status */
mbed_official 610:813dcc80987e 2168 return tmp_status;
mbed_official 610:813dcc80987e 2169 }
mbed_official 610:813dcc80987e 2170
mbed_official 610:813dcc80987e 2171
mbed_official 610:813dcc80987e 2172
mbed_official 610:813dcc80987e 2173
mbed_official 610:813dcc80987e 2174
mbed_official 610:813dcc80987e 2175 /**
mbed_official 610:813dcc80987e 2176 * @brief Enable ADC multimode and configure multimode parameters
mbed_official 610:813dcc80987e 2177 * @note Possibility to update parameters on the fly:
mbed_official 610:813dcc80987e 2178 * This function initializes multimode parameters, following
mbed_official 610:813dcc80987e 2179 * calls to this function can be used to reconfigure some parameters
mbed_official 610:813dcc80987e 2180 * of structure "ADC_MultiModeTypeDef" on the fly, without resetting
mbed_official 610:813dcc80987e 2181 * the ADCs.
mbed_official 610:813dcc80987e 2182 * The setting of these parameters is conditioned to ADC state.
mbed_official 610:813dcc80987e 2183 * For parameters constraints, see comments of structure
mbed_official 610:813dcc80987e 2184 * "ADC_MultiModeTypeDef".
mbed_official 610:813dcc80987e 2185 * @note To move back configuration from multimode to single mode, ADC must
mbed_official 610:813dcc80987e 2186 * be reset (using function HAL_ADC_Init() ).
mbed_official 610:813dcc80987e 2187 * @param hadc: Master ADC handle
mbed_official 610:813dcc80987e 2188 * @param multimode : Structure of ADC multimode configuration
mbed_official 610:813dcc80987e 2189 * @retval HAL status
mbed_official 610:813dcc80987e 2190 */
mbed_official 610:813dcc80987e 2191 HAL_StatusTypeDef HAL_ADCEx_MultiModeConfigChannel(ADC_HandleTypeDef* hadc, ADC_MultiModeTypeDef* multimode)
mbed_official 610:813dcc80987e 2192 {
mbed_official 610:813dcc80987e 2193 HAL_StatusTypeDef tmp_status = HAL_OK;
mbed_official 610:813dcc80987e 2194 ADC_Common_TypeDef *tmpADC_Common;
mbed_official 610:813dcc80987e 2195 ADC_HandleTypeDef tmphadcSlave;
mbed_official 610:813dcc80987e 2196
mbed_official 610:813dcc80987e 2197 /* Check the parameters */
mbed_official 610:813dcc80987e 2198 assert_param(IS_ADC_MULTIMODE_MASTER_INSTANCE(hadc->Instance));
mbed_official 610:813dcc80987e 2199 assert_param(IS_ADC_MULTIMODE(multimode->Mode));
mbed_official 610:813dcc80987e 2200 assert_param(IS_ADC_DMA_ACCESS_MULTIMODE(multimode->DMAAccessMode));
mbed_official 610:813dcc80987e 2201 assert_param(IS_ADC_SAMPLING_DELAY(multimode->TwoSamplingDelay));
mbed_official 610:813dcc80987e 2202
mbed_official 610:813dcc80987e 2203 /* Process locked */
mbed_official 610:813dcc80987e 2204 __HAL_LOCK(hadc);
mbed_official 610:813dcc80987e 2205
mbed_official 610:813dcc80987e 2206 ADC_MULTI_SLAVE(hadc, &tmphadcSlave);
mbed_official 610:813dcc80987e 2207
mbed_official 610:813dcc80987e 2208 /* Parameters update conditioned to ADC state: */
mbed_official 610:813dcc80987e 2209 /* Parameters that can be updated when ADC is disabled or enabled without */
mbed_official 610:813dcc80987e 2210 /* conversion on going on regular group: */
mbed_official 610:813dcc80987e 2211 /* - Multimode DMA configuration */
mbed_official 610:813dcc80987e 2212 /* - Multimode DMA mode */
mbed_official 610:813dcc80987e 2213 if ( (ADC_IS_CONVERSION_ONGOING_REGULAR(hadc) == RESET)
mbed_official 610:813dcc80987e 2214 && (ADC_IS_CONVERSION_ONGOING_REGULAR(&tmphadcSlave) == RESET) )
mbed_official 610:813dcc80987e 2215 {
mbed_official 610:813dcc80987e 2216
mbed_official 610:813dcc80987e 2217 /* Pointer to the common control register */
mbed_official 610:813dcc80987e 2218 tmpADC_Common = ADC_COMMON_REGISTER(hadc);
mbed_official 610:813dcc80987e 2219
mbed_official 610:813dcc80987e 2220 MODIFY_REG(tmpADC_Common->CCR, ADC_CCR_MDMA | ADC_CCR_DMACFG,
mbed_official 610:813dcc80987e 2221 multimode->DMAAccessMode |
mbed_official 610:813dcc80987e 2222 ADC_CCR_MULTI_DMACONTREQ(hadc->Init.DMAContinuousRequests));
mbed_official 610:813dcc80987e 2223
mbed_official 610:813dcc80987e 2224 /* Parameters that can be updated only when ADC is disabled: */
mbed_official 610:813dcc80987e 2225 /* - Multimode mode selection */
mbed_official 610:813dcc80987e 2226 /* - Multimode delay */
mbed_official 610:813dcc80987e 2227 if ((ADC_IS_ENABLE(hadc) == RESET) &&
mbed_official 610:813dcc80987e 2228 (ADC_IS_ENABLE(&tmphadcSlave) == RESET) )
mbed_official 610:813dcc80987e 2229 {
mbed_official 610:813dcc80987e 2230 /* Configuration of ADC common group ADC1&ADC2 */
mbed_official 610:813dcc80987e 2231 /* - set the selected multimode */
mbed_official 610:813dcc80987e 2232 /* - Set delay between two sampling phases */
mbed_official 610:813dcc80987e 2233 /* Note: Delay range depends on selected resolution: */
mbed_official 610:813dcc80987e 2234 /* from 1 to 12 clock cycles for 12 bits */
mbed_official 610:813dcc80987e 2235 /* from 1 to 10 clock cycles for 10 bits, */
mbed_official 610:813dcc80987e 2236 /* from 1 to 8 clock cycles for 8 bits */
mbed_official 610:813dcc80987e 2237 /* from 1 to 6 clock cycles for 6 bits */
mbed_official 610:813dcc80987e 2238 /* If a higher delay is selected, it will be clipped to maximum delay */
mbed_official 610:813dcc80987e 2239 /* range */
mbed_official 610:813dcc80987e 2240
mbed_official 610:813dcc80987e 2241 MODIFY_REG(tmpADC_Common->CCR, ADC_CCR_DUAL | ADC_CCR_DELAY,
mbed_official 610:813dcc80987e 2242 multimode->Mode | multimode->TwoSamplingDelay );
mbed_official 610:813dcc80987e 2243 }
mbed_official 610:813dcc80987e 2244
mbed_official 610:813dcc80987e 2245
mbed_official 610:813dcc80987e 2246 }
mbed_official 610:813dcc80987e 2247 /* If one of the ADC sharing the same common group is enabled, no update */
mbed_official 610:813dcc80987e 2248 /* could be done on neither of the multimode structure parameters. */
mbed_official 610:813dcc80987e 2249 else
mbed_official 610:813dcc80987e 2250 {
mbed_official 610:813dcc80987e 2251 /* Update ADC state machine to error */
mbed_official 610:813dcc80987e 2252 SET_BIT(hadc->State, HAL_ADC_STATE_ERROR_CONFIG);
mbed_official 610:813dcc80987e 2253
mbed_official 610:813dcc80987e 2254 tmp_status = HAL_ERROR;
mbed_official 610:813dcc80987e 2255 }
mbed_official 610:813dcc80987e 2256
mbed_official 610:813dcc80987e 2257
mbed_official 610:813dcc80987e 2258 /* Process unlocked */
mbed_official 610:813dcc80987e 2259 __HAL_UNLOCK(hadc);
mbed_official 610:813dcc80987e 2260
mbed_official 610:813dcc80987e 2261 /* Return function status */
mbed_official 610:813dcc80987e 2262 return tmp_status;
mbed_official 610:813dcc80987e 2263 }
mbed_official 610:813dcc80987e 2264
mbed_official 610:813dcc80987e 2265
mbed_official 610:813dcc80987e 2266
mbed_official 610:813dcc80987e 2267 /**
mbed_official 610:813dcc80987e 2268 * @brief Enable Injected Queue
mbed_official 610:813dcc80987e 2269 * @note This function resets CFGR register JQDIS bit in order to enable the
mbed_official 610:813dcc80987e 2270 * Injected Queue. JQDIS can be written only when ADSTART and JDSTART
mbed_official 610:813dcc80987e 2271 * are both equal to 0 to ensure that no regular nor injected
mbed_official 610:813dcc80987e 2272 * conversion is ongoing.
mbed_official 610:813dcc80987e 2273 * @param hadc: ADC handle
mbed_official 610:813dcc80987e 2274 * @retval HAL status
mbed_official 610:813dcc80987e 2275 */
mbed_official 610:813dcc80987e 2276 HAL_StatusTypeDef HAL_ADCEx_EnableInjectedQueue(ADC_HandleTypeDef* hadc)
mbed_official 610:813dcc80987e 2277 {
mbed_official 610:813dcc80987e 2278
mbed_official 610:813dcc80987e 2279 /* Parameter can be set only if no conversion is on-going */
mbed_official 610:813dcc80987e 2280 if (ADC_IS_CONVERSION_ONGOING_REGULAR_INJECTED(hadc) == RESET)
mbed_official 610:813dcc80987e 2281 {
mbed_official 610:813dcc80987e 2282 CLEAR_BIT(hadc->Instance->CFGR, ADC_CFGR_JQDIS);
mbed_official 610:813dcc80987e 2283
mbed_official 610:813dcc80987e 2284 /* Update state, clear previous result related to injected queue overflow */
mbed_official 610:813dcc80987e 2285 CLEAR_BIT(hadc->State, HAL_ADC_STATE_INJ_JQOVF);
mbed_official 610:813dcc80987e 2286
mbed_official 610:813dcc80987e 2287 return HAL_OK;
mbed_official 610:813dcc80987e 2288 }
mbed_official 610:813dcc80987e 2289 else
mbed_official 610:813dcc80987e 2290 {
mbed_official 610:813dcc80987e 2291 return HAL_ERROR;
mbed_official 610:813dcc80987e 2292 }
mbed_official 610:813dcc80987e 2293
mbed_official 610:813dcc80987e 2294 }
mbed_official 610:813dcc80987e 2295
mbed_official 610:813dcc80987e 2296 /**
mbed_official 610:813dcc80987e 2297 * @brief Disable Injected Queue
mbed_official 610:813dcc80987e 2298 * @note This function sets CFGR register JQDIS bit in order to disable the
mbed_official 610:813dcc80987e 2299 * Injected Queue. JQDIS can be written only when ADSTART and JDSTART
mbed_official 610:813dcc80987e 2300 * are both equal to 0 to ensure that no regular nor injected
mbed_official 610:813dcc80987e 2301 * conversion is ongoing.
mbed_official 610:813dcc80987e 2302 * @param hadc: ADC handle
mbed_official 610:813dcc80987e 2303 * @retval HAL status
mbed_official 610:813dcc80987e 2304 */
mbed_official 610:813dcc80987e 2305 HAL_StatusTypeDef HAL_ADCEx_DisableInjectedQueue(ADC_HandleTypeDef* hadc)
mbed_official 610:813dcc80987e 2306 {
mbed_official 610:813dcc80987e 2307
mbed_official 610:813dcc80987e 2308 /* Parameter can be set only if no conversion is on-going */
mbed_official 610:813dcc80987e 2309 if (ADC_IS_CONVERSION_ONGOING_REGULAR_INJECTED(hadc) == RESET)
mbed_official 610:813dcc80987e 2310 {
mbed_official 610:813dcc80987e 2311 SET_BIT(hadc->Instance->CFGR, ADC_CFGR_JQDIS);
mbed_official 610:813dcc80987e 2312 return HAL_OK;
mbed_official 610:813dcc80987e 2313 }
mbed_official 610:813dcc80987e 2314 else
mbed_official 610:813dcc80987e 2315 {
mbed_official 610:813dcc80987e 2316 return HAL_ERROR;
mbed_official 610:813dcc80987e 2317 }
mbed_official 610:813dcc80987e 2318
mbed_official 610:813dcc80987e 2319 }
mbed_official 610:813dcc80987e 2320
mbed_official 610:813dcc80987e 2321
mbed_official 610:813dcc80987e 2322 /**
mbed_official 610:813dcc80987e 2323 * @brief Disable ADC voltage regulator.
mbed_official 610:813dcc80987e 2324 * @note Disabling voltage regulator allows to save power. This operation can
mbed_official 610:813dcc80987e 2325 * be carried out only when ADC is disabled.
mbed_official 610:813dcc80987e 2326 * @note To enable again the voltage regulator, the user is expected to
mbed_official 610:813dcc80987e 2327 * resort to HAL_ADC_Init() API.
mbed_official 610:813dcc80987e 2328 * @param hadc: ADC handle
mbed_official 610:813dcc80987e 2329 * @retval HAL status
mbed_official 610:813dcc80987e 2330 */
mbed_official 610:813dcc80987e 2331 HAL_StatusTypeDef HAL_ADCEx_DisableVoltageRegulator(ADC_HandleTypeDef* hadc)
mbed_official 610:813dcc80987e 2332 {
mbed_official 610:813dcc80987e 2333
mbed_official 610:813dcc80987e 2334 /* ADVREGEN can be written only when the ADC is disabled */
mbed_official 610:813dcc80987e 2335 if (ADC_IS_ENABLE(hadc) == RESET)
mbed_official 610:813dcc80987e 2336 {
mbed_official 610:813dcc80987e 2337 CLEAR_BIT(hadc->Instance->CR, ADC_CR_ADVREGEN);
mbed_official 610:813dcc80987e 2338 return HAL_OK;
mbed_official 610:813dcc80987e 2339 }
mbed_official 610:813dcc80987e 2340 else
mbed_official 610:813dcc80987e 2341 {
mbed_official 610:813dcc80987e 2342 return HAL_ERROR;
mbed_official 610:813dcc80987e 2343 }
mbed_official 610:813dcc80987e 2344 }
mbed_official 610:813dcc80987e 2345
mbed_official 610:813dcc80987e 2346 /**
mbed_official 610:813dcc80987e 2347 * @brief Enter ADC deep-power-down mode
mbed_official 610:813dcc80987e 2348 * @note This mode is achieved in setting DEEPPWD bit and allows to save power
mbed_official 610:813dcc80987e 2349 * in reducing leakage currents. It is particularly interesting before
mbed_official 610:813dcc80987e 2350 * entering STOP1 or STOP2 modes.
mbed_official 610:813dcc80987e 2351 * @note Setting DEEPPWD automatically clears ADVREGEN bit and disables the
mbed_official 610:813dcc80987e 2352 * ADC voltage regulator. This means that this API encompasses
mbed_official 610:813dcc80987e 2353 * HAL_ADCEx_DisableVoltageRegulator(). Additionally, the internal
mbed_official 610:813dcc80987e 2354 * calibration is lost.
mbed_official 610:813dcc80987e 2355 * @note To exit the ADC deep-power-down mode, the user is expected to
mbed_official 610:813dcc80987e 2356 * resort to HAL_ADC_Init() API as well as to relaunch a calibration
mbed_official 610:813dcc80987e 2357 * with HAL_ADCEx_Calibration_Start() API or to re-apply a previously
mbed_official 610:813dcc80987e 2358 * saved calibration factor.
mbed_official 610:813dcc80987e 2359 * @param hadc: ADC handle
mbed_official 610:813dcc80987e 2360 * @retval HAL status
mbed_official 610:813dcc80987e 2361 */
mbed_official 610:813dcc80987e 2362 HAL_StatusTypeDef HAL_ADCEx_EnterADCDeepPowerDownMode(ADC_HandleTypeDef* hadc)
mbed_official 610:813dcc80987e 2363 {
mbed_official 610:813dcc80987e 2364
mbed_official 610:813dcc80987e 2365 /* DEEPPWD can be written only when the ADC is disabled */
mbed_official 610:813dcc80987e 2366 if (ADC_IS_ENABLE(hadc) == RESET)
mbed_official 610:813dcc80987e 2367 {
mbed_official 610:813dcc80987e 2368 SET_BIT(hadc->Instance->CR, ADC_CR_DEEPPWD);
mbed_official 610:813dcc80987e 2369 return HAL_OK;
mbed_official 610:813dcc80987e 2370 }
mbed_official 610:813dcc80987e 2371 else
mbed_official 610:813dcc80987e 2372 {
mbed_official 610:813dcc80987e 2373 return HAL_ERROR;
mbed_official 610:813dcc80987e 2374 }
mbed_official 610:813dcc80987e 2375 }
mbed_official 610:813dcc80987e 2376
mbed_official 610:813dcc80987e 2377 /**
mbed_official 610:813dcc80987e 2378 * @}
mbed_official 610:813dcc80987e 2379 */
mbed_official 610:813dcc80987e 2380
mbed_official 610:813dcc80987e 2381 /**
mbed_official 610:813dcc80987e 2382 * @}
mbed_official 610:813dcc80987e 2383 */
mbed_official 610:813dcc80987e 2384
mbed_official 610:813dcc80987e 2385
mbed_official 610:813dcc80987e 2386
mbed_official 610:813dcc80987e 2387 #endif /* HAL_ADC_MODULE_ENABLED */
mbed_official 610:813dcc80987e 2388 /**
mbed_official 610:813dcc80987e 2389 * @}
mbed_official 610:813dcc80987e 2390 */
mbed_official 610:813dcc80987e 2391
mbed_official 610:813dcc80987e 2392 /**
mbed_official 610:813dcc80987e 2393 * @}
mbed_official 610:813dcc80987e 2394 */
mbed_official 610:813dcc80987e 2395
mbed_official 610:813dcc80987e 2396 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/