mbed-src - mbed library sources

Users » lzbpli » Code » mbed-src

lzbp li / mbed-src

mbed library sources

Fork of mbed-src by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32L1/stm32l1xx_hal_adc.c@394:83f921546702, 2014-11-07 (annotated)

Committer:: mbed_official
Date:: Fri Nov 07 15:45:07 2014 +0000
Revision:: 394:83f921546702
Parent:: targets/cmsis/TARGET_STM/TARGET_NUCLEO_L152RE/stm32l1xx_hal_adc.c@354:e67efb2aab0e

Synchronized with git revision aab52cb7ec5a665869e507dd988bbfd55b7e087e

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

Tests: Fix cpputest testrunner

Who changed what in which revision?

User	Revision	Line number	New contents of line
mbed_official	354:e67efb2aab0e	1	/**
mbed_official	354:e67efb2aab0e	2	******************************************************************************
mbed_official	354:e67efb2aab0e	3	* @file stm32l1xx_hal_adc.c
mbed_official	354:e67efb2aab0e	4	* @author MCD Application conversion
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 (extended functions) are available in file
mbed_official	354:e67efb2aab0e	22	* "stm32l1xx_hal_adc_ex.c".
mbed_official	354:e67efb2aab0e	23	*
mbed_official	354:e67efb2aab0e	24	@verbatim
mbed_official	354:e67efb2aab0e	25	==============================================================================
mbed_official	354:e67efb2aab0e	26	##### ADC specific features #####
mbed_official	354:e67efb2aab0e	27	==============================================================================
mbed_official	354:e67efb2aab0e	28	[..]
mbed_official	354:e67efb2aab0e	29	(#) 12-bit, 10-bit, 8-bit or 6-bit configurable resolution
mbed_official	354:e67efb2aab0e	30
mbed_official	354:e67efb2aab0e	31	(#) Interrupt generation at the end of regular conversion, end of injected
mbed_official	354:e67efb2aab0e	32	conversion, and in case of analog watchdog or overrun events.
mbed_official	354:e67efb2aab0e	33
mbed_official	354:e67efb2aab0e	34	(#) Single and continuous conversion modes.
mbed_official	354:e67efb2aab0e	35
mbed_official	354:e67efb2aab0e	36	(#) Scan mode for automatic conversion of channel 0 to channel 'n'.
mbed_official	354:e67efb2aab0e	37
mbed_official	354:e67efb2aab0e	38	(#) Data alignment with in-built data coherency.
mbed_official	354:e67efb2aab0e	39
mbed_official	354:e67efb2aab0e	40	(#) Channel-wise programmable sampling time.
mbed_official	354:e67efb2aab0e	41
mbed_official	354:e67efb2aab0e	42	(#) ADC conversion Regular or Injected groups.
mbed_official	354:e67efb2aab0e	43
mbed_official	354:e67efb2aab0e	44	(#) External trigger (timer or EXTI) with configurable polarity for both
mbed_official	354:e67efb2aab0e	45	regular and injected groups.
mbed_official	354:e67efb2aab0e	46
mbed_official	354:e67efb2aab0e	47	(#) DMA request generation for transfer of conversions data of regular group.
mbed_official	354:e67efb2aab0e	48
mbed_official	354:e67efb2aab0e	49	(#) ADC calibration
mbed_official	354:e67efb2aab0e	50
mbed_official	354:e67efb2aab0e	51	(#) ADC offset on injected channels
mbed_official	354:e67efb2aab0e	52
mbed_official	354:e67efb2aab0e	53	(#) ADC supply requirements: 2.4 V to 3.6 V at full speed and down to 1.8 V at
mbed_official	354:e67efb2aab0e	54	slower speed.
mbed_official	354:e67efb2aab0e	55
mbed_official	354:e67efb2aab0e	56	(#) ADC input range: from Vref (connected to Vssa) to Vref+ (connected to
mbed_official	354:e67efb2aab0e	57	Vdda or to an external voltage reference).
mbed_official	354:e67efb2aab0e	58
mbed_official	354:e67efb2aab0e	59
mbed_official	354:e67efb2aab0e	60	##### How to use this driver #####
mbed_official	354:e67efb2aab0e	61	==============================================================================
mbed_official	354:e67efb2aab0e	62	[..]
mbed_official	354:e67efb2aab0e	63
mbed_official	354:e67efb2aab0e	64	(#) Enable the ADC interface
mbed_official	354:e67efb2aab0e	65	As prerequisite, ADC clock must be configured at RCC top level.
mbed_official	354:e67efb2aab0e	66	Two clocks settings are mandatory:
mbed_official	354:e67efb2aab0e	67	- ADC clock (core clock):
mbed_official	354:e67efb2aab0e	68	Example:
mbed_official	354:e67efb2aab0e	69	Into HAL_ADC_MspInit() (recommended code location):
mbed_official	354:e67efb2aab0e	70	__ADC1_CLK_ENABLE();
mbed_official	354:e67efb2aab0e	71
mbed_official	354:e67efb2aab0e	72	- ADC clock (conversions clock):
mbed_official	354:e67efb2aab0e	73	Only one possible clock source: derived from HSI RC 16MHz oscillator
mbed_official	354:e67efb2aab0e	74	(HSI).
mbed_official	354:e67efb2aab0e	75	Example:
mbed_official	354:e67efb2aab0e	76	Into HAL_ADC_MspInit() or with main setting of RCC:
mbed_official	354:e67efb2aab0e	77	RCC_OscInitTypeDef RCC_OscInitStructure;
mbed_official	354:e67efb2aab0e	78	HAL_RCC_GetOscConfig(&RCC_OscInitStructure);
mbed_official	354:e67efb2aab0e	79	RCC_OscInitStructure.OscillatorType = (... \| RCC_OSCILLATORTYPE_HSI);
mbed_official	354:e67efb2aab0e	80	RCC_OscInitStructure.HSIState = RCC_HSI_ON;
mbed_official	354:e67efb2aab0e	81	RCC_OscInitStructure.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
mbed_official	354:e67efb2aab0e	82	RCC_OscInitStructure.PLL.PLLState = RCC_PLL_NONE;
mbed_official	354:e67efb2aab0e	83	RCC_OscInitStructure.PLL.PLLSource = ...
mbed_official	354:e67efb2aab0e	84	RCC_OscInitStructure.PLL...
mbed_official	354:e67efb2aab0e	85	HAL_RCC_OscConfig(&RCC_OscInitStructure);
mbed_official	354:e67efb2aab0e	86
mbed_official	354:e67efb2aab0e	87	Note: ADC is connected directly to HSI RC 16MHz oscillator.
mbed_official	354:e67efb2aab0e	88	Therefore, RCC PLL setting has no impact on ADC.
mbed_official	354:e67efb2aab0e	89	PLL can be disabled (".PLL.PLLState = RCC_PLL_NONE") or
mbed_official	354:e67efb2aab0e	90	enabled with HSI16 as clock source
mbed_official	354:e67efb2aab0e	91	(".PLL.PLLSource = RCC_PLLSOURCE_HSI") to be used as device
mbed_official	354:e67efb2aab0e	92	main clock source SYSCLK.
mbed_official	354:e67efb2aab0e	93	The only mandatory setting is ".HSIState = RCC_HSI_ON"
mbed_official	354:e67efb2aab0e	94
mbed_official	354:e67efb2aab0e	95	Note: ADC clock prescaler is configured at ADC level with
mbed_official	354:e67efb2aab0e	96	parameter "ClockPrescaler" using function HAL_ADC_Init().
mbed_official	354:e67efb2aab0e	97
mbed_official	354:e67efb2aab0e	98	(#) ADC pins configuration
mbed_official	354:e67efb2aab0e	99	(++) Enable the clock for the ADC GPIOs using the following function:
mbed_official	354:e67efb2aab0e	100	__GPIOx_CLK_ENABLE();
mbed_official	354:e67efb2aab0e	101	(++) Configure these ADC pins in analog mode using HAL_GPIO_Init();
mbed_official	354:e67efb2aab0e	102
mbed_official	354:e67efb2aab0e	103	(#) Configure the ADC parameters (conversion resolution, data alignment,
mbed_official	354:e67efb2aab0e	104	continuous mode, ...) using the HAL_ADC_Init() function.
mbed_official	354:e67efb2aab0e	105
mbed_official	354:e67efb2aab0e	106	(#) Activate the ADC peripheral using one of the start functions:
mbed_official	354:e67efb2aab0e	107	HAL_ADC_Start(), HAL_ADC_Start_IT(), HAL_ADC_Start_DMA().
mbed_official	354:e67efb2aab0e	108
mbed_official	354:e67efb2aab0e	109	* Channels configuration to regular group *
mbed_official	354:e67efb2aab0e	110	================================================
mbed_official	354:e67efb2aab0e	111	[..]
mbed_official	354:e67efb2aab0e	112	(+) To configure the ADC regular group features, use
mbed_official	354:e67efb2aab0e	113	HAL_ADC_Init() and HAL_ADC_ConfigChannel() functions.
mbed_official	354:e67efb2aab0e	114	(+) To read the ADC converted values, use the HAL_ADC_GetValue() function.
mbed_official	354:e67efb2aab0e	115
mbed_official	354:e67efb2aab0e	116	* DMA for regular group configuration *
mbed_official	354:e67efb2aab0e	117	===========================================
mbed_official	354:e67efb2aab0e	118	[..]
mbed_official	354:e67efb2aab0e	119	(+) To enable the DMA mode for regular group, use the
mbed_official	354:e67efb2aab0e	120	HAL_ADC_Start_DMA() function.
mbed_official	354:e67efb2aab0e	121	(+) To enable the generation of DMA requests continuously at the end of
mbed_official	354:e67efb2aab0e	122	the last DMA transfer, use the HAL_ADC_Init() function.
mbed_official	354:e67efb2aab0e	123
mbed_official	354:e67efb2aab0e	124	@endverbatim
mbed_official	354:e67efb2aab0e	125	******************************************************************************
mbed_official	354:e67efb2aab0e	126	* @attention
mbed_official	354:e67efb2aab0e	127	*
mbed_official	354:e67efb2aab0e	128	* <h2><center>© COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
mbed_official	354:e67efb2aab0e	129	*
mbed_official	354:e67efb2aab0e	130	* Redistribution and use in source and binary forms, with or without modification,
mbed_official	354:e67efb2aab0e	131	* are permitted provided that the following conditions are met:
mbed_official	354:e67efb2aab0e	132	* 1. Redistributions of source code must retain the above copyright notice,
mbed_official	354:e67efb2aab0e	133	* this list of conditions and the following disclaimer.
mbed_official	354:e67efb2aab0e	134	* 2. Redistributions in binary form must reproduce the above copyright notice,
mbed_official	354:e67efb2aab0e	135	* this list of conditions and the following disclaimer in the documentation
mbed_official	354:e67efb2aab0e	136	* and/or other materials provided with the distribution.
mbed_official	354:e67efb2aab0e	137	* 3. Neither the name of STMicroelectronics nor the names of its contributors
mbed_official	354:e67efb2aab0e	138	* may be used to endorse or promote products derived from this software
mbed_official	354:e67efb2aab0e	139	* without specific prior written permission.
mbed_official	354:e67efb2aab0e	140	*
mbed_official	354:e67efb2aab0e	141	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
mbed_official	354:e67efb2aab0e	142	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
mbed_official	354:e67efb2aab0e	143	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
mbed_official	354:e67efb2aab0e	144	* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
mbed_official	354:e67efb2aab0e	145	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
mbed_official	354:e67efb2aab0e	146	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
mbed_official	354:e67efb2aab0e	147	* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
mbed_official	354:e67efb2aab0e	148	* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
mbed_official	354:e67efb2aab0e	149	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
mbed_official	354:e67efb2aab0e	150	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
mbed_official	354:e67efb2aab0e	151	*
mbed_official	354:e67efb2aab0e	152	******************************************************************************
mbed_official	354:e67efb2aab0e	153	*/
mbed_official	354:e67efb2aab0e	154
mbed_official	354:e67efb2aab0e	155	/* Includes ------------------------------------------------------------------*/
mbed_official	354:e67efb2aab0e	156	#include "stm32l1xx_hal.h"
mbed_official	354:e67efb2aab0e	157
mbed_official	354:e67efb2aab0e	158	/** @addtogroup STM32L1xx_HAL_Driver
mbed_official	354:e67efb2aab0e	159	* @{
mbed_official	354:e67efb2aab0e	160	*/
mbed_official	354:e67efb2aab0e	161
mbed_official	354:e67efb2aab0e	162	/** @defgroup ADC ADC
mbed_official	354:e67efb2aab0e	163	* @brief ADC HAL module driver
mbed_official	354:e67efb2aab0e	164	* @{
mbed_official	354:e67efb2aab0e	165	*/
mbed_official	354:e67efb2aab0e	166
mbed_official	354:e67efb2aab0e	167	#ifdef HAL_ADC_MODULE_ENABLED
mbed_official	354:e67efb2aab0e	168
mbed_official	354:e67efb2aab0e	169	/* Private typedef -----------------------------------------------------------*/
mbed_official	354:e67efb2aab0e	170	/* Private define ------------------------------------------------------------*/
mbed_official	354:e67efb2aab0e	171	/** @defgroup ADC_Private_Constants ADC Private Constants
mbed_official	354:e67efb2aab0e	172	* @{
mbed_official	354:e67efb2aab0e	173	*/
mbed_official	354:e67efb2aab0e	174
mbed_official	354:e67efb2aab0e	175	/* Fixed timeout values for ADC calibration, enable settling time. */
mbed_official	354:e67efb2aab0e	176	/* Values defined to be higher than worst cases: low clocks freq, */
mbed_official	354:e67efb2aab0e	177	/* maximum prescaler. */
mbed_official	354:e67efb2aab0e	178	/* Ex of profile low frequency : Clock source at 0.1 MHz, ADC clock */
mbed_official	354:e67efb2aab0e	179	/* prescaler 4, sampling time 7.5 ADC clock cycles, resolution 12 bits. */
mbed_official	354:e67efb2aab0e	180	/* Unit: ms */
mbed_official	354:e67efb2aab0e	181	#define ADC_ENABLE_TIMEOUT ((uint32_t) 2)
mbed_official	354:e67efb2aab0e	182	#define ADC_DISABLE_TIMEOUT ((uint32_t) 2)
mbed_official	354:e67efb2aab0e	183
mbed_official	354:e67efb2aab0e	184	/* Delay for ADC stabilization time. */
mbed_official	354:e67efb2aab0e	185	/* Maximum delay is 3.5us (refer to device datasheet, parameter tSTAB). */
mbed_official	354:e67efb2aab0e	186	/* Delay in CPU cycles, fixed to worst case: maximum CPU frequency 32MHz to */
mbed_official	354:e67efb2aab0e	187	/* have the minimum number of CPU cycles to fulfill this delay. */
mbed_official	354:e67efb2aab0e	188	#define ADC_STAB_DELAY_CPU_CYCLES ((uint32_t)112)
mbed_official	354:e67efb2aab0e	189	/**
mbed_official	354:e67efb2aab0e	190	* @}
mbed_official	354:e67efb2aab0e	191	*/
mbed_official	354:e67efb2aab0e	192
mbed_official	354:e67efb2aab0e	193	/* Private macro -------------------------------------------------------------*/
mbed_official	354:e67efb2aab0e	194	/* Private variables ---------------------------------------------------------*/
mbed_official	354:e67efb2aab0e	195	/* Private function prototypes -----------------------------------------------*/
mbed_official	354:e67efb2aab0e	196	/** @defgroup ADC_Private_Functions ADC Private Functions
mbed_official	354:e67efb2aab0e	197	* @{
mbed_official	354:e67efb2aab0e	198	*/
mbed_official	354:e67efb2aab0e	199	static void ADC_DMAConvCplt(DMA_HandleTypeDef *hdma);
mbed_official	354:e67efb2aab0e	200	static void ADC_DMAHalfConvCplt(DMA_HandleTypeDef *hdma);
mbed_official	354:e67efb2aab0e	201	static void ADC_DMAError(DMA_HandleTypeDef *hdma);
mbed_official	354:e67efb2aab0e	202	/**
mbed_official	354:e67efb2aab0e	203	* @}
mbed_official	354:e67efb2aab0e	204	*/
mbed_official	354:e67efb2aab0e	205
mbed_official	354:e67efb2aab0e	206	/* Exported functions ---------------------------------------------------------*/
mbed_official	354:e67efb2aab0e	207
mbed_official	354:e67efb2aab0e	208	/** @defgroup ADC_Exported_Functions ADC Exported Functions
mbed_official	354:e67efb2aab0e	209	* @{
mbed_official	354:e67efb2aab0e	210	*/
mbed_official	354:e67efb2aab0e	211
mbed_official	354:e67efb2aab0e	212	/** @defgroup ADC_Exported_Functions_Group1 Initialization/de-initialization functions
mbed_official	354:e67efb2aab0e	213	* @brief Initialization and Configuration functions
mbed_official	354:e67efb2aab0e	214	*
mbed_official	354:e67efb2aab0e	215	@verbatim
mbed_official	354:e67efb2aab0e	216	===============================================================================
mbed_official	354:e67efb2aab0e	217	##### Initialization and de-initialization functions #####
mbed_official	354:e67efb2aab0e	218	===============================================================================
mbed_official	354:e67efb2aab0e	219	[..] This section provides functions allowing to:
mbed_official	354:e67efb2aab0e	220	(+) Initialize and configure the ADC.
mbed_official	354:e67efb2aab0e	221	(+) De-initialize the ADC
mbed_official	354:e67efb2aab0e	222	@endverbatim
mbed_official	354:e67efb2aab0e	223	* @{
mbed_official	354:e67efb2aab0e	224	*/
mbed_official	354:e67efb2aab0e	225
mbed_official	354:e67efb2aab0e	226	/**
mbed_official	354:e67efb2aab0e	227	* @brief Initializes the ADC peripheral and regular group according to
mbed_official	354:e67efb2aab0e	228	* parameters specified in structure "ADC_InitTypeDef".
mbed_official	354:e67efb2aab0e	229	* @note As prerequisite, ADC clock must be configured at RCC top level
mbed_official	354:e67efb2aab0e	230	* (clock source APB2).
mbed_official	354:e67efb2aab0e	231	* See commented example code below that can be copied and uncommented
mbed_official	354:e67efb2aab0e	232	* into HAL_ADC_MspInit().
mbed_official	354:e67efb2aab0e	233	* @note Possibility to update parameters on the fly:
mbed_official	354:e67efb2aab0e	234	* This function initializes the ADC MSP (HAL_ADC_MspInit()) only when
mbed_official	354:e67efb2aab0e	235	* coming from ADC state reset. Following calls to this function can
mbed_official	354:e67efb2aab0e	236	* be used to reconfigure some parameters of ADC_InitTypeDef
mbed_official	354:e67efb2aab0e	237	* structure on the fly, without modifying MSP configuration. If ADC
mbed_official	354:e67efb2aab0e	238	* MSP has to be modified again, HAL_ADC_DeInit() must be called
mbed_official	354:e67efb2aab0e	239	* before HAL_ADC_Init().
mbed_official	354:e67efb2aab0e	240	* The setting of these parameters is conditioned to ADC state.
mbed_official	354:e67efb2aab0e	241	* For parameters constraints, see comments of structure
mbed_official	354:e67efb2aab0e	242	* "ADC_InitTypeDef".
mbed_official	354:e67efb2aab0e	243	* @note This function configures the ADC within 2 scopes: scope of entire
mbed_official	354:e67efb2aab0e	244	* ADC and scope of regular group. For parameters details, see comments
mbed_official	354:e67efb2aab0e	245	* of structure "ADC_InitTypeDef".
mbed_official	354:e67efb2aab0e	246	* @param hadc: ADC handle
mbed_official	354:e67efb2aab0e	247	* @retval HAL status
mbed_official	354:e67efb2aab0e	248	*/
mbed_official	354:e67efb2aab0e	249	HAL_StatusTypeDef HAL_ADC_Init(ADC_HandleTypeDef* hadc)
mbed_official	354:e67efb2aab0e	250	{
mbed_official	354:e67efb2aab0e	251	HAL_StatusTypeDef tmpHALStatus = HAL_OK;
mbed_official	354:e67efb2aab0e	252	uint32_t tmp_cr1 = 0;
mbed_official	354:e67efb2aab0e	253	uint32_t tmp_cr2 = 0;
mbed_official	354:e67efb2aab0e	254
mbed_official	354:e67efb2aab0e	255	/* Check ADC handle */
mbed_official	354:e67efb2aab0e	256	if(hadc == HAL_NULL)
mbed_official	354:e67efb2aab0e	257	{
mbed_official	354:e67efb2aab0e	258	return HAL_ERROR;
mbed_official	354:e67efb2aab0e	259	}
mbed_official	354:e67efb2aab0e	260
mbed_official	354:e67efb2aab0e	261	/* Check the parameters */
mbed_official	354:e67efb2aab0e	262	assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official	354:e67efb2aab0e	263	assert_param(IS_ADC_CLOCKPRESCALER(hadc->Init.ClockPrescaler));
mbed_official	354:e67efb2aab0e	264	assert_param(IS_ADC_RESOLUTION(hadc->Init.Resolution));
mbed_official	354:e67efb2aab0e	265	assert_param(IS_ADC_DATA_ALIGN(hadc->Init.DataAlign));
mbed_official	354:e67efb2aab0e	266	assert_param(IS_ADC_SCAN_MODE(hadc->Init.ScanConvMode));
mbed_official	354:e67efb2aab0e	267	assert_param(IS_ADC_EOC_SELECTION(hadc->Init.EOCSelection));
mbed_official	354:e67efb2aab0e	268	assert_param(IS_ADC_AUTOWAIT(hadc->Init.LowPowerAutoWait));
mbed_official	354:e67efb2aab0e	269	assert_param(IS_ADC_AUTOPOWEROFF(hadc->Init.LowPowerAutoPowerOff));
mbed_official	354:e67efb2aab0e	270	assert_param(IS_ADC_CHANNELSBANK(hadc->Init.ChannelsBank));
mbed_official	354:e67efb2aab0e	271	assert_param(IS_FUNCTIONAL_STATE(hadc->Init.ContinuousConvMode));
mbed_official	354:e67efb2aab0e	272	assert_param(IS_ADC_EXTTRIG(hadc->Init.ExternalTrigConv));
mbed_official	354:e67efb2aab0e	273	assert_param(IS_FUNCTIONAL_STATE(hadc->Init.DMAContinuousRequests));
mbed_official	354:e67efb2aab0e	274
mbed_official	354:e67efb2aab0e	275	if(hadc->Init.ScanConvMode != ADC_SCAN_DISABLE)
mbed_official	354:e67efb2aab0e	276	{
mbed_official	354:e67efb2aab0e	277	assert_param(IS_ADC_REGULAR_NB_CONV(hadc->Init.NbrOfConversion));
mbed_official	354:e67efb2aab0e	278	assert_param(IS_FUNCTIONAL_STATE(hadc->Init.DiscontinuousConvMode));
mbed_official	354:e67efb2aab0e	279	assert_param(IS_ADC_REGULAR_DISCONT_NUMBER(hadc->Init.NbrOfDiscConversion));
mbed_official	354:e67efb2aab0e	280	}
mbed_official	354:e67efb2aab0e	281
mbed_official	354:e67efb2aab0e	282	if(hadc->Init.ExternalTrigConv != ADC_SOFTWARE_START)
mbed_official	354:e67efb2aab0e	283	{
mbed_official	354:e67efb2aab0e	284	assert_param(IS_ADC_EXTTRIG_EDGE(hadc->Init.ExternalTrigConvEdge));
mbed_official	354:e67efb2aab0e	285	}
mbed_official	354:e67efb2aab0e	286
mbed_official	354:e67efb2aab0e	287
mbed_official	354:e67efb2aab0e	288	/* As prerequisite, into HAL_ADC_MspInit(), ADC clock must be configured */
mbed_official	354:e67efb2aab0e	289	/* at RCC top level. */
mbed_official	354:e67efb2aab0e	290	/* Refer to header of this file for more details on clock enabling */
mbed_official	354:e67efb2aab0e	291	/* procedure. */
mbed_official	354:e67efb2aab0e	292
mbed_official	354:e67efb2aab0e	293	/* Actions performed only if ADC is coming from state reset: */
mbed_official	354:e67efb2aab0e	294	/* - Initialization of ADC MSP */
mbed_official	354:e67efb2aab0e	295	if (hadc->State == HAL_ADC_STATE_RESET)
mbed_official	354:e67efb2aab0e	296	{
mbed_official	354:e67efb2aab0e	297	/* Enable SYSCFG clock to control the routing Interface (RI) */
mbed_official	354:e67efb2aab0e	298	__SYSCFG_CLK_ENABLE();
mbed_official	354:e67efb2aab0e	299
mbed_official	354:e67efb2aab0e	300	/* Init the low level hardware */
mbed_official	354:e67efb2aab0e	301	HAL_ADC_MspInit(hadc);
mbed_official	354:e67efb2aab0e	302	}
mbed_official	354:e67efb2aab0e	303
mbed_official	354:e67efb2aab0e	304	/* Configuration of ADC parameters if previous preliminary actions are */
mbed_official	354:e67efb2aab0e	305	/* correctly completed. */
mbed_official	354:e67efb2aab0e	306	if (tmpHALStatus != HAL_ERROR)
mbed_official	354:e67efb2aab0e	307	{
mbed_official	354:e67efb2aab0e	308	/* Initialize the ADC state */
mbed_official	354:e67efb2aab0e	309	hadc->State = HAL_ADC_STATE_BUSY;
mbed_official	354:e67efb2aab0e	310
mbed_official	354:e67efb2aab0e	311	/* Set ADC parameters */
mbed_official	354:e67efb2aab0e	312
mbed_official	354:e67efb2aab0e	313	/* Configuration of common ADC clock: clock source HSI with selectable */
mbed_official	354:e67efb2aab0e	314	/* prescaler */
mbed_official	354:e67efb2aab0e	315	MODIFY_REG(ADC->CCR ,
mbed_official	354:e67efb2aab0e	316	ADC_CCR_ADCPRE ,
mbed_official	354:e67efb2aab0e	317	hadc->Init.ClockPrescaler );
mbed_official	354:e67efb2aab0e	318
mbed_official	354:e67efb2aab0e	319	/* Configuration of ADC: */
mbed_official	354:e67efb2aab0e	320	/* - external trigger polarity */
mbed_official	354:e67efb2aab0e	321	/* - End of conversion selection */
mbed_official	354:e67efb2aab0e	322	/* - DMA continuous request */
mbed_official	354:e67efb2aab0e	323	/* - Channels bank (Banks availability depends on devices categories) */
mbed_official	354:e67efb2aab0e	324	/* - continuous conversion mode */
mbed_official	354:e67efb2aab0e	325	tmp_cr2 \|= (hadc->Init.DataAlign \|
mbed_official	354:e67efb2aab0e	326	hadc->Init.EOCSelection \|
mbed_official	354:e67efb2aab0e	327	__ADC_CR2_DMACONTREQ(hadc->Init.DMAContinuousRequests) \|
mbed_official	354:e67efb2aab0e	328	hadc->Init.ChannelsBank \|
mbed_official	354:e67efb2aab0e	329	__ADC_CR2_CONTINUOUS(hadc->Init.ContinuousConvMode) );
mbed_official	354:e67efb2aab0e	330
mbed_official	354:e67efb2aab0e	331	/* Enable external trigger if trigger selection is different of software */
mbed_official	354:e67efb2aab0e	332	/* start. */
mbed_official	354:e67efb2aab0e	333	/* Note: This configuration keeps the hardware feature of parameter */
mbed_official	354:e67efb2aab0e	334	/* ExternalTrigConvEdge "trigger edge none" equivalent to */
mbed_official	354:e67efb2aab0e	335	/* software start. */
mbed_official	354:e67efb2aab0e	336	if (hadc->Init.ExternalTrigConv != ADC_SOFTWARE_START)
mbed_official	354:e67efb2aab0e	337	{
mbed_official	354:e67efb2aab0e	338	tmp_cr2 \|= ( hadc->Init.ExternalTrigConv \|
mbed_official	354:e67efb2aab0e	339	hadc->Init.ExternalTrigConvEdge );
mbed_official	354:e67efb2aab0e	340	}
mbed_official	354:e67efb2aab0e	341
mbed_official	354:e67efb2aab0e	342	/* Parameters update conditioned to ADC state: */
mbed_official	354:e67efb2aab0e	343	/* Parameters that can be updated only when ADC is disabled: */
mbed_official	354:e67efb2aab0e	344	/* - delay selection (LowPowerAutoWait mode) */
mbed_official	354:e67efb2aab0e	345	/* - resolution */
mbed_official	354:e67efb2aab0e	346	/* - auto power off (LowPowerAutoPowerOff mode) */
mbed_official	354:e67efb2aab0e	347	/* - scan mode */
mbed_official	354:e67efb2aab0e	348	/* - discontinuous mode disable/enable */
mbed_official	354:e67efb2aab0e	349	/* - discontinuous mode number of conversions */
mbed_official	354:e67efb2aab0e	350	if ((__HAL_ADC_IS_ENABLED(hadc) == RESET))
mbed_official	354:e67efb2aab0e	351	{
mbed_official	354:e67efb2aab0e	352	tmp_cr2 \|= hadc->Init.LowPowerAutoWait;
mbed_official	354:e67efb2aab0e	353
mbed_official	354:e67efb2aab0e	354	tmp_cr1 \|= (hadc->Init.Resolution \|
mbed_official	354:e67efb2aab0e	355	hadc->Init.LowPowerAutoPowerOff \|
mbed_official	354:e67efb2aab0e	356	__ADC_CR1_SCAN(hadc->Init.ScanConvMode) );
mbed_official	354:e67efb2aab0e	357
mbed_official	354:e67efb2aab0e	358	/* Enable discontinuous mode only if continuous mode is disabled */
mbed_official	354:e67efb2aab0e	359	if ((hadc->Init.DiscontinuousConvMode == ENABLE) &&
mbed_official	354:e67efb2aab0e	360	(hadc->Init.ContinuousConvMode == DISABLE) )
mbed_official	354:e67efb2aab0e	361	{
mbed_official	354:e67efb2aab0e	362	/* Enable discontinuous mode of regular group */
mbed_official	354:e67efb2aab0e	363	/* Set the number of channels to be converted in discontinuous mode */
mbed_official	354:e67efb2aab0e	364	tmp_cr1 \|= ((ADC_CR1_DISCEN) \|
mbed_official	354:e67efb2aab0e	365	__ADC_CR1_DISCONTINUOUS_NUM(hadc->Init.NbrOfDiscConversion));
mbed_official	354:e67efb2aab0e	366	}
mbed_official	354:e67efb2aab0e	367
mbed_official	354:e67efb2aab0e	368	/* Update ADC configuration register CR1 with previous settings */
mbed_official	354:e67efb2aab0e	369	MODIFY_REG(hadc->Instance->CR1,
mbed_official	354:e67efb2aab0e	370	ADC_CR1_RES \|
mbed_official	354:e67efb2aab0e	371	ADC_CR1_PDI \|
mbed_official	354:e67efb2aab0e	372	ADC_CR1_PDD \|
mbed_official	354:e67efb2aab0e	373	ADC_CR1_DISCNUM \|
mbed_official	354:e67efb2aab0e	374	ADC_CR1_DISCEN \|
mbed_official	354:e67efb2aab0e	375	ADC_CR1_SCAN ,
mbed_official	354:e67efb2aab0e	376	tmp_cr1 );
mbed_official	354:e67efb2aab0e	377	}
mbed_official	354:e67efb2aab0e	378
mbed_official	354:e67efb2aab0e	379	/* Update ADC configuration register CR2 with previous settings */
mbed_official	354:e67efb2aab0e	380	MODIFY_REG(hadc->Instance->CR2 ,
mbed_official	354:e67efb2aab0e	381	__ADC_CR2_MASK_ADCINIT() ,
mbed_official	354:e67efb2aab0e	382	tmp_cr2 );
mbed_official	354:e67efb2aab0e	383
mbed_official	354:e67efb2aab0e	384	/* Configuration of regular group sequencer: */
mbed_official	354:e67efb2aab0e	385	/* - if scan mode is disabled, regular channels sequence length is set to */
mbed_official	354:e67efb2aab0e	386	/* 0x00: 1 channel converted (channel on regular rank 1) */
mbed_official	354:e67efb2aab0e	387	/* Parameter "NbrOfConversion" is discarded. */
mbed_official	354:e67efb2aab0e	388	/* Note: Scan mode is present by hardware on this device and, if */
mbed_official	354:e67efb2aab0e	389	/* disabled, discards automatically nb of conversions. Anyway, nb of */
mbed_official	354:e67efb2aab0e	390	/* conversions is forced to 0x00 for alignment over all STM32 devices. */
mbed_official	354:e67efb2aab0e	391	/* - if scan mode is enabled, regular channels sequence length is set to */
mbed_official	354:e67efb2aab0e	392	/* parameter "NbrOfConversion" */
mbed_official	354:e67efb2aab0e	393	if (hadc->Init.ScanConvMode == ADC_SCAN_ENABLE)
mbed_official	354:e67efb2aab0e	394	{
mbed_official	354:e67efb2aab0e	395	MODIFY_REG(hadc->Instance->SQR1 ,
mbed_official	354:e67efb2aab0e	396	ADC_SQR1_L ,
mbed_official	354:e67efb2aab0e	397	__ADC_SQR1_L(hadc->Init.NbrOfConversion) );
mbed_official	354:e67efb2aab0e	398	}
mbed_official	354:e67efb2aab0e	399	else
mbed_official	354:e67efb2aab0e	400	{
mbed_official	354:e67efb2aab0e	401	MODIFY_REG(hadc->Instance->SQR1,
mbed_official	354:e67efb2aab0e	402	ADC_SQR1_L ,
mbed_official	354:e67efb2aab0e	403	0x00000000 );
mbed_official	354:e67efb2aab0e	404	}
mbed_official	354:e67efb2aab0e	405
mbed_official	354:e67efb2aab0e	406	/* Check back that ADC registers have effectively been configured to */
mbed_official	354:e67efb2aab0e	407	/* ensure of no potential problem of ADC core IP clocking. */
mbed_official	354:e67efb2aab0e	408	/* Check through register CR2 (excluding execution control bits ADON, */
mbed_official	354:e67efb2aab0e	409	/* JSWSTART, SWSTART and injected trigger bits JEXTEN and JEXTSEL). */
mbed_official	354:e67efb2aab0e	410	if ((READ_REG(hadc->Instance->CR2) & ~(ADC_CR2_ADON \|
mbed_official	354:e67efb2aab0e	411	ADC_CR2_SWSTART \| ADC_CR2_JSWSTART \|
mbed_official	354:e67efb2aab0e	412	ADC_CR2_JEXTEN \| ADC_CR2_JEXTSEL ))
mbed_official	354:e67efb2aab0e	413	== tmp_cr2)
mbed_official	354:e67efb2aab0e	414	{
mbed_official	354:e67efb2aab0e	415	/* Set ADC error code to none */
mbed_official	354:e67efb2aab0e	416	__HAL_ADC_CLEAR_ERRORCODE(hadc);
mbed_official	354:e67efb2aab0e	417
mbed_official	354:e67efb2aab0e	418	/* Initialize the ADC state */
mbed_official	354:e67efb2aab0e	419	hadc->State = HAL_ADC_STATE_READY;
mbed_official	354:e67efb2aab0e	420	}
mbed_official	354:e67efb2aab0e	421	else
mbed_official	354:e67efb2aab0e	422	{
mbed_official	354:e67efb2aab0e	423	/* Update ADC state machine to error */
mbed_official	354:e67efb2aab0e	424	hadc->State = HAL_ADC_STATE_ERROR;
mbed_official	354:e67efb2aab0e	425
mbed_official	354:e67efb2aab0e	426	/* Set ADC error code to ADC IP internal error */
mbed_official	354:e67efb2aab0e	427	hadc->ErrorCode \|= HAL_ADC_ERROR_INTERNAL;
mbed_official	354:e67efb2aab0e	428
mbed_official	354:e67efb2aab0e	429	tmpHALStatus = HAL_ERROR;
mbed_official	354:e67efb2aab0e	430	}
mbed_official	354:e67efb2aab0e	431
mbed_official	354:e67efb2aab0e	432	}
mbed_official	354:e67efb2aab0e	433	else
mbed_official	354:e67efb2aab0e	434	{
mbed_official	354:e67efb2aab0e	435	/* Update ADC state machine to error */
mbed_official	354:e67efb2aab0e	436	hadc->State = HAL_ADC_STATE_ERROR;
mbed_official	354:e67efb2aab0e	437
mbed_official	354:e67efb2aab0e	438	tmpHALStatus = HAL_ERROR;
mbed_official	354:e67efb2aab0e	439	}
mbed_official	354:e67efb2aab0e	440
mbed_official	354:e67efb2aab0e	441	/* Return function status */
mbed_official	354:e67efb2aab0e	442	return tmpHALStatus;
mbed_official	354:e67efb2aab0e	443	}
mbed_official	354:e67efb2aab0e	444
mbed_official	354:e67efb2aab0e	445	/**
mbed_official	354:e67efb2aab0e	446	* @brief Deinitialize the ADC peripheral registers to its default reset values.
mbed_official	354:e67efb2aab0e	447	* @note To not impact other ADCs, reset of common ADC registers have been
mbed_official	354:e67efb2aab0e	448	* left commented below.
mbed_official	354:e67efb2aab0e	449	* If needed, the example code can be copied and uncommented into
mbed_official	354:e67efb2aab0e	450	* function HAL_ADC_MspDeInit().
mbed_official	354:e67efb2aab0e	451	* @param hadc: ADC handle
mbed_official	354:e67efb2aab0e	452	* @retval HAL status
mbed_official	354:e67efb2aab0e	453	*/
mbed_official	354:e67efb2aab0e	454	HAL_StatusTypeDef HAL_ADC_DeInit(ADC_HandleTypeDef* hadc)
mbed_official	354:e67efb2aab0e	455	{
mbed_official	354:e67efb2aab0e	456	HAL_StatusTypeDef tmpHALStatus = HAL_OK;
mbed_official	354:e67efb2aab0e	457
mbed_official	354:e67efb2aab0e	458	/* Check ADC handle */
mbed_official	354:e67efb2aab0e	459	if(hadc == HAL_NULL)
mbed_official	354:e67efb2aab0e	460	{
mbed_official	354:e67efb2aab0e	461	return HAL_ERROR;
mbed_official	354:e67efb2aab0e	462	}
mbed_official	354:e67efb2aab0e	463
mbed_official	354:e67efb2aab0e	464	/* Check the parameters */
mbed_official	354:e67efb2aab0e	465	assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official	354:e67efb2aab0e	466
mbed_official	354:e67efb2aab0e	467	/* Change ADC state */
mbed_official	354:e67efb2aab0e	468	hadc->State = HAL_ADC_STATE_BUSY;
mbed_official	354:e67efb2aab0e	469
mbed_official	354:e67efb2aab0e	470	/* Stop potential conversion on going, on regular and injected groups */
mbed_official	354:e67efb2aab0e	471	/* Disable ADC peripheral */
mbed_official	354:e67efb2aab0e	472	tmpHALStatus = ADC_ConversionStop_Disable(hadc);
mbed_official	354:e67efb2aab0e	473
mbed_official	354:e67efb2aab0e	474
mbed_official	354:e67efb2aab0e	475	/* Configuration of ADC parameters if previous preliminary actions are */
mbed_official	354:e67efb2aab0e	476	/* correctly completed. */
mbed_official	354:e67efb2aab0e	477	if (tmpHALStatus != HAL_ERROR)
mbed_official	354:e67efb2aab0e	478	{
mbed_official	354:e67efb2aab0e	479	/* ========== Reset ADC registers ========== */
mbed_official	354:e67efb2aab0e	480	/* Reset register SR */
mbed_official	354:e67efb2aab0e	481	__HAL_ADC_CLEAR_FLAG(hadc, (ADC_FLAG_AWD \| ADC_FLAG_JEOC \| ADC_FLAG_EOC \|
mbed_official	354:e67efb2aab0e	482	ADC_FLAG_JSTRT \| ADC_FLAG_STRT));
mbed_official	354:e67efb2aab0e	483
mbed_official	354:e67efb2aab0e	484	/* Reset register CR1 */
mbed_official	354:e67efb2aab0e	485	CLEAR_BIT(hadc->Instance->CR1, (ADC_CR1_OVRIE \| ADC_CR1_RES \| ADC_CR1_AWDEN \|
mbed_official	354:e67efb2aab0e	486	ADC_CR1_JAWDEN \| ADC_CR1_PDI \| ADC_CR1_PDD \|
mbed_official	354:e67efb2aab0e	487	ADC_CR1_DISCNUM \| ADC_CR1_JDISCEN \| ADC_CR1_DISCEN \|
mbed_official	354:e67efb2aab0e	488	ADC_CR1_JAUTO \| ADC_CR1_AWDSGL \| ADC_CR1_SCAN \|
mbed_official	354:e67efb2aab0e	489	ADC_CR1_JEOCIE \| ADC_CR1_AWDIE \| ADC_CR1_EOCIE \|
mbed_official	354:e67efb2aab0e	490	ADC_CR1_AWDCH ));
mbed_official	354:e67efb2aab0e	491
mbed_official	354:e67efb2aab0e	492	/* Reset register CR2 */
mbed_official	354:e67efb2aab0e	493	__ADC_CR2_CLEAR(hadc);
mbed_official	354:e67efb2aab0e	494
mbed_official	354:e67efb2aab0e	495	/* Reset register SMPR0 */
mbed_official	354:e67efb2aab0e	496	__ADC_SMPR0_CLEAR(hadc);
mbed_official	354:e67efb2aab0e	497
mbed_official	354:e67efb2aab0e	498	/* Reset register SMPR1 */
mbed_official	354:e67efb2aab0e	499	CLEAR_BIT(hadc->Instance->SMPR1, (ADC_SMPR1_SMP29 \| ADC_SMPR1_SMP28 \| ADC_SMPR1_SMP27 \|
mbed_official	354:e67efb2aab0e	500	ADC_SMPR1_SMP26 \| ADC_SMPR1_SMP25 \| ADC_SMPR1_SMP24 \|
mbed_official	354:e67efb2aab0e	501	ADC_SMPR1_SMP23 \| ADC_SMPR1_SMP22 \| ADC_SMPR1_SMP21 \|
mbed_official	354:e67efb2aab0e	502	ADC_SMPR1_SMP20 ));
mbed_official	354:e67efb2aab0e	503
mbed_official	354:e67efb2aab0e	504	/* Reset register SMPR2 */
mbed_official	354:e67efb2aab0e	505	CLEAR_BIT(hadc->Instance->SMPR2, (ADC_SMPR2_SMP19 \| ADC_SMPR2_SMP18 \| ADC_SMPR2_SMP17 \|
mbed_official	354:e67efb2aab0e	506	ADC_SMPR2_SMP16 \| ADC_SMPR2_SMP15 \| ADC_SMPR2_SMP14 \|
mbed_official	354:e67efb2aab0e	507	ADC_SMPR2_SMP13 \| ADC_SMPR2_SMP12 \| ADC_SMPR2_SMP11 \|
mbed_official	354:e67efb2aab0e	508	ADC_SMPR2_SMP10 ));
mbed_official	354:e67efb2aab0e	509
mbed_official	354:e67efb2aab0e	510	/* Reset register SMPR3 */
mbed_official	354:e67efb2aab0e	511	CLEAR_BIT(hadc->Instance->SMPR3, (ADC_SMPR3_SMP9 \| ADC_SMPR3_SMP8 \| ADC_SMPR3_SMP7 \|
mbed_official	354:e67efb2aab0e	512	ADC_SMPR3_SMP6 \| ADC_SMPR3_SMP5 \| ADC_SMPR3_SMP4 \|
mbed_official	354:e67efb2aab0e	513	ADC_SMPR3_SMP3 \| ADC_SMPR3_SMP2 \| ADC_SMPR3_SMP1 \|
mbed_official	354:e67efb2aab0e	514	ADC_SMPR3_SMP0 ));
mbed_official	354:e67efb2aab0e	515
mbed_official	354:e67efb2aab0e	516	/* Reset register JOFR1 */
mbed_official	354:e67efb2aab0e	517	CLEAR_BIT(hadc->Instance->JOFR1, ADC_JOFR1_JOFFSET1);
mbed_official	354:e67efb2aab0e	518	/* Reset register JOFR2 */
mbed_official	354:e67efb2aab0e	519	CLEAR_BIT(hadc->Instance->JOFR2, ADC_JOFR2_JOFFSET2);
mbed_official	354:e67efb2aab0e	520	/* Reset register JOFR3 */
mbed_official	354:e67efb2aab0e	521	CLEAR_BIT(hadc->Instance->JOFR3, ADC_JOFR3_JOFFSET3);
mbed_official	354:e67efb2aab0e	522	/* Reset register JOFR4 */
mbed_official	354:e67efb2aab0e	523	CLEAR_BIT(hadc->Instance->JOFR4, ADC_JOFR4_JOFFSET4);
mbed_official	354:e67efb2aab0e	524
mbed_official	354:e67efb2aab0e	525	/* Reset register HTR */
mbed_official	354:e67efb2aab0e	526	CLEAR_BIT(hadc->Instance->HTR, ADC_HTR_HT);
mbed_official	354:e67efb2aab0e	527	/* Reset register LTR */
mbed_official	354:e67efb2aab0e	528	CLEAR_BIT(hadc->Instance->LTR, ADC_LTR_LT);
mbed_official	354:e67efb2aab0e	529
mbed_official	354:e67efb2aab0e	530	/* Reset register SQR1 */
mbed_official	354:e67efb2aab0e	531	CLEAR_BIT(hadc->Instance->SQR1, (ADC_SQR1_L \| __ADC_SQR1_SQXX));
mbed_official	354:e67efb2aab0e	532
mbed_official	354:e67efb2aab0e	533	/* Reset register SQR2 */
mbed_official	354:e67efb2aab0e	534	CLEAR_BIT(hadc->Instance->SQR2, (ADC_SQR2_SQ24 \| ADC_SQR2_SQ23 \| ADC_SQR2_SQ22 \|
mbed_official	354:e67efb2aab0e	535	ADC_SQR2_SQ21 \| ADC_SQR2_SQ20 \| ADC_SQR2_SQ19 ));
mbed_official	354:e67efb2aab0e	536
mbed_official	354:e67efb2aab0e	537	/* Reset register SQR3 */
mbed_official	354:e67efb2aab0e	538	CLEAR_BIT(hadc->Instance->SQR3, (ADC_SQR3_SQ18 \| ADC_SQR3_SQ17 \| ADC_SQR3_SQ16 \|
mbed_official	354:e67efb2aab0e	539	ADC_SQR3_SQ15 \| ADC_SQR3_SQ14 \| ADC_SQR3_SQ13 ));
mbed_official	354:e67efb2aab0e	540
mbed_official	354:e67efb2aab0e	541	/* Reset register SQR4 */
mbed_official	354:e67efb2aab0e	542	CLEAR_BIT(hadc->Instance->SQR4, (ADC_SQR4_SQ12 \| ADC_SQR4_SQ11 \| ADC_SQR4_SQ10 \|
mbed_official	354:e67efb2aab0e	543	ADC_SQR4_SQ9 \| ADC_SQR4_SQ8 \| ADC_SQR4_SQ7 ));
mbed_official	354:e67efb2aab0e	544
mbed_official	354:e67efb2aab0e	545	/* Reset register SQR5 */
mbed_official	354:e67efb2aab0e	546	CLEAR_BIT(hadc->Instance->SQR5, (ADC_SQR5_SQ6 \| ADC_SQR5_SQ5 \| ADC_SQR5_SQ4 \|
mbed_official	354:e67efb2aab0e	547	ADC_SQR5_SQ3 \| ADC_SQR5_SQ2 \| ADC_SQR5_SQ1 ));
mbed_official	354:e67efb2aab0e	548
mbed_official	354:e67efb2aab0e	549
mbed_official	354:e67efb2aab0e	550	/* Reset register JSQR */
mbed_official	354:e67efb2aab0e	551	CLEAR_BIT(hadc->Instance->JSQR, (ADC_JSQR_JL \|
mbed_official	354:e67efb2aab0e	552	ADC_JSQR_JSQ4 \| ADC_JSQR_JSQ3 \|
mbed_official	354:e67efb2aab0e	553	ADC_JSQR_JSQ2 \| ADC_JSQR_JSQ1 ));
mbed_official	354:e67efb2aab0e	554
mbed_official	354:e67efb2aab0e	555	/* Reset register JSQR */
mbed_official	354:e67efb2aab0e	556	CLEAR_BIT(hadc->Instance->JSQR, (ADC_JSQR_JL \|
mbed_official	354:e67efb2aab0e	557	ADC_JSQR_JSQ4 \| ADC_JSQR_JSQ3 \|
mbed_official	354:e67efb2aab0e	558	ADC_JSQR_JSQ2 \| ADC_JSQR_JSQ1 ));
mbed_official	354:e67efb2aab0e	559
mbed_official	354:e67efb2aab0e	560	/* Reset register DR */
mbed_official	354:e67efb2aab0e	561	/* bits in access mode read only, no direct reset applicable*/
mbed_official	354:e67efb2aab0e	562
mbed_official	354:e67efb2aab0e	563	/* Reset registers JDR1, JDR2, JDR3, JDR4 */
mbed_official	354:e67efb2aab0e	564	/* bits in access mode read only, no direct reset applicable*/
mbed_official	354:e67efb2aab0e	565
mbed_official	354:e67efb2aab0e	566	/* Reset register CCR */
mbed_official	354:e67efb2aab0e	567	CLEAR_BIT(ADC->CCR, ADC_CCR_TSVREFE);
mbed_official	354:e67efb2aab0e	568
mbed_official	354:e67efb2aab0e	569	/* ========== Hard reset ADC peripheral ========== */
mbed_official	354:e67efb2aab0e	570	/* Performs a global reset of the entire ADC peripheral: ADC state is */
mbed_official	354:e67efb2aab0e	571	/* forced to a similar state after device power-on. */
mbed_official	354:e67efb2aab0e	572	/* If needed, copy-paste and uncomment the following reset code into */
mbed_official	354:e67efb2aab0e	573	/* function "void HAL_ADC_MspInit(ADC_HandleTypeDef* hadc)": */
mbed_official	354:e67efb2aab0e	574	/* */
mbed_official	354:e67efb2aab0e	575	/* __ADC1_FORCE_RESET() */
mbed_official	354:e67efb2aab0e	576	/* __ADC1_RELEASE_RESET() */
mbed_official	354:e67efb2aab0e	577
mbed_official	354:e67efb2aab0e	578	/* DeInit the low level hardware */
mbed_official	354:e67efb2aab0e	579	HAL_ADC_MspDeInit(hadc);
mbed_official	354:e67efb2aab0e	580
mbed_official	354:e67efb2aab0e	581	/* Set ADC error code to none */
mbed_official	354:e67efb2aab0e	582	__HAL_ADC_CLEAR_ERRORCODE(hadc);
mbed_official	354:e67efb2aab0e	583
mbed_official	354:e67efb2aab0e	584	/* Change ADC state */
mbed_official	354:e67efb2aab0e	585	hadc->State = HAL_ADC_STATE_RESET;
mbed_official	354:e67efb2aab0e	586
mbed_official	354:e67efb2aab0e	587	}
mbed_official	354:e67efb2aab0e	588
mbed_official	354:e67efb2aab0e	589	/* Process unlocked */
mbed_official	354:e67efb2aab0e	590	__HAL_UNLOCK(hadc);
mbed_official	354:e67efb2aab0e	591
mbed_official	354:e67efb2aab0e	592	/* Return function status */
mbed_official	354:e67efb2aab0e	593	return tmpHALStatus;
mbed_official	354:e67efb2aab0e	594	}
mbed_official	354:e67efb2aab0e	595
mbed_official	354:e67efb2aab0e	596	/**
mbed_official	354:e67efb2aab0e	597	* @brief Initializes the ADC MSP.
mbed_official	354:e67efb2aab0e	598	* @param hadc: ADC handle
mbed_official	354:e67efb2aab0e	599	* @retval None
mbed_official	354:e67efb2aab0e	600	*/
mbed_official	354:e67efb2aab0e	601	__weak void HAL_ADC_MspInit(ADC_HandleTypeDef* hadc)
mbed_official	354:e67efb2aab0e	602	{
mbed_official	354:e67efb2aab0e	603	/* NOTE : This function should not be modified. When the callback is needed,
mbed_official	354:e67efb2aab0e	604	function HAL_ADC_MspInit must be implemented in the user file.
mbed_official	354:e67efb2aab0e	605	*/
mbed_official	354:e67efb2aab0e	606	}
mbed_official	354:e67efb2aab0e	607
mbed_official	354:e67efb2aab0e	608	/**
mbed_official	354:e67efb2aab0e	609	* @brief DeInitializes the ADC MSP.
mbed_official	354:e67efb2aab0e	610	* @param hadc: ADC handle
mbed_official	354:e67efb2aab0e	611	* @retval None
mbed_official	354:e67efb2aab0e	612	*/
mbed_official	354:e67efb2aab0e	613	__weak void HAL_ADC_MspDeInit(ADC_HandleTypeDef* hadc)
mbed_official	354:e67efb2aab0e	614	{
mbed_official	354:e67efb2aab0e	615	/* NOTE : This function should not be modified. When the callback is needed,
mbed_official	354:e67efb2aab0e	616	function HAL_ADC_MspDeInit must be implemented in the user file.
mbed_official	354:e67efb2aab0e	617	*/
mbed_official	354:e67efb2aab0e	618	}
mbed_official	354:e67efb2aab0e	619
mbed_official	354:e67efb2aab0e	620	/**
mbed_official	354:e67efb2aab0e	621	* @}
mbed_official	354:e67efb2aab0e	622	*/
mbed_official	354:e67efb2aab0e	623
mbed_official	354:e67efb2aab0e	624	/** @defgroup ADC_Exported_Functions_Group2 IO operation functions
mbed_official	354:e67efb2aab0e	625	* @brief IO operation functions
mbed_official	354:e67efb2aab0e	626	*
mbed_official	354:e67efb2aab0e	627	@verbatim
mbed_official	354:e67efb2aab0e	628	===============================================================================
mbed_official	354:e67efb2aab0e	629	##### IO operation functions #####
mbed_official	354:e67efb2aab0e	630	===============================================================================
mbed_official	354:e67efb2aab0e	631	[..] This section provides functions allowing to:
mbed_official	354:e67efb2aab0e	632	(+) Start conversion of regular group.
mbed_official	354:e67efb2aab0e	633	(+) Stop conversion of regular group.
mbed_official	354:e67efb2aab0e	634	(+) Poll for conversion complete on regular group.
mbed_official	354:e67efb2aab0e	635	(+) Poll for conversion event.
mbed_official	354:e67efb2aab0e	636	(+) Get result of regular channel conversion.
mbed_official	354:e67efb2aab0e	637	(+) Start conversion of regular group and enable interruptions.
mbed_official	354:e67efb2aab0e	638	(+) Stop conversion of regular group and disable interruptions.
mbed_official	354:e67efb2aab0e	639	(+) Handle ADC interrupt request
mbed_official	354:e67efb2aab0e	640	(+) Start conversion of regular group and enable DMA transfer.
mbed_official	354:e67efb2aab0e	641	(+) Stop conversion of regular group and disable ADC DMA transfer.
mbed_official	354:e67efb2aab0e	642	@endverbatim
mbed_official	354:e67efb2aab0e	643	* @{
mbed_official	354:e67efb2aab0e	644	*/
mbed_official	354:e67efb2aab0e	645
mbed_official	354:e67efb2aab0e	646	/**
mbed_official	354:e67efb2aab0e	647	* @brief Enables ADC, starts conversion of regular group.
mbed_official	354:e67efb2aab0e	648	* Interruptions enabled in this function: None.
mbed_official	354:e67efb2aab0e	649	* @param hadc: ADC handle
mbed_official	354:e67efb2aab0e	650	* @retval HAL status
mbed_official	354:e67efb2aab0e	651	*/
mbed_official	354:e67efb2aab0e	652	HAL_StatusTypeDef HAL_ADC_Start(ADC_HandleTypeDef* hadc)
mbed_official	354:e67efb2aab0e	653	{
mbed_official	354:e67efb2aab0e	654	HAL_StatusTypeDef tmpHALStatus = HAL_OK;
mbed_official	354:e67efb2aab0e	655
mbed_official	354:e67efb2aab0e	656	/* Check the parameters */
mbed_official	354:e67efb2aab0e	657	assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official	354:e67efb2aab0e	658
mbed_official	354:e67efb2aab0e	659	/* Process locked */
mbed_official	354:e67efb2aab0e	660	__HAL_LOCK(hadc);
mbed_official	354:e67efb2aab0e	661
mbed_official	354:e67efb2aab0e	662	/* Enable the ADC peripheral */
mbed_official	354:e67efb2aab0e	663	tmpHALStatus = ADC_Enable(hadc);
mbed_official	354:e67efb2aab0e	664
mbed_official	354:e67efb2aab0e	665	/* Start conversion if ADC is effectively enabled */
mbed_official	354:e67efb2aab0e	666	if (tmpHALStatus != HAL_ERROR)
mbed_official	354:e67efb2aab0e	667	{
mbed_official	354:e67efb2aab0e	668	/* State machine update: Check if an injected conversion is ongoing */
mbed_official	354:e67efb2aab0e	669	if(hadc->State == HAL_ADC_STATE_BUSY_INJ)
mbed_official	354:e67efb2aab0e	670	{
mbed_official	354:e67efb2aab0e	671	/* Change ADC state */
mbed_official	354:e67efb2aab0e	672	hadc->State = HAL_ADC_STATE_BUSY_INJ_REG;
mbed_official	354:e67efb2aab0e	673	}
mbed_official	354:e67efb2aab0e	674	else
mbed_official	354:e67efb2aab0e	675	{
mbed_official	354:e67efb2aab0e	676	/* Change ADC state */
mbed_official	354:e67efb2aab0e	677	hadc->State = HAL_ADC_STATE_BUSY_REG;
mbed_official	354:e67efb2aab0e	678	}
mbed_official	354:e67efb2aab0e	679
mbed_official	354:e67efb2aab0e	680	/* Set ADC error code to none */
mbed_official	354:e67efb2aab0e	681	__HAL_ADC_CLEAR_ERRORCODE(hadc);
mbed_official	354:e67efb2aab0e	682
mbed_official	354:e67efb2aab0e	683	/* Clear regular group conversion flag and overrun flag */
mbed_official	354:e67efb2aab0e	684	/* (To ensure of no unknown state from potential previous ADC operations) */
mbed_official	354:e67efb2aab0e	685	__HAL_ADC_CLEAR_FLAG(hadc, ADC_FLAG_EOC);
mbed_official	354:e67efb2aab0e	686
mbed_official	354:e67efb2aab0e	687	/* Start conversion of regular group if software start has been selected. */
mbed_official	354:e67efb2aab0e	688	/* If external trigger has been selected, conversion will start at next */
mbed_official	354:e67efb2aab0e	689	/* trigger event. */
mbed_official	354:e67efb2aab0e	690	if (__HAL_ADC_IS_SOFTWARE_START_REGULAR(hadc))
mbed_official	354:e67efb2aab0e	691	{
mbed_official	354:e67efb2aab0e	692	/* Start ADC conversion on regular group */
mbed_official	354:e67efb2aab0e	693	SET_BIT(hadc->Instance->CR2, ADC_CR2_SWSTART);
mbed_official	354:e67efb2aab0e	694	}
mbed_official	354:e67efb2aab0e	695	}
mbed_official	354:e67efb2aab0e	696
mbed_official	354:e67efb2aab0e	697	/* Process unlocked */
mbed_official	354:e67efb2aab0e	698	__HAL_UNLOCK(hadc);
mbed_official	354:e67efb2aab0e	699
mbed_official	354:e67efb2aab0e	700	/* Return function status */
mbed_official	354:e67efb2aab0e	701	return tmpHALStatus;
mbed_official	354:e67efb2aab0e	702	}
mbed_official	354:e67efb2aab0e	703
mbed_official	354:e67efb2aab0e	704	/**
mbed_official	354:e67efb2aab0e	705	* @brief Stop ADC conversion of regular group (and injected channels in
mbed_official	354:e67efb2aab0e	706	* case of auto_injection mode), disable ADC peripheral.
mbed_official	354:e67efb2aab0e	707	* @note: ADC peripheral disable is forcing interruption of potential
mbed_official	354:e67efb2aab0e	708	* conversion on injected group. If injected group is under use, it
mbed_official	354:e67efb2aab0e	709	* should be preliminarily stopped using HAL_ADCEx_InjectedStop function.
mbed_official	354:e67efb2aab0e	710	* @param hadc: ADC handle
mbed_official	354:e67efb2aab0e	711	* @retval HAL status.
mbed_official	354:e67efb2aab0e	712	*/
mbed_official	354:e67efb2aab0e	713	HAL_StatusTypeDef HAL_ADC_Stop(ADC_HandleTypeDef* hadc)
mbed_official	354:e67efb2aab0e	714	{
mbed_official	354:e67efb2aab0e	715	HAL_StatusTypeDef tmpHALStatus = HAL_OK;
mbed_official	354:e67efb2aab0e	716
mbed_official	354:e67efb2aab0e	717	/* Check the parameters */
mbed_official	354:e67efb2aab0e	718	assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official	354:e67efb2aab0e	719
mbed_official	354:e67efb2aab0e	720	/* Process locked */
mbed_official	354:e67efb2aab0e	721	__HAL_LOCK(hadc);
mbed_official	354:e67efb2aab0e	722
mbed_official	354:e67efb2aab0e	723	/* Stop potential conversion on going, on regular and injected groups */
mbed_official	354:e67efb2aab0e	724	/* Disable ADC peripheral */
mbed_official	354:e67efb2aab0e	725	tmpHALStatus = ADC_ConversionStop_Disable(hadc);
mbed_official	354:e67efb2aab0e	726
mbed_official	354:e67efb2aab0e	727	/* Check if ADC is effectively disabled */
mbed_official	354:e67efb2aab0e	728	if (tmpHALStatus != HAL_ERROR)
mbed_official	354:e67efb2aab0e	729	{
mbed_official	354:e67efb2aab0e	730	/* Change ADC state */
mbed_official	354:e67efb2aab0e	731	hadc->State = HAL_ADC_STATE_READY;
mbed_official	354:e67efb2aab0e	732	}
mbed_official	354:e67efb2aab0e	733
mbed_official	354:e67efb2aab0e	734	/* Process unlocked */
mbed_official	354:e67efb2aab0e	735	__HAL_UNLOCK(hadc);
mbed_official	354:e67efb2aab0e	736
mbed_official	354:e67efb2aab0e	737	/* Return function status */
mbed_official	354:e67efb2aab0e	738	return tmpHALStatus;
mbed_official	354:e67efb2aab0e	739	}
mbed_official	354:e67efb2aab0e	740
mbed_official	354:e67efb2aab0e	741	/**
mbed_official	354:e67efb2aab0e	742	* @brief Wait for regular group conversion to be completed.
mbed_official	354:e67efb2aab0e	743	* @param hadc: ADC handle
mbed_official	354:e67efb2aab0e	744	* @param Timeout: Timeout value in millisecond.
mbed_official	354:e67efb2aab0e	745	* @retval HAL status
mbed_official	354:e67efb2aab0e	746	*/
mbed_official	354:e67efb2aab0e	747	HAL_StatusTypeDef HAL_ADC_PollForConversion(ADC_HandleTypeDef* hadc, uint32_t Timeout)
mbed_official	354:e67efb2aab0e	748	{
mbed_official	354:e67efb2aab0e	749	uint32_t tickstart = 0;
mbed_official	354:e67efb2aab0e	750
mbed_official	354:e67efb2aab0e	751	/* Check the parameters */
mbed_official	354:e67efb2aab0e	752	assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official	354:e67efb2aab0e	753
mbed_official	354:e67efb2aab0e	754	/* Get timeout */
mbed_official	354:e67efb2aab0e	755	tickstart = HAL_GetTick();
mbed_official	354:e67efb2aab0e	756
mbed_official	354:e67efb2aab0e	757	/* Wait until End of Conversion flag is raised */
mbed_official	354:e67efb2aab0e	758	while(HAL_IS_BIT_CLR(hadc->Instance->SR, ADC_FLAG_EOC))
mbed_official	354:e67efb2aab0e	759	{
mbed_official	354:e67efb2aab0e	760	/* Check if timeout is disabled (set to infinite wait) */
mbed_official	354:e67efb2aab0e	761	if(Timeout != HAL_MAX_DELAY)
mbed_official	354:e67efb2aab0e	762	{
mbed_official	354:e67efb2aab0e	763	if((Timeout == 0)\|\|((HAL_GetTick() - tickstart ) > Timeout))
mbed_official	354:e67efb2aab0e	764	{
mbed_official	354:e67efb2aab0e	765	/* Update ADC state machine to timeout */
mbed_official	354:e67efb2aab0e	766	hadc->State = HAL_ADC_STATE_TIMEOUT;
mbed_official	354:e67efb2aab0e	767
mbed_official	354:e67efb2aab0e	768	/* Process unlocked */
mbed_official	354:e67efb2aab0e	769	__HAL_UNLOCK(hadc);
mbed_official	354:e67efb2aab0e	770
mbed_official	354:e67efb2aab0e	771	return HAL_ERROR;
mbed_official	354:e67efb2aab0e	772	}
mbed_official	354:e67efb2aab0e	773	}
mbed_official	354:e67efb2aab0e	774	}
mbed_official	354:e67efb2aab0e	775
mbed_official	354:e67efb2aab0e	776	/* Clear end of conversion flag of regular group if low power feature "Auto */
mbed_official	354:e67efb2aab0e	777	/* Wait" is disabled, to not interfere with this feature until data */
mbed_official	354:e67efb2aab0e	778	/* register is read using function HAL_ADC_GetValue(). */
mbed_official	354:e67efb2aab0e	779	if (hadc->Init.LowPowerAutoWait == DISABLE)
mbed_official	354:e67efb2aab0e	780	{
mbed_official	354:e67efb2aab0e	781	/* Clear regular group conversion flag */
mbed_official	354:e67efb2aab0e	782	__HAL_ADC_CLEAR_FLAG(hadc, ADC_FLAG_STRT \| ADC_FLAG_EOC);
mbed_official	354:e67efb2aab0e	783	}
mbed_official	354:e67efb2aab0e	784
mbed_official	354:e67efb2aab0e	785	/* Update state machine on conversion status if not in error state */
mbed_official	354:e67efb2aab0e	786	if(hadc->State != HAL_ADC_STATE_ERROR)
mbed_official	354:e67efb2aab0e	787	{
mbed_official	354:e67efb2aab0e	788	/* Update ADC state machine */
mbed_official	354:e67efb2aab0e	789	if(hadc->State != HAL_ADC_STATE_EOC_INJ_REG)
mbed_official	354:e67efb2aab0e	790	{
mbed_official	354:e67efb2aab0e	791	/* Check if a conversion is ready on injected group */
mbed_official	354:e67efb2aab0e	792	if(hadc->State == HAL_ADC_STATE_EOC_INJ)
mbed_official	354:e67efb2aab0e	793	{
mbed_official	354:e67efb2aab0e	794	/* Change ADC state */
mbed_official	354:e67efb2aab0e	795	hadc->State = HAL_ADC_STATE_EOC_INJ_REG;
mbed_official	354:e67efb2aab0e	796	}
mbed_official	354:e67efb2aab0e	797	else
mbed_official	354:e67efb2aab0e	798	{
mbed_official	354:e67efb2aab0e	799	/* Change ADC state */
mbed_official	354:e67efb2aab0e	800	hadc->State = HAL_ADC_STATE_EOC_REG;
mbed_official	354:e67efb2aab0e	801	}
mbed_official	354:e67efb2aab0e	802	}
mbed_official	354:e67efb2aab0e	803	}
mbed_official	354:e67efb2aab0e	804
mbed_official	354:e67efb2aab0e	805	/* Return ADC state */
mbed_official	354:e67efb2aab0e	806	return HAL_OK;
mbed_official	354:e67efb2aab0e	807	}
mbed_official	354:e67efb2aab0e	808
mbed_official	354:e67efb2aab0e	809	/**
mbed_official	354:e67efb2aab0e	810	* @brief Poll for conversion event.
mbed_official	354:e67efb2aab0e	811	* @param hadc: ADC handle
mbed_official	354:e67efb2aab0e	812	* @param EventType: the ADC event type.
mbed_official	354:e67efb2aab0e	813	* This parameter can be one of the following values:
mbed_official	354:e67efb2aab0e	814	* @arg AWD_EVENT: ADC Analog watchdog event.
mbed_official	354:e67efb2aab0e	815	* @arg OVR_EVENT: ADC Overrun event
mbed_official	354:e67efb2aab0e	816	* @param Timeout: Timeout value in millisecond.
mbed_official	354:e67efb2aab0e	817	* @retval HAL status
mbed_official	354:e67efb2aab0e	818	*/
mbed_official	354:e67efb2aab0e	819	HAL_StatusTypeDef HAL_ADC_PollForEvent(ADC_HandleTypeDef* hadc, uint32_t EventType, uint32_t Timeout)
mbed_official	354:e67efb2aab0e	820	{
mbed_official	354:e67efb2aab0e	821	uint32_t tickstart = 0;
mbed_official	354:e67efb2aab0e	822
mbed_official	354:e67efb2aab0e	823	/* Check the parameters */
mbed_official	354:e67efb2aab0e	824	assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official	354:e67efb2aab0e	825	assert_param(IS_ADC_EVENT_TYPE(EventType));
mbed_official	354:e67efb2aab0e	826
mbed_official	354:e67efb2aab0e	827	/* Get timeout */
mbed_official	354:e67efb2aab0e	828	tickstart = HAL_GetTick();
mbed_official	354:e67efb2aab0e	829
mbed_official	354:e67efb2aab0e	830	/* Check selected event flag */
mbed_official	354:e67efb2aab0e	831	while(__HAL_ADC_GET_FLAG(hadc, EventType) == RESET)
mbed_official	354:e67efb2aab0e	832	{
mbed_official	354:e67efb2aab0e	833	/* Check if timeout is disabled (set to infinite wait) */
mbed_official	354:e67efb2aab0e	834	if(Timeout != HAL_MAX_DELAY)
mbed_official	354:e67efb2aab0e	835	{
mbed_official	354:e67efb2aab0e	836	if((Timeout == 0)\|\|((HAL_GetTick() - tickstart ) > Timeout))
mbed_official	354:e67efb2aab0e	837	{
mbed_official	354:e67efb2aab0e	838	/* Update ADC state machine to timeout */
mbed_official	354:e67efb2aab0e	839	hadc->State = HAL_ADC_STATE_TIMEOUT;
mbed_official	354:e67efb2aab0e	840
mbed_official	354:e67efb2aab0e	841	/* Process unlocked */
mbed_official	354:e67efb2aab0e	842	__HAL_UNLOCK(hadc);
mbed_official	354:e67efb2aab0e	843
mbed_official	354:e67efb2aab0e	844	return HAL_ERROR;
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	switch(EventType)
mbed_official	354:e67efb2aab0e	850	{
mbed_official	354:e67efb2aab0e	851	/* Analog watchdog (level out of window) event */
mbed_official	354:e67efb2aab0e	852	case AWD_EVENT:
mbed_official	354:e67efb2aab0e	853	/* Change ADC state */
mbed_official	354:e67efb2aab0e	854	hadc->State = HAL_ADC_STATE_AWD;
mbed_official	354:e67efb2aab0e	855
mbed_official	354:e67efb2aab0e	856	/* Clear ADC analog watchdog flag */
mbed_official	354:e67efb2aab0e	857	__HAL_ADC_CLEAR_FLAG(hadc, ADC_FLAG_AWD);
mbed_official	354:e67efb2aab0e	858	break;
mbed_official	354:e67efb2aab0e	859
mbed_official	354:e67efb2aab0e	860	/* Overrun event */
mbed_official	354:e67efb2aab0e	861	default: /* Case OVR_EVENT */
mbed_official	354:e67efb2aab0e	862	/* Change ADC state */
mbed_official	354:e67efb2aab0e	863	hadc->State = HAL_ADC_STATE_ERROR;
mbed_official	354:e67efb2aab0e	864
mbed_official	354:e67efb2aab0e	865	/* Set ADC error code to overrun */
mbed_official	354:e67efb2aab0e	866	hadc->ErrorCode \|= HAL_ADC_ERROR_OVR;
mbed_official	354:e67efb2aab0e	867
mbed_official	354:e67efb2aab0e	868	/* Clear ADC Overrun flag */
mbed_official	354:e67efb2aab0e	869	__HAL_ADC_CLEAR_FLAG(hadc, ADC_FLAG_OVR);
mbed_official	354:e67efb2aab0e	870	break;
mbed_official	354:e67efb2aab0e	871	}
mbed_official	354:e67efb2aab0e	872
mbed_official	354:e67efb2aab0e	873	/* Return ADC state */
mbed_official	354:e67efb2aab0e	874	return HAL_OK;
mbed_official	354:e67efb2aab0e	875	}
mbed_official	354:e67efb2aab0e	876
mbed_official	354:e67efb2aab0e	877	/**
mbed_official	354:e67efb2aab0e	878	* @brief Enables ADC, starts conversion of regular group with interruption.
mbed_official	354:e67efb2aab0e	879	* Interruptions enabled in this function: EOC (end of conversion),
mbed_official	354:e67efb2aab0e	880	* overrun.
mbed_official	354:e67efb2aab0e	881	* Each of these interruptions has its dedicated callback function.
mbed_official	354:e67efb2aab0e	882	* @param hadc: ADC handle
mbed_official	354:e67efb2aab0e	883	* @retval HAL status
mbed_official	354:e67efb2aab0e	884	*/
mbed_official	354:e67efb2aab0e	885	HAL_StatusTypeDef HAL_ADC_Start_IT(ADC_HandleTypeDef* hadc)
mbed_official	354:e67efb2aab0e	886	{
mbed_official	354:e67efb2aab0e	887	HAL_StatusTypeDef tmpHALStatus = HAL_OK;
mbed_official	354:e67efb2aab0e	888
mbed_official	354:e67efb2aab0e	889	/* Check the parameters */
mbed_official	354:e67efb2aab0e	890	assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official	354:e67efb2aab0e	891
mbed_official	354:e67efb2aab0e	892	/* Process locked */
mbed_official	354:e67efb2aab0e	893	__HAL_LOCK(hadc);
mbed_official	354:e67efb2aab0e	894
mbed_official	354:e67efb2aab0e	895	/* Enable the ADC peripheral */
mbed_official	354:e67efb2aab0e	896	tmpHALStatus = ADC_Enable(hadc);
mbed_official	354:e67efb2aab0e	897
mbed_official	354:e67efb2aab0e	898	/* Start conversion if ADC is effectively enabled */
mbed_official	354:e67efb2aab0e	899	if (tmpHALStatus != HAL_ERROR)
mbed_official	354:e67efb2aab0e	900	{
mbed_official	354:e67efb2aab0e	901	/* State machine update: Check if an injected conversion is ongoing */
mbed_official	354:e67efb2aab0e	902	if(hadc->State == HAL_ADC_STATE_BUSY_INJ)
mbed_official	354:e67efb2aab0e	903	{
mbed_official	354:e67efb2aab0e	904	/* Change ADC state */
mbed_official	354:e67efb2aab0e	905	hadc->State = HAL_ADC_STATE_BUSY_INJ_REG;
mbed_official	354:e67efb2aab0e	906	}
mbed_official	354:e67efb2aab0e	907	else
mbed_official	354:e67efb2aab0e	908	{
mbed_official	354:e67efb2aab0e	909	/* Change ADC state */
mbed_official	354:e67efb2aab0e	910	hadc->State = HAL_ADC_STATE_BUSY_REG;
mbed_official	354:e67efb2aab0e	911	}
mbed_official	354:e67efb2aab0e	912
mbed_official	354:e67efb2aab0e	913	/* Set ADC error code to none */
mbed_official	354:e67efb2aab0e	914	__HAL_ADC_CLEAR_ERRORCODE(hadc);
mbed_official	354:e67efb2aab0e	915
mbed_official	354:e67efb2aab0e	916	/* Clear regular group conversion flag and overrun flag */
mbed_official	354:e67efb2aab0e	917	/* (To ensure of no unknown state from potential previous ADC operations) */
mbed_official	354:e67efb2aab0e	918	__HAL_ADC_CLEAR_FLAG(hadc, ADC_FLAG_EOC);
mbed_official	354:e67efb2aab0e	919
mbed_official	354:e67efb2aab0e	920	/* Enable end of conversion interrupt for regular group */
mbed_official	354:e67efb2aab0e	921	__HAL_ADC_ENABLE_IT(hadc, (ADC_IT_EOC \| ADC_IT_OVR));
mbed_official	354:e67efb2aab0e	922
mbed_official	354:e67efb2aab0e	923	/* Start conversion of regular group if software start has been selected. */
mbed_official	354:e67efb2aab0e	924	/* If external trigger has been selected, conversion will start at next */
mbed_official	354:e67efb2aab0e	925	/* trigger event. */
mbed_official	354:e67efb2aab0e	926	if (__HAL_ADC_IS_SOFTWARE_START_REGULAR(hadc))
mbed_official	354:e67efb2aab0e	927	{
mbed_official	354:e67efb2aab0e	928	/* Start ADC conversion on regular group */
mbed_official	354:e67efb2aab0e	929	SET_BIT(hadc->Instance->CR2, ADC_CR2_SWSTART);
mbed_official	354:e67efb2aab0e	930	}
mbed_official	354:e67efb2aab0e	931
mbed_official	354:e67efb2aab0e	932	}
mbed_official	354:e67efb2aab0e	933
mbed_official	354:e67efb2aab0e	934	/* Process unlocked */
mbed_official	354:e67efb2aab0e	935	__HAL_UNLOCK(hadc);
mbed_official	354:e67efb2aab0e	936
mbed_official	354:e67efb2aab0e	937	/* Return function status */
mbed_official	354:e67efb2aab0e	938	return tmpHALStatus;
mbed_official	354:e67efb2aab0e	939	}
mbed_official	354:e67efb2aab0e	940
mbed_official	354:e67efb2aab0e	941	/**
mbed_official	354:e67efb2aab0e	942	* @brief Stop ADC conversion of regular group (and injected group in
mbed_official	354:e67efb2aab0e	943	* case of auto_injection mode), disable interrution of
mbed_official	354:e67efb2aab0e	944	* end-of-conversion, disable ADC peripheral.
mbed_official	354:e67efb2aab0e	945	* @param hadc: ADC handle
mbed_official	354:e67efb2aab0e	946	* @retval None
mbed_official	354:e67efb2aab0e	947	*/
mbed_official	354:e67efb2aab0e	948	HAL_StatusTypeDef HAL_ADC_Stop_IT(ADC_HandleTypeDef* hadc)
mbed_official	354:e67efb2aab0e	949	{
mbed_official	354:e67efb2aab0e	950	HAL_StatusTypeDef tmpHALStatus = HAL_OK;
mbed_official	354:e67efb2aab0e	951
mbed_official	354:e67efb2aab0e	952	/* Check the parameters */
mbed_official	354:e67efb2aab0e	953	assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official	354:e67efb2aab0e	954
mbed_official	354:e67efb2aab0e	955	/* Process locked */
mbed_official	354:e67efb2aab0e	956	__HAL_LOCK(hadc);
mbed_official	354:e67efb2aab0e	957
mbed_official	354:e67efb2aab0e	958	/* Stop potential conversion on going, on regular and injected groups */
mbed_official	354:e67efb2aab0e	959	/* Disable ADC peripheral */
mbed_official	354:e67efb2aab0e	960	tmpHALStatus = ADC_ConversionStop_Disable(hadc);
mbed_official	354:e67efb2aab0e	961
mbed_official	354:e67efb2aab0e	962	/* Check if ADC is effectively disabled */
mbed_official	354:e67efb2aab0e	963	if (tmpHALStatus != HAL_ERROR)
mbed_official	354:e67efb2aab0e	964	{
mbed_official	354:e67efb2aab0e	965	/* Disable ADC end of conversion interrupt for regular group */
mbed_official	354:e67efb2aab0e	966	__HAL_ADC_DISABLE_IT(hadc, ADC_IT_EOC);
mbed_official	354:e67efb2aab0e	967
mbed_official	354:e67efb2aab0e	968	/* Change ADC state */
mbed_official	354:e67efb2aab0e	969	hadc->State = HAL_ADC_STATE_READY;
mbed_official	354:e67efb2aab0e	970	}
mbed_official	354:e67efb2aab0e	971
mbed_official	354:e67efb2aab0e	972	/* Process unlocked */
mbed_official	354:e67efb2aab0e	973	__HAL_UNLOCK(hadc);
mbed_official	354:e67efb2aab0e	974
mbed_official	354:e67efb2aab0e	975	/* Return function status */
mbed_official	354:e67efb2aab0e	976	return tmpHALStatus;
mbed_official	354:e67efb2aab0e	977	}
mbed_official	354:e67efb2aab0e	978
mbed_official	354:e67efb2aab0e	979	/**
mbed_official	354:e67efb2aab0e	980	* @brief Enables ADC, starts conversion of regular group and transfers result
mbed_official	354:e67efb2aab0e	981	* through DMA.
mbed_official	354:e67efb2aab0e	982	* Interruptions enabled in this function:
mbed_official	354:e67efb2aab0e	983	* overrun, DMA half transfer, DMA transfer complete.
mbed_official	354:e67efb2aab0e	984	* Each of these interruptions has its dedicated callback function.
mbed_official	354:e67efb2aab0e	985	* @param hadc: ADC handle
mbed_official	354:e67efb2aab0e	986	* @param pData: The destination Buffer address.
mbed_official	354:e67efb2aab0e	987	* @param Length: The length of data to be transferred from ADC peripheral to memory.
mbed_official	354:e67efb2aab0e	988	* @retval None
mbed_official	354:e67efb2aab0e	989	*/
mbed_official	354:e67efb2aab0e	990	HAL_StatusTypeDef HAL_ADC_Start_DMA(ADC_HandleTypeDef* hadc, uint32_t* pData, uint32_t Length)
mbed_official	354:e67efb2aab0e	991	{
mbed_official	354:e67efb2aab0e	992	HAL_StatusTypeDef tmpHALStatus = HAL_OK;
mbed_official	354:e67efb2aab0e	993
mbed_official	354:e67efb2aab0e	994	/* Check the parameters */
mbed_official	354:e67efb2aab0e	995	assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official	354:e67efb2aab0e	996
mbed_official	354:e67efb2aab0e	997	/* Process locked */
mbed_official	354:e67efb2aab0e	998	__HAL_LOCK(hadc);
mbed_official	354:e67efb2aab0e	999
mbed_official	354:e67efb2aab0e	1000	/* Enable the ADC peripheral */
mbed_official	354:e67efb2aab0e	1001	tmpHALStatus = ADC_Enable(hadc);
mbed_official	354:e67efb2aab0e	1002
mbed_official	354:e67efb2aab0e	1003	/* Start conversion if ADC is effectively enabled */
mbed_official	354:e67efb2aab0e	1004	if (tmpHALStatus != HAL_ERROR)
mbed_official	354:e67efb2aab0e	1005	{
mbed_official	354:e67efb2aab0e	1006	/* State machine update: Check if an injected conversion is ongoing */
mbed_official	354:e67efb2aab0e	1007	if(hadc->State == HAL_ADC_STATE_BUSY_INJ)
mbed_official	354:e67efb2aab0e	1008	{
mbed_official	354:e67efb2aab0e	1009	/* Change ADC state */
mbed_official	354:e67efb2aab0e	1010	hadc->State = HAL_ADC_STATE_BUSY_INJ_REG;
mbed_official	354:e67efb2aab0e	1011	}
mbed_official	354:e67efb2aab0e	1012	else
mbed_official	354:e67efb2aab0e	1013	{
mbed_official	354:e67efb2aab0e	1014	/* Change ADC state */
mbed_official	354:e67efb2aab0e	1015	hadc->State = HAL_ADC_STATE_BUSY_REG;
mbed_official	354:e67efb2aab0e	1016	}
mbed_official	354:e67efb2aab0e	1017
mbed_official	354:e67efb2aab0e	1018	/* Set ADC error code to none */
mbed_official	354:e67efb2aab0e	1019	__HAL_ADC_CLEAR_ERRORCODE(hadc);
mbed_official	354:e67efb2aab0e	1020
mbed_official	354:e67efb2aab0e	1021
mbed_official	354:e67efb2aab0e	1022	/* Set the DMA transfer complete callback */
mbed_official	354:e67efb2aab0e	1023	hadc->DMA_Handle->XferCpltCallback = ADC_DMAConvCplt;
mbed_official	354:e67efb2aab0e	1024
mbed_official	354:e67efb2aab0e	1025	/* Set the DMA half transfer complete callback */
mbed_official	354:e67efb2aab0e	1026	hadc->DMA_Handle->XferHalfCpltCallback = ADC_DMAHalfConvCplt;
mbed_official	354:e67efb2aab0e	1027
mbed_official	354:e67efb2aab0e	1028	/* Set the DMA error callback */
mbed_official	354:e67efb2aab0e	1029	hadc->DMA_Handle->XferErrorCallback = ADC_DMAError;
mbed_official	354:e67efb2aab0e	1030
mbed_official	354:e67efb2aab0e	1031
mbed_official	354:e67efb2aab0e	1032	/* Manage ADC and DMA start: ADC overrun interruption, DMA start, ADC */
mbed_official	354:e67efb2aab0e	1033	/* start (in case of SW start): */
mbed_official	354:e67efb2aab0e	1034
mbed_official	354:e67efb2aab0e	1035	/* Clear regular group conversion flag and overrun flag */
mbed_official	354:e67efb2aab0e	1036	/* (To ensure of no unknown state from potential previous ADC operations) */
mbed_official	354:e67efb2aab0e	1037	__HAL_ADC_CLEAR_FLAG(hadc, ADC_FLAG_EOC);
mbed_official	354:e67efb2aab0e	1038
mbed_official	354:e67efb2aab0e	1039	/* Enable ADC overrun interrupt */
mbed_official	354:e67efb2aab0e	1040	__HAL_ADC_ENABLE_IT(hadc, ADC_IT_OVR);
mbed_official	354:e67efb2aab0e	1041
mbed_official	354:e67efb2aab0e	1042	/* Enable ADC DMA mode */
mbed_official	354:e67efb2aab0e	1043	hadc->Instance->CR2 \|= ADC_CR2_DMA;
mbed_official	354:e67efb2aab0e	1044
mbed_official	354:e67efb2aab0e	1045	/* Start the DMA channel */
mbed_official	354:e67efb2aab0e	1046	HAL_DMA_Start_IT(hadc->DMA_Handle, (uint32_t)&hadc->Instance->DR, (uint32_t)pData, Length);
mbed_official	354:e67efb2aab0e	1047
mbed_official	354:e67efb2aab0e	1048	/* Start conversion of regular group if software start has been selected. */
mbed_official	354:e67efb2aab0e	1049	/* If external trigger has been selected, conversion will start at next */
mbed_official	354:e67efb2aab0e	1050	/* trigger event. */
mbed_official	354:e67efb2aab0e	1051	/* Note: Alternate trigger for single conversion could be to force an */
mbed_official	354:e67efb2aab0e	1052	/* additional set of bit ADON "hadc->Instance->CR2 \|= ADC_CR2_ADON;"*/
mbed_official	354:e67efb2aab0e	1053	if (__HAL_ADC_IS_SOFTWARE_START_REGULAR(hadc))
mbed_official	354:e67efb2aab0e	1054	{
mbed_official	354:e67efb2aab0e	1055	/* Start ADC conversion on regular group */
mbed_official	354:e67efb2aab0e	1056	SET_BIT(hadc->Instance->CR2, ADC_CR2_SWSTART);
mbed_official	354:e67efb2aab0e	1057	}
mbed_official	354:e67efb2aab0e	1058	}
mbed_official	354:e67efb2aab0e	1059
mbed_official	354:e67efb2aab0e	1060	/* Process unlocked */
mbed_official	354:e67efb2aab0e	1061	__HAL_UNLOCK(hadc);
mbed_official	354:e67efb2aab0e	1062
mbed_official	354:e67efb2aab0e	1063	/* Return function status */
mbed_official	354:e67efb2aab0e	1064	return tmpHALStatus;
mbed_official	354:e67efb2aab0e	1065	}
mbed_official	354:e67efb2aab0e	1066
mbed_official	354:e67efb2aab0e	1067	/**
mbed_official	354:e67efb2aab0e	1068	* @brief Stop ADC conversion of regular group (and injected group in
mbed_official	354:e67efb2aab0e	1069	* case of auto_injection mode), disable ADC DMA transfer, disable
mbed_official	354:e67efb2aab0e	1070	* ADC peripheral.
mbed_official	354:e67efb2aab0e	1071	* @note: ADC peripheral disable is forcing interruption of potential
mbed_official	354:e67efb2aab0e	1072	* conversion on injected group. If injected group is under use, it
mbed_official	354:e67efb2aab0e	1073	* should be preliminarily stopped using HAL_ADCEx_InjectedStop function.
mbed_official	354:e67efb2aab0e	1074	* @param hadc: ADC handle
mbed_official	354:e67efb2aab0e	1075	* @retval HAL status.
mbed_official	354:e67efb2aab0e	1076	*/
mbed_official	354:e67efb2aab0e	1077	HAL_StatusTypeDef HAL_ADC_Stop_DMA(ADC_HandleTypeDef* hadc)
mbed_official	354:e67efb2aab0e	1078	{
mbed_official	354:e67efb2aab0e	1079	HAL_StatusTypeDef tmpHALStatus = HAL_OK;
mbed_official	354:e67efb2aab0e	1080
mbed_official	354:e67efb2aab0e	1081	/* Check the parameters */
mbed_official	354:e67efb2aab0e	1082	assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official	354:e67efb2aab0e	1083
mbed_official	354:e67efb2aab0e	1084	/* Process locked */
mbed_official	354:e67efb2aab0e	1085	__HAL_LOCK(hadc);
mbed_official	354:e67efb2aab0e	1086
mbed_official	354:e67efb2aab0e	1087	/* Stop potential conversion on going, on regular and injected groups */
mbed_official	354:e67efb2aab0e	1088	/* Disable ADC peripheral */
mbed_official	354:e67efb2aab0e	1089	tmpHALStatus = ADC_ConversionStop_Disable(hadc);
mbed_official	354:e67efb2aab0e	1090
mbed_official	354:e67efb2aab0e	1091	/* Check if ADC is effectively disabled */
mbed_official	354:e67efb2aab0e	1092	if (tmpHALStatus != HAL_ERROR)
mbed_official	354:e67efb2aab0e	1093	{
mbed_official	354:e67efb2aab0e	1094	/* Disable ADC DMA mode */
mbed_official	354:e67efb2aab0e	1095	hadc->Instance->CR2 &= ~ADC_CR2_DMA;
mbed_official	354:e67efb2aab0e	1096
mbed_official	354:e67efb2aab0e	1097	/* Disable the DMA channel (in case of DMA in circular mode or stop while */
mbed_official	354:e67efb2aab0e	1098	/* DMA transfer is on going) */
mbed_official	354:e67efb2aab0e	1099	tmpHALStatus = HAL_DMA_Abort(hadc->DMA_Handle);
mbed_official	354:e67efb2aab0e	1100
mbed_official	354:e67efb2aab0e	1101	/* Check if DMA channel effectively disabled */
mbed_official	354:e67efb2aab0e	1102	if (tmpHALStatus != HAL_ERROR)
mbed_official	354:e67efb2aab0e	1103	{
mbed_official	354:e67efb2aab0e	1104	/* Change ADC state */
mbed_official	354:e67efb2aab0e	1105	hadc->State = HAL_ADC_STATE_READY;
mbed_official	354:e67efb2aab0e	1106	}
mbed_official	354:e67efb2aab0e	1107	else
mbed_official	354:e67efb2aab0e	1108	{
mbed_official	354:e67efb2aab0e	1109	/* Update ADC state machine to error */
mbed_official	354:e67efb2aab0e	1110	hadc->State = HAL_ADC_STATE_ERROR;
mbed_official	354:e67efb2aab0e	1111	}
mbed_official	354:e67efb2aab0e	1112	}
mbed_official	354:e67efb2aab0e	1113
mbed_official	354:e67efb2aab0e	1114	/* Process unlocked */
mbed_official	354:e67efb2aab0e	1115	__HAL_UNLOCK(hadc);
mbed_official	354:e67efb2aab0e	1116
mbed_official	354:e67efb2aab0e	1117	/* Return function status */
mbed_official	354:e67efb2aab0e	1118	return tmpHALStatus;
mbed_official	354:e67efb2aab0e	1119	}
mbed_official	354:e67efb2aab0e	1120
mbed_official	354:e67efb2aab0e	1121	/**
mbed_official	354:e67efb2aab0e	1122	* @brief Get ADC regular group conversion result.
mbed_official	354:e67efb2aab0e	1123	* @param hadc: ADC handle
mbed_official	354:e67efb2aab0e	1124	* @retval Converted value
mbed_official	354:e67efb2aab0e	1125	*/
mbed_official	354:e67efb2aab0e	1126	uint32_t HAL_ADC_GetValue(ADC_HandleTypeDef* hadc)
mbed_official	354:e67efb2aab0e	1127	{
mbed_official	354:e67efb2aab0e	1128	/* Check the parameters */
mbed_official	354:e67efb2aab0e	1129	assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official	354:e67efb2aab0e	1130
mbed_official	354:e67efb2aab0e	1131	/* Note: EOC flag is not cleared here by software because automatically */
mbed_official	354:e67efb2aab0e	1132	/* cleared by hardware when reading register DR. */
mbed_official	354:e67efb2aab0e	1133
mbed_official	354:e67efb2aab0e	1134	/* Return ADC converted value */
mbed_official	354:e67efb2aab0e	1135	return hadc->Instance->DR;
mbed_official	354:e67efb2aab0e	1136	}
mbed_official	354:e67efb2aab0e	1137
mbed_official	354:e67efb2aab0e	1138	/**
mbed_official	354:e67efb2aab0e	1139	* @brief DMA transfer complete callback.
mbed_official	354:e67efb2aab0e	1140	* @param hdma: pointer to DMA handle.
mbed_official	354:e67efb2aab0e	1141	* @retval None
mbed_official	354:e67efb2aab0e	1142	*/
mbed_official	354:e67efb2aab0e	1143	static void ADC_DMAConvCplt(DMA_HandleTypeDef *hdma)
mbed_official	354:e67efb2aab0e	1144	{
mbed_official	354:e67efb2aab0e	1145	/* Retrieve ADC handle corresponding to current DMA handle */
mbed_official	354:e67efb2aab0e	1146	ADC_HandleTypeDef* hadc = ( ADC_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official	354:e67efb2aab0e	1147
mbed_official	354:e67efb2aab0e	1148	/* Update state machine on conversion status if not in error state */
mbed_official	354:e67efb2aab0e	1149	if(hadc->State != HAL_ADC_STATE_ERROR)
mbed_official	354:e67efb2aab0e	1150	{
mbed_official	354:e67efb2aab0e	1151	/* Update ADC state machine */
mbed_official	354:e67efb2aab0e	1152	if(hadc->State != HAL_ADC_STATE_EOC_INJ_REG)
mbed_official	354:e67efb2aab0e	1153	{
mbed_official	354:e67efb2aab0e	1154	/* Check if a conversion is ready on injected group */
mbed_official	354:e67efb2aab0e	1155	if(hadc->State == HAL_ADC_STATE_EOC_INJ)
mbed_official	354:e67efb2aab0e	1156	{
mbed_official	354:e67efb2aab0e	1157	/* Change ADC state */
mbed_official	354:e67efb2aab0e	1158	hadc->State = HAL_ADC_STATE_EOC_INJ_REG;
mbed_official	354:e67efb2aab0e	1159	}
mbed_official	354:e67efb2aab0e	1160	else
mbed_official	354:e67efb2aab0e	1161	{
mbed_official	354:e67efb2aab0e	1162	/* Change ADC state */
mbed_official	354:e67efb2aab0e	1163	hadc->State = HAL_ADC_STATE_EOC_REG;
mbed_official	354:e67efb2aab0e	1164	}
mbed_official	354:e67efb2aab0e	1165	}
mbed_official	354:e67efb2aab0e	1166	}
mbed_official	354:e67efb2aab0e	1167
mbed_official	354:e67efb2aab0e	1168	/* Conversion complete callback */
mbed_official	354:e67efb2aab0e	1169	HAL_ADC_ConvCpltCallback(hadc);
mbed_official	354:e67efb2aab0e	1170	}
mbed_official	354:e67efb2aab0e	1171
mbed_official	354:e67efb2aab0e	1172	/**
mbed_official	354:e67efb2aab0e	1173	* @brief DMA half transfer complete callback.
mbed_official	354:e67efb2aab0e	1174	* @param hdma: pointer to DMA handle.
mbed_official	354:e67efb2aab0e	1175	* @retval None
mbed_official	354:e67efb2aab0e	1176	*/
mbed_official	354:e67efb2aab0e	1177	static void ADC_DMAHalfConvCplt(DMA_HandleTypeDef *hdma)
mbed_official	354:e67efb2aab0e	1178	{
mbed_official	354:e67efb2aab0e	1179	/* Retrieve ADC handle corresponding to current DMA handle */
mbed_official	354:e67efb2aab0e	1180	ADC_HandleTypeDef* hadc = ( ADC_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official	354:e67efb2aab0e	1181
mbed_official	354:e67efb2aab0e	1182	/* Half conversion callback */
mbed_official	354:e67efb2aab0e	1183	HAL_ADC_ConvHalfCpltCallback(hadc);
mbed_official	354:e67efb2aab0e	1184	}
mbed_official	354:e67efb2aab0e	1185
mbed_official	354:e67efb2aab0e	1186	/**
mbed_official	354:e67efb2aab0e	1187	* @brief DMA error callback
mbed_official	354:e67efb2aab0e	1188	* @param hdma: pointer to DMA handle.
mbed_official	354:e67efb2aab0e	1189	* @retval None
mbed_official	354:e67efb2aab0e	1190	*/
mbed_official	354:e67efb2aab0e	1191	static void ADC_DMAError(DMA_HandleTypeDef *hdma)
mbed_official	354:e67efb2aab0e	1192	{
mbed_official	354:e67efb2aab0e	1193	/* Retrieve ADC handle corresponding to current DMA handle */
mbed_official	354:e67efb2aab0e	1194	ADC_HandleTypeDef* hadc = ( ADC_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official	354:e67efb2aab0e	1195
mbed_official	354:e67efb2aab0e	1196	/* Change ADC state */
mbed_official	354:e67efb2aab0e	1197	hadc->State = HAL_ADC_STATE_ERROR;
mbed_official	354:e67efb2aab0e	1198
mbed_official	354:e67efb2aab0e	1199	/* Set ADC error code to DMA error */
mbed_official	354:e67efb2aab0e	1200	hadc->ErrorCode \|= HAL_ADC_ERROR_DMA;
mbed_official	354:e67efb2aab0e	1201
mbed_official	354:e67efb2aab0e	1202	/* Error callback */
mbed_official	354:e67efb2aab0e	1203	HAL_ADC_ErrorCallback(hadc);
mbed_official	354:e67efb2aab0e	1204	}
mbed_official	354:e67efb2aab0e	1205
mbed_official	354:e67efb2aab0e	1206	/**
mbed_official	354:e67efb2aab0e	1207	* @brief Handles ADC interrupt request
mbed_official	354:e67efb2aab0e	1208	* @param hadc: ADC handle
mbed_official	354:e67efb2aab0e	1209	* @retval None
mbed_official	354:e67efb2aab0e	1210	*/
mbed_official	354:e67efb2aab0e	1211	void HAL_ADC_IRQHandler(ADC_HandleTypeDef* hadc)
mbed_official	354:e67efb2aab0e	1212	{
mbed_official	354:e67efb2aab0e	1213	/* Check the parameters */
mbed_official	354:e67efb2aab0e	1214	assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official	354:e67efb2aab0e	1215	assert_param(IS_FUNCTIONAL_STATE(hadc->Init.ContinuousConvMode));
mbed_official	354:e67efb2aab0e	1216	assert_param(IS_ADC_REGULAR_NB_CONV(hadc->Init.NbrOfConversion));
mbed_official	354:e67efb2aab0e	1217
mbed_official	354:e67efb2aab0e	1218
mbed_official	354:e67efb2aab0e	1219	/* ========== Check End of Conversion flag for regular group ========== */
mbed_official	354:e67efb2aab0e	1220	if(__HAL_ADC_GET_IT_SOURCE(hadc, ADC_IT_EOC))
mbed_official	354:e67efb2aab0e	1221	{
mbed_official	354:e67efb2aab0e	1222	if(__HAL_ADC_GET_FLAG(hadc, ADC_FLAG_EOC) )
mbed_official	354:e67efb2aab0e	1223	{
mbed_official	354:e67efb2aab0e	1224	/* Update state machine on conversion status if not in error state */
mbed_official	354:e67efb2aab0e	1225	if(hadc->State != HAL_ADC_STATE_ERROR)
mbed_official	354:e67efb2aab0e	1226	{
mbed_official	354:e67efb2aab0e	1227	/* Update ADC state machine */
mbed_official	354:e67efb2aab0e	1228	if(hadc->State != HAL_ADC_STATE_EOC_INJ_REG)
mbed_official	354:e67efb2aab0e	1229	{
mbed_official	354:e67efb2aab0e	1230	/* Check if a conversion is ready on injected group */
mbed_official	354:e67efb2aab0e	1231	if(hadc->State == HAL_ADC_STATE_EOC_INJ)
mbed_official	354:e67efb2aab0e	1232	{
mbed_official	354:e67efb2aab0e	1233	/* Change ADC state */
mbed_official	354:e67efb2aab0e	1234	hadc->State = HAL_ADC_STATE_EOC_INJ_REG;
mbed_official	354:e67efb2aab0e	1235	}
mbed_official	354:e67efb2aab0e	1236	else
mbed_official	354:e67efb2aab0e	1237	{
mbed_official	354:e67efb2aab0e	1238	/* Change ADC state */
mbed_official	354:e67efb2aab0e	1239	hadc->State = HAL_ADC_STATE_EOC_REG;
mbed_official	354:e67efb2aab0e	1240	}
mbed_official	354:e67efb2aab0e	1241	}
mbed_official	354:e67efb2aab0e	1242	}
mbed_official	354:e67efb2aab0e	1243
mbed_official	354:e67efb2aab0e	1244	/* Disable interruption if no further conversion upcoming regular */
mbed_official	354:e67efb2aab0e	1245	/* external trigger or by continuous mode */
mbed_official	354:e67efb2aab0e	1246	if(__HAL_ADC_IS_SOFTWARE_START_REGULAR(hadc) &&
mbed_official	354:e67efb2aab0e	1247	(hadc->Init.ContinuousConvMode == DISABLE) )
mbed_official	354:e67efb2aab0e	1248	{
mbed_official	354:e67efb2aab0e	1249	/* Disable ADC end of single conversion interrupt */
mbed_official	354:e67efb2aab0e	1250	/* Note: Overrun interrupt was enabled with EOC interrupt in */
mbed_official	354:e67efb2aab0e	1251	/* HAL_ADC_Start_IT(), but is not disabled here because can be used by */
mbed_official	354:e67efb2aab0e	1252	/* overrun IRQ process below. */
mbed_official	354:e67efb2aab0e	1253	__HAL_ADC_DISABLE_IT(hadc, ADC_IT_EOC);
mbed_official	354:e67efb2aab0e	1254	}
mbed_official	354:e67efb2aab0e	1255
mbed_official	354:e67efb2aab0e	1256	/* Conversion complete callback */
mbed_official	354:e67efb2aab0e	1257	HAL_ADC_ConvCpltCallback(hadc);
mbed_official	354:e67efb2aab0e	1258
mbed_official	354:e67efb2aab0e	1259	/* Clear regular group conversion flag */
mbed_official	354:e67efb2aab0e	1260	__HAL_ADC_CLEAR_FLAG(hadc, ADC_FLAG_STRT \| ADC_FLAG_EOC);
mbed_official	354:e67efb2aab0e	1261	}
mbed_official	354:e67efb2aab0e	1262	}
mbed_official	354:e67efb2aab0e	1263
mbed_official	354:e67efb2aab0e	1264	/* ========== Check End of Conversion flag for injected group ========== */
mbed_official	354:e67efb2aab0e	1265	if(__HAL_ADC_GET_IT_SOURCE(hadc, ADC_IT_JEOC))
mbed_official	354:e67efb2aab0e	1266	{
mbed_official	354:e67efb2aab0e	1267	if(__HAL_ADC_GET_FLAG(hadc, ADC_FLAG_JEOC))
mbed_official	354:e67efb2aab0e	1268	{
mbed_official	354:e67efb2aab0e	1269	/* Update state machine on conversion status if not in error state */
mbed_official	354:e67efb2aab0e	1270	if(hadc->State != HAL_ADC_STATE_ERROR)
mbed_official	354:e67efb2aab0e	1271	{
mbed_official	354:e67efb2aab0e	1272	/* Update ADC state machine */
mbed_official	354:e67efb2aab0e	1273	if(hadc->State != HAL_ADC_STATE_EOC_INJ_REG)
mbed_official	354:e67efb2aab0e	1274	{
mbed_official	354:e67efb2aab0e	1275
mbed_official	354:e67efb2aab0e	1276	if(hadc->State == HAL_ADC_STATE_EOC_REG)
mbed_official	354:e67efb2aab0e	1277	{
mbed_official	354:e67efb2aab0e	1278	/* Change ADC state */
mbed_official	354:e67efb2aab0e	1279	hadc->State = HAL_ADC_STATE_EOC_INJ_REG;
mbed_official	354:e67efb2aab0e	1280	}
mbed_official	354:e67efb2aab0e	1281	else
mbed_official	354:e67efb2aab0e	1282	{
mbed_official	354:e67efb2aab0e	1283	/* Change ADC state */
mbed_official	354:e67efb2aab0e	1284	hadc->State = HAL_ADC_STATE_EOC_INJ;
mbed_official	354:e67efb2aab0e	1285	}
mbed_official	354:e67efb2aab0e	1286	}
mbed_official	354:e67efb2aab0e	1287	}
mbed_official	354:e67efb2aab0e	1288
mbed_official	354:e67efb2aab0e	1289	/* Disable interruption if no further conversion upcoming injected */
mbed_official	354:e67efb2aab0e	1290	/* external trigger or by automatic injected conversion with regular */
mbed_official	354:e67efb2aab0e	1291	/* group having no further conversion upcoming (same conditions as */
mbed_official	354:e67efb2aab0e	1292	/* regular group interruption disabling above). */
mbed_official	354:e67efb2aab0e	1293	if(__HAL_ADC_IS_SOFTWARE_START_INJECTED(hadc) \|\|
mbed_official	354:e67efb2aab0e	1294	(HAL_IS_BIT_CLR(hadc->Instance->CR1, ADC_CR1_JAUTO) &&
mbed_official	354:e67efb2aab0e	1295	(__HAL_ADC_IS_SOFTWARE_START_REGULAR(hadc) &&
mbed_official	354:e67efb2aab0e	1296	(hadc->Init.ContinuousConvMode == DISABLE) ) ) )
mbed_official	354:e67efb2aab0e	1297	{
mbed_official	354:e67efb2aab0e	1298	/* Disable ADC end of single conversion interrupt */
mbed_official	354:e67efb2aab0e	1299	__HAL_ADC_DISABLE_IT(hadc, ADC_IT_JEOC);
mbed_official	354:e67efb2aab0e	1300	}
mbed_official	354:e67efb2aab0e	1301
mbed_official	354:e67efb2aab0e	1302	/* Conversion complete callback */
mbed_official	354:e67efb2aab0e	1303	HAL_ADCEx_InjectedConvCpltCallback(hadc);
mbed_official	354:e67efb2aab0e	1304
mbed_official	354:e67efb2aab0e	1305	/* Clear injected group conversion flag */
mbed_official	354:e67efb2aab0e	1306	__HAL_ADC_CLEAR_FLAG(hadc, (ADC_FLAG_JSTRT \| ADC_FLAG_JEOC));
mbed_official	354:e67efb2aab0e	1307	}
mbed_official	354:e67efb2aab0e	1308	}
mbed_official	354:e67efb2aab0e	1309
mbed_official	354:e67efb2aab0e	1310	/* ========== Check Analog watchdog flags ========== */
mbed_official	354:e67efb2aab0e	1311	if(__HAL_ADC_GET_IT_SOURCE(hadc, ADC_IT_AWD))
mbed_official	354:e67efb2aab0e	1312	{
mbed_official	354:e67efb2aab0e	1313	if(__HAL_ADC_GET_FLAG(hadc, ADC_FLAG_AWD))
mbed_official	354:e67efb2aab0e	1314	{
mbed_official	354:e67efb2aab0e	1315	/* Change ADC state */
mbed_official	354:e67efb2aab0e	1316	hadc->State = HAL_ADC_STATE_AWD;
mbed_official	354:e67efb2aab0e	1317
mbed_official	354:e67efb2aab0e	1318	/* Clear the ADCx's Analog watchdog flag */
mbed_official	354:e67efb2aab0e	1319	__HAL_ADC_CLEAR_FLAG(hadc,ADC_FLAG_AWD);
mbed_official	354:e67efb2aab0e	1320
mbed_official	354:e67efb2aab0e	1321	/* Level out of window callback */
mbed_official	354:e67efb2aab0e	1322	HAL_ADC_LevelOutOfWindowCallback(hadc);
mbed_official	354:e67efb2aab0e	1323	}
mbed_official	354:e67efb2aab0e	1324	}
mbed_official	354:e67efb2aab0e	1325
mbed_official	354:e67efb2aab0e	1326	/* ========== Check Overrun flag ========== */
mbed_official	354:e67efb2aab0e	1327	if(__HAL_ADC_GET_IT_SOURCE(hadc, ADC_IT_OVR))
mbed_official	354:e67efb2aab0e	1328	{
mbed_official	354:e67efb2aab0e	1329	if(__HAL_ADC_GET_FLAG(hadc, ADC_FLAG_OVR))
mbed_official	354:e67efb2aab0e	1330	{
mbed_official	354:e67efb2aab0e	1331	/* Change ADC state to error state */
mbed_official	354:e67efb2aab0e	1332	hadc->State = HAL_ADC_STATE_ERROR;
mbed_official	354:e67efb2aab0e	1333
mbed_official	354:e67efb2aab0e	1334	/* Set ADC error code to overrun */
mbed_official	354:e67efb2aab0e	1335	hadc->ErrorCode \|= HAL_ADC_ERROR_OVR;
mbed_official	354:e67efb2aab0e	1336
mbed_official	354:e67efb2aab0e	1337	/* Error callback */
mbed_official	354:e67efb2aab0e	1338	HAL_ADC_ErrorCallback(hadc);
mbed_official	354:e67efb2aab0e	1339
mbed_official	354:e67efb2aab0e	1340	/* Clear the Overrun flag */
mbed_official	354:e67efb2aab0e	1341	__HAL_ADC_CLEAR_FLAG(hadc, ADC_FLAG_OVR);
mbed_official	354:e67efb2aab0e	1342	}
mbed_official	354:e67efb2aab0e	1343	}
mbed_official	354:e67efb2aab0e	1344
mbed_official	354:e67efb2aab0e	1345	}
mbed_official	354:e67efb2aab0e	1346
mbed_official	354:e67efb2aab0e	1347	/**
mbed_official	354:e67efb2aab0e	1348	* @brief Conversion complete callback in non blocking mode
mbed_official	354:e67efb2aab0e	1349	* @param hadc: ADC handle
mbed_official	354:e67efb2aab0e	1350	* @retval None
mbed_official	354:e67efb2aab0e	1351	*/
mbed_official	354:e67efb2aab0e	1352	__weak void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc)
mbed_official	354:e67efb2aab0e	1353	{
mbed_official	354:e67efb2aab0e	1354	/* NOTE : This function should not be modified. When the callback is needed,
mbed_official	354:e67efb2aab0e	1355	function HAL_ADC_ConvCpltCallback must be implemented in the user file.
mbed_official	354:e67efb2aab0e	1356	*/
mbed_official	354:e67efb2aab0e	1357	}
mbed_official	354:e67efb2aab0e	1358
mbed_official	354:e67efb2aab0e	1359	/**
mbed_official	354:e67efb2aab0e	1360	* @brief Conversion DMA half-transfer callback in non blocking mode
mbed_official	354:e67efb2aab0e	1361	* @param hadc: ADC handle
mbed_official	354:e67efb2aab0e	1362	* @retval None
mbed_official	354:e67efb2aab0e	1363	*/
mbed_official	354:e67efb2aab0e	1364	__weak void HAL_ADC_ConvHalfCpltCallback(ADC_HandleTypeDef* hadc)
mbed_official	354:e67efb2aab0e	1365	{
mbed_official	354:e67efb2aab0e	1366	/* NOTE : This function should not be modified. When the callback is needed,
mbed_official	354:e67efb2aab0e	1367	function HAL_ADC_ConvHalfCpltCallback must be implemented in the user file.
mbed_official	354:e67efb2aab0e	1368	*/
mbed_official	354:e67efb2aab0e	1369	}
mbed_official	354:e67efb2aab0e	1370
mbed_official	354:e67efb2aab0e	1371	/**
mbed_official	354:e67efb2aab0e	1372	* @brief Analog watchdog callback in non blocking mode.
mbed_official	354:e67efb2aab0e	1373	* @param hadc: ADC handle
mbed_official	354:e67efb2aab0e	1374	* @retval None
mbed_official	354:e67efb2aab0e	1375	*/
mbed_official	354:e67efb2aab0e	1376	__weak void HAL_ADC_LevelOutOfWindowCallback(ADC_HandleTypeDef* hadc)
mbed_official	354:e67efb2aab0e	1377	{
mbed_official	354:e67efb2aab0e	1378	/* NOTE : This function should not be modified. When the callback is needed,
mbed_official	354:e67efb2aab0e	1379	function HAL_ADC_LevelOutOfWindowCallback must be implemented in the user file.
mbed_official	354:e67efb2aab0e	1380	*/
mbed_official	354:e67efb2aab0e	1381	}
mbed_official	354:e67efb2aab0e	1382
mbed_official	354:e67efb2aab0e	1383	/**
mbed_official	354:e67efb2aab0e	1384	* @brief ADC error callback in non blocking mode
mbed_official	354:e67efb2aab0e	1385	* (ADC conversion with interruption or transfer by DMA)
mbed_official	354:e67efb2aab0e	1386	* @param hadc: ADC handle
mbed_official	354:e67efb2aab0e	1387	* @retval None
mbed_official	354:e67efb2aab0e	1388	*/
mbed_official	354:e67efb2aab0e	1389	__weak void HAL_ADC_ErrorCallback(ADC_HandleTypeDef *hadc)
mbed_official	354:e67efb2aab0e	1390	{
mbed_official	354:e67efb2aab0e	1391	/* NOTE : This function should not be modified. When the callback is needed,
mbed_official	354:e67efb2aab0e	1392	function HAL_ADC_ErrorCallback must be implemented in the user file.
mbed_official	354:e67efb2aab0e	1393	*/
mbed_official	354:e67efb2aab0e	1394	}
mbed_official	354:e67efb2aab0e	1395
mbed_official	354:e67efb2aab0e	1396
mbed_official	354:e67efb2aab0e	1397	/**
mbed_official	354:e67efb2aab0e	1398	* @}
mbed_official	354:e67efb2aab0e	1399	*/
mbed_official	354:e67efb2aab0e	1400
mbed_official	354:e67efb2aab0e	1401	/** @defgroup ADC_Exported_Functions_Group3 Peripheral Control functions
mbed_official	354:e67efb2aab0e	1402	* @brief Peripheral Control functions
mbed_official	354:e67efb2aab0e	1403	*
mbed_official	354:e67efb2aab0e	1404	@verbatim
mbed_official	354:e67efb2aab0e	1405	===============================================================================
mbed_official	354:e67efb2aab0e	1406	##### Peripheral Control functions #####
mbed_official	354:e67efb2aab0e	1407	===============================================================================
mbed_official	354:e67efb2aab0e	1408	[..] This section provides functions allowing to:
mbed_official	354:e67efb2aab0e	1409	(+) Configure channels on regular group
mbed_official	354:e67efb2aab0e	1410	(+) Configure the analog watchdog
mbed_official	354:e67efb2aab0e	1411
mbed_official	354:e67efb2aab0e	1412	@endverbatim
mbed_official	354:e67efb2aab0e	1413	* @{
mbed_official	354:e67efb2aab0e	1414	*/
mbed_official	354:e67efb2aab0e	1415
mbed_official	354:e67efb2aab0e	1416	/**
mbed_official	354:e67efb2aab0e	1417	* @brief Configures the the selected channel to be linked to the regular
mbed_official	354:e67efb2aab0e	1418	* group.
mbed_official	354:e67efb2aab0e	1419	* @note In case of usage of internal measurement channels:
mbed_official	354:e67efb2aab0e	1420	* Vbat/VrefInt/TempSensor.
mbed_official	354:e67efb2aab0e	1421	* These internal paths can be be disabled using function
mbed_official	354:e67efb2aab0e	1422	* HAL_ADC_DeInit().
mbed_official	354:e67efb2aab0e	1423	* @note Possibility to update parameters on the fly:
mbed_official	354:e67efb2aab0e	1424	* This function initializes channel into regular group, following
mbed_official	354:e67efb2aab0e	1425	* calls to this function can be used to reconfigure some parameters
mbed_official	354:e67efb2aab0e	1426	* of structure "ADC_ChannelConfTypeDef" on the fly, without reseting
mbed_official	354:e67efb2aab0e	1427	* the ADC.
mbed_official	354:e67efb2aab0e	1428	* The setting of these parameters is conditioned to ADC state.
mbed_official	354:e67efb2aab0e	1429	* For parameters constraints, see comments of structure
mbed_official	354:e67efb2aab0e	1430	* "ADC_ChannelConfTypeDef".
mbed_official	354:e67efb2aab0e	1431	* @param hadc: ADC handle
mbed_official	354:e67efb2aab0e	1432	* @param sConfig: Structure of ADC channel for regular group.
mbed_official	354:e67efb2aab0e	1433	* @retval HAL status
mbed_official	354:e67efb2aab0e	1434	*/
mbed_official	354:e67efb2aab0e	1435	HAL_StatusTypeDef HAL_ADC_ConfigChannel(ADC_HandleTypeDef* hadc, ADC_ChannelConfTypeDef* sConfig)
mbed_official	354:e67efb2aab0e	1436	{
mbed_official	354:e67efb2aab0e	1437	HAL_StatusTypeDef tmpHALStatus = HAL_OK;
mbed_official	354:e67efb2aab0e	1438
mbed_official	354:e67efb2aab0e	1439	/* Check the parameters */
mbed_official	354:e67efb2aab0e	1440	assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official	354:e67efb2aab0e	1441	assert_param(IS_ADC_CHANNEL(sConfig->Channel));
mbed_official	354:e67efb2aab0e	1442	assert_param(IS_ADC_REGULAR_RANK(sConfig->Rank));
mbed_official	354:e67efb2aab0e	1443	assert_param(IS_ADC_SAMPLE_TIME(sConfig->SamplingTime));
mbed_official	354:e67efb2aab0e	1444
mbed_official	354:e67efb2aab0e	1445	/* Process locked */
mbed_official	354:e67efb2aab0e	1446	__HAL_LOCK(hadc);
mbed_official	354:e67efb2aab0e	1447
mbed_official	354:e67efb2aab0e	1448
mbed_official	354:e67efb2aab0e	1449	/* Regular sequence configuration */
mbed_official	354:e67efb2aab0e	1450	/* For Rank 1 to 6 */
mbed_official	354:e67efb2aab0e	1451	if (sConfig->Rank < 7)
mbed_official	354:e67efb2aab0e	1452	{
mbed_official	354:e67efb2aab0e	1453	MODIFY_REG(hadc->Instance->SQR5,
mbed_official	354:e67efb2aab0e	1454	__ADC_SQR5_RK(ADC_SQR5_SQ1, sConfig->Rank),
mbed_official	354:e67efb2aab0e	1455	__ADC_SQR5_RK(sConfig->Channel, sConfig->Rank) );
mbed_official	354:e67efb2aab0e	1456	}
mbed_official	354:e67efb2aab0e	1457	/* For Rank 7 to 12 */
mbed_official	354:e67efb2aab0e	1458	else if (sConfig->Rank < 13)
mbed_official	354:e67efb2aab0e	1459	{
mbed_official	354:e67efb2aab0e	1460	MODIFY_REG(hadc->Instance->SQR4,
mbed_official	354:e67efb2aab0e	1461	__ADC_SQR4_RK(ADC_SQR4_SQ7, sConfig->Rank),
mbed_official	354:e67efb2aab0e	1462	__ADC_SQR4_RK(sConfig->Channel, sConfig->Rank) );
mbed_official	354:e67efb2aab0e	1463	}
mbed_official	354:e67efb2aab0e	1464	/* For Rank 13 to 18 */
mbed_official	354:e67efb2aab0e	1465	else if (sConfig->Rank < 19)
mbed_official	354:e67efb2aab0e	1466	{
mbed_official	354:e67efb2aab0e	1467	MODIFY_REG(hadc->Instance->SQR3,
mbed_official	354:e67efb2aab0e	1468	__ADC_SQR3_RK(ADC_SQR3_SQ13, sConfig->Rank),
mbed_official	354:e67efb2aab0e	1469	__ADC_SQR3_RK(sConfig->Channel, sConfig->Rank) );
mbed_official	354:e67efb2aab0e	1470	}
mbed_official	354:e67efb2aab0e	1471	/* For Rank 19 to 24 */
mbed_official	354:e67efb2aab0e	1472	else if (sConfig->Rank < 25)
mbed_official	354:e67efb2aab0e	1473	{
mbed_official	354:e67efb2aab0e	1474	MODIFY_REG(hadc->Instance->SQR2,
mbed_official	354:e67efb2aab0e	1475	__ADC_SQR2_RK(ADC_SQR2_SQ19, sConfig->Rank),
mbed_official	354:e67efb2aab0e	1476	__ADC_SQR2_RK(sConfig->Channel, sConfig->Rank) );
mbed_official	354:e67efb2aab0e	1477	}
mbed_official	354:e67efb2aab0e	1478	/* For Rank 25 to 28 */
mbed_official	354:e67efb2aab0e	1479	else
mbed_official	354:e67efb2aab0e	1480	{
mbed_official	354:e67efb2aab0e	1481	MODIFY_REG(hadc->Instance->SQR1,
mbed_official	354:e67efb2aab0e	1482	__ADC_SQR1_RK(ADC_SQR1_SQ25, sConfig->Rank),
mbed_official	354:e67efb2aab0e	1483	__ADC_SQR1_RK(sConfig->Channel, sConfig->Rank) );
mbed_official	354:e67efb2aab0e	1484	}
mbed_official	354:e67efb2aab0e	1485
mbed_official	354:e67efb2aab0e	1486
mbed_official	354:e67efb2aab0e	1487	/* Channel sampling time configuration */
mbed_official	354:e67efb2aab0e	1488	/* For channels 0 to 9 */
mbed_official	354:e67efb2aab0e	1489	if (sConfig->Channel < ADC_CHANNEL_10)
mbed_official	354:e67efb2aab0e	1490	{
mbed_official	354:e67efb2aab0e	1491	MODIFY_REG(hadc->Instance->SMPR3,
mbed_official	354:e67efb2aab0e	1492	__ADC_SMPR3(ADC_SMPR3_SMP0, sConfig->Channel),
mbed_official	354:e67efb2aab0e	1493	__ADC_SMPR3(sConfig->SamplingTime, sConfig->Channel) );
mbed_official	354:e67efb2aab0e	1494	}
mbed_official	354:e67efb2aab0e	1495	/* For channels 10 to 19 */
mbed_official	354:e67efb2aab0e	1496	else if (sConfig->Channel < ADC_CHANNEL_20)
mbed_official	354:e67efb2aab0e	1497	{
mbed_official	354:e67efb2aab0e	1498	MODIFY_REG(hadc->Instance->SMPR2,
mbed_official	354:e67efb2aab0e	1499	__ADC_SMPR2(ADC_SMPR2_SMP10, sConfig->Channel),
mbed_official	354:e67efb2aab0e	1500	__ADC_SMPR2(sConfig->SamplingTime, sConfig->Channel) );
mbed_official	354:e67efb2aab0e	1501	}
mbed_official	354:e67efb2aab0e	1502	/* For channels 20 to 26 for devices Cat.1, Cat.2, Cat.3 */
mbed_official	354:e67efb2aab0e	1503	/* For channels 20 to 29 for devices Cat4, Cat.5 */
mbed_official	354:e67efb2aab0e	1504	else if (sConfig->Channel <= ADC_SMPR1_CHANNEL_MAX)
mbed_official	354:e67efb2aab0e	1505	{
mbed_official	354:e67efb2aab0e	1506	MODIFY_REG(hadc->Instance->SMPR1,
mbed_official	354:e67efb2aab0e	1507	__ADC_SMPR1(ADC_SMPR1_SMP20, sConfig->Channel),
mbed_official	354:e67efb2aab0e	1508	__ADC_SMPR1(sConfig->SamplingTime, sConfig->Channel) );
mbed_official	354:e67efb2aab0e	1509	}
mbed_official	354:e67efb2aab0e	1510	/* For channels 30 to 31 for devices Cat4, Cat.5 */
mbed_official	354:e67efb2aab0e	1511	else
mbed_official	354:e67efb2aab0e	1512	{
mbed_official	354:e67efb2aab0e	1513	__ADC_SMPR0_CHANNEL_SET(hadc, sConfig->SamplingTime, sConfig->Channel);
mbed_official	354:e67efb2aab0e	1514	}
mbed_official	354:e67efb2aab0e	1515
mbed_official	354:e67efb2aab0e	1516	/* If ADC1 Channel_16 or Channel_17 is selected, enable Temperature sensor */
mbed_official	354:e67efb2aab0e	1517	/* and VREFINT measurement path. */
mbed_official	354:e67efb2aab0e	1518	if ((sConfig->Channel == ADC_CHANNEL_TEMPSENSOR) \|\|
mbed_official	354:e67efb2aab0e	1519	(sConfig->Channel == ADC_CHANNEL_VREFINT) )
mbed_official	354:e67efb2aab0e	1520	{
mbed_official	354:e67efb2aab0e	1521	SET_BIT(ADC->CCR, ADC_CCR_TSVREFE);
mbed_official	354:e67efb2aab0e	1522	}
mbed_official	354:e67efb2aab0e	1523
mbed_official	354:e67efb2aab0e	1524	/* Process unlocked */
mbed_official	354:e67efb2aab0e	1525	__HAL_UNLOCK(hadc);
mbed_official	354:e67efb2aab0e	1526
mbed_official	354:e67efb2aab0e	1527	/* Return function status */
mbed_official	354:e67efb2aab0e	1528	return tmpHALStatus;
mbed_official	354:e67efb2aab0e	1529	}
mbed_official	354:e67efb2aab0e	1530
mbed_official	354:e67efb2aab0e	1531	/**
mbed_official	354:e67efb2aab0e	1532	* @brief Configures the analog watchdog.
mbed_official	354:e67efb2aab0e	1533	* @param hadc: ADC handle
mbed_official	354:e67efb2aab0e	1534	* @param AnalogWDGConfig: Structure of ADC analog watchdog configuration
mbed_official	354:e67efb2aab0e	1535	* @retval HAL status
mbed_official	354:e67efb2aab0e	1536	*/
mbed_official	354:e67efb2aab0e	1537	HAL_StatusTypeDef HAL_ADC_AnalogWDGConfig(ADC_HandleTypeDef* hadc, ADC_AnalogWDGConfTypeDef* AnalogWDGConfig)
mbed_official	354:e67efb2aab0e	1538	{
mbed_official	354:e67efb2aab0e	1539	/* Check the parameters */
mbed_official	354:e67efb2aab0e	1540	assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
mbed_official	354:e67efb2aab0e	1541	assert_param(IS_ADC_ANALOG_WATCHDOG_MODE(AnalogWDGConfig->WatchdogMode));
mbed_official	354:e67efb2aab0e	1542	assert_param(IS_FUNCTIONAL_STATE(AnalogWDGConfig->ITMode));
mbed_official	354:e67efb2aab0e	1543	assert_param(IS_ADC_RANGE(AnalogWDGConfig->HighThreshold));
mbed_official	354:e67efb2aab0e	1544	assert_param(IS_ADC_RANGE(AnalogWDGConfig->LowThreshold));
mbed_official	354:e67efb2aab0e	1545
mbed_official	354:e67efb2aab0e	1546	if((AnalogWDGConfig->WatchdogMode == ADC_ANALOGWATCHDOG_SINGLE_REG) \|\|
mbed_official	354:e67efb2aab0e	1547	(AnalogWDGConfig->WatchdogMode == ADC_ANALOGWATCHDOG_SINGLE_INJEC) \|\|
mbed_official	354:e67efb2aab0e	1548	(AnalogWDGConfig->WatchdogMode == ADC_ANALOGWATCHDOG_SINGLE_REGINJEC) )
mbed_official	354:e67efb2aab0e	1549	{
mbed_official	354:e67efb2aab0e	1550	assert_param(IS_ADC_CHANNEL(AnalogWDGConfig->Channel));
mbed_official	354:e67efb2aab0e	1551	}
mbed_official	354:e67efb2aab0e	1552
mbed_official	354:e67efb2aab0e	1553	/* Process locked */
mbed_official	354:e67efb2aab0e	1554	__HAL_LOCK(hadc);
mbed_official	354:e67efb2aab0e	1555
mbed_official	354:e67efb2aab0e	1556	/* Analog watchdog configuration */
mbed_official	354:e67efb2aab0e	1557
mbed_official	354:e67efb2aab0e	1558	/* Configure ADC Analog watchdog interrupt */
mbed_official	354:e67efb2aab0e	1559	if(AnalogWDGConfig->ITMode == ENABLE)
mbed_official	354:e67efb2aab0e	1560	{
mbed_official	354:e67efb2aab0e	1561	/* Enable the ADC Analog watchdog interrupt */
mbed_official	354:e67efb2aab0e	1562	__HAL_ADC_ENABLE_IT(hadc, ADC_IT_AWD);
mbed_official	354:e67efb2aab0e	1563	}
mbed_official	354:e67efb2aab0e	1564	else
mbed_official	354:e67efb2aab0e	1565	{
mbed_official	354:e67efb2aab0e	1566	/* Disable the ADC Analog watchdog interrupt */
mbed_official	354:e67efb2aab0e	1567	__HAL_ADC_DISABLE_IT(hadc, ADC_IT_AWD);
mbed_official	354:e67efb2aab0e	1568	}
mbed_official	354:e67efb2aab0e	1569
mbed_official	354:e67efb2aab0e	1570	/* Configuration of analog watchdog: */
mbed_official	354:e67efb2aab0e	1571	/* - Set the analog watchdog enable mode: regular and/or injected groups, */
mbed_official	354:e67efb2aab0e	1572	/* one or all channels. */
mbed_official	354:e67efb2aab0e	1573	/* - Set the Analog watchdog channel (is not used if watchdog */
mbed_official	354:e67efb2aab0e	1574	/* mode "all channels": ADC_CFGR_AWD1SGL=0). */
mbed_official	354:e67efb2aab0e	1575	hadc->Instance->CR1 &= ~( ADC_CR1_AWDSGL \|
mbed_official	354:e67efb2aab0e	1576	ADC_CR1_JAWDEN \|
mbed_official	354:e67efb2aab0e	1577	ADC_CR1_AWDEN \|
mbed_official	354:e67efb2aab0e	1578	ADC_CR1_AWDCH );
mbed_official	354:e67efb2aab0e	1579
mbed_official	354:e67efb2aab0e	1580	hadc->Instance->CR1 \|= ( AnalogWDGConfig->WatchdogMode \|
mbed_official	354:e67efb2aab0e	1581	AnalogWDGConfig->Channel );
mbed_official	354:e67efb2aab0e	1582
mbed_official	354:e67efb2aab0e	1583	/* Set the high threshold */
mbed_official	354:e67efb2aab0e	1584	hadc->Instance->HTR = AnalogWDGConfig->HighThreshold;
mbed_official	354:e67efb2aab0e	1585
mbed_official	354:e67efb2aab0e	1586	/* Set the low threshold */
mbed_official	354:e67efb2aab0e	1587	hadc->Instance->LTR = AnalogWDGConfig->LowThreshold;
mbed_official	354:e67efb2aab0e	1588
mbed_official	354:e67efb2aab0e	1589	/* Process unlocked */
mbed_official	354:e67efb2aab0e	1590	__HAL_UNLOCK(hadc);
mbed_official	354:e67efb2aab0e	1591
mbed_official	354:e67efb2aab0e	1592	/* Return function status */
mbed_official	354:e67efb2aab0e	1593	return HAL_OK;
mbed_official	354:e67efb2aab0e	1594	}
mbed_official	354:e67efb2aab0e	1595
mbed_official	354:e67efb2aab0e	1596
mbed_official	354:e67efb2aab0e	1597	/**
mbed_official	354:e67efb2aab0e	1598	* @}
mbed_official	354:e67efb2aab0e	1599	*/
mbed_official	354:e67efb2aab0e	1600
mbed_official	354:e67efb2aab0e	1601
mbed_official	354:e67efb2aab0e	1602	/** @defgroup ADC_Exported_Functions_Group4 Peripheral State functions
mbed_official	354:e67efb2aab0e	1603	* @brief Peripheral State functions
mbed_official	354:e67efb2aab0e	1604	*
mbed_official	354:e67efb2aab0e	1605	@verbatim
mbed_official	354:e67efb2aab0e	1606	===============================================================================
mbed_official	354:e67efb2aab0e	1607	##### Peripheral State and Errors functions #####
mbed_official	354:e67efb2aab0e	1608	===============================================================================
mbed_official	354:e67efb2aab0e	1609	[..]
mbed_official	354:e67efb2aab0e	1610	This subsection provides functions to get in run-time the status of the
mbed_official	354:e67efb2aab0e	1611	peripheral.
mbed_official	354:e67efb2aab0e	1612	(+) Check the ADC state
mbed_official	354:e67efb2aab0e	1613	(+) Check the ADC error code
mbed_official	354:e67efb2aab0e	1614
mbed_official	354:e67efb2aab0e	1615	@endverbatim
mbed_official	354:e67efb2aab0e	1616	* @{
mbed_official	354:e67efb2aab0e	1617	*/
mbed_official	354:e67efb2aab0e	1618
mbed_official	354:e67efb2aab0e	1619	/**
mbed_official	354:e67efb2aab0e	1620	* @brief return the ADC state
mbed_official	354:e67efb2aab0e	1621	* @param hadc: ADC handle
mbed_official	354:e67efb2aab0e	1622	* @retval HAL state
mbed_official	354:e67efb2aab0e	1623	*/
mbed_official	354:e67efb2aab0e	1624	HAL_ADC_StateTypeDef HAL_ADC_GetState(ADC_HandleTypeDef* hadc)
mbed_official	354:e67efb2aab0e	1625	{
mbed_official	354:e67efb2aab0e	1626	/* Return ADC state */
mbed_official	354:e67efb2aab0e	1627	return hadc->State;
mbed_official	354:e67efb2aab0e	1628	}
mbed_official	354:e67efb2aab0e	1629
mbed_official	354:e67efb2aab0e	1630	/**
mbed_official	354:e67efb2aab0e	1631	* @brief Return the ADC error code
mbed_official	354:e67efb2aab0e	1632	* @param hadc: ADC handle
mbed_official	354:e67efb2aab0e	1633	* @retval ADC Error Code
mbed_official	354:e67efb2aab0e	1634	*/
mbed_official	354:e67efb2aab0e	1635	uint32_t HAL_ADC_GetError(ADC_HandleTypeDef *hadc)
mbed_official	354:e67efb2aab0e	1636	{
mbed_official	354:e67efb2aab0e	1637	return hadc->ErrorCode;
mbed_official	354:e67efb2aab0e	1638	}
mbed_official	354:e67efb2aab0e	1639
mbed_official	354:e67efb2aab0e	1640	/**
mbed_official	354:e67efb2aab0e	1641	* @}
mbed_official	354:e67efb2aab0e	1642	*/
mbed_official	354:e67efb2aab0e	1643
mbed_official	354:e67efb2aab0e	1644	/**
mbed_official	354:e67efb2aab0e	1645	* @}
mbed_official	354:e67efb2aab0e	1646	*/
mbed_official	354:e67efb2aab0e	1647
mbed_official	354:e67efb2aab0e	1648	/** @defgroup ADC_Private_Functions ADC Private Functions
mbed_official	354:e67efb2aab0e	1649	* @{
mbed_official	354:e67efb2aab0e	1650	*/
mbed_official	354:e67efb2aab0e	1651
mbed_official	354:e67efb2aab0e	1652	/**
mbed_official	354:e67efb2aab0e	1653	* @brief Enable the selected ADC.
mbed_official	354:e67efb2aab0e	1654	* @note Prerequisite condition to use this function: ADC must be disabled
mbed_official	354:e67efb2aab0e	1655	* and voltage regulator must be enabled (done into HAL_ADC_Init()).
mbed_official	354:e67efb2aab0e	1656	* @param hadc: ADC handle
mbed_official	354:e67efb2aab0e	1657	* @retval HAL status.
mbed_official	354:e67efb2aab0e	1658	*/
mbed_official	354:e67efb2aab0e	1659	HAL_StatusTypeDef ADC_Enable(ADC_HandleTypeDef* hadc)
mbed_official	354:e67efb2aab0e	1660	{
mbed_official	354:e67efb2aab0e	1661	uint32_t wait_loop_index = 0;
mbed_official	354:e67efb2aab0e	1662	uint32_t tickstart = 0;
mbed_official	354:e67efb2aab0e	1663
mbed_official	354:e67efb2aab0e	1664	/* ADC enable and wait for ADC ready (in case of ADC is disabled or */
mbed_official	354:e67efb2aab0e	1665	/* enabling phase not yet completed: flag ADC ready not yet set). */
mbed_official	354:e67efb2aab0e	1666	/* Timeout implemented to not be stuck if ADC cannot be enabled (possible */
mbed_official	354:e67efb2aab0e	1667	/* causes: ADC clock not running, ...). */
mbed_official	354:e67efb2aab0e	1668	if (__HAL_ADC_IS_ENABLED(hadc) == RESET)
mbed_official	354:e67efb2aab0e	1669	{
mbed_official	354:e67efb2aab0e	1670	/* Enable the Peripheral */
mbed_official	354:e67efb2aab0e	1671	__ADC_ENABLE(hadc);
mbed_official	354:e67efb2aab0e	1672
mbed_official	354:e67efb2aab0e	1673	/* Delay for ADC stabilization time. */
mbed_official	354:e67efb2aab0e	1674	/* Delay fixed to worst case: maximum CPU frequency */
mbed_official	354:e67efb2aab0e	1675	while(wait_loop_index < ADC_STAB_DELAY_CPU_CYCLES)
mbed_official	354:e67efb2aab0e	1676	{
mbed_official	354:e67efb2aab0e	1677	wait_loop_index++;
mbed_official	354:e67efb2aab0e	1678	}
mbed_official	354:e67efb2aab0e	1679
mbed_official	354:e67efb2aab0e	1680	/* Get timeout */
mbed_official	354:e67efb2aab0e	1681	tickstart = HAL_GetTick();
mbed_official	354:e67efb2aab0e	1682
mbed_official	354:e67efb2aab0e	1683	/* Wait for ADC effectively enabled */
mbed_official	354:e67efb2aab0e	1684	while(__HAL_ADC_IS_ENABLED(hadc) == RESET)
mbed_official	354:e67efb2aab0e	1685	{
mbed_official	354:e67efb2aab0e	1686	if((HAL_GetTick() - tickstart ) > ADC_ENABLE_TIMEOUT)
mbed_official	354:e67efb2aab0e	1687	{
mbed_official	354:e67efb2aab0e	1688	/* Update ADC state machine to error */
mbed_official	354:e67efb2aab0e	1689	hadc->State = HAL_ADC_STATE_ERROR;
mbed_official	354:e67efb2aab0e	1690
mbed_official	354:e67efb2aab0e	1691	/* Set ADC error code to ADC IP internal error */
mbed_official	354:e67efb2aab0e	1692	hadc->ErrorCode \|= HAL_ADC_ERROR_INTERNAL;
mbed_official	354:e67efb2aab0e	1693
mbed_official	354:e67efb2aab0e	1694	/* Process unlocked */
mbed_official	354:e67efb2aab0e	1695	__HAL_UNLOCK(hadc);
mbed_official	354:e67efb2aab0e	1696
mbed_official	354:e67efb2aab0e	1697	return HAL_ERROR;
mbed_official	354:e67efb2aab0e	1698	}
mbed_official	354:e67efb2aab0e	1699	}
mbed_official	354:e67efb2aab0e	1700	}
mbed_official	354:e67efb2aab0e	1701
mbed_official	354:e67efb2aab0e	1702	/* Return HAL status */
mbed_official	354:e67efb2aab0e	1703	return HAL_OK;
mbed_official	354:e67efb2aab0e	1704	}
mbed_official	354:e67efb2aab0e	1705
mbed_official	354:e67efb2aab0e	1706	/**
mbed_official	354:e67efb2aab0e	1707	* @brief Stop ADC conversion and disable the selected ADC
mbed_official	354:e67efb2aab0e	1708	* @note Prerequisite condition to use this function: ADC conversions must be
mbed_official	354:e67efb2aab0e	1709	* stopped to disable the ADC.
mbed_official	354:e67efb2aab0e	1710	* @param hadc: ADC handle
mbed_official	354:e67efb2aab0e	1711	* @retval HAL status.
mbed_official	354:e67efb2aab0e	1712	*/
mbed_official	354:e67efb2aab0e	1713	HAL_StatusTypeDef ADC_ConversionStop_Disable(ADC_HandleTypeDef* hadc)
mbed_official	354:e67efb2aab0e	1714	{
mbed_official	354:e67efb2aab0e	1715	uint32_t tickstart = 0;
mbed_official	354:e67efb2aab0e	1716
mbed_official	354:e67efb2aab0e	1717	/* Verification if ADC is not already disabled: */
mbed_official	354:e67efb2aab0e	1718	if (__HAL_ADC_IS_ENABLED(hadc) != RESET)
mbed_official	354:e67efb2aab0e	1719	{
mbed_official	354:e67efb2aab0e	1720	/* Disable the ADC peripheral */
mbed_official	354:e67efb2aab0e	1721	__ADC_DISABLE(hadc);
mbed_official	354:e67efb2aab0e	1722
mbed_official	354:e67efb2aab0e	1723	/* Get timeout */
mbed_official	354:e67efb2aab0e	1724	tickstart = HAL_GetTick();
mbed_official	354:e67efb2aab0e	1725
mbed_official	354:e67efb2aab0e	1726	/* Wait for ADC effectively disabled */
mbed_official	354:e67efb2aab0e	1727	while(__HAL_ADC_IS_ENABLED(hadc) != RESET)
mbed_official	354:e67efb2aab0e	1728	{
mbed_official	354:e67efb2aab0e	1729	if((HAL_GetTick() - tickstart ) > ADC_DISABLE_TIMEOUT)
mbed_official	354:e67efb2aab0e	1730	{
mbed_official	354:e67efb2aab0e	1731	/* Update ADC state machine to error */
mbed_official	354:e67efb2aab0e	1732	hadc->State = HAL_ADC_STATE_ERROR;
mbed_official	354:e67efb2aab0e	1733
mbed_official	354:e67efb2aab0e	1734	/* Set ADC error code to ADC IP internal error */
mbed_official	354:e67efb2aab0e	1735	hadc->ErrorCode \|= HAL_ADC_ERROR_INTERNAL;
mbed_official	354:e67efb2aab0e	1736
mbed_official	354:e67efb2aab0e	1737	return HAL_ERROR;
mbed_official	354:e67efb2aab0e	1738	}
mbed_official	354:e67efb2aab0e	1739	}
mbed_official	354:e67efb2aab0e	1740	}
mbed_official	354:e67efb2aab0e	1741
mbed_official	354:e67efb2aab0e	1742	/* Return HAL status */
mbed_official	354:e67efb2aab0e	1743	return HAL_OK;
mbed_official	354:e67efb2aab0e	1744	}
mbed_official	354:e67efb2aab0e	1745
mbed_official	354:e67efb2aab0e	1746	/**
mbed_official	354:e67efb2aab0e	1747	* @}
mbed_official	354:e67efb2aab0e	1748	*/
mbed_official	354:e67efb2aab0e	1749
mbed_official	354:e67efb2aab0e	1750	#endif /* HAL_ADC_MODULE_ENABLED */
mbed_official	354:e67efb2aab0e	1751	/**
mbed_official	354:e67efb2aab0e	1752	* @}
mbed_official	354:e67efb2aab0e	1753	*/
mbed_official	354:e67efb2aab0e	1754
mbed_official	354:e67efb2aab0e	1755	/**
mbed_official	354:e67efb2aab0e	1756	* @}
mbed_official	354:e67efb2aab0e	1757	*/
mbed_official	354:e67efb2aab0e	1758
mbed_official	354:e67efb2aab0e	1759	/********************** (C) COPYRIGHT STMicroelectronics *END OF FILE**/

Repository toolbox

Export to desktop IDE

Repository details

Type:	Library
Created:	13 Dec 2016
Imports:	0
Forks:	0
Commits:	637
Dependents:	0
Dependencies:	0
Followers:	1

targets/cmsis/TARGET_STM/TARGET_STM32L1/stm32l1xx_hal_adc.c@394:83f921546702, 2014-11-07 (annotated)

Who changed what in which revision?

Repository toolbox

Repository details

Important Information for this Arm website

Access Warning