mbed official / mbed-src

mbed library sources

Dependents:   Encrypted my_mbed lklk CyaSSL_DTLS_Cellular ... more

Superseded

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

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

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

Import librarymbed

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

Last commit 20 Feb 2019 by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32L1/stm32l1xx_hal_adc_ex.c@579:53297373a894, 2015-07-01 (annotated)

Committer:
mbed_official
Date:
Wed Jul 01 09:45:11 2015 +0100
Revision:
579:53297373a894
Parent:
394:83f921546702 
Synchronized with git revision d5b4d2ab9c47edb4dc5776e7177b0c2263459081



Full URL: https://github.com/mbedmicro/mbed/commit/d5b4d2ab9c47edb4dc5776e7177b0c2263459081/



Initial version of drivers for SAMR21

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mbed_official 354:e67efb2aab0e 1 /**
mbed_official 354:e67efb2aab0e 2 ******************************************************************************
mbed_official 354:e67efb2aab0e 3 * @file stm32l1xx_hal_adc_ex.c
mbed_official 354:e67efb2aab0e 4 * @author MCD Application Team
mbed_official 354:e67efb2aab0e 5 * @version V1.0.0
mbed_official 354:e67efb2aab0e 6 * @date 5-September-2014
mbed_official 354:e67efb2aab0e 7 * @brief This file provides firmware functions to manage the following
mbed_official 354:e67efb2aab0e 8 * functionalities of the Analog to Digital Convertor (ADC)
mbed_official 354:e67efb2aab0e 9 * peripheral:
mbed_official 354:e67efb2aab0e 10 * + Initialization and de-initialization functions
mbed_official 354:e67efb2aab0e 11 * ++ Initialization and Configuration of ADC
mbed_official 354:e67efb2aab0e 12 * + Operation functions
mbed_official 354:e67efb2aab0e 13 * ++ Start, stop, get result of conversions of regular
mbed_official 354:e67efb2aab0e 14 * group, using 3 possible modes: polling, interruption or DMA.
mbed_official 354:e67efb2aab0e 15 * + Control functions
mbed_official 354:e67efb2aab0e 16 * ++ Analog Watchdog configuration
mbed_official 354:e67efb2aab0e 17 * ++ Channels configuration on regular group
mbed_official 354:e67efb2aab0e 18 * + State functions
mbed_official 354:e67efb2aab0e 19 * ++ ADC state machine management
mbed_official 354:e67efb2aab0e 20 * ++ Interrupts and flags management
mbed_official 354:e67efb2aab0e 21 * Other functions (generic functions) are available in file
mbed_official 354:e67efb2aab0e 22 * "stm32l1xx_hal_adc.c".
mbed_official 354:e67efb2aab0e 23 *
mbed_official 354:e67efb2aab0e 24 @verbatim
mbed_official 354:e67efb2aab0e 25 ==============================================================================
mbed_official 354:e67efb2aab0e 26 ##### How to use this driver #####
mbed_official 354:e67efb2aab0e 27 ==============================================================================
mbed_official 354:e67efb2aab0e 28 [..]
mbed_official 354:e67efb2aab0e 29
mbed_official 354:e67efb2aab0e 30 (#) Activate the ADC peripheral using one of the start functions:
mbed_official 354:e67efb2aab0e 31 HAL_ADCEx_InjectedStart(), HAL_ADCEx_InjectedStart_IT().
mbed_official 354:e67efb2aab0e 32
mbed_official 354:e67efb2aab0e 33 *** Channels configuration to injected group ***
mbed_official 354:e67efb2aab0e 34 ================================================
mbed_official 354:e67efb2aab0e 35 [..]
mbed_official 354:e67efb2aab0e 36 (+) To configure the ADC Injected channels group features, use
mbed_official 354:e67efb2aab0e 37 HAL_ADCEx_InjectedConfigChannel() functions.
mbed_official 354:e67efb2aab0e 38 (+) To activate the continuous mode, use the HAL_ADC_Init() function.
mbed_official 354:e67efb2aab0e 39 (+) To read the ADC converted values, use the HAL_ADCEx_InjectedGetValue()
mbed_official 354:e67efb2aab0e 40 function.
mbed_official 354:e67efb2aab0e 41
mbed_official 354:e67efb2aab0e 42 @endverbatim
mbed_official 354:e67efb2aab0e 43 ******************************************************************************
mbed_official 354:e67efb2aab0e 44 * @attention
mbed_official 354:e67efb2aab0e 45 *
mbed_official 354:e67efb2aab0e 46 * <h2><center>&copy; COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
mbed_official 354:e67efb2aab0e 47 *
mbed_official 354:e67efb2aab0e 48 * Redistribution and use in source and binary forms, with or without modification,
mbed_official 354:e67efb2aab0e 49 * are permitted provided that the following conditions are met:
mbed_official 354:e67efb2aab0e 50 * 1. Redistributions of source code must retain the above copyright notice,
mbed_official 354:e67efb2aab0e 51 * this list of conditions and the following disclaimer.
mbed_official 354:e67efb2aab0e 52 * 2. Redistributions in binary form must reproduce the above copyright notice,
mbed_official 354:e67efb2aab0e 53 * this list of conditions and the following disclaimer in the documentation
mbed_official 354:e67efb2aab0e 54 * and/or other materials provided with the distribution.
mbed_official 354:e67efb2aab0e 55 * 3. Neither the name of STMicroelectronics nor the names of its contributors
mbed_official 354:e67efb2aab0e 56 * may be used to endorse or promote products derived from this software
mbed_official 354:e67efb2aab0e 57 * without specific prior written permission.
mbed_official 354:e67efb2aab0e 58 *
mbed_official 354:e67efb2aab0e 59 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
mbed_official 354:e67efb2aab0e 60 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
mbed_official 354:e67efb2aab0e 61 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
mbed_official 354:e67efb2aab0e 62 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
mbed_official 354:e67efb2aab0e 63 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
mbed_official 354:e67efb2aab0e 64 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
mbed_official 354:e67efb2aab0e 65 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
mbed_official 354:e67efb2aab0e 66 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
mbed_official 354:e67efb2aab0e 67 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
mbed_official 354:e67efb2aab0e 68 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
mbed_official 354:e67efb2aab0e 69 *
mbed_official 354:e67efb2aab0e 70 ******************************************************************************
mbed_official 354:e67efb2aab0e 71 */
mbed_official 354:e67efb2aab0e 72
mbed_official 354:e67efb2aab0e 73 /* Includes ------------------------------------------------------------------*/
mbed_official 354:e67efb2aab0e 74 #include "stm32l1xx_hal.h"
mbed_official 354:e67efb2aab0e 75
mbed_official 354:e67efb2aab0e 76 /** @addtogroup STM32L1xx_HAL_Driver
mbed_official 354:e67efb2aab0e 77 * @{
mbed_official 354:e67efb2aab0e 78 */
mbed_official 354:e67efb2aab0e 79
mbed_official 354:e67efb2aab0e 80 /** @defgroup ADCEx ADCEx
mbed_official 354:e67efb2aab0e 81 * @brief ADC HAL module driver
mbed_official 354:e67efb2aab0e 82 * @{
mbed_official 354:e67efb2aab0e 83 */
mbed_official 354:e67efb2aab0e 84
mbed_official 354:e67efb2aab0e 85 #ifdef HAL_ADC_MODULE_ENABLED
mbed_official 354:e67efb2aab0e 86
mbed_official 354:e67efb2aab0e 87 /* Private typedef -----------------------------------------------------------*/
mbed_official 354:e67efb2aab0e 88 /* Private define ------------------------------------------------------------*/
mbed_official 354:e67efb2aab0e 89 /** @defgroup ADCEx_Private_Constants ADCEx Private Constants
mbed_official 354:e67efb2aab0e 90 * @{
mbed_official 354:e67efb2aab0e 91 */
mbed_official 354:e67efb2aab0e 92
mbed_official 354:e67efb2aab0e 93 /* ADC conversion cycles (unit: ADC clock cycles) */
mbed_official 354:e67efb2aab0e 94 /* (selected sampling time + conversion time of 12 ADC clock cycles, with */
mbed_official 354:e67efb2aab0e 95 /* resolution 12 bits) */
mbed_official 354:e67efb2aab0e 96 #define ADC_CONVERSIONCLOCKCYCLES_SAMPLETIME_4CYCLE5 ((uint32_t) 16)
mbed_official 354:e67efb2aab0e 97 #define ADC_CONVERSIONCLOCKCYCLES_SAMPLETIME_9CYCLES ((uint32_t) 21)
mbed_official 354:e67efb2aab0e 98 #define ADC_CONVERSIONCLOCKCYCLES_SAMPLETIME_16CYCLES ((uint32_t) 28)
mbed_official 354:e67efb2aab0e 99 #define ADC_CONVERSIONCLOCKCYCLES_SAMPLETIME_24CYCLES ((uint32_t) 36)
mbed_official 354:e67efb2aab0e 100 #define ADC_CONVERSIONCLOCKCYCLES_SAMPLETIME_48CYCLES ((uint32_t) 60)
mbed_official 354:e67efb2aab0e 101 #define ADC_CONVERSIONCLOCKCYCLES_SAMPLETIME_96CYCLES ((uint32_t)108)
mbed_official 354:e67efb2aab0e 102 #define ADC_CONVERSIONCLOCKCYCLES_SAMPLETIME_192CYCLES ((uint32_t)204)
mbed_official 354:e67efb2aab0e 103 #define ADC_CONVERSIONCLOCKCYCLES_SAMPLETIME_384CYCLES ((uint32_t)396)
mbed_official 354:e67efb2aab0e 104 /**
mbed_official 354:e67efb2aab0e 105 * @}
mbed_official 354:e67efb2aab0e 106 */
mbed_official 354:e67efb2aab0e 107
mbed_official 354:e67efb2aab0e 108 /* Private macro -------------------------------------------------------------*/
mbed_official 354:e67efb2aab0e 109 /* Private variables ---------------------------------------------------------*/
mbed_official 354:e67efb2aab0e 110 /* Private function prototypes -----------------------------------------------*/
mbed_official 354:e67efb2aab0e 111 /* Private functions ---------------------------------------------------------*/
mbed_official 354:e67efb2aab0e 112
mbed_official 354:e67efb2aab0e 113 /** @defgroup ADCEx_Exported_Functions ADCEx Exported Functions
mbed_official 354:e67efb2aab0e 114 * @{
mbed_official 354:e67efb2aab0e 115 */
mbed_official 354:e67efb2aab0e 116
mbed_official 354:e67efb2aab0e 117 /** @defgroup ADCEx_Exported_Functions_Group1 Extended Initialization/de-initialization functions
mbed_official 354:e67efb2aab0e 118 * @brief Extended Initialization and Configuration functions
mbed_official 354:e67efb2aab0e 119 *
mbed_official 354:e67efb2aab0e 120 @verbatim
mbed_official 354:e67efb2aab0e 121 ===============================================================================
mbed_official 354:e67efb2aab0e 122 ##### IO operation functions #####
mbed_official 354:e67efb2aab0e 123 ===============================================================================
mbed_official 354:e67efb2aab0e 124 [..] This section provides functions allowing to:
mbed_official 354:e67efb2aab0e 125 (+) Start conversion of injected group.
mbed_official 354:e67efb2aab0e 126 (+) Stop conversion of injected group.
mbed_official 354:e67efb2aab0e 127 (+) Poll for conversion complete on injected group.
mbed_official 354:e67efb2aab0e 128 (+) Get result of injected channel conversion.
mbed_official 354:e67efb2aab0e 129 (+) Start conversion of injected group and enable interruptions.
mbed_official 354:e67efb2aab0e 130 (+) Stop conversion of injected group and disable interruptions.
mbed_official 354:e67efb2aab0e 131
mbed_official 354:e67efb2aab0e 132 @endverbatim
mbed_official 354:e67efb2aab0e 133 * @{
mbed_official 354:e67efb2aab0e 134 */
mbed_official 354:e67efb2aab0e 135
mbed_official 354:e67efb2aab0e 136 /**
mbed_official 354:e67efb2aab0e 137 * @brief Enables ADC, starts conversion of injected group.
mbed_official 354:e67efb2aab0e 138 * Interruptions enabled in this function: None.
mbed_official 354:e67efb2aab0e 139 * @param hadc: ADC handle
mbed_official 354:e67efb2aab0e 140 * @retval HAL status
mbed_official 354:e67efb2aab0e 141 */
mbed_official 354:e67efb2aab0e 142 HAL_StatusTypeDef HAL_ADCEx_InjectedStart(ADC_HandleTypeDef* hadc)
mbed_official 354:e67efb2aab0e 143 {
mbed_official 354:e67efb2aab0e 144 HAL_StatusTypeDef tmpHALStatus = HAL_OK;
mbed_official 354:e67efb2aab0e 145
mbed_official 354:e67efb2aab0e 146 /* Check the parameters */
mbed_official 354:e67efb2aab0e 147 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 354:e67efb2aab0e 148
mbed_official 354:e67efb2aab0e 149 /* Process locked */
mbed_official 354:e67efb2aab0e 150 __HAL_LOCK(hadc);
mbed_official 354:e67efb2aab0e 151
mbed_official 354:e67efb2aab0e 152 /* Enable the ADC peripheral */
mbed_official 354:e67efb2aab0e 153 tmpHALStatus = ADC_Enable(hadc);
mbed_official 354:e67efb2aab0e 154
mbed_official 354:e67efb2aab0e 155 /* Start conversion if ADC is effectively enabled */
mbed_official 354:e67efb2aab0e 156 if (tmpHALStatus != HAL_ERROR)
mbed_official 354:e67efb2aab0e 157 {
mbed_official 354:e67efb2aab0e 158 /* Check if a regular conversion is ongoing */
mbed_official 354:e67efb2aab0e 159 if(hadc->State == HAL_ADC_STATE_BUSY_REG)
mbed_official 354:e67efb2aab0e 160 {
mbed_official 354:e67efb2aab0e 161 /* Change ADC state */
mbed_official 354:e67efb2aab0e 162 hadc->State = HAL_ADC_STATE_BUSY_INJ_REG;
mbed_official 354:e67efb2aab0e 163 }
mbed_official 354:e67efb2aab0e 164 else
mbed_official 354:e67efb2aab0e 165 {
mbed_official 354:e67efb2aab0e 166 /* Change ADC state */
mbed_official 354:e67efb2aab0e 167 hadc->State = HAL_ADC_STATE_BUSY_INJ;
mbed_official 354:e67efb2aab0e 168 }
mbed_official 354:e67efb2aab0e 169
mbed_official 354:e67efb2aab0e 170 /* Set ADC error code to none */
mbed_official 354:e67efb2aab0e 171 __HAL_ADC_CLEAR_ERRORCODE(hadc);
mbed_official 354:e67efb2aab0e 172
mbed_official 354:e67efb2aab0e 173 /* Clear injected group conversion flag */
mbed_official 354:e67efb2aab0e 174 /* (To ensure of no unknown state from potential previous ADC operations) */
mbed_official 354:e67efb2aab0e 175 __HAL_ADC_CLEAR_FLAG(hadc, ADC_FLAG_JEOC);
mbed_official 354:e67efb2aab0e 176
mbed_official 354:e67efb2aab0e 177 /* Start conversion of injected group if software start has been selected */
mbed_official 354:e67efb2aab0e 178 /* and if automatic injected conversion is disabled. */
mbed_official 354:e67efb2aab0e 179 /* If external trigger has been selected, conversion will start at next */
mbed_official 354:e67efb2aab0e 180 /* trigger event. */
mbed_official 354:e67efb2aab0e 181 /* If automatic injected conversion is enabled, conversion will start */
mbed_official 354:e67efb2aab0e 182 /* after next regular group conversion. */
mbed_official 354:e67efb2aab0e 183 if (__HAL_ADC_IS_SOFTWARE_START_INJECTED(hadc) &&
mbed_official 354:e67efb2aab0e 184 HAL_IS_BIT_CLR(hadc->Instance->CR1, ADC_CR1_JAUTO) )
mbed_official 354:e67efb2aab0e 185 {
mbed_official 354:e67efb2aab0e 186 /* Enable ADC software conversion for injected channels */
mbed_official 354:e67efb2aab0e 187 SET_BIT(hadc->Instance->CR2, ADC_CR2_JSWSTART);
mbed_official 354:e67efb2aab0e 188 }
mbed_official 354:e67efb2aab0e 189 }
mbed_official 354:e67efb2aab0e 190
mbed_official 354:e67efb2aab0e 191 /* Process unlocked */
mbed_official 354:e67efb2aab0e 192 __HAL_UNLOCK(hadc);
mbed_official 354:e67efb2aab0e 193
mbed_official 354:e67efb2aab0e 194 /* Return function status */
mbed_official 354:e67efb2aab0e 195 return tmpHALStatus;
mbed_official 354:e67efb2aab0e 196 }
mbed_official 354:e67efb2aab0e 197
mbed_official 354:e67efb2aab0e 198 /**
mbed_official 354:e67efb2aab0e 199 * @brief Stop conversion of injected channels. Disable ADC peripheral if
mbed_official 354:e67efb2aab0e 200 * no regular conversion is on going.
mbed_official 354:e67efb2aab0e 201 * @note If ADC must be disabled with this function and if regular conversion
mbed_official 354:e67efb2aab0e 202 * is on going, function HAL_ADC_Stop must be used preliminarily.
mbed_official 354:e67efb2aab0e 203 * @note In case of auto-injection mode, HAL_ADC_Stop must be used.
mbed_official 354:e67efb2aab0e 204 * @param hadc: ADC handle
mbed_official 354:e67efb2aab0e 205 * @retval None
mbed_official 354:e67efb2aab0e 206 */
mbed_official 354:e67efb2aab0e 207 HAL_StatusTypeDef HAL_ADCEx_InjectedStop(ADC_HandleTypeDef* hadc)
mbed_official 354:e67efb2aab0e 208 {
mbed_official 354:e67efb2aab0e 209 HAL_StatusTypeDef tmpHALStatus = HAL_OK;
mbed_official 354:e67efb2aab0e 210
mbed_official 354:e67efb2aab0e 211 /* Check the parameters */
mbed_official 354:e67efb2aab0e 212 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 354:e67efb2aab0e 213
mbed_official 354:e67efb2aab0e 214 /* Process locked */
mbed_official 354:e67efb2aab0e 215 __HAL_LOCK(hadc);
mbed_official 354:e67efb2aab0e 216
mbed_official 354:e67efb2aab0e 217 /* Stop potential conversion and disable ADC peripheral */
mbed_official 354:e67efb2aab0e 218 /* Conditioned to: */
mbed_official 354:e67efb2aab0e 219 /* - No conversion on the other group (regular group) is intended to */
mbed_official 354:e67efb2aab0e 220 /* continue (injected and regular groups stop conversion and ADC disable */
mbed_official 354:e67efb2aab0e 221 /* are common) */
mbed_official 354:e67efb2aab0e 222 /* - In case of auto-injection mode, HAL_ADC_Stop must be used. */
mbed_official 354:e67efb2aab0e 223 if((hadc->State != HAL_ADC_STATE_BUSY_REG) &&
mbed_official 354:e67efb2aab0e 224 (hadc->State != HAL_ADC_STATE_BUSY_INJ_REG) &&
mbed_official 354:e67efb2aab0e 225 HAL_IS_BIT_CLR(hadc->Instance->CR1, ADC_CR1_JAUTO) )
mbed_official 354:e67efb2aab0e 226 {
mbed_official 354:e67efb2aab0e 227 /* Stop potential conversion on going, on regular and injected groups */
mbed_official 354:e67efb2aab0e 228 /* Disable ADC peripheral */
mbed_official 354:e67efb2aab0e 229 tmpHALStatus = ADC_ConversionStop_Disable(hadc);
mbed_official 354:e67efb2aab0e 230
mbed_official 354:e67efb2aab0e 231 /* Check if ADC is effectively disabled */
mbed_official 354:e67efb2aab0e 232 if (tmpHALStatus != HAL_ERROR)
mbed_official 354:e67efb2aab0e 233 {
mbed_official 354:e67efb2aab0e 234 /* Change ADC state */
mbed_official 354:e67efb2aab0e 235 hadc->State = HAL_ADC_STATE_READY;
mbed_official 354:e67efb2aab0e 236 }
mbed_official 354:e67efb2aab0e 237 }
mbed_official 354:e67efb2aab0e 238 else
mbed_official 354:e67efb2aab0e 239 {
mbed_official 354:e67efb2aab0e 240 /* Update ADC state machine to error */
mbed_official 354:e67efb2aab0e 241 hadc->State = HAL_ADC_STATE_ERROR;
mbed_official 354:e67efb2aab0e 242
mbed_official 354:e67efb2aab0e 243 tmpHALStatus = HAL_ERROR;
mbed_official 354:e67efb2aab0e 244 }
mbed_official 354:e67efb2aab0e 245
mbed_official 354:e67efb2aab0e 246 /* Process unlocked */
mbed_official 354:e67efb2aab0e 247 __HAL_UNLOCK(hadc);
mbed_official 354:e67efb2aab0e 248
mbed_official 354:e67efb2aab0e 249 /* Return function status */
mbed_official 354:e67efb2aab0e 250 return tmpHALStatus;
mbed_official 354:e67efb2aab0e 251 }
mbed_official 354:e67efb2aab0e 252
mbed_official 354:e67efb2aab0e 253 /**
mbed_official 354:e67efb2aab0e 254 * @brief Wait for injected group conversion to be completed.
mbed_official 354:e67efb2aab0e 255 * @param hadc: ADC handle
mbed_official 354:e67efb2aab0e 256 * @param Timeout: Timeout value in millisecond.
mbed_official 354:e67efb2aab0e 257 * @retval HAL status
mbed_official 354:e67efb2aab0e 258 */
mbed_official 354:e67efb2aab0e 259 HAL_StatusTypeDef HAL_ADCEx_InjectedPollForConversion(ADC_HandleTypeDef* hadc, uint32_t Timeout)
mbed_official 354:e67efb2aab0e 260 {
mbed_official 354:e67efb2aab0e 261 uint32_t tickstart;
mbed_official 354:e67efb2aab0e 262
mbed_official 354:e67efb2aab0e 263 /* Variables for polling in case of scan mode enabled and polling for each */
mbed_official 354:e67efb2aab0e 264 /* conversion. */
mbed_official 354:e67efb2aab0e 265 /* Note: Variable "conversion_timeout_cpu_cycles" set to offset 28 CPU */
mbed_official 354:e67efb2aab0e 266 /* cycles to compensate number of CPU cycles for processing of variable */
mbed_official 354:e67efb2aab0e 267 /* "conversion_timeout_cpu_cycles_max" */
mbed_official 354:e67efb2aab0e 268 uint32_t conversion_timeout_cpu_cycles = 28;
mbed_official 354:e67efb2aab0e 269 uint32_t conversion_timeout_cpu_cycles_max = 0;
mbed_official 354:e67efb2aab0e 270
mbed_official 354:e67efb2aab0e 271 /* Check the parameters */
mbed_official 354:e67efb2aab0e 272 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 354:e67efb2aab0e 273
mbed_official 354:e67efb2aab0e 274 /* Get timeout */
mbed_official 354:e67efb2aab0e 275 tickstart = HAL_GetTick();
mbed_official 354:e67efb2aab0e 276
mbed_official 354:e67efb2aab0e 277 /* Polling for end of conversion: differentiation if single/sequence */
mbed_official 354:e67efb2aab0e 278 /* conversion. */
mbed_official 354:e67efb2aab0e 279 /* For injected group, flag JEOC is set only at the end of the sequence, */
mbed_official 354:e67efb2aab0e 280 /* not for each conversion within the sequence. */
mbed_official 354:e67efb2aab0e 281 /* If setting "EOCSelection" is set to poll for each single conversion, */
mbed_official 354:e67efb2aab0e 282 /* management of polling depends on setting of injected group sequencer: */
mbed_official 354:e67efb2aab0e 283 /* - If single conversion for injected group (scan mode disabled or */
mbed_official 354:e67efb2aab0e 284 /* InjectedNbrOfConversion ==1), flag JEOC is used to determine the */
mbed_official 354:e67efb2aab0e 285 /* conversion completion. */
mbed_official 354:e67efb2aab0e 286 /* - If sequence conversion for injected group (scan mode enabled and */
mbed_official 354:e67efb2aab0e 287 /* InjectedNbrOfConversion >=2), flag JEOC is set only at the end of the */
mbed_official 354:e67efb2aab0e 288 /* sequence. */
mbed_official 354:e67efb2aab0e 289 /* To poll for each conversion, the maximum conversion time is computed */
mbed_official 354:e67efb2aab0e 290 /* from ADC conversion time (selected sampling time + conversion time of */
mbed_official 354:e67efb2aab0e 291 /* 12 ADC clock cycles) and APB2/ADC clock prescalers (depending on */
mbed_official 354:e67efb2aab0e 292 /* settings, conversion time range can vary from 8 to several thousands */
mbed_official 354:e67efb2aab0e 293 /* of CPU cycles). */
mbed_official 354:e67efb2aab0e 294
mbed_official 354:e67efb2aab0e 295 /* Note: On STM32L1, setting "EOCSelection" is related to regular group */
mbed_official 354:e67efb2aab0e 296 /* only, by hardware. For compatibility with other STM32 devices, */
mbed_official 354:e67efb2aab0e 297 /* this setting is related also to injected group by software. */
mbed_official 354:e67efb2aab0e 298 if (((hadc->Instance->JSQR & ADC_JSQR_JL) == RESET) ||
mbed_official 354:e67efb2aab0e 299 (hadc->Init.EOCSelection != EOC_SINGLE_CONV) )
mbed_official 354:e67efb2aab0e 300 {
mbed_official 354:e67efb2aab0e 301 /* Wait until End of Conversion flag is raised */
mbed_official 354:e67efb2aab0e 302 while(HAL_IS_BIT_CLR(hadc->Instance->SR, ADC_FLAG_JEOC))
mbed_official 354:e67efb2aab0e 303 {
mbed_official 354:e67efb2aab0e 304 /* Check if timeout is disabled (set to infinite wait) */
mbed_official 354:e67efb2aab0e 305 if(Timeout != HAL_MAX_DELAY)
mbed_official 354:e67efb2aab0e 306 {
mbed_official 354:e67efb2aab0e 307 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 354:e67efb2aab0e 308 {
mbed_official 354:e67efb2aab0e 309 /* Update ADC state machine to timeout */
mbed_official 354:e67efb2aab0e 310 hadc->State = HAL_ADC_STATE_TIMEOUT;
mbed_official 354:e67efb2aab0e 311
mbed_official 354:e67efb2aab0e 312 /* Process unlocked */
mbed_official 354:e67efb2aab0e 313 __HAL_UNLOCK(hadc);
mbed_official 354:e67efb2aab0e 314
mbed_official 354:e67efb2aab0e 315 return HAL_ERROR;
mbed_official 354:e67efb2aab0e 316 }
mbed_official 354:e67efb2aab0e 317 }
mbed_official 354:e67efb2aab0e 318 }
mbed_official 354:e67efb2aab0e 319 }
mbed_official 354:e67efb2aab0e 320 else
mbed_official 354:e67efb2aab0e 321 {
mbed_official 354:e67efb2aab0e 322 /* Computation of CPU cycles corresponding to ADC conversion cycles. */
mbed_official 354:e67efb2aab0e 323 /* Retrieve ADC clock prescaler and ADC maximum conversion cycles on all */
mbed_official 354:e67efb2aab0e 324 /* channels. */
mbed_official 354:e67efb2aab0e 325 conversion_timeout_cpu_cycles_max = __ADC_GET_CLOCK_PRESCALER_DECIMAL(hadc);
mbed_official 354:e67efb2aab0e 326 conversion_timeout_cpu_cycles_max *= __ADC_CONVCYCLES_MAX_RANGE(hadc);
mbed_official 354:e67efb2aab0e 327
mbed_official 354:e67efb2aab0e 328 /* Poll with maximum conversion time */
mbed_official 354:e67efb2aab0e 329 while(conversion_timeout_cpu_cycles < conversion_timeout_cpu_cycles_max)
mbed_official 354:e67efb2aab0e 330 {
mbed_official 354:e67efb2aab0e 331 /* Check if timeout is disabled (set to infinite wait) */
mbed_official 354:e67efb2aab0e 332 if(Timeout != HAL_MAX_DELAY)
mbed_official 354:e67efb2aab0e 333 {
mbed_official 354:e67efb2aab0e 334 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 354:e67efb2aab0e 335 {
mbed_official 354:e67efb2aab0e 336 /* Update ADC state machine to timeout */
mbed_official 354:e67efb2aab0e 337 hadc->State = HAL_ADC_STATE_TIMEOUT;
mbed_official 354:e67efb2aab0e 338
mbed_official 354:e67efb2aab0e 339 /* Process unlocked */
mbed_official 354:e67efb2aab0e 340 __HAL_UNLOCK(hadc);
mbed_official 354:e67efb2aab0e 341
mbed_official 354:e67efb2aab0e 342 return HAL_ERROR;
mbed_official 354:e67efb2aab0e 343 }
mbed_official 354:e67efb2aab0e 344 }
mbed_official 354:e67efb2aab0e 345 conversion_timeout_cpu_cycles ++;
mbed_official 354:e67efb2aab0e 346 }
mbed_official 354:e67efb2aab0e 347 }
mbed_official 354:e67efb2aab0e 348
mbed_official 354:e67efb2aab0e 349 /* Clear end of conversion flag of injected group if low power feature */
mbed_official 354:e67efb2aab0e 350 /* "Auto Wait" is disabled, to not interfere with this feature until data */
mbed_official 354:e67efb2aab0e 351 /* register is read using function HAL_ADCEx_InjectedGetValue(). */
mbed_official 354:e67efb2aab0e 352 if (hadc->Init.LowPowerAutoWait == DISABLE)
mbed_official 354:e67efb2aab0e 353 {
mbed_official 354:e67efb2aab0e 354 /* Clear injected group conversion flag */
mbed_official 354:e67efb2aab0e 355 __HAL_ADC_CLEAR_FLAG(hadc, ADC_FLAG_JSTRT | ADC_FLAG_JEOC);
mbed_official 354:e67efb2aab0e 356 }
mbed_official 354:e67efb2aab0e 357
mbed_official 354:e67efb2aab0e 358 /* Update state machine on conversion status if not in error state */
mbed_official 354:e67efb2aab0e 359 if(hadc->State != HAL_ADC_STATE_ERROR)
mbed_official 354:e67efb2aab0e 360 {
mbed_official 354:e67efb2aab0e 361 /* Update ADC state machine */
mbed_official 354:e67efb2aab0e 362 if(hadc->State != HAL_ADC_STATE_EOC_INJ_REG)
mbed_official 354:e67efb2aab0e 363 {
mbed_official 354:e67efb2aab0e 364
mbed_official 354:e67efb2aab0e 365 if(hadc->State == HAL_ADC_STATE_EOC_REG)
mbed_official 354:e67efb2aab0e 366 {
mbed_official 354:e67efb2aab0e 367 /* Change ADC state */
mbed_official 354:e67efb2aab0e 368 hadc->State = HAL_ADC_STATE_EOC_INJ_REG;
mbed_official 354:e67efb2aab0e 369 }
mbed_official 354:e67efb2aab0e 370 else
mbed_official 354:e67efb2aab0e 371 {
mbed_official 354:e67efb2aab0e 372 /* Change ADC state */
mbed_official 354:e67efb2aab0e 373 hadc->State = HAL_ADC_STATE_EOC_INJ;
mbed_official 354:e67efb2aab0e 374 }
mbed_official 354:e67efb2aab0e 375 }
mbed_official 354:e67efb2aab0e 376 }
mbed_official 354:e67efb2aab0e 377
mbed_official 354:e67efb2aab0e 378 /* Return ADC state */
mbed_official 354:e67efb2aab0e 379 return HAL_OK;
mbed_official 354:e67efb2aab0e 380 }
mbed_official 354:e67efb2aab0e 381
mbed_official 354:e67efb2aab0e 382 /**
mbed_official 354:e67efb2aab0e 383 * @brief Enables ADC, starts conversion of injected group with interruption.
mbed_official 354:e67efb2aab0e 384 * Interruptions enabled in this function: JEOC (end of conversion).
mbed_official 354:e67efb2aab0e 385 * Each of these interruptions has its dedicated callback function.
mbed_official 354:e67efb2aab0e 386 * @param hadc: ADC handle
mbed_official 354:e67efb2aab0e 387 * @retval HAL status.
mbed_official 354:e67efb2aab0e 388 */
mbed_official 354:e67efb2aab0e 389 HAL_StatusTypeDef HAL_ADCEx_InjectedStart_IT(ADC_HandleTypeDef* hadc)
mbed_official 354:e67efb2aab0e 390 {
mbed_official 354:e67efb2aab0e 391 HAL_StatusTypeDef tmpHALStatus = HAL_OK;
mbed_official 354:e67efb2aab0e 392
mbed_official 354:e67efb2aab0e 393 /* Check the parameters */
mbed_official 354:e67efb2aab0e 394 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 354:e67efb2aab0e 395
mbed_official 354:e67efb2aab0e 396 /* Process locked */
mbed_official 354:e67efb2aab0e 397 __HAL_LOCK(hadc);
mbed_official 354:e67efb2aab0e 398
mbed_official 354:e67efb2aab0e 399 /* Enable the ADC peripheral */
mbed_official 354:e67efb2aab0e 400 tmpHALStatus = ADC_Enable(hadc);
mbed_official 354:e67efb2aab0e 401
mbed_official 354:e67efb2aab0e 402 /* Start conversion if ADC is effectively enabled */
mbed_official 354:e67efb2aab0e 403 if (tmpHALStatus != HAL_ERROR)
mbed_official 354:e67efb2aab0e 404 {
mbed_official 354:e67efb2aab0e 405 /* Check if a regular conversion is ongoing */
mbed_official 354:e67efb2aab0e 406 if(hadc->State == HAL_ADC_STATE_BUSY_REG)
mbed_official 354:e67efb2aab0e 407 {
mbed_official 354:e67efb2aab0e 408 /* Change ADC state */
mbed_official 354:e67efb2aab0e 409 hadc->State = HAL_ADC_STATE_BUSY_INJ_REG;
mbed_official 354:e67efb2aab0e 410 }
mbed_official 354:e67efb2aab0e 411 else
mbed_official 354:e67efb2aab0e 412 {
mbed_official 354:e67efb2aab0e 413 /* Change ADC state */
mbed_official 354:e67efb2aab0e 414 hadc->State = HAL_ADC_STATE_BUSY_INJ;
mbed_official 354:e67efb2aab0e 415 }
mbed_official 354:e67efb2aab0e 416
mbed_official 354:e67efb2aab0e 417 /* Set ADC error code to none */
mbed_official 354:e67efb2aab0e 418 __HAL_ADC_CLEAR_ERRORCODE(hadc);
mbed_official 354:e67efb2aab0e 419
mbed_official 354:e67efb2aab0e 420 /* Clear injected group conversion flag */
mbed_official 354:e67efb2aab0e 421 /* (To ensure of no unknown state from potential previous ADC operations) */
mbed_official 354:e67efb2aab0e 422 __HAL_ADC_CLEAR_FLAG(hadc, ADC_FLAG_JEOC);
mbed_official 354:e67efb2aab0e 423
mbed_official 354:e67efb2aab0e 424 /* Enable end of conversion interrupt for injected channels */
mbed_official 354:e67efb2aab0e 425 __HAL_ADC_ENABLE_IT(hadc, ADC_IT_JEOC);
mbed_official 354:e67efb2aab0e 426
mbed_official 354:e67efb2aab0e 427 /* Start conversion of injected group if software start has been selected */
mbed_official 354:e67efb2aab0e 428 /* and if automatic injected conversion is disabled. */
mbed_official 354:e67efb2aab0e 429 /* If external trigger has been selected, conversion will start at next */
mbed_official 354:e67efb2aab0e 430 /* trigger event. */
mbed_official 354:e67efb2aab0e 431 /* If automatic injected conversion is enabled, conversion will start */
mbed_official 354:e67efb2aab0e 432 /* after next regular group conversion. */
mbed_official 354:e67efb2aab0e 433 if (__HAL_ADC_IS_SOFTWARE_START_INJECTED(hadc) &&
mbed_official 354:e67efb2aab0e 434 HAL_IS_BIT_CLR(hadc->Instance->CR1, ADC_CR1_JAUTO) )
mbed_official 354:e67efb2aab0e 435 {
mbed_official 354:e67efb2aab0e 436 /* Enable ADC software conversion for injected channels */
mbed_official 354:e67efb2aab0e 437 SET_BIT(hadc->Instance->CR2, ADC_CR2_JSWSTART);
mbed_official 354:e67efb2aab0e 438 }
mbed_official 354:e67efb2aab0e 439 }
mbed_official 354:e67efb2aab0e 440
mbed_official 354:e67efb2aab0e 441 /* Process unlocked */
mbed_official 354:e67efb2aab0e 442 __HAL_UNLOCK(hadc);
mbed_official 354:e67efb2aab0e 443
mbed_official 354:e67efb2aab0e 444 /* Return function status */
mbed_official 354:e67efb2aab0e 445 return tmpHALStatus;
mbed_official 354:e67efb2aab0e 446 }
mbed_official 354:e67efb2aab0e 447
mbed_official 354:e67efb2aab0e 448 /**
mbed_official 354:e67efb2aab0e 449 * @brief Stop conversion of injected channels, disable interruption of
mbed_official 354:e67efb2aab0e 450 * end-of-conversion. Disable ADC peripheral if no regular conversion
mbed_official 354:e67efb2aab0e 451 * is on going.
mbed_official 354:e67efb2aab0e 452 * @note If ADC must be disabled with this function and if regular conversion
mbed_official 354:e67efb2aab0e 453 * is on going, function HAL_ADC_Stop must be used preliminarily.
mbed_official 354:e67efb2aab0e 454 * @param hadc: ADC handle
mbed_official 354:e67efb2aab0e 455 * @retval None
mbed_official 354:e67efb2aab0e 456 */
mbed_official 354:e67efb2aab0e 457 HAL_StatusTypeDef HAL_ADCEx_InjectedStop_IT(ADC_HandleTypeDef* hadc)
mbed_official 354:e67efb2aab0e 458 {
mbed_official 354:e67efb2aab0e 459 HAL_StatusTypeDef tmpHALStatus = HAL_OK;
mbed_official 354:e67efb2aab0e 460
mbed_official 354:e67efb2aab0e 461 /* Check the parameters */
mbed_official 354:e67efb2aab0e 462 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 354:e67efb2aab0e 463
mbed_official 354:e67efb2aab0e 464 /* Process locked */
mbed_official 354:e67efb2aab0e 465 __HAL_LOCK(hadc);
mbed_official 354:e67efb2aab0e 466
mbed_official 354:e67efb2aab0e 467 /* Stop potential conversion and disable ADC peripheral */
mbed_official 354:e67efb2aab0e 468 /* Conditioned to: */
mbed_official 354:e67efb2aab0e 469 /* - No conversion on the other group (regular group) is intended to */
mbed_official 354:e67efb2aab0e 470 /* continue (injected and regular groups stop conversion and ADC disable */
mbed_official 354:e67efb2aab0e 471 /* are common) */
mbed_official 354:e67efb2aab0e 472 /* - In case of auto-injection mode, HAL_ADC_Stop must be used. */
mbed_official 354:e67efb2aab0e 473 if((hadc->State != HAL_ADC_STATE_BUSY_REG) &&
mbed_official 354:e67efb2aab0e 474 (hadc->State != HAL_ADC_STATE_BUSY_INJ_REG) &&
mbed_official 354:e67efb2aab0e 475 HAL_IS_BIT_CLR(hadc->Instance->CR1, ADC_CR1_JAUTO) )
mbed_official 354:e67efb2aab0e 476 {
mbed_official 354:e67efb2aab0e 477 /* Stop potential conversion on going, on regular and injected groups */
mbed_official 354:e67efb2aab0e 478 /* Disable ADC peripheral */
mbed_official 354:e67efb2aab0e 479 tmpHALStatus = ADC_ConversionStop_Disable(hadc);
mbed_official 354:e67efb2aab0e 480
mbed_official 354:e67efb2aab0e 481 /* Check if ADC is effectively disabled */
mbed_official 354:e67efb2aab0e 482 if (tmpHALStatus != HAL_ERROR)
mbed_official 354:e67efb2aab0e 483 {
mbed_official 354:e67efb2aab0e 484 /* Disable ADC end of conversion interrupt for injected channels */
mbed_official 354:e67efb2aab0e 485 __HAL_ADC_DISABLE_IT(hadc, ADC_IT_JEOC);
mbed_official 354:e67efb2aab0e 486
mbed_official 354:e67efb2aab0e 487 /* Change ADC state */
mbed_official 354:e67efb2aab0e 488 hadc->State = HAL_ADC_STATE_READY;
mbed_official 354:e67efb2aab0e 489 }
mbed_official 354:e67efb2aab0e 490 }
mbed_official 354:e67efb2aab0e 491 else
mbed_official 354:e67efb2aab0e 492 {
mbed_official 354:e67efb2aab0e 493 /* Update ADC state machine to error */
mbed_official 354:e67efb2aab0e 494 hadc->State = HAL_ADC_STATE_ERROR;
mbed_official 354:e67efb2aab0e 495
mbed_official 354:e67efb2aab0e 496 tmpHALStatus = HAL_ERROR;
mbed_official 354:e67efb2aab0e 497 }
mbed_official 354:e67efb2aab0e 498
mbed_official 354:e67efb2aab0e 499 /* Process unlocked */
mbed_official 354:e67efb2aab0e 500 __HAL_UNLOCK(hadc);
mbed_official 354:e67efb2aab0e 501
mbed_official 354:e67efb2aab0e 502 /* Return function status */
mbed_official 354:e67efb2aab0e 503 return tmpHALStatus;
mbed_official 354:e67efb2aab0e 504 }
mbed_official 354:e67efb2aab0e 505
mbed_official 354:e67efb2aab0e 506 /**
mbed_official 354:e67efb2aab0e 507 * @brief Get ADC injected group conversion result.
mbed_official 354:e67efb2aab0e 508 * @param hadc: ADC handle
mbed_official 354:e67efb2aab0e 509 * @param InjectedRank: the converted ADC injected rank.
mbed_official 354:e67efb2aab0e 510 * This parameter can be one of the following values:
mbed_official 354:e67efb2aab0e 511 * @arg ADC_INJECTED_RANK_1: Injected Channel1 selected
mbed_official 354:e67efb2aab0e 512 * @arg ADC_INJECTED_RANK_2: Injected Channel2 selected
mbed_official 354:e67efb2aab0e 513 * @arg ADC_INJECTED_RANK_3: Injected Channel3 selected
mbed_official 354:e67efb2aab0e 514 * @arg ADC_INJECTED_RANK_4: Injected Channel4 selected
mbed_official 354:e67efb2aab0e 515 * @retval None
mbed_official 354:e67efb2aab0e 516 */
mbed_official 354:e67efb2aab0e 517 uint32_t HAL_ADCEx_InjectedGetValue(ADC_HandleTypeDef* hadc, uint32_t InjectedRank)
mbed_official 354:e67efb2aab0e 518 {
mbed_official 354:e67efb2aab0e 519 uint32_t tmp_jdr = 0;
mbed_official 354:e67efb2aab0e 520
mbed_official 354:e67efb2aab0e 521 /* Check the parameters */
mbed_official 354:e67efb2aab0e 522 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 354:e67efb2aab0e 523 assert_param(IS_ADC_INJECTED_RANK(InjectedRank));
mbed_official 354:e67efb2aab0e 524
mbed_official 354:e67efb2aab0e 525 /* Clear injected group conversion flag to have similar behaviour as */
mbed_official 354:e67efb2aab0e 526 /* regular group: reading data register also clears end of conversion flag. */
mbed_official 354:e67efb2aab0e 527 __HAL_ADC_CLEAR_FLAG(hadc, ADC_FLAG_JEOC);
mbed_official 354:e67efb2aab0e 528
mbed_official 354:e67efb2aab0e 529 /* Get ADC converted value */
mbed_official 354:e67efb2aab0e 530 switch(InjectedRank)
mbed_official 354:e67efb2aab0e 531 {
mbed_official 354:e67efb2aab0e 532 case ADC_INJECTED_RANK_4:
mbed_official 354:e67efb2aab0e 533 tmp_jdr = hadc->Instance->JDR4;
mbed_official 354:e67efb2aab0e 534 break;
mbed_official 354:e67efb2aab0e 535 case ADC_INJECTED_RANK_3:
mbed_official 354:e67efb2aab0e 536 tmp_jdr = hadc->Instance->JDR3;
mbed_official 354:e67efb2aab0e 537 break;
mbed_official 354:e67efb2aab0e 538 case ADC_INJECTED_RANK_2:
mbed_official 354:e67efb2aab0e 539 tmp_jdr = hadc->Instance->JDR2;
mbed_official 354:e67efb2aab0e 540 break;
mbed_official 354:e67efb2aab0e 541 case ADC_INJECTED_RANK_1:
mbed_official 354:e67efb2aab0e 542 default:
mbed_official 354:e67efb2aab0e 543 tmp_jdr = hadc->Instance->JDR1;
mbed_official 354:e67efb2aab0e 544 break;
mbed_official 354:e67efb2aab0e 545 }
mbed_official 354:e67efb2aab0e 546
mbed_official 354:e67efb2aab0e 547 /* Return ADC converted value */
mbed_official 354:e67efb2aab0e 548 return tmp_jdr;
mbed_official 354:e67efb2aab0e 549 }
mbed_official 354:e67efb2aab0e 550
mbed_official 354:e67efb2aab0e 551 /**
mbed_official 354:e67efb2aab0e 552 * @brief Injected conversion complete callback in non blocking mode
mbed_official 354:e67efb2aab0e 553 * @param hadc: ADC handle
mbed_official 354:e67efb2aab0e 554 * @retval None
mbed_official 354:e67efb2aab0e 555 */
mbed_official 354:e67efb2aab0e 556 __weak void HAL_ADCEx_InjectedConvCpltCallback(ADC_HandleTypeDef* hadc)
mbed_official 354:e67efb2aab0e 557 {
mbed_official 354:e67efb2aab0e 558 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 354:e67efb2aab0e 559 the HAL_ADCEx_InjectedConvCpltCallback could be implemented in the user file
mbed_official 354:e67efb2aab0e 560 */
mbed_official 354:e67efb2aab0e 561 }
mbed_official 354:e67efb2aab0e 562
mbed_official 354:e67efb2aab0e 563 /**
mbed_official 354:e67efb2aab0e 564 * @}
mbed_official 354:e67efb2aab0e 565 */
mbed_official 354:e67efb2aab0e 566
mbed_official 354:e67efb2aab0e 567 /** @defgroup ADCEx_Exported_Functions_Group2 Extended Peripheral Control functions
mbed_official 354:e67efb2aab0e 568 * @brief Extended Peripheral Control functions
mbed_official 354:e67efb2aab0e 569 *
mbed_official 354:e67efb2aab0e 570 @verbatim
mbed_official 354:e67efb2aab0e 571 ===============================================================================
mbed_official 354:e67efb2aab0e 572 ##### Peripheral Control functions #####
mbed_official 354:e67efb2aab0e 573 ===============================================================================
mbed_official 354:e67efb2aab0e 574 [..] This section provides functions allowing to:
mbed_official 354:e67efb2aab0e 575 (+) Configure channels on injected group
mbed_official 354:e67efb2aab0e 576
mbed_official 354:e67efb2aab0e 577 @endverbatim
mbed_official 354:e67efb2aab0e 578 * @{
mbed_official 354:e67efb2aab0e 579 */
mbed_official 354:e67efb2aab0e 580
mbed_official 354:e67efb2aab0e 581 /**
mbed_official 354:e67efb2aab0e 582 * @brief Configures the ADC injected group and the selected channel to be
mbed_official 354:e67efb2aab0e 583 * linked to the injected group.
mbed_official 354:e67efb2aab0e 584 * @note Possibility to update parameters on the fly:
mbed_official 354:e67efb2aab0e 585 * This function initializes injected group, following calls to this
mbed_official 354:e67efb2aab0e 586 * function can be used to reconfigure some parameters of structure
mbed_official 354:e67efb2aab0e 587 * "ADC_InjectionConfTypeDef" on the fly, without reseting the ADC.
mbed_official 354:e67efb2aab0e 588 * The setting of these parameters is conditioned to ADC state:
mbed_official 354:e67efb2aab0e 589 * this function must be called when ADC is not under conversion.
mbed_official 354:e67efb2aab0e 590 * @param hadc: ADC handle
mbed_official 354:e67efb2aab0e 591 * @param sConfigInjected: Structure of ADC injected group and ADC channel for
mbed_official 354:e67efb2aab0e 592 * injected group.
mbed_official 354:e67efb2aab0e 593 * @retval None
mbed_official 354:e67efb2aab0e 594 */
mbed_official 354:e67efb2aab0e 595 HAL_StatusTypeDef HAL_ADCEx_InjectedConfigChannel(ADC_HandleTypeDef* hadc, ADC_InjectionConfTypeDef* sConfigInjected)
mbed_official 354:e67efb2aab0e 596 {
mbed_official 354:e67efb2aab0e 597 HAL_StatusTypeDef tmpHALStatus = HAL_OK;
mbed_official 354:e67efb2aab0e 598
mbed_official 354:e67efb2aab0e 599 /* Check the parameters */
mbed_official 354:e67efb2aab0e 600 assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official 354:e67efb2aab0e 601 assert_param(IS_ADC_CHANNEL(sConfigInjected->InjectedChannel));
mbed_official 354:e67efb2aab0e 602 assert_param(IS_ADC_SAMPLE_TIME(sConfigInjected->InjectedSamplingTime));
mbed_official 354:e67efb2aab0e 603 assert_param(IS_FUNCTIONAL_STATE(sConfigInjected->AutoInjectedConv));
mbed_official 354:e67efb2aab0e 604 assert_param(IS_ADC_EXTTRIGINJEC(sConfigInjected->ExternalTrigInjecConv));
mbed_official 354:e67efb2aab0e 605 assert_param(IS_ADC_RANGE(sConfigInjected->InjectedOffset));
mbed_official 354:e67efb2aab0e 606
mbed_official 354:e67efb2aab0e 607 if(hadc->Init.ScanConvMode != ADC_SCAN_DISABLE)
mbed_official 354:e67efb2aab0e 608 {
mbed_official 354:e67efb2aab0e 609 assert_param(IS_ADC_INJECTED_RANK(sConfigInjected->InjectedRank));
mbed_official 354:e67efb2aab0e 610 assert_param(IS_ADC_INJECTED_NB_CONV(sConfigInjected->InjectedNbrOfConversion));
mbed_official 354:e67efb2aab0e 611 assert_param(IS_FUNCTIONAL_STATE(sConfigInjected->InjectedDiscontinuousConvMode));
mbed_official 354:e67efb2aab0e 612 }
mbed_official 354:e67efb2aab0e 613
mbed_official 354:e67efb2aab0e 614 if(sConfigInjected->ExternalTrigInjecConvEdge != ADC_INJECTED_SOFTWARE_START)
mbed_official 354:e67efb2aab0e 615 {
mbed_official 354:e67efb2aab0e 616 assert_param(IS_ADC_EXTTRIGINJEC_EDGE(sConfigInjected->ExternalTrigInjecConvEdge));
mbed_official 354:e67efb2aab0e 617 }
mbed_official 354:e67efb2aab0e 618
mbed_official 354:e67efb2aab0e 619 /* Process locked */
mbed_official 354:e67efb2aab0e 620 __HAL_LOCK(hadc);
mbed_official 354:e67efb2aab0e 621
mbed_official 354:e67efb2aab0e 622 /* Configuration of injected group sequencer: */
mbed_official 354:e67efb2aab0e 623 /* - if scan mode is disabled, injected channels sequence length is set to */
mbed_official 354:e67efb2aab0e 624 /* 0x00: 1 channel converted (channel on regular rank 1) */
mbed_official 354:e67efb2aab0e 625 /* Parameter "InjectedNbrOfConversion" is discarded. */
mbed_official 354:e67efb2aab0e 626 /* Note: Scan mode is present by hardware on this device and, if */
mbed_official 354:e67efb2aab0e 627 /* disabled, discards automatically nb of conversions. Anyway, nb of */
mbed_official 354:e67efb2aab0e 628 /* conversions is forced to 0x00 for alignment over all STM32 devices. */
mbed_official 354:e67efb2aab0e 629 /* - if scan mode is enabled, injected channels sequence length is set to */
mbed_official 354:e67efb2aab0e 630 /* parameter ""InjectedNbrOfConversion". */
mbed_official 354:e67efb2aab0e 631 if (hadc->Init.ScanConvMode == ADC_SCAN_DISABLE)
mbed_official 354:e67efb2aab0e 632 {
mbed_official 354:e67efb2aab0e 633 if (sConfigInjected->InjectedRank == ADC_INJECTED_RANK_1)
mbed_official 354:e67efb2aab0e 634 {
mbed_official 354:e67efb2aab0e 635 /* Clear the old SQx bits for all injected ranks */
mbed_official 354:e67efb2aab0e 636 MODIFY_REG(hadc->Instance->JSQR ,
mbed_official 354:e67efb2aab0e 637 ADC_JSQR_JL |
mbed_official 354:e67efb2aab0e 638 ADC_JSQR_JSQ4 |
mbed_official 354:e67efb2aab0e 639 ADC_JSQR_JSQ3 |
mbed_official 354:e67efb2aab0e 640 ADC_JSQR_JSQ2 |
mbed_official 354:e67efb2aab0e 641 ADC_JSQR_JSQ1 ,
mbed_official 354:e67efb2aab0e 642 __ADC_JSQR_RK(sConfigInjected->InjectedChannel,
mbed_official 354:e67efb2aab0e 643 ADC_INJECTED_RANK_1,
mbed_official 354:e67efb2aab0e 644 0x01) );
mbed_official 354:e67efb2aab0e 645 }
mbed_official 354:e67efb2aab0e 646 /* If another injected rank than rank1 was intended to be set, and could */
mbed_official 354:e67efb2aab0e 647 /* not due to ScanConvMode disabled, error is reported. */
mbed_official 354:e67efb2aab0e 648 else
mbed_official 354:e67efb2aab0e 649 {
mbed_official 354:e67efb2aab0e 650 /* Update ADC state machine to error */
mbed_official 354:e67efb2aab0e 651 hadc->State = HAL_ADC_STATE_ERROR;
mbed_official 354:e67efb2aab0e 652
mbed_official 354:e67efb2aab0e 653 tmpHALStatus = HAL_ERROR;
mbed_official 354:e67efb2aab0e 654 }
mbed_official 354:e67efb2aab0e 655 }
mbed_official 354:e67efb2aab0e 656 else
mbed_official 354:e67efb2aab0e 657 {
mbed_official 354:e67efb2aab0e 658 /* Since injected channels rank conv. order depends on total number of */
mbed_official 354:e67efb2aab0e 659 /* injected conversions, selected rank must be below or equal to total */
mbed_official 354:e67efb2aab0e 660 /* number of injected conversions to be updated. */
mbed_official 354:e67efb2aab0e 661 if (sConfigInjected->InjectedRank <= sConfigInjected->InjectedNbrOfConversion)
mbed_official 354:e67efb2aab0e 662 {
mbed_official 354:e67efb2aab0e 663 /* Clear the old SQx bits for the selected rank */
mbed_official 354:e67efb2aab0e 664 /* Set the SQx bits for the selected rank */
mbed_official 354:e67efb2aab0e 665 MODIFY_REG(hadc->Instance->JSQR ,
mbed_official 354:e67efb2aab0e 666
mbed_official 354:e67efb2aab0e 667 ADC_JSQR_JL |
mbed_official 354:e67efb2aab0e 668 __ADC_JSQR_RK(ADC_JSQR_JSQ1,
mbed_official 354:e67efb2aab0e 669 sConfigInjected->InjectedRank,
mbed_official 354:e67efb2aab0e 670 sConfigInjected->InjectedNbrOfConversion) ,
mbed_official 354:e67efb2aab0e 671
mbed_official 354:e67efb2aab0e 672 __ADC_JSQR_JL(sConfigInjected->InjectedNbrOfConversion) |
mbed_official 354:e67efb2aab0e 673 __ADC_JSQR_RK(sConfigInjected->InjectedChannel,
mbed_official 354:e67efb2aab0e 674 sConfigInjected->InjectedRank,
mbed_official 354:e67efb2aab0e 675 sConfigInjected->InjectedNbrOfConversion) );
mbed_official 354:e67efb2aab0e 676 }
mbed_official 354:e67efb2aab0e 677 else
mbed_official 354:e67efb2aab0e 678 {
mbed_official 354:e67efb2aab0e 679 /* Clear the old SQx bits for the selected rank */
mbed_official 354:e67efb2aab0e 680 MODIFY_REG(hadc->Instance->JSQR ,
mbed_official 354:e67efb2aab0e 681
mbed_official 354:e67efb2aab0e 682 ADC_JSQR_JL |
mbed_official 354:e67efb2aab0e 683 __ADC_JSQR_RK(ADC_JSQR_JSQ1,
mbed_official 354:e67efb2aab0e 684 sConfigInjected->InjectedRank,
mbed_official 354:e67efb2aab0e 685 sConfigInjected->InjectedNbrOfConversion) ,
mbed_official 354:e67efb2aab0e 686
mbed_official 354:e67efb2aab0e 687 0x00000000 );
mbed_official 354:e67efb2aab0e 688 }
mbed_official 354:e67efb2aab0e 689 }
mbed_official 354:e67efb2aab0e 690
mbed_official 354:e67efb2aab0e 691 /* Enable external trigger if trigger selection is different of software */
mbed_official 354:e67efb2aab0e 692 /* start. */
mbed_official 354:e67efb2aab0e 693 /* Note: This configuration keeps the hardware feature of parameter */
mbed_official 354:e67efb2aab0e 694 /* ExternalTrigConvEdge "trigger edge none" equivalent to */
mbed_official 354:e67efb2aab0e 695 /* software start. */
mbed_official 354:e67efb2aab0e 696
mbed_official 354:e67efb2aab0e 697 if (sConfigInjected->ExternalTrigInjecConv != ADC_INJECTED_SOFTWARE_START)
mbed_official 354:e67efb2aab0e 698 {
mbed_official 354:e67efb2aab0e 699 MODIFY_REG(hadc->Instance->CR2 ,
mbed_official 354:e67efb2aab0e 700 ADC_CR2_JEXTEN |
mbed_official 354:e67efb2aab0e 701 ADC_CR2_JEXTSEL ,
mbed_official 354:e67efb2aab0e 702 sConfigInjected->ExternalTrigInjecConv |
mbed_official 354:e67efb2aab0e 703 sConfigInjected->ExternalTrigInjecConvEdge );
mbed_official 354:e67efb2aab0e 704 }
mbed_official 354:e67efb2aab0e 705 else
mbed_official 354:e67efb2aab0e 706 {
mbed_official 354:e67efb2aab0e 707 MODIFY_REG(hadc->Instance->CR2,
mbed_official 354:e67efb2aab0e 708 ADC_CR2_JEXTEN |
mbed_official 354:e67efb2aab0e 709 ADC_CR2_JEXTSEL ,
mbed_official 354:e67efb2aab0e 710 0x00000000 );
mbed_official 354:e67efb2aab0e 711 }
mbed_official 354:e67efb2aab0e 712
mbed_official 354:e67efb2aab0e 713 /* Configuration of injected group */
mbed_official 354:e67efb2aab0e 714 /* Parameters update conditioned to ADC state: */
mbed_official 354:e67efb2aab0e 715 /* Parameters that can be updated only when ADC is disabled: */
mbed_official 354:e67efb2aab0e 716 /* - Automatic injected conversion */
mbed_official 354:e67efb2aab0e 717 /* - Injected discontinuous mode */
mbed_official 354:e67efb2aab0e 718 if ((__HAL_ADC_IS_ENABLED(hadc) == RESET))
mbed_official 354:e67efb2aab0e 719 {
mbed_official 354:e67efb2aab0e 720 hadc->Instance->CR1 &= ~(ADC_CR1_JAUTO |
mbed_official 354:e67efb2aab0e 721 ADC_CR1_JDISCEN );
mbed_official 354:e67efb2aab0e 722
mbed_official 354:e67efb2aab0e 723 /* Automatic injected conversion can be enabled if injected group */
mbed_official 354:e67efb2aab0e 724 /* external triggers are disabled. */
mbed_official 354:e67efb2aab0e 725 if (sConfigInjected->AutoInjectedConv == ENABLE)
mbed_official 354:e67efb2aab0e 726 {
mbed_official 354:e67efb2aab0e 727 if (sConfigInjected->ExternalTrigInjecConv == ADC_INJECTED_SOFTWARE_START)
mbed_official 354:e67efb2aab0e 728 {
mbed_official 354:e67efb2aab0e 729 SET_BIT(hadc->Instance->CR1, ADC_CR1_JAUTO);
mbed_official 354:e67efb2aab0e 730 }
mbed_official 354:e67efb2aab0e 731 else
mbed_official 354:e67efb2aab0e 732 {
mbed_official 354:e67efb2aab0e 733 /* Update ADC state machine to error */
mbed_official 354:e67efb2aab0e 734 hadc->State = HAL_ADC_STATE_ERROR;
mbed_official 354:e67efb2aab0e 735
mbed_official 354:e67efb2aab0e 736 tmpHALStatus = HAL_ERROR;
mbed_official 354:e67efb2aab0e 737 }
mbed_official 354:e67efb2aab0e 738 }
mbed_official 354:e67efb2aab0e 739
mbed_official 354:e67efb2aab0e 740 /* Injected discontinuous can be enabled only if auto-injected mode is */
mbed_official 354:e67efb2aab0e 741 /* disabled. */
mbed_official 354:e67efb2aab0e 742 if (sConfigInjected->InjectedDiscontinuousConvMode == ENABLE)
mbed_official 354:e67efb2aab0e 743 {
mbed_official 354:e67efb2aab0e 744 if (sConfigInjected->AutoInjectedConv == DISABLE)
mbed_official 354:e67efb2aab0e 745 {
mbed_official 354:e67efb2aab0e 746 SET_BIT(hadc->Instance->CR1, ADC_CR1_JDISCEN);
mbed_official 354:e67efb2aab0e 747 }
mbed_official 354:e67efb2aab0e 748 else
mbed_official 354:e67efb2aab0e 749 {
mbed_official 354:e67efb2aab0e 750 /* Update ADC state machine to error */
mbed_official 354:e67efb2aab0e 751 hadc->State = HAL_ADC_STATE_ERROR;
mbed_official 354:e67efb2aab0e 752
mbed_official 354:e67efb2aab0e 753 tmpHALStatus = HAL_ERROR;
mbed_official 354:e67efb2aab0e 754 }
mbed_official 354:e67efb2aab0e 755 }
mbed_official 354:e67efb2aab0e 756 }
mbed_official 354:e67efb2aab0e 757
mbed_official 354:e67efb2aab0e 758 /* InjectedChannel sampling time configuration */
mbed_official 354:e67efb2aab0e 759 /* For InjectedChannels 0 to 9 */
mbed_official 354:e67efb2aab0e 760 if (sConfigInjected->InjectedChannel < ADC_CHANNEL_10)
mbed_official 354:e67efb2aab0e 761 {
mbed_official 354:e67efb2aab0e 762 MODIFY_REG(hadc->Instance->SMPR3,
mbed_official 354:e67efb2aab0e 763 __ADC_SMPR3(ADC_SMPR3_SMP0, sConfigInjected->InjectedChannel),
mbed_official 354:e67efb2aab0e 764 __ADC_SMPR3(sConfigInjected->InjectedSamplingTime, sConfigInjected->InjectedChannel) );
mbed_official 354:e67efb2aab0e 765 }
mbed_official 354:e67efb2aab0e 766 /* For InjectedChannels 10 to 19 */
mbed_official 354:e67efb2aab0e 767 else if (sConfigInjected->InjectedChannel < ADC_CHANNEL_20)
mbed_official 354:e67efb2aab0e 768 {
mbed_official 354:e67efb2aab0e 769 MODIFY_REG(hadc->Instance->SMPR2,
mbed_official 354:e67efb2aab0e 770 __ADC_SMPR2(ADC_SMPR2_SMP10, sConfigInjected->InjectedChannel),
mbed_official 354:e67efb2aab0e 771 __ADC_SMPR2(sConfigInjected->InjectedSamplingTime, sConfigInjected->InjectedChannel) );
mbed_official 354:e67efb2aab0e 772 }
mbed_official 354:e67efb2aab0e 773 /* For InjectedChannels 20 to 26 for devices Cat.1, Cat.2, Cat.3 */
mbed_official 354:e67efb2aab0e 774 /* For InjectedChannels 20 to 29 for devices Cat4, Cat.5 */
mbed_official 354:e67efb2aab0e 775 else if (sConfigInjected->InjectedChannel <= ADC_SMPR1_CHANNEL_MAX)
mbed_official 354:e67efb2aab0e 776 {
mbed_official 354:e67efb2aab0e 777 MODIFY_REG(hadc->Instance->SMPR1,
mbed_official 354:e67efb2aab0e 778 __ADC_SMPR1(ADC_SMPR1_SMP20, sConfigInjected->InjectedChannel),
mbed_official 354:e67efb2aab0e 779 __ADC_SMPR1(sConfigInjected->InjectedSamplingTime, sConfigInjected->InjectedChannel) );
mbed_official 354:e67efb2aab0e 780 }
mbed_official 354:e67efb2aab0e 781 /* For InjectedChannels 30 to 31 for devices Cat4, Cat.5 */
mbed_official 354:e67efb2aab0e 782 else
mbed_official 354:e67efb2aab0e 783 {
mbed_official 354:e67efb2aab0e 784 __ADC_SMPR0_CHANNEL_SET(hadc, sConfigInjected->InjectedSamplingTime, sConfigInjected->InjectedChannel);
mbed_official 354:e67efb2aab0e 785 }
mbed_official 354:e67efb2aab0e 786
mbed_official 354:e67efb2aab0e 787
mbed_official 354:e67efb2aab0e 788 /* Configure the offset: offset enable/disable, InjectedChannel, offset value */
mbed_official 354:e67efb2aab0e 789 switch(sConfigInjected->InjectedRank)
mbed_official 354:e67efb2aab0e 790 {
mbed_official 354:e67efb2aab0e 791 case 1:
mbed_official 354:e67efb2aab0e 792 /* Set injected channel 1 offset */
mbed_official 354:e67efb2aab0e 793 MODIFY_REG(hadc->Instance->JOFR1,
mbed_official 354:e67efb2aab0e 794 ADC_JOFR1_JOFFSET1,
mbed_official 354:e67efb2aab0e 795 sConfigInjected->InjectedOffset);
mbed_official 354:e67efb2aab0e 796 break;
mbed_official 354:e67efb2aab0e 797 case 2:
mbed_official 354:e67efb2aab0e 798 /* Set injected channel 2 offset */
mbed_official 354:e67efb2aab0e 799 MODIFY_REG(hadc->Instance->JOFR2,
mbed_official 354:e67efb2aab0e 800 ADC_JOFR2_JOFFSET2,
mbed_official 354:e67efb2aab0e 801 sConfigInjected->InjectedOffset);
mbed_official 354:e67efb2aab0e 802 break;
mbed_official 354:e67efb2aab0e 803 case 3:
mbed_official 354:e67efb2aab0e 804 /* Set injected channel 3 offset */
mbed_official 354:e67efb2aab0e 805 MODIFY_REG(hadc->Instance->JOFR3,
mbed_official 354:e67efb2aab0e 806 ADC_JOFR3_JOFFSET3,
mbed_official 354:e67efb2aab0e 807 sConfigInjected->InjectedOffset);
mbed_official 354:e67efb2aab0e 808 break;
mbed_official 354:e67efb2aab0e 809 case 4:
mbed_official 354:e67efb2aab0e 810 default:
mbed_official 354:e67efb2aab0e 811 MODIFY_REG(hadc->Instance->JOFR4,
mbed_official 354:e67efb2aab0e 812 ADC_JOFR4_JOFFSET4,
mbed_official 354:e67efb2aab0e 813 sConfigInjected->InjectedOffset);
mbed_official 354:e67efb2aab0e 814 break;
mbed_official 354:e67efb2aab0e 815 }
mbed_official 354:e67efb2aab0e 816
mbed_official 354:e67efb2aab0e 817 /* If ADC1 Channel_16 or Channel_17 is selected, enable Temperature sensor */
mbed_official 354:e67efb2aab0e 818 /* and VREFINT measurement path. */
mbed_official 354:e67efb2aab0e 819 if ((sConfigInjected->InjectedChannel == ADC_CHANNEL_TEMPSENSOR) ||
mbed_official 354:e67efb2aab0e 820 (sConfigInjected->InjectedChannel == ADC_CHANNEL_VREFINT) )
mbed_official 354:e67efb2aab0e 821 {
mbed_official 354:e67efb2aab0e 822 SET_BIT(ADC->CCR, ADC_CCR_TSVREFE);
mbed_official 354:e67efb2aab0e 823 }
mbed_official 354:e67efb2aab0e 824
mbed_official 354:e67efb2aab0e 825 /* Process unlocked */
mbed_official 354:e67efb2aab0e 826 __HAL_UNLOCK(hadc);
mbed_official 354:e67efb2aab0e 827
mbed_official 354:e67efb2aab0e 828 /* Return function status */
mbed_official 354:e67efb2aab0e 829 return tmpHALStatus;
mbed_official 354:e67efb2aab0e 830 }
mbed_official 354:e67efb2aab0e 831
mbed_official 354:e67efb2aab0e 832 /**
mbed_official 354:e67efb2aab0e 833 * @}
mbed_official 354:e67efb2aab0e 834 */
mbed_official 354:e67efb2aab0e 835
mbed_official 354:e67efb2aab0e 836 /**
mbed_official 354:e67efb2aab0e 837 * @}
mbed_official 354:e67efb2aab0e 838 */
mbed_official 354:e67efb2aab0e 839
mbed_official 354:e67efb2aab0e 840 #endif /* HAL_ADC_MODULE_ENABLED */
mbed_official 354:e67efb2aab0e 841 /**
mbed_official 354:e67efb2aab0e 842 * @}
mbed_official 354:e67efb2aab0e 843 */
mbed_official 354:e67efb2aab0e 844
mbed_official 354:e67efb2aab0e 845 /**
mbed_official 354:e67efb2aab0e 846 * @}
mbed_official 354:e67efb2aab0e 847 */
mbed_official 354:e67efb2aab0e 848
mbed_official 354:e67efb2aab0e 849 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/