/** | |
****************************************************************************** | |
* @file stm32f3xx_hal_sdadc.c | |
* @author MCD Application Team | |
* @brief This file provides firmware functions to manage the following | |
* functionalities of the Sigma-Delta Analog to Digital Converter | |
* (SDADC) peripherals: | |
* + Initialization and Configuration | |
* + Regular Channels Configuration | |
* + Injected channels Configuration | |
* + Power saving | |
* + Regular/Injected Channels DMA Configuration | |
* + Interrupts and flags management | |
@verbatim | |
============================================================================== | |
##### SDADC specific features ##### | |
============================================================================== | |
[..] | |
(#) 16-bit sigma delta architecture. | |
(#) Self calibration. | |
(#) Interrupt generation at the end of calibration, regular/injected conversion | |
and in case of overrun events. | |
(#) Single and continuous conversion modes. | |
(#) External trigger option with configurable polarity for injected conversion. | |
(#) Multi mode (synchronized another SDADC with SDADC1). | |
(#) DMA request generation during regular or injected channel conversion. | |
##### How to use this driver ##### | |
============================================================================== | |
[..] | |
*** Initialization *** | |
====================== | |
[..] | |
(#) As prerequisite, fill in the HAL_SDADC_MspInit() : | |
(++) Enable SDADCx clock interface with __SDADCx_CLK_ENABLE(). | |
(++) Configure SDADCx clock divider with HAL_RCCEx_PeriphCLKConfig. | |
(++) Enable power on SDADC with HAL_PWREx_EnableSDADC(). | |
(++) Enable the clocks for the SDADC GPIOS with __HAL_RCC_GPIOx_CLK_ENABLE(). | |
(++) Configure these SDADC pins in analog mode using HAL_GPIO_Init(). | |
(++) If interrupt mode is used, enable and configure SDADC global | |
interrupt with HAL_NVIC_SetPriority() and HAL_NVIC_EnableIRQ(). | |
(++) If DMA mode is used, configure DMA with HAL_DMA_Init and link it | |
with SDADC handle using __HAL_LINKDMA. | |
(#) Configure the SDADC low power mode, fast conversion mode, slow clock | |
mode and SDADC1 reference voltage using the HAL_ADC_Init() function. | |
Note: Common reference voltage. is common to all SDADC instances. | |
(#) Prepare channel configurations (input mode, common mode, gain and | |
offset) using HAL_SDADC_PrepareChannelConfig and associate channel | |
with one configuration using HAL_SDADC_AssociateChannelConfig. | |
*** Calibration *** | |
============================================ | |
[..] | |
(#) Start calibration using HAL_SDADC_StartCalibration or | |
HAL_SDADC_CalibrationStart_IT. | |
(#) In polling mode, use HAL_SDADC_PollForCalibEvent to detect the end of | |
calibration. | |
(#) In interrupt mode, HAL_SDADC_CalibrationCpltCallback will be called at | |
the end of calibration. | |
*** Regular channel conversion *** | |
============================================ | |
[..] | |
(#) Select trigger for regular conversion using | |
HAL_SDADC_SelectRegularTrigger. | |
(#) Select regular channel and enable/disable continuous mode using | |
HAL_SDADC_ConfigChannel. | |
(#) Start regular conversion using HAL_SDADC_Start, HAL_SDADC_Start_IT | |
or HAL_SDADC_Start_DMA. | |
(#) In polling mode, use HAL_SDADC_PollForConversion to detect the end of | |
regular conversion. | |
(#) In interrupt mode, HAL_SDADC_ConvCpltCallback will be called at the | |
end of regular conversion. | |
(#) Get value of regular conversion using HAL_SDADC_GetValue. | |
(#) In DMA mode, HAL_SDADC_ConvHalfCpltCallback and | |
HAL_SDADC_ConvCpltCallback will be called respectively at the half | |
transfer and at the transfer complete. | |
(#) Stop regular conversion using HAL_SDADC_Stop, HAL_SDADC_Stop_IT | |
or HAL_SDADC_Stop_DMA. | |
*** Injected channels conversion *** | |
============================================ | |
[..] | |
(#) Enable/disable delay on injected conversion using | |
HAL_SDADC_SelectInjectedDelay. | |
(#) If external trigger is used for injected conversion, configure this | |
trigger using HAL_SDADC_SelectInjectedExtTrigger. | |
(#) Select trigger for injected conversion using | |
HAL_SDADC_SelectInjectedTrigger. | |
(#) Select injected channels and enable/disable continuous mode using | |
HAL_SDADC_InjectedConfigChannel. | |
(#) Start injected conversion using HAL_SDADC_InjectedStart, | |
HAL_SDADC_InjectedStart_IT or HAL_SDADC_InjectedStart_DMA. | |
(#) In polling mode, use HAL_SDADC_PollForInjectedConversion to detect the | |
end of injected conversion. | |
(#) In interrupt mode, HAL_SDADC_InjectedConvCpltCallback will be called | |
at the end of injected conversion. | |
(#) Get value of injected conversion and corresponding channel using | |
HAL_SDADC_InjectedGetValue. | |
(#) In DMA mode, HAL_SDADC_InjectedConvHalfCpltCallback and | |
HAL_SDADC_InjectedConvCpltCallback will be called respectively at the | |
half transfer and at the transfer complete. | |
(#) Stop injected conversion using HAL_SDADC_InjectedStop, | |
HAL_SDADC_InjectedStop_IT or HAL_SDADC_InjectedStop_DMA. | |
*** Multi mode regular channels conversions *** | |
====================================================== | |
[..] | |
(#) Select type of multimode (SDADC1/SDADC2 or SDADC1/SDADC3) using | |
HAL_SDADC_MultiModeConfigChannel. | |
(#) Select software trigger for SDADC1 and synchronized trigger for | |
SDADC2 (or SDADC3) using HAL_SDADC_SelectRegularTrigger. | |
(#) Select regular channel for SDADC1 and SDADC2 (or SDADC3) using | |
HAL_SDADC_ConfigChannel. | |
(#) Start regular conversion for SDADC2 (or SDADC3) with HAL_SDADC_Start. | |
(#) Start regular conversion for SDADC1 using HAL_SDADC_Start, | |
HAL_SDADC_Start_IT or HAL_SDADC_MultiModeStart_DMA. | |
(#) In polling mode, use HAL_SDADC_PollForConversion to detect the end of | |
regular conversion for SDADC1. | |
(#) In interrupt mode, HAL_SDADC_ConvCpltCallback will be called at the | |
end of regular conversion for SDADC1. | |
(#) Get value of regular conversions using HAL_SDADC_MultiModeGetValue. | |
(#) In DMA mode, HAL_SDADC_ConvHalfCpltCallback and | |
HAL_SDADC_ConvCpltCallback will be called respectively at the half | |
transfer and at the transfer complete for SDADC1. | |
(#) Stop regular conversion using HAL_SDADC_Stop, HAL_SDADC_Stop_IT | |
or HAL_SDADC_MultiModeStop_DMA for SDADC1. | |
(#) Stop regular conversion using HAL_SDADC_Stop for SDADC2 (or SDADC3). | |
*** Multi mode injected channels conversions *** | |
====================================================== | |
[..] | |
(#) Select type of multimode (SDADC1/SDADC2 or SDADC1/SDADC3) using | |
HAL_SDADC_InjectedMultiModeConfigChannel. | |
(#) Select software or external trigger for SDADC1 and synchronized | |
trigger for SDADC2 (or SDADC3) using HAL_SDADC_SelectInjectedTrigger. | |
(#) Select injected channels for SDADC1 and SDADC2 (or SDADC3) using | |
HAL_SDADC_InjectedConfigChannel. | |
(#) Start injected conversion for SDADC2 (or SDADC3) with | |
HAL_SDADC_InjectedStart. | |
(#) Start injected conversion for SDADC1 using HAL_SDADC_InjectedStart, | |
HAL_SDADC_InjectedStart_IT or HAL_SDADC_InjectedMultiModeStart_DMA. | |
(#) In polling mode, use HAL_SDADC_InjectedPollForConversion to detect | |
the end of injected conversion for SDADC1. | |
(#) In interrupt mode, HAL_SDADC_InjectedConvCpltCallback will be called | |
at the end of injected conversion for SDADC1. | |
(#) Get value of injected conversions using | |
HAL_SDADC_InjectedMultiModeGetValue. | |
(#) In DMA mode, HAL_SDADC_InjectedConvHalfCpltCallback and | |
HAL_SDADC_InjectedConvCpltCallback will be called respectively at the | |
half transfer and at the transfer complete for SDADC1. | |
(#) Stop injected conversion using HAL_SDADC_InjectedStop, | |
HAL_SDADC_InjectedStop_IT or HAL_SDADC_InjecteddMultiModeStop_DMA | |
for SDADC1. | |
(#) Stop injected conversion using HAL_SDADC_InjectedStop for SDADC2 | |
(or SDADC3). | |
@endverbatim | |
****************************************************************************** | |
* @attention | |
* | |
* <h2><center>© COPYRIGHT(c) 2016 STMicroelectronics</center></h2> | |
* | |
* Redistribution and use in source and binary forms, with or without modification, | |
* are permitted provided that the following conditions are met: | |
* 1. Redistributions of source code must retain the above copyright notice, | |
* this list of conditions and the following disclaimer. | |
* 2. Redistributions in binary form must reproduce the above copyright notice, | |
* this list of conditions and the following disclaimer in the documentation | |
* and/or other materials provided with the distribution. | |
* 3. Neither the name of STMicroelectronics nor the names of its contributors | |
* may be used to endorse or promote products derived from this software | |
* without specific prior written permission. | |
* | |
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" | |
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | |
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE | |
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | |
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR | |
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER | |
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, | |
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
* | |
****************************************************************************** | |
*/ | |
/* Includes ------------------------------------------------------------------*/ | |
#include "stm32f3xx_hal.h" | |
/** @addtogroup STM32F3xx_HAL_Driver | |
* @{ | |
*/ | |
#ifdef HAL_SDADC_MODULE_ENABLED | |
#if defined(STM32F373xC) || defined(STM32F378xx) | |
/** @defgroup SDADC SDADC | |
* @brief SDADC HAL driver modules | |
* @{ | |
*/ | |
/* Private typedef -----------------------------------------------------------*/ | |
/* Private define ------------------------------------------------------------*/ | |
/** @defgroup SDADC_Private_Define SDADC Private Define | |
* @{ | |
*/ | |
#define SDADC_TIMEOUT 200 | |
#define SDADC_CONFREG_OFFSET 0x00000020 | |
#define SDADC_JDATAR_CH_OFFSET 24 | |
#define SDADC_MSB_MASK 0xFFFF0000U | |
#define SDADC_LSB_MASK 0x0000FFFFU | |
/** | |
* @} | |
*/ | |
/* Private macro -------------------------------------------------------------*/ | |
/* Private variables ---------------------------------------------------------*/ | |
/* Private function prototypes -----------------------------------------------*/ | |
/** @defgroup SDADC_Private_Functions SDADC Private Functions | |
* @{ | |
*/ | |
static HAL_StatusTypeDef SDADC_EnterInitMode(SDADC_HandleTypeDef* hsdadc); | |
static void SDADC_ExitInitMode(SDADC_HandleTypeDef* hsdadc); | |
static uint32_t SDADC_GetInjChannelsNbr(uint32_t Channels); | |
static HAL_StatusTypeDef SDADC_RegConvStart(SDADC_HandleTypeDef* hsdadc); | |
static HAL_StatusTypeDef SDADC_RegConvStop(SDADC_HandleTypeDef* hsdadc); | |
static HAL_StatusTypeDef SDADC_InjConvStart(SDADC_HandleTypeDef* hsdadc); | |
static HAL_StatusTypeDef SDADC_InjConvStop(SDADC_HandleTypeDef* hsdadc); | |
static void SDADC_DMARegularHalfConvCplt(DMA_HandleTypeDef *hdma); | |
static void SDADC_DMARegularConvCplt(DMA_HandleTypeDef *hdma); | |
static void SDADC_DMAInjectedHalfConvCplt(DMA_HandleTypeDef *hdma); | |
static void SDADC_DMAInjectedConvCplt(DMA_HandleTypeDef *hdma); | |
static void SDADC_DMAError(DMA_HandleTypeDef *hdma); | |
/** | |
* @} | |
*/ | |
/* Exported functions ---------------------------------------------------------*/ | |
/** @defgroup SDADC_Exported_Functions SDADC Exported Functions | |
* @{ | |
*/ | |
/** @defgroup SDADC_Exported_Functions_Group1 Initialization and de-initialization functions | |
* @brief Initialization and de-initialization functions | |
* | |
@verbatim | |
=============================================================================== | |
##### Initialization and de-initialization functions ##### | |
=============================================================================== | |
[..] This section provides functions allowing to: | |
(+) Initialize the SDADC. | |
(+) De-initialize the SDADC. | |
@endverbatim | |
* @{ | |
*/ | |
/** | |
* @brief Initializes the SDADC according to the specified | |
* parameters in the SDADC_InitTypeDef structure. | |
* @note If multiple SDADC are used, please configure first SDADC1 to set | |
* the common reference voltage. | |
* @param hsdadc SDADC handle. | |
* @retval HAL status. | |
*/ | |
HAL_StatusTypeDef HAL_SDADC_Init(SDADC_HandleTypeDef* hsdadc) | |
{ | |
/* Check SDADC handle */ | |
if(hsdadc == NULL) | |
{ | |
return HAL_ERROR; | |
} | |
/* Check parameters */ | |
assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance)); | |
assert_param(IS_SDADC_LOWPOWER_MODE(hsdadc->Init.IdleLowPowerMode)); | |
assert_param(IS_SDADC_FAST_CONV_MODE(hsdadc->Init.FastConversionMode)); | |
assert_param(IS_SDADC_SLOW_CLOCK_MODE(hsdadc->Init.SlowClockMode)); | |
assert_param(IS_SDADC_VREF(hsdadc->Init.ReferenceVoltage)); | |
/* Initialize SDADC variables with default values */ | |
hsdadc->RegularContMode = SDADC_CONTINUOUS_CONV_OFF; | |
hsdadc->InjectedContMode = SDADC_CONTINUOUS_CONV_OFF; | |
hsdadc->InjectedChannelsNbr = 1U; | |
hsdadc->InjConvRemaining = 1U; | |
hsdadc->RegularTrigger = SDADC_SOFTWARE_TRIGGER; | |
hsdadc->InjectedTrigger = SDADC_SOFTWARE_TRIGGER; | |
hsdadc->ExtTriggerEdge = SDADC_EXT_TRIG_RISING_EDGE; | |
hsdadc->RegularMultimode = SDADC_MULTIMODE_SDADC1_SDADC2; | |
hsdadc->InjectedMultimode = SDADC_MULTIMODE_SDADC1_SDADC2; | |
hsdadc->ErrorCode = SDADC_ERROR_NONE; | |
/* Call MSP init function */ | |
HAL_SDADC_MspInit(hsdadc); | |
/* Set idle low power and slow clock modes */ | |
hsdadc->Instance->CR1 &= ~(SDADC_CR1_SBI|SDADC_CR1_PDI|SDADC_CR1_SLOWCK); | |
hsdadc->Instance->CR1 |= (hsdadc->Init.IdleLowPowerMode | \ | |
hsdadc->Init.SlowClockMode); | |
/* Set fast conversion mode */ | |
hsdadc->Instance->CR2 &= ~(SDADC_CR2_FAST); | |
hsdadc->Instance->CR2 |= hsdadc->Init.FastConversionMode; | |
/* Set reference voltage common to all SDADC instances */ | |
/* Update this parameter only if needed to avoid unnecessary settling time */ | |
if((SDADC1->CR1 & SDADC_CR1_REFV) != hsdadc->Init.ReferenceVoltage) | |
{ | |
/* Voltage reference bits are common to all SADC instances but are */ | |
/* present in SDADC1 register. */ | |
SDADC1->CR1 &= ~(SDADC_CR1_REFV); | |
SDADC1->CR1 |= hsdadc->Init.ReferenceVoltage; | |
/* Wait at least 2ms before setting ADON */ | |
HAL_Delay(2U); | |
} | |
/* Enable SDADC */ | |
hsdadc->Instance->CR2 |= SDADC_CR2_ADON; | |
/* Wait end of stabilization */ | |
while((hsdadc->Instance->ISR & SDADC_ISR_STABIP) != 0U) | |
{ | |
} | |
/* Set SDADC to ready state */ | |
hsdadc->State = HAL_SDADC_STATE_READY; | |
/* Return HAL status */ | |
return HAL_OK; | |
} | |
/** | |
* @brief De-initializes the SDADC. | |
* @param hsdadc SDADC handle. | |
* @retval HAL status. | |
*/ | |
HAL_StatusTypeDef HAL_SDADC_DeInit(SDADC_HandleTypeDef* hsdadc) | |
{ | |
/* Check SDADC handle */ | |
if(hsdadc == NULL) | |
{ | |
return HAL_ERROR; | |
} | |
/* Check parameters */ | |
assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance)); | |
/* Disable the SDADC */ | |
hsdadc->Instance->CR2 &= ~(SDADC_CR2_ADON); | |
/* Reset all registers */ | |
hsdadc->Instance->CR1 = 0x00000000U; | |
hsdadc->Instance->CR2 = 0x00000000U; | |
hsdadc->Instance->JCHGR = 0x00000001U; | |
hsdadc->Instance->CONF0R = 0x00000000U; | |
hsdadc->Instance->CONF1R = 0x00000000U; | |
hsdadc->Instance->CONF2R = 0x00000000U; | |
hsdadc->Instance->CONFCHR1 = 0x00000000U; | |
hsdadc->Instance->CONFCHR2 = 0x00000000U; | |
/* Call MSP deinit function */ | |
HAL_SDADC_MspDeInit(hsdadc); | |
/* Set SDADC in reset state */ | |
hsdadc->State = HAL_SDADC_STATE_RESET; | |
/* Return function status */ | |
return HAL_OK; | |
} | |
/** | |
* @brief Initializes the SDADC MSP. | |
* @param hsdadc SDADC handle | |
* @retval None | |
*/ | |
__weak void HAL_SDADC_MspInit(SDADC_HandleTypeDef* hsdadc) | |
{ | |
/* Prevent unused argument(s) compilation warning */ | |
UNUSED(hsdadc); | |
/* NOTE : This function should not be modified, when the callback is needed, | |
the HAL_SDADC_MspInit could be implemented in the user file. | |
*/ | |
} | |
/** | |
* @brief De-initializes the SDADC MSP. | |
* @param hsdadc SDADC handle | |
* @retval None | |
*/ | |
__weak void HAL_SDADC_MspDeInit(SDADC_HandleTypeDef* hsdadc) | |
{ | |
/* Prevent unused argument(s) compilation warning */ | |
UNUSED(hsdadc); | |
/* NOTE : This function should not be modified, when the callback is needed, | |
the HAL_SDADC_MspDeInit could be implemented in the user file. | |
*/ | |
} | |
/** | |
* @} | |
*/ | |
/** @defgroup SDADC_Exported_Functions_Group2 peripheral control functions | |
* @brief Peripheral control functions | |
* | |
@verbatim | |
=============================================================================== | |
##### Peripheral control functions ##### | |
=============================================================================== | |
[..] This section provides functions allowing to: | |
(+) Program one of the three different configurations for channels. | |
(+) Associate channel to one of configurations. | |
(+) Select regular and injected channels. | |
(+) Enable/disable continuous mode for regular and injected conversions. | |
(+) Select regular and injected triggers. | |
(+) Select and configure injected external trigger. | |
(+) Enable/disable delay addition for injected conversions. | |
(+) Configure multimode. | |
@endverbatim | |
* @{ | |
*/ | |
/** | |
* @brief This function allows the user to set parameters for a configuration. | |
* Parameters are input mode, common mode, gain and offset. | |
* @note This function should be called only when SDADC instance is in idle state | |
* (neither calibration nor regular or injected conversion ongoing) | |
* @param hsdadc SDADC handle. | |
* @param ConfIndex Index of configuration to modify. | |
* This parameter can be a value of @ref SDADC_ConfIndex. | |
* @param ConfParamStruct Parameters to apply for this configuration. | |
* @retval HAL status | |
*/ | |
HAL_StatusTypeDef HAL_SDADC_PrepareChannelConfig(SDADC_HandleTypeDef *hsdadc, | |
uint32_t ConfIndex, | |
SDADC_ConfParamTypeDef* ConfParamStruct) | |
{ | |
HAL_StatusTypeDef status = HAL_OK; | |
uint32_t tmp = 0U; | |
/* Check parameters */ | |
assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance)); | |
assert_param(IS_SDADC_CONF_INDEX(ConfIndex)); | |
assert_param(ConfParamStruct != NULL); | |
assert_param(IS_SDADC_INPUT_MODE(ConfParamStruct->InputMode)); | |
assert_param(IS_SDADC_GAIN(ConfParamStruct->Gain)); | |
assert_param(IS_SDADC_COMMON_MODE(ConfParamStruct->CommonMode)); | |
assert_param(IS_SDADC_OFFSET_VALUE(ConfParamStruct->Offset)); | |
/* Check SDADC state is ready */ | |
if(hsdadc->State != HAL_SDADC_STATE_READY) | |
{ | |
status = HAL_ERROR; | |
} | |
else | |
{ | |
/* Enter init mode */ | |
if(SDADC_EnterInitMode(hsdadc) != HAL_OK) | |
{ | |
/* Set SDADC in error state */ | |
hsdadc->State = HAL_SDADC_STATE_ERROR; | |
status = HAL_TIMEOUT; | |
} | |
else | |
{ | |
/* Program configuration register with parameters */ | |
tmp = (uint32_t)((uint32_t)(hsdadc->Instance) + \ | |
SDADC_CONFREG_OFFSET + \ | |
(uint32_t)(ConfIndex << 2U)); | |
*(__IO uint32_t *) (tmp) = (uint32_t) (ConfParamStruct->InputMode | \ | |
ConfParamStruct->Gain | \ | |
ConfParamStruct->CommonMode | \ | |
ConfParamStruct->Offset); | |
/* Exit init mode */ | |
SDADC_ExitInitMode(hsdadc); | |
} | |
} | |
/* Return function status */ | |
return status; | |
} | |
/** | |
* @brief This function allows the user to associate a channel with one of the | |
* available configurations. | |
* @note This function should be called only when SDADC instance is in idle state | |
* (neither calibration nor regular or injected conversion ongoing) | |
* @param hsdadc SDADC handle. | |
* @param Channel Channel to associate with configuration. | |
* This parameter can be a value of @ref SDADC_Channel_Selection. | |
* @param ConfIndex Index of configuration to associate with channel. | |
* This parameter can be a value of @ref SDADC_ConfIndex. | |
* @retval HAL status | |
*/ | |
HAL_StatusTypeDef HAL_SDADC_AssociateChannelConfig(SDADC_HandleTypeDef *hsdadc, | |
uint32_t Channel, | |
uint32_t ConfIndex) | |
{ | |
HAL_StatusTypeDef status = HAL_OK; | |
uint32_t channelnum = 0U; | |
/* Check parameters */ | |
assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance)); | |
assert_param(IS_SDADC_REGULAR_CHANNEL(Channel)); | |
assert_param(IS_SDADC_CONF_INDEX(ConfIndex)); | |
/* Check SDADC state is ready */ | |
if(hsdadc->State != HAL_SDADC_STATE_READY) | |
{ | |
status = HAL_ERROR; | |
} | |
else | |
{ | |
/* Enter init mode */ | |
if(SDADC_EnterInitMode(hsdadc) != HAL_OK) | |
{ | |
/* Set SDADC in error state */ | |
hsdadc->State = HAL_SDADC_STATE_ERROR; | |
status = HAL_TIMEOUT; | |
} | |
else | |
{ | |
/* Program channel configuration register according parameters */ | |
if(Channel != SDADC_CHANNEL_8) | |
{ | |
/* Get channel number */ | |
channelnum = (uint32_t)(Channel>>16U); | |
/* Set the channel configuration */ | |
hsdadc->Instance->CONFCHR1 &= (uint32_t) ~((uint32_t)SDADC_CONFCHR1_CONFCH0 << (channelnum << 2U)); | |
hsdadc->Instance->CONFCHR1 |= (uint32_t) (ConfIndex << (channelnum << 2U)); | |
} | |
else | |
{ | |
hsdadc->Instance->CONFCHR2 = (uint32_t) (ConfIndex); | |
} | |
/* Exit init mode */ | |
SDADC_ExitInitMode(hsdadc); | |
} | |
} | |
/* Return function status */ | |
return status; | |
} | |
/** | |
* @brief This function allows to select channel for regular conversion and | |
* to enable/disable continuous mode for regular conversion. | |
* @param hsdadc SDADC handle. | |
* @param Channel Channel for regular conversion. | |
* This parameter can be a value of @ref SDADC_Channel_Selection. | |
* @param ContinuousMode Enable/disable continuous mode for regular conversion. | |
* This parameter can be a value of @ref SDADC_ContinuousMode. | |
* @retval HAL status | |
*/ | |
HAL_StatusTypeDef HAL_SDADC_ConfigChannel(SDADC_HandleTypeDef *hsdadc, | |
uint32_t Channel, | |
uint32_t ContinuousMode) | |
{ | |
HAL_StatusTypeDef status = HAL_OK; | |
/* Check parameters */ | |
assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance)); | |
assert_param(IS_SDADC_REGULAR_CHANNEL(Channel)); | |
assert_param(IS_SDADC_CONTINUOUS_MODE(ContinuousMode)); | |
/* Check SDADC state */ | |
if((hsdadc->State != HAL_SDADC_STATE_RESET) && (hsdadc->State != HAL_SDADC_STATE_ERROR)) | |
{ | |
/* Set RCH[3:0] and RCONT bits in SDADC_CR2 */ | |
hsdadc->Instance->CR2 &= (uint32_t) ~(SDADC_CR2_RCH | SDADC_CR2_RCONT); | |
if(ContinuousMode == SDADC_CONTINUOUS_CONV_ON) | |
{ | |
hsdadc->Instance->CR2 |= (uint32_t) ((Channel & SDADC_MSB_MASK) | SDADC_CR2_RCONT); | |
} | |
else | |
{ | |
hsdadc->Instance->CR2 |= (uint32_t) ((Channel & SDADC_MSB_MASK)); | |
} | |
/* Store continuous mode information */ | |
hsdadc->RegularContMode = ContinuousMode; | |
} | |
else | |
{ | |
status = HAL_ERROR; | |
} | |
/* Return function status */ | |
return status; | |
} | |
/** | |
* @brief This function allows to select channels for injected conversion and | |
* to enable/disable continuous mode for injected conversion. | |
* @param hsdadc SDADC handle. | |
* @param Channel Channels for injected conversion. | |
* This parameter can be a values combination of @ref SDADC_Channel_Selection. | |
* @param ContinuousMode Enable/disable continuous mode for injected conversion. | |
* This parameter can be a value of @ref SDADC_ContinuousMode. | |
* @retval HAL status | |
*/ | |
HAL_StatusTypeDef HAL_SDADC_InjectedConfigChannel(SDADC_HandleTypeDef *hsdadc, | |
uint32_t Channel, | |
uint32_t ContinuousMode) | |
{ | |
HAL_StatusTypeDef status = HAL_OK; | |
/* Check parameters */ | |
assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance)); | |
assert_param(IS_SDADC_INJECTED_CHANNEL(Channel)); | |
assert_param(IS_SDADC_CONTINUOUS_MODE(ContinuousMode)); | |
/* Check SDADC state */ | |
if((hsdadc->State != HAL_SDADC_STATE_RESET) && (hsdadc->State != HAL_SDADC_STATE_ERROR)) | |
{ | |
/* Set JCHG[8:0] bits in SDADC_JCHG */ | |
hsdadc->Instance->JCHGR = (uint32_t) (Channel & SDADC_LSB_MASK); | |
/* Set or clear JCONT bit in SDADC_CR2 */ | |
if(ContinuousMode == SDADC_CONTINUOUS_CONV_ON) | |
{ | |
hsdadc->Instance->CR2 |= SDADC_CR2_JCONT; | |
} | |
else | |
{ | |
hsdadc->Instance->CR2 &= ~(SDADC_CR2_JCONT); | |
} | |
/* Store continuous mode information */ | |
hsdadc->InjectedContMode = ContinuousMode; | |
/* Store number of injected channels */ | |
hsdadc->InjectedChannelsNbr = SDADC_GetInjChannelsNbr(Channel); | |
} | |
else | |
{ | |
status = HAL_ERROR; | |
} | |
/* Return function status */ | |
return status; | |
} | |
/** | |
* @brief This function allows to select trigger for regular conversions. | |
* @note This function should not be called if regular conversion is ongoing. | |
* @param hsdadc SDADC handle. | |
* @param Trigger Trigger for regular conversions. | |
* This parameter can be one of the following value : | |
* @arg SDADC_SOFTWARE_TRIGGER : Software trigger. | |
* @arg SDADC_SYNCHRONOUS_TRIGGER : Synchronous with SDADC1 (only for SDADC2 and SDADC3). | |
* @retval HAL status | |
*/ | |
HAL_StatusTypeDef HAL_SDADC_SelectRegularTrigger(SDADC_HandleTypeDef *hsdadc, uint32_t Trigger) | |
{ | |
HAL_StatusTypeDef status = HAL_OK; | |
/* Check parameters */ | |
assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance)); | |
assert_param(IS_SDADC_REGULAR_TRIGGER(Trigger)); | |
/* Check parameters compatibility */ | |
if((hsdadc->Instance == SDADC1) && (Trigger == SDADC_SYNCHRONOUS_TRIGGER)) | |
{ | |
status = HAL_ERROR; | |
} | |
/* Check SDADC state */ | |
else if((hsdadc->State == HAL_SDADC_STATE_READY) || \ | |
(hsdadc->State == HAL_SDADC_STATE_CALIB) || \ | |
(hsdadc->State == HAL_SDADC_STATE_INJ)) | |
{ | |
/* Store regular trigger information */ | |
hsdadc->RegularTrigger = Trigger; | |
} | |
else | |
{ | |
status = HAL_ERROR; | |
} | |
/* Return function status */ | |
return status; | |
} | |
/** | |
* @brief This function allows to select trigger for injected conversions. | |
* @note This function should not be called if injected conversion is ongoing. | |
* @param hsdadc SDADC handle. | |
* @param Trigger Trigger for injected conversions. | |
* This parameter can be one of the following value : | |
* @arg SDADC_SOFTWARE_TRIGGER : Software trigger. | |
* @arg SDADC_SYNCHRONOUS_TRIGGER : Synchronous with SDADC1 (only for SDADC2 and SDADC3). | |
* @arg SDADC_EXTERNAL_TRIGGER : External trigger. | |
* @retval HAL status | |
*/ | |
HAL_StatusTypeDef HAL_SDADC_SelectInjectedTrigger(SDADC_HandleTypeDef *hsdadc, uint32_t Trigger) | |
{ | |
HAL_StatusTypeDef status = HAL_OK; | |
/* Check parameters */ | |
assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance)); | |
assert_param(IS_SDADC_INJECTED_TRIGGER(Trigger)); | |
/* Check parameters compatibility */ | |
if((hsdadc->Instance == SDADC1) && (Trigger == SDADC_SYNCHRONOUS_TRIGGER)) | |
{ | |
status = HAL_ERROR; | |
} | |
/* Check SDADC state */ | |
else if((hsdadc->State == HAL_SDADC_STATE_READY) || \ | |
(hsdadc->State == HAL_SDADC_STATE_CALIB) || \ | |
(hsdadc->State == HAL_SDADC_STATE_REG)) | |
{ | |
/* Store regular trigger information */ | |
hsdadc->InjectedTrigger = Trigger; | |
} | |
else | |
{ | |
status = HAL_ERROR; | |
} | |
/* Return function status */ | |
return status; | |
} | |
/** | |
* @brief This function allows to select and configure injected external trigger. | |
* @note This function should be called only when SDADC instance is in idle state | |
* (neither calibration nor regular or injected conversion ongoing) | |
* @param hsdadc SDADC handle. | |
* @param InjectedExtTrigger External trigger for injected conversions. | |
* This parameter can be a value of @ref SDADC_InjectedExtTrigger. | |
* @param ExtTriggerEdge Edge of external injected trigger. | |
* This parameter can be a value of @ref SDADC_ExtTriggerEdge. | |
* @retval HAL status | |
*/ | |
HAL_StatusTypeDef HAL_SDADC_SelectInjectedExtTrigger(SDADC_HandleTypeDef *hsdadc, | |
uint32_t InjectedExtTrigger, | |
uint32_t ExtTriggerEdge) | |
{ | |
HAL_StatusTypeDef status = HAL_OK; | |
/* Check parameters */ | |
assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance)); | |
assert_param(IS_SDADC_EXT_INJEC_TRIG(InjectedExtTrigger)); | |
assert_param(IS_SDADC_EXT_TRIG_EDGE(ExtTriggerEdge)); | |
/* Check SDADC state */ | |
if(hsdadc->State == HAL_SDADC_STATE_READY) | |
{ | |
/* Enter init mode */ | |
if(SDADC_EnterInitMode(hsdadc) != HAL_OK) | |
{ | |
/* Set SDADC in error state */ | |
hsdadc->State = HAL_SDADC_STATE_ERROR; | |
status = HAL_TIMEOUT; | |
} | |
else | |
{ | |
/* Set JEXTSEL[2:0] bits in SDADC_CR2 register */ | |
hsdadc->Instance->CR2 &= ~(SDADC_CR2_JEXTSEL); | |
hsdadc->Instance->CR2 |= InjectedExtTrigger; | |
/* Store external trigger edge information */ | |
hsdadc->ExtTriggerEdge = ExtTriggerEdge; | |
/* Exit init mode */ | |
SDADC_ExitInitMode(hsdadc); | |
} | |
} | |
else | |
{ | |
status = HAL_ERROR; | |
} | |
/* Return function status */ | |
return status; | |
} | |
/** | |
* @brief This function allows to enable/disable delay addition for injected conversions. | |
* @note This function should be called only when SDADC instance is in idle state | |
* (neither calibration nor regular or injected conversion ongoing) | |
* @param hsdadc SDADC handle. | |
* @param InjectedDelay Enable/disable delay for injected conversions. | |
* This parameter can be a value of @ref SDADC_InjectedDelay. | |
* @retval HAL status | |
*/ | |
HAL_StatusTypeDef HAL_SDADC_SelectInjectedDelay(SDADC_HandleTypeDef *hsdadc, | |
uint32_t InjectedDelay) | |
{ | |
HAL_StatusTypeDef status = HAL_OK; | |
/* Check parameters */ | |
assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance)); | |
assert_param(IS_SDADC_INJECTED_DELAY(InjectedDelay)); | |
/* Check SDADC state */ | |
if(hsdadc->State == HAL_SDADC_STATE_READY) | |
{ | |
/* Enter init mode */ | |
if(SDADC_EnterInitMode(hsdadc) != HAL_OK) | |
{ | |
/* Set SDADC in error state */ | |
hsdadc->State = HAL_SDADC_STATE_ERROR; | |
status = HAL_TIMEOUT; | |
} | |
else | |
{ | |
/* Set JDS bit in SDADC_CR2 register */ | |
hsdadc->Instance->CR2 &= ~(SDADC_CR2_JDS); | |
hsdadc->Instance->CR2 |= InjectedDelay; | |
/* Exit init mode */ | |
SDADC_ExitInitMode(hsdadc); | |
} | |
} | |
else | |
{ | |
status = HAL_ERROR; | |
} | |
/* Return function status */ | |
return status; | |
} | |
/** | |
* @brief This function allows to configure multimode for regular conversions. | |
* @note This function should not be called if regular conversion is ongoing | |
* and should be could only for SDADC1. | |
* @param hsdadc SDADC handle. | |
* @param MultimodeType Type of multimode for regular conversions. | |
* This parameter can be a value of @ref SDADC_MultimodeType. | |
* @retval HAL status | |
*/ | |
HAL_StatusTypeDef HAL_SDADC_MultiModeConfigChannel(SDADC_HandleTypeDef* hsdadc, | |
uint32_t MultimodeType) | |
{ | |
HAL_StatusTypeDef status = HAL_OK; | |
/* Check parameters */ | |
assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance)); | |
assert_param(IS_SDADC_MULTIMODE_TYPE(MultimodeType)); | |
/* Check instance is SDADC1 */ | |
if(hsdadc->Instance != SDADC1) | |
{ | |
status = HAL_ERROR; | |
} | |
/* Check SDADC state */ | |
else if((hsdadc->State == HAL_SDADC_STATE_READY) || \ | |
(hsdadc->State == HAL_SDADC_STATE_CALIB) || \ | |
(hsdadc->State == HAL_SDADC_STATE_INJ)) | |
{ | |
/* Store regular trigger information */ | |
hsdadc->RegularMultimode = MultimodeType; | |
} | |
else | |
{ | |
status = HAL_ERROR; | |
} | |
/* Return function status */ | |
return status; | |
} | |
/** | |
* @brief This function allows to configure multimode for injected conversions. | |
* @note This function should not be called if injected conversion is ongoing | |
* and should be could only for SDADC1. | |
* @param hsdadc SDADC handle. | |
* @param MultimodeType Type of multimode for injected conversions. | |
* This parameter can be a value of @ref SDADC_MultimodeType. | |
* @retval HAL status | |
*/ | |
HAL_StatusTypeDef HAL_SDADC_InjectedMultiModeConfigChannel(SDADC_HandleTypeDef* hsdadc, | |
uint32_t MultimodeType) | |
{ | |
HAL_StatusTypeDef status = HAL_OK; | |
/* Check parameters */ | |
assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance)); | |
assert_param(IS_SDADC_MULTIMODE_TYPE(MultimodeType)); | |
/* Check instance is SDADC1 */ | |
if(hsdadc->Instance != SDADC1) | |
{ | |
status = HAL_ERROR; | |
} | |
/* Check SDADC state */ | |
else if((hsdadc->State == HAL_SDADC_STATE_READY) || \ | |
(hsdadc->State == HAL_SDADC_STATE_CALIB) || \ | |
(hsdadc->State == HAL_SDADC_STATE_REG)) | |
{ | |
/* Store regular trigger information */ | |
hsdadc->InjectedMultimode = MultimodeType; | |
} | |
else | |
{ | |
status = HAL_ERROR; | |
} | |
/* Return function status */ | |
return status; | |
} | |
/** | |
* @} | |
*/ | |
/** @defgroup SDADC_Exported_Functions_Group3 Input and Output operation functions | |
* @brief IO operation Control functions | |
* | |
@verbatim | |
=============================================================================== | |
##### IO operation functions ##### | |
=============================================================================== | |
[..] This section provides functions allowing to: | |
(+) Start calibration. | |
(+) Poll for the end of calibration. | |
(+) Start calibration and enable interrupt. | |
(+) Start conversion of regular/injected channel. | |
(+) Poll for the end of regular/injected conversion. | |
(+) Stop conversion of regular/injected channel. | |
(+) Start conversion of regular/injected channel and enable interrupt. | |
(+) Stop conversion of regular/injected channel and disable interrupt. | |
(+) Start conversion of regular/injected channel and enable DMA transfer. | |
(+) Stop conversion of regular/injected channel and disable DMA transfer. | |
(+) Start multimode and enable DMA transfer for regular/injected conversion. | |
(+) Stop multimode and disable DMA transfer for regular/injected conversion.. | |
(+) Get result of regular channel conversion. | |
(+) Get result of injected channel conversion. | |
(+) Get result of multimode conversion. | |
(+) Handle SDADC interrupt request. | |
(+) Callbacks for calibration and regular/injected conversions. | |
@endverbatim | |
* @{ | |
*/ | |
/** | |
* @brief This function allows to start calibration in polling mode. | |
* @note This function should be called only when SDADC instance is in idle state | |
* (neither calibration nor regular or injected conversion ongoing). | |
* @param hsdadc SDADC handle. | |
* @param CalibrationSequence Calibration sequence. | |
* This parameter can be a value of @ref SDADC_CalibrationSequence. | |
* @retval HAL status | |
*/ | |
HAL_StatusTypeDef HAL_SDADC_CalibrationStart(SDADC_HandleTypeDef *hsdadc, | |
uint32_t CalibrationSequence) | |
{ | |
HAL_StatusTypeDef status = HAL_OK; | |
/* Check parameters */ | |
assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance)); | |
assert_param(IS_SDADC_CALIB_SEQUENCE(CalibrationSequence)); | |
/* Check SDADC state */ | |
if(hsdadc->State == HAL_SDADC_STATE_READY) | |
{ | |
/* Enter init mode */ | |
if(SDADC_EnterInitMode(hsdadc) != HAL_OK) | |
{ | |
/* Set SDADC in error state */ | |
hsdadc->State = HAL_SDADC_STATE_ERROR; | |
status = HAL_TIMEOUT; | |
} | |
else | |
{ | |
/* Set CALIBCNT[1:0] bits in SDADC_CR2 register */ | |
hsdadc->Instance->CR2 &= ~(SDADC_CR2_CALIBCNT); | |
hsdadc->Instance->CR2 |= CalibrationSequence; | |
/* Exit init mode */ | |
SDADC_ExitInitMode(hsdadc); | |
/* Set STARTCALIB in SDADC_CR2 */ | |
hsdadc->Instance->CR2 |= SDADC_CR2_STARTCALIB; | |
/* Set SDADC in calibration state */ | |
hsdadc->State = HAL_SDADC_STATE_CALIB; | |
} | |
} | |
else | |
{ | |
status = HAL_ERROR; | |
} | |
/* Return function status */ | |
return status; | |
} | |
/** | |
* @brief This function allows to poll for the end of calibration. | |
* @note This function should be called only if calibration is ongoing. | |
* @param hsdadc SDADC handle. | |
* @param Timeout Timeout value in milliseconds. | |
* @retval HAL status | |
*/ | |
HAL_StatusTypeDef HAL_SDADC_PollForCalibEvent(SDADC_HandleTypeDef* hsdadc, uint32_t Timeout) | |
{ | |
uint32_t tickstart; | |
/* Check parameters */ | |
assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance)); | |
/* Check SDADC state */ | |
if(hsdadc->State != HAL_SDADC_STATE_CALIB) | |
{ | |
/* Return error status */ | |
return HAL_ERROR; | |
} | |
else | |
{ | |
/* Get timeout */ | |
tickstart = HAL_GetTick(); | |
/* Wait EOCALF bit in SDADC_ISR register */ | |
while((hsdadc->Instance->ISR & SDADC_ISR_EOCALF) != SDADC_ISR_EOCALF) | |
{ | |
/* Check the Timeout */ | |
if(Timeout != HAL_MAX_DELAY) | |
{ | |
if((Timeout == 0U) || ((HAL_GetTick()-tickstart) > Timeout)) | |
{ | |
/* Return timeout status */ | |
return HAL_TIMEOUT; | |
} | |
} | |
} | |
/* Set CLREOCALF bit in SDADC_CLRISR register */ | |
hsdadc->Instance->CLRISR |= SDADC_ISR_CLREOCALF; | |
/* Set SDADC in ready state */ | |
hsdadc->State = HAL_SDADC_STATE_READY; | |
/* Return function status */ | |
return HAL_OK; | |
} | |
} | |
/** | |
* @brief This function allows to start calibration in interrupt mode. | |
* @note This function should be called only when SDADC instance is in idle state | |
* (neither calibration nor regular or injected conversion ongoing). | |
* @param hsdadc SDADC handle. | |
* @param CalibrationSequence Calibration sequence. | |
* This parameter can be a value of @ref SDADC_CalibrationSequence. | |
* @retval HAL status | |
*/ | |
HAL_StatusTypeDef HAL_SDADC_CalibrationStart_IT(SDADC_HandleTypeDef *hsdadc, | |
uint32_t CalibrationSequence) | |
{ | |
HAL_StatusTypeDef status = HAL_OK; | |
/* Check parameters */ | |
assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance)); | |
assert_param(IS_SDADC_CALIB_SEQUENCE(CalibrationSequence)); | |
/* Check SDADC state */ | |
if(hsdadc->State == HAL_SDADC_STATE_READY) | |
{ | |
/* Enter init mode */ | |
if(SDADC_EnterInitMode(hsdadc) != HAL_OK) | |
{ | |
/* Set SDADC in error state */ | |
hsdadc->State = HAL_SDADC_STATE_ERROR; | |
status = HAL_TIMEOUT; | |
} | |
else | |
{ | |
/* Set CALIBCNT[1:0] bits in SDADC_CR2 register */ | |
hsdadc->Instance->CR2 &= ~(SDADC_CR2_CALIBCNT); | |
hsdadc->Instance->CR2 |= CalibrationSequence; | |
/* Exit init mode */ | |
SDADC_ExitInitMode(hsdadc); | |
/* Set EOCALIE bit in SDADC_CR1 register */ | |
hsdadc->Instance->CR1 |= SDADC_CR1_EOCALIE; | |
/* Set STARTCALIB in SDADC_CR2 */ | |
hsdadc->Instance->CR2 |= SDADC_CR2_STARTCALIB; | |
/* Set SDADC in calibration state */ | |
hsdadc->State = HAL_SDADC_STATE_CALIB; | |
} | |
} | |
else | |
{ | |
status = HAL_ERROR; | |
} | |
/* Return function status */ | |
return status; | |
} | |
/** | |
* @brief This function allows to start regular conversion in polling mode. | |
* @note This function should be called only when SDADC instance is in idle state | |
* or if injected conversion is ongoing. | |
* @param hsdadc SDADC handle. | |
* @retval HAL status | |
*/ | |
HAL_StatusTypeDef HAL_SDADC_Start(SDADC_HandleTypeDef *hsdadc) | |
{ | |
HAL_StatusTypeDef status = HAL_OK; | |
/* Check parameters */ | |
assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance)); | |
/* Check SDADC state */ | |
if((hsdadc->State == HAL_SDADC_STATE_READY) || \ | |
(hsdadc->State == HAL_SDADC_STATE_INJ)) | |
{ | |
/* Start regular conversion */ | |
status = SDADC_RegConvStart(hsdadc); | |
} | |
else | |
{ | |
status = HAL_ERROR; | |
} | |
/* Return function status */ | |
return status; | |
} | |
/** | |
* @brief This function allows to poll for the end of regular conversion. | |
* @note This function should be called only if regular conversion is ongoing. | |
* @param hsdadc SDADC handle. | |
* @param Timeout Timeout value in milliseconds. | |
* @retval HAL status | |
*/ | |
HAL_StatusTypeDef HAL_SDADC_PollForConversion(SDADC_HandleTypeDef* hsdadc, uint32_t Timeout) | |
{ | |
uint32_t tickstart; | |
/* Check parameters */ | |
assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance)); | |
/* Check SDADC state */ | |
if((hsdadc->State != HAL_SDADC_STATE_REG) && \ | |
(hsdadc->State != HAL_SDADC_STATE_REG_INJ)) | |
{ | |
/* Return error status */ | |
return HAL_ERROR; | |
} | |
else | |
{ | |
/* Get timeout */ | |
tickstart = HAL_GetTick(); | |
/* Wait REOCF bit in SDADC_ISR register */ | |
while((hsdadc->Instance->ISR & SDADC_ISR_REOCF) != SDADC_ISR_REOCF) | |
{ | |
/* Check the Timeout */ | |
if(Timeout != HAL_MAX_DELAY) | |
{ | |
if((Timeout == 0U) || ((HAL_GetTick()-tickstart) > Timeout)) | |
{ | |
/* Return timeout status */ | |
return HAL_TIMEOUT; | |
} | |
} | |
} | |
/* Check if overrun occurs */ | |
if((hsdadc->Instance->ISR & SDADC_ISR_ROVRF) == SDADC_ISR_ROVRF) | |
{ | |
/* Update error code and call error callback */ | |
hsdadc->ErrorCode = SDADC_ERROR_REGULAR_OVERRUN; | |
HAL_SDADC_ErrorCallback(hsdadc); | |
/* Set CLRROVRF bit in SDADC_CLRISR register */ | |
hsdadc->Instance->CLRISR |= SDADC_ISR_CLRROVRF; | |
} | |
/* Update SDADC state only if not continuous conversion and SW trigger */ | |
if((hsdadc->RegularContMode == SDADC_CONTINUOUS_CONV_OFF) && \ | |
(hsdadc->RegularTrigger == SDADC_SOFTWARE_TRIGGER)) | |
{ | |
hsdadc->State = (hsdadc->State == HAL_SDADC_STATE_REG) ? \ | |
HAL_SDADC_STATE_READY : HAL_SDADC_STATE_INJ; | |
} | |
/* Return function status */ | |
return HAL_OK; | |
} | |
} | |
/** | |
* @brief This function allows to stop regular conversion in polling mode. | |
* @note This function should be called only if regular conversion is ongoing. | |
* @param hsdadc SDADC handle. | |
* @retval HAL status | |
*/ | |
HAL_StatusTypeDef HAL_SDADC_Stop(SDADC_HandleTypeDef *hsdadc) | |
{ | |
HAL_StatusTypeDef status = HAL_OK; | |
/* Check parameters */ | |
assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance)); | |
/* Check SDADC state */ | |
if((hsdadc->State != HAL_SDADC_STATE_REG) && \ | |
(hsdadc->State != HAL_SDADC_STATE_REG_INJ)) | |
{ | |
/* Return error status */ | |
status = HAL_ERROR; | |
} | |
else | |
{ | |
/* Stop regular conversion */ | |
status = SDADC_RegConvStop(hsdadc); | |
} | |
/* Return function status */ | |
return status; | |
} | |
/** | |
* @brief This function allows to start regular conversion in interrupt mode. | |
* @note This function should be called only when SDADC instance is in idle state | |
* or if injected conversion is ongoing. | |
* @param hsdadc SDADC handle. | |
* @retval HAL status | |
*/ | |
HAL_StatusTypeDef HAL_SDADC_Start_IT(SDADC_HandleTypeDef *hsdadc) | |
{ | |
HAL_StatusTypeDef status = HAL_OK; | |
/* Check parameters */ | |
assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance)); | |
/* Check SDADC state */ | |
if((hsdadc->State == HAL_SDADC_STATE_READY) || \ | |
(hsdadc->State == HAL_SDADC_STATE_INJ)) | |
{ | |
/* Set REOCIE and ROVRIE bits in SDADC_CR1 register */ | |
hsdadc->Instance->CR1 |= (uint32_t) (SDADC_CR1_REOCIE | SDADC_CR1_ROVRIE); | |
/* Start regular conversion */ | |
status = SDADC_RegConvStart(hsdadc); | |
} | |
else | |
{ | |
status = HAL_ERROR; | |
} | |
/* Return function status */ | |
return status; | |
} | |
/** | |
* @brief This function allows to stop regular conversion in interrupt mode. | |
* @note This function should be called only if regular conversion is ongoing. | |
* @param hsdadc SDADC handle. | |
* @retval HAL status | |
*/ | |
HAL_StatusTypeDef HAL_SDADC_Stop_IT(SDADC_HandleTypeDef *hsdadc) | |
{ | |
HAL_StatusTypeDef status = HAL_OK; | |
/* Check parameters */ | |
assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance)); | |
/* Check SDADC state */ | |
if((hsdadc->State != HAL_SDADC_STATE_REG) && \ | |
(hsdadc->State != HAL_SDADC_STATE_REG_INJ)) | |
{ | |
/* Return error status */ | |
status = HAL_ERROR; | |
} | |
else | |
{ | |
/* Clear REOCIE and ROVRIE bits in SDADC_CR1 register */ | |
hsdadc->Instance->CR1 &= (uint32_t) ~(SDADC_CR1_REOCIE | SDADC_CR1_ROVRIE); | |
/* Stop regular conversion */ | |
status = SDADC_RegConvStop(hsdadc); | |
} | |
/* Return function status */ | |
return status; | |
} | |
/** | |
* @brief This function allows to start regular conversion in DMA mode. | |
* @note This function should be called only when SDADC instance is in idle state | |
* or if injected conversion is ongoing. | |
* @param hsdadc SDADC handle. | |
* @param pData The destination buffer address. | |
* @param Length The length of data to be transferred from SDADC peripheral to memory. | |
* @retval HAL status | |
*/ | |
HAL_StatusTypeDef HAL_SDADC_Start_DMA(SDADC_HandleTypeDef *hsdadc, uint32_t *pData, | |
uint32_t Length) | |
{ | |
HAL_StatusTypeDef status = HAL_OK; | |
/* Check parameters */ | |
assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance)); | |
assert_param(pData != NULL); | |
assert_param(Length != 0U); | |
/* Check that DMA is not enabled for injected conversion */ | |
if((hsdadc->Instance->CR1 & SDADC_CR1_JDMAEN) == SDADC_CR1_JDMAEN) | |
{ | |
status = HAL_ERROR; | |
} | |
/* Check parameters compatibility */ | |
else if((hsdadc->RegularTrigger == SDADC_SOFTWARE_TRIGGER) && \ | |
(hsdadc->RegularContMode == SDADC_CONTINUOUS_CONV_OFF) && \ | |
(hsdadc->hdma->Init.Mode == DMA_NORMAL) && \ | |
(Length != 1U)) | |
{ | |
status = HAL_ERROR; | |
} | |
else if((hsdadc->RegularTrigger == SDADC_SOFTWARE_TRIGGER) && \ | |
(hsdadc->RegularContMode == SDADC_CONTINUOUS_CONV_OFF) && \ | |
(hsdadc->hdma->Init.Mode == DMA_CIRCULAR)) | |
{ | |
status = HAL_ERROR; | |
} | |
/* Check SDADC state */ | |
else if((hsdadc->State == HAL_SDADC_STATE_READY) || \ | |
(hsdadc->State == HAL_SDADC_STATE_INJ)) | |
{ | |
/* Set callbacks on DMA handler */ | |
hsdadc->hdma->XferCpltCallback = SDADC_DMARegularConvCplt; | |
hsdadc->hdma->XferErrorCallback = SDADC_DMAError; | |
if(hsdadc->hdma->Init.Mode == DMA_CIRCULAR) | |
{ | |
hsdadc->hdma->XferHalfCpltCallback = SDADC_DMARegularHalfConvCplt; | |
} | |
/* Set RDMAEN bit in SDADC_CR1 register */ | |
hsdadc->Instance->CR1 |= SDADC_CR1_RDMAEN; | |
/* Start DMA in interrupt mode */ | |
if(HAL_DMA_Start_IT(hsdadc->hdma, (uint32_t)&hsdadc->Instance->RDATAR, \ | |
(uint32_t) pData, Length) != HAL_OK) | |
{ | |
/* Set SDADC in error state */ | |
hsdadc->State = HAL_SDADC_STATE_ERROR; | |
status = HAL_ERROR; | |
} | |
else | |
{ | |
/* Start regular conversion */ | |
status = SDADC_RegConvStart(hsdadc); | |
} | |
} | |
else | |
{ | |
status = HAL_ERROR; | |
} | |
/* Return function status */ | |
return status; | |
} | |
/** | |
* @brief This function allows to stop regular conversion in DMA mode. | |
* @note This function should be called only if regular conversion is ongoing. | |
* @param hsdadc SDADC handle. | |
* @retval HAL status | |
*/ | |
HAL_StatusTypeDef HAL_SDADC_Stop_DMA(SDADC_HandleTypeDef *hsdadc) | |
{ | |
HAL_StatusTypeDef status = HAL_OK; | |
/* Check parameters */ | |
assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance)); | |
/* Check SDADC state */ | |
if((hsdadc->State != HAL_SDADC_STATE_REG) && \ | |
(hsdadc->State != HAL_SDADC_STATE_REG_INJ)) | |
{ | |
/* Return error status */ | |
status = HAL_ERROR; | |
} | |
else | |
{ | |
/* Clear RDMAEN bit in SDADC_CR1 register */ | |
hsdadc->Instance->CR1 &= ~(SDADC_CR1_RDMAEN); | |
/* Stop current DMA transfer */ | |
if(HAL_DMA_Abort(hsdadc->hdma) != HAL_OK) | |
{ | |
/* Set SDADC in error state */ | |
hsdadc->State = HAL_SDADC_STATE_ERROR; | |
status = HAL_ERROR; | |
} | |
else | |
{ | |
/* Stop regular conversion */ | |
status = SDADC_RegConvStop(hsdadc); | |
} | |
} | |
/* Return function status */ | |
return status; | |
} | |
/** | |
* @brief This function allows to get regular conversion value. | |
* @param hsdadc SDADC handle. | |
* @retval Regular conversion value | |
*/ | |
uint32_t HAL_SDADC_GetValue(SDADC_HandleTypeDef *hsdadc) | |
{ | |
/* Check parameters */ | |
assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance)); | |
/* Return regular conversion value */ | |
return hsdadc->Instance->RDATAR; | |
} | |
/** | |
* @brief This function allows to start injected conversion in polling mode. | |
* @note This function should be called only when SDADC instance is in idle state | |
* or if regular conversion is ongoing. | |
* @param hsdadc SDADC handle. | |
* @retval HAL status | |
*/ | |
HAL_StatusTypeDef HAL_SDADC_InjectedStart(SDADC_HandleTypeDef *hsdadc) | |
{ | |
HAL_StatusTypeDef status = HAL_OK; | |
/* Check parameters */ | |
assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance)); | |
/* Check SDADC state */ | |
if((hsdadc->State == HAL_SDADC_STATE_READY) || \ | |
(hsdadc->State == HAL_SDADC_STATE_REG)) | |
{ | |
/* Start injected conversion */ | |
status = SDADC_InjConvStart(hsdadc); | |
} | |
else | |
{ | |
status = HAL_ERROR; | |
} | |
/* Return function status */ | |
return status; | |
} | |
/** | |
* @brief This function allows to poll for the end of injected conversion. | |
* @note This function should be called only if injected conversion is ongoing. | |
* @param hsdadc SDADC handle. | |
* @param Timeout Timeout value in milliseconds. | |
* @retval HAL status | |
*/ | |
HAL_StatusTypeDef HAL_SDADC_PollForInjectedConversion(SDADC_HandleTypeDef* hsdadc, | |
uint32_t Timeout) | |
{ | |
uint32_t tickstart; | |
/* Check parameters */ | |
assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance)); | |
/* Check SDADC state */ | |
if((hsdadc->State != HAL_SDADC_STATE_INJ) && \ | |
(hsdadc->State != HAL_SDADC_STATE_REG_INJ)) | |
{ | |
/* Return error status */ | |
return HAL_ERROR; | |
} | |
else | |
{ | |
/* Get timeout */ | |
tickstart = HAL_GetTick(); | |
/* Wait JEOCF bit in SDADC_ISR register */ | |
while((hsdadc->Instance->ISR & SDADC_ISR_JEOCF) != SDADC_ISR_JEOCF) | |
{ | |
/* Check the Timeout */ | |
if(Timeout != HAL_MAX_DELAY) | |
{ | |
if((Timeout == 0U) || ((HAL_GetTick()-tickstart) > Timeout)) | |
{ | |
/* Return timeout status */ | |
return HAL_TIMEOUT; | |
} | |
} | |
} | |
/* Check if overrun occurs */ | |
if((hsdadc->Instance->ISR & SDADC_ISR_JOVRF) == SDADC_ISR_JOVRF) | |
{ | |
/* Update error code and call error callback */ | |
hsdadc->ErrorCode = SDADC_ERROR_INJECTED_OVERRUN; | |
HAL_SDADC_ErrorCallback(hsdadc); | |
/* Set CLRJOVRF bit in SDADC_CLRISR register */ | |
hsdadc->Instance->CLRISR |= SDADC_ISR_CLRJOVRF; | |
} | |
/* Update remaining injected conversions */ | |
hsdadc->InjConvRemaining--; | |
if(hsdadc->InjConvRemaining == 0U) | |
{ | |
/* end of injected sequence, reset the value */ | |
hsdadc->InjConvRemaining = hsdadc->InjectedChannelsNbr; | |
} | |
/* Update SDADC state only if not continuous conversion, SW trigger */ | |
/* and end of injected sequence */ | |
if((hsdadc->InjectedContMode == SDADC_CONTINUOUS_CONV_OFF) && \ | |
(hsdadc->InjectedTrigger == SDADC_SOFTWARE_TRIGGER) && \ | |
(hsdadc->InjConvRemaining == hsdadc->InjectedChannelsNbr)) | |
{ | |
hsdadc->State = (hsdadc->State == HAL_SDADC_STATE_INJ) ? \ | |
HAL_SDADC_STATE_READY : HAL_SDADC_STATE_REG; | |
} | |
/* Return function status */ | |
return HAL_OK; | |
} | |
} | |
/** | |
* @brief This function allows to stop injected conversion in polling mode. | |
* @note This function should be called only if injected conversion is ongoing. | |
* @param hsdadc SDADC handle. | |
* @retval HAL status | |
*/ | |
HAL_StatusTypeDef HAL_SDADC_InjectedStop(SDADC_HandleTypeDef *hsdadc) | |
{ | |
HAL_StatusTypeDef status = HAL_OK; | |
/* Check parameters */ | |
assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance)); | |
/* Check SDADC state */ | |
if((hsdadc->State != HAL_SDADC_STATE_INJ) && \ | |
(hsdadc->State != HAL_SDADC_STATE_REG_INJ)) | |
{ | |
/* Return error status */ | |
status = HAL_ERROR; | |
} | |
else | |
{ | |
/* Stop injected conversion */ | |
status = SDADC_InjConvStop(hsdadc); | |
} | |
/* Return function status */ | |
return status; | |
} | |
/** | |
* @brief This function allows to start injected conversion in interrupt mode. | |
* @note This function should be called only when SDADC instance is in idle state | |
* or if regular conversion is ongoing. | |
* @param hsdadc SDADC handle. | |
* @retval HAL status | |
*/ | |
HAL_StatusTypeDef HAL_SDADC_InjectedStart_IT(SDADC_HandleTypeDef *hsdadc) | |
{ | |
HAL_StatusTypeDef status = HAL_OK; | |
/* Check parameters */ | |
assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance)); | |
/* Check SDADC state */ | |
if((hsdadc->State == HAL_SDADC_STATE_READY) || \ | |
(hsdadc->State == HAL_SDADC_STATE_REG)) | |
{ | |
/* Set JEOCIE and JOVRIE bits in SDADC_CR1 register */ | |
hsdadc->Instance->CR1 |= (uint32_t) (SDADC_CR1_JEOCIE | SDADC_CR1_JOVRIE); | |
/* Start injected conversion */ | |
status = SDADC_InjConvStart(hsdadc); | |
} | |
else | |
{ | |
status = HAL_ERROR; | |
} | |
/* Return function status */ | |
return status; | |
} | |
/** | |
* @brief This function allows to stop injected conversion in interrupt mode. | |
* @note This function should be called only if injected conversion is ongoing. | |
* @param hsdadc SDADC handle. | |
* @retval HAL status | |
*/ | |
HAL_StatusTypeDef HAL_SDADC_InjectedStop_IT(SDADC_HandleTypeDef *hsdadc) | |
{ | |
HAL_StatusTypeDef status = HAL_OK; | |
/* Check parameters */ | |
assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance)); | |
/* Check SDADC state */ | |
if((hsdadc->State != HAL_SDADC_STATE_INJ) && \ | |
(hsdadc->State != HAL_SDADC_STATE_REG_INJ)) | |
{ | |
/* Return error status */ | |
status = HAL_ERROR; | |
} | |
else | |
{ | |
/* Clear JEOCIE and JOVRIE bits in SDADC_CR1 register */ | |
hsdadc->Instance->CR1 &= (uint32_t) ~(SDADC_CR1_JEOCIE | SDADC_CR1_JOVRIE); | |
/* Stop injected conversion */ | |
status = SDADC_InjConvStop(hsdadc); | |
} | |
/* Return function status */ | |
return status; | |
} | |
/** | |
* @brief This function allows to start injected conversion in DMA mode. | |
* @note This function should be called only when SDADC instance is in idle state | |
* or if regular conversion is ongoing. | |
* @param hsdadc SDADC handle. | |
* @param pData The destination buffer address. | |
* @param Length The length of data to be transferred from SDADC peripheral to memory. | |
* @retval HAL status | |
*/ | |
HAL_StatusTypeDef HAL_SDADC_InjectedStart_DMA(SDADC_HandleTypeDef *hsdadc, uint32_t *pData, | |
uint32_t Length) | |
{ | |
HAL_StatusTypeDef status = HAL_OK; | |
/* Check parameters */ | |
assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance)); | |
assert_param(pData != NULL); | |
assert_param(Length != 0U); | |
/* Check that DMA is not enabled for regular conversion */ | |
if((hsdadc->Instance->CR1 & SDADC_CR1_RDMAEN) == SDADC_CR1_RDMAEN) | |
{ | |
status = HAL_ERROR; | |
} | |
/* Check parameters compatibility */ | |
else if((hsdadc->InjectedTrigger == SDADC_SOFTWARE_TRIGGER) && \ | |
(hsdadc->InjectedContMode == SDADC_CONTINUOUS_CONV_OFF) && \ | |
(hsdadc->hdma->Init.Mode == DMA_NORMAL) && \ | |
(Length > hsdadc->InjectedChannelsNbr)) | |
{ | |
status = HAL_ERROR; | |
} | |
else if((hsdadc->InjectedTrigger == SDADC_SOFTWARE_TRIGGER) && \ | |
(hsdadc->InjectedContMode == SDADC_CONTINUOUS_CONV_OFF) && \ | |
(hsdadc->hdma->Init.Mode == DMA_CIRCULAR)) | |
{ | |
status = HAL_ERROR; | |
} | |
/* Check SDADC state */ | |
else if((hsdadc->State == HAL_SDADC_STATE_READY) || \ | |
(hsdadc->State == HAL_SDADC_STATE_REG)) | |
{ | |
/* Set callbacks on DMA handler */ | |
hsdadc->hdma->XferCpltCallback = SDADC_DMAInjectedConvCplt; | |
hsdadc->hdma->XferErrorCallback = SDADC_DMAError; | |
if(hsdadc->hdma->Init.Mode == DMA_CIRCULAR) | |
{ | |
hsdadc->hdma->XferHalfCpltCallback = SDADC_DMAInjectedHalfConvCplt; | |
} | |
/* Set JDMAEN bit in SDADC_CR1 register */ | |
hsdadc->Instance->CR1 |= SDADC_CR1_JDMAEN; | |
/* Start DMA in interrupt mode */ | |
if(HAL_DMA_Start_IT(hsdadc->hdma, (uint32_t)&hsdadc->Instance->JDATAR, \ | |
(uint32_t) pData, Length) != HAL_OK) | |
{ | |
/* Set SDADC in error state */ | |
hsdadc->State = HAL_SDADC_STATE_ERROR; | |
status = HAL_ERROR; | |
} | |
else | |
{ | |
/* Start injected conversion */ | |
status = SDADC_InjConvStart(hsdadc); | |
} | |
} | |
else | |
{ | |
status = HAL_ERROR; | |
} | |
/* Return function status */ | |
return status; | |
} | |
/** | |
* @brief This function allows to stop injected conversion in DMA mode. | |
* @note This function should be called only if injected conversion is ongoing. | |
* @param hsdadc SDADC handle. | |
* @retval HAL status | |
*/ | |
HAL_StatusTypeDef HAL_SDADC_InjectedStop_DMA(SDADC_HandleTypeDef *hsdadc) | |
{ | |
HAL_StatusTypeDef status = HAL_OK; | |
/* Check parameters */ | |
assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance)); | |
/* Check SDADC state */ | |
if((hsdadc->State != HAL_SDADC_STATE_INJ) && \ | |
(hsdadc->State != HAL_SDADC_STATE_REG_INJ)) | |
{ | |
/* Return error status */ | |
status = HAL_ERROR; | |
} | |
else | |
{ | |
/* Clear JDMAEN bit in SDADC_CR1 register */ | |
hsdadc->Instance->CR1 &= ~(SDADC_CR1_JDMAEN); | |
/* Stop current DMA transfer */ | |
if(HAL_DMA_Abort(hsdadc->hdma) != HAL_OK) | |
{ | |
/* Set SDADC in error state */ | |
hsdadc->State = HAL_SDADC_STATE_ERROR; | |
status = HAL_ERROR; | |
} | |
else | |
{ | |
/* Stop injected conversion */ | |
status = SDADC_InjConvStop(hsdadc); | |
} | |
} | |
/* Return function status */ | |
return status; | |
} | |
/** | |
* @brief This function allows to get injected conversion value. | |
* @param hsdadc SDADC handle. | |
* @param Channel Corresponding channel of injected conversion. | |
* @retval Injected conversion value | |
*/ | |
uint32_t HAL_SDADC_InjectedGetValue(SDADC_HandleTypeDef *hsdadc, uint32_t* Channel) | |
{ | |
uint32_t value = 0U; | |
/* Check parameters */ | |
assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance)); | |
assert_param(Channel != NULL); | |
/* Read SDADC_JDATAR register and extract channel and conversion value */ | |
value = hsdadc->Instance->JDATAR; | |
*Channel = ((value & SDADC_JDATAR_JDATACH) >> SDADC_JDATAR_CH_OFFSET); | |
value &= SDADC_JDATAR_JDATA; | |
/* Return injected conversion value */ | |
return value; | |
} | |
/** | |
* @brief This function allows to start multimode regular conversions in DMA mode. | |
* @note This function should be called only when SDADC instance is in idle state | |
* or if injected conversion is ongoing. | |
* @param hsdadc SDADC handle. | |
* @param pData The destination buffer address. | |
* @param Length The length of data to be transferred from SDADC peripheral to memory. | |
* @retval HAL status | |
*/ | |
HAL_StatusTypeDef HAL_SDADC_MultiModeStart_DMA(SDADC_HandleTypeDef* hsdadc, uint32_t* pData, | |
uint32_t Length) | |
{ | |
HAL_StatusTypeDef status = HAL_OK; | |
/* Check parameters */ | |
assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance)); | |
assert_param(pData != NULL); | |
assert_param(Length != 0U); | |
/* Check instance is SDADC1 */ | |
if(hsdadc->Instance != SDADC1) | |
{ | |
status = HAL_ERROR; | |
} | |
/* Check that DMA is not enabled for injected conversion */ | |
else if((hsdadc->Instance->CR1 & SDADC_CR1_JDMAEN) == SDADC_CR1_JDMAEN) | |
{ | |
status = HAL_ERROR; | |
} | |
/* Check parameters compatibility */ | |
else if((hsdadc->RegularTrigger == SDADC_SOFTWARE_TRIGGER) && \ | |
(hsdadc->RegularContMode == SDADC_CONTINUOUS_CONV_OFF) && \ | |
(hsdadc->hdma->Init.Mode == DMA_NORMAL) && \ | |
(Length != 1U)) | |
{ | |
status = HAL_ERROR; | |
} | |
else if((hsdadc->RegularTrigger == SDADC_SOFTWARE_TRIGGER) && \ | |
(hsdadc->RegularContMode == SDADC_CONTINUOUS_CONV_OFF) && \ | |
(hsdadc->hdma->Init.Mode == DMA_CIRCULAR)) | |
{ | |
status = HAL_ERROR; | |
} | |
/* Check SDADC state */ | |
else if((hsdadc->State == HAL_SDADC_STATE_READY) || \ | |
(hsdadc->State == HAL_SDADC_STATE_INJ)) | |
{ | |
/* Set callbacks on DMA handler */ | |
hsdadc->hdma->XferCpltCallback = SDADC_DMARegularConvCplt; | |
hsdadc->hdma->XferErrorCallback = SDADC_DMAError; | |
if(hsdadc->hdma->Init.Mode == DMA_CIRCULAR) | |
{ | |
hsdadc->hdma->XferHalfCpltCallback = SDADC_DMARegularHalfConvCplt; | |
} | |
/* Set RDMAEN bit in SDADC_CR1 register */ | |
hsdadc->Instance->CR1 |= SDADC_CR1_RDMAEN; | |
/* Start DMA in interrupt mode */ | |
if(hsdadc->RegularMultimode == SDADC_MULTIMODE_SDADC1_SDADC2) | |
{ | |
status = HAL_DMA_Start_IT(hsdadc->hdma, (uint32_t)&hsdadc->Instance->RDATA12R, \ | |
(uint32_t) pData, Length); | |
} | |
else | |
{ | |
status = HAL_DMA_Start_IT(hsdadc->hdma, (uint32_t)&hsdadc->Instance->RDATA13R, \ | |
(uint32_t) pData, Length); | |
} | |
if(status != HAL_OK) | |
{ | |
/* Set SDADC in error state */ | |
hsdadc->State = HAL_SDADC_STATE_ERROR; | |
status = HAL_ERROR; | |
} | |
else | |
{ | |
/* Start regular conversion */ | |
status = SDADC_RegConvStart(hsdadc); | |
} | |
} | |
else | |
{ | |
status = HAL_ERROR; | |
} | |
/* Return function status */ | |
return status; | |
} | |
/** | |
* @brief This function allows to stop multimode regular conversions in DMA mode. | |
* @note This function should be called only if regular conversion is ongoing. | |
* @param hsdadc SDADC handle. | |
* @retval HAL status | |
*/ | |
HAL_StatusTypeDef HAL_SDADC_MultiModeStop_DMA(SDADC_HandleTypeDef* hsdadc) | |
{ | |
HAL_StatusTypeDef status = HAL_OK; | |
/* Check parameters */ | |
assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance)); | |
/* Check instance is SDADC1 */ | |
if(hsdadc->Instance != SDADC1) | |
{ | |
status = HAL_ERROR; | |
} | |
/* Check SDADC state */ | |
else if((hsdadc->State != HAL_SDADC_STATE_REG) && \ | |
(hsdadc->State != HAL_SDADC_STATE_REG_INJ)) | |
{ | |
/* Return error status */ | |
status = HAL_ERROR; | |
} | |
else | |
{ | |
/* Clear RDMAEN bit in SDADC_CR1 register */ | |
hsdadc->Instance->CR1 &= ~(SDADC_CR1_RDMAEN); | |
/* Stop current DMA transfer */ | |
if(HAL_DMA_Abort(hsdadc->hdma) != HAL_OK) | |
{ | |
/* Set SDADC in error state */ | |
hsdadc->State = HAL_SDADC_STATE_ERROR; | |
status = HAL_ERROR; | |
} | |
else | |
{ | |
/* Stop regular conversion */ | |
status = SDADC_RegConvStop(hsdadc); | |
} | |
} | |
/* Return function status */ | |
return status; | |
} | |
/** | |
* @brief This function allows to get multimode regular conversion value. | |
* @param hsdadc SDADC handle. | |
* @retval Multimode regular conversion value | |
*/ | |
uint32_t HAL_SDADC_MultiModeGetValue(SDADC_HandleTypeDef* hsdadc) | |
{ | |
uint32_t value = 0U; | |
/* Check parameters and check instance is SDADC1 */ | |
assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance)); | |
assert_param(hsdadc->Instance == SDADC1); | |
/* read multimode regular value */ | |
value = (hsdadc->RegularMultimode == SDADC_MULTIMODE_SDADC1_SDADC2) ? \ | |
hsdadc->Instance->RDATA12R : hsdadc->Instance->RDATA13R; | |
/* Return multimode regular conversions value */ | |
return value; | |
} | |
/** | |
* @brief This function allows to start multimode injected conversions in DMA mode. | |
* @note This function should be called only when SDADC instance is in idle state | |
* or if regular conversion is ongoing. | |
* @param hsdadc SDADC handle. | |
* @param pData The destination buffer address. | |
* @param Length The length of data to be transferred from SDADC peripheral to memory. | |
* @retval HAL status | |
*/ | |
HAL_StatusTypeDef HAL_SDADC_InjectedMultiModeStart_DMA(SDADC_HandleTypeDef* hsdadc, | |
uint32_t* pData, uint32_t Length) | |
{ | |
HAL_StatusTypeDef status = HAL_OK; | |
/* Check parameters */ | |
assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance)); | |
assert_param(pData != NULL); | |
assert_param(Length != 0U); | |
/* Check instance is SDADC1 */ | |
if(hsdadc->Instance != SDADC1) | |
{ | |
status = HAL_ERROR; | |
} | |
/* Check that DMA is not enabled for regular conversion */ | |
else if((hsdadc->Instance->CR1 & SDADC_CR1_RDMAEN) == SDADC_CR1_RDMAEN) | |
{ | |
status = HAL_ERROR; | |
} | |
/* Check parameters compatibility */ | |
else if((hsdadc->InjectedTrigger == SDADC_SOFTWARE_TRIGGER) && \ | |
(hsdadc->InjectedContMode == SDADC_CONTINUOUS_CONV_OFF) && \ | |
(hsdadc->hdma->Init.Mode == DMA_NORMAL) && \ | |
(Length > (hsdadc->InjectedChannelsNbr << 1U))) | |
{ | |
status = HAL_ERROR; | |
} | |
else if((hsdadc->InjectedTrigger == SDADC_SOFTWARE_TRIGGER) && \ | |
(hsdadc->InjectedContMode == SDADC_CONTINUOUS_CONV_OFF) && \ | |
(hsdadc->hdma->Init.Mode == DMA_CIRCULAR)) | |
{ | |
status = HAL_ERROR; | |
} | |
/* Check SDADC state */ | |
else if((hsdadc->State == HAL_SDADC_STATE_READY) || \ | |
(hsdadc->State == HAL_SDADC_STATE_REG)) | |
{ | |
/* Set callbacks on DMA handler */ | |
hsdadc->hdma->XferCpltCallback = SDADC_DMAInjectedConvCplt; | |
hsdadc->hdma->XferErrorCallback = SDADC_DMAError; | |
if(hsdadc->hdma->Init.Mode == DMA_CIRCULAR) | |
{ | |
hsdadc->hdma->XferHalfCpltCallback = SDADC_DMAInjectedHalfConvCplt; | |
} | |
/* Set JDMAEN bit in SDADC_CR1 register */ | |
hsdadc->Instance->CR1 |= SDADC_CR1_JDMAEN; | |
/* Start DMA in interrupt mode */ | |
if(hsdadc->InjectedMultimode == SDADC_MULTIMODE_SDADC1_SDADC2) | |
{ | |
status = HAL_DMA_Start_IT(hsdadc->hdma, (uint32_t)&hsdadc->Instance->JDATA12R, \ | |
(uint32_t) pData, Length); | |
} | |
else | |
{ | |
status = HAL_DMA_Start_IT(hsdadc->hdma, (uint32_t)&hsdadc->Instance->JDATA13R, \ | |
(uint32_t) pData, Length); | |
} | |
if(status != HAL_OK) | |
{ | |
/* Set SDADC in error state */ | |
hsdadc->State = HAL_SDADC_STATE_ERROR; | |
status = HAL_ERROR; | |
} | |
else | |
{ | |
/* Start injected conversion */ | |
status = SDADC_InjConvStart(hsdadc); | |
} | |
} | |
else | |
{ | |
status = HAL_ERROR; | |
} | |
/* Return function status */ | |
return status; | |
} | |
/** | |
* @brief This function allows to stop multimode injected conversions in DMA mode. | |
* @note This function should be called only if injected conversion is ongoing. | |
* @param hsdadc SDADC handle. | |
* @retval HAL status | |
*/ | |
HAL_StatusTypeDef HAL_SDADC_InjectedMultiModeStop_DMA(SDADC_HandleTypeDef* hsdadc) | |
{ | |
HAL_StatusTypeDef status = HAL_OK; | |
/* Check parameters */ | |
assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance)); | |
/* Check instance is SDADC1 */ | |
if(hsdadc->Instance != SDADC1) | |
{ | |
status = HAL_ERROR; | |
} | |
/* Check SDADC state */ | |
else if((hsdadc->State != HAL_SDADC_STATE_INJ) && \ | |
(hsdadc->State != HAL_SDADC_STATE_REG_INJ)) | |
{ | |
/* Return error status */ | |
status = HAL_ERROR; | |
} | |
else | |
{ | |
/* Clear JDMAEN bit in SDADC_CR1 register */ | |
hsdadc->Instance->CR1 &= ~(SDADC_CR1_JDMAEN); | |
/* Stop current DMA transfer */ | |
if(HAL_DMA_Abort(hsdadc->hdma) != HAL_OK) | |
{ | |
/* Set SDADC in error state */ | |
hsdadc->State = HAL_SDADC_STATE_ERROR; | |
status = HAL_ERROR; | |
} | |
else | |
{ | |
/* Stop injected conversion */ | |
status = SDADC_InjConvStop(hsdadc); | |
} | |
} | |
/* Return function status */ | |
return status; | |
} | |
/** | |
* @brief This function allows to get multimode injected conversion value. | |
* @param hsdadc SDADC handle. | |
* @retval Multimode injected conversion value | |
*/ | |
uint32_t HAL_SDADC_InjectedMultiModeGetValue(SDADC_HandleTypeDef* hsdadc) | |
{ | |
uint32_t value = 0U; | |
/* Check parameters and check instance is SDADC1 */ | |
assert_param(IS_SDADC_ALL_INSTANCE(hsdadc->Instance)); | |
assert_param(hsdadc->Instance == SDADC1); | |
/* read multimode injected value */ | |
value = (hsdadc->InjectedMultimode == SDADC_MULTIMODE_SDADC1_SDADC2) ? \ | |
hsdadc->Instance->JDATA12R : hsdadc->Instance->JDATA13R; | |
/* Return multimode injected conversions value */ | |
return value; | |
} | |
/** | |
* @brief This function handles the SDADC interrupts. | |
* @param hsdadc SDADC handle. | |
* @retval None | |
*/ | |
void HAL_SDADC_IRQHandler(SDADC_HandleTypeDef* hsdadc) | |
{ | |
/* Check if end of regular conversion */ | |
if(((hsdadc->Instance->ISR & SDADC_ISR_REOCF) == SDADC_ISR_REOCF) && \ | |
((hsdadc->Instance->CR1 & SDADC_CR1_REOCIE) == SDADC_CR1_REOCIE)) | |
{ | |
/* Call regular conversion complete callback */ | |
HAL_SDADC_ConvCpltCallback(hsdadc); | |
/* End of conversion if mode is not continuous and software trigger */ | |
if((hsdadc->RegularContMode == SDADC_CONTINUOUS_CONV_OFF) && \ | |
(hsdadc->RegularTrigger == SDADC_SOFTWARE_TRIGGER)) | |
{ | |
/* Clear REOCIE and ROVRIE bits in SDADC_CR1 register */ | |
hsdadc->Instance->CR1 &= ~(SDADC_CR1_REOCIE | SDADC_CR1_ROVRIE); | |
/* Update SDADC state */ | |
hsdadc->State = (hsdadc->State == HAL_SDADC_STATE_REG) ? \ | |
HAL_SDADC_STATE_READY : HAL_SDADC_STATE_INJ; | |
} | |
} | |
/* Check if end of injected conversion */ | |
else if(((hsdadc->Instance->ISR & SDADC_ISR_JEOCF) == SDADC_ISR_JEOCF) && \ | |
((hsdadc->Instance->CR1 & SDADC_CR1_JEOCIE) == SDADC_CR1_JEOCIE)) | |
{ | |
/* Call injected conversion complete callback */ | |
HAL_SDADC_InjectedConvCpltCallback(hsdadc); | |
/* Update remaining injected conversions */ | |
hsdadc->InjConvRemaining--; | |
if(hsdadc->InjConvRemaining ==0U) | |
{ | |
/* end of injected sequence, reset the value */ | |
hsdadc->InjConvRemaining = hsdadc->InjectedChannelsNbr; | |
} | |
/* End of conversion if mode is not continuous, software trigger */ | |
/* and end of injected sequence */ | |
if((hsdadc->InjectedContMode == SDADC_CONTINUOUS_CONV_OFF) && \ | |
(hsdadc->InjectedTrigger == SDADC_SOFTWARE_TRIGGER) && \ | |
(hsdadc->InjConvRemaining == hsdadc->InjectedChannelsNbr)) | |
{ | |
/* Clear JEOCIE and JOVRIE bits in SDADC_CR1 register */ | |
hsdadc->Instance->CR1 &= ~(SDADC_CR1_JEOCIE | SDADC_CR1_JOVRIE); | |
/* Update SDADC state */ | |
hsdadc->State = (hsdadc->State == HAL_SDADC_STATE_INJ) ? \ | |
HAL_SDADC_STATE_READY : HAL_SDADC_STATE_REG; | |
} | |
} | |
/* Check if end of calibration */ | |
else if(((hsdadc->Instance->ISR & SDADC_ISR_EOCALF) == SDADC_ISR_EOCALF) && \ | |
((hsdadc->Instance->CR1 & SDADC_CR1_EOCALIE) == SDADC_CR1_EOCALIE)) | |
{ | |
/* Clear EOCALIE bit in SDADC_CR1 register */ | |
hsdadc->Instance->CR1 &= ~(SDADC_CR1_EOCALIE); | |
/* Set CLREOCALF bit in SDADC_CLRISR register */ | |
hsdadc->Instance->CLRISR |= SDADC_ISR_CLREOCALF; | |
/* Call calibration callback */ | |
HAL_SDADC_CalibrationCpltCallback(hsdadc); | |
/* Update SDADC state */ | |
hsdadc->State = HAL_SDADC_STATE_READY; | |
} | |
/* Check if overrun occurs during regular conversion */ | |
else if(((hsdadc->Instance->ISR & SDADC_ISR_ROVRF) == SDADC_ISR_ROVRF) && \ | |
((hsdadc->Instance->CR1 & SDADC_CR1_ROVRIE) == SDADC_CR1_ROVRIE)) | |
{ | |
/* Set CLRROVRF bit in SDADC_CLRISR register */ | |
hsdadc->Instance->CLRISR |= SDADC_ISR_CLRROVRF; | |
/* Update error code */ | |
hsdadc->ErrorCode = SDADC_ERROR_REGULAR_OVERRUN; | |
/* Call error callback */ | |
HAL_SDADC_ErrorCallback(hsdadc); | |
} | |
/* Check if overrun occurs during injected conversion */ | |
else if(((hsdadc->Instance->ISR & SDADC_ISR_JOVRF) == SDADC_ISR_JOVRF) && \ | |
((hsdadc->Instance->CR1 & SDADC_CR1_JOVRIE) == SDADC_CR1_JOVRIE)) | |
{ | |
/* Set CLRJOVRF bit in SDADC_CLRISR register */ | |
hsdadc->Instance->CLRISR |= SDADC_ISR_CLRJOVRF; | |
/* Update error code */ | |
hsdadc->ErrorCode = SDADC_ERROR_INJECTED_OVERRUN; | |
/* Call error callback */ | |
HAL_SDADC_ErrorCallback(hsdadc); | |
} | |
else | |
{ | |
/* No additional IRQ source */ | |
} | |
return; | |
} | |
/** | |
* @brief Calibration complete callback. | |
* @param hsdadc SDADC handle. | |
* @retval None | |
*/ | |
__weak void HAL_SDADC_CalibrationCpltCallback(SDADC_HandleTypeDef* hsdadc) | |
{ | |
/* Prevent unused argument(s) compilation warning */ | |
UNUSED(hsdadc); | |
/* NOTE : This function should not be modified, when the callback is needed, | |
the HAL_SDADC_CalibrationCpltCallback could be implemented in the user file | |
*/ | |
} | |
/** | |
* @brief Half regular conversion complete callback. | |
* @param hsdadc SDADC handle. | |
* @retval None | |
*/ | |
__weak void HAL_SDADC_ConvHalfCpltCallback(SDADC_HandleTypeDef* hsdadc) | |
{ | |
/* Prevent unused argument(s) compilation warning */ | |
UNUSED(hsdadc); | |
/* NOTE : This function should not be modified, when the callback is needed, | |
the HAL_SDADC_ConvHalfCpltCallback could be implemented in the user file | |
*/ | |
} | |
/** | |
* @brief Regular conversion complete callback. | |
* @note In interrupt mode, user has to read conversion value in this function | |
using HAL_SDADC_GetValue or HAL_SDADC_MultiModeGetValue. | |
* @param hsdadc SDADC handle. | |
* @retval None | |
*/ | |
__weak void HAL_SDADC_ConvCpltCallback(SDADC_HandleTypeDef* hsdadc) | |
{ | |
/* Prevent unused argument(s) compilation warning */ | |
UNUSED(hsdadc); | |
/* NOTE : This function should not be modified, when the callback is needed, | |
the HAL_SDADC_ConvCpltCallback could be implemented in the user file. | |
*/ | |
} | |
/** | |
* @brief Half injected conversion complete callback. | |
* @param hsdadc SDADC handle. | |
* @retval None | |
*/ | |
__weak void HAL_SDADC_InjectedConvHalfCpltCallback(SDADC_HandleTypeDef* hsdadc) | |
{ | |
/* Prevent unused argument(s) compilation warning */ | |
UNUSED(hsdadc); | |
/* NOTE : This function should not be modified, when the callback is needed, | |
the HAL_SDADC_InjectedConvHalfCpltCallback could be implemented in the user file. | |
*/ | |
} | |
/** | |
* @brief Injected conversion complete callback. | |
* @note In interrupt mode, user has to read conversion value in this function | |
using HAL_SDADC_InjectedGetValue or HAL_SDADC_InjectedMultiModeGetValue. | |
* @param hsdadc SDADC handle. | |
* @retval None | |
*/ | |
__weak void HAL_SDADC_InjectedConvCpltCallback(SDADC_HandleTypeDef* hsdadc) | |
{ | |
/* Prevent unused argument(s) compilation warning */ | |
UNUSED(hsdadc); | |
/* NOTE : This function should not be modified, when the callback is needed, | |
the HAL_SDADC_InjectedConvCpltCallback could be implemented in the user file. | |
*/ | |
} | |
/** | |
* @brief Error callback. | |
* @param hsdadc SDADC handle. | |
* @retval None | |
*/ | |
__weak void HAL_SDADC_ErrorCallback(SDADC_HandleTypeDef* hsdadc) | |
{ | |
/* Prevent unused argument(s) compilation warning */ | |
UNUSED(hsdadc); | |
/* NOTE : This function should not be modified, when the callback is needed, | |
the HAL_SDADC_ErrorCallback could be implemented in the user file. | |
*/ | |
} | |
/** | |
* @brief DMA half transfer complete callback for regular conversion. | |
* @param hdma DMA handle. | |
* @retval None | |
*/ | |
static void SDADC_DMARegularHalfConvCplt(DMA_HandleTypeDef *hdma) | |
{ | |
/* Get SDADC handle */ | |
SDADC_HandleTypeDef* hsdadc = (SDADC_HandleTypeDef*) ((DMA_HandleTypeDef*)hdma)->Parent; | |
/* Call regular half conversion complete callback */ | |
HAL_SDADC_ConvHalfCpltCallback(hsdadc); | |
} | |
/** | |
* @brief DMA transfer complete callback for regular conversion. | |
* @param hdma DMA handle. | |
* @retval None | |
*/ | |
static void SDADC_DMARegularConvCplt(DMA_HandleTypeDef *hdma) | |
{ | |
/* Get SDADC handle */ | |
SDADC_HandleTypeDef* hsdadc = (SDADC_HandleTypeDef*) ((DMA_HandleTypeDef*)hdma)->Parent; | |
/* Call regular conversion complete callback */ | |
HAL_SDADC_ConvCpltCallback(hsdadc); | |
} | |
/** | |
* @brief DMA half transfer complete callback for injected conversion. | |
* @param hdma DMA handle. | |
* @retval None | |
*/ | |
static void SDADC_DMAInjectedHalfConvCplt(DMA_HandleTypeDef *hdma) | |
{ | |
/* Get SDADC handle */ | |
SDADC_HandleTypeDef* hsdadc = (SDADC_HandleTypeDef*) ((DMA_HandleTypeDef*)hdma)->Parent; | |
/* Call injected half conversion complete callback */ | |
HAL_SDADC_InjectedConvHalfCpltCallback(hsdadc); | |
} | |
/** | |
* @brief DMA transfer complete callback for injected conversion. | |
* @param hdma DMA handle. | |
* @retval None | |
*/ | |
static void SDADC_DMAInjectedConvCplt(DMA_HandleTypeDef *hdma) | |
{ | |
/* Get SDADC handle */ | |
SDADC_HandleTypeDef* hsdadc = (SDADC_HandleTypeDef*) ((DMA_HandleTypeDef*)hdma)->Parent; | |
/* Call injected conversion complete callback */ | |
HAL_SDADC_InjectedConvCpltCallback(hsdadc); | |
} | |
/** | |
* @brief DMA error callback. | |
* @param hdma DMA handle. | |
* @retval None | |
*/ | |
static void SDADC_DMAError(DMA_HandleTypeDef *hdma) | |
{ | |
/* Get SDADC handle */ | |
SDADC_HandleTypeDef* hsdadc = (SDADC_HandleTypeDef*) ((DMA_HandleTypeDef*)hdma)->Parent; | |
/* Update error code */ | |
hsdadc->ErrorCode = SDADC_ERROR_DMA; | |
/* Call error callback */ | |
HAL_SDADC_ErrorCallback(hsdadc); | |
} | |
/** | |
* @} | |
*/ | |
/** @defgroup SDADC_Exported_Functions_Group4 Peripheral State functions | |
* @brief SDADC Peripheral State functions | |
* | |
@verbatim | |
=============================================================================== | |
##### ADC Peripheral State functions ##### | |
=============================================================================== | |
[..] This subsection provides functions allowing to | |
(+) Get the SDADC state | |
(+) Get the SDADC Error | |
@endverbatim | |
* @{ | |
*/ | |
/** | |
* @brief This function allows to get the current SDADC state. | |
* @param hsdadc SDADC handle. | |
* @retval SDADC state. | |
*/ | |
HAL_SDADC_StateTypeDef HAL_SDADC_GetState(SDADC_HandleTypeDef* hsdadc) | |
{ | |
return hsdadc->State; | |
} | |
/** | |
* @brief This function allows to get the current SDADC error code. | |
* @param hsdadc SDADC handle. | |
* @retval SDADC error code. | |
*/ | |
uint32_t HAL_SDADC_GetError(SDADC_HandleTypeDef* hsdadc) | |
{ | |
return hsdadc->ErrorCode; | |
} | |
/** | |
* @} | |
*/ | |
/** @addtogroup SDADC_Private_Functions SDADC Private Functions | |
* @{ | |
*/ | |
/** | |
* @brief This function allows to enter in init mode for SDADC instance. | |
* @param hsdadc SDADC handle. | |
* @retval HAL status. | |
*/ | |
static HAL_StatusTypeDef SDADC_EnterInitMode(SDADC_HandleTypeDef* hsdadc) | |
{ | |
uint32_t tickstart = 0U; | |
/* Set INIT bit on SDADC_CR1 register */ | |
hsdadc->Instance->CR1 |= SDADC_CR1_INIT; | |
/* Wait INITRDY bit on SDADC_ISR */ | |
tickstart = HAL_GetTick(); | |
while((hsdadc->Instance->ISR & SDADC_ISR_INITRDY) == (uint32_t)RESET) | |
{ | |
if((HAL_GetTick()-tickstart) > SDADC_TIMEOUT) | |
{ | |
return HAL_TIMEOUT; | |
} | |
} | |
/* Return HAL status */ | |
return HAL_OK; | |
} | |
/** | |
* @brief This function allows to exit from init mode for SDADC instance. | |
* @param hsdadc SDADC handle. | |
* @retval None. | |
*/ | |
static void SDADC_ExitInitMode(SDADC_HandleTypeDef* hsdadc) | |
{ | |
/* Reset INIT bit in SDADC_CR1 register */ | |
hsdadc->Instance->CR1 &= ~(SDADC_CR1_INIT); | |
} | |
/** | |
* @brief This function allows to get the number of injected channels. | |
* @param Channels bitfield of injected channels. | |
* @retval Number of injected channels. | |
*/ | |
static uint32_t SDADC_GetInjChannelsNbr(uint32_t Channels) | |
{ | |
uint32_t nbChannels = 0U; | |
uint32_t tmp,i; | |
/* Get the number of channels from bitfield */ | |
tmp = (uint32_t) (Channels & SDADC_LSB_MASK); | |
for(i = 0U ; i < 9U ; i++) | |
{ | |
if((tmp & 0x00000001U) != 0U) | |
{ | |
nbChannels++; | |
} | |
tmp = (uint32_t) (tmp >> 1U); | |
} | |
return nbChannels; | |
} | |
/** | |
* @brief This function allows to really start regular conversion. | |
* @param hsdadc SDADC handle. | |
* @retval HAL status. | |
*/ | |
static HAL_StatusTypeDef SDADC_RegConvStart(SDADC_HandleTypeDef* hsdadc) | |
{ | |
HAL_StatusTypeDef status = HAL_OK; | |
/* Check regular trigger */ | |
if(hsdadc->RegularTrigger == SDADC_SOFTWARE_TRIGGER) | |
{ | |
/* Set RSWSTART bit in SDADC_CR2 register */ | |
hsdadc->Instance->CR2 |= SDADC_CR2_RSWSTART; | |
} | |
else /* synchronuous trigger */ | |
{ | |
/* Enter init mode */ | |
if(SDADC_EnterInitMode(hsdadc) != HAL_OK) | |
{ | |
/* Set SDADC in error state */ | |
hsdadc->State = HAL_SDADC_STATE_ERROR; | |
status = HAL_TIMEOUT; | |
} | |
else | |
{ | |
/* Set RSYNC bit in SDADC_CR1 register */ | |
hsdadc->Instance->CR1 |= SDADC_CR1_RSYNC; | |
/* Exit init mode */ | |
SDADC_ExitInitMode(hsdadc); | |
} | |
} | |
/* Update SDADC state only if status is OK */ | |
if(status == HAL_OK) | |
{ | |
hsdadc->State = (hsdadc->State == HAL_SDADC_STATE_READY) ? \ | |
HAL_SDADC_STATE_REG : HAL_SDADC_STATE_REG_INJ; | |
} | |
/* Return function status */ | |
return status; | |
} | |
/** | |
* @brief This function allows to really stop regular conversion. | |
* @param hsdadc SDADC handle. | |
* @retval HAL status. | |
*/ | |
static HAL_StatusTypeDef SDADC_RegConvStop(SDADC_HandleTypeDef* hsdadc) | |
{ | |
uint32_t tickstart; | |
__IO uint32_t dummy_read_for_register_reset; | |
/* Check continuous mode */ | |
if(hsdadc->RegularContMode == SDADC_CONTINUOUS_CONV_ON) | |
{ | |
/* Clear REOCF by reading SDADC_RDATAR register */ | |
dummy_read_for_register_reset = hsdadc->Instance->RDATAR; | |
UNUSED(dummy_read_for_register_reset); | |
/* Clear RCONT bit in SDADC_CR2 register */ | |
hsdadc->Instance->CR2 &= ~(SDADC_CR2_RCONT); | |
} | |
/* Wait for the end of regular conversion */ | |
tickstart = HAL_GetTick(); | |
while((hsdadc->Instance->ISR & SDADC_ISR_RCIP) != 0U) | |
{ | |
if((HAL_GetTick()-tickstart) > SDADC_TIMEOUT) | |
{ | |
/* Set SDADC in error state and return timeout status */ | |
hsdadc->State = HAL_SDADC_STATE_ERROR; | |
return HAL_TIMEOUT; | |
} | |
} | |
/* Check if trigger is synchronuous */ | |
if(hsdadc->RegularTrigger == SDADC_SYNCHRONOUS_TRIGGER) | |
{ | |
/* Enter init mode */ | |
if(SDADC_EnterInitMode(hsdadc) != HAL_OK) | |
{ | |
/* Set SDADC in error state and return timeout status */ | |
hsdadc->State = HAL_SDADC_STATE_ERROR; | |
return HAL_TIMEOUT; | |
} | |
else | |
{ | |
/* Clear RSYNC bit in SDADC_CR1 register */ | |
hsdadc->Instance->CR1 &= ~(SDADC_CR1_RSYNC); | |
/* Exit init mode */ | |
SDADC_ExitInitMode(hsdadc); | |
} | |
} | |
/* Check if continuous mode */ | |
if(hsdadc->RegularContMode == SDADC_CONTINUOUS_CONV_ON) | |
{ | |
/* Restore RCONT bit in SDADC_CR2 register */ | |
hsdadc->Instance->CR2 |= SDADC_CR2_RCONT; | |
} | |
/* Clear REOCF by reading SDADC_RDATAR register */ | |
dummy_read_for_register_reset = hsdadc->Instance->RDATAR; | |
UNUSED(dummy_read_for_register_reset); | |
/* Set CLRROVRF bit in SDADC_CLRISR register */ | |
hsdadc->Instance->CLRISR |= SDADC_ISR_CLRROVRF; | |
/* Update SDADC state */ | |
hsdadc->State = (hsdadc->State == HAL_SDADC_STATE_REG) ? \ | |
HAL_SDADC_STATE_READY : HAL_SDADC_STATE_INJ; | |
/* Return function status */ | |
return HAL_OK; | |
} | |
/** | |
* @brief This function allows to really start injected conversion. | |
* @param hsdadc SDADC handle. | |
* @retval HAL status. | |
*/ | |
static HAL_StatusTypeDef SDADC_InjConvStart(SDADC_HandleTypeDef* hsdadc) | |
{ | |
HAL_StatusTypeDef status = HAL_OK; | |
/* Initialize number of injected conversions remaining */ | |
hsdadc->InjConvRemaining = hsdadc->InjectedChannelsNbr; | |
/* Check injected trigger */ | |
if(hsdadc->InjectedTrigger == SDADC_SOFTWARE_TRIGGER) | |
{ | |
/* Set JSWSTART bit in SDADC_CR2 register */ | |
hsdadc->Instance->CR2 |= SDADC_CR2_JSWSTART; | |
} | |
else /* external or synchronuous trigger */ | |
{ | |
/* Enter init mode */ | |
if(SDADC_EnterInitMode(hsdadc) != HAL_OK) | |
{ | |
/* Set SDADC in error state */ | |
hsdadc->State = HAL_SDADC_STATE_ERROR; | |
status = HAL_TIMEOUT; | |
} | |
else | |
{ | |
if(hsdadc->InjectedTrigger == SDADC_SYNCHRONOUS_TRIGGER) | |
{ | |
/* Set JSYNC bit in SDADC_CR1 register */ | |
hsdadc->Instance->CR1 |= SDADC_CR1_JSYNC; | |
} | |
else /* external trigger */ | |
{ | |
/* Set JEXTEN[1:0] bits in SDADC_CR2 register */ | |
hsdadc->Instance->CR2 |= hsdadc->ExtTriggerEdge; | |
} | |
/* Exit init mode */ | |
SDADC_ExitInitMode(hsdadc); | |
} | |
} | |
/* Update SDADC state only if status is OK */ | |
if(status == HAL_OK) | |
{ | |
hsdadc->State = (hsdadc->State == HAL_SDADC_STATE_READY) ? \ | |
HAL_SDADC_STATE_INJ : HAL_SDADC_STATE_REG_INJ; | |
} | |
/* Return function status */ | |
return status; | |
} | |
/** | |
* @brief This function allows to really stop injected conversion. | |
* @param hsdadc SDADC handle. | |
* @retval HAL status. | |
*/ | |
static HAL_StatusTypeDef SDADC_InjConvStop(SDADC_HandleTypeDef* hsdadc) | |
{ | |
uint32_t tickstart; | |
__IO uint32_t dummy_read_for_register_reset; | |
/* Check continuous mode */ | |
if(hsdadc->InjectedContMode == SDADC_CONTINUOUS_CONV_ON) | |
{ | |
/* Clear JEOCF by reading SDADC_JDATAR register */ | |
dummy_read_for_register_reset = hsdadc->Instance->JDATAR; | |
UNUSED(dummy_read_for_register_reset); | |
/* Clear JCONT bit in SDADC_CR2 register */ | |
hsdadc->Instance->CR2 &= ~(SDADC_CR2_JCONT); | |
} | |
/* Wait for the end of injected conversion */ | |
tickstart = HAL_GetTick(); | |
while((hsdadc->Instance->ISR & SDADC_ISR_JCIP) != 0U) | |
{ | |
if((HAL_GetTick()-tickstart) > SDADC_TIMEOUT) | |
{ | |
/* Set SDADC in error state and return timeout status */ | |
hsdadc->State = HAL_SDADC_STATE_ERROR; | |
return HAL_TIMEOUT; | |
} | |
} | |
/* Check if trigger is not software */ | |
if(hsdadc->InjectedTrigger != SDADC_SOFTWARE_TRIGGER) | |
{ | |
/* Enter init mode */ | |
if(SDADC_EnterInitMode(hsdadc) != HAL_OK) | |
{ | |
/* Set SDADC in error state and return timeout status */ | |
hsdadc->State = HAL_SDADC_STATE_ERROR; | |
return HAL_TIMEOUT; | |
} | |
else | |
{ | |
/* Check if trigger is synchronuous */ | |
if(hsdadc->InjectedTrigger == SDADC_SYNCHRONOUS_TRIGGER) | |
{ | |
/* Clear JSYNC bit in SDADC_CR1 register */ | |
hsdadc->Instance->CR1 &= ~(SDADC_CR1_JSYNC); | |
} | |
else /* external trigger */ | |
{ | |
/* Clear JEXTEN[1:0] bits in SDADC_CR2 register */ | |
hsdadc->Instance->CR2 &= ~(SDADC_CR2_JEXTEN); | |
} | |
/* Exit init mode */ | |
SDADC_ExitInitMode(hsdadc); | |
} | |
} | |
/* Check if continuous mode */ | |
if(hsdadc->InjectedContMode == SDADC_CONTINUOUS_CONV_ON) | |
{ | |
/* Restore JCONT bit in SDADC_CR2 register */ | |
hsdadc->Instance->CR2 |= SDADC_CR2_JCONT; | |
} | |
/* Clear JEOCF by reading SDADC_JDATAR register */ | |
dummy_read_for_register_reset = hsdadc->Instance->JDATAR; | |
UNUSED(dummy_read_for_register_reset); | |
/* Set CLRJOVRF bit in SDADC_CLRISR register */ | |
hsdadc->Instance->CLRISR |= SDADC_ISR_CLRJOVRF; | |
/* Update SDADC state */ | |
hsdadc->State = (hsdadc->State == HAL_SDADC_STATE_INJ) ? \ | |
HAL_SDADC_STATE_READY : HAL_SDADC_STATE_REG; | |
/* Return function status */ | |
return HAL_OK; | |
} | |
/** | |
* @} | |
*/ | |
/** | |
* @} | |
*/ | |
/** | |
* @} | |
*/ | |
#endif /* defined(STM32F373xC) || defined(STM32F378xx) */ | |
#endif /* HAL_SDADC_MODULE_ENABLED */ | |
/** | |
* @} | |
*/ | |
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ |