TUKS MCU Introductory course / TUKS-COURSE-TIMER

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

HAL_L476/stm32l4xx_hal_adc_ex.c@2:5acdd8565d02, 2017-02-25 (annotated)

Committer:
elmot
Date:
Sat Feb 25 00:23:53 2017 +0000
Revision:
2:5acdd8565d02
Parent:
1:d0dfbce63a89 
Ready to show

Who changed what in which revision?

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