mbed official / mbed-src

mbed library sources

Dependents:   Encrypted my_mbed lklk CyaSSL_DTLS_Cellular ... more

Superseded

This library was superseded by mbed-dev - https://os.mbed.com/users/mbed_official/code/mbed-dev/.

Development branch of the mbed library sources. This library is kept in synch with the latest changes from the mbed SDK and it is not guaranteed to work.

If you are looking for a stable and tested release, please import one of the official mbed library releases:

Import librarymbed

The official Mbed 2 C/C++ SDK provides the software platform and libraries to build your applications.

Last commit 20 Feb 2019 by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32L4/stm32l4xx_hal_adc_ex.c@610:813dcc80987e, 2015-08-14 (annotated)

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



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



DISCO_F746NG - Improvements

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mbed_official 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****/