mbed official / mbed-src

mbed library sources

Dependents:   Encrypted my_mbed lklk CyaSSL_DTLS_Cellular ... more

Superseded

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

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

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

Import librarymbed

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

Last commit 20 Feb 2019 by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32F3/stm32f3xx_hal_sdadc.c@634:ac7d6880524d, 2015-09-28 (annotated)

Committer:
mbed_official
Date:
Mon Sep 28 20:15:09 2015 +0100
Revision:
634:ac7d6880524d
Parent:
632:7687fb9c4f91 
Synchronized with git revision 9b7d23d47153c298a6d24de9a415202705889d11



Full URL: https://github.com/mbedmicro/mbed/commit/9b7d23d47153c298a6d24de9a415202705889d11/



Revert "[NUCLEO_F303K8] add support of the STM32F303K8"

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mbed_official 330:c80ac197fa6a 1 /**
mbed_official 330:c80ac197fa6a 2 ******************************************************************************
mbed_official 330:c80ac197fa6a 3 * @file stm32f3xx_hal_sdadc.c
mbed_official 330:c80ac197fa6a 4 * @author MCD Application Team
mbed_official 634:ac7d6880524d 5 * @version V1.1.0
mbed_official 634:ac7d6880524d 6 * @date 12-Sept-2014
mbed_official 330:c80ac197fa6a 7 * @brief This file provides firmware functions to manage the following
mbed_official 330:c80ac197fa6a 8 * functionalities of the Sigma-Delta Analog to Digital Convertor
mbed_official 330:c80ac197fa6a 9 * (SDADC) peripherals:
mbed_official 330:c80ac197fa6a 10 * + Initialization and Configuration
mbed_official 330:c80ac197fa6a 11 * + Regular Channels Configuration
mbed_official 330:c80ac197fa6a 12 * + Injected channels Configuration
mbed_official 330:c80ac197fa6a 13 * + Power saving
mbed_official 330:c80ac197fa6a 14 * + Regular/Injected Channels DMA Configuration
mbed_official 330:c80ac197fa6a 15 * + Interrupts and flags management
mbed_official 330:c80ac197fa6a 16 *
mbed_official 330:c80ac197fa6a 17 @verbatim
mbed_official 330:c80ac197fa6a 18 ==============================================================================
mbed_official 330:c80ac197fa6a 19 ##### SDADC specific features #####
mbed_official 330:c80ac197fa6a 20 ==============================================================================
mbed_official 330:c80ac197fa6a 21 [..]
mbed_official 330:c80ac197fa6a 22 (#) 16-bit sigma delta architecture.
mbed_official 330:c80ac197fa6a 23 (#) Self calibration.
mbed_official 330:c80ac197fa6a 24 (#) Interrupt generation at the end of calibration, regular/injected conversion
mbed_official 330:c80ac197fa6a 25 and in case of overrun events.
mbed_official 330:c80ac197fa6a 26 (#) Single and continuous conversion modes.
mbed_official 330:c80ac197fa6a 27 (#) External trigger option with configurable polarity for injected conversion.
mbed_official 330:c80ac197fa6a 28 (#) Multi mode (synchronized another SDADC with SDADC1).
mbed_official 330:c80ac197fa6a 29 (#) DMA request generation during regular or injected channel conversion.
mbed_official 330:c80ac197fa6a 30
mbed_official 330:c80ac197fa6a 31 ##### How to use this driver #####
mbed_official 330:c80ac197fa6a 32 ==============================================================================
mbed_official 330:c80ac197fa6a 33 [..]
mbed_official 330:c80ac197fa6a 34 *** Initialization ***
mbed_official 330:c80ac197fa6a 35 ======================
mbed_official 330:c80ac197fa6a 36 [..]
mbed_official 330:c80ac197fa6a 37 (#) As prerequisite, fill in the HAL_SDADC_MspInit() :
mbed_official 330:c80ac197fa6a 38 (+) Enable SDADCx clock interface with __SDADCx_CLK_ENABLE().
mbed_official 330:c80ac197fa6a 39 (+) Configure SDADCx clock divider with HAL_RCCEx_PeriphCLKConfig.
mbed_official 330:c80ac197fa6a 40 (+) Enable power on SDADC with HAL_PWREx_EnableSDADCAnalog().
mbed_official 330:c80ac197fa6a 41 (+) Enable the clocks for the SDADC GPIOS with __GPIOx_CLK_ENABLE().
mbed_official 330:c80ac197fa6a 42 (+) Configure these SDADC pins in analog mode using HAL_GPIO_Init().
mbed_official 330:c80ac197fa6a 43 (+) If interrupt mode is used, enable and configure SDADC global
mbed_official 330:c80ac197fa6a 44 interrupt with HAL_NVIC_SetPriority() and HAL_NVIC_EnableIRQ().
mbed_official 330:c80ac197fa6a 45 (+) If DMA mode is used, configure DMA with HAL_DMA_Init and link it
mbed_official 330:c80ac197fa6a 46 with SDADC handle using __HAL_LINKDMA.
mbed_official 330:c80ac197fa6a 47 (#) Configure the SDADC low power mode, fast conversion mode, slow clock
mbed_official 330:c80ac197fa6a 48 mode and SDADC1 reference voltage using the HAL_ADC_Init() function.
mbed_official 330:c80ac197fa6a 49 If multiple SDADC are used, please configure first SDADC1 with the
mbed_official 330:c80ac197fa6a 50 common reference voltage.
mbed_official 330:c80ac197fa6a 51 (#) Prepare channel configurations (input mode, common mode, gain and
mbed_official 330:c80ac197fa6a 52 offset) using HAL_SDADC_PrepareChannelConfig and associate channel
mbed_official 330:c80ac197fa6a 53 with one configuration using HAL_SDADC_AssociateChannelConfig.
mbed_official 330:c80ac197fa6a 54
mbed_official 330:c80ac197fa6a 55 *** Calibration ***
mbed_official 330:c80ac197fa6a 56 ============================================
mbed_official 330:c80ac197fa6a 57 [..]
mbed_official 330:c80ac197fa6a 58 (#) Start calibration using HAL_SDADC_StartCalibration or
mbed_official 330:c80ac197fa6a 59 HAL_SDADC_CalibrationStart_IT.
mbed_official 330:c80ac197fa6a 60 (#) In polling mode, use HAL_SDADC_PollForCalibEvent to detect the end of
mbed_official 330:c80ac197fa6a 61 calibration.
mbed_official 330:c80ac197fa6a 62 (#) In interrupt mode, HAL_SDADC_CalibrationCpltCallback will be called at
mbed_official 330:c80ac197fa6a 63 the end of calibration.
mbed_official 330:c80ac197fa6a 64
mbed_official 330:c80ac197fa6a 65 *** Regular channel conversion ***
mbed_official 330:c80ac197fa6a 66 ============================================
mbed_official 330:c80ac197fa6a 67 [..]
mbed_official 330:c80ac197fa6a 68 (#) Select trigger for regular conversion using
mbed_official 330:c80ac197fa6a 69 HAL_SDADC_SelectRegularTrigger.
mbed_official 330:c80ac197fa6a 70 (#) Select regular channel and enable/disable continuous mode using
mbed_official 330:c80ac197fa6a 71 HAL_SDADC_ConfigChannel.
mbed_official 330:c80ac197fa6a 72 (#) Start regular conversion using HAL_SDADC_Start, HAL_SDADC_Start_IT
mbed_official 330:c80ac197fa6a 73 or HAL_SDADC_Start_DMA.
mbed_official 330:c80ac197fa6a 74 (#) In polling mode, use HAL_SDADC_PollForConversion to detect the end of
mbed_official 330:c80ac197fa6a 75 regular conversion.
mbed_official 330:c80ac197fa6a 76 (#) In interrupt mode, HAL_SDADC_ConvCpltCallback will be called at the
mbed_official 330:c80ac197fa6a 77 end of regular conversion.
mbed_official 330:c80ac197fa6a 78 (#) Get value of regular conversion using HAL_SDADC_GetValue.
mbed_official 330:c80ac197fa6a 79 (#) In DMA mode, HAL_SDADC_ConvHalfCpltCallback and
mbed_official 330:c80ac197fa6a 80 HAL_SDADC_ConvCpltCallback will be called respectively at the half
mbed_official 330:c80ac197fa6a 81 tranfer and at the tranfer complete.
mbed_official 330:c80ac197fa6a 82 (#) Stop regular conversion using HAL_SDADC_Stop, HAL_SDADC_Stop_IT
mbed_official 330:c80ac197fa6a 83 or HAL_SDADC_Stop_DMA.
mbed_official 330:c80ac197fa6a 84
mbed_official 330:c80ac197fa6a 85 *** Injected channels conversion ***
mbed_official 330:c80ac197fa6a 86 ============================================
mbed_official 330:c80ac197fa6a 87 [..]
mbed_official 330:c80ac197fa6a 88 (#) Enable/disable delay on injected conversion using
mbed_official 330:c80ac197fa6a 89 HAL_SDADC_SelectInjectedDelay.
mbed_official 330:c80ac197fa6a 90 (#) If external trigger is used for injected conversion, configure this
mbed_official 330:c80ac197fa6a 91 trigger using HAL_SDADC_SelectInjectedExtTrigger.
mbed_official 330:c80ac197fa6a 92 (#) Select trigger for injected conversion using
mbed_official 330:c80ac197fa6a 93 HAL_SDADC_SelectInjectedTrigger.
mbed_official 330:c80ac197fa6a 94 (#) Select injected channels and enable/disable continuous mode using
mbed_official 330:c80ac197fa6a 95 HAL_SDADC_InjectedConfigChannel.
mbed_official 330:c80ac197fa6a 96 (#) Start injected conversion using HAL_SDADC_InjectedStart,
mbed_official 330:c80ac197fa6a 97 HAL_SDADC_InjectedStart_IT or HAL_SDADC_InjectedStart_DMA.
mbed_official 330:c80ac197fa6a 98 (#) In polling mode, use HAL_SDADC_PollForInjectedConversion to detect the
mbed_official 330:c80ac197fa6a 99 end of injected conversion.
mbed_official 330:c80ac197fa6a 100 (#) In interrupt mode, HAL_SDADC_InjectedConvCpltCallback will be called
mbed_official 330:c80ac197fa6a 101 at the end of injected conversion.
mbed_official 330:c80ac197fa6a 102 (#) Get value of injected conversion and corresponding channel using
mbed_official 330:c80ac197fa6a 103 HAL_SDADC_InjectedGetValue.
mbed_official 330:c80ac197fa6a 104 (#) In DMA mode, HAL_SDADC_InjectedConvHalfCpltCallback and
mbed_official 330:c80ac197fa6a 105 HAL_SDADC_InjectedConvCpltCallback will be called respectively at the
mbed_official 330:c80ac197fa6a 106 half tranfer and at the tranfer complete.
mbed_official 330:c80ac197fa6a 107 (#) Stop injected conversion using HAL_SDADC_InjectedStop,
mbed_official 330:c80ac197fa6a 108 HAL_SDADC_InjectedStop_IT or HAL_SDADC_InjectedStop_DMA.
mbed_official 330:c80ac197fa6a 109
mbed_official 330:c80ac197fa6a 110 *** Multi mode regular channels conversions ***
mbed_official 330:c80ac197fa6a 111 ======================================================
mbed_official 330:c80ac197fa6a 112 [..]
mbed_official 330:c80ac197fa6a 113 (#) Select type of multimode (SDADC1/SDADC2 or SDADC1/SDADC3) using
mbed_official 330:c80ac197fa6a 114 HAL_SDADC_MultiModeConfigChannel.
mbed_official 330:c80ac197fa6a 115 (#) Select software trigger for SDADC1 and synchronized trigger for
mbed_official 330:c80ac197fa6a 116 SDADC2 (or SDADC3) using HAL_SDADC_SelectRegularTrigger.
mbed_official 330:c80ac197fa6a 117 (#) Select regular channel for SDADC1 and SDADC2 (or SDADC3) using
mbed_official 330:c80ac197fa6a 118 HAL_SDADC_ConfigChannel.
mbed_official 330:c80ac197fa6a 119 (#) Start regular conversion for SDADC2 (or SDADC3) with HAL_SDADC_Start.
mbed_official 330:c80ac197fa6a 120 (#) Start regular conversion for SDADC1 using HAL_SDADC_Start,
mbed_official 330:c80ac197fa6a 121 HAL_SDADC_Start_IT or HAL_SDADC_MultiModeStart_DMA.
mbed_official 330:c80ac197fa6a 122 (#) In polling mode, use HAL_SDADC_PollForConversion to detect the end of
mbed_official 330:c80ac197fa6a 123 regular conversion for SDADC1.
mbed_official 330:c80ac197fa6a 124 (#) In interrupt mode, HAL_SDADC_ConvCpltCallback will be called at the
mbed_official 330:c80ac197fa6a 125 end of regular conversion for SDADC1.
mbed_official 330:c80ac197fa6a 126 (#) Get value of regular conversions using HAL_SDADC_MultiModeGetValue.
mbed_official 330:c80ac197fa6a 127 (#) In DMA mode, HAL_SDADC_ConvHalfCpltCallback and
mbed_official 330:c80ac197fa6a 128 HAL_SDADC_ConvCpltCallback will be called respectively at the half
mbed_official 330:c80ac197fa6a 129 tranfer and at the tranfer complete for SDADC1.
mbed_official 330:c80ac197fa6a 130 (#) Stop regular conversion using HAL_SDADC_Stop, HAL_SDADC_Stop_IT
mbed_official 330:c80ac197fa6a 131 or HAL_SDADC_MultiModeStop_DMA for SDADC1.
mbed_official 330:c80ac197fa6a 132 (#) Stop regular conversion using HAL_SDADC_Stop for SDADC2 (or SDADC3).
mbed_official 330:c80ac197fa6a 133
mbed_official 330:c80ac197fa6a 134 *** Multi mode injected channels conversions ***
mbed_official 330:c80ac197fa6a 135 ======================================================
mbed_official 330:c80ac197fa6a 136 [..]
mbed_official 330:c80ac197fa6a 137 (#) Select type of multimode (SDADC1/SDADC2 or SDADC1/SDADC3) using
mbed_official 330:c80ac197fa6a 138 HAL_SDADC_InjectedMultiModeConfigChannel.
mbed_official 330:c80ac197fa6a 139 (#) Select software or external trigger for SDADC1 and synchronized
mbed_official 330:c80ac197fa6a 140 trigger for SDADC2 (or SDADC3) using HAL_SDADC_SelectInjectedTrigger.
mbed_official 330:c80ac197fa6a 141 (#) Select injected channels for SDADC1 and SDADC2 (or SDADC3) using
mbed_official 330:c80ac197fa6a 142 HAL_SDADC_InjectedConfigChannel.
mbed_official 330:c80ac197fa6a 143 (#) Start injected conversion for SDADC2 (or SDADC3) with
mbed_official 330:c80ac197fa6a 144 HAL_SDADC_InjectedStart.
mbed_official 330:c80ac197fa6a 145 (#) Start injected conversion for SDADC1 using HAL_SDADC_InjectedStart,
mbed_official 330:c80ac197fa6a 146 HAL_SDADC_InjectedStart_IT or HAL_SDADC_InjectedMultiModeStart_DMA.
mbed_official 330:c80ac197fa6a 147 (#) In polling mode, use HAL_SDADC_InjectedPollForConversion to detect
mbed_official 330:c80ac197fa6a 148 the end of injected conversion for SDADC1.
mbed_official 330:c80ac197fa6a 149 (#) In interrupt mode, HAL_SDADC_InjectedConvCpltCallback will be called
mbed_official 330:c80ac197fa6a 150 at the end of injected conversion for SDADC1.
mbed_official 330:c80ac197fa6a 151 (#) Get value of injected conversions using
mbed_official 330:c80ac197fa6a 152 HAL_SDADC_InjectedMultiModeGetValue.
mbed_official 330:c80ac197fa6a 153 (#) In DMA mode, HAL_SDADC_InjectedConvHalfCpltCallback and
mbed_official 330:c80ac197fa6a 154 HAL_SDADC_InjectedConvCpltCallback will be called respectively at the
mbed_official 330:c80ac197fa6a 155 half tranfer and at the tranfer complete for SDADC1.
mbed_official 330:c80ac197fa6a 156 (#) Stop injected conversion using HAL_SDADC_InjectedStop,
mbed_official 330:c80ac197fa6a 157 HAL_SDADC_InjectedStop_IT or HAL_SDADC_InjecteddMultiModeStop_DMA
mbed_official 330:c80ac197fa6a 158 for SDADC1.
mbed_official 330:c80ac197fa6a 159 (#) Stop injected conversion using HAL_SDADC_InjectedStop for SDADC2
mbed_official 330:c80ac197fa6a 160 (or SDADC3).
mbed_official 330:c80ac197fa6a 161
mbed_official 330:c80ac197fa6a 162 @endverbatim
mbed_official 330:c80ac197fa6a 163 ******************************************************************************
mbed_official 330:c80ac197fa6a 164 * @attention
mbed_official 330:c80ac197fa6a 165 *
mbed_official 634:ac7d6880524d 166 * <h2><center>&copy; COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
mbed_official 330:c80ac197fa6a 167 *
mbed_official 330:c80ac197fa6a 168 * Redistribution and use in source and binary forms, with or without modification,
mbed_official 330:c80ac197fa6a 169 * are permitted provided that the following conditions are met:
mbed_official 330:c80ac197fa6a 170 * 1. Redistributions of source code must retain the above copyright notice,
mbed_official 330:c80ac197fa6a 171 * this list of conditions and the following disclaimer.
mbed_official 330:c80ac197fa6a 172 * 2. Redistributions in binary form must reproduce the above copyright notice,
mbed_official 330:c80ac197fa6a 173 * this list of conditions and the following disclaimer in the documentation
mbed_official 330:c80ac197fa6a 174 * and/or other materials provided with the distribution.
mbed_official 330:c80ac197fa6a 175 * 3. Neither the name of STMicroelectronics nor the names of its contributors
mbed_official 330:c80ac197fa6a 176 * may be used to endorse or promote products derived from this software
mbed_official 330:c80ac197fa6a 177 * without specific prior written permission.
mbed_official 330:c80ac197fa6a 178 *
mbed_official 330:c80ac197fa6a 179 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
mbed_official 330:c80ac197fa6a 180 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
mbed_official 330:c80ac197fa6a 181 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
mbed_official 330:c80ac197fa6a 182 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
mbed_official 330:c80ac197fa6a 183 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
mbed_official 330:c80ac197fa6a 184 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
mbed_official 330:c80ac197fa6a 185 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
mbed_official 330:c80ac197fa6a 186 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
mbed_official 330:c80ac197fa6a 187 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
mbed_official 330:c80ac197fa6a 188 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
mbed_official 330:c80ac197fa6a 189 *
mbed_official 330:c80ac197fa6a 190 ******************************************************************************
mbed_official 330:c80ac197fa6a 191 */
mbed_official 330:c80ac197fa6a 192
mbed_official 330:c80ac197fa6a 193 /* Includes ------------------------------------------------------------------*/
mbed_official 330:c80ac197fa6a 194 #include "stm32f3xx_hal.h"
mbed_official 330:c80ac197fa6a 195
mbed_official 330:c80ac197fa6a 196 /** @addtogroup STM32F3xx_HAL_Driver
mbed_official 330:c80ac197fa6a 197 * @{
mbed_official 330:c80ac197fa6a 198 */
mbed_official 330:c80ac197fa6a 199
mbed_official 330:c80ac197fa6a 200 #ifdef HAL_SDADC_MODULE_ENABLED
mbed_official 330:c80ac197fa6a 201 #if defined(STM32F373xC) || defined(STM32F378xx)
mbed_official 330:c80ac197fa6a 202 /** @defgroup SDADC SDADC HAL module driver
mbed_official 330:c80ac197fa6a 203 * @brief SDADC HAL driver modules
mbed_official 330:c80ac197fa6a 204 * @{
mbed_official 330:c80ac197fa6a 205 */
mbed_official 330:c80ac197fa6a 206
mbed_official 330:c80ac197fa6a 207 /* Private typedef -----------------------------------------------------------*/
mbed_official 330:c80ac197fa6a 208 /* Private define ------------------------------------------------------------*/
mbed_official 330:c80ac197fa6a 209 /** @defgroup SDADC_Private_Define SDADC Private Define
mbed_official 330:c80ac197fa6a 210 * @{
mbed_official 330:c80ac197fa6a 211 */
mbed_official 330:c80ac197fa6a 212 #define SDADC_TIMEOUT 200
mbed_official 330:c80ac197fa6a 213 #define SDADC_CONFREG_OFFSET 0x00000020
mbed_official 330:c80ac197fa6a 214 #define SDADC_JDATAR_CH_OFFSET 24
mbed_official 330:c80ac197fa6a 215 #define SDADC_MSB_MASK 0xFFFF0000
mbed_official 330:c80ac197fa6a 216 #define SDADC_LSB_MASK 0x0000FFFF
mbed_official 330:c80ac197fa6a 217 /**
mbed_official 330:c80ac197fa6a 218 * @}
mbed_official 330:c80ac197fa6a 219 */
mbed_official 330:c80ac197fa6a 220
mbed_official 330:c80ac197fa6a 221 /* Private macro -------------------------------------------------------------*/
mbed_official 330:c80ac197fa6a 222 /* Private variables ---------------------------------------------------------*/
mbed_official 330:c80ac197fa6a 223 /* Private function prototypes -----------------------------------------------*/
mbed_official 330:c80ac197fa6a 224 /** @defgroup SDADC_Private_Functions SDADC Private Functions
mbed_official 330:c80ac197fa6a 225 * @{
mbed_official 330:c80ac197fa6a 226 */
mbed_official 330:c80ac197fa6a 227
mbed_official 330:c80ac197fa6a 228 static HAL_StatusTypeDef SDADC_EnterInitMode(SDADC_HandleTypeDef* hsdadc);
mbed_official 330:c80ac197fa6a 229 static void SDADC_ExitInitMode(SDADC_HandleTypeDef* hsdadc);
mbed_official 330:c80ac197fa6a 230 static uint32_t SDADC_GetInjChannelsNbr(uint32_t Channels);
mbed_official 330:c80ac197fa6a 231 static HAL_StatusTypeDef SDADC_RegConvStart(SDADC_HandleTypeDef* hsdadc);
mbed_official 330:c80ac197fa6a 232 static HAL_StatusTypeDef SDADC_RegConvStop(SDADC_HandleTypeDef* hsdadc);
mbed_official 330:c80ac197fa6a 233 static HAL_StatusTypeDef SDADC_InjConvStart(SDADC_HandleTypeDef* hsdadc);
mbed_official 330:c80ac197fa6a 234 static HAL_StatusTypeDef SDADC_InjConvStop(SDADC_HandleTypeDef* hsdadc);
mbed_official 330:c80ac197fa6a 235 static void SDADC_DMARegularHalfConvCplt(DMA_HandleTypeDef *hdma);
mbed_official 330:c80ac197fa6a 236 static void SDADC_DMARegularConvCplt(DMA_HandleTypeDef *hdma);
mbed_official 330:c80ac197fa6a 237 static void SDADC_DMAInjectedHalfConvCplt(DMA_HandleTypeDef *hdma);
mbed_official 330:c80ac197fa6a 238 static void SDADC_DMAInjectedConvCplt(DMA_HandleTypeDef *hdma);
mbed_official 330:c80ac197fa6a 239 static void SDADC_DMAError(DMA_HandleTypeDef *hdma);
mbed_official 330:c80ac197fa6a 240 /**
mbed_official 330:c80ac197fa6a 241 * @}
mbed_official 330:c80ac197fa6a 242 */
mbed_official 330:c80ac197fa6a 243
mbed_official 330:c80ac197fa6a 244 /* Exported functions ---------------------------------------------------------*/
mbed_official 330:c80ac197fa6a 245
mbed_official 330:c80ac197fa6a 246 /** @defgroup SDADC_Exported_Functions SDADC Exported Functions
mbed_official 330:c80ac197fa6a 247 * @{
mbed_official 330:c80ac197fa6a 248 */
mbed_official 330:c80ac197fa6a 249
mbed_official 330:c80ac197fa6a 250 /** @defgroup SDADC_Exported_Functions_Group1 Initialization and de-initialization functions
mbed_official 330:c80ac197fa6a 251 * @brief Initialization and de-initialization functions
mbed_official 330:c80ac197fa6a 252 *
mbed_official 330:c80ac197fa6a 253 @verbatim
mbed_official 330:c80ac197fa6a 254 ===============================================================================
mbed_official 330:c80ac197fa6a 255 ##### Initialization and de-initialization functions #####
mbed_official 330:c80ac197fa6a 256 ===============================================================================
mbed_official 330:c80ac197fa6a 257 [..] This section provides functions allowing to:
mbed_official 330:c80ac197fa6a 258 (+) Initialize the SDADC.
mbed_official 330:c80ac197fa6a 259 (+) De-initialize the SDADC.
mbed_official 330:c80ac197fa6a 260
mbed_official 330:c80ac197fa6a 261 @endverbatim
mbed_official 330:c80ac197fa6a 262 * @{
mbed_official 330:c80ac197fa6a 263 */
mbed_official 330:c80ac197fa6a 264
mbed_official 330:c80ac197fa6a 265 /**
mbed_official 330:c80ac197fa6a 266 * @brief Initializes the SDADC according to the specified
mbed_official 330:c80ac197fa6a 267 * parameters in the SDADC_InitTypeDef structure.
mbed_official 330:c80ac197fa6a 268 * @note If multiple SDADC are used, please configure first SDADC1 to set
mbed_official 330:c80ac197fa6a 269 * the common reference voltage.
mbed_official 330:c80ac197fa6a 270 * @param hsdadc : SDADC handle.
mbed_official 330:c80ac197fa6a 271 * @retval HAL status.
mbed_official 330:c80ac197fa6a 272 */
mbed_official 330:c80ac197fa6a 273 HAL_StatusTypeDef HAL_SDADC_Init(SDADC_HandleTypeDef* hsdadc)
mbed_official 330:c80ac197fa6a 274 {
mbed_official 330:c80ac197fa6a 275 /* Check parameters */
mbed_official 330:c80ac197fa6a 276 assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance));
mbed_official 330:c80ac197fa6a 277 assert_param(IS_SDADC_LOWPOWER_MODE(hsdadc->Init.IdleLowPowerMode));
mbed_official 330:c80ac197fa6a 278 assert_param(IS_SDADC_FAST_CONV_MODE(hsdadc->Init.FastConversionMode));
mbed_official 330:c80ac197fa6a 279 assert_param(IS_SDADC_SLOW_CLOCK_MODE(hsdadc->Init.SlowClockMode));
mbed_official 330:c80ac197fa6a 280 assert_param(IS_SDADC_VREF(hsdadc->Init.ReferenceVoltage));
mbed_official 330:c80ac197fa6a 281
mbed_official 330:c80ac197fa6a 282 /* Check SDADC handle */
mbed_official 634:ac7d6880524d 283 if(hsdadc == HAL_NULL)
mbed_official 330:c80ac197fa6a 284 {
mbed_official 330:c80ac197fa6a 285 return HAL_ERROR;
mbed_official 330:c80ac197fa6a 286 }
mbed_official 330:c80ac197fa6a 287
mbed_official 330:c80ac197fa6a 288 /* Initialize SDADC variables with default values */
mbed_official 330:c80ac197fa6a 289 hsdadc->RegularContMode = SDADC_CONTINUOUS_CONV_OFF;
mbed_official 330:c80ac197fa6a 290 hsdadc->InjectedContMode = SDADC_CONTINUOUS_CONV_OFF;
mbed_official 330:c80ac197fa6a 291 hsdadc->InjectedChannelsNbr = 1;
mbed_official 330:c80ac197fa6a 292 hsdadc->InjConvRemaining = 1;
mbed_official 330:c80ac197fa6a 293 hsdadc->RegularTrigger = SDADC_SOFTWARE_TRIGGER;
mbed_official 330:c80ac197fa6a 294 hsdadc->InjectedTrigger = SDADC_SOFTWARE_TRIGGER;
mbed_official 330:c80ac197fa6a 295 hsdadc->ExtTriggerEdge = SDADC_EXT_TRIG_RISING_EDGE;
mbed_official 330:c80ac197fa6a 296 hsdadc->RegularMultimode = SDADC_MULTIMODE_SDADC1_SDADC2;
mbed_official 330:c80ac197fa6a 297 hsdadc->InjectedMultimode = SDADC_MULTIMODE_SDADC1_SDADC2;
mbed_official 330:c80ac197fa6a 298 hsdadc->ErrorCode = SDADC_ERROR_NONE;
mbed_official 330:c80ac197fa6a 299
mbed_official 330:c80ac197fa6a 300 /* Call MSP init function */
mbed_official 330:c80ac197fa6a 301 HAL_SDADC_MspInit(hsdadc);
mbed_official 330:c80ac197fa6a 302
mbed_official 330:c80ac197fa6a 303 /* Set idle low power and slow clock modes */
mbed_official 330:c80ac197fa6a 304 hsdadc->Instance->CR1 &= ~(SDADC_CR1_SBI|SDADC_CR1_PDI|SDADC_CR1_SLOWCK);
mbed_official 330:c80ac197fa6a 305 hsdadc->Instance->CR1 |= (hsdadc->Init.IdleLowPowerMode | \
mbed_official 330:c80ac197fa6a 306 hsdadc->Init.SlowClockMode);
mbed_official 330:c80ac197fa6a 307
mbed_official 330:c80ac197fa6a 308 /* Set fast conversion mode */
mbed_official 330:c80ac197fa6a 309 hsdadc->Instance->CR2 &= ~(SDADC_CR2_FAST);
mbed_official 330:c80ac197fa6a 310 hsdadc->Instance->CR2 |= hsdadc->Init.FastConversionMode;
mbed_official 330:c80ac197fa6a 311
mbed_official 330:c80ac197fa6a 312 /* Set reference voltage only for SDADC1 */
mbed_official 330:c80ac197fa6a 313 if(hsdadc->Instance == SDADC1)
mbed_official 330:c80ac197fa6a 314 {
mbed_official 330:c80ac197fa6a 315 hsdadc->Instance->CR1 &= ~(SDADC_CR1_REFV);
mbed_official 330:c80ac197fa6a 316 hsdadc->Instance->CR1 |= hsdadc->Init.ReferenceVoltage;
mbed_official 330:c80ac197fa6a 317
mbed_official 330:c80ac197fa6a 318 /* Wait at least 2ms before setting ADON */
mbed_official 330:c80ac197fa6a 319 HAL_Delay(2);
mbed_official 330:c80ac197fa6a 320 }
mbed_official 330:c80ac197fa6a 321
mbed_official 330:c80ac197fa6a 322 /* Enable SDADC */
mbed_official 330:c80ac197fa6a 323 hsdadc->Instance->CR2 |= SDADC_CR2_ADON;
mbed_official 330:c80ac197fa6a 324
mbed_official 330:c80ac197fa6a 325 /* Wait end of stabilization */
mbed_official 330:c80ac197fa6a 326 while((hsdadc->Instance->ISR & SDADC_ISR_STABIP) != 0);
mbed_official 330:c80ac197fa6a 327
mbed_official 330:c80ac197fa6a 328 /* Set SDADC to ready state */
mbed_official 330:c80ac197fa6a 329 hsdadc->State = HAL_SDADC_STATE_READY;
mbed_official 330:c80ac197fa6a 330
mbed_official 330:c80ac197fa6a 331 /* Return HAL status */
mbed_official 330:c80ac197fa6a 332 return HAL_OK;
mbed_official 330:c80ac197fa6a 333 }
mbed_official 330:c80ac197fa6a 334
mbed_official 330:c80ac197fa6a 335 /**
mbed_official 330:c80ac197fa6a 336 * @brief De-initializes the SDADC.
mbed_official 330:c80ac197fa6a 337 * @param hsdadc : SDADC handle.
mbed_official 330:c80ac197fa6a 338 * @retval HAL status.
mbed_official 330:c80ac197fa6a 339 */
mbed_official 330:c80ac197fa6a 340 HAL_StatusTypeDef HAL_SDADC_DeInit(SDADC_HandleTypeDef* hsdadc)
mbed_official 330:c80ac197fa6a 341 {
mbed_official 330:c80ac197fa6a 342 /* Check parameters */
mbed_official 330:c80ac197fa6a 343 assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance));
mbed_official 330:c80ac197fa6a 344
mbed_official 330:c80ac197fa6a 345 /* Check SDADC handle */
mbed_official 634:ac7d6880524d 346 if(hsdadc == HAL_NULL)
mbed_official 330:c80ac197fa6a 347 {
mbed_official 330:c80ac197fa6a 348 return HAL_ERROR;
mbed_official 330:c80ac197fa6a 349 }
mbed_official 330:c80ac197fa6a 350
mbed_official 330:c80ac197fa6a 351 /* Disable the SDADC */
mbed_official 330:c80ac197fa6a 352 hsdadc->Instance->CR2 &= ~(SDADC_CR2_ADON);
mbed_official 330:c80ac197fa6a 353
mbed_official 330:c80ac197fa6a 354 /* Reset all registers */
mbed_official 330:c80ac197fa6a 355 hsdadc->Instance->CR1 = 0x00000000;
mbed_official 330:c80ac197fa6a 356 hsdadc->Instance->CR2 = 0x00000000;
mbed_official 330:c80ac197fa6a 357 hsdadc->Instance->JCHGR = 0x00000001;
mbed_official 330:c80ac197fa6a 358 hsdadc->Instance->CONF0R = 0x00000000;
mbed_official 330:c80ac197fa6a 359 hsdadc->Instance->CONF1R = 0x00000000;
mbed_official 330:c80ac197fa6a 360 hsdadc->Instance->CONF2R = 0x00000000;
mbed_official 330:c80ac197fa6a 361 hsdadc->Instance->CONFCHR1 = 0x00000000;
mbed_official 330:c80ac197fa6a 362 hsdadc->Instance->CONFCHR2 = 0x00000000;
mbed_official 330:c80ac197fa6a 363
mbed_official 330:c80ac197fa6a 364 /* Call MSP deinit function */
mbed_official 330:c80ac197fa6a 365 HAL_SDADC_MspDeInit(hsdadc);
mbed_official 330:c80ac197fa6a 366
mbed_official 330:c80ac197fa6a 367 /* Set SDADC in reset state */
mbed_official 330:c80ac197fa6a 368 hsdadc->State = HAL_SDADC_STATE_RESET;
mbed_official 330:c80ac197fa6a 369
mbed_official 330:c80ac197fa6a 370 /* Return function status */
mbed_official 330:c80ac197fa6a 371 return HAL_OK;
mbed_official 330:c80ac197fa6a 372 }
mbed_official 330:c80ac197fa6a 373
mbed_official 330:c80ac197fa6a 374 /**
mbed_official 330:c80ac197fa6a 375 * @brief Initializes the SDADC MSP.
mbed_official 330:c80ac197fa6a 376 * @param hsdadc : SDADC handle
mbed_official 330:c80ac197fa6a 377 * @retval None
mbed_official 330:c80ac197fa6a 378 */
mbed_official 330:c80ac197fa6a 379 __weak void HAL_SDADC_MspInit(SDADC_HandleTypeDef* hsdadc)
mbed_official 330:c80ac197fa6a 380 {
mbed_official 330:c80ac197fa6a 381 /* NOTE : This function should not be modified, when the callback is needed,
mbed_official 330:c80ac197fa6a 382 the HAL_SDADC_MspInit could be implemented in the user file.
mbed_official 330:c80ac197fa6a 383 */
mbed_official 330:c80ac197fa6a 384 }
mbed_official 330:c80ac197fa6a 385
mbed_official 330:c80ac197fa6a 386 /**
mbed_official 330:c80ac197fa6a 387 * @brief De-initializes the SDADC MSP.
mbed_official 330:c80ac197fa6a 388 * @param hsdadc : SDADC handle
mbed_official 330:c80ac197fa6a 389 * @retval None
mbed_official 330:c80ac197fa6a 390 */
mbed_official 330:c80ac197fa6a 391 __weak void HAL_SDADC_MspDeInit(SDADC_HandleTypeDef* hsdadc)
mbed_official 330:c80ac197fa6a 392 {
mbed_official 330:c80ac197fa6a 393 /* NOTE : This function should not be modified, when the callback is needed,
mbed_official 330:c80ac197fa6a 394 the HAL_SDADC_MspDeInit could be implemented in the user file.
mbed_official 330:c80ac197fa6a 395 */
mbed_official 330:c80ac197fa6a 396 }
mbed_official 330:c80ac197fa6a 397
mbed_official 330:c80ac197fa6a 398 /**
mbed_official 330:c80ac197fa6a 399 * @}
mbed_official 330:c80ac197fa6a 400 */
mbed_official 330:c80ac197fa6a 401
mbed_official 330:c80ac197fa6a 402 /** @defgroup SDADC_Exported_Functions_Group2 peripheral control functions
mbed_official 330:c80ac197fa6a 403 * @brief Peripheral control functions
mbed_official 330:c80ac197fa6a 404 *
mbed_official 330:c80ac197fa6a 405 @verbatim
mbed_official 330:c80ac197fa6a 406 ===============================================================================
mbed_official 330:c80ac197fa6a 407 ##### Peripheral control functions #####
mbed_official 330:c80ac197fa6a 408 ===============================================================================
mbed_official 330:c80ac197fa6a 409 [..] This section provides functions allowing to:
mbed_official 330:c80ac197fa6a 410 (+) Program on of the three different configurations for channels.
mbed_official 330:c80ac197fa6a 411 (+) Associate channel to one of configurations.
mbed_official 330:c80ac197fa6a 412 (+) Select regular and injected channels.
mbed_official 330:c80ac197fa6a 413 (+) Enable/disable continuous mode for regular and injected conversions.
mbed_official 330:c80ac197fa6a 414 (+) Select regular and injected triggers.
mbed_official 330:c80ac197fa6a 415 (+) Select and configure injected external trigger.
mbed_official 330:c80ac197fa6a 416 (+) Enable/disable delay addition for injected conversions.
mbed_official 330:c80ac197fa6a 417 (+) Configure multimode.
mbed_official 330:c80ac197fa6a 418
mbed_official 330:c80ac197fa6a 419 @endverbatim
mbed_official 330:c80ac197fa6a 420 * @{
mbed_official 330:c80ac197fa6a 421 */
mbed_official 330:c80ac197fa6a 422
mbed_official 330:c80ac197fa6a 423 /**
mbed_official 330:c80ac197fa6a 424 * @brief This function allows the user to set parameters for a configuration.
mbed_official 330:c80ac197fa6a 425 * Parameters are input mode, common mode, gain and offset.
mbed_official 330:c80ac197fa6a 426 * @note This function should be called only when SDADC instance is in idle state
mbed_official 330:c80ac197fa6a 427 * (neither calibration nor regular or injected conversion ongoing)
mbed_official 330:c80ac197fa6a 428 * @param hsdadc : SDADC handle.
mbed_official 330:c80ac197fa6a 429 * @param ConfIndex : Index of configuration to modify.
mbed_official 330:c80ac197fa6a 430 * This parameter can be a value of @ref SDADC_ConfIndex.
mbed_official 330:c80ac197fa6a 431 * @param ConfParamStruct : Parameters to apply for this configuration.
mbed_official 330:c80ac197fa6a 432 * @retval HAL status
mbed_official 330:c80ac197fa6a 433 */
mbed_official 330:c80ac197fa6a 434 HAL_StatusTypeDef HAL_SDADC_PrepareChannelConfig(SDADC_HandleTypeDef *hsdadc,
mbed_official 330:c80ac197fa6a 435 uint32_t ConfIndex,
mbed_official 330:c80ac197fa6a 436 SDADC_ConfParamTypeDef* ConfParamStruct)
mbed_official 330:c80ac197fa6a 437 {
mbed_official 330:c80ac197fa6a 438 HAL_StatusTypeDef status = HAL_OK;
mbed_official 330:c80ac197fa6a 439 uint32_t tmp = 0;
mbed_official 330:c80ac197fa6a 440
mbed_official 330:c80ac197fa6a 441 /* Check parameters */
mbed_official 330:c80ac197fa6a 442 assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance));
mbed_official 330:c80ac197fa6a 443 assert_param(IS_SDADC_CONF_INDEX(ConfIndex));
mbed_official 634:ac7d6880524d 444 assert_param(ConfParamStruct != HAL_NULL);
mbed_official 330:c80ac197fa6a 445 assert_param(IS_SDADC_INPUT_MODE(ConfParamStruct->InputMode));
mbed_official 330:c80ac197fa6a 446 assert_param(IS_SDADC_GAIN(ConfParamStruct->Gain));
mbed_official 330:c80ac197fa6a 447 assert_param(IS_SDADC_COMMON_MODE(ConfParamStruct->CommonMode));
mbed_official 330:c80ac197fa6a 448 assert_param(IS_SDADC_OFFSET_VALUE(ConfParamStruct->Offset));
mbed_official 330:c80ac197fa6a 449
mbed_official 330:c80ac197fa6a 450 /* Check SDADC state is ready */
mbed_official 330:c80ac197fa6a 451 if(hsdadc->State != HAL_SDADC_STATE_READY)
mbed_official 330:c80ac197fa6a 452 {
mbed_official 330:c80ac197fa6a 453 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 454 }
mbed_official 330:c80ac197fa6a 455 else
mbed_official 330:c80ac197fa6a 456 {
mbed_official 330:c80ac197fa6a 457 /* Enter init mode */
mbed_official 330:c80ac197fa6a 458 if(SDADC_EnterInitMode(hsdadc) != HAL_OK)
mbed_official 330:c80ac197fa6a 459 {
mbed_official 330:c80ac197fa6a 460 /* Set SDADC in error state */
mbed_official 330:c80ac197fa6a 461 hsdadc->State = HAL_SDADC_STATE_ERROR;
mbed_official 330:c80ac197fa6a 462 status = HAL_TIMEOUT;
mbed_official 330:c80ac197fa6a 463 }
mbed_official 330:c80ac197fa6a 464 else
mbed_official 330:c80ac197fa6a 465 {
mbed_official 330:c80ac197fa6a 466 /* Program configuration register with parameters */
mbed_official 330:c80ac197fa6a 467 tmp = (uint32_t)((uint32_t)(hsdadc->Instance) + \
mbed_official 330:c80ac197fa6a 468 SDADC_CONFREG_OFFSET + \
mbed_official 330:c80ac197fa6a 469 (uint32_t)(ConfIndex << 2));
mbed_official 330:c80ac197fa6a 470 *(__IO uint32_t *) (tmp) = (uint32_t) (ConfParamStruct->InputMode | \
mbed_official 330:c80ac197fa6a 471 ConfParamStruct->Gain | \
mbed_official 330:c80ac197fa6a 472 ConfParamStruct->CommonMode | \
mbed_official 330:c80ac197fa6a 473 ConfParamStruct->Offset);
mbed_official 330:c80ac197fa6a 474 /* Exit init mode */
mbed_official 330:c80ac197fa6a 475 SDADC_ExitInitMode(hsdadc);
mbed_official 330:c80ac197fa6a 476 }
mbed_official 330:c80ac197fa6a 477 }
mbed_official 330:c80ac197fa6a 478 /* Return function status */
mbed_official 330:c80ac197fa6a 479 return status;
mbed_official 330:c80ac197fa6a 480 }
mbed_official 330:c80ac197fa6a 481
mbed_official 330:c80ac197fa6a 482 /**
mbed_official 330:c80ac197fa6a 483 * @brief This function allows the user to associate a channel with one of the
mbed_official 330:c80ac197fa6a 484 * available configurations.
mbed_official 330:c80ac197fa6a 485 * @note This function should be called only when SDADC instance is in idle state
mbed_official 330:c80ac197fa6a 486 * (neither calibration nor regular or injected conversion ongoing)
mbed_official 330:c80ac197fa6a 487 * @param hsdadc : SDADC handle.
mbed_official 330:c80ac197fa6a 488 * @param Channel : Channel to associate with configuration.
mbed_official 330:c80ac197fa6a 489 * This parameter can be a value of @ref SDADC_Channel_Selection.
mbed_official 330:c80ac197fa6a 490 * @param ConfIndex : Index of configuration to associate with channel.
mbed_official 330:c80ac197fa6a 491 * This parameter can be a value of @ref SDADC_ConfIndex.
mbed_official 330:c80ac197fa6a 492 * @retval HAL status
mbed_official 330:c80ac197fa6a 493 */
mbed_official 330:c80ac197fa6a 494 HAL_StatusTypeDef HAL_SDADC_AssociateChannelConfig(SDADC_HandleTypeDef *hsdadc,
mbed_official 330:c80ac197fa6a 495 uint32_t Channel,
mbed_official 330:c80ac197fa6a 496 uint32_t ConfIndex)
mbed_official 330:c80ac197fa6a 497 {
mbed_official 330:c80ac197fa6a 498 HAL_StatusTypeDef status = HAL_OK;
mbed_official 330:c80ac197fa6a 499 uint32_t channelnum = 0;
mbed_official 330:c80ac197fa6a 500
mbed_official 330:c80ac197fa6a 501 /* Check parameters */
mbed_official 330:c80ac197fa6a 502 assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance));
mbed_official 330:c80ac197fa6a 503 assert_param(IS_SDADC_REGULAR_CHANNEL(Channel));
mbed_official 330:c80ac197fa6a 504 assert_param(IS_SDADC_CONF_INDEX(ConfIndex));
mbed_official 330:c80ac197fa6a 505
mbed_official 330:c80ac197fa6a 506 /* Check SDADC state is ready */
mbed_official 330:c80ac197fa6a 507 if(hsdadc->State != HAL_SDADC_STATE_READY)
mbed_official 330:c80ac197fa6a 508 {
mbed_official 330:c80ac197fa6a 509 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 510 }
mbed_official 330:c80ac197fa6a 511 else
mbed_official 330:c80ac197fa6a 512 {
mbed_official 330:c80ac197fa6a 513 /* Enter init mode */
mbed_official 330:c80ac197fa6a 514 if(SDADC_EnterInitMode(hsdadc) != HAL_OK)
mbed_official 330:c80ac197fa6a 515 {
mbed_official 330:c80ac197fa6a 516 /* Set SDADC in error state */
mbed_official 330:c80ac197fa6a 517 hsdadc->State = HAL_SDADC_STATE_ERROR;
mbed_official 330:c80ac197fa6a 518 status = HAL_TIMEOUT;
mbed_official 330:c80ac197fa6a 519 }
mbed_official 330:c80ac197fa6a 520 else
mbed_official 330:c80ac197fa6a 521 {
mbed_official 330:c80ac197fa6a 522 /* Program channel configuration register according parameters */
mbed_official 330:c80ac197fa6a 523 if(Channel != SDADC_CHANNEL_8)
mbed_official 330:c80ac197fa6a 524 {
mbed_official 330:c80ac197fa6a 525 /* Get channel number */
mbed_official 330:c80ac197fa6a 526 channelnum = (uint32_t)(Channel>>16);
mbed_official 330:c80ac197fa6a 527
mbed_official 330:c80ac197fa6a 528 /* Set the channel configuration */
mbed_official 330:c80ac197fa6a 529 hsdadc->Instance->CONFCHR1 &= (uint32_t) ~(SDADC_CONFCHR1_CONFCH0 << (channelnum << 2));
mbed_official 330:c80ac197fa6a 530 hsdadc->Instance->CONFCHR1 |= (uint32_t) (ConfIndex << (channelnum << 2));
mbed_official 330:c80ac197fa6a 531 }
mbed_official 330:c80ac197fa6a 532 else
mbed_official 330:c80ac197fa6a 533 {
mbed_official 330:c80ac197fa6a 534 hsdadc->Instance->CONFCHR2 = (uint32_t) (ConfIndex);
mbed_official 330:c80ac197fa6a 535 }
mbed_official 330:c80ac197fa6a 536 /* Exit init mode */
mbed_official 330:c80ac197fa6a 537 SDADC_ExitInitMode(hsdadc);
mbed_official 330:c80ac197fa6a 538 }
mbed_official 330:c80ac197fa6a 539 }
mbed_official 330:c80ac197fa6a 540 /* Return function status */
mbed_official 330:c80ac197fa6a 541 return status;
mbed_official 330:c80ac197fa6a 542 }
mbed_official 330:c80ac197fa6a 543
mbed_official 330:c80ac197fa6a 544 /**
mbed_official 330:c80ac197fa6a 545 * @brief This function allows to select channel for regular conversion and
mbed_official 330:c80ac197fa6a 546 * to enable/disable continuous mode for regular conversion.
mbed_official 330:c80ac197fa6a 547 * @param hsdadc : SDADC handle.
mbed_official 330:c80ac197fa6a 548 * @param Channel : Channel for regular conversion.
mbed_official 330:c80ac197fa6a 549 * This parameter can be a value of @ref SDADC_Channel_Selection.
mbed_official 330:c80ac197fa6a 550 * @param ContinuousMode : Enable/disable continuous mode for regular conversion.
mbed_official 330:c80ac197fa6a 551 * This parameter can be a value of @ref SDADC_ContinuousMode.
mbed_official 330:c80ac197fa6a 552 * @retval HAL status
mbed_official 330:c80ac197fa6a 553 */
mbed_official 330:c80ac197fa6a 554 HAL_StatusTypeDef HAL_SDADC_ConfigChannel(SDADC_HandleTypeDef *hsdadc,
mbed_official 330:c80ac197fa6a 555 uint32_t Channel,
mbed_official 330:c80ac197fa6a 556 uint32_t ContinuousMode)
mbed_official 330:c80ac197fa6a 557 {
mbed_official 330:c80ac197fa6a 558 HAL_StatusTypeDef status = HAL_OK;
mbed_official 330:c80ac197fa6a 559
mbed_official 330:c80ac197fa6a 560 /* Check parameters */
mbed_official 330:c80ac197fa6a 561 assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance));
mbed_official 330:c80ac197fa6a 562 assert_param(IS_SDADC_REGULAR_CHANNEL(Channel));
mbed_official 330:c80ac197fa6a 563 assert_param(IS_SDADC_CONTINUOUS_MODE(ContinuousMode));
mbed_official 330:c80ac197fa6a 564
mbed_official 330:c80ac197fa6a 565 /* Check SDADC state */
mbed_official 330:c80ac197fa6a 566 if((hsdadc->State != HAL_SDADC_STATE_RESET) && (hsdadc->State != HAL_SDADC_STATE_ERROR))
mbed_official 330:c80ac197fa6a 567 {
mbed_official 330:c80ac197fa6a 568 /* Set RCH[3:0] and RCONT bits in SDADC_CR2 */
mbed_official 330:c80ac197fa6a 569 hsdadc->Instance->CR2 &= (uint32_t) ~(SDADC_CR2_RCH | SDADC_CR2_RCONT);
mbed_official 330:c80ac197fa6a 570 if(ContinuousMode == SDADC_CONTINUOUS_CONV_ON)
mbed_official 330:c80ac197fa6a 571 {
mbed_official 330:c80ac197fa6a 572 hsdadc->Instance->CR2 |= (uint32_t) ((Channel & SDADC_MSB_MASK) | SDADC_CR2_RCONT);
mbed_official 330:c80ac197fa6a 573 }
mbed_official 330:c80ac197fa6a 574 else
mbed_official 330:c80ac197fa6a 575 {
mbed_official 330:c80ac197fa6a 576 hsdadc->Instance->CR2 |= (uint32_t) ((Channel & SDADC_MSB_MASK));
mbed_official 330:c80ac197fa6a 577 }
mbed_official 330:c80ac197fa6a 578 /* Store continuous mode information */
mbed_official 330:c80ac197fa6a 579 hsdadc->RegularContMode = ContinuousMode;
mbed_official 330:c80ac197fa6a 580 }
mbed_official 330:c80ac197fa6a 581 else
mbed_official 330:c80ac197fa6a 582 {
mbed_official 330:c80ac197fa6a 583 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 584 }
mbed_official 330:c80ac197fa6a 585 /* Return function status */
mbed_official 330:c80ac197fa6a 586 return status;
mbed_official 330:c80ac197fa6a 587 }
mbed_official 330:c80ac197fa6a 588
mbed_official 330:c80ac197fa6a 589 /**
mbed_official 330:c80ac197fa6a 590 * @brief This function allows to select channels for injected conversion and
mbed_official 330:c80ac197fa6a 591 * to enable/disable continuous mode for injected conversion.
mbed_official 330:c80ac197fa6a 592 * @param hsdadc : SDADC handle.
mbed_official 330:c80ac197fa6a 593 * @param Channel : Channels for injected conversion.
mbed_official 330:c80ac197fa6a 594 * This parameter can be a values combination of @ref SDADC_Channel_Selection.
mbed_official 330:c80ac197fa6a 595 * @param ContinuousMode : Enable/disable continuous mode for injected conversion.
mbed_official 330:c80ac197fa6a 596 * This parameter can be a value of @ref SDADC_ContinuousMode.
mbed_official 330:c80ac197fa6a 597 * @retval HAL status
mbed_official 330:c80ac197fa6a 598 */
mbed_official 330:c80ac197fa6a 599 HAL_StatusTypeDef HAL_SDADC_InjectedConfigChannel(SDADC_HandleTypeDef *hsdadc,
mbed_official 330:c80ac197fa6a 600 uint32_t Channel,
mbed_official 330:c80ac197fa6a 601 uint32_t ContinuousMode)
mbed_official 330:c80ac197fa6a 602 {
mbed_official 330:c80ac197fa6a 603 HAL_StatusTypeDef status = HAL_OK;
mbed_official 330:c80ac197fa6a 604
mbed_official 330:c80ac197fa6a 605 /* Check parameters */
mbed_official 330:c80ac197fa6a 606 assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance));
mbed_official 330:c80ac197fa6a 607 assert_param(IS_SDADC_INJECTED_CHANNEL(Channel));
mbed_official 330:c80ac197fa6a 608 assert_param(IS_SDADC_CONTINUOUS_MODE(ContinuousMode));
mbed_official 330:c80ac197fa6a 609
mbed_official 330:c80ac197fa6a 610 /* Check SDADC state */
mbed_official 330:c80ac197fa6a 611 if((hsdadc->State != HAL_SDADC_STATE_RESET) && (hsdadc->State != HAL_SDADC_STATE_ERROR))
mbed_official 330:c80ac197fa6a 612 {
mbed_official 330:c80ac197fa6a 613 /* Set JCHG[8:0] bits in SDADC_JCHG */
mbed_official 330:c80ac197fa6a 614 hsdadc->Instance->JCHGR = (uint32_t) (Channel & SDADC_LSB_MASK);
mbed_official 330:c80ac197fa6a 615 /* Set or clear JCONT bit in SDADC_CR2 */
mbed_official 330:c80ac197fa6a 616 if(ContinuousMode == SDADC_CONTINUOUS_CONV_ON)
mbed_official 330:c80ac197fa6a 617 {
mbed_official 330:c80ac197fa6a 618 hsdadc->Instance->CR2 |= SDADC_CR2_JCONT;
mbed_official 330:c80ac197fa6a 619 }
mbed_official 330:c80ac197fa6a 620 else
mbed_official 330:c80ac197fa6a 621 {
mbed_official 330:c80ac197fa6a 622 hsdadc->Instance->CR2 &= ~(SDADC_CR2_JCONT);
mbed_official 330:c80ac197fa6a 623 }
mbed_official 330:c80ac197fa6a 624 /* Store continuous mode information */
mbed_official 330:c80ac197fa6a 625 hsdadc->InjectedContMode = ContinuousMode;
mbed_official 330:c80ac197fa6a 626 /* Store number of injected channels */
mbed_official 330:c80ac197fa6a 627 hsdadc->InjectedChannelsNbr = SDADC_GetInjChannelsNbr(Channel);
mbed_official 330:c80ac197fa6a 628 }
mbed_official 330:c80ac197fa6a 629 else
mbed_official 330:c80ac197fa6a 630 {
mbed_official 330:c80ac197fa6a 631 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 632 }
mbed_official 330:c80ac197fa6a 633 /* Return function status */
mbed_official 330:c80ac197fa6a 634 return status;
mbed_official 330:c80ac197fa6a 635 }
mbed_official 330:c80ac197fa6a 636
mbed_official 330:c80ac197fa6a 637 /**
mbed_official 330:c80ac197fa6a 638 * @brief This function allows to select trigger for regular conversions.
mbed_official 330:c80ac197fa6a 639 * @note This function should not be called if regular conversion is ongoing.
mbed_official 330:c80ac197fa6a 640 * @param hsdadc : SDADC handle.
mbed_official 330:c80ac197fa6a 641 * @param Trigger : Trigger for regular conversions.
mbed_official 330:c80ac197fa6a 642 * This parameter can be one of the following value :
mbed_official 330:c80ac197fa6a 643 * @arg SDADC_SOFTWARE_TRIGGER : Software trigger.
mbed_official 330:c80ac197fa6a 644 * @arg SDADC_SYNCHRONOUS_TRIGGER : Synchronous with SDADC1 (only for SDADC2 and SDADC3).
mbed_official 330:c80ac197fa6a 645 * @retval HAL status
mbed_official 330:c80ac197fa6a 646 */
mbed_official 330:c80ac197fa6a 647 HAL_StatusTypeDef HAL_SDADC_SelectRegularTrigger(SDADC_HandleTypeDef *hsdadc, uint32_t Trigger)
mbed_official 330:c80ac197fa6a 648 {
mbed_official 330:c80ac197fa6a 649 HAL_StatusTypeDef status = HAL_OK;
mbed_official 330:c80ac197fa6a 650
mbed_official 330:c80ac197fa6a 651 /* Check parameters */
mbed_official 330:c80ac197fa6a 652 assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance));
mbed_official 330:c80ac197fa6a 653 assert_param(IS_SDADC_REGULAR_TRIGGER(Trigger));
mbed_official 330:c80ac197fa6a 654
mbed_official 330:c80ac197fa6a 655 /* Check parameters compatibility */
mbed_official 330:c80ac197fa6a 656 if((hsdadc->Instance == SDADC1) && (Trigger == SDADC_SYNCHRONOUS_TRIGGER))
mbed_official 330:c80ac197fa6a 657 {
mbed_official 330:c80ac197fa6a 658 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 659 }
mbed_official 330:c80ac197fa6a 660 /* Check SDADC state */
mbed_official 330:c80ac197fa6a 661 else if((hsdadc->State == HAL_SDADC_STATE_READY) || \
mbed_official 330:c80ac197fa6a 662 (hsdadc->State == HAL_SDADC_STATE_CALIB) || \
mbed_official 330:c80ac197fa6a 663 (hsdadc->State == HAL_SDADC_STATE_INJ))
mbed_official 330:c80ac197fa6a 664 {
mbed_official 330:c80ac197fa6a 665 /* Store regular trigger information */
mbed_official 330:c80ac197fa6a 666 hsdadc->RegularTrigger = Trigger;
mbed_official 330:c80ac197fa6a 667 }
mbed_official 330:c80ac197fa6a 668 else
mbed_official 330:c80ac197fa6a 669 {
mbed_official 330:c80ac197fa6a 670 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 671 }
mbed_official 330:c80ac197fa6a 672 /* Return function status */
mbed_official 330:c80ac197fa6a 673 return status;
mbed_official 330:c80ac197fa6a 674 }
mbed_official 330:c80ac197fa6a 675
mbed_official 330:c80ac197fa6a 676 /**
mbed_official 330:c80ac197fa6a 677 * @brief This function allows to select trigger for injected conversions.
mbed_official 330:c80ac197fa6a 678 * @note This function should not be called if injected conversion is ongoing.
mbed_official 330:c80ac197fa6a 679 * @param hsdadc : SDADC handle.
mbed_official 330:c80ac197fa6a 680 * @param Trigger : Trigger for injected conversions.
mbed_official 330:c80ac197fa6a 681 * This parameter can be one of the following value :
mbed_official 330:c80ac197fa6a 682 * @arg SDADC_SOFTWARE_TRIGGER : Software trigger.
mbed_official 330:c80ac197fa6a 683 * @arg SDADC_SYNCHRONOUS_TRIGGER : Synchronous with SDADC1 (only for SDADC2 and SDADC3).
mbed_official 330:c80ac197fa6a 684 * @arg SDADC_EXTERNAL_TRIGGER : External trigger.
mbed_official 330:c80ac197fa6a 685 * @retval HAL status
mbed_official 330:c80ac197fa6a 686 */
mbed_official 330:c80ac197fa6a 687 HAL_StatusTypeDef HAL_SDADC_SelectInjectedTrigger(SDADC_HandleTypeDef *hsdadc, uint32_t Trigger)
mbed_official 330:c80ac197fa6a 688 {
mbed_official 330:c80ac197fa6a 689 HAL_StatusTypeDef status = HAL_OK;
mbed_official 330:c80ac197fa6a 690
mbed_official 330:c80ac197fa6a 691 /* Check parameters */
mbed_official 330:c80ac197fa6a 692 assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance));
mbed_official 330:c80ac197fa6a 693 assert_param(IS_SDADC_INJECTED_TRIGGER(Trigger));
mbed_official 330:c80ac197fa6a 694
mbed_official 330:c80ac197fa6a 695 /* Check parameters compatibility */
mbed_official 330:c80ac197fa6a 696 if((hsdadc->Instance == SDADC1) && (Trigger == SDADC_SYNCHRONOUS_TRIGGER))
mbed_official 330:c80ac197fa6a 697 {
mbed_official 330:c80ac197fa6a 698 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 699 }
mbed_official 330:c80ac197fa6a 700 /* Check SDADC state */
mbed_official 330:c80ac197fa6a 701 else if((hsdadc->State == HAL_SDADC_STATE_READY) || \
mbed_official 330:c80ac197fa6a 702 (hsdadc->State == HAL_SDADC_STATE_CALIB) || \
mbed_official 330:c80ac197fa6a 703 (hsdadc->State == HAL_SDADC_STATE_REG))
mbed_official 330:c80ac197fa6a 704 {
mbed_official 330:c80ac197fa6a 705 /* Store regular trigger information */
mbed_official 330:c80ac197fa6a 706 hsdadc->InjectedTrigger = Trigger;
mbed_official 330:c80ac197fa6a 707 }
mbed_official 330:c80ac197fa6a 708 else
mbed_official 330:c80ac197fa6a 709 {
mbed_official 330:c80ac197fa6a 710 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 711 }
mbed_official 330:c80ac197fa6a 712 /* Return function status */
mbed_official 330:c80ac197fa6a 713 return status;
mbed_official 330:c80ac197fa6a 714 }
mbed_official 330:c80ac197fa6a 715
mbed_official 330:c80ac197fa6a 716 /**
mbed_official 330:c80ac197fa6a 717 * @brief This function allows to select and configure injected external trigger.
mbed_official 330:c80ac197fa6a 718 * @note This function should be called only when SDADC instance is in idle state
mbed_official 330:c80ac197fa6a 719 * (neither calibration nor regular or injected conversion ongoing)
mbed_official 330:c80ac197fa6a 720 * @param hsdadc : SDADC handle.
mbed_official 330:c80ac197fa6a 721 * @param InjectedExtTrigger : External trigger for injected conversions.
mbed_official 330:c80ac197fa6a 722 * This parameter can be a value of @ref SDADC_InjectedExtTrigger.
mbed_official 330:c80ac197fa6a 723 * @param ExtTriggerEdge : Edge of external injected trigger.
mbed_official 330:c80ac197fa6a 724 * This parameter can be a value of @ref SDADC_ExtTriggerEdge.
mbed_official 330:c80ac197fa6a 725 * @retval HAL status
mbed_official 330:c80ac197fa6a 726 */
mbed_official 330:c80ac197fa6a 727 HAL_StatusTypeDef HAL_SDADC_SelectInjectedExtTrigger(SDADC_HandleTypeDef *hsdadc,
mbed_official 330:c80ac197fa6a 728 uint32_t InjectedExtTrigger,
mbed_official 330:c80ac197fa6a 729 uint32_t ExtTriggerEdge)
mbed_official 330:c80ac197fa6a 730 {
mbed_official 330:c80ac197fa6a 731 HAL_StatusTypeDef status = HAL_OK;
mbed_official 330:c80ac197fa6a 732
mbed_official 330:c80ac197fa6a 733 /* Check parameters */
mbed_official 330:c80ac197fa6a 734 assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance));
mbed_official 330:c80ac197fa6a 735 assert_param(IS_SDADC_EXT_INJEC_TRIG(InjectedExtTrigger));
mbed_official 330:c80ac197fa6a 736 assert_param(IS_SDADC_EXT_TRIG_EDGE(ExtTriggerEdge));
mbed_official 330:c80ac197fa6a 737
mbed_official 330:c80ac197fa6a 738 /* Check SDADC state */
mbed_official 330:c80ac197fa6a 739 if(hsdadc->State == HAL_SDADC_STATE_READY)
mbed_official 330:c80ac197fa6a 740 {
mbed_official 330:c80ac197fa6a 741 /* Enter init mode */
mbed_official 330:c80ac197fa6a 742 if(SDADC_EnterInitMode(hsdadc) != HAL_OK)
mbed_official 330:c80ac197fa6a 743 {
mbed_official 330:c80ac197fa6a 744 /* Set SDADC in error state */
mbed_official 330:c80ac197fa6a 745 hsdadc->State = HAL_SDADC_STATE_ERROR;
mbed_official 330:c80ac197fa6a 746 status = HAL_TIMEOUT;
mbed_official 330:c80ac197fa6a 747 }
mbed_official 330:c80ac197fa6a 748 else
mbed_official 330:c80ac197fa6a 749 {
mbed_official 330:c80ac197fa6a 750 /* Set JEXTSEL[2:0] bits in SDADC_CR2 register */
mbed_official 330:c80ac197fa6a 751 hsdadc->Instance->CR2 &= ~(SDADC_CR2_JEXTSEL);
mbed_official 330:c80ac197fa6a 752 hsdadc->Instance->CR2 |= InjectedExtTrigger;
mbed_official 330:c80ac197fa6a 753
mbed_official 330:c80ac197fa6a 754 /* Store external trigger edge information */
mbed_official 330:c80ac197fa6a 755 hsdadc->ExtTriggerEdge = ExtTriggerEdge;
mbed_official 330:c80ac197fa6a 756
mbed_official 330:c80ac197fa6a 757 /* Exit init mode */
mbed_official 330:c80ac197fa6a 758 SDADC_ExitInitMode(hsdadc);
mbed_official 330:c80ac197fa6a 759 }
mbed_official 330:c80ac197fa6a 760 }
mbed_official 330:c80ac197fa6a 761 else
mbed_official 330:c80ac197fa6a 762 {
mbed_official 330:c80ac197fa6a 763 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 764 }
mbed_official 330:c80ac197fa6a 765 /* Return function status */
mbed_official 330:c80ac197fa6a 766 return status;
mbed_official 330:c80ac197fa6a 767 }
mbed_official 330:c80ac197fa6a 768
mbed_official 330:c80ac197fa6a 769 /**
mbed_official 330:c80ac197fa6a 770 * @brief This function allows to enable/disable delay addition for injected conversions.
mbed_official 330:c80ac197fa6a 771 * @note This function should be called only when SDADC instance is in idle state
mbed_official 330:c80ac197fa6a 772 * (neither calibration nor regular or injected conversion ongoing)
mbed_official 330:c80ac197fa6a 773 * @param hsdadc : SDADC handle.
mbed_official 330:c80ac197fa6a 774 * @param InjectedDelay : Enable/disable delay for injected conversions.
mbed_official 330:c80ac197fa6a 775 * This parameter can be a value of @ref SDADC_InjectedDelay.
mbed_official 330:c80ac197fa6a 776 * @retval HAL status
mbed_official 330:c80ac197fa6a 777 */
mbed_official 330:c80ac197fa6a 778 HAL_StatusTypeDef HAL_SDADC_SelectInjectedDelay(SDADC_HandleTypeDef *hsdadc,
mbed_official 330:c80ac197fa6a 779 uint32_t InjectedDelay)
mbed_official 330:c80ac197fa6a 780 {
mbed_official 330:c80ac197fa6a 781 HAL_StatusTypeDef status = HAL_OK;
mbed_official 330:c80ac197fa6a 782
mbed_official 330:c80ac197fa6a 783 /* Check parameters */
mbed_official 330:c80ac197fa6a 784 assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance));
mbed_official 330:c80ac197fa6a 785 assert_param(IS_SDADC_INJECTED_DELAY(InjectedDelay));
mbed_official 330:c80ac197fa6a 786
mbed_official 330:c80ac197fa6a 787 /* Check SDADC state */
mbed_official 330:c80ac197fa6a 788 if(hsdadc->State == HAL_SDADC_STATE_READY)
mbed_official 330:c80ac197fa6a 789 {
mbed_official 330:c80ac197fa6a 790 /* Enter init mode */
mbed_official 330:c80ac197fa6a 791 if(SDADC_EnterInitMode(hsdadc) != HAL_OK)
mbed_official 330:c80ac197fa6a 792 {
mbed_official 330:c80ac197fa6a 793 /* Set SDADC in error state */
mbed_official 330:c80ac197fa6a 794 hsdadc->State = HAL_SDADC_STATE_ERROR;
mbed_official 330:c80ac197fa6a 795 status = HAL_TIMEOUT;
mbed_official 330:c80ac197fa6a 796 }
mbed_official 330:c80ac197fa6a 797 else
mbed_official 330:c80ac197fa6a 798 {
mbed_official 330:c80ac197fa6a 799 /* Set JDS bit in SDADC_CR2 register */
mbed_official 330:c80ac197fa6a 800 hsdadc->Instance->CR2 &= ~(SDADC_CR2_JDS);
mbed_official 330:c80ac197fa6a 801 hsdadc->Instance->CR2 |= InjectedDelay;
mbed_official 330:c80ac197fa6a 802
mbed_official 330:c80ac197fa6a 803 /* Exit init mode */
mbed_official 330:c80ac197fa6a 804 SDADC_ExitInitMode(hsdadc);
mbed_official 330:c80ac197fa6a 805 }
mbed_official 330:c80ac197fa6a 806 }
mbed_official 330:c80ac197fa6a 807 else
mbed_official 330:c80ac197fa6a 808 {
mbed_official 330:c80ac197fa6a 809 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 810 }
mbed_official 330:c80ac197fa6a 811 /* Return function status */
mbed_official 330:c80ac197fa6a 812 return status;
mbed_official 330:c80ac197fa6a 813 }
mbed_official 330:c80ac197fa6a 814
mbed_official 330:c80ac197fa6a 815 /**
mbed_official 330:c80ac197fa6a 816 * @brief This function allows to configure multimode for regular conversions.
mbed_official 330:c80ac197fa6a 817 * @note This function should not be called if regular conversion is ongoing
mbed_official 330:c80ac197fa6a 818 * and should be could only for SDADC1.
mbed_official 330:c80ac197fa6a 819 * @param hsdadc : SDADC handle.
mbed_official 330:c80ac197fa6a 820 * @param MultimodeType : Type of multimode for regular conversions.
mbed_official 330:c80ac197fa6a 821 * This parameter can be a value of @ref SDADC_MultimodeType.
mbed_official 330:c80ac197fa6a 822 * @retval HAL status
mbed_official 330:c80ac197fa6a 823 */
mbed_official 330:c80ac197fa6a 824 HAL_StatusTypeDef HAL_SDADC_MultiModeConfigChannel(SDADC_HandleTypeDef* hsdadc,
mbed_official 330:c80ac197fa6a 825 uint32_t MultimodeType)
mbed_official 330:c80ac197fa6a 826 {
mbed_official 330:c80ac197fa6a 827 HAL_StatusTypeDef status = HAL_OK;
mbed_official 330:c80ac197fa6a 828
mbed_official 330:c80ac197fa6a 829 /* Check parameters */
mbed_official 330:c80ac197fa6a 830 assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance));
mbed_official 330:c80ac197fa6a 831 assert_param(IS_SDADC_MULTIMODE_TYPE(MultimodeType));
mbed_official 330:c80ac197fa6a 832
mbed_official 330:c80ac197fa6a 833 /* Check instance is SDADC1 */
mbed_official 330:c80ac197fa6a 834 if(hsdadc->Instance != SDADC1)
mbed_official 330:c80ac197fa6a 835 {
mbed_official 330:c80ac197fa6a 836 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 837 }
mbed_official 330:c80ac197fa6a 838 /* Check SDADC state */
mbed_official 330:c80ac197fa6a 839 else if((hsdadc->State == HAL_SDADC_STATE_READY) || \
mbed_official 330:c80ac197fa6a 840 (hsdadc->State == HAL_SDADC_STATE_CALIB) || \
mbed_official 330:c80ac197fa6a 841 (hsdadc->State == HAL_SDADC_STATE_INJ))
mbed_official 330:c80ac197fa6a 842 {
mbed_official 330:c80ac197fa6a 843 /* Store regular trigger information */
mbed_official 330:c80ac197fa6a 844 hsdadc->RegularMultimode = MultimodeType;
mbed_official 330:c80ac197fa6a 845 }
mbed_official 330:c80ac197fa6a 846 else
mbed_official 330:c80ac197fa6a 847 {
mbed_official 330:c80ac197fa6a 848 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 849 }
mbed_official 330:c80ac197fa6a 850 /* Return function status */
mbed_official 330:c80ac197fa6a 851 return status;
mbed_official 330:c80ac197fa6a 852 }
mbed_official 330:c80ac197fa6a 853
mbed_official 330:c80ac197fa6a 854 /**
mbed_official 330:c80ac197fa6a 855 * @brief This function allows to configure multimode for injected conversions.
mbed_official 330:c80ac197fa6a 856 * @note This function should not be called if injected conversion is ongoing
mbed_official 330:c80ac197fa6a 857 * and should be could only for SDADC1.
mbed_official 330:c80ac197fa6a 858 * @param hsdadc : SDADC handle.
mbed_official 330:c80ac197fa6a 859 * @param MultimodeType : Type of multimode for injected conversions.
mbed_official 330:c80ac197fa6a 860 * This parameter can be a value of @ref SDADC_MultimodeType.
mbed_official 330:c80ac197fa6a 861 * @retval HAL status
mbed_official 330:c80ac197fa6a 862 */
mbed_official 330:c80ac197fa6a 863 HAL_StatusTypeDef HAL_SDADC_InjectedMultiModeConfigChannel(SDADC_HandleTypeDef* hsdadc,
mbed_official 330:c80ac197fa6a 864 uint32_t MultimodeType)
mbed_official 330:c80ac197fa6a 865 {
mbed_official 330:c80ac197fa6a 866 HAL_StatusTypeDef status = HAL_OK;
mbed_official 330:c80ac197fa6a 867
mbed_official 330:c80ac197fa6a 868 /* Check parameters */
mbed_official 330:c80ac197fa6a 869 assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance));
mbed_official 330:c80ac197fa6a 870 assert_param(IS_SDADC_MULTIMODE_TYPE(MultimodeType));
mbed_official 330:c80ac197fa6a 871
mbed_official 330:c80ac197fa6a 872 /* Check instance is SDADC1 */
mbed_official 330:c80ac197fa6a 873 if(hsdadc->Instance != SDADC1)
mbed_official 330:c80ac197fa6a 874 {
mbed_official 330:c80ac197fa6a 875 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 876 }
mbed_official 330:c80ac197fa6a 877 /* Check SDADC state */
mbed_official 330:c80ac197fa6a 878 else if((hsdadc->State == HAL_SDADC_STATE_READY) || \
mbed_official 330:c80ac197fa6a 879 (hsdadc->State == HAL_SDADC_STATE_CALIB) || \
mbed_official 330:c80ac197fa6a 880 (hsdadc->State == HAL_SDADC_STATE_REG))
mbed_official 330:c80ac197fa6a 881 {
mbed_official 330:c80ac197fa6a 882 /* Store regular trigger information */
mbed_official 330:c80ac197fa6a 883 hsdadc->InjectedMultimode = MultimodeType;
mbed_official 330:c80ac197fa6a 884 }
mbed_official 330:c80ac197fa6a 885 else
mbed_official 330:c80ac197fa6a 886 {
mbed_official 330:c80ac197fa6a 887 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 888 }
mbed_official 330:c80ac197fa6a 889 /* Return function status */
mbed_official 330:c80ac197fa6a 890 return status;
mbed_official 330:c80ac197fa6a 891 }
mbed_official 330:c80ac197fa6a 892
mbed_official 330:c80ac197fa6a 893 /**
mbed_official 330:c80ac197fa6a 894 * @}
mbed_official 330:c80ac197fa6a 895 */
mbed_official 330:c80ac197fa6a 896
mbed_official 330:c80ac197fa6a 897 /** @defgroup SDADC_Exported_Functions_Group3 Input and Output operation functions
mbed_official 330:c80ac197fa6a 898 * @brief I/O operation Control functions
mbed_official 330:c80ac197fa6a 899 *
mbed_official 330:c80ac197fa6a 900 @verbatim
mbed_official 330:c80ac197fa6a 901 ===============================================================================
mbed_official 330:c80ac197fa6a 902 ##### I/O operation functions #####
mbed_official 330:c80ac197fa6a 903 ===============================================================================
mbed_official 330:c80ac197fa6a 904 [..] This section provides functions allowing to:
mbed_official 330:c80ac197fa6a 905 (+) Start calibration.
mbed_official 330:c80ac197fa6a 906 (+) Poll for the end of calibration.
mbed_official 330:c80ac197fa6a 907 (+) Start calibration and enable interrupt.
mbed_official 330:c80ac197fa6a 908 (+) Start conversion of regular/injected channel.
mbed_official 330:c80ac197fa6a 909 (+) Poll for the end of regular/injected conversion.
mbed_official 330:c80ac197fa6a 910 (+) Stop conversion of regular/injected channel.
mbed_official 330:c80ac197fa6a 911 (+) Start conversion of regular/injected channel and enable interrupt.
mbed_official 330:c80ac197fa6a 912 (+) Stop conversion of regular/injected channel and disable interrupt.
mbed_official 330:c80ac197fa6a 913 (+) Start conversion of regular/injected channel and enable DMA transfer.
mbed_official 330:c80ac197fa6a 914 (+) Stop conversion of regular/injected channel and disable DMA transfer.
mbed_official 330:c80ac197fa6a 915 (+) Start multimode and enable DMA transfer for regular/injected conversion.
mbed_official 330:c80ac197fa6a 916 (+) Stop multimode and disable DMA transfer for regular/injected conversion..
mbed_official 330:c80ac197fa6a 917 (+) Get result of regular channel conversion.
mbed_official 330:c80ac197fa6a 918 (+) Get result of injected channel conversion.
mbed_official 330:c80ac197fa6a 919 (+) Get result of multimode conversion.
mbed_official 330:c80ac197fa6a 920 (+) Handle SDADC interrupt request.
mbed_official 330:c80ac197fa6a 921 (+) Callbacks for calibration and regular/injected conversions.
mbed_official 330:c80ac197fa6a 922
mbed_official 330:c80ac197fa6a 923 @endverbatim
mbed_official 330:c80ac197fa6a 924 * @{
mbed_official 330:c80ac197fa6a 925 */
mbed_official 330:c80ac197fa6a 926
mbed_official 330:c80ac197fa6a 927 /**
mbed_official 330:c80ac197fa6a 928 * @brief This function allows to start calibration in polling mode.
mbed_official 330:c80ac197fa6a 929 * @note This function should be called only when SDADC instance is in idle state
mbed_official 330:c80ac197fa6a 930 * (neither calibration nor regular or injected conversion ongoing).
mbed_official 330:c80ac197fa6a 931 * @param hsdadc : SDADC handle.
mbed_official 330:c80ac197fa6a 932 * @param CalibrationSequence : Calibration sequence.
mbed_official 330:c80ac197fa6a 933 * This parameter can be a value of @ref SDADC_CalibrationSequence.
mbed_official 330:c80ac197fa6a 934 * @retval HAL status
mbed_official 330:c80ac197fa6a 935 */
mbed_official 330:c80ac197fa6a 936 HAL_StatusTypeDef HAL_SDADC_CalibrationStart(SDADC_HandleTypeDef *hsdadc,
mbed_official 330:c80ac197fa6a 937 uint32_t CalibrationSequence)
mbed_official 330:c80ac197fa6a 938 {
mbed_official 330:c80ac197fa6a 939 HAL_StatusTypeDef status = HAL_OK;
mbed_official 330:c80ac197fa6a 940
mbed_official 330:c80ac197fa6a 941 /* Check parameters */
mbed_official 330:c80ac197fa6a 942 assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance));
mbed_official 330:c80ac197fa6a 943 assert_param(IS_SDADC_CALIB_SEQUENCE(CalibrationSequence));
mbed_official 330:c80ac197fa6a 944
mbed_official 330:c80ac197fa6a 945 /* Check SDADC state */
mbed_official 330:c80ac197fa6a 946 if(hsdadc->State == HAL_SDADC_STATE_READY)
mbed_official 330:c80ac197fa6a 947 {
mbed_official 330:c80ac197fa6a 948 /* Enter init mode */
mbed_official 330:c80ac197fa6a 949 if(SDADC_EnterInitMode(hsdadc) != HAL_OK)
mbed_official 330:c80ac197fa6a 950 {
mbed_official 330:c80ac197fa6a 951 /* Set SDADC in error state */
mbed_official 330:c80ac197fa6a 952 hsdadc->State = HAL_SDADC_STATE_ERROR;
mbed_official 330:c80ac197fa6a 953 status = HAL_TIMEOUT;
mbed_official 330:c80ac197fa6a 954 }
mbed_official 330:c80ac197fa6a 955 else
mbed_official 330:c80ac197fa6a 956 {
mbed_official 330:c80ac197fa6a 957 /* Set CALIBCNT[1:0] bits in SDADC_CR2 register */
mbed_official 330:c80ac197fa6a 958 hsdadc->Instance->CR2 &= ~(SDADC_CR2_CALIBCNT);
mbed_official 330:c80ac197fa6a 959 hsdadc->Instance->CR2 |= CalibrationSequence;
mbed_official 330:c80ac197fa6a 960
mbed_official 330:c80ac197fa6a 961 /* Exit init mode */
mbed_official 330:c80ac197fa6a 962 SDADC_ExitInitMode(hsdadc);
mbed_official 330:c80ac197fa6a 963
mbed_official 330:c80ac197fa6a 964 /* Set STARTCALIB in SDADC_CR2 */
mbed_official 330:c80ac197fa6a 965 hsdadc->Instance->CR2 |= SDADC_CR2_STARTCALIB;
mbed_official 330:c80ac197fa6a 966
mbed_official 330:c80ac197fa6a 967 /* Set SDADC in calibration state */
mbed_official 330:c80ac197fa6a 968 hsdadc->State = HAL_SDADC_STATE_CALIB;
mbed_official 330:c80ac197fa6a 969 }
mbed_official 330:c80ac197fa6a 970 }
mbed_official 330:c80ac197fa6a 971 else
mbed_official 330:c80ac197fa6a 972 {
mbed_official 330:c80ac197fa6a 973 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 974 }
mbed_official 330:c80ac197fa6a 975 /* Return function status */
mbed_official 330:c80ac197fa6a 976 return status;
mbed_official 330:c80ac197fa6a 977 }
mbed_official 330:c80ac197fa6a 978
mbed_official 330:c80ac197fa6a 979 /**
mbed_official 330:c80ac197fa6a 980 * @brief This function allows to poll for the end of calibration.
mbed_official 330:c80ac197fa6a 981 * @note This function should be called only if calibration is ongoing.
mbed_official 330:c80ac197fa6a 982 * @param hsdadc : SDADC handle.
mbed_official 330:c80ac197fa6a 983 * @param Timeout : Timeout value in milliseconds.
mbed_official 330:c80ac197fa6a 984 * @retval HAL status
mbed_official 330:c80ac197fa6a 985 */
mbed_official 330:c80ac197fa6a 986 HAL_StatusTypeDef HAL_SDADC_PollForCalibEvent(SDADC_HandleTypeDef* hsdadc, uint32_t Timeout)
mbed_official 330:c80ac197fa6a 987 {
mbed_official 330:c80ac197fa6a 988 uint32_t tickstart;
mbed_official 330:c80ac197fa6a 989
mbed_official 330:c80ac197fa6a 990 /* Check parameters */
mbed_official 330:c80ac197fa6a 991 assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance));
mbed_official 330:c80ac197fa6a 992
mbed_official 330:c80ac197fa6a 993 /* Check SDADC state */
mbed_official 330:c80ac197fa6a 994 if(hsdadc->State != HAL_SDADC_STATE_CALIB)
mbed_official 330:c80ac197fa6a 995 {
mbed_official 330:c80ac197fa6a 996 /* Return error status */
mbed_official 330:c80ac197fa6a 997 return HAL_ERROR;
mbed_official 330:c80ac197fa6a 998 }
mbed_official 330:c80ac197fa6a 999 else
mbed_official 330:c80ac197fa6a 1000 {
mbed_official 330:c80ac197fa6a 1001 /* Get timeout */
mbed_official 330:c80ac197fa6a 1002 tickstart = HAL_GetTick();
mbed_official 330:c80ac197fa6a 1003
mbed_official 330:c80ac197fa6a 1004 /* Wait EOCALF bit in SDADC_ISR register */
mbed_official 330:c80ac197fa6a 1005 while((hsdadc->Instance->ISR & SDADC_ISR_EOCALF) != SDADC_ISR_EOCALF)
mbed_official 330:c80ac197fa6a 1006 {
mbed_official 330:c80ac197fa6a 1007 /* Check the Timeout */
mbed_official 330:c80ac197fa6a 1008 if(Timeout != HAL_MAX_DELAY)
mbed_official 330:c80ac197fa6a 1009 {
mbed_official 330:c80ac197fa6a 1010 if((Timeout == 0) || ((HAL_GetTick()-tickstart) > Timeout))
mbed_official 330:c80ac197fa6a 1011 {
mbed_official 330:c80ac197fa6a 1012 /* Return timeout status */
mbed_official 330:c80ac197fa6a 1013 return HAL_TIMEOUT;
mbed_official 330:c80ac197fa6a 1014 }
mbed_official 330:c80ac197fa6a 1015 }
mbed_official 330:c80ac197fa6a 1016 }
mbed_official 330:c80ac197fa6a 1017 /* Set CLREOCALF bit in SDADC_CLRISR register */
mbed_official 330:c80ac197fa6a 1018 hsdadc->Instance->CLRISR |= SDADC_ISR_CLREOCALF;
mbed_official 330:c80ac197fa6a 1019
mbed_official 330:c80ac197fa6a 1020 /* Set SDADC in ready state */
mbed_official 330:c80ac197fa6a 1021 hsdadc->State = HAL_SDADC_STATE_READY;
mbed_official 330:c80ac197fa6a 1022
mbed_official 330:c80ac197fa6a 1023 /* Return function status */
mbed_official 330:c80ac197fa6a 1024 return HAL_OK;
mbed_official 330:c80ac197fa6a 1025 }
mbed_official 330:c80ac197fa6a 1026 }
mbed_official 330:c80ac197fa6a 1027
mbed_official 330:c80ac197fa6a 1028 /**
mbed_official 330:c80ac197fa6a 1029 * @brief This function allows to start calibration in interrupt mode.
mbed_official 330:c80ac197fa6a 1030 * @note This function should be called only when SDADC instance is in idle state
mbed_official 330:c80ac197fa6a 1031 * (neither calibration nor regular or injected conversion ongoing).
mbed_official 330:c80ac197fa6a 1032 * @param hsdadc : SDADC handle.
mbed_official 330:c80ac197fa6a 1033 * @param CalibrationSequence : Calibration sequence.
mbed_official 330:c80ac197fa6a 1034 * This parameter can be a value of @ref SDADC_CalibrationSequence.
mbed_official 330:c80ac197fa6a 1035 * @retval HAL status
mbed_official 330:c80ac197fa6a 1036 */
mbed_official 330:c80ac197fa6a 1037 HAL_StatusTypeDef HAL_SDADC_CalibrationStart_IT(SDADC_HandleTypeDef *hsdadc,
mbed_official 330:c80ac197fa6a 1038 uint32_t CalibrationSequence)
mbed_official 330:c80ac197fa6a 1039 {
mbed_official 330:c80ac197fa6a 1040 HAL_StatusTypeDef status = HAL_OK;
mbed_official 330:c80ac197fa6a 1041
mbed_official 330:c80ac197fa6a 1042 /* Check parameters */
mbed_official 330:c80ac197fa6a 1043 assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance));
mbed_official 330:c80ac197fa6a 1044 assert_param(IS_SDADC_CALIB_SEQUENCE(CalibrationSequence));
mbed_official 330:c80ac197fa6a 1045
mbed_official 330:c80ac197fa6a 1046 /* Check SDADC state */
mbed_official 330:c80ac197fa6a 1047 if(hsdadc->State == HAL_SDADC_STATE_READY)
mbed_official 330:c80ac197fa6a 1048 {
mbed_official 330:c80ac197fa6a 1049 /* Enter init mode */
mbed_official 330:c80ac197fa6a 1050 if(SDADC_EnterInitMode(hsdadc) != HAL_OK)
mbed_official 330:c80ac197fa6a 1051 {
mbed_official 330:c80ac197fa6a 1052 /* Set SDADC in error state */
mbed_official 330:c80ac197fa6a 1053 hsdadc->State = HAL_SDADC_STATE_ERROR;
mbed_official 330:c80ac197fa6a 1054 status = HAL_TIMEOUT;
mbed_official 330:c80ac197fa6a 1055 }
mbed_official 330:c80ac197fa6a 1056 else
mbed_official 330:c80ac197fa6a 1057 {
mbed_official 330:c80ac197fa6a 1058 /* Set CALIBCNT[1:0] bits in SDADC_CR2 register */
mbed_official 330:c80ac197fa6a 1059 hsdadc->Instance->CR2 &= ~(SDADC_CR2_CALIBCNT);
mbed_official 330:c80ac197fa6a 1060 hsdadc->Instance->CR2 |= CalibrationSequence;
mbed_official 330:c80ac197fa6a 1061
mbed_official 330:c80ac197fa6a 1062 /* Exit init mode */
mbed_official 330:c80ac197fa6a 1063 SDADC_ExitInitMode(hsdadc);
mbed_official 330:c80ac197fa6a 1064
mbed_official 330:c80ac197fa6a 1065 /* Set EOCALIE bit in SDADC_CR1 register */
mbed_official 330:c80ac197fa6a 1066 hsdadc->Instance->CR1 |= SDADC_CR1_EOCALIE;
mbed_official 330:c80ac197fa6a 1067
mbed_official 330:c80ac197fa6a 1068 /* Set STARTCALIB in SDADC_CR2 */
mbed_official 330:c80ac197fa6a 1069 hsdadc->Instance->CR2 |= SDADC_CR2_STARTCALIB;
mbed_official 330:c80ac197fa6a 1070
mbed_official 330:c80ac197fa6a 1071 /* Set SDADC in calibration state */
mbed_official 330:c80ac197fa6a 1072 hsdadc->State = HAL_SDADC_STATE_CALIB;
mbed_official 330:c80ac197fa6a 1073 }
mbed_official 330:c80ac197fa6a 1074 }
mbed_official 330:c80ac197fa6a 1075 else
mbed_official 330:c80ac197fa6a 1076 {
mbed_official 330:c80ac197fa6a 1077 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 1078 }
mbed_official 330:c80ac197fa6a 1079 /* Return function status */
mbed_official 330:c80ac197fa6a 1080 return status;
mbed_official 330:c80ac197fa6a 1081 }
mbed_official 330:c80ac197fa6a 1082
mbed_official 330:c80ac197fa6a 1083 /**
mbed_official 330:c80ac197fa6a 1084 * @brief This function allows to start regular conversion in polling mode.
mbed_official 330:c80ac197fa6a 1085 * @note This function should be called only when SDADC instance is in idle state
mbed_official 330:c80ac197fa6a 1086 * or if injected conversion is ongoing.
mbed_official 330:c80ac197fa6a 1087 * @param hsdadc : SDADC handle.
mbed_official 330:c80ac197fa6a 1088 * @retval HAL status
mbed_official 330:c80ac197fa6a 1089 */
mbed_official 330:c80ac197fa6a 1090 HAL_StatusTypeDef HAL_SDADC_Start(SDADC_HandleTypeDef *hsdadc)
mbed_official 330:c80ac197fa6a 1091 {
mbed_official 330:c80ac197fa6a 1092 HAL_StatusTypeDef status = HAL_OK;
mbed_official 330:c80ac197fa6a 1093
mbed_official 330:c80ac197fa6a 1094 /* Check parameters */
mbed_official 330:c80ac197fa6a 1095 assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance));
mbed_official 330:c80ac197fa6a 1096
mbed_official 330:c80ac197fa6a 1097 /* Check SDADC state */
mbed_official 330:c80ac197fa6a 1098 if((hsdadc->State == HAL_SDADC_STATE_READY) || \
mbed_official 330:c80ac197fa6a 1099 (hsdadc->State == HAL_SDADC_STATE_INJ))
mbed_official 330:c80ac197fa6a 1100 {
mbed_official 330:c80ac197fa6a 1101 /* Start regular conversion */
mbed_official 330:c80ac197fa6a 1102 status = SDADC_RegConvStart(hsdadc);
mbed_official 330:c80ac197fa6a 1103 }
mbed_official 330:c80ac197fa6a 1104 else
mbed_official 330:c80ac197fa6a 1105 {
mbed_official 330:c80ac197fa6a 1106 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 1107 }
mbed_official 330:c80ac197fa6a 1108 /* Return function status */
mbed_official 330:c80ac197fa6a 1109 return status;
mbed_official 330:c80ac197fa6a 1110 }
mbed_official 330:c80ac197fa6a 1111
mbed_official 330:c80ac197fa6a 1112 /**
mbed_official 330:c80ac197fa6a 1113 * @brief This function allows to poll for the end of regular conversion.
mbed_official 330:c80ac197fa6a 1114 * @note This function should be called only if regular conversion is ongoing.
mbed_official 330:c80ac197fa6a 1115 * @param hsdadc : SDADC handle.
mbed_official 330:c80ac197fa6a 1116 * @param Timeout : Timeout value in milliseconds.
mbed_official 330:c80ac197fa6a 1117 * @retval HAL status
mbed_official 330:c80ac197fa6a 1118 */
mbed_official 330:c80ac197fa6a 1119 HAL_StatusTypeDef HAL_SDADC_PollForConversion(SDADC_HandleTypeDef* hsdadc, uint32_t Timeout)
mbed_official 330:c80ac197fa6a 1120 {
mbed_official 330:c80ac197fa6a 1121 uint32_t tickstart;
mbed_official 330:c80ac197fa6a 1122
mbed_official 330:c80ac197fa6a 1123 /* Check parameters */
mbed_official 330:c80ac197fa6a 1124 assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance));
mbed_official 330:c80ac197fa6a 1125
mbed_official 330:c80ac197fa6a 1126 /* Check SDADC state */
mbed_official 330:c80ac197fa6a 1127 if((hsdadc->State != HAL_SDADC_STATE_REG) && \
mbed_official 330:c80ac197fa6a 1128 (hsdadc->State != HAL_SDADC_STATE_REG_INJ))
mbed_official 330:c80ac197fa6a 1129 {
mbed_official 330:c80ac197fa6a 1130 /* Return error status */
mbed_official 330:c80ac197fa6a 1131 return HAL_ERROR;
mbed_official 330:c80ac197fa6a 1132 }
mbed_official 330:c80ac197fa6a 1133 else
mbed_official 330:c80ac197fa6a 1134 {
mbed_official 330:c80ac197fa6a 1135 /* Get timeout */
mbed_official 330:c80ac197fa6a 1136 tickstart = HAL_GetTick();
mbed_official 330:c80ac197fa6a 1137
mbed_official 330:c80ac197fa6a 1138 /* Wait REOCF bit in SDADC_ISR register */
mbed_official 330:c80ac197fa6a 1139 while((hsdadc->Instance->ISR & SDADC_ISR_REOCF) != SDADC_ISR_REOCF)
mbed_official 330:c80ac197fa6a 1140 {
mbed_official 330:c80ac197fa6a 1141 /* Check the Timeout */
mbed_official 330:c80ac197fa6a 1142 if(Timeout != HAL_MAX_DELAY)
mbed_official 330:c80ac197fa6a 1143 {
mbed_official 330:c80ac197fa6a 1144 if((Timeout == 0) || ((HAL_GetTick()-tickstart) > Timeout))
mbed_official 330:c80ac197fa6a 1145 {
mbed_official 330:c80ac197fa6a 1146 /* Return timeout status */
mbed_official 330:c80ac197fa6a 1147 return HAL_TIMEOUT;
mbed_official 330:c80ac197fa6a 1148 }
mbed_official 330:c80ac197fa6a 1149 }
mbed_official 330:c80ac197fa6a 1150 }
mbed_official 330:c80ac197fa6a 1151 /* Check if overrun occurs */
mbed_official 330:c80ac197fa6a 1152 if((hsdadc->Instance->ISR & SDADC_ISR_ROVRF) == SDADC_ISR_ROVRF)
mbed_official 330:c80ac197fa6a 1153 {
mbed_official 330:c80ac197fa6a 1154 /* Update error code and call error callback */
mbed_official 330:c80ac197fa6a 1155 hsdadc->ErrorCode = SDADC_ERROR_REGULAR_OVERRUN;
mbed_official 330:c80ac197fa6a 1156 HAL_SDADC_ErrorCallback(hsdadc);
mbed_official 330:c80ac197fa6a 1157
mbed_official 330:c80ac197fa6a 1158 /* Set CLRROVRF bit in SDADC_CLRISR register */
mbed_official 330:c80ac197fa6a 1159 hsdadc->Instance->CLRISR |= SDADC_ISR_CLRROVRF;
mbed_official 330:c80ac197fa6a 1160 }
mbed_official 330:c80ac197fa6a 1161 /* Update SDADC state only if not continuous conversion and SW trigger */
mbed_official 330:c80ac197fa6a 1162 if((hsdadc->RegularContMode == SDADC_CONTINUOUS_CONV_OFF) && \
mbed_official 330:c80ac197fa6a 1163 (hsdadc->RegularTrigger == SDADC_SOFTWARE_TRIGGER))
mbed_official 330:c80ac197fa6a 1164 {
mbed_official 330:c80ac197fa6a 1165 hsdadc->State = (hsdadc->State == HAL_SDADC_STATE_REG) ? \
mbed_official 330:c80ac197fa6a 1166 HAL_SDADC_STATE_READY : HAL_SDADC_STATE_INJ;
mbed_official 330:c80ac197fa6a 1167 }
mbed_official 330:c80ac197fa6a 1168 /* Return function status */
mbed_official 330:c80ac197fa6a 1169 return HAL_OK;
mbed_official 330:c80ac197fa6a 1170 }
mbed_official 330:c80ac197fa6a 1171 }
mbed_official 330:c80ac197fa6a 1172
mbed_official 330:c80ac197fa6a 1173 /**
mbed_official 330:c80ac197fa6a 1174 * @brief This function allows to stop regular conversion in polling mode.
mbed_official 330:c80ac197fa6a 1175 * @note This function should be called only if regular conversion is ongoing.
mbed_official 330:c80ac197fa6a 1176 * @param hsdadc : SDADC handle.
mbed_official 330:c80ac197fa6a 1177 * @retval HAL status
mbed_official 330:c80ac197fa6a 1178 */
mbed_official 330:c80ac197fa6a 1179 HAL_StatusTypeDef HAL_SDADC_Stop(SDADC_HandleTypeDef *hsdadc)
mbed_official 330:c80ac197fa6a 1180 {
mbed_official 330:c80ac197fa6a 1181 HAL_StatusTypeDef status = HAL_OK;
mbed_official 330:c80ac197fa6a 1182
mbed_official 330:c80ac197fa6a 1183 /* Check parameters */
mbed_official 330:c80ac197fa6a 1184 assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance));
mbed_official 330:c80ac197fa6a 1185
mbed_official 330:c80ac197fa6a 1186 /* Check SDADC state */
mbed_official 330:c80ac197fa6a 1187 if((hsdadc->State != HAL_SDADC_STATE_REG) && \
mbed_official 330:c80ac197fa6a 1188 (hsdadc->State != HAL_SDADC_STATE_REG_INJ))
mbed_official 330:c80ac197fa6a 1189 {
mbed_official 330:c80ac197fa6a 1190 /* Return error status */
mbed_official 330:c80ac197fa6a 1191 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 1192 }
mbed_official 330:c80ac197fa6a 1193 else
mbed_official 330:c80ac197fa6a 1194 {
mbed_official 330:c80ac197fa6a 1195 /* Stop regular conversion */
mbed_official 330:c80ac197fa6a 1196 status = SDADC_RegConvStop(hsdadc);
mbed_official 330:c80ac197fa6a 1197 }
mbed_official 330:c80ac197fa6a 1198 /* Return function status */
mbed_official 330:c80ac197fa6a 1199 return status;
mbed_official 330:c80ac197fa6a 1200 }
mbed_official 330:c80ac197fa6a 1201
mbed_official 330:c80ac197fa6a 1202 /**
mbed_official 330:c80ac197fa6a 1203 * @brief This function allows to start regular conversion in interrupt mode.
mbed_official 330:c80ac197fa6a 1204 * @note This function should be called only when SDADC instance is in idle state
mbed_official 330:c80ac197fa6a 1205 * or if injected conversion is ongoing.
mbed_official 330:c80ac197fa6a 1206 * @param hsdadc : SDADC handle.
mbed_official 330:c80ac197fa6a 1207 * @retval HAL status
mbed_official 330:c80ac197fa6a 1208 */
mbed_official 330:c80ac197fa6a 1209 HAL_StatusTypeDef HAL_SDADC_Start_IT(SDADC_HandleTypeDef *hsdadc)
mbed_official 330:c80ac197fa6a 1210 {
mbed_official 330:c80ac197fa6a 1211 HAL_StatusTypeDef status = HAL_OK;
mbed_official 330:c80ac197fa6a 1212
mbed_official 330:c80ac197fa6a 1213 /* Check parameters */
mbed_official 330:c80ac197fa6a 1214 assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance));
mbed_official 330:c80ac197fa6a 1215
mbed_official 330:c80ac197fa6a 1216 /* Check SDADC state */
mbed_official 330:c80ac197fa6a 1217 if((hsdadc->State == HAL_SDADC_STATE_READY) || \
mbed_official 330:c80ac197fa6a 1218 (hsdadc->State == HAL_SDADC_STATE_INJ))
mbed_official 330:c80ac197fa6a 1219 {
mbed_official 330:c80ac197fa6a 1220 /* Set REOCIE and ROVRIE bits in SDADC_CR1 register */
mbed_official 330:c80ac197fa6a 1221 hsdadc->Instance->CR1 |= (uint32_t) (SDADC_CR1_REOCIE | SDADC_CR1_ROVRIE);
mbed_official 330:c80ac197fa6a 1222
mbed_official 330:c80ac197fa6a 1223 /* Start regular conversion */
mbed_official 330:c80ac197fa6a 1224 status = SDADC_RegConvStart(hsdadc);
mbed_official 330:c80ac197fa6a 1225 }
mbed_official 330:c80ac197fa6a 1226 else
mbed_official 330:c80ac197fa6a 1227 {
mbed_official 330:c80ac197fa6a 1228 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 1229 }
mbed_official 330:c80ac197fa6a 1230 /* Return function status */
mbed_official 330:c80ac197fa6a 1231 return status;
mbed_official 330:c80ac197fa6a 1232 }
mbed_official 330:c80ac197fa6a 1233
mbed_official 330:c80ac197fa6a 1234 /**
mbed_official 330:c80ac197fa6a 1235 * @brief This function allows to stop regular conversion in interrupt mode.
mbed_official 330:c80ac197fa6a 1236 * @note This function should be called only if regular conversion is ongoing.
mbed_official 330:c80ac197fa6a 1237 * @param hsdadc : SDADC handle.
mbed_official 330:c80ac197fa6a 1238 * @retval HAL status
mbed_official 330:c80ac197fa6a 1239 */
mbed_official 330:c80ac197fa6a 1240 HAL_StatusTypeDef HAL_SDADC_Stop_IT(SDADC_HandleTypeDef *hsdadc)
mbed_official 330:c80ac197fa6a 1241 {
mbed_official 330:c80ac197fa6a 1242 HAL_StatusTypeDef status = HAL_OK;
mbed_official 330:c80ac197fa6a 1243
mbed_official 330:c80ac197fa6a 1244 /* Check parameters */
mbed_official 330:c80ac197fa6a 1245 assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance));
mbed_official 330:c80ac197fa6a 1246
mbed_official 330:c80ac197fa6a 1247 /* Check SDADC state */
mbed_official 330:c80ac197fa6a 1248 if((hsdadc->State != HAL_SDADC_STATE_REG) && \
mbed_official 330:c80ac197fa6a 1249 (hsdadc->State != HAL_SDADC_STATE_REG_INJ))
mbed_official 330:c80ac197fa6a 1250 {
mbed_official 330:c80ac197fa6a 1251 /* Return error status */
mbed_official 330:c80ac197fa6a 1252 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 1253 }
mbed_official 330:c80ac197fa6a 1254 else
mbed_official 330:c80ac197fa6a 1255 {
mbed_official 330:c80ac197fa6a 1256 /* Clear REOCIE and ROVRIE bits in SDADC_CR1 register */
mbed_official 330:c80ac197fa6a 1257 hsdadc->Instance->CR1 &= (uint32_t) ~(SDADC_CR1_REOCIE | SDADC_CR1_ROVRIE);
mbed_official 330:c80ac197fa6a 1258
mbed_official 330:c80ac197fa6a 1259 /* Stop regular conversion */
mbed_official 330:c80ac197fa6a 1260 status = SDADC_RegConvStop(hsdadc);
mbed_official 330:c80ac197fa6a 1261 }
mbed_official 330:c80ac197fa6a 1262 /* Return function status */
mbed_official 330:c80ac197fa6a 1263 return status;
mbed_official 330:c80ac197fa6a 1264 }
mbed_official 330:c80ac197fa6a 1265
mbed_official 330:c80ac197fa6a 1266 /**
mbed_official 330:c80ac197fa6a 1267 * @brief This function allows to start regular conversion in DMA mode.
mbed_official 330:c80ac197fa6a 1268 * @note This function should be called only when SDADC instance is in idle state
mbed_official 330:c80ac197fa6a 1269 * or if injected conversion is ongoing.
mbed_official 330:c80ac197fa6a 1270 * @param hsdadc : SDADC handle.
mbed_official 330:c80ac197fa6a 1271 * @param pData : The destination buffer address.
mbed_official 330:c80ac197fa6a 1272 * @param Length : The length of data to be transferred from SDADC peripheral to memory.
mbed_official 330:c80ac197fa6a 1273 * @retval HAL status
mbed_official 330:c80ac197fa6a 1274 */
mbed_official 330:c80ac197fa6a 1275 HAL_StatusTypeDef HAL_SDADC_Start_DMA(SDADC_HandleTypeDef *hsdadc, uint32_t *pData,
mbed_official 330:c80ac197fa6a 1276 uint32_t Length)
mbed_official 330:c80ac197fa6a 1277 {
mbed_official 330:c80ac197fa6a 1278 HAL_StatusTypeDef status = HAL_OK;
mbed_official 330:c80ac197fa6a 1279
mbed_official 330:c80ac197fa6a 1280 /* Check parameters */
mbed_official 330:c80ac197fa6a 1281 assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance));
mbed_official 634:ac7d6880524d 1282 assert_param(pData != HAL_NULL);
mbed_official 330:c80ac197fa6a 1283 assert_param(Length != 0);
mbed_official 330:c80ac197fa6a 1284
mbed_official 330:c80ac197fa6a 1285 /* Check that DMA is not enabled for injected conversion */
mbed_official 330:c80ac197fa6a 1286 if((hsdadc->Instance->CR1 & SDADC_CR1_JDMAEN) == SDADC_CR1_JDMAEN)
mbed_official 330:c80ac197fa6a 1287 {
mbed_official 330:c80ac197fa6a 1288 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 1289 }
mbed_official 330:c80ac197fa6a 1290 /* Check parameters compatibility */
mbed_official 330:c80ac197fa6a 1291 else if((hsdadc->RegularTrigger == SDADC_SOFTWARE_TRIGGER) && \
mbed_official 330:c80ac197fa6a 1292 (hsdadc->RegularContMode == SDADC_CONTINUOUS_CONV_OFF) && \
mbed_official 330:c80ac197fa6a 1293 (hsdadc->hdma->Init.Mode == DMA_NORMAL) && \
mbed_official 330:c80ac197fa6a 1294 (Length != 1))
mbed_official 330:c80ac197fa6a 1295 {
mbed_official 330:c80ac197fa6a 1296 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 1297 }
mbed_official 330:c80ac197fa6a 1298 else if((hsdadc->RegularTrigger == SDADC_SOFTWARE_TRIGGER) && \
mbed_official 330:c80ac197fa6a 1299 (hsdadc->RegularContMode == SDADC_CONTINUOUS_CONV_OFF) && \
mbed_official 330:c80ac197fa6a 1300 (hsdadc->hdma->Init.Mode == DMA_CIRCULAR))
mbed_official 330:c80ac197fa6a 1301 {
mbed_official 330:c80ac197fa6a 1302 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 1303 }
mbed_official 330:c80ac197fa6a 1304 /* Check SDADC state */
mbed_official 330:c80ac197fa6a 1305 else if((hsdadc->State == HAL_SDADC_STATE_READY) || \
mbed_official 330:c80ac197fa6a 1306 (hsdadc->State == HAL_SDADC_STATE_INJ))
mbed_official 330:c80ac197fa6a 1307 {
mbed_official 330:c80ac197fa6a 1308 /* Set callbacks on DMA handler */
mbed_official 330:c80ac197fa6a 1309 hsdadc->hdma->XferCpltCallback = SDADC_DMARegularConvCplt;
mbed_official 330:c80ac197fa6a 1310 hsdadc->hdma->XferErrorCallback = SDADC_DMAError;
mbed_official 330:c80ac197fa6a 1311 if(hsdadc->hdma->Init.Mode == DMA_CIRCULAR)
mbed_official 330:c80ac197fa6a 1312 {
mbed_official 330:c80ac197fa6a 1313 hsdadc->hdma->XferHalfCpltCallback = SDADC_DMARegularHalfConvCplt;
mbed_official 330:c80ac197fa6a 1314 }
mbed_official 330:c80ac197fa6a 1315
mbed_official 330:c80ac197fa6a 1316 /* Set RDMAEN bit in SDADC_CR1 register */
mbed_official 330:c80ac197fa6a 1317 hsdadc->Instance->CR1 |= SDADC_CR1_RDMAEN;
mbed_official 330:c80ac197fa6a 1318
mbed_official 330:c80ac197fa6a 1319 /* Start DMA in interrupt mode */
mbed_official 330:c80ac197fa6a 1320 if(HAL_DMA_Start_IT(hsdadc->hdma, (uint32_t)&hsdadc->Instance->RDATAR, \
mbed_official 330:c80ac197fa6a 1321 (uint32_t) pData, Length) != HAL_OK)
mbed_official 330:c80ac197fa6a 1322 {
mbed_official 330:c80ac197fa6a 1323 /* Set SDADC in error state */
mbed_official 330:c80ac197fa6a 1324 hsdadc->State = HAL_SDADC_STATE_ERROR;
mbed_official 330:c80ac197fa6a 1325 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 1326 }
mbed_official 330:c80ac197fa6a 1327 else
mbed_official 330:c80ac197fa6a 1328 {
mbed_official 330:c80ac197fa6a 1329 /* Start regular conversion */
mbed_official 330:c80ac197fa6a 1330 status = SDADC_RegConvStart(hsdadc);
mbed_official 330:c80ac197fa6a 1331 }
mbed_official 330:c80ac197fa6a 1332 }
mbed_official 330:c80ac197fa6a 1333 else
mbed_official 330:c80ac197fa6a 1334 {
mbed_official 330:c80ac197fa6a 1335 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 1336 }
mbed_official 330:c80ac197fa6a 1337 /* Return function status */
mbed_official 330:c80ac197fa6a 1338 return status;
mbed_official 330:c80ac197fa6a 1339 }
mbed_official 330:c80ac197fa6a 1340
mbed_official 330:c80ac197fa6a 1341 /**
mbed_official 330:c80ac197fa6a 1342 * @brief This function allows to stop regular conversion in DMA mode.
mbed_official 330:c80ac197fa6a 1343 * @note This function should be called only if regular conversion is ongoing.
mbed_official 330:c80ac197fa6a 1344 * @param hsdadc : SDADC handle.
mbed_official 330:c80ac197fa6a 1345 * @retval HAL status
mbed_official 330:c80ac197fa6a 1346 */
mbed_official 330:c80ac197fa6a 1347 HAL_StatusTypeDef HAL_SDADC_Stop_DMA(SDADC_HandleTypeDef *hsdadc)
mbed_official 330:c80ac197fa6a 1348 {
mbed_official 330:c80ac197fa6a 1349 HAL_StatusTypeDef status = HAL_OK;
mbed_official 330:c80ac197fa6a 1350
mbed_official 330:c80ac197fa6a 1351 /* Check parameters */
mbed_official 330:c80ac197fa6a 1352 assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance));
mbed_official 330:c80ac197fa6a 1353
mbed_official 330:c80ac197fa6a 1354 /* Check SDADC state */
mbed_official 330:c80ac197fa6a 1355 if((hsdadc->State != HAL_SDADC_STATE_REG) && \
mbed_official 330:c80ac197fa6a 1356 (hsdadc->State != HAL_SDADC_STATE_REG_INJ))
mbed_official 330:c80ac197fa6a 1357 {
mbed_official 330:c80ac197fa6a 1358 /* Return error status */
mbed_official 330:c80ac197fa6a 1359 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 1360 }
mbed_official 330:c80ac197fa6a 1361 else
mbed_official 330:c80ac197fa6a 1362 {
mbed_official 330:c80ac197fa6a 1363 /* Clear RDMAEN bit in SDADC_CR1 register */
mbed_official 330:c80ac197fa6a 1364 hsdadc->Instance->CR1 &= ~(SDADC_CR1_RDMAEN);
mbed_official 330:c80ac197fa6a 1365
mbed_official 330:c80ac197fa6a 1366 /* Stop current DMA transfer */
mbed_official 330:c80ac197fa6a 1367 if(HAL_DMA_Abort(hsdadc->hdma) != HAL_OK)
mbed_official 330:c80ac197fa6a 1368 {
mbed_official 330:c80ac197fa6a 1369 /* Set SDADC in error state */
mbed_official 330:c80ac197fa6a 1370 hsdadc->State = HAL_SDADC_STATE_ERROR;
mbed_official 330:c80ac197fa6a 1371 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 1372 }
mbed_official 330:c80ac197fa6a 1373 else
mbed_official 330:c80ac197fa6a 1374 {
mbed_official 330:c80ac197fa6a 1375 /* Stop regular conversion */
mbed_official 330:c80ac197fa6a 1376 status = SDADC_RegConvStop(hsdadc);
mbed_official 330:c80ac197fa6a 1377 }
mbed_official 330:c80ac197fa6a 1378 }
mbed_official 330:c80ac197fa6a 1379 /* Return function status */
mbed_official 330:c80ac197fa6a 1380 return status;
mbed_official 330:c80ac197fa6a 1381 }
mbed_official 330:c80ac197fa6a 1382
mbed_official 330:c80ac197fa6a 1383 /**
mbed_official 330:c80ac197fa6a 1384 * @brief This function allows to get regular conversion value.
mbed_official 330:c80ac197fa6a 1385 * @param hsdadc : SDADC handle.
mbed_official 330:c80ac197fa6a 1386 * @retval Regular conversion value
mbed_official 330:c80ac197fa6a 1387 */
mbed_official 330:c80ac197fa6a 1388 uint32_t HAL_SDADC_GetValue(SDADC_HandleTypeDef *hsdadc)
mbed_official 330:c80ac197fa6a 1389 {
mbed_official 330:c80ac197fa6a 1390 /* Check parameters */
mbed_official 330:c80ac197fa6a 1391 assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance));
mbed_official 330:c80ac197fa6a 1392
mbed_official 330:c80ac197fa6a 1393 /* Return regular conversion value */
mbed_official 330:c80ac197fa6a 1394 return hsdadc->Instance->RDATAR;
mbed_official 330:c80ac197fa6a 1395 }
mbed_official 330:c80ac197fa6a 1396
mbed_official 330:c80ac197fa6a 1397 /**
mbed_official 330:c80ac197fa6a 1398 * @brief This function allows to start injected conversion in polling mode.
mbed_official 330:c80ac197fa6a 1399 * @note This function should be called only when SDADC instance is in idle state
mbed_official 330:c80ac197fa6a 1400 * or if regular conversion is ongoing.
mbed_official 330:c80ac197fa6a 1401 * @param hsdadc : SDADC handle.
mbed_official 330:c80ac197fa6a 1402 * @retval HAL status
mbed_official 330:c80ac197fa6a 1403 */
mbed_official 330:c80ac197fa6a 1404 HAL_StatusTypeDef HAL_SDADC_InjectedStart(SDADC_HandleTypeDef *hsdadc)
mbed_official 330:c80ac197fa6a 1405 {
mbed_official 330:c80ac197fa6a 1406 HAL_StatusTypeDef status = HAL_OK;
mbed_official 330:c80ac197fa6a 1407
mbed_official 330:c80ac197fa6a 1408 /* Check parameters */
mbed_official 330:c80ac197fa6a 1409 assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance));
mbed_official 330:c80ac197fa6a 1410
mbed_official 330:c80ac197fa6a 1411 /* Check SDADC state */
mbed_official 330:c80ac197fa6a 1412 if((hsdadc->State == HAL_SDADC_STATE_READY) || \
mbed_official 330:c80ac197fa6a 1413 (hsdadc->State == HAL_SDADC_STATE_REG))
mbed_official 330:c80ac197fa6a 1414 {
mbed_official 330:c80ac197fa6a 1415 /* Start injected conversion */
mbed_official 330:c80ac197fa6a 1416 status = SDADC_InjConvStart(hsdadc);
mbed_official 330:c80ac197fa6a 1417 }
mbed_official 330:c80ac197fa6a 1418 else
mbed_official 330:c80ac197fa6a 1419 {
mbed_official 330:c80ac197fa6a 1420 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 1421 }
mbed_official 330:c80ac197fa6a 1422 /* Return function status */
mbed_official 330:c80ac197fa6a 1423 return status;
mbed_official 330:c80ac197fa6a 1424 }
mbed_official 330:c80ac197fa6a 1425
mbed_official 330:c80ac197fa6a 1426 /**
mbed_official 330:c80ac197fa6a 1427 * @brief This function allows to poll for the end of injected conversion.
mbed_official 330:c80ac197fa6a 1428 * @note This function should be called only if injected conversion is ongoing.
mbed_official 330:c80ac197fa6a 1429 * @param hsdadc : SDADC handle.
mbed_official 330:c80ac197fa6a 1430 * @param Timeout : Timeout value in milliseconds.
mbed_official 330:c80ac197fa6a 1431 * @retval HAL status
mbed_official 330:c80ac197fa6a 1432 */
mbed_official 330:c80ac197fa6a 1433 HAL_StatusTypeDef HAL_SDADC_PollForInjectedConversion(SDADC_HandleTypeDef* hsdadc,
mbed_official 330:c80ac197fa6a 1434 uint32_t Timeout)
mbed_official 330:c80ac197fa6a 1435 {
mbed_official 330:c80ac197fa6a 1436 uint32_t tickstart;
mbed_official 330:c80ac197fa6a 1437
mbed_official 330:c80ac197fa6a 1438 /* Check parameters */
mbed_official 330:c80ac197fa6a 1439 assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance));
mbed_official 330:c80ac197fa6a 1440
mbed_official 330:c80ac197fa6a 1441 /* Check SDADC state */
mbed_official 330:c80ac197fa6a 1442 if((hsdadc->State != HAL_SDADC_STATE_INJ) && \
mbed_official 330:c80ac197fa6a 1443 (hsdadc->State != HAL_SDADC_STATE_REG_INJ))
mbed_official 330:c80ac197fa6a 1444 {
mbed_official 330:c80ac197fa6a 1445 /* Return error status */
mbed_official 330:c80ac197fa6a 1446 return HAL_ERROR;
mbed_official 330:c80ac197fa6a 1447 }
mbed_official 330:c80ac197fa6a 1448 else
mbed_official 330:c80ac197fa6a 1449 {
mbed_official 330:c80ac197fa6a 1450 /* Get timeout */
mbed_official 330:c80ac197fa6a 1451 tickstart = HAL_GetTick();
mbed_official 330:c80ac197fa6a 1452
mbed_official 330:c80ac197fa6a 1453 /* Wait JEOCF bit in SDADC_ISR register */
mbed_official 330:c80ac197fa6a 1454 while((hsdadc->Instance->ISR & SDADC_ISR_JEOCF) != SDADC_ISR_JEOCF)
mbed_official 330:c80ac197fa6a 1455 {
mbed_official 330:c80ac197fa6a 1456 /* Check the Timeout */
mbed_official 330:c80ac197fa6a 1457 if(Timeout != HAL_MAX_DELAY)
mbed_official 330:c80ac197fa6a 1458 {
mbed_official 330:c80ac197fa6a 1459 if((Timeout == 0) || ((HAL_GetTick()-tickstart) > Timeout))
mbed_official 330:c80ac197fa6a 1460 {
mbed_official 330:c80ac197fa6a 1461 /* Return timeout status */
mbed_official 330:c80ac197fa6a 1462 return HAL_TIMEOUT;
mbed_official 330:c80ac197fa6a 1463 }
mbed_official 330:c80ac197fa6a 1464 }
mbed_official 330:c80ac197fa6a 1465 }
mbed_official 330:c80ac197fa6a 1466 /* Check if overrun occurs */
mbed_official 330:c80ac197fa6a 1467 if((hsdadc->Instance->ISR & SDADC_ISR_JOVRF) == SDADC_ISR_JOVRF)
mbed_official 330:c80ac197fa6a 1468 {
mbed_official 330:c80ac197fa6a 1469 /* Update error code and call error callback */
mbed_official 330:c80ac197fa6a 1470 hsdadc->ErrorCode = SDADC_ERROR_INJECTED_OVERRUN;
mbed_official 330:c80ac197fa6a 1471 HAL_SDADC_ErrorCallback(hsdadc);
mbed_official 330:c80ac197fa6a 1472
mbed_official 330:c80ac197fa6a 1473 /* Set CLRJOVRF bit in SDADC_CLRISR register */
mbed_official 330:c80ac197fa6a 1474 hsdadc->Instance->CLRISR |= SDADC_ISR_CLRJOVRF;
mbed_official 330:c80ac197fa6a 1475 }
mbed_official 330:c80ac197fa6a 1476 /* Update remaining injected conversions */
mbed_official 330:c80ac197fa6a 1477 hsdadc->InjConvRemaining--;
mbed_official 330:c80ac197fa6a 1478 if(hsdadc->InjConvRemaining == 0)
mbed_official 330:c80ac197fa6a 1479 {
mbed_official 330:c80ac197fa6a 1480 /* end of injected sequence, reset the value */
mbed_official 330:c80ac197fa6a 1481 hsdadc->InjConvRemaining = hsdadc->InjectedChannelsNbr;
mbed_official 330:c80ac197fa6a 1482 }
mbed_official 330:c80ac197fa6a 1483
mbed_official 330:c80ac197fa6a 1484 /* Update SDADC state only if not continuous conversion, SW trigger */
mbed_official 330:c80ac197fa6a 1485 /* and end of injected sequence */
mbed_official 330:c80ac197fa6a 1486 if((hsdadc->InjectedContMode == SDADC_CONTINUOUS_CONV_OFF) && \
mbed_official 330:c80ac197fa6a 1487 (hsdadc->InjectedTrigger == SDADC_SOFTWARE_TRIGGER) && \
mbed_official 330:c80ac197fa6a 1488 (hsdadc->InjConvRemaining == hsdadc->InjectedChannelsNbr))
mbed_official 330:c80ac197fa6a 1489 {
mbed_official 330:c80ac197fa6a 1490 hsdadc->State = (hsdadc->State == HAL_SDADC_STATE_INJ) ? \
mbed_official 330:c80ac197fa6a 1491 HAL_SDADC_STATE_READY : HAL_SDADC_STATE_REG;
mbed_official 330:c80ac197fa6a 1492 }
mbed_official 330:c80ac197fa6a 1493 /* Return function status */
mbed_official 330:c80ac197fa6a 1494 return HAL_OK;
mbed_official 330:c80ac197fa6a 1495 }
mbed_official 330:c80ac197fa6a 1496 }
mbed_official 330:c80ac197fa6a 1497
mbed_official 330:c80ac197fa6a 1498 /**
mbed_official 330:c80ac197fa6a 1499 * @brief This function allows to stop injected conversion in polling mode.
mbed_official 330:c80ac197fa6a 1500 * @note This function should be called only if injected conversion is ongoing.
mbed_official 330:c80ac197fa6a 1501 * @param hsdadc : SDADC handle.
mbed_official 330:c80ac197fa6a 1502 * @retval HAL status
mbed_official 330:c80ac197fa6a 1503 */
mbed_official 330:c80ac197fa6a 1504 HAL_StatusTypeDef HAL_SDADC_InjectedStop(SDADC_HandleTypeDef *hsdadc)
mbed_official 330:c80ac197fa6a 1505 {
mbed_official 330:c80ac197fa6a 1506 HAL_StatusTypeDef status = HAL_OK;
mbed_official 330:c80ac197fa6a 1507
mbed_official 330:c80ac197fa6a 1508 /* Check parameters */
mbed_official 330:c80ac197fa6a 1509 assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance));
mbed_official 330:c80ac197fa6a 1510
mbed_official 330:c80ac197fa6a 1511 /* Check SDADC state */
mbed_official 330:c80ac197fa6a 1512 if((hsdadc->State != HAL_SDADC_STATE_INJ) && \
mbed_official 330:c80ac197fa6a 1513 (hsdadc->State != HAL_SDADC_STATE_REG_INJ))
mbed_official 330:c80ac197fa6a 1514 {
mbed_official 330:c80ac197fa6a 1515 /* Return error status */
mbed_official 330:c80ac197fa6a 1516 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 1517 }
mbed_official 330:c80ac197fa6a 1518 else
mbed_official 330:c80ac197fa6a 1519 {
mbed_official 330:c80ac197fa6a 1520 /* Stop injected conversion */
mbed_official 330:c80ac197fa6a 1521 status = SDADC_InjConvStop(hsdadc);
mbed_official 330:c80ac197fa6a 1522 }
mbed_official 330:c80ac197fa6a 1523 /* Return function status */
mbed_official 330:c80ac197fa6a 1524 return status;
mbed_official 330:c80ac197fa6a 1525 }
mbed_official 330:c80ac197fa6a 1526
mbed_official 330:c80ac197fa6a 1527 /**
mbed_official 330:c80ac197fa6a 1528 * @brief This function allows to start injected conversion in interrupt mode.
mbed_official 330:c80ac197fa6a 1529 * @note This function should be called only when SDADC instance is in idle state
mbed_official 330:c80ac197fa6a 1530 * or if regular conversion is ongoing.
mbed_official 330:c80ac197fa6a 1531 * @param hsdadc : SDADC handle.
mbed_official 330:c80ac197fa6a 1532 * @retval HAL status
mbed_official 330:c80ac197fa6a 1533 */
mbed_official 330:c80ac197fa6a 1534 HAL_StatusTypeDef HAL_SDADC_InjectedStart_IT(SDADC_HandleTypeDef *hsdadc)
mbed_official 330:c80ac197fa6a 1535 {
mbed_official 330:c80ac197fa6a 1536 HAL_StatusTypeDef status = HAL_OK;
mbed_official 330:c80ac197fa6a 1537
mbed_official 330:c80ac197fa6a 1538 /* Check parameters */
mbed_official 330:c80ac197fa6a 1539 assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance));
mbed_official 330:c80ac197fa6a 1540
mbed_official 330:c80ac197fa6a 1541 /* Check SDADC state */
mbed_official 330:c80ac197fa6a 1542 if((hsdadc->State == HAL_SDADC_STATE_READY) || \
mbed_official 330:c80ac197fa6a 1543 (hsdadc->State == HAL_SDADC_STATE_REG))
mbed_official 330:c80ac197fa6a 1544 {
mbed_official 330:c80ac197fa6a 1545 /* Set JEOCIE and JOVRIE bits in SDADC_CR1 register */
mbed_official 330:c80ac197fa6a 1546 hsdadc->Instance->CR1 |= (uint32_t) (SDADC_CR1_JEOCIE | SDADC_CR1_JOVRIE);
mbed_official 330:c80ac197fa6a 1547
mbed_official 330:c80ac197fa6a 1548 /* Start injected conversion */
mbed_official 330:c80ac197fa6a 1549 status = SDADC_InjConvStart(hsdadc);
mbed_official 330:c80ac197fa6a 1550 }
mbed_official 330:c80ac197fa6a 1551 else
mbed_official 330:c80ac197fa6a 1552 {
mbed_official 330:c80ac197fa6a 1553 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 1554 }
mbed_official 330:c80ac197fa6a 1555 /* Return function status */
mbed_official 330:c80ac197fa6a 1556 return status;
mbed_official 330:c80ac197fa6a 1557 }
mbed_official 330:c80ac197fa6a 1558
mbed_official 330:c80ac197fa6a 1559 /**
mbed_official 330:c80ac197fa6a 1560 * @brief This function allows to stop injected conversion in interrupt mode.
mbed_official 330:c80ac197fa6a 1561 * @note This function should be called only if injected conversion is ongoing.
mbed_official 330:c80ac197fa6a 1562 * @param hsdadc : SDADC handle.
mbed_official 330:c80ac197fa6a 1563 * @retval HAL status
mbed_official 330:c80ac197fa6a 1564 */
mbed_official 330:c80ac197fa6a 1565 HAL_StatusTypeDef HAL_SDADC_InjectedStop_IT(SDADC_HandleTypeDef *hsdadc)
mbed_official 330:c80ac197fa6a 1566 {
mbed_official 330:c80ac197fa6a 1567 HAL_StatusTypeDef status = HAL_OK;
mbed_official 330:c80ac197fa6a 1568
mbed_official 330:c80ac197fa6a 1569 /* Check parameters */
mbed_official 330:c80ac197fa6a 1570 assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance));
mbed_official 330:c80ac197fa6a 1571
mbed_official 330:c80ac197fa6a 1572 /* Check SDADC state */
mbed_official 330:c80ac197fa6a 1573 if((hsdadc->State != HAL_SDADC_STATE_INJ) && \
mbed_official 330:c80ac197fa6a 1574 (hsdadc->State != HAL_SDADC_STATE_REG_INJ))
mbed_official 330:c80ac197fa6a 1575 {
mbed_official 330:c80ac197fa6a 1576 /* Return error status */
mbed_official 330:c80ac197fa6a 1577 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 1578 }
mbed_official 330:c80ac197fa6a 1579 else
mbed_official 330:c80ac197fa6a 1580 {
mbed_official 330:c80ac197fa6a 1581 /* Clear JEOCIE and JOVRIE bits in SDADC_CR1 register */
mbed_official 330:c80ac197fa6a 1582 hsdadc->Instance->CR1 &= (uint32_t) ~(SDADC_CR1_JEOCIE | SDADC_CR1_JOVRIE);
mbed_official 330:c80ac197fa6a 1583
mbed_official 330:c80ac197fa6a 1584 /* Stop injected conversion */
mbed_official 330:c80ac197fa6a 1585 status = SDADC_InjConvStop(hsdadc);
mbed_official 330:c80ac197fa6a 1586 }
mbed_official 330:c80ac197fa6a 1587 /* Return function status */
mbed_official 330:c80ac197fa6a 1588 return status;
mbed_official 330:c80ac197fa6a 1589 }
mbed_official 330:c80ac197fa6a 1590
mbed_official 330:c80ac197fa6a 1591 /**
mbed_official 330:c80ac197fa6a 1592 * @brief This function allows to start injected conversion in DMA mode.
mbed_official 330:c80ac197fa6a 1593 * @note This function should be called only when SDADC instance is in idle state
mbed_official 330:c80ac197fa6a 1594 * or if regular conversion is ongoing.
mbed_official 330:c80ac197fa6a 1595 * @param hsdadc : SDADC handle.
mbed_official 330:c80ac197fa6a 1596 * @param pData : The destination buffer address.
mbed_official 330:c80ac197fa6a 1597 * @param Length : The length of data to be transferred from SDADC peripheral to memory.
mbed_official 330:c80ac197fa6a 1598 * @retval HAL status
mbed_official 330:c80ac197fa6a 1599 */
mbed_official 330:c80ac197fa6a 1600 HAL_StatusTypeDef HAL_SDADC_InjectedStart_DMA(SDADC_HandleTypeDef *hsdadc, uint32_t *pData,
mbed_official 330:c80ac197fa6a 1601 uint32_t Length)
mbed_official 330:c80ac197fa6a 1602 {
mbed_official 330:c80ac197fa6a 1603 HAL_StatusTypeDef status = HAL_OK;
mbed_official 330:c80ac197fa6a 1604
mbed_official 330:c80ac197fa6a 1605 /* Check parameters */
mbed_official 330:c80ac197fa6a 1606 assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance));
mbed_official 634:ac7d6880524d 1607 assert_param(pData != HAL_NULL);
mbed_official 330:c80ac197fa6a 1608 assert_param(Length != 0);
mbed_official 330:c80ac197fa6a 1609
mbed_official 330:c80ac197fa6a 1610 /* Check that DMA is not enabled for regular conversion */
mbed_official 330:c80ac197fa6a 1611 if((hsdadc->Instance->CR1 & SDADC_CR1_RDMAEN) == SDADC_CR1_RDMAEN)
mbed_official 330:c80ac197fa6a 1612 {
mbed_official 330:c80ac197fa6a 1613 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 1614 }
mbed_official 330:c80ac197fa6a 1615 /* Check parameters compatibility */
mbed_official 330:c80ac197fa6a 1616 else if((hsdadc->InjectedTrigger == SDADC_SOFTWARE_TRIGGER) && \
mbed_official 330:c80ac197fa6a 1617 (hsdadc->InjectedContMode == SDADC_CONTINUOUS_CONV_OFF) && \
mbed_official 330:c80ac197fa6a 1618 (hsdadc->hdma->Init.Mode == DMA_NORMAL) && \
mbed_official 330:c80ac197fa6a 1619 (Length > hsdadc->InjectedChannelsNbr))
mbed_official 330:c80ac197fa6a 1620 {
mbed_official 330:c80ac197fa6a 1621 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 1622 }
mbed_official 330:c80ac197fa6a 1623 else if((hsdadc->InjectedTrigger == SDADC_SOFTWARE_TRIGGER) && \
mbed_official 330:c80ac197fa6a 1624 (hsdadc->InjectedContMode == SDADC_CONTINUOUS_CONV_OFF) && \
mbed_official 330:c80ac197fa6a 1625 (hsdadc->hdma->Init.Mode == DMA_CIRCULAR))
mbed_official 330:c80ac197fa6a 1626 {
mbed_official 330:c80ac197fa6a 1627 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 1628 }
mbed_official 330:c80ac197fa6a 1629 /* Check SDADC state */
mbed_official 330:c80ac197fa6a 1630 else if((hsdadc->State == HAL_SDADC_STATE_READY) || \
mbed_official 330:c80ac197fa6a 1631 (hsdadc->State == HAL_SDADC_STATE_REG))
mbed_official 330:c80ac197fa6a 1632 {
mbed_official 330:c80ac197fa6a 1633 /* Set callbacks on DMA handler */
mbed_official 330:c80ac197fa6a 1634 hsdadc->hdma->XferCpltCallback = SDADC_DMAInjectedConvCplt;
mbed_official 330:c80ac197fa6a 1635 hsdadc->hdma->XferErrorCallback = SDADC_DMAError;
mbed_official 330:c80ac197fa6a 1636 if(hsdadc->hdma->Init.Mode == DMA_CIRCULAR)
mbed_official 330:c80ac197fa6a 1637 {
mbed_official 330:c80ac197fa6a 1638 hsdadc->hdma->XferHalfCpltCallback = SDADC_DMAInjectedHalfConvCplt;
mbed_official 330:c80ac197fa6a 1639 }
mbed_official 330:c80ac197fa6a 1640
mbed_official 330:c80ac197fa6a 1641 /* Set JDMAEN bit in SDADC_CR1 register */
mbed_official 330:c80ac197fa6a 1642 hsdadc->Instance->CR1 |= SDADC_CR1_JDMAEN;
mbed_official 330:c80ac197fa6a 1643
mbed_official 330:c80ac197fa6a 1644 /* Start DMA in interrupt mode */
mbed_official 330:c80ac197fa6a 1645 if(HAL_DMA_Start_IT(hsdadc->hdma, (uint32_t)&hsdadc->Instance->JDATAR, \
mbed_official 330:c80ac197fa6a 1646 (uint32_t) pData, Length) != HAL_OK)
mbed_official 330:c80ac197fa6a 1647 {
mbed_official 330:c80ac197fa6a 1648 /* Set SDADC in error state */
mbed_official 330:c80ac197fa6a 1649 hsdadc->State = HAL_SDADC_STATE_ERROR;
mbed_official 330:c80ac197fa6a 1650 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 1651 }
mbed_official 330:c80ac197fa6a 1652 else
mbed_official 330:c80ac197fa6a 1653 {
mbed_official 330:c80ac197fa6a 1654 /* Start injected conversion */
mbed_official 330:c80ac197fa6a 1655 status = SDADC_InjConvStart(hsdadc);
mbed_official 330:c80ac197fa6a 1656 }
mbed_official 330:c80ac197fa6a 1657 }
mbed_official 330:c80ac197fa6a 1658 else
mbed_official 330:c80ac197fa6a 1659 {
mbed_official 330:c80ac197fa6a 1660 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 1661 }
mbed_official 330:c80ac197fa6a 1662 /* Return function status */
mbed_official 330:c80ac197fa6a 1663 return status;
mbed_official 330:c80ac197fa6a 1664 }
mbed_official 330:c80ac197fa6a 1665
mbed_official 330:c80ac197fa6a 1666 /**
mbed_official 330:c80ac197fa6a 1667 * @brief This function allows to stop injected conversion in DMA mode.
mbed_official 330:c80ac197fa6a 1668 * @note This function should be called only if injected conversion is ongoing.
mbed_official 330:c80ac197fa6a 1669 * @param hsdadc : SDADC handle.
mbed_official 330:c80ac197fa6a 1670 * @retval HAL status
mbed_official 330:c80ac197fa6a 1671 */
mbed_official 330:c80ac197fa6a 1672 HAL_StatusTypeDef HAL_SDADC_InjectedStop_DMA(SDADC_HandleTypeDef *hsdadc)
mbed_official 330:c80ac197fa6a 1673 {
mbed_official 330:c80ac197fa6a 1674 HAL_StatusTypeDef status = HAL_OK;
mbed_official 330:c80ac197fa6a 1675
mbed_official 330:c80ac197fa6a 1676 /* Check parameters */
mbed_official 330:c80ac197fa6a 1677 assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance));
mbed_official 330:c80ac197fa6a 1678
mbed_official 330:c80ac197fa6a 1679 /* Check SDADC state */
mbed_official 330:c80ac197fa6a 1680 if((hsdadc->State != HAL_SDADC_STATE_INJ) && \
mbed_official 330:c80ac197fa6a 1681 (hsdadc->State != HAL_SDADC_STATE_REG_INJ))
mbed_official 330:c80ac197fa6a 1682 {
mbed_official 330:c80ac197fa6a 1683 /* Return error status */
mbed_official 330:c80ac197fa6a 1684 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 1685 }
mbed_official 330:c80ac197fa6a 1686 else
mbed_official 330:c80ac197fa6a 1687 {
mbed_official 330:c80ac197fa6a 1688 /* Clear JDMAEN bit in SDADC_CR1 register */
mbed_official 330:c80ac197fa6a 1689 hsdadc->Instance->CR1 &= ~(SDADC_CR1_JDMAEN);
mbed_official 330:c80ac197fa6a 1690
mbed_official 330:c80ac197fa6a 1691 /* Stop current DMA transfer */
mbed_official 330:c80ac197fa6a 1692 if(HAL_DMA_Abort(hsdadc->hdma) != HAL_OK)
mbed_official 330:c80ac197fa6a 1693 {
mbed_official 330:c80ac197fa6a 1694 /* Set SDADC in error state */
mbed_official 330:c80ac197fa6a 1695 hsdadc->State = HAL_SDADC_STATE_ERROR;
mbed_official 330:c80ac197fa6a 1696 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 1697 }
mbed_official 330:c80ac197fa6a 1698 else
mbed_official 330:c80ac197fa6a 1699 {
mbed_official 330:c80ac197fa6a 1700 /* Stop injected conversion */
mbed_official 330:c80ac197fa6a 1701 status = SDADC_InjConvStop(hsdadc);
mbed_official 330:c80ac197fa6a 1702 }
mbed_official 330:c80ac197fa6a 1703 }
mbed_official 330:c80ac197fa6a 1704 /* Return function status */
mbed_official 330:c80ac197fa6a 1705 return status;
mbed_official 330:c80ac197fa6a 1706 }
mbed_official 330:c80ac197fa6a 1707
mbed_official 330:c80ac197fa6a 1708 /**
mbed_official 330:c80ac197fa6a 1709 * @brief This function allows to get injected conversion value.
mbed_official 330:c80ac197fa6a 1710 * @param hsdadc : SDADC handle.
mbed_official 330:c80ac197fa6a 1711 * @param Channel : Corresponding channel of injected conversion.
mbed_official 330:c80ac197fa6a 1712 * @retval Injected conversion value
mbed_official 330:c80ac197fa6a 1713 */
mbed_official 330:c80ac197fa6a 1714 uint32_t HAL_SDADC_InjectedGetValue(SDADC_HandleTypeDef *hsdadc, uint32_t* Channel)
mbed_official 330:c80ac197fa6a 1715 {
mbed_official 330:c80ac197fa6a 1716 uint32_t value = 0;
mbed_official 330:c80ac197fa6a 1717
mbed_official 330:c80ac197fa6a 1718 /* Check parameters */
mbed_official 330:c80ac197fa6a 1719 assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance));
mbed_official 634:ac7d6880524d 1720 assert_param(Channel != HAL_NULL);
mbed_official 330:c80ac197fa6a 1721
mbed_official 330:c80ac197fa6a 1722 /* Read SDADC_JDATAR register and extract channel and conversion value */
mbed_official 330:c80ac197fa6a 1723 value = hsdadc->Instance->JDATAR;
mbed_official 330:c80ac197fa6a 1724 *Channel = ((value & SDADC_JDATAR_JDATACH) >> SDADC_JDATAR_CH_OFFSET);
mbed_official 330:c80ac197fa6a 1725 value &= SDADC_JDATAR_JDATA;
mbed_official 330:c80ac197fa6a 1726
mbed_official 330:c80ac197fa6a 1727 /* Return injected conversion value */
mbed_official 330:c80ac197fa6a 1728 return value;
mbed_official 330:c80ac197fa6a 1729 }
mbed_official 330:c80ac197fa6a 1730
mbed_official 330:c80ac197fa6a 1731 /**
mbed_official 330:c80ac197fa6a 1732 * @brief This function allows to start multimode regular conversions in DMA mode.
mbed_official 330:c80ac197fa6a 1733 * @note This function should be called only when SDADC instance is in idle state
mbed_official 330:c80ac197fa6a 1734 * or if injected conversion is ongoing.
mbed_official 330:c80ac197fa6a 1735 * @param hsdadc : SDADC handle.
mbed_official 330:c80ac197fa6a 1736 * @param pData : The destination buffer address.
mbed_official 330:c80ac197fa6a 1737 * @param Length : The length of data to be transferred from SDADC peripheral to memory.
mbed_official 330:c80ac197fa6a 1738 * @retval HAL status
mbed_official 330:c80ac197fa6a 1739 */
mbed_official 330:c80ac197fa6a 1740 HAL_StatusTypeDef HAL_SDADC_MultiModeStart_DMA(SDADC_HandleTypeDef* hsdadc, uint32_t* pData,
mbed_official 330:c80ac197fa6a 1741 uint32_t Length)
mbed_official 330:c80ac197fa6a 1742 {
mbed_official 330:c80ac197fa6a 1743 HAL_StatusTypeDef status = HAL_OK;
mbed_official 330:c80ac197fa6a 1744
mbed_official 330:c80ac197fa6a 1745 /* Check parameters */
mbed_official 330:c80ac197fa6a 1746 assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance));
mbed_official 634:ac7d6880524d 1747 assert_param(pData != HAL_NULL);
mbed_official 330:c80ac197fa6a 1748 assert_param(Length != 0);
mbed_official 330:c80ac197fa6a 1749
mbed_official 330:c80ac197fa6a 1750 /* Check instance is SDADC1 */
mbed_official 330:c80ac197fa6a 1751 if(hsdadc->Instance != SDADC1)
mbed_official 330:c80ac197fa6a 1752 {
mbed_official 330:c80ac197fa6a 1753 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 1754 }
mbed_official 330:c80ac197fa6a 1755 /* Check that DMA is not enabled for injected conversion */
mbed_official 330:c80ac197fa6a 1756 else if((hsdadc->Instance->CR1 & SDADC_CR1_JDMAEN) == SDADC_CR1_JDMAEN)
mbed_official 330:c80ac197fa6a 1757 {
mbed_official 330:c80ac197fa6a 1758 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 1759 }
mbed_official 330:c80ac197fa6a 1760 /* Check parameters compatibility */
mbed_official 330:c80ac197fa6a 1761 else if((hsdadc->RegularTrigger == SDADC_SOFTWARE_TRIGGER) && \
mbed_official 330:c80ac197fa6a 1762 (hsdadc->RegularContMode == SDADC_CONTINUOUS_CONV_OFF) && \
mbed_official 330:c80ac197fa6a 1763 (hsdadc->hdma->Init.Mode == DMA_NORMAL) && \
mbed_official 330:c80ac197fa6a 1764 (Length != 1))
mbed_official 330:c80ac197fa6a 1765 {
mbed_official 330:c80ac197fa6a 1766 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 1767 }
mbed_official 330:c80ac197fa6a 1768 else if((hsdadc->RegularTrigger == SDADC_SOFTWARE_TRIGGER) && \
mbed_official 330:c80ac197fa6a 1769 (hsdadc->RegularContMode == SDADC_CONTINUOUS_CONV_OFF) && \
mbed_official 330:c80ac197fa6a 1770 (hsdadc->hdma->Init.Mode == DMA_CIRCULAR))
mbed_official 330:c80ac197fa6a 1771 {
mbed_official 330:c80ac197fa6a 1772 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 1773 }
mbed_official 330:c80ac197fa6a 1774 /* Check SDADC state */
mbed_official 330:c80ac197fa6a 1775 else if((hsdadc->State == HAL_SDADC_STATE_READY) || \
mbed_official 330:c80ac197fa6a 1776 (hsdadc->State == HAL_SDADC_STATE_INJ))
mbed_official 330:c80ac197fa6a 1777 {
mbed_official 330:c80ac197fa6a 1778 /* Set callbacks on DMA handler */
mbed_official 330:c80ac197fa6a 1779 hsdadc->hdma->XferCpltCallback = SDADC_DMARegularConvCplt;
mbed_official 330:c80ac197fa6a 1780 hsdadc->hdma->XferErrorCallback = SDADC_DMAError;
mbed_official 330:c80ac197fa6a 1781 if(hsdadc->hdma->Init.Mode == DMA_CIRCULAR)
mbed_official 330:c80ac197fa6a 1782 {
mbed_official 330:c80ac197fa6a 1783 hsdadc->hdma->XferHalfCpltCallback = SDADC_DMARegularHalfConvCplt;
mbed_official 330:c80ac197fa6a 1784 }
mbed_official 330:c80ac197fa6a 1785 /* Set RDMAEN bit in SDADC_CR1 register */
mbed_official 330:c80ac197fa6a 1786 hsdadc->Instance->CR1 |= SDADC_CR1_RDMAEN;
mbed_official 330:c80ac197fa6a 1787
mbed_official 330:c80ac197fa6a 1788 /* Start DMA in interrupt mode */
mbed_official 330:c80ac197fa6a 1789 if(hsdadc->RegularMultimode == SDADC_MULTIMODE_SDADC1_SDADC2)
mbed_official 330:c80ac197fa6a 1790 {
mbed_official 330:c80ac197fa6a 1791 status = HAL_DMA_Start_IT(hsdadc->hdma, (uint32_t)&hsdadc->Instance->RDATA12R, \
mbed_official 330:c80ac197fa6a 1792 (uint32_t) pData, Length);
mbed_official 330:c80ac197fa6a 1793 }
mbed_official 330:c80ac197fa6a 1794 else
mbed_official 330:c80ac197fa6a 1795 {
mbed_official 330:c80ac197fa6a 1796 status = HAL_DMA_Start_IT(hsdadc->hdma, (uint32_t)&hsdadc->Instance->RDATA13R, \
mbed_official 330:c80ac197fa6a 1797 (uint32_t) pData, Length);
mbed_official 330:c80ac197fa6a 1798 }
mbed_official 330:c80ac197fa6a 1799 if(status != HAL_OK)
mbed_official 330:c80ac197fa6a 1800 {
mbed_official 330:c80ac197fa6a 1801 /* Set SDADC in error state */
mbed_official 330:c80ac197fa6a 1802 hsdadc->State = HAL_SDADC_STATE_ERROR;
mbed_official 330:c80ac197fa6a 1803 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 1804 }
mbed_official 330:c80ac197fa6a 1805 else
mbed_official 330:c80ac197fa6a 1806 {
mbed_official 330:c80ac197fa6a 1807 /* Start regular conversion */
mbed_official 330:c80ac197fa6a 1808 status = SDADC_RegConvStart(hsdadc);
mbed_official 330:c80ac197fa6a 1809 }
mbed_official 330:c80ac197fa6a 1810 }
mbed_official 330:c80ac197fa6a 1811 else
mbed_official 330:c80ac197fa6a 1812 {
mbed_official 330:c80ac197fa6a 1813 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 1814 }
mbed_official 330:c80ac197fa6a 1815 /* Return function status */
mbed_official 330:c80ac197fa6a 1816 return status;
mbed_official 330:c80ac197fa6a 1817 }
mbed_official 330:c80ac197fa6a 1818
mbed_official 330:c80ac197fa6a 1819 /**
mbed_official 330:c80ac197fa6a 1820 * @brief This function allows to stop multimode regular conversions in DMA mode.
mbed_official 330:c80ac197fa6a 1821 * @note This function should be called only if regular conversion is ongoing.
mbed_official 330:c80ac197fa6a 1822 * @param hsdadc : SDADC handle.
mbed_official 330:c80ac197fa6a 1823 * @retval HAL status
mbed_official 330:c80ac197fa6a 1824 */
mbed_official 330:c80ac197fa6a 1825 HAL_StatusTypeDef HAL_SDADC_MultiModeStop_DMA(SDADC_HandleTypeDef* hsdadc)
mbed_official 330:c80ac197fa6a 1826 {
mbed_official 330:c80ac197fa6a 1827 HAL_StatusTypeDef status = HAL_OK;
mbed_official 330:c80ac197fa6a 1828
mbed_official 330:c80ac197fa6a 1829 /* Check parameters */
mbed_official 330:c80ac197fa6a 1830 assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance));
mbed_official 330:c80ac197fa6a 1831
mbed_official 330:c80ac197fa6a 1832 /* Check instance is SDADC1 */
mbed_official 330:c80ac197fa6a 1833 if(hsdadc->Instance != SDADC1)
mbed_official 330:c80ac197fa6a 1834 {
mbed_official 330:c80ac197fa6a 1835 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 1836 }
mbed_official 330:c80ac197fa6a 1837 /* Check SDADC state */
mbed_official 330:c80ac197fa6a 1838 else if((hsdadc->State != HAL_SDADC_STATE_REG) && \
mbed_official 330:c80ac197fa6a 1839 (hsdadc->State != HAL_SDADC_STATE_REG_INJ))
mbed_official 330:c80ac197fa6a 1840 {
mbed_official 330:c80ac197fa6a 1841 /* Return error status */
mbed_official 330:c80ac197fa6a 1842 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 1843 }
mbed_official 330:c80ac197fa6a 1844 else
mbed_official 330:c80ac197fa6a 1845 {
mbed_official 330:c80ac197fa6a 1846 /* Clear RDMAEN bit in SDADC_CR1 register */
mbed_official 330:c80ac197fa6a 1847 hsdadc->Instance->CR1 &= ~(SDADC_CR1_RDMAEN);
mbed_official 330:c80ac197fa6a 1848
mbed_official 330:c80ac197fa6a 1849 /* Stop current DMA transfer */
mbed_official 330:c80ac197fa6a 1850 if(HAL_DMA_Abort(hsdadc->hdma) != HAL_OK)
mbed_official 330:c80ac197fa6a 1851 {
mbed_official 330:c80ac197fa6a 1852 /* Set SDADC in error state */
mbed_official 330:c80ac197fa6a 1853 hsdadc->State = HAL_SDADC_STATE_ERROR;
mbed_official 330:c80ac197fa6a 1854 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 1855 }
mbed_official 330:c80ac197fa6a 1856 else
mbed_official 330:c80ac197fa6a 1857 {
mbed_official 330:c80ac197fa6a 1858 /* Stop regular conversion */
mbed_official 330:c80ac197fa6a 1859 status = SDADC_RegConvStop(hsdadc);
mbed_official 330:c80ac197fa6a 1860 }
mbed_official 330:c80ac197fa6a 1861 }
mbed_official 330:c80ac197fa6a 1862 /* Return function status */
mbed_official 330:c80ac197fa6a 1863 return status;
mbed_official 330:c80ac197fa6a 1864 }
mbed_official 330:c80ac197fa6a 1865
mbed_official 330:c80ac197fa6a 1866 /**
mbed_official 330:c80ac197fa6a 1867 * @brief This function allows to get multimode regular conversion value.
mbed_official 330:c80ac197fa6a 1868 * @param hsdadc : SDADC handle.
mbed_official 330:c80ac197fa6a 1869 * @retval Multimode regular conversion value
mbed_official 330:c80ac197fa6a 1870 */
mbed_official 330:c80ac197fa6a 1871 uint32_t HAL_SDADC_MultiModeGetValue(SDADC_HandleTypeDef* hsdadc)
mbed_official 330:c80ac197fa6a 1872 {
mbed_official 330:c80ac197fa6a 1873 uint32_t value = 0;
mbed_official 330:c80ac197fa6a 1874
mbed_official 330:c80ac197fa6a 1875 /* Check parameters and check instance is SDADC1 */
mbed_official 330:c80ac197fa6a 1876 assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance));
mbed_official 330:c80ac197fa6a 1877 assert_param(hsdadc->Instance == SDADC1);
mbed_official 330:c80ac197fa6a 1878
mbed_official 330:c80ac197fa6a 1879 /* read multimode regular value */
mbed_official 330:c80ac197fa6a 1880 value = (hsdadc->RegularMultimode == SDADC_MULTIMODE_SDADC1_SDADC2) ? \
mbed_official 330:c80ac197fa6a 1881 hsdadc->Instance->RDATA12R : hsdadc->Instance->RDATA13R;
mbed_official 330:c80ac197fa6a 1882
mbed_official 330:c80ac197fa6a 1883 /* Return multimode regular conversions value */
mbed_official 330:c80ac197fa6a 1884 return value;
mbed_official 330:c80ac197fa6a 1885 }
mbed_official 330:c80ac197fa6a 1886
mbed_official 330:c80ac197fa6a 1887 /**
mbed_official 330:c80ac197fa6a 1888 * @brief This function allows to start multimode injected conversions in DMA mode.
mbed_official 330:c80ac197fa6a 1889 * @note This function should be called only when SDADC instance is in idle state
mbed_official 330:c80ac197fa6a 1890 * or if regular conversion is ongoing.
mbed_official 330:c80ac197fa6a 1891 * @param hsdadc : SDADC handle.
mbed_official 330:c80ac197fa6a 1892 * @param pData : The destination buffer address.
mbed_official 330:c80ac197fa6a 1893 * @param Length : The length of data to be transferred from SDADC peripheral to memory.
mbed_official 330:c80ac197fa6a 1894 * @retval HAL status
mbed_official 330:c80ac197fa6a 1895 */
mbed_official 330:c80ac197fa6a 1896 HAL_StatusTypeDef HAL_SDADC_InjectedMultiModeStart_DMA(SDADC_HandleTypeDef* hsdadc,
mbed_official 330:c80ac197fa6a 1897 uint32_t* pData, uint32_t Length)
mbed_official 330:c80ac197fa6a 1898 {
mbed_official 330:c80ac197fa6a 1899 HAL_StatusTypeDef status = HAL_OK;
mbed_official 330:c80ac197fa6a 1900
mbed_official 330:c80ac197fa6a 1901 /* Check parameters */
mbed_official 330:c80ac197fa6a 1902 assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance));
mbed_official 634:ac7d6880524d 1903 assert_param(pData != HAL_NULL);
mbed_official 330:c80ac197fa6a 1904 assert_param(Length != 0);
mbed_official 330:c80ac197fa6a 1905
mbed_official 330:c80ac197fa6a 1906 /* Check instance is SDADC1 */
mbed_official 330:c80ac197fa6a 1907 if(hsdadc->Instance != SDADC1)
mbed_official 330:c80ac197fa6a 1908 {
mbed_official 330:c80ac197fa6a 1909 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 1910 }
mbed_official 330:c80ac197fa6a 1911 /* Check that DMA is not enabled for regular conversion */
mbed_official 330:c80ac197fa6a 1912 else if((hsdadc->Instance->CR1 & SDADC_CR1_RDMAEN) == SDADC_CR1_RDMAEN)
mbed_official 330:c80ac197fa6a 1913 {
mbed_official 330:c80ac197fa6a 1914 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 1915 }
mbed_official 330:c80ac197fa6a 1916 /* Check parameters compatibility */
mbed_official 330:c80ac197fa6a 1917 else if((hsdadc->InjectedTrigger == SDADC_SOFTWARE_TRIGGER) && \
mbed_official 330:c80ac197fa6a 1918 (hsdadc->InjectedContMode == SDADC_CONTINUOUS_CONV_OFF) && \
mbed_official 330:c80ac197fa6a 1919 (hsdadc->hdma->Init.Mode == DMA_NORMAL) && \
mbed_official 330:c80ac197fa6a 1920 (Length > (hsdadc->InjectedChannelsNbr << 1)))
mbed_official 330:c80ac197fa6a 1921 {
mbed_official 330:c80ac197fa6a 1922 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 1923 }
mbed_official 330:c80ac197fa6a 1924 else if((hsdadc->InjectedTrigger == SDADC_SOFTWARE_TRIGGER) && \
mbed_official 330:c80ac197fa6a 1925 (hsdadc->InjectedContMode == SDADC_CONTINUOUS_CONV_OFF) && \
mbed_official 330:c80ac197fa6a 1926 (hsdadc->hdma->Init.Mode == DMA_CIRCULAR))
mbed_official 330:c80ac197fa6a 1927 {
mbed_official 330:c80ac197fa6a 1928 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 1929 }
mbed_official 330:c80ac197fa6a 1930 /* Check SDADC state */
mbed_official 330:c80ac197fa6a 1931 else if((hsdadc->State == HAL_SDADC_STATE_READY) || \
mbed_official 330:c80ac197fa6a 1932 (hsdadc->State == HAL_SDADC_STATE_REG))
mbed_official 330:c80ac197fa6a 1933 {
mbed_official 330:c80ac197fa6a 1934 /* Set callbacks on DMA handler */
mbed_official 330:c80ac197fa6a 1935 hsdadc->hdma->XferCpltCallback = SDADC_DMAInjectedConvCplt;
mbed_official 330:c80ac197fa6a 1936 hsdadc->hdma->XferErrorCallback = SDADC_DMAError;
mbed_official 330:c80ac197fa6a 1937 if(hsdadc->hdma->Init.Mode == DMA_CIRCULAR)
mbed_official 330:c80ac197fa6a 1938 {
mbed_official 330:c80ac197fa6a 1939 hsdadc->hdma->XferHalfCpltCallback = SDADC_DMAInjectedHalfConvCplt;
mbed_official 330:c80ac197fa6a 1940 }
mbed_official 330:c80ac197fa6a 1941 /* Set JDMAEN bit in SDADC_CR1 register */
mbed_official 330:c80ac197fa6a 1942 hsdadc->Instance->CR1 |= SDADC_CR1_JDMAEN;
mbed_official 330:c80ac197fa6a 1943
mbed_official 330:c80ac197fa6a 1944 /* Start DMA in interrupt mode */
mbed_official 330:c80ac197fa6a 1945 if(hsdadc->InjectedMultimode == SDADC_MULTIMODE_SDADC1_SDADC2)
mbed_official 330:c80ac197fa6a 1946 {
mbed_official 330:c80ac197fa6a 1947 status = HAL_DMA_Start_IT(hsdadc->hdma, (uint32_t)&hsdadc->Instance->JDATA12R, \
mbed_official 330:c80ac197fa6a 1948 (uint32_t) pData, Length);
mbed_official 330:c80ac197fa6a 1949 }
mbed_official 330:c80ac197fa6a 1950 else
mbed_official 330:c80ac197fa6a 1951 {
mbed_official 330:c80ac197fa6a 1952 status = HAL_DMA_Start_IT(hsdadc->hdma, (uint32_t)&hsdadc->Instance->JDATA13R, \
mbed_official 330:c80ac197fa6a 1953 (uint32_t) pData, Length);
mbed_official 330:c80ac197fa6a 1954 }
mbed_official 330:c80ac197fa6a 1955 if(status != HAL_OK)
mbed_official 330:c80ac197fa6a 1956 {
mbed_official 330:c80ac197fa6a 1957 /* Set SDADC in error state */
mbed_official 330:c80ac197fa6a 1958 hsdadc->State = HAL_SDADC_STATE_ERROR;
mbed_official 330:c80ac197fa6a 1959 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 1960 }
mbed_official 330:c80ac197fa6a 1961 else
mbed_official 330:c80ac197fa6a 1962 {
mbed_official 330:c80ac197fa6a 1963 /* Start injected conversion */
mbed_official 330:c80ac197fa6a 1964 status = SDADC_InjConvStart(hsdadc);
mbed_official 330:c80ac197fa6a 1965 }
mbed_official 330:c80ac197fa6a 1966 }
mbed_official 330:c80ac197fa6a 1967 else
mbed_official 330:c80ac197fa6a 1968 {
mbed_official 330:c80ac197fa6a 1969 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 1970 }
mbed_official 330:c80ac197fa6a 1971 /* Return function status */
mbed_official 330:c80ac197fa6a 1972 return status;
mbed_official 330:c80ac197fa6a 1973 }
mbed_official 330:c80ac197fa6a 1974
mbed_official 330:c80ac197fa6a 1975 /**
mbed_official 330:c80ac197fa6a 1976 * @brief This function allows to stop multimode injected conversions in DMA mode.
mbed_official 330:c80ac197fa6a 1977 * @note This function should be called only if injected conversion is ongoing.
mbed_official 330:c80ac197fa6a 1978 * @param hsdadc : SDADC handle.
mbed_official 330:c80ac197fa6a 1979 * @retval HAL status
mbed_official 330:c80ac197fa6a 1980 */
mbed_official 330:c80ac197fa6a 1981 HAL_StatusTypeDef HAL_SDADC_InjectedMultiModeStop_DMA(SDADC_HandleTypeDef* hsdadc)
mbed_official 330:c80ac197fa6a 1982 {
mbed_official 330:c80ac197fa6a 1983 HAL_StatusTypeDef status = HAL_OK;
mbed_official 330:c80ac197fa6a 1984
mbed_official 330:c80ac197fa6a 1985 /* Check parameters */
mbed_official 330:c80ac197fa6a 1986 assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance));
mbed_official 330:c80ac197fa6a 1987
mbed_official 330:c80ac197fa6a 1988 /* Check instance is SDADC1 */
mbed_official 330:c80ac197fa6a 1989 if(hsdadc->Instance != SDADC1)
mbed_official 330:c80ac197fa6a 1990 {
mbed_official 330:c80ac197fa6a 1991 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 1992 }
mbed_official 330:c80ac197fa6a 1993 /* Check SDADC state */
mbed_official 330:c80ac197fa6a 1994 else if((hsdadc->State != HAL_SDADC_STATE_INJ) && \
mbed_official 330:c80ac197fa6a 1995 (hsdadc->State != HAL_SDADC_STATE_REG_INJ))
mbed_official 330:c80ac197fa6a 1996 {
mbed_official 330:c80ac197fa6a 1997 /* Return error status */
mbed_official 330:c80ac197fa6a 1998 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 1999 }
mbed_official 330:c80ac197fa6a 2000 else
mbed_official 330:c80ac197fa6a 2001 {
mbed_official 330:c80ac197fa6a 2002 /* Clear JDMAEN bit in SDADC_CR1 register */
mbed_official 330:c80ac197fa6a 2003 hsdadc->Instance->CR1 &= ~(SDADC_CR1_JDMAEN);
mbed_official 330:c80ac197fa6a 2004
mbed_official 330:c80ac197fa6a 2005 /* Stop current DMA transfer */
mbed_official 330:c80ac197fa6a 2006 if(HAL_DMA_Abort(hsdadc->hdma) != HAL_OK)
mbed_official 330:c80ac197fa6a 2007 {
mbed_official 330:c80ac197fa6a 2008 /* Set SDADC in error state */
mbed_official 330:c80ac197fa6a 2009 hsdadc->State = HAL_SDADC_STATE_ERROR;
mbed_official 330:c80ac197fa6a 2010 status = HAL_ERROR;
mbed_official 330:c80ac197fa6a 2011 }
mbed_official 330:c80ac197fa6a 2012 else
mbed_official 330:c80ac197fa6a 2013 {
mbed_official 330:c80ac197fa6a 2014 /* Stop injected conversion */
mbed_official 330:c80ac197fa6a 2015 status = SDADC_InjConvStop(hsdadc);
mbed_official 330:c80ac197fa6a 2016 }
mbed_official 330:c80ac197fa6a 2017 }
mbed_official 330:c80ac197fa6a 2018 /* Return function status */
mbed_official 330:c80ac197fa6a 2019 return status;
mbed_official 330:c80ac197fa6a 2020 }
mbed_official 330:c80ac197fa6a 2021
mbed_official 330:c80ac197fa6a 2022 /**
mbed_official 330:c80ac197fa6a 2023 * @brief This function allows to get multimode injected conversion value.
mbed_official 330:c80ac197fa6a 2024 * @param hsdadc : SDADC handle.
mbed_official 330:c80ac197fa6a 2025 * @retval Multimode injected conversion value
mbed_official 330:c80ac197fa6a 2026 */
mbed_official 330:c80ac197fa6a 2027 uint32_t HAL_SDADC_InjectedMultiModeGetValue(SDADC_HandleTypeDef* hsdadc)
mbed_official 330:c80ac197fa6a 2028 {
mbed_official 330:c80ac197fa6a 2029 uint32_t value = 0;
mbed_official 330:c80ac197fa6a 2030
mbed_official 330:c80ac197fa6a 2031 /* Check parameters and check instance is SDADC1 */
mbed_official 330:c80ac197fa6a 2032 assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance));
mbed_official 330:c80ac197fa6a 2033 assert_param(hsdadc->Instance == SDADC1);
mbed_official 330:c80ac197fa6a 2034
mbed_official 330:c80ac197fa6a 2035 /* read multimode injected value */
mbed_official 330:c80ac197fa6a 2036 value = (hsdadc->InjectedMultimode == SDADC_MULTIMODE_SDADC1_SDADC2) ? \
mbed_official 330:c80ac197fa6a 2037 hsdadc->Instance->JDATA12R : hsdadc->Instance->JDATA13R;
mbed_official 330:c80ac197fa6a 2038
mbed_official 330:c80ac197fa6a 2039 /* Return multimode injected conversions value */
mbed_official 330:c80ac197fa6a 2040 return value;
mbed_official 330:c80ac197fa6a 2041 }
mbed_official 330:c80ac197fa6a 2042
mbed_official 330:c80ac197fa6a 2043 /**
mbed_official 330:c80ac197fa6a 2044 * @brief This function handles the SDADC interrupts.
mbed_official 330:c80ac197fa6a 2045 * @param hsdadc : SDADC handle.
mbed_official 330:c80ac197fa6a 2046 * @retval None
mbed_official 330:c80ac197fa6a 2047 */
mbed_official 330:c80ac197fa6a 2048 void HAL_SDADC_IRQHandler(SDADC_HandleTypeDef* hsdadc)
mbed_official 330:c80ac197fa6a 2049 {
mbed_official 330:c80ac197fa6a 2050 /* Check if end of regular conversion */
mbed_official 330:c80ac197fa6a 2051 if(((hsdadc->Instance->ISR & SDADC_ISR_REOCF) == SDADC_ISR_REOCF) && \
mbed_official 330:c80ac197fa6a 2052 ((hsdadc->Instance->CR1 & SDADC_CR1_REOCIE) == SDADC_CR1_REOCIE))
mbed_official 330:c80ac197fa6a 2053 {
mbed_official 330:c80ac197fa6a 2054 /* Call regular conversion complete callback */
mbed_official 330:c80ac197fa6a 2055 HAL_SDADC_ConvCpltCallback(hsdadc);
mbed_official 330:c80ac197fa6a 2056
mbed_official 330:c80ac197fa6a 2057 /* End of conversion if mode is not continuous and software trigger */
mbed_official 330:c80ac197fa6a 2058 if((hsdadc->RegularContMode == SDADC_CONTINUOUS_CONV_OFF) && \
mbed_official 330:c80ac197fa6a 2059 (hsdadc->RegularTrigger == SDADC_SOFTWARE_TRIGGER))
mbed_official 330:c80ac197fa6a 2060 {
mbed_official 330:c80ac197fa6a 2061 /* Clear REOCIE and ROVRIE bits in SDADC_CR1 register */
mbed_official 330:c80ac197fa6a 2062 hsdadc->Instance->CR1 &= ~(SDADC_CR1_REOCIE | SDADC_CR1_ROVRIE);
mbed_official 330:c80ac197fa6a 2063
mbed_official 330:c80ac197fa6a 2064 /* Update SDADC state */
mbed_official 330:c80ac197fa6a 2065 hsdadc->State = (hsdadc->State == HAL_SDADC_STATE_REG) ? \
mbed_official 330:c80ac197fa6a 2066 HAL_SDADC_STATE_READY : HAL_SDADC_STATE_INJ;
mbed_official 330:c80ac197fa6a 2067 }
mbed_official 330:c80ac197fa6a 2068 }
mbed_official 330:c80ac197fa6a 2069 /* Check if end of injected conversion */
mbed_official 330:c80ac197fa6a 2070 else if(((hsdadc->Instance->ISR & SDADC_ISR_JEOCF) == SDADC_ISR_JEOCF) && \
mbed_official 330:c80ac197fa6a 2071 ((hsdadc->Instance->CR1 & SDADC_CR1_JEOCIE) == SDADC_CR1_JEOCIE))
mbed_official 330:c80ac197fa6a 2072 {
mbed_official 330:c80ac197fa6a 2073 /* Call injected conversion complete callback */
mbed_official 330:c80ac197fa6a 2074 HAL_SDADC_InjectedConvCpltCallback(hsdadc);
mbed_official 330:c80ac197fa6a 2075
mbed_official 330:c80ac197fa6a 2076 /* Update remaining injected conversions */
mbed_official 330:c80ac197fa6a 2077 hsdadc->InjConvRemaining--;
mbed_official 330:c80ac197fa6a 2078 if(hsdadc->InjConvRemaining ==0)
mbed_official 330:c80ac197fa6a 2079 {
mbed_official 330:c80ac197fa6a 2080 /* end of injected sequence, reset the value */
mbed_official 330:c80ac197fa6a 2081 hsdadc->InjConvRemaining = hsdadc->InjectedChannelsNbr;
mbed_official 330:c80ac197fa6a 2082 }
mbed_official 330:c80ac197fa6a 2083 /* End of conversion if mode is not continuous, software trigger */
mbed_official 330:c80ac197fa6a 2084 /* and end of injected sequence */
mbed_official 330:c80ac197fa6a 2085 if((hsdadc->InjectedContMode == SDADC_CONTINUOUS_CONV_OFF) && \
mbed_official 330:c80ac197fa6a 2086 (hsdadc->InjectedTrigger == SDADC_SOFTWARE_TRIGGER) && \
mbed_official 330:c80ac197fa6a 2087 (hsdadc->InjConvRemaining == hsdadc->InjectedChannelsNbr))
mbed_official 330:c80ac197fa6a 2088 {
mbed_official 330:c80ac197fa6a 2089 /* Clear JEOCIE and JOVRIE bits in SDADC_CR1 register */
mbed_official 330:c80ac197fa6a 2090 hsdadc->Instance->CR1 &= ~(SDADC_CR1_JEOCIE | SDADC_CR1_JOVRIE);
mbed_official 330:c80ac197fa6a 2091
mbed_official 330:c80ac197fa6a 2092 /* Update SDADC state */
mbed_official 330:c80ac197fa6a 2093 hsdadc->State = (hsdadc->State == HAL_SDADC_STATE_INJ) ? \
mbed_official 330:c80ac197fa6a 2094 HAL_SDADC_STATE_READY : HAL_SDADC_STATE_REG;
mbed_official 330:c80ac197fa6a 2095 }
mbed_official 330:c80ac197fa6a 2096 }
mbed_official 330:c80ac197fa6a 2097 /* Check if end of calibration */
mbed_official 330:c80ac197fa6a 2098 else if(((hsdadc->Instance->ISR & SDADC_ISR_EOCALF) == SDADC_ISR_EOCALF) && \
mbed_official 330:c80ac197fa6a 2099 ((hsdadc->Instance->CR1 & SDADC_CR1_EOCALIE) == SDADC_CR1_EOCALIE))
mbed_official 330:c80ac197fa6a 2100 {
mbed_official 330:c80ac197fa6a 2101 /* Clear EOCALIE bit in SDADC_CR1 register */
mbed_official 330:c80ac197fa6a 2102 hsdadc->Instance->CR1 &= ~(SDADC_CR1_EOCALIE);
mbed_official 330:c80ac197fa6a 2103
mbed_official 330:c80ac197fa6a 2104 /* Set CLREOCALF bit in SDADC_CLRISR register */
mbed_official 330:c80ac197fa6a 2105 hsdadc->Instance->CLRISR |= SDADC_ISR_CLREOCALF;
mbed_official 330:c80ac197fa6a 2106
mbed_official 330:c80ac197fa6a 2107 /* Call calibration callback */
mbed_official 330:c80ac197fa6a 2108 HAL_SDADC_CalibrationCpltCallback(hsdadc);
mbed_official 330:c80ac197fa6a 2109
mbed_official 330:c80ac197fa6a 2110 /* Update SDADC state */
mbed_official 330:c80ac197fa6a 2111 hsdadc->State = HAL_SDADC_STATE_READY;
mbed_official 330:c80ac197fa6a 2112 }
mbed_official 330:c80ac197fa6a 2113 /* Check if overrun occurs during regular conversion */
mbed_official 330:c80ac197fa6a 2114 else if(((hsdadc->Instance->ISR & SDADC_ISR_ROVRF) == SDADC_ISR_ROVRF) && \
mbed_official 330:c80ac197fa6a 2115 ((hsdadc->Instance->CR1 & SDADC_CR1_ROVRIE) == SDADC_CR1_ROVRIE))
mbed_official 330:c80ac197fa6a 2116 {
mbed_official 330:c80ac197fa6a 2117 /* Set CLRROVRF bit in SDADC_CLRISR register */
mbed_official 330:c80ac197fa6a 2118 hsdadc->Instance->CLRISR |= SDADC_ISR_CLRROVRF;
mbed_official 330:c80ac197fa6a 2119
mbed_official 330:c80ac197fa6a 2120 /* Update error code */
mbed_official 330:c80ac197fa6a 2121 hsdadc->ErrorCode = SDADC_ERROR_REGULAR_OVERRUN;
mbed_official 330:c80ac197fa6a 2122
mbed_official 330:c80ac197fa6a 2123 /* Call error callback */
mbed_official 330:c80ac197fa6a 2124 HAL_SDADC_ErrorCallback(hsdadc);
mbed_official 330:c80ac197fa6a 2125 }
mbed_official 330:c80ac197fa6a 2126 /* Check if overrun occurs during injected conversion */
mbed_official 330:c80ac197fa6a 2127 else if(((hsdadc->Instance->ISR & SDADC_ISR_JOVRF) == SDADC_ISR_JOVRF) && \
mbed_official 330:c80ac197fa6a 2128 ((hsdadc->Instance->CR1 & SDADC_CR1_JOVRIE) == SDADC_CR1_JOVRIE))
mbed_official 330:c80ac197fa6a 2129 {
mbed_official 330:c80ac197fa6a 2130 /* Set CLRJOVRF bit in SDADC_CLRISR register */
mbed_official 330:c80ac197fa6a 2131 hsdadc->Instance->CLRISR |= SDADC_ISR_CLRJOVRF;
mbed_official 330:c80ac197fa6a 2132
mbed_official 330:c80ac197fa6a 2133 /* Update error code */
mbed_official 330:c80ac197fa6a 2134 hsdadc->ErrorCode = SDADC_ERROR_INJECTED_OVERRUN;
mbed_official 330:c80ac197fa6a 2135
mbed_official 330:c80ac197fa6a 2136 /* Call error callback */
mbed_official 330:c80ac197fa6a 2137 HAL_SDADC_ErrorCallback(hsdadc);
mbed_official 330:c80ac197fa6a 2138 }
mbed_official 330:c80ac197fa6a 2139 return;
mbed_official 330:c80ac197fa6a 2140 }
mbed_official 330:c80ac197fa6a 2141
mbed_official 330:c80ac197fa6a 2142 /**
mbed_official 330:c80ac197fa6a 2143 * @brief Calibration complete callback.
mbed_official 330:c80ac197fa6a 2144 * @param hsdadc : SDADC handle.
mbed_official 330:c80ac197fa6a 2145 * @retval None
mbed_official 330:c80ac197fa6a 2146 */
mbed_official 330:c80ac197fa6a 2147 __weak void HAL_SDADC_CalibrationCpltCallback(SDADC_HandleTypeDef* hsdadc)
mbed_official 330:c80ac197fa6a 2148 {
mbed_official 330:c80ac197fa6a 2149 /* NOTE : This function should not be modified, when the callback is needed,
mbed_official 330:c80ac197fa6a 2150 the HAL_SDADC_CalibrationCpltCallback could be implemented in the user file
mbed_official 330:c80ac197fa6a 2151 */
mbed_official 330:c80ac197fa6a 2152 }
mbed_official 330:c80ac197fa6a 2153
mbed_official 330:c80ac197fa6a 2154 /**
mbed_official 330:c80ac197fa6a 2155 * @brief Half regular conversion complete callback.
mbed_official 330:c80ac197fa6a 2156 * @param hsdadc : SDADC handle.
mbed_official 330:c80ac197fa6a 2157 * @retval None
mbed_official 330:c80ac197fa6a 2158 */
mbed_official 330:c80ac197fa6a 2159 __weak void HAL_SDADC_ConvHalfCpltCallback(SDADC_HandleTypeDef* hsdadc)
mbed_official 330:c80ac197fa6a 2160 {
mbed_official 330:c80ac197fa6a 2161 /* NOTE : This function should not be modified, when the callback is needed,
mbed_official 330:c80ac197fa6a 2162 the HAL_SDADC_ConvHalfCpltCallback could be implemented in the user file
mbed_official 330:c80ac197fa6a 2163 */
mbed_official 330:c80ac197fa6a 2164 }
mbed_official 330:c80ac197fa6a 2165
mbed_official 330:c80ac197fa6a 2166 /**
mbed_official 330:c80ac197fa6a 2167 * @brief Regular conversion complete callback.
mbed_official 330:c80ac197fa6a 2168 * @note In interrupt mode, user has to read conversion value in this function
mbed_official 330:c80ac197fa6a 2169 using HAL_SDADC_GetValue or HAL_SDADC_MultiModeGetValue.
mbed_official 330:c80ac197fa6a 2170 * @param hsdadc : SDADC handle.
mbed_official 330:c80ac197fa6a 2171 * @retval None
mbed_official 330:c80ac197fa6a 2172 */
mbed_official 330:c80ac197fa6a 2173 __weak void HAL_SDADC_ConvCpltCallback(SDADC_HandleTypeDef* hsdadc)
mbed_official 330:c80ac197fa6a 2174 {
mbed_official 330:c80ac197fa6a 2175 /* NOTE : This function should not be modified, when the callback is needed,
mbed_official 330:c80ac197fa6a 2176 the HAL_SDADC_ConvCpltCallback could be implemented in the user file.
mbed_official 330:c80ac197fa6a 2177 */
mbed_official 330:c80ac197fa6a 2178 }
mbed_official 330:c80ac197fa6a 2179
mbed_official 330:c80ac197fa6a 2180 /**
mbed_official 330:c80ac197fa6a 2181 * @brief Half injected conversion complete callback.
mbed_official 330:c80ac197fa6a 2182 * @param hsdadc : SDADC handle.
mbed_official 330:c80ac197fa6a 2183 * @retval None
mbed_official 330:c80ac197fa6a 2184 */
mbed_official 330:c80ac197fa6a 2185 __weak void HAL_SDADC_InjectedConvHalfCpltCallback(SDADC_HandleTypeDef* hsdadc)
mbed_official 330:c80ac197fa6a 2186 {
mbed_official 330:c80ac197fa6a 2187 /* NOTE : This function should not be modified, when the callback is needed,
mbed_official 330:c80ac197fa6a 2188 the HAL_SDADC_InjectedConvHalfCpltCallback could be implemented in the user file.
mbed_official 330:c80ac197fa6a 2189 */
mbed_official 330:c80ac197fa6a 2190 }
mbed_official 330:c80ac197fa6a 2191
mbed_official 330:c80ac197fa6a 2192 /**
mbed_official 330:c80ac197fa6a 2193 * @brief Injected conversion complete callback.
mbed_official 330:c80ac197fa6a 2194 * @note In interrupt mode, user has to read conversion value in this function
mbed_official 330:c80ac197fa6a 2195 using HAL_SDADC_InjectedGetValue or HAL_SDADC_InjectedMultiModeGetValue.
mbed_official 330:c80ac197fa6a 2196 * @param hsdadc : SDADC handle.
mbed_official 330:c80ac197fa6a 2197 * @retval None
mbed_official 330:c80ac197fa6a 2198 */
mbed_official 330:c80ac197fa6a 2199 __weak void HAL_SDADC_InjectedConvCpltCallback(SDADC_HandleTypeDef* hsdadc)
mbed_official 330:c80ac197fa6a 2200 {
mbed_official 330:c80ac197fa6a 2201 /* NOTE : This function should not be modified, when the callback is needed,
mbed_official 330:c80ac197fa6a 2202 the HAL_SDADC_InjectedConvCpltCallback could be implemented in the user file.
mbed_official 330:c80ac197fa6a 2203 */
mbed_official 330:c80ac197fa6a 2204 }
mbed_official 330:c80ac197fa6a 2205
mbed_official 330:c80ac197fa6a 2206 /**
mbed_official 330:c80ac197fa6a 2207 * @brief Error callback.
mbed_official 330:c80ac197fa6a 2208 * @param hsdadc : SDADC handle.
mbed_official 330:c80ac197fa6a 2209 * @retval None
mbed_official 330:c80ac197fa6a 2210 */
mbed_official 330:c80ac197fa6a 2211 __weak void HAL_SDADC_ErrorCallback(SDADC_HandleTypeDef* hsdadc)
mbed_official 330:c80ac197fa6a 2212 {
mbed_official 330:c80ac197fa6a 2213 /* NOTE : This function should not be modified, when the callback is needed,
mbed_official 330:c80ac197fa6a 2214 the HAL_SDADC_ErrorCallback could be implemented in the user file.
mbed_official 330:c80ac197fa6a 2215 */
mbed_official 330:c80ac197fa6a 2216 }
mbed_official 330:c80ac197fa6a 2217
mbed_official 330:c80ac197fa6a 2218 /**
mbed_official 330:c80ac197fa6a 2219 * @brief DMA half transfer complete callback for regular conversion.
mbed_official 330:c80ac197fa6a 2220 * @param hdma : DMA handle.
mbed_official 330:c80ac197fa6a 2221 * @retval None
mbed_official 330:c80ac197fa6a 2222 */
mbed_official 330:c80ac197fa6a 2223 static void SDADC_DMARegularHalfConvCplt(DMA_HandleTypeDef *hdma)
mbed_official 330:c80ac197fa6a 2224 {
mbed_official 330:c80ac197fa6a 2225 /* Get SDADC handle */
mbed_official 330:c80ac197fa6a 2226 SDADC_HandleTypeDef* hsdadc = (SDADC_HandleTypeDef*) ((DMA_HandleTypeDef*)hdma)->Parent;
mbed_official 330:c80ac197fa6a 2227
mbed_official 330:c80ac197fa6a 2228 /* Call regular half conversion complete callback */
mbed_official 330:c80ac197fa6a 2229 HAL_SDADC_ConvHalfCpltCallback(hsdadc);
mbed_official 330:c80ac197fa6a 2230 }
mbed_official 330:c80ac197fa6a 2231
mbed_official 330:c80ac197fa6a 2232 /**
mbed_official 330:c80ac197fa6a 2233 * @brief DMA transfer complete callback for regular conversion.
mbed_official 330:c80ac197fa6a 2234 * @param hdma : DMA handle.
mbed_official 330:c80ac197fa6a 2235 * @retval None
mbed_official 330:c80ac197fa6a 2236 */
mbed_official 330:c80ac197fa6a 2237 static void SDADC_DMARegularConvCplt(DMA_HandleTypeDef *hdma)
mbed_official 330:c80ac197fa6a 2238 {
mbed_official 330:c80ac197fa6a 2239 /* Get SDADC handle */
mbed_official 330:c80ac197fa6a 2240 SDADC_HandleTypeDef* hsdadc = (SDADC_HandleTypeDef*) ((DMA_HandleTypeDef*)hdma)->Parent;
mbed_official 330:c80ac197fa6a 2241
mbed_official 330:c80ac197fa6a 2242 /* Call regular conversion complete callback */
mbed_official 330:c80ac197fa6a 2243 HAL_SDADC_ConvCpltCallback(hsdadc);
mbed_official 330:c80ac197fa6a 2244 }
mbed_official 330:c80ac197fa6a 2245
mbed_official 330:c80ac197fa6a 2246 /**
mbed_official 330:c80ac197fa6a 2247 * @brief DMA half transfer complete callback for injected conversion.
mbed_official 330:c80ac197fa6a 2248 * @param hdma : DMA handle.
mbed_official 330:c80ac197fa6a 2249 * @retval None
mbed_official 330:c80ac197fa6a 2250 */
mbed_official 330:c80ac197fa6a 2251 static void SDADC_DMAInjectedHalfConvCplt(DMA_HandleTypeDef *hdma)
mbed_official 330:c80ac197fa6a 2252 {
mbed_official 330:c80ac197fa6a 2253 /* Get SDADC handle */
mbed_official 330:c80ac197fa6a 2254 SDADC_HandleTypeDef* hsdadc = (SDADC_HandleTypeDef*) ((DMA_HandleTypeDef*)hdma)->Parent;
mbed_official 330:c80ac197fa6a 2255
mbed_official 330:c80ac197fa6a 2256 /* Call injected half conversion complete callback */
mbed_official 330:c80ac197fa6a 2257 HAL_SDADC_InjectedConvHalfCpltCallback(hsdadc);
mbed_official 330:c80ac197fa6a 2258 }
mbed_official 330:c80ac197fa6a 2259
mbed_official 330:c80ac197fa6a 2260 /**
mbed_official 330:c80ac197fa6a 2261 * @brief DMA transfer complete callback for injected conversion.
mbed_official 330:c80ac197fa6a 2262 * @param hdma : DMA handle.
mbed_official 330:c80ac197fa6a 2263 * @retval None
mbed_official 330:c80ac197fa6a 2264 */
mbed_official 330:c80ac197fa6a 2265 static void SDADC_DMAInjectedConvCplt(DMA_HandleTypeDef *hdma)
mbed_official 330:c80ac197fa6a 2266 {
mbed_official 330:c80ac197fa6a 2267 /* Get SDADC handle */
mbed_official 330:c80ac197fa6a 2268 SDADC_HandleTypeDef* hsdadc = (SDADC_HandleTypeDef*) ((DMA_HandleTypeDef*)hdma)->Parent;
mbed_official 330:c80ac197fa6a 2269
mbed_official 330:c80ac197fa6a 2270 /* Call injected conversion complete callback */
mbed_official 330:c80ac197fa6a 2271 HAL_SDADC_InjectedConvCpltCallback(hsdadc);
mbed_official 330:c80ac197fa6a 2272 }
mbed_official 330:c80ac197fa6a 2273
mbed_official 330:c80ac197fa6a 2274 /**
mbed_official 330:c80ac197fa6a 2275 * @brief DMA error callback.
mbed_official 330:c80ac197fa6a 2276 * @param hdma : DMA handle.
mbed_official 330:c80ac197fa6a 2277 * @retval None
mbed_official 330:c80ac197fa6a 2278 */
mbed_official 330:c80ac197fa6a 2279 static void SDADC_DMAError(DMA_HandleTypeDef *hdma)
mbed_official 330:c80ac197fa6a 2280 {
mbed_official 330:c80ac197fa6a 2281 /* Get SDADC handle */
mbed_official 330:c80ac197fa6a 2282 SDADC_HandleTypeDef* hsdadc = (SDADC_HandleTypeDef*) ((DMA_HandleTypeDef*)hdma)->Parent;
mbed_official 330:c80ac197fa6a 2283
mbed_official 330:c80ac197fa6a 2284 /* Update error code */
mbed_official 330:c80ac197fa6a 2285 hsdadc->ErrorCode = SDADC_ERROR_DMA;
mbed_official 330:c80ac197fa6a 2286
mbed_official 330:c80ac197fa6a 2287 /* Call error callback */
mbed_official 330:c80ac197fa6a 2288 HAL_SDADC_ErrorCallback(hsdadc);
mbed_official 330:c80ac197fa6a 2289 }
mbed_official 330:c80ac197fa6a 2290
mbed_official 330:c80ac197fa6a 2291 /**
mbed_official 330:c80ac197fa6a 2292 * @}
mbed_official 330:c80ac197fa6a 2293 */
mbed_official 330:c80ac197fa6a 2294
mbed_official 330:c80ac197fa6a 2295 /** @defgroup SDADC_Exported_Functions_Group4 Peripheral State functions
mbed_official 330:c80ac197fa6a 2296 * @brief SDADC Peripheral State functions
mbed_official 330:c80ac197fa6a 2297 *
mbed_official 330:c80ac197fa6a 2298 @verbatim
mbed_official 330:c80ac197fa6a 2299 ===============================================================================
mbed_official 330:c80ac197fa6a 2300 ##### ADC Peripheral State functions #####
mbed_official 330:c80ac197fa6a 2301 ===============================================================================
mbed_official 330:c80ac197fa6a 2302 [..] This subsection provides functions allowing to
mbed_official 330:c80ac197fa6a 2303 (+) Get the SDADC state
mbed_official 330:c80ac197fa6a 2304 (+) Get the SDADC Error
mbed_official 330:c80ac197fa6a 2305
mbed_official 330:c80ac197fa6a 2306 @endverbatim
mbed_official 330:c80ac197fa6a 2307 * @{
mbed_official 330:c80ac197fa6a 2308 */
mbed_official 330:c80ac197fa6a 2309
mbed_official 330:c80ac197fa6a 2310 /**
mbed_official 330:c80ac197fa6a 2311 * @brief This function allows to get the current SDADC state.
mbed_official 330:c80ac197fa6a 2312 * @param hsdadc : SDADC handle.
mbed_official 330:c80ac197fa6a 2313 * @retval SDADC state.
mbed_official 330:c80ac197fa6a 2314 */
mbed_official 330:c80ac197fa6a 2315 HAL_SDADC_StateTypeDef HAL_SDADC_GetState(SDADC_HandleTypeDef* hsdadc)
mbed_official 330:c80ac197fa6a 2316 {
mbed_official 330:c80ac197fa6a 2317 return hsdadc->State;
mbed_official 330:c80ac197fa6a 2318 }
mbed_official 330:c80ac197fa6a 2319
mbed_official 330:c80ac197fa6a 2320 /**
mbed_official 330:c80ac197fa6a 2321 * @brief This function allows to get the current SDADC error code.
mbed_official 330:c80ac197fa6a 2322 * @param hsdadc : SDADC handle.
mbed_official 330:c80ac197fa6a 2323 * @retval SDADC error code.
mbed_official 330:c80ac197fa6a 2324 */
mbed_official 330:c80ac197fa6a 2325 uint32_t HAL_SDADC_GetError(SDADC_HandleTypeDef* hsdadc)
mbed_official 330:c80ac197fa6a 2326 {
mbed_official 330:c80ac197fa6a 2327 return hsdadc->ErrorCode;
mbed_official 330:c80ac197fa6a 2328 }
mbed_official 330:c80ac197fa6a 2329
mbed_official 330:c80ac197fa6a 2330 /**
mbed_official 330:c80ac197fa6a 2331 * @}
mbed_official 330:c80ac197fa6a 2332 */
mbed_official 330:c80ac197fa6a 2333
mbed_official 330:c80ac197fa6a 2334 /**
mbed_official 330:c80ac197fa6a 2335 * @brief This function allows to enter in init mode for SDADC instance.
mbed_official 330:c80ac197fa6a 2336 * @param hsdadc : SDADC handle.
mbed_official 330:c80ac197fa6a 2337 * @retval HAL status.
mbed_official 330:c80ac197fa6a 2338 */
mbed_official 330:c80ac197fa6a 2339 static HAL_StatusTypeDef SDADC_EnterInitMode(SDADC_HandleTypeDef* hsdadc)
mbed_official 330:c80ac197fa6a 2340 {
mbed_official 330:c80ac197fa6a 2341 uint32_t tickstart = 0;
mbed_official 330:c80ac197fa6a 2342
mbed_official 330:c80ac197fa6a 2343 /* Set INIT bit on SDADC_CR1 register */
mbed_official 330:c80ac197fa6a 2344 hsdadc->Instance->CR1 |= SDADC_CR1_INIT;
mbed_official 330:c80ac197fa6a 2345
mbed_official 330:c80ac197fa6a 2346 /* Wait INITRDY bit on SDADC_ISR */
mbed_official 330:c80ac197fa6a 2347 tickstart = HAL_GetTick();
mbed_official 330:c80ac197fa6a 2348 while((hsdadc->Instance->ISR & SDADC_ISR_INITRDY) == (uint32_t)RESET)
mbed_official 330:c80ac197fa6a 2349 {
mbed_official 330:c80ac197fa6a 2350 if((HAL_GetTick()-tickstart) > SDADC_TIMEOUT)
mbed_official 330:c80ac197fa6a 2351 {
mbed_official 330:c80ac197fa6a 2352 return HAL_TIMEOUT;
mbed_official 330:c80ac197fa6a 2353 }
mbed_official 330:c80ac197fa6a 2354 }
mbed_official 330:c80ac197fa6a 2355
mbed_official 330:c80ac197fa6a 2356 /* Return HAL status */
mbed_official 330:c80ac197fa6a 2357 return HAL_OK;
mbed_official 330:c80ac197fa6a 2358 }
mbed_official 330:c80ac197fa6a 2359
mbed_official 330:c80ac197fa6a 2360 /**
mbed_official 330:c80ac197fa6a 2361 * @brief This function allows to exit from init mode for SDADC instance.
mbed_official 330:c80ac197fa6a 2362 * @param hsdadc : SDADC handle.
mbed_official 330:c80ac197fa6a 2363 * @retval None.
mbed_official 330:c80ac197fa6a 2364 */
mbed_official 330:c80ac197fa6a 2365 static void SDADC_ExitInitMode(SDADC_HandleTypeDef* hsdadc)
mbed_official 330:c80ac197fa6a 2366 {
mbed_official 330:c80ac197fa6a 2367 /* Reset INIT bit in SDADC_CR1 register */
mbed_official 330:c80ac197fa6a 2368 hsdadc->Instance->CR1 &= ~(SDADC_CR1_INIT);
mbed_official 330:c80ac197fa6a 2369 }
mbed_official 330:c80ac197fa6a 2370
mbed_official 330:c80ac197fa6a 2371 /**
mbed_official 330:c80ac197fa6a 2372 * @brief This function allows to get the number of injected channels.
mbed_official 330:c80ac197fa6a 2373 * @param Channels : bitfield of injected channels.
mbed_official 330:c80ac197fa6a 2374 * @retval Number of injected channels.
mbed_official 330:c80ac197fa6a 2375 */
mbed_official 330:c80ac197fa6a 2376 static uint32_t SDADC_GetInjChannelsNbr(uint32_t Channels)
mbed_official 330:c80ac197fa6a 2377 {
mbed_official 330:c80ac197fa6a 2378 uint32_t nbChannels = 0;
mbed_official 330:c80ac197fa6a 2379 uint32_t tmp,i;
mbed_official 330:c80ac197fa6a 2380
mbed_official 330:c80ac197fa6a 2381 /* Get the number of channels from bitfield */
mbed_official 330:c80ac197fa6a 2382 tmp = (uint32_t) (Channels & SDADC_LSB_MASK);
mbed_official 330:c80ac197fa6a 2383 for(i = 0 ; i < 9 ; i++)
mbed_official 330:c80ac197fa6a 2384 {
mbed_official 330:c80ac197fa6a 2385 if(tmp & 1)
mbed_official 330:c80ac197fa6a 2386 {
mbed_official 330:c80ac197fa6a 2387 nbChannels++;
mbed_official 330:c80ac197fa6a 2388 }
mbed_official 330:c80ac197fa6a 2389 tmp = (uint32_t) (tmp >> 1);
mbed_official 330:c80ac197fa6a 2390 }
mbed_official 330:c80ac197fa6a 2391 return nbChannels;
mbed_official 330:c80ac197fa6a 2392 }
mbed_official 330:c80ac197fa6a 2393
mbed_official 330:c80ac197fa6a 2394 /**
mbed_official 330:c80ac197fa6a 2395 * @brief This function allows to really start regular conversion.
mbed_official 330:c80ac197fa6a 2396 * @param hsdadc : SDADC handle.
mbed_official 330:c80ac197fa6a 2397 * @retval HAL status.
mbed_official 330:c80ac197fa6a 2398 */
mbed_official 330:c80ac197fa6a 2399 static HAL_StatusTypeDef SDADC_RegConvStart(SDADC_HandleTypeDef* hsdadc)
mbed_official 330:c80ac197fa6a 2400 {
mbed_official 330:c80ac197fa6a 2401 HAL_StatusTypeDef status = HAL_OK;
mbed_official 330:c80ac197fa6a 2402
mbed_official 330:c80ac197fa6a 2403 /* Check regular trigger */
mbed_official 330:c80ac197fa6a 2404 if(hsdadc->RegularTrigger == SDADC_SOFTWARE_TRIGGER)
mbed_official 330:c80ac197fa6a 2405 {
mbed_official 330:c80ac197fa6a 2406 /* Set RSWSTART bit in SDADC_CR2 register */
mbed_official 330:c80ac197fa6a 2407 hsdadc->Instance->CR2 |= SDADC_CR2_RSWSTART;
mbed_official 330:c80ac197fa6a 2408 }
mbed_official 330:c80ac197fa6a 2409 else /* synchronuous trigger */
mbed_official 330:c80ac197fa6a 2410 {
mbed_official 330:c80ac197fa6a 2411 /* Enter init mode */
mbed_official 330:c80ac197fa6a 2412 if(SDADC_EnterInitMode(hsdadc) != HAL_OK)
mbed_official 330:c80ac197fa6a 2413 {
mbed_official 330:c80ac197fa6a 2414 /* Set SDADC in error state */
mbed_official 330:c80ac197fa6a 2415 hsdadc->State = HAL_SDADC_STATE_ERROR;
mbed_official 330:c80ac197fa6a 2416 status = HAL_TIMEOUT;
mbed_official 330:c80ac197fa6a 2417 }
mbed_official 330:c80ac197fa6a 2418 else
mbed_official 330:c80ac197fa6a 2419 {
mbed_official 330:c80ac197fa6a 2420 /* Set RSYNC bit in SDADC_CR1 register */
mbed_official 330:c80ac197fa6a 2421 hsdadc->Instance->CR1 |= SDADC_CR1_RSYNC;
mbed_official 330:c80ac197fa6a 2422
mbed_official 330:c80ac197fa6a 2423 /* Exit init mode */
mbed_official 330:c80ac197fa6a 2424 SDADC_ExitInitMode(hsdadc);
mbed_official 330:c80ac197fa6a 2425 }
mbed_official 330:c80ac197fa6a 2426 }
mbed_official 330:c80ac197fa6a 2427 /* Update SDADC state only if status is OK */
mbed_official 330:c80ac197fa6a 2428 if(status == HAL_OK)
mbed_official 330:c80ac197fa6a 2429 {
mbed_official 330:c80ac197fa6a 2430 hsdadc->State = (hsdadc->State == HAL_SDADC_STATE_READY) ? \
mbed_official 330:c80ac197fa6a 2431 HAL_SDADC_STATE_REG : HAL_SDADC_STATE_REG_INJ;
mbed_official 330:c80ac197fa6a 2432 }
mbed_official 330:c80ac197fa6a 2433 /* Return function status */
mbed_official 330:c80ac197fa6a 2434 return status;
mbed_official 330:c80ac197fa6a 2435 }
mbed_official 330:c80ac197fa6a 2436
mbed_official 330:c80ac197fa6a 2437 /**
mbed_official 330:c80ac197fa6a 2438 * @brief This function allows to really stop regular conversion.
mbed_official 330:c80ac197fa6a 2439 * @param hsdadc : SDADC handle.
mbed_official 330:c80ac197fa6a 2440 * @retval HAL status.
mbed_official 330:c80ac197fa6a 2441 */
mbed_official 330:c80ac197fa6a 2442 static HAL_StatusTypeDef SDADC_RegConvStop(SDADC_HandleTypeDef* hsdadc)
mbed_official 330:c80ac197fa6a 2443 {
mbed_official 330:c80ac197fa6a 2444 uint32_t tickstart;
mbed_official 330:c80ac197fa6a 2445
mbed_official 330:c80ac197fa6a 2446 /* Check continuous mode */
mbed_official 330:c80ac197fa6a 2447 if(hsdadc->RegularContMode == SDADC_CONTINUOUS_CONV_ON)
mbed_official 330:c80ac197fa6a 2448 {
mbed_official 330:c80ac197fa6a 2449 /* Clear REOCF by reading SDADC_RDATAR register */
mbed_official 330:c80ac197fa6a 2450 hsdadc->Instance->RDATAR;
mbed_official 330:c80ac197fa6a 2451
mbed_official 330:c80ac197fa6a 2452 /* Clear RCONT bit in SDADC_CR2 register */
mbed_official 330:c80ac197fa6a 2453 hsdadc->Instance->CR2 &= ~(SDADC_CR2_RCONT);
mbed_official 330:c80ac197fa6a 2454 }
mbed_official 330:c80ac197fa6a 2455 /* Wait for the end of regular conversion */
mbed_official 330:c80ac197fa6a 2456 tickstart = HAL_GetTick();
mbed_official 330:c80ac197fa6a 2457 while((hsdadc->Instance->ISR & SDADC_ISR_RCIP) != 0)
mbed_official 330:c80ac197fa6a 2458 {
mbed_official 330:c80ac197fa6a 2459 if((HAL_GetTick()-tickstart) > SDADC_TIMEOUT)
mbed_official 330:c80ac197fa6a 2460 {
mbed_official 330:c80ac197fa6a 2461 /* Set SDADC in error state and return timeout status */
mbed_official 330:c80ac197fa6a 2462 hsdadc->State = HAL_SDADC_STATE_ERROR;
mbed_official 330:c80ac197fa6a 2463 return HAL_TIMEOUT;
mbed_official 330:c80ac197fa6a 2464 }
mbed_official 330:c80ac197fa6a 2465 }
mbed_official 330:c80ac197fa6a 2466 /* Check if trigger is synchronuous */
mbed_official 330:c80ac197fa6a 2467 if(hsdadc->RegularTrigger == SDADC_SYNCHRONOUS_TRIGGER)
mbed_official 330:c80ac197fa6a 2468 {
mbed_official 330:c80ac197fa6a 2469 /* Enter init mode */
mbed_official 330:c80ac197fa6a 2470 if(SDADC_EnterInitMode(hsdadc) != HAL_OK)
mbed_official 330:c80ac197fa6a 2471 {
mbed_official 330:c80ac197fa6a 2472 /* Set SDADC in error state and return timeout status */
mbed_official 330:c80ac197fa6a 2473 hsdadc->State = HAL_SDADC_STATE_ERROR;
mbed_official 330:c80ac197fa6a 2474 return HAL_TIMEOUT;
mbed_official 330:c80ac197fa6a 2475 }
mbed_official 330:c80ac197fa6a 2476 else
mbed_official 330:c80ac197fa6a 2477 {
mbed_official 330:c80ac197fa6a 2478 /* Clear RSYNC bit in SDADC_CR1 register */
mbed_official 330:c80ac197fa6a 2479 hsdadc->Instance->CR1 &= ~(SDADC_CR1_RSYNC);
mbed_official 330:c80ac197fa6a 2480
mbed_official 330:c80ac197fa6a 2481 /* Exit init mode */
mbed_official 330:c80ac197fa6a 2482 SDADC_ExitInitMode(hsdadc);
mbed_official 330:c80ac197fa6a 2483 }
mbed_official 330:c80ac197fa6a 2484 }
mbed_official 330:c80ac197fa6a 2485 /* Check if continuous mode */
mbed_official 330:c80ac197fa6a 2486 if(hsdadc->RegularContMode == SDADC_CONTINUOUS_CONV_ON)
mbed_official 330:c80ac197fa6a 2487 {
mbed_official 330:c80ac197fa6a 2488 /* Restore RCONT bit in SDADC_CR2 register */
mbed_official 330:c80ac197fa6a 2489 hsdadc->Instance->CR2 |= SDADC_CR2_RCONT;
mbed_official 330:c80ac197fa6a 2490 }
mbed_official 330:c80ac197fa6a 2491 /* Clear REOCF by reading SDADC_RDATAR register */
mbed_official 330:c80ac197fa6a 2492 hsdadc->Instance->RDATAR;
mbed_official 330:c80ac197fa6a 2493
mbed_official 330:c80ac197fa6a 2494 /* Set CLRROVRF bit in SDADC_CLRISR register */
mbed_official 330:c80ac197fa6a 2495 hsdadc->Instance->CLRISR |= SDADC_ISR_CLRROVRF;
mbed_official 330:c80ac197fa6a 2496
mbed_official 330:c80ac197fa6a 2497 /* Update SDADC state */
mbed_official 330:c80ac197fa6a 2498 hsdadc->State = (hsdadc->State == HAL_SDADC_STATE_REG) ? \
mbed_official 330:c80ac197fa6a 2499 HAL_SDADC_STATE_READY : HAL_SDADC_STATE_INJ;
mbed_official 330:c80ac197fa6a 2500
mbed_official 330:c80ac197fa6a 2501 /* Return function status */
mbed_official 330:c80ac197fa6a 2502 return HAL_OK;
mbed_official 330:c80ac197fa6a 2503 }
mbed_official 330:c80ac197fa6a 2504
mbed_official 330:c80ac197fa6a 2505 /**
mbed_official 330:c80ac197fa6a 2506 * @brief This function allows to really start injected conversion.
mbed_official 330:c80ac197fa6a 2507 * @param hsdadc : SDADC handle.
mbed_official 330:c80ac197fa6a 2508 * @retval HAL status.
mbed_official 330:c80ac197fa6a 2509 */
mbed_official 330:c80ac197fa6a 2510 static HAL_StatusTypeDef SDADC_InjConvStart(SDADC_HandleTypeDef* hsdadc)
mbed_official 330:c80ac197fa6a 2511 {
mbed_official 330:c80ac197fa6a 2512 HAL_StatusTypeDef status = HAL_OK;
mbed_official 330:c80ac197fa6a 2513
mbed_official 330:c80ac197fa6a 2514 /* Initialize number of injected conversions remaining */
mbed_official 330:c80ac197fa6a 2515 hsdadc->InjConvRemaining = hsdadc->InjectedChannelsNbr;
mbed_official 330:c80ac197fa6a 2516
mbed_official 330:c80ac197fa6a 2517 /* Check injected trigger */
mbed_official 330:c80ac197fa6a 2518 if(hsdadc->InjectedTrigger == SDADC_SOFTWARE_TRIGGER)
mbed_official 330:c80ac197fa6a 2519 {
mbed_official 330:c80ac197fa6a 2520 /* Set JSWSTART bit in SDADC_CR2 register */
mbed_official 330:c80ac197fa6a 2521 hsdadc->Instance->CR2 |= SDADC_CR2_JSWSTART;
mbed_official 330:c80ac197fa6a 2522 }
mbed_official 330:c80ac197fa6a 2523 else /* external or synchronuous trigger */
mbed_official 330:c80ac197fa6a 2524 {
mbed_official 330:c80ac197fa6a 2525 /* Enter init mode */
mbed_official 330:c80ac197fa6a 2526 if(SDADC_EnterInitMode(hsdadc) != HAL_OK)
mbed_official 330:c80ac197fa6a 2527 {
mbed_official 330:c80ac197fa6a 2528 /* Set SDADC in error state */
mbed_official 330:c80ac197fa6a 2529 hsdadc->State = HAL_SDADC_STATE_ERROR;
mbed_official 330:c80ac197fa6a 2530 status = HAL_TIMEOUT;
mbed_official 330:c80ac197fa6a 2531 }
mbed_official 330:c80ac197fa6a 2532 else
mbed_official 330:c80ac197fa6a 2533 {
mbed_official 330:c80ac197fa6a 2534 if(hsdadc->InjectedTrigger == SDADC_SYNCHRONOUS_TRIGGER)
mbed_official 330:c80ac197fa6a 2535 {
mbed_official 330:c80ac197fa6a 2536 /* Set JSYNC bit in SDADC_CR1 register */
mbed_official 330:c80ac197fa6a 2537 hsdadc->Instance->CR1 |= SDADC_CR1_JSYNC;
mbed_official 330:c80ac197fa6a 2538 }
mbed_official 330:c80ac197fa6a 2539 else /* external trigger */
mbed_official 330:c80ac197fa6a 2540 {
mbed_official 330:c80ac197fa6a 2541 /* Set JEXTEN[1:0] bits in SDADC_CR2 register */
mbed_official 330:c80ac197fa6a 2542 hsdadc->Instance->CR2 |= hsdadc->ExtTriggerEdge;
mbed_official 330:c80ac197fa6a 2543 }
mbed_official 330:c80ac197fa6a 2544 /* Exit init mode */
mbed_official 330:c80ac197fa6a 2545 SDADC_ExitInitMode(hsdadc);
mbed_official 330:c80ac197fa6a 2546 }
mbed_official 330:c80ac197fa6a 2547 }
mbed_official 330:c80ac197fa6a 2548 /* Update SDADC state only if status is OK */
mbed_official 330:c80ac197fa6a 2549 if(status == HAL_OK)
mbed_official 330:c80ac197fa6a 2550 {
mbed_official 330:c80ac197fa6a 2551 hsdadc->State = (hsdadc->State == HAL_SDADC_STATE_READY) ? \
mbed_official 330:c80ac197fa6a 2552 HAL_SDADC_STATE_INJ : HAL_SDADC_STATE_REG_INJ;
mbed_official 330:c80ac197fa6a 2553 }
mbed_official 330:c80ac197fa6a 2554 /* Return function status */
mbed_official 330:c80ac197fa6a 2555 return status;
mbed_official 330:c80ac197fa6a 2556 }
mbed_official 330:c80ac197fa6a 2557
mbed_official 330:c80ac197fa6a 2558 /**
mbed_official 330:c80ac197fa6a 2559 * @brief This function allows to really stop injected conversion.
mbed_official 330:c80ac197fa6a 2560 * @param hsdadc : SDADC handle.
mbed_official 330:c80ac197fa6a 2561 * @retval HAL status.
mbed_official 330:c80ac197fa6a 2562 */
mbed_official 330:c80ac197fa6a 2563 static HAL_StatusTypeDef SDADC_InjConvStop(SDADC_HandleTypeDef* hsdadc)
mbed_official 330:c80ac197fa6a 2564 {
mbed_official 330:c80ac197fa6a 2565 uint32_t tickstart;
mbed_official 330:c80ac197fa6a 2566
mbed_official 330:c80ac197fa6a 2567 /* Check continuous mode */
mbed_official 330:c80ac197fa6a 2568 if(hsdadc->InjectedContMode == SDADC_CONTINUOUS_CONV_ON)
mbed_official 330:c80ac197fa6a 2569 {
mbed_official 330:c80ac197fa6a 2570 /* Clear JEOCF by reading SDADC_JDATAR register */
mbed_official 330:c80ac197fa6a 2571 hsdadc->Instance->JDATAR;
mbed_official 330:c80ac197fa6a 2572
mbed_official 330:c80ac197fa6a 2573 /* Clear JCONT bit in SDADC_CR2 register */
mbed_official 330:c80ac197fa6a 2574 hsdadc->Instance->CR2 &= ~(SDADC_CR2_JCONT);
mbed_official 330:c80ac197fa6a 2575 }
mbed_official 330:c80ac197fa6a 2576 /* Wait for the end of injected conversion */
mbed_official 330:c80ac197fa6a 2577 tickstart = HAL_GetTick();
mbed_official 330:c80ac197fa6a 2578 while((hsdadc->Instance->ISR & SDADC_ISR_JCIP) != 0)
mbed_official 330:c80ac197fa6a 2579 {
mbed_official 330:c80ac197fa6a 2580 if((HAL_GetTick()-tickstart) > SDADC_TIMEOUT)
mbed_official 330:c80ac197fa6a 2581 {
mbed_official 330:c80ac197fa6a 2582 /* Set SDADC in error state and return timeout status */
mbed_official 330:c80ac197fa6a 2583 hsdadc->State = HAL_SDADC_STATE_ERROR;
mbed_official 330:c80ac197fa6a 2584 return HAL_TIMEOUT;
mbed_official 330:c80ac197fa6a 2585 }
mbed_official 330:c80ac197fa6a 2586 }
mbed_official 330:c80ac197fa6a 2587 /* Check if trigger is not software */
mbed_official 330:c80ac197fa6a 2588 if(hsdadc->InjectedTrigger != SDADC_SOFTWARE_TRIGGER)
mbed_official 330:c80ac197fa6a 2589 {
mbed_official 330:c80ac197fa6a 2590 /* Enter init mode */
mbed_official 330:c80ac197fa6a 2591 if(SDADC_EnterInitMode(hsdadc) != HAL_OK)
mbed_official 330:c80ac197fa6a 2592 {
mbed_official 330:c80ac197fa6a 2593 /* Set SDADC in error state and return timeout status */
mbed_official 330:c80ac197fa6a 2594 hsdadc->State = HAL_SDADC_STATE_ERROR;
mbed_official 330:c80ac197fa6a 2595 return HAL_TIMEOUT;
mbed_official 330:c80ac197fa6a 2596 }
mbed_official 330:c80ac197fa6a 2597 else
mbed_official 330:c80ac197fa6a 2598 {
mbed_official 330:c80ac197fa6a 2599 /* Check if trigger is synchronuous */
mbed_official 330:c80ac197fa6a 2600 if(hsdadc->InjectedTrigger == SDADC_SYNCHRONOUS_TRIGGER)
mbed_official 330:c80ac197fa6a 2601 {
mbed_official 330:c80ac197fa6a 2602 /* Clear JSYNC bit in SDADC_CR1 register */
mbed_official 330:c80ac197fa6a 2603 hsdadc->Instance->CR1 &= ~(SDADC_CR1_JSYNC);
mbed_official 330:c80ac197fa6a 2604 }
mbed_official 330:c80ac197fa6a 2605 else /* external trigger */
mbed_official 330:c80ac197fa6a 2606 {
mbed_official 330:c80ac197fa6a 2607 /* Clear JEXTEN[1:0] bits in SDADC_CR2 register */
mbed_official 330:c80ac197fa6a 2608 hsdadc->Instance->CR2 &= ~(SDADC_CR2_JEXTEN);
mbed_official 330:c80ac197fa6a 2609 }
mbed_official 330:c80ac197fa6a 2610 /* Exit init mode */
mbed_official 330:c80ac197fa6a 2611 SDADC_ExitInitMode(hsdadc);
mbed_official 330:c80ac197fa6a 2612 }
mbed_official 330:c80ac197fa6a 2613 }
mbed_official 330:c80ac197fa6a 2614 /* Check if continuous mode */
mbed_official 330:c80ac197fa6a 2615 if(hsdadc->InjectedContMode == SDADC_CONTINUOUS_CONV_ON)
mbed_official 330:c80ac197fa6a 2616 {
mbed_official 330:c80ac197fa6a 2617 /* Restore JCONT bit in SDADC_CR2 register */
mbed_official 330:c80ac197fa6a 2618 hsdadc->Instance->CR2 |= SDADC_CR2_JCONT;
mbed_official 330:c80ac197fa6a 2619 }
mbed_official 330:c80ac197fa6a 2620 /* Clear JEOCF by reading SDADC_JDATAR register */
mbed_official 330:c80ac197fa6a 2621 hsdadc->Instance->JDATAR;
mbed_official 330:c80ac197fa6a 2622
mbed_official 330:c80ac197fa6a 2623 /* Set CLRJOVRF bit in SDADC_CLRISR register */
mbed_official 330:c80ac197fa6a 2624 hsdadc->Instance->CLRISR |= SDADC_ISR_CLRJOVRF;
mbed_official 330:c80ac197fa6a 2625
mbed_official 330:c80ac197fa6a 2626 /* Update SDADC state */
mbed_official 330:c80ac197fa6a 2627 hsdadc->State = (hsdadc->State == HAL_SDADC_STATE_INJ) ? \
mbed_official 330:c80ac197fa6a 2628 HAL_SDADC_STATE_READY : HAL_SDADC_STATE_REG;
mbed_official 330:c80ac197fa6a 2629
mbed_official 330:c80ac197fa6a 2630 /* Return function status */
mbed_official 330:c80ac197fa6a 2631 return HAL_OK;
mbed_official 330:c80ac197fa6a 2632 }
mbed_official 330:c80ac197fa6a 2633
mbed_official 330:c80ac197fa6a 2634 /**
mbed_official 330:c80ac197fa6a 2635 * @}
mbed_official 330:c80ac197fa6a 2636 */
mbed_official 330:c80ac197fa6a 2637
mbed_official 330:c80ac197fa6a 2638 /**
mbed_official 330:c80ac197fa6a 2639 * @}
mbed_official 330:c80ac197fa6a 2640 */
mbed_official 330:c80ac197fa6a 2641
mbed_official 330:c80ac197fa6a 2642 #endif /* defined(STM32F373xC) || defined(STM32F378xx) */
mbed_official 330:c80ac197fa6a 2643 #endif /* HAL_SDADC_MODULE_ENABLED */
mbed_official 330:c80ac197fa6a 2644 /**
mbed_official 330:c80ac197fa6a 2645 * @}
mbed_official 330:c80ac197fa6a 2646 */
mbed_official 330:c80ac197fa6a 2647
mbed_official 330:c80ac197fa6a 2648 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/