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_STM32L4/stm32l4xx_hal_dfsdm.c@610:813dcc80987e, 2015-08-14 (annotated)

Committer:
mbed_official
Date:
Fri Aug 14 13:15:17 2015 +0100
Revision:
610:813dcc80987e
Synchronized with git revision 6d84db41c6833e0b9b024741eb0616a5f62d5599



Full URL: https://github.com/mbedmicro/mbed/commit/6d84db41c6833e0b9b024741eb0616a5f62d5599/



DISCO_F746NG - Improvements

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mbed_official 610:813dcc80987e 1 /**
mbed_official 610:813dcc80987e 2 ******************************************************************************
mbed_official 610:813dcc80987e 3 * @file stm32l4xx_hal_dfsdm.c
mbed_official 610:813dcc80987e 4 * @author MCD Application Team
mbed_official 610:813dcc80987e 5 * @version V1.0.0
mbed_official 610:813dcc80987e 6 * @date 26-June-2015
mbed_official 610:813dcc80987e 7 * @brief This file provides firmware functions to manage the following
mbed_official 610:813dcc80987e 8 * functionalities of the Digital Filter for Sigma-Delta Modulators
mbed_official 610:813dcc80987e 9 * (DFSDM) peripherals:
mbed_official 610:813dcc80987e 10 * + Initialization and configuration of channels and filters
mbed_official 610:813dcc80987e 11 * + Regular channels configuration
mbed_official 610:813dcc80987e 12 * + Injected channels configuration
mbed_official 610:813dcc80987e 13 * + Regular/Injected Channels DMA Configuration
mbed_official 610:813dcc80987e 14 * + Interrupts and flags management
mbed_official 610:813dcc80987e 15 * + Analog watchdog feature
mbed_official 610:813dcc80987e 16 * + Short-circuit detector feature
mbed_official 610:813dcc80987e 17 * + Extremes detector feature
mbed_official 610:813dcc80987e 18 * + Clock absence detector feature
mbed_official 610:813dcc80987e 19 * + Break generation on analog watchdog or short-circuit event
mbed_official 610:813dcc80987e 20 *
mbed_official 610:813dcc80987e 21 @verbatim
mbed_official 610:813dcc80987e 22 ==============================================================================
mbed_official 610:813dcc80987e 23 ##### How to use this driver #####
mbed_official 610:813dcc80987e 24 ==============================================================================
mbed_official 610:813dcc80987e 25 [..]
mbed_official 610:813dcc80987e 26 *** Channel initialization ***
mbed_official 610:813dcc80987e 27 ==============================
mbed_official 610:813dcc80987e 28 [..]
mbed_official 610:813dcc80987e 29 (#) User has first to initialize channels (before filters initialization).
mbed_official 610:813dcc80987e 30 (#) As prerequisite, fill in the HAL_DFSDM_ChannelMspInit() :
mbed_official 610:813dcc80987e 31 (++) Enable DFSDM clock interface with __HAL_RCC_DFSDM_CLK_ENABLE().
mbed_official 610:813dcc80987e 32 (++) Enable the clocks for the DFSDM GPIOS with __HAL_RCC_GPIOx_CLK_ENABLE().
mbed_official 610:813dcc80987e 33 (++) Configure these DFSDM pins in alternate mode using HAL_GPIO_Init().
mbed_official 610:813dcc80987e 34 (++) If interrupt mode is used, enable and configure DFSDM1 global
mbed_official 610:813dcc80987e 35 interrupt with HAL_NVIC_SetPriority() and HAL_NVIC_EnableIRQ().
mbed_official 610:813dcc80987e 36 (#) Configure the output clock, input, serial interface, analog watchdog,
mbed_official 610:813dcc80987e 37 offset and data right bit shift parameters for this channel using the
mbed_official 610:813dcc80987e 38 HAL_DFSDM_ChannelInit() function.
mbed_official 610:813dcc80987e 39
mbed_official 610:813dcc80987e 40 *** Channel clock absence detector ***
mbed_official 610:813dcc80987e 41 ======================================
mbed_official 610:813dcc80987e 42 [..]
mbed_official 610:813dcc80987e 43 (#) Start clock absence detector using HAL_DFSDM_ChannelCkabStart() or
mbed_official 610:813dcc80987e 44 HAL_DFSDM_ChannelCkabStart_IT().
mbed_official 610:813dcc80987e 45 (#) In polling mode, use HAL_DFSDM_ChannelPollForCkab() to detect the clock
mbed_official 610:813dcc80987e 46 absence.
mbed_official 610:813dcc80987e 47 (#) In interrupt mode, HAL_DFSDM_ChannelCkabCallback() will be called if
mbed_official 610:813dcc80987e 48 clock absence is detected.
mbed_official 610:813dcc80987e 49 (#) Stop clock absence detector using HAL_DFSDM_ChannelCkabStop() or
mbed_official 610:813dcc80987e 50 HAL_DFSDM_ChannelCkabStop_IT().
mbed_official 610:813dcc80987e 51 (#) Please note that the same mode (polling or interrupt) has to be used
mbed_official 610:813dcc80987e 52 for all channels because the channels are sharing the same interrupt.
mbed_official 610:813dcc80987e 53 (#) Please note also that in interrupt mode, if clock absence detector is
mbed_official 610:813dcc80987e 54 stopped for one channel, interrupt will be disabled for all channels.
mbed_official 610:813dcc80987e 55
mbed_official 610:813dcc80987e 56 *** Channel short circuit detector ***
mbed_official 610:813dcc80987e 57 ======================================
mbed_official 610:813dcc80987e 58 [..]
mbed_official 610:813dcc80987e 59 (#) Start short circuit detector using HAL_DFSDM_ChannelScdStart() or
mbed_official 610:813dcc80987e 60 or HAL_DFSDM_ChannelScdStart_IT().
mbed_official 610:813dcc80987e 61 (#) In polling mode, use HAL_DFSDM_ChannelPollForScd() to detect short
mbed_official 610:813dcc80987e 62 circuit.
mbed_official 610:813dcc80987e 63 (#) In interrupt mode, HAL_DFSDM_ChannelScdCallback() will be called if
mbed_official 610:813dcc80987e 64 short circuit is detected.
mbed_official 610:813dcc80987e 65 (#) Stop short circuit detector using HAL_DFSDM_ChannelScdStop() or
mbed_official 610:813dcc80987e 66 or HAL_DFSDM_ChannelScdStop_IT().
mbed_official 610:813dcc80987e 67 (#) Please note that the same mode (polling or interrupt) has to be used
mbed_official 610:813dcc80987e 68 for all channels because the channels are sharing the same interrupt.
mbed_official 610:813dcc80987e 69 (#) Please note also that in interrupt mode, if short circuit detector is
mbed_official 610:813dcc80987e 70 stopped for one channel, interrupt will be disabled for all channels.
mbed_official 610:813dcc80987e 71
mbed_official 610:813dcc80987e 72 *** Channel analog watchdog value ***
mbed_official 610:813dcc80987e 73 =====================================
mbed_official 610:813dcc80987e 74 [..]
mbed_official 610:813dcc80987e 75 (#) Get analog watchdog filter value of a channel using
mbed_official 610:813dcc80987e 76 HAL_DFSDM_ChannelGetAwdValue().
mbed_official 610:813dcc80987e 77
mbed_official 610:813dcc80987e 78 *** Channel offset value ***
mbed_official 610:813dcc80987e 79 =====================================
mbed_official 610:813dcc80987e 80 [..]
mbed_official 610:813dcc80987e 81 (#) Modify offset value of a channel using HAL_DFSDM_ChannelModifyOffset().
mbed_official 610:813dcc80987e 82
mbed_official 610:813dcc80987e 83 *** Filter initialization ***
mbed_official 610:813dcc80987e 84 =============================
mbed_official 610:813dcc80987e 85 [..]
mbed_official 610:813dcc80987e 86 (#) After channel initialization, user has to init filters.
mbed_official 610:813dcc80987e 87 (#) As prerequisite, fill in the HAL_DFSDM_FilterMspInit() :
mbed_official 610:813dcc80987e 88 (++) If interrupt mode is used , enable and configure DFSDMx global
mbed_official 610:813dcc80987e 89 interrupt with HAL_NVIC_SetPriority() and HAL_NVIC_EnableIRQ().
mbed_official 610:813dcc80987e 90 Please note that DFSDM0 global interrupt could be already
mbed_official 610:813dcc80987e 91 enabled if interrupt is used for channel.
mbed_official 610:813dcc80987e 92 (++) If DMA mode is used, configure DMA with HAL_DMA_Init() and link it
mbed_official 610:813dcc80987e 93 with DFSDMx filter handle using __HAL_LINKDMA().
mbed_official 610:813dcc80987e 94 (#) Configure the regular conversion, injected conversion and filter
mbed_official 610:813dcc80987e 95 parameters for this filter using the HAL_DFSDM_FilterInit() function.
mbed_official 610:813dcc80987e 96
mbed_official 610:813dcc80987e 97 *** Filter regular channel conversion ***
mbed_official 610:813dcc80987e 98 =========================================
mbed_official 610:813dcc80987e 99 [..]
mbed_official 610:813dcc80987e 100 (#) Select regular channel and enable/disable continuous mode using
mbed_official 610:813dcc80987e 101 HAL_DFSDM_FilterConfigRegChannel().
mbed_official 610:813dcc80987e 102 (#) Start regular conversion using HAL_DFSDM_FilterRegularStart(),
mbed_official 610:813dcc80987e 103 HAL_DFSDM_FilterRegularStart_IT(), HAL_DFSDM_FilterRegularStart_DMA() or
mbed_official 610:813dcc80987e 104 HAL_DFSDM_FilterRegularMsbStart_DMA().
mbed_official 610:813dcc80987e 105 (#) In polling mode, use HAL_DFSDM_FilterPollForRegConversion() to detect
mbed_official 610:813dcc80987e 106 the end of regular conversion.
mbed_official 610:813dcc80987e 107 (#) In interrupt mode, HAL_DFSDM_FilterRegConvCpltCallback() will be called
mbed_official 610:813dcc80987e 108 at the end of regular conversion.
mbed_official 610:813dcc80987e 109 (#) Get value of regular conversion and corresponding channel using
mbed_official 610:813dcc80987e 110 HAL_DFSDM_FilterGetRegularValue().
mbed_official 610:813dcc80987e 111 (#) In DMA mode, HAL_DFSDM_FilterRegConvHalfCpltCallback() and
mbed_official 610:813dcc80987e 112 HAL_DFSDM_FilterRegConvCpltCallback() will be called respectively at the
mbed_official 610:813dcc80987e 113 half transfer and at the transfer complete. Please note that
mbed_official 610:813dcc80987e 114 HAL_DFSDM_FilterRegConvHalfCpltCallback() will be called only in DMA
mbed_official 610:813dcc80987e 115 circular mode.
mbed_official 610:813dcc80987e 116 (#) Stop regular conversion using HAL_DFSDM_FilterRegularStop(),
mbed_official 610:813dcc80987e 117 HAL_DFSDM_FilterRegularStop_IT() or HAL_DFSDM_FilterRegularStop_DMA().
mbed_official 610:813dcc80987e 118
mbed_official 610:813dcc80987e 119 *** Filter injected channels conversion ***
mbed_official 610:813dcc80987e 120 ===========================================
mbed_official 610:813dcc80987e 121 [..]
mbed_official 610:813dcc80987e 122 (#) Select injected channels using HAL_DFSDM_FilterConfigInjChannel().
mbed_official 610:813dcc80987e 123 (#) Start injected conversion using HAL_DFSDM_FilterInjectedStart(),
mbed_official 610:813dcc80987e 124 HAL_DFSDM_FilterInjectedStart_IT(), HAL_DFSDM_FilterInjectedStart_DMA() or
mbed_official 610:813dcc80987e 125 HAL_DFSDM_FilterInjectedMsbStart_DMA().
mbed_official 610:813dcc80987e 126 (#) In polling mode, use HAL_DFSDM_FilterPollForInjConversion() to detect
mbed_official 610:813dcc80987e 127 the end of injected conversion.
mbed_official 610:813dcc80987e 128 (#) In interrupt mode, HAL_DFSDM_FilterInjConvCpltCallback() will be called
mbed_official 610:813dcc80987e 129 at the end of injected conversion.
mbed_official 610:813dcc80987e 130 (#) Get value of injected conversion and corresponding channel using
mbed_official 610:813dcc80987e 131 HAL_DFSDM_FilterGetInjectedValue().
mbed_official 610:813dcc80987e 132 (#) In DMA mode, HAL_DFSDM_FilterInjConvHalfCpltCallback() and
mbed_official 610:813dcc80987e 133 HAL_DFSDM_FilterInjConvCpltCallback() will be called respectively at the
mbed_official 610:813dcc80987e 134 half transfer and at the transfer complete. Please note that
mbed_official 610:813dcc80987e 135 HAL_DFSDM_FilterInjConvCpltCallback() will be called only in DMA
mbed_official 610:813dcc80987e 136 circular mode.
mbed_official 610:813dcc80987e 137 (#) Stop injected conversion using HAL_DFSDM_FilterInjectedStop(),
mbed_official 610:813dcc80987e 138 HAL_DFSDM_FilterInjectedStop_IT() or HAL_DFSDM_FilterInjectedStop_DMA().
mbed_official 610:813dcc80987e 139
mbed_official 610:813dcc80987e 140 *** Filter analog watchdog ***
mbed_official 610:813dcc80987e 141 ==============================
mbed_official 610:813dcc80987e 142 [..]
mbed_official 610:813dcc80987e 143 (#) Start filter analog watchdog using HAL_DFSDM_FilterAwdStart_IT().
mbed_official 610:813dcc80987e 144 (#) HAL_DFSDM_FilterAwdCallback() will be called if analog watchdog occurs.
mbed_official 610:813dcc80987e 145 (#) Stop filter analog watchdog using HAL_DFSDM_FilterAwdStop_IT().
mbed_official 610:813dcc80987e 146
mbed_official 610:813dcc80987e 147 *** Filter extreme detector ***
mbed_official 610:813dcc80987e 148 ===============================
mbed_official 610:813dcc80987e 149 [..]
mbed_official 610:813dcc80987e 150 (#) Start filter extreme detector using HAL_DFSDM_FilterExdStart().
mbed_official 610:813dcc80987e 151 (#) Get extreme detector maximum value using HAL_DFSDM_FilterGetExdMaxValue().
mbed_official 610:813dcc80987e 152 (#) Get extreme detector minimum value using HAL_DFSDM_FilterGetExdMinValue().
mbed_official 610:813dcc80987e 153 (#) Start filter extreme detector using HAL_DFSDM_FilterExdStop().
mbed_official 610:813dcc80987e 154
mbed_official 610:813dcc80987e 155 *** Filter conversion time ***
mbed_official 610:813dcc80987e 156 ==============================
mbed_official 610:813dcc80987e 157 [..]
mbed_official 610:813dcc80987e 158 (#) Get conversion time value using HAL_DFSDM_FilterGetConvTimeValue().
mbed_official 610:813dcc80987e 159
mbed_official 610:813dcc80987e 160 @endverbatim
mbed_official 610:813dcc80987e 161 ******************************************************************************
mbed_official 610:813dcc80987e 162 * @attention
mbed_official 610:813dcc80987e 163 *
mbed_official 610:813dcc80987e 164 * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
mbed_official 610:813dcc80987e 165 *
mbed_official 610:813dcc80987e 166 * Redistribution and use in source and binary forms, with or without modification,
mbed_official 610:813dcc80987e 167 * are permitted provided that the following conditions are met:
mbed_official 610:813dcc80987e 168 * 1. Redistributions of source code must retain the above copyright notice,
mbed_official 610:813dcc80987e 169 * this list of conditions and the following disclaimer.
mbed_official 610:813dcc80987e 170 * 2. Redistributions in binary form must reproduce the above copyright notice,
mbed_official 610:813dcc80987e 171 * this list of conditions and the following disclaimer in the documentation
mbed_official 610:813dcc80987e 172 * and/or other materials provided with the distribution.
mbed_official 610:813dcc80987e 173 * 3. Neither the name of STMicroelectronics nor the names of its contributors
mbed_official 610:813dcc80987e 174 * may be used to endorse or promote products derived from this software
mbed_official 610:813dcc80987e 175 * without specific prior written permission.
mbed_official 610:813dcc80987e 176 *
mbed_official 610:813dcc80987e 177 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
mbed_official 610:813dcc80987e 178 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
mbed_official 610:813dcc80987e 179 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
mbed_official 610:813dcc80987e 180 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
mbed_official 610:813dcc80987e 181 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
mbed_official 610:813dcc80987e 182 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
mbed_official 610:813dcc80987e 183 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
mbed_official 610:813dcc80987e 184 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
mbed_official 610:813dcc80987e 185 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
mbed_official 610:813dcc80987e 186 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
mbed_official 610:813dcc80987e 187 *
mbed_official 610:813dcc80987e 188 ******************************************************************************
mbed_official 610:813dcc80987e 189 */
mbed_official 610:813dcc80987e 190
mbed_official 610:813dcc80987e 191 /* Includes ------------------------------------------------------------------*/
mbed_official 610:813dcc80987e 192 #include "stm32l4xx_hal.h"
mbed_official 610:813dcc80987e 193
mbed_official 610:813dcc80987e 194 /** @addtogroup STM32L4xx_HAL_Driver
mbed_official 610:813dcc80987e 195 * @{
mbed_official 610:813dcc80987e 196 */
mbed_official 610:813dcc80987e 197 #ifdef HAL_DFSDM_MODULE_ENABLED
mbed_official 610:813dcc80987e 198 /** @defgroup DFSDM DFSDM
mbed_official 610:813dcc80987e 199 * @brief DFSDM HAL driver module
mbed_official 610:813dcc80987e 200 * @{
mbed_official 610:813dcc80987e 201 */
mbed_official 610:813dcc80987e 202
mbed_official 610:813dcc80987e 203 /* Private typedef -----------------------------------------------------------*/
mbed_official 610:813dcc80987e 204 /* Private define ------------------------------------------------------------*/
mbed_official 610:813dcc80987e 205 /** @defgroup DFSDM_Private_Define DFSDM Private Define
mbed_official 610:813dcc80987e 206 * @{
mbed_official 610:813dcc80987e 207 */
mbed_official 610:813dcc80987e 208 #define DFSDM_CHCFGR1_CLK_DIV_OFFSET POSITION_VAL(DFSDM_CHCFGR1_CKOUTDIV)
mbed_official 610:813dcc80987e 209 #define DFSDM_AWSCDR_BKSCD_OFFSET POSITION_VAL(DFSDM_AWSCDR_BKSCD)
mbed_official 610:813dcc80987e 210 #define DFSDM_AWSCDR_FOSR_OFFSET POSITION_VAL(DFSDM_AWSCDR_AWFOSR)
mbed_official 610:813dcc80987e 211 #define DFSDM_CHCFGR2_OFFSET_OFFSET POSITION_VAL(DFSDM_CHCFGR2_OFFSET)
mbed_official 610:813dcc80987e 212 #define DFSDM_CHCFGR2_DTRBS_OFFSET POSITION_VAL(DFSDM_CHCFGR2_DTRBS)
mbed_official 610:813dcc80987e 213 #define DFSDM_FCR_FOSR_OFFSET POSITION_VAL(DFSDM_FCR_FOSR)
mbed_official 610:813dcc80987e 214 #define DFSDM_CR1_MSB_RCH_OFFSET 8
mbed_official 610:813dcc80987e 215 #define DFSDM_CR2_EXCH_OFFSET POSITION_VAL(DFSDM_CR2_EXCH)
mbed_official 610:813dcc80987e 216 #define DFSDM_CR2_AWDCH_OFFSET POSITION_VAL(DFSDM_CR2_AWDCH)
mbed_official 610:813dcc80987e 217 #define DFSDM_ISR_CKABF_OFFSET POSITION_VAL(DFSDM_ISR_CKABF)
mbed_official 610:813dcc80987e 218 #define DFSDM_ISR_SCDF_OFFSET POSITION_VAL(DFSDM_ISR_SCDF)
mbed_official 610:813dcc80987e 219 #define DFSDM_ICR_CLRCKABF_OFFSET POSITION_VAL(DFSDM_ICR_CLRCKABF)
mbed_official 610:813dcc80987e 220 #define DFSDM_ICR_CLRSCDF_OFFSET POSITION_VAL(DFSDM_ICR_CLRSCSDF)
mbed_official 610:813dcc80987e 221 #define DFSDM_RDATAR_DATA_OFFSET POSITION_VAL(DFSDM_RDATAR_RDATA)
mbed_official 610:813dcc80987e 222 #define DFSDM_JDATAR_DATA_OFFSET POSITION_VAL(DFSDM_JDATAR_JDATA)
mbed_official 610:813dcc80987e 223 #define DFSDM_AWHTR_THRESHOLD_OFFSET POSITION_VAL(DFSDM_AWHTR_AWHT)
mbed_official 610:813dcc80987e 224 #define DFSDM_AWLTR_THRESHOLD_OFFSET POSITION_VAL(DFSDM_AWLTR_AWLT)
mbed_official 610:813dcc80987e 225 #define DFSDM_EXMAX_DATA_OFFSET POSITION_VAL(DFSDM_EXMAX_EXMAX)
mbed_official 610:813dcc80987e 226 #define DFSDM_EXMIN_DATA_OFFSET POSITION_VAL(DFSDM_EXMIN_EXMIN)
mbed_official 610:813dcc80987e 227 #define DFSDM_CNVTIMR_DATA_OFFSET POSITION_VAL(DFSDM_CNVTIMR_CNVCNT)
mbed_official 610:813dcc80987e 228 #define DFSDM_AWSR_HIGH_OFFSET POSITION_VAL(DFSDM_AWSR_AWHTF)
mbed_official 610:813dcc80987e 229 #define DFSDM_MSB_MASK 0xFFFF0000
mbed_official 610:813dcc80987e 230 #define DFSDM_LSB_MASK 0x0000FFFF
mbed_official 610:813dcc80987e 231 #define DFSDM_CKAB_TIMEOUT 5000
mbed_official 610:813dcc80987e 232 #define DFSDM_CHANNEL_NUMBER 8
mbed_official 610:813dcc80987e 233 /**
mbed_official 610:813dcc80987e 234 * @}
mbed_official 610:813dcc80987e 235 */
mbed_official 610:813dcc80987e 236
mbed_official 610:813dcc80987e 237 /* Private macro -------------------------------------------------------------*/
mbed_official 610:813dcc80987e 238 /* Private variables ---------------------------------------------------------*/
mbed_official 610:813dcc80987e 239 /** @defgroup DFSDM_Private_Variables DFSDM Private Variables
mbed_official 610:813dcc80987e 240 * @{
mbed_official 610:813dcc80987e 241 */
mbed_official 610:813dcc80987e 242 __IO uint32_t v_dfsdmChannelCounter = 0;
mbed_official 610:813dcc80987e 243 DFSDM_Channel_HandleTypeDef* a_dfsdmChannelHandle[DFSDM_CHANNEL_NUMBER] = {(DFSDM_Channel_HandleTypeDef *) NULL};
mbed_official 610:813dcc80987e 244 /**
mbed_official 610:813dcc80987e 245 * @}
mbed_official 610:813dcc80987e 246 */
mbed_official 610:813dcc80987e 247
mbed_official 610:813dcc80987e 248 /* Private function prototypes -----------------------------------------------*/
mbed_official 610:813dcc80987e 249 /** @defgroup DFSDM_Private_Functions DFSDM Private Functions
mbed_official 610:813dcc80987e 250 * @{
mbed_official 610:813dcc80987e 251 */
mbed_official 610:813dcc80987e 252 static uint32_t DFSDM_GetInjChannelsNbr(uint32_t Channels);
mbed_official 610:813dcc80987e 253 static uint32_t DFSDM_GetChannelFromInstance(DFSDM_Channel_TypeDef* Instance);
mbed_official 610:813dcc80987e 254 static void DFSDM_RegConvStart(DFSDM_Filter_HandleTypeDef *hdfsdm_filter);
mbed_official 610:813dcc80987e 255 static void DFSDM_RegConvStop(DFSDM_Filter_HandleTypeDef* hdfsdm_filter);
mbed_official 610:813dcc80987e 256 static void DFSDM_InjConvStart(DFSDM_Filter_HandleTypeDef* hdfsdm_filter);
mbed_official 610:813dcc80987e 257 static void DFSDM_InjConvStop(DFSDM_Filter_HandleTypeDef* hdfsdm_filter);
mbed_official 610:813dcc80987e 258 static void DFSDM_DMARegularHalfConvCplt(DMA_HandleTypeDef *hdma);
mbed_official 610:813dcc80987e 259 static void DFSDM_DMARegularConvCplt(DMA_HandleTypeDef *hdma);
mbed_official 610:813dcc80987e 260 static void DFSDM_DMAInjectedHalfConvCplt(DMA_HandleTypeDef *hdma);
mbed_official 610:813dcc80987e 261 static void DFSDM_DMAInjectedConvCplt(DMA_HandleTypeDef *hdma);
mbed_official 610:813dcc80987e 262 static void DFSDM_DMAError(DMA_HandleTypeDef *hdma);
mbed_official 610:813dcc80987e 263 /**
mbed_official 610:813dcc80987e 264 * @}
mbed_official 610:813dcc80987e 265 */
mbed_official 610:813dcc80987e 266
mbed_official 610:813dcc80987e 267 /* Exported functions --------------------------------------------------------*/
mbed_official 610:813dcc80987e 268 /** @defgroup DFSDM_Exported_Functions DFSDM Exported Functions
mbed_official 610:813dcc80987e 269 * @{
mbed_official 610:813dcc80987e 270 */
mbed_official 610:813dcc80987e 271
mbed_official 610:813dcc80987e 272 /** @defgroup DFSDM_Exported_Functions_Group1_Channel Channel initialization and de-initialization functions
mbed_official 610:813dcc80987e 273 * @brief Channel initialization and de-initialization functions
mbed_official 610:813dcc80987e 274 *
mbed_official 610:813dcc80987e 275 @verbatim
mbed_official 610:813dcc80987e 276 ==============================================================================
mbed_official 610:813dcc80987e 277 ##### Channel initialization and de-initialization functions #####
mbed_official 610:813dcc80987e 278 ==============================================================================
mbed_official 610:813dcc80987e 279 [..] This section provides functions allowing to:
mbed_official 610:813dcc80987e 280 (+) Initialize the DFSDM channel.
mbed_official 610:813dcc80987e 281 (+) De-initialize the DFSDM channel.
mbed_official 610:813dcc80987e 282 @endverbatim
mbed_official 610:813dcc80987e 283 * @{
mbed_official 610:813dcc80987e 284 */
mbed_official 610:813dcc80987e 285
mbed_official 610:813dcc80987e 286 /**
mbed_official 610:813dcc80987e 287 * @brief Initialize the DFSDM channel according to the specified parameters
mbed_official 610:813dcc80987e 288 * in the DFSDM_ChannelInitTypeDef structure and initialize the associated handle.
mbed_official 610:813dcc80987e 289 * @param hdfsdm_channel : DFSDM channel handle.
mbed_official 610:813dcc80987e 290 * @retval HAL status.
mbed_official 610:813dcc80987e 291 */
mbed_official 610:813dcc80987e 292 HAL_StatusTypeDef HAL_DFSDM_ChannelInit(DFSDM_Channel_HandleTypeDef *hdfsdm_channel)
mbed_official 610:813dcc80987e 293 {
mbed_official 610:813dcc80987e 294 /* Check parameters */
mbed_official 610:813dcc80987e 295 assert_param(IS_DFSDM_CHANNEL_ALL_INSTANCE(hdfsdm_channel->Instance));
mbed_official 610:813dcc80987e 296 assert_param(IS_FUNCTIONAL_STATE(hdfsdm_channel->Init.OutputClock.Activation));
mbed_official 610:813dcc80987e 297 assert_param(IS_DFSDM_CHANNEL_INPUT(hdfsdm_channel->Init.Input.Multiplexer));
mbed_official 610:813dcc80987e 298 assert_param(IS_DFSDM_CHANNEL_DATA_PACKING(hdfsdm_channel->Init.Input.DataPacking));
mbed_official 610:813dcc80987e 299 assert_param(IS_DFSDM_CHANNEL_INPUT_PINS(hdfsdm_channel->Init.Input.Pins));
mbed_official 610:813dcc80987e 300 assert_param(IS_DFSDM_CHANNEL_SERIAL_INTERFACE_TYPE(hdfsdm_channel->Init.SerialInterface.Type));
mbed_official 610:813dcc80987e 301 assert_param(IS_DFSDM_CHANNEL_SPI_CLOCK(hdfsdm_channel->Init.SerialInterface.SpiClock));
mbed_official 610:813dcc80987e 302 assert_param(IS_DFSDM_CHANNEL_FILTER_ORDER(hdfsdm_channel->Init.Awd.FilterOrder));
mbed_official 610:813dcc80987e 303 assert_param(IS_DFSDM_CHANNEL_FILTER_OVS_RATIO(hdfsdm_channel->Init.Awd.Oversampling));
mbed_official 610:813dcc80987e 304 assert_param(IS_DFSDM_CHANNEL_OFFSET(hdfsdm_channel->Init.Offset));
mbed_official 610:813dcc80987e 305 assert_param(IS_DFSDM_CHANNEL_RIGHT_BIT_SHIFT(hdfsdm_channel->Init.RightBitShift));
mbed_official 610:813dcc80987e 306
mbed_official 610:813dcc80987e 307 /* Check DFSDM Channel handle */
mbed_official 610:813dcc80987e 308 if(hdfsdm_channel == NULL)
mbed_official 610:813dcc80987e 309 {
mbed_official 610:813dcc80987e 310 return HAL_ERROR;
mbed_official 610:813dcc80987e 311 }
mbed_official 610:813dcc80987e 312 /* Check that channel has not been already initialized */
mbed_official 610:813dcc80987e 313 if(a_dfsdmChannelHandle[DFSDM_GetChannelFromInstance(hdfsdm_channel->Instance)] != NULL)
mbed_official 610:813dcc80987e 314 {
mbed_official 610:813dcc80987e 315 return HAL_ERROR;
mbed_official 610:813dcc80987e 316 }
mbed_official 610:813dcc80987e 317
mbed_official 610:813dcc80987e 318 /* Call MSP init function */
mbed_official 610:813dcc80987e 319 HAL_DFSDM_ChannelMspInit(hdfsdm_channel);
mbed_official 610:813dcc80987e 320
mbed_official 610:813dcc80987e 321 /* Update the channel counter */
mbed_official 610:813dcc80987e 322 v_dfsdmChannelCounter++;
mbed_official 610:813dcc80987e 323
mbed_official 610:813dcc80987e 324 /* Configure output serial clock and enable global DFSDM interface only for first channel */
mbed_official 610:813dcc80987e 325 if(v_dfsdmChannelCounter == 1)
mbed_official 610:813dcc80987e 326 {
mbed_official 610:813dcc80987e 327 assert_param(IS_DFSDM_CHANNEL_OUTPUT_CLOCK(hdfsdm_channel->Init.OutputClock.Selection));
mbed_official 610:813dcc80987e 328 /* Set the output serial clock source */
mbed_official 610:813dcc80987e 329 DFSDM_Channel0->CHCFGR1 &= ~(DFSDM_CHCFGR1_CKOUTSRC);
mbed_official 610:813dcc80987e 330 DFSDM_Channel0->CHCFGR1 |= hdfsdm_channel->Init.OutputClock.Selection;
mbed_official 610:813dcc80987e 331
mbed_official 610:813dcc80987e 332 /* Reset clock divider */
mbed_official 610:813dcc80987e 333 DFSDM_Channel0->CHCFGR1 &= ~(DFSDM_CHCFGR1_CKOUTDIV);
mbed_official 610:813dcc80987e 334 if(hdfsdm_channel->Init.OutputClock.Activation == ENABLE)
mbed_official 610:813dcc80987e 335 {
mbed_official 610:813dcc80987e 336 assert_param(IS_DFSDM_CHANNEL_OUTPUT_CLOCK_DIVIDER(hdfsdm_channel->Init.OutputClock.Divider));
mbed_official 610:813dcc80987e 337 /* Set the output clock divider */
mbed_official 610:813dcc80987e 338 DFSDM_Channel0->CHCFGR1 |= (uint32_t) ((hdfsdm_channel->Init.OutputClock.Divider - 1) <<
mbed_official 610:813dcc80987e 339 DFSDM_CHCFGR1_CLK_DIV_OFFSET);
mbed_official 610:813dcc80987e 340 }
mbed_official 610:813dcc80987e 341
mbed_official 610:813dcc80987e 342 /* enable the DFSDM global interface */
mbed_official 610:813dcc80987e 343 DFSDM_Channel0->CHCFGR1 |= DFSDM_CHCFGR1_DFSDMEN;
mbed_official 610:813dcc80987e 344 }
mbed_official 610:813dcc80987e 345
mbed_official 610:813dcc80987e 346 /* Set channel input parameters */
mbed_official 610:813dcc80987e 347 hdfsdm_channel->Instance->CHCFGR1 &= ~(DFSDM_CHCFGR1_DATPACK | DFSDM_CHCFGR1_DATMPX |
mbed_official 610:813dcc80987e 348 DFSDM_CHCFGR1_CHINSEL);
mbed_official 610:813dcc80987e 349 hdfsdm_channel->Instance->CHCFGR1 |= (hdfsdm_channel->Init.Input.Multiplexer |
mbed_official 610:813dcc80987e 350 hdfsdm_channel->Init.Input.DataPacking |
mbed_official 610:813dcc80987e 351 hdfsdm_channel->Init.Input.Pins);
mbed_official 610:813dcc80987e 352
mbed_official 610:813dcc80987e 353 /* Set serial interface parameters */
mbed_official 610:813dcc80987e 354 hdfsdm_channel->Instance->CHCFGR1 &= ~(DFSDM_CHCFGR1_SITP | DFSDM_CHCFGR1_SPICKSEL);
mbed_official 610:813dcc80987e 355 hdfsdm_channel->Instance->CHCFGR1 |= (hdfsdm_channel->Init.SerialInterface.Type |
mbed_official 610:813dcc80987e 356 hdfsdm_channel->Init.SerialInterface.SpiClock);
mbed_official 610:813dcc80987e 357
mbed_official 610:813dcc80987e 358 /* Set analog watchdog parameters */
mbed_official 610:813dcc80987e 359 hdfsdm_channel->Instance->AWSCDR &= ~(DFSDM_AWSCDR_AWFORD | DFSDM_AWSCDR_AWFOSR);
mbed_official 610:813dcc80987e 360 hdfsdm_channel->Instance->AWSCDR |= (hdfsdm_channel->Init.Awd.FilterOrder |
mbed_official 610:813dcc80987e 361 ((hdfsdm_channel->Init.Awd.Oversampling - 1) << DFSDM_AWSCDR_FOSR_OFFSET));
mbed_official 610:813dcc80987e 362
mbed_official 610:813dcc80987e 363 /* Set channel offset and right bit shift */
mbed_official 610:813dcc80987e 364 hdfsdm_channel->Instance->CHCFGR2 &= ~(DFSDM_CHCFGR2_OFFSET | DFSDM_CHCFGR2_DTRBS);
mbed_official 610:813dcc80987e 365 hdfsdm_channel->Instance->CHCFGR2 |= ((hdfsdm_channel->Init.Offset << DFSDM_CHCFGR2_OFFSET_OFFSET) |
mbed_official 610:813dcc80987e 366 (hdfsdm_channel->Init.RightBitShift << DFSDM_CHCFGR2_DTRBS_OFFSET));
mbed_official 610:813dcc80987e 367
mbed_official 610:813dcc80987e 368 /* Enable DFSDM channel */
mbed_official 610:813dcc80987e 369 hdfsdm_channel->Instance->CHCFGR1 |= DFSDM_CHCFGR1_CHEN;
mbed_official 610:813dcc80987e 370
mbed_official 610:813dcc80987e 371 /* Set DFSDM Channel to ready state */
mbed_official 610:813dcc80987e 372 hdfsdm_channel->State = HAL_DFSDM_CHANNEL_STATE_READY;
mbed_official 610:813dcc80987e 373
mbed_official 610:813dcc80987e 374 /* Store channel handle in DFSDM channel handle table */
mbed_official 610:813dcc80987e 375 a_dfsdmChannelHandle[DFSDM_GetChannelFromInstance(hdfsdm_channel->Instance)] = hdfsdm_channel;
mbed_official 610:813dcc80987e 376
mbed_official 610:813dcc80987e 377 return HAL_OK;
mbed_official 610:813dcc80987e 378 }
mbed_official 610:813dcc80987e 379
mbed_official 610:813dcc80987e 380 /**
mbed_official 610:813dcc80987e 381 * @brief De-initialize the DFSDM channel.
mbed_official 610:813dcc80987e 382 * @param hdfsdm_channel : DFSDM channel handle.
mbed_official 610:813dcc80987e 383 * @retval HAL status.
mbed_official 610:813dcc80987e 384 */
mbed_official 610:813dcc80987e 385 HAL_StatusTypeDef HAL_DFSDM_ChannelDeInit(DFSDM_Channel_HandleTypeDef *hdfsdm_channel)
mbed_official 610:813dcc80987e 386 {
mbed_official 610:813dcc80987e 387 /* Check parameters */
mbed_official 610:813dcc80987e 388 assert_param(IS_DFSDM_CHANNEL_ALL_INSTANCE(hdfsdm_channel->Instance));
mbed_official 610:813dcc80987e 389
mbed_official 610:813dcc80987e 390 /* Check DFSDM Channel handle */
mbed_official 610:813dcc80987e 391 if(hdfsdm_channel == NULL)
mbed_official 610:813dcc80987e 392 {
mbed_official 610:813dcc80987e 393 return HAL_ERROR;
mbed_official 610:813dcc80987e 394 }
mbed_official 610:813dcc80987e 395 /* Check that channel has not been already deinitialized */
mbed_official 610:813dcc80987e 396 if(a_dfsdmChannelHandle[DFSDM_GetChannelFromInstance(hdfsdm_channel->Instance)] == NULL)
mbed_official 610:813dcc80987e 397 {
mbed_official 610:813dcc80987e 398 return HAL_ERROR;
mbed_official 610:813dcc80987e 399 }
mbed_official 610:813dcc80987e 400
mbed_official 610:813dcc80987e 401 /* Disable the DFSDM channel */
mbed_official 610:813dcc80987e 402 hdfsdm_channel->Instance->CHCFGR1 &= ~(DFSDM_CHCFGR1_CHEN);
mbed_official 610:813dcc80987e 403
mbed_official 610:813dcc80987e 404 /* Update the channel counter */
mbed_official 610:813dcc80987e 405 v_dfsdmChannelCounter--;
mbed_official 610:813dcc80987e 406
mbed_official 610:813dcc80987e 407 /* Disable global DFSDM at deinit of last channel */
mbed_official 610:813dcc80987e 408 if(v_dfsdmChannelCounter == 0)
mbed_official 610:813dcc80987e 409 {
mbed_official 610:813dcc80987e 410 DFSDM_Channel0->CHCFGR1 &= ~(DFSDM_CHCFGR1_DFSDMEN);
mbed_official 610:813dcc80987e 411 }
mbed_official 610:813dcc80987e 412
mbed_official 610:813dcc80987e 413 /* Call MSP deinit function */
mbed_official 610:813dcc80987e 414 HAL_DFSDM_ChannelMspDeInit(hdfsdm_channel);
mbed_official 610:813dcc80987e 415
mbed_official 610:813dcc80987e 416 /* Set DFSDM Channel in reset state */
mbed_official 610:813dcc80987e 417 hdfsdm_channel->State = HAL_DFSDM_CHANNEL_STATE_RESET;
mbed_official 610:813dcc80987e 418
mbed_official 610:813dcc80987e 419 /* Reset channel handle in DFSDM channel handle table */
mbed_official 610:813dcc80987e 420 a_dfsdmChannelHandle[DFSDM_GetChannelFromInstance(hdfsdm_channel->Instance)] = (DFSDM_Channel_HandleTypeDef *) NULL;
mbed_official 610:813dcc80987e 421
mbed_official 610:813dcc80987e 422 return HAL_OK;
mbed_official 610:813dcc80987e 423 }
mbed_official 610:813dcc80987e 424
mbed_official 610:813dcc80987e 425 /**
mbed_official 610:813dcc80987e 426 * @brief Initialize the DFSDM channel MSP.
mbed_official 610:813dcc80987e 427 * @param hdfsdm_channel : DFSDM channel handle.
mbed_official 610:813dcc80987e 428 * @retval None
mbed_official 610:813dcc80987e 429 */
mbed_official 610:813dcc80987e 430 __weak void HAL_DFSDM_ChannelMspInit(DFSDM_Channel_HandleTypeDef *hdfsdm_channel)
mbed_official 610:813dcc80987e 431 {
mbed_official 610:813dcc80987e 432 /* NOTE : This function should not be modified, when the function is needed,
mbed_official 610:813dcc80987e 433 the HAL_DFSDM_ChannelMspInit could be implemented in the user file.
mbed_official 610:813dcc80987e 434 */
mbed_official 610:813dcc80987e 435 }
mbed_official 610:813dcc80987e 436
mbed_official 610:813dcc80987e 437 /**
mbed_official 610:813dcc80987e 438 * @brief De-initialize the DFSDM channel MSP.
mbed_official 610:813dcc80987e 439 * @param hdfsdm_channel : DFSDM channel handle.
mbed_official 610:813dcc80987e 440 * @retval None
mbed_official 610:813dcc80987e 441 */
mbed_official 610:813dcc80987e 442 __weak void HAL_DFSDM_ChannelMspDeInit(DFSDM_Channel_HandleTypeDef *hdfsdm_channel)
mbed_official 610:813dcc80987e 443 {
mbed_official 610:813dcc80987e 444 /* NOTE : This function should not be modified, when the function is needed,
mbed_official 610:813dcc80987e 445 the HAL_DFSDM_ChannelMspDeInit could be implemented in the user file.
mbed_official 610:813dcc80987e 446 */
mbed_official 610:813dcc80987e 447 }
mbed_official 610:813dcc80987e 448
mbed_official 610:813dcc80987e 449 /**
mbed_official 610:813dcc80987e 450 * @}
mbed_official 610:813dcc80987e 451 */
mbed_official 610:813dcc80987e 452
mbed_official 610:813dcc80987e 453 /** @defgroup DFSDM_Exported_Functions_Group2_Channel Channel operation functions
mbed_official 610:813dcc80987e 454 * @brief Channel operation functions
mbed_official 610:813dcc80987e 455 *
mbed_official 610:813dcc80987e 456 @verbatim
mbed_official 610:813dcc80987e 457 ==============================================================================
mbed_official 610:813dcc80987e 458 ##### Channel operation functions #####
mbed_official 610:813dcc80987e 459 ==============================================================================
mbed_official 610:813dcc80987e 460 [..] This section provides functions allowing to:
mbed_official 610:813dcc80987e 461 (+) Manage clock absence detector feature.
mbed_official 610:813dcc80987e 462 (+) Manage short circuit detector feature.
mbed_official 610:813dcc80987e 463 (+) Get analog watchdog value.
mbed_official 610:813dcc80987e 464 (+) Modify offset value.
mbed_official 610:813dcc80987e 465 @endverbatim
mbed_official 610:813dcc80987e 466 * @{
mbed_official 610:813dcc80987e 467 */
mbed_official 610:813dcc80987e 468
mbed_official 610:813dcc80987e 469 /**
mbed_official 610:813dcc80987e 470 * @brief This function allows to start clock absence detection in polling mode.
mbed_official 610:813dcc80987e 471 * @note Same mode has to be used for all channels.
mbed_official 610:813dcc80987e 472 * @note If clock is not available on this channel during 5 seconds,
mbed_official 610:813dcc80987e 473 * clock absence detection will not be activated and function
mbed_official 610:813dcc80987e 474 * will return HAL_TIMEOUT error.
mbed_official 610:813dcc80987e 475 * @param hdfsdm_channel : DFSDM channel handle.
mbed_official 610:813dcc80987e 476 * @retval HAL status
mbed_official 610:813dcc80987e 477 */
mbed_official 610:813dcc80987e 478 HAL_StatusTypeDef HAL_DFSDM_ChannelCkabStart(DFSDM_Channel_HandleTypeDef *hdfsdm_channel)
mbed_official 610:813dcc80987e 479 {
mbed_official 610:813dcc80987e 480 HAL_StatusTypeDef status = HAL_OK;
mbed_official 610:813dcc80987e 481 uint32_t channel;
mbed_official 610:813dcc80987e 482 uint32_t tickstart;
mbed_official 610:813dcc80987e 483
mbed_official 610:813dcc80987e 484 /* Check parameters */
mbed_official 610:813dcc80987e 485 assert_param(IS_DFSDM_CHANNEL_ALL_INSTANCE(hdfsdm_channel->Instance));
mbed_official 610:813dcc80987e 486
mbed_official 610:813dcc80987e 487 /* Check DFSDM channel state */
mbed_official 610:813dcc80987e 488 if(hdfsdm_channel->State != HAL_DFSDM_CHANNEL_STATE_READY)
mbed_official 610:813dcc80987e 489 {
mbed_official 610:813dcc80987e 490 /* Return error status */
mbed_official 610:813dcc80987e 491 status = HAL_ERROR;
mbed_official 610:813dcc80987e 492 }
mbed_official 610:813dcc80987e 493 else
mbed_official 610:813dcc80987e 494 {
mbed_official 610:813dcc80987e 495 /* Get channel number from channel instance */
mbed_official 610:813dcc80987e 496 channel = DFSDM_GetChannelFromInstance(hdfsdm_channel->Instance);
mbed_official 610:813dcc80987e 497
mbed_official 610:813dcc80987e 498 /* Get timeout */
mbed_official 610:813dcc80987e 499 tickstart = HAL_GetTick();
mbed_official 610:813dcc80987e 500
mbed_official 610:813dcc80987e 501 /* Clear clock absence flag */
mbed_official 610:813dcc80987e 502 while((((DFSDM_Filter0->ISR & DFSDM_ISR_CKABF) >> (DFSDM_ISR_CKABF_OFFSET + channel)) & 1) != 0)
mbed_official 610:813dcc80987e 503 {
mbed_official 610:813dcc80987e 504 DFSDM_Filter0->ICR = (1 << (DFSDM_ICR_CLRCKABF_OFFSET + channel));
mbed_official 610:813dcc80987e 505
mbed_official 610:813dcc80987e 506 /* Check the Timeout */
mbed_official 610:813dcc80987e 507 if((HAL_GetTick()-tickstart) > DFSDM_CKAB_TIMEOUT)
mbed_official 610:813dcc80987e 508 {
mbed_official 610:813dcc80987e 509 /* Set timeout status */
mbed_official 610:813dcc80987e 510 status = HAL_TIMEOUT;
mbed_official 610:813dcc80987e 511 break;
mbed_official 610:813dcc80987e 512 }
mbed_official 610:813dcc80987e 513 }
mbed_official 610:813dcc80987e 514
mbed_official 610:813dcc80987e 515 if(status == HAL_OK)
mbed_official 610:813dcc80987e 516 {
mbed_official 610:813dcc80987e 517 /* Start clock absence detection */
mbed_official 610:813dcc80987e 518 hdfsdm_channel->Instance->CHCFGR1 |= DFSDM_CHCFGR1_CKABEN;
mbed_official 610:813dcc80987e 519 }
mbed_official 610:813dcc80987e 520 }
mbed_official 610:813dcc80987e 521 /* Return function status */
mbed_official 610:813dcc80987e 522 return status;
mbed_official 610:813dcc80987e 523 }
mbed_official 610:813dcc80987e 524
mbed_official 610:813dcc80987e 525 /**
mbed_official 610:813dcc80987e 526 * @brief This function allows to poll for the clock absence detection.
mbed_official 610:813dcc80987e 527 * @param hdfsdm_channel : DFSDM channel handle.
mbed_official 610:813dcc80987e 528 * @param Timeout : Timeout value in milliseconds.
mbed_official 610:813dcc80987e 529 * @retval HAL status
mbed_official 610:813dcc80987e 530 */
mbed_official 610:813dcc80987e 531 HAL_StatusTypeDef HAL_DFSDM_ChannelPollForCkab(DFSDM_Channel_HandleTypeDef *hdfsdm_channel,
mbed_official 610:813dcc80987e 532 uint32_t Timeout)
mbed_official 610:813dcc80987e 533 {
mbed_official 610:813dcc80987e 534 uint32_t tickstart;
mbed_official 610:813dcc80987e 535 uint32_t channel;
mbed_official 610:813dcc80987e 536
mbed_official 610:813dcc80987e 537 /* Check parameters */
mbed_official 610:813dcc80987e 538 assert_param(IS_DFSDM_CHANNEL_ALL_INSTANCE(hdfsdm_channel->Instance));
mbed_official 610:813dcc80987e 539
mbed_official 610:813dcc80987e 540 /* Check DFSDM channel state */
mbed_official 610:813dcc80987e 541 if(hdfsdm_channel->State != HAL_DFSDM_CHANNEL_STATE_READY)
mbed_official 610:813dcc80987e 542 {
mbed_official 610:813dcc80987e 543 /* Return error status */
mbed_official 610:813dcc80987e 544 return HAL_ERROR;
mbed_official 610:813dcc80987e 545 }
mbed_official 610:813dcc80987e 546 else
mbed_official 610:813dcc80987e 547 {
mbed_official 610:813dcc80987e 548 /* Get channel number from channel instance */
mbed_official 610:813dcc80987e 549 channel = DFSDM_GetChannelFromInstance(hdfsdm_channel->Instance);
mbed_official 610:813dcc80987e 550
mbed_official 610:813dcc80987e 551 /* Get timeout */
mbed_official 610:813dcc80987e 552 tickstart = HAL_GetTick();
mbed_official 610:813dcc80987e 553
mbed_official 610:813dcc80987e 554 /* Wait clock absence detection */
mbed_official 610:813dcc80987e 555 while((((DFSDM_Filter0->ISR & DFSDM_ISR_CKABF) >> (DFSDM_ISR_CKABF_OFFSET + channel)) & 1) == 0)
mbed_official 610:813dcc80987e 556 {
mbed_official 610:813dcc80987e 557 /* Check the Timeout */
mbed_official 610:813dcc80987e 558 if(Timeout != HAL_MAX_DELAY)
mbed_official 610:813dcc80987e 559 {
mbed_official 610:813dcc80987e 560 if((Timeout == 0) || ((HAL_GetTick()-tickstart) > Timeout))
mbed_official 610:813dcc80987e 561 {
mbed_official 610:813dcc80987e 562 /* Return timeout status */
mbed_official 610:813dcc80987e 563 return HAL_TIMEOUT;
mbed_official 610:813dcc80987e 564 }
mbed_official 610:813dcc80987e 565 }
mbed_official 610:813dcc80987e 566 }
mbed_official 610:813dcc80987e 567
mbed_official 610:813dcc80987e 568 /* Clear clock absence detection flag */
mbed_official 610:813dcc80987e 569 DFSDM_Filter0->ICR = (1 << (DFSDM_ICR_CLRCKABF_OFFSET + channel));
mbed_official 610:813dcc80987e 570
mbed_official 610:813dcc80987e 571 /* Return function status */
mbed_official 610:813dcc80987e 572 return HAL_OK;
mbed_official 610:813dcc80987e 573 }
mbed_official 610:813dcc80987e 574 }
mbed_official 610:813dcc80987e 575
mbed_official 610:813dcc80987e 576 /**
mbed_official 610:813dcc80987e 577 * @brief This function allows to stop clock absence detection in polling mode.
mbed_official 610:813dcc80987e 578 * @param hdfsdm_channel : DFSDM channel handle.
mbed_official 610:813dcc80987e 579 * @retval HAL status
mbed_official 610:813dcc80987e 580 */
mbed_official 610:813dcc80987e 581 HAL_StatusTypeDef HAL_DFSDM_ChannelCkabStop(DFSDM_Channel_HandleTypeDef *hdfsdm_channel)
mbed_official 610:813dcc80987e 582 {
mbed_official 610:813dcc80987e 583 HAL_StatusTypeDef status = HAL_OK;
mbed_official 610:813dcc80987e 584 uint32_t channel;
mbed_official 610:813dcc80987e 585
mbed_official 610:813dcc80987e 586 /* Check parameters */
mbed_official 610:813dcc80987e 587 assert_param(IS_DFSDM_CHANNEL_ALL_INSTANCE(hdfsdm_channel->Instance));
mbed_official 610:813dcc80987e 588
mbed_official 610:813dcc80987e 589 /* Check DFSDM channel state */
mbed_official 610:813dcc80987e 590 if(hdfsdm_channel->State != HAL_DFSDM_CHANNEL_STATE_READY)
mbed_official 610:813dcc80987e 591 {
mbed_official 610:813dcc80987e 592 /* Return error status */
mbed_official 610:813dcc80987e 593 status = HAL_ERROR;
mbed_official 610:813dcc80987e 594 }
mbed_official 610:813dcc80987e 595 else
mbed_official 610:813dcc80987e 596 {
mbed_official 610:813dcc80987e 597 /* Stop clock absence detection */
mbed_official 610:813dcc80987e 598 hdfsdm_channel->Instance->CHCFGR1 &= ~(DFSDM_CHCFGR1_CKABEN);
mbed_official 610:813dcc80987e 599
mbed_official 610:813dcc80987e 600 /* Clear clock absence flag */
mbed_official 610:813dcc80987e 601 channel = DFSDM_GetChannelFromInstance(hdfsdm_channel->Instance);
mbed_official 610:813dcc80987e 602 DFSDM_Filter0->ICR = (1 << (DFSDM_ICR_CLRCKABF_OFFSET + channel));
mbed_official 610:813dcc80987e 603 }
mbed_official 610:813dcc80987e 604 /* Return function status */
mbed_official 610:813dcc80987e 605 return status;
mbed_official 610:813dcc80987e 606 }
mbed_official 610:813dcc80987e 607
mbed_official 610:813dcc80987e 608 /**
mbed_official 610:813dcc80987e 609 * @brief This function allows to start clock absence detection in interrupt mode.
mbed_official 610:813dcc80987e 610 * @note Same mode has to be used for all channels.
mbed_official 610:813dcc80987e 611 * @note If clock is not available on this channel during 5 seconds,
mbed_official 610:813dcc80987e 612 * clock absence detection will not be activated and function
mbed_official 610:813dcc80987e 613 * will return HAL_TIMEOUT error.
mbed_official 610:813dcc80987e 614 * @param hdfsdm_channel : DFSDM channel handle.
mbed_official 610:813dcc80987e 615 * @retval HAL status
mbed_official 610:813dcc80987e 616 */
mbed_official 610:813dcc80987e 617 HAL_StatusTypeDef HAL_DFSDM_ChannelCkabStart_IT(DFSDM_Channel_HandleTypeDef *hdfsdm_channel)
mbed_official 610:813dcc80987e 618 {
mbed_official 610:813dcc80987e 619 HAL_StatusTypeDef status = HAL_OK;
mbed_official 610:813dcc80987e 620 uint32_t channel;
mbed_official 610:813dcc80987e 621 uint32_t tickstart;
mbed_official 610:813dcc80987e 622
mbed_official 610:813dcc80987e 623 /* Check parameters */
mbed_official 610:813dcc80987e 624 assert_param(IS_DFSDM_CHANNEL_ALL_INSTANCE(hdfsdm_channel->Instance));
mbed_official 610:813dcc80987e 625
mbed_official 610:813dcc80987e 626 /* Check DFSDM channel state */
mbed_official 610:813dcc80987e 627 if(hdfsdm_channel->State != HAL_DFSDM_CHANNEL_STATE_READY)
mbed_official 610:813dcc80987e 628 {
mbed_official 610:813dcc80987e 629 /* Return error status */
mbed_official 610:813dcc80987e 630 status = HAL_ERROR;
mbed_official 610:813dcc80987e 631 }
mbed_official 610:813dcc80987e 632 else
mbed_official 610:813dcc80987e 633 {
mbed_official 610:813dcc80987e 634 /* Get channel number from channel instance */
mbed_official 610:813dcc80987e 635 channel = DFSDM_GetChannelFromInstance(hdfsdm_channel->Instance);
mbed_official 610:813dcc80987e 636
mbed_official 610:813dcc80987e 637 /* Get timeout */
mbed_official 610:813dcc80987e 638 tickstart = HAL_GetTick();
mbed_official 610:813dcc80987e 639
mbed_official 610:813dcc80987e 640 /* Clear clock absence flag */
mbed_official 610:813dcc80987e 641 while((((DFSDM_Filter0->ISR & DFSDM_ISR_CKABF) >> (DFSDM_ISR_CKABF_OFFSET + channel)) & 1) != 0)
mbed_official 610:813dcc80987e 642 {
mbed_official 610:813dcc80987e 643 DFSDM_Filter0->ICR = (1 << (DFSDM_ICR_CLRCKABF_OFFSET + channel));
mbed_official 610:813dcc80987e 644
mbed_official 610:813dcc80987e 645 /* Check the Timeout */
mbed_official 610:813dcc80987e 646 if((HAL_GetTick()-tickstart) > DFSDM_CKAB_TIMEOUT)
mbed_official 610:813dcc80987e 647 {
mbed_official 610:813dcc80987e 648 /* Set timeout status */
mbed_official 610:813dcc80987e 649 status = HAL_TIMEOUT;
mbed_official 610:813dcc80987e 650 break;
mbed_official 610:813dcc80987e 651 }
mbed_official 610:813dcc80987e 652 }
mbed_official 610:813dcc80987e 653
mbed_official 610:813dcc80987e 654 if(status == HAL_OK)
mbed_official 610:813dcc80987e 655 {
mbed_official 610:813dcc80987e 656 /* Activate clock absence detection interrupt */
mbed_official 610:813dcc80987e 657 DFSDM_Filter0->CR2 |= DFSDM_CR2_CKABIE;
mbed_official 610:813dcc80987e 658
mbed_official 610:813dcc80987e 659 /* Start clock absence detection */
mbed_official 610:813dcc80987e 660 hdfsdm_channel->Instance->CHCFGR1 |= DFSDM_CHCFGR1_CKABEN;
mbed_official 610:813dcc80987e 661 }
mbed_official 610:813dcc80987e 662 }
mbed_official 610:813dcc80987e 663 /* Return function status */
mbed_official 610:813dcc80987e 664 return status;
mbed_official 610:813dcc80987e 665 }
mbed_official 610:813dcc80987e 666
mbed_official 610:813dcc80987e 667 /**
mbed_official 610:813dcc80987e 668 * @brief Clock absence detection callback.
mbed_official 610:813dcc80987e 669 * @param hdfsdm_channel : DFSDM channel handle.
mbed_official 610:813dcc80987e 670 * @retval None
mbed_official 610:813dcc80987e 671 */
mbed_official 610:813dcc80987e 672 __weak void HAL_DFSDM_ChannelCkabCallback(DFSDM_Channel_HandleTypeDef *hdfsdm_channel)
mbed_official 610:813dcc80987e 673 {
mbed_official 610:813dcc80987e 674 /* NOTE : This function should not be modified, when the callback is needed,
mbed_official 610:813dcc80987e 675 the HAL_DFSDM_ChannelCkabCallback could be implemented in the user file
mbed_official 610:813dcc80987e 676 */
mbed_official 610:813dcc80987e 677 }
mbed_official 610:813dcc80987e 678
mbed_official 610:813dcc80987e 679 /**
mbed_official 610:813dcc80987e 680 * @brief This function allows to stop clock absence detection in interrupt mode.
mbed_official 610:813dcc80987e 681 * @note Interrupt will be disabled for all channels
mbed_official 610:813dcc80987e 682 * @param hdfsdm_channel : DFSDM channel handle.
mbed_official 610:813dcc80987e 683 * @retval HAL status
mbed_official 610:813dcc80987e 684 */
mbed_official 610:813dcc80987e 685 HAL_StatusTypeDef HAL_DFSDM_ChannelCkabStop_IT(DFSDM_Channel_HandleTypeDef *hdfsdm_channel)
mbed_official 610:813dcc80987e 686 {
mbed_official 610:813dcc80987e 687 HAL_StatusTypeDef status = HAL_OK;
mbed_official 610:813dcc80987e 688 uint32_t channel;
mbed_official 610:813dcc80987e 689
mbed_official 610:813dcc80987e 690 /* Check parameters */
mbed_official 610:813dcc80987e 691 assert_param(IS_DFSDM_CHANNEL_ALL_INSTANCE(hdfsdm_channel->Instance));
mbed_official 610:813dcc80987e 692
mbed_official 610:813dcc80987e 693 /* Check DFSDM channel state */
mbed_official 610:813dcc80987e 694 if(hdfsdm_channel->State != HAL_DFSDM_CHANNEL_STATE_READY)
mbed_official 610:813dcc80987e 695 {
mbed_official 610:813dcc80987e 696 /* Return error status */
mbed_official 610:813dcc80987e 697 status = HAL_ERROR;
mbed_official 610:813dcc80987e 698 }
mbed_official 610:813dcc80987e 699 else
mbed_official 610:813dcc80987e 700 {
mbed_official 610:813dcc80987e 701 /* Stop clock absence detection */
mbed_official 610:813dcc80987e 702 hdfsdm_channel->Instance->CHCFGR1 &= ~(DFSDM_CHCFGR1_CKABEN);
mbed_official 610:813dcc80987e 703
mbed_official 610:813dcc80987e 704 /* Clear clock absence flag */
mbed_official 610:813dcc80987e 705 channel = DFSDM_GetChannelFromInstance(hdfsdm_channel->Instance);
mbed_official 610:813dcc80987e 706 DFSDM_Filter0->ICR = (1 << (DFSDM_ICR_CLRCKABF_OFFSET + channel));
mbed_official 610:813dcc80987e 707
mbed_official 610:813dcc80987e 708 /* Disable clock absence detection interrupt */
mbed_official 610:813dcc80987e 709 DFSDM_Filter0->CR2 &= ~(DFSDM_CR2_CKABIE);
mbed_official 610:813dcc80987e 710 }
mbed_official 610:813dcc80987e 711 /* Return function status */
mbed_official 610:813dcc80987e 712 return status;
mbed_official 610:813dcc80987e 713 }
mbed_official 610:813dcc80987e 714
mbed_official 610:813dcc80987e 715 /**
mbed_official 610:813dcc80987e 716 * @brief This function allows to start short circuit detection in polling mode.
mbed_official 610:813dcc80987e 717 * @note Same mode has to be used for all channels
mbed_official 610:813dcc80987e 718 * @param hdfsdm_channel : DFSDM channel handle.
mbed_official 610:813dcc80987e 719 * @param Threshold : Short circuit detector threshold.
mbed_official 610:813dcc80987e 720 * This parameter must be a number between Min_Data = 0 and Max_Data = 255.
mbed_official 610:813dcc80987e 721 * @param BreakSignal : Break signals assigned to short circuit event.
mbed_official 610:813dcc80987e 722 * This parameter can be a values combination of @ref DFSDM_BreakSignals.
mbed_official 610:813dcc80987e 723 * @retval HAL status
mbed_official 610:813dcc80987e 724 */
mbed_official 610:813dcc80987e 725 HAL_StatusTypeDef HAL_DFSDM_ChannelScdStart(DFSDM_Channel_HandleTypeDef *hdfsdm_channel,
mbed_official 610:813dcc80987e 726 uint32_t Threshold,
mbed_official 610:813dcc80987e 727 uint32_t BreakSignal)
mbed_official 610:813dcc80987e 728 {
mbed_official 610:813dcc80987e 729 HAL_StatusTypeDef status = HAL_OK;
mbed_official 610:813dcc80987e 730
mbed_official 610:813dcc80987e 731 /* Check parameters */
mbed_official 610:813dcc80987e 732 assert_param(IS_DFSDM_CHANNEL_ALL_INSTANCE(hdfsdm_channel->Instance));
mbed_official 610:813dcc80987e 733 assert_param(IS_DFSDM_CHANNEL_SCD_THRESHOLD(Threshold));
mbed_official 610:813dcc80987e 734 assert_param(IS_DFSDM_BREAK_SIGNALS(BreakSignal));
mbed_official 610:813dcc80987e 735
mbed_official 610:813dcc80987e 736 /* Check DFSDM channel state */
mbed_official 610:813dcc80987e 737 if(hdfsdm_channel->State != HAL_DFSDM_CHANNEL_STATE_READY)
mbed_official 610:813dcc80987e 738 {
mbed_official 610:813dcc80987e 739 /* Return error status */
mbed_official 610:813dcc80987e 740 status = HAL_ERROR;
mbed_official 610:813dcc80987e 741 }
mbed_official 610:813dcc80987e 742 else
mbed_official 610:813dcc80987e 743 {
mbed_official 610:813dcc80987e 744 /* Configure threshold and break signals */
mbed_official 610:813dcc80987e 745 hdfsdm_channel->Instance->AWSCDR &= ~(DFSDM_AWSCDR_BKSCD | DFSDM_AWSCDR_SCDT);
mbed_official 610:813dcc80987e 746 hdfsdm_channel->Instance->AWSCDR |= ((BreakSignal << DFSDM_AWSCDR_BKSCD_OFFSET) | \
mbed_official 610:813dcc80987e 747 Threshold);
mbed_official 610:813dcc80987e 748
mbed_official 610:813dcc80987e 749 /* Start short circuit detection */
mbed_official 610:813dcc80987e 750 hdfsdm_channel->Instance->CHCFGR1 |= DFSDM_CHCFGR1_SCDEN;
mbed_official 610:813dcc80987e 751 }
mbed_official 610:813dcc80987e 752 /* Return function status */
mbed_official 610:813dcc80987e 753 return status;
mbed_official 610:813dcc80987e 754 }
mbed_official 610:813dcc80987e 755
mbed_official 610:813dcc80987e 756 /**
mbed_official 610:813dcc80987e 757 * @brief This function allows to poll for the short circuit detection.
mbed_official 610:813dcc80987e 758 * @param hdfsdm_channel : DFSDM channel handle.
mbed_official 610:813dcc80987e 759 * @param Timeout : Timeout value in milliseconds.
mbed_official 610:813dcc80987e 760 * @retval HAL status
mbed_official 610:813dcc80987e 761 */
mbed_official 610:813dcc80987e 762 HAL_StatusTypeDef HAL_DFSDM_ChannelPollForScd(DFSDM_Channel_HandleTypeDef *hdfsdm_channel,
mbed_official 610:813dcc80987e 763 uint32_t Timeout)
mbed_official 610:813dcc80987e 764 {
mbed_official 610:813dcc80987e 765 uint32_t tickstart;
mbed_official 610:813dcc80987e 766 uint32_t channel;
mbed_official 610:813dcc80987e 767
mbed_official 610:813dcc80987e 768 /* Check parameters */
mbed_official 610:813dcc80987e 769 assert_param(IS_DFSDM_CHANNEL_ALL_INSTANCE(hdfsdm_channel->Instance));
mbed_official 610:813dcc80987e 770
mbed_official 610:813dcc80987e 771 /* Check DFSDM channel state */
mbed_official 610:813dcc80987e 772 if(hdfsdm_channel->State != HAL_DFSDM_CHANNEL_STATE_READY)
mbed_official 610:813dcc80987e 773 {
mbed_official 610:813dcc80987e 774 /* Return error status */
mbed_official 610:813dcc80987e 775 return HAL_ERROR;
mbed_official 610:813dcc80987e 776 }
mbed_official 610:813dcc80987e 777 else
mbed_official 610:813dcc80987e 778 {
mbed_official 610:813dcc80987e 779 /* Get channel number from channel instance */
mbed_official 610:813dcc80987e 780 channel = DFSDM_GetChannelFromInstance(hdfsdm_channel->Instance);
mbed_official 610:813dcc80987e 781
mbed_official 610:813dcc80987e 782 /* Get timeout */
mbed_official 610:813dcc80987e 783 tickstart = HAL_GetTick();
mbed_official 610:813dcc80987e 784
mbed_official 610:813dcc80987e 785 /* Wait short circuit detection */
mbed_official 610:813dcc80987e 786 while(((DFSDM_Filter0->ISR & DFSDM_ISR_SCDF) >> (DFSDM_ISR_SCDF_OFFSET + channel)) == 0)
mbed_official 610:813dcc80987e 787 {
mbed_official 610:813dcc80987e 788 /* Check the Timeout */
mbed_official 610:813dcc80987e 789 if(Timeout != HAL_MAX_DELAY)
mbed_official 610:813dcc80987e 790 {
mbed_official 610:813dcc80987e 791 if((Timeout == 0) || ((HAL_GetTick()-tickstart) > Timeout))
mbed_official 610:813dcc80987e 792 {
mbed_official 610:813dcc80987e 793 /* Return timeout status */
mbed_official 610:813dcc80987e 794 return HAL_TIMEOUT;
mbed_official 610:813dcc80987e 795 }
mbed_official 610:813dcc80987e 796 }
mbed_official 610:813dcc80987e 797 }
mbed_official 610:813dcc80987e 798
mbed_official 610:813dcc80987e 799 /* Clear short circuit detection flag */
mbed_official 610:813dcc80987e 800 DFSDM_Filter0->ICR = (1 << (DFSDM_ICR_CLRSCDF_OFFSET + channel));
mbed_official 610:813dcc80987e 801
mbed_official 610:813dcc80987e 802 /* Return function status */
mbed_official 610:813dcc80987e 803 return HAL_OK;
mbed_official 610:813dcc80987e 804 }
mbed_official 610:813dcc80987e 805 }
mbed_official 610:813dcc80987e 806
mbed_official 610:813dcc80987e 807 /**
mbed_official 610:813dcc80987e 808 * @brief This function allows to stop short circuit detection in polling mode.
mbed_official 610:813dcc80987e 809 * @param hdfsdm_channel : DFSDM channel handle.
mbed_official 610:813dcc80987e 810 * @retval HAL status
mbed_official 610:813dcc80987e 811 */
mbed_official 610:813dcc80987e 812 HAL_StatusTypeDef HAL_DFSDM_ChannelScdStop(DFSDM_Channel_HandleTypeDef *hdfsdm_channel)
mbed_official 610:813dcc80987e 813 {
mbed_official 610:813dcc80987e 814 HAL_StatusTypeDef status = HAL_OK;
mbed_official 610:813dcc80987e 815 uint32_t channel;
mbed_official 610:813dcc80987e 816
mbed_official 610:813dcc80987e 817 /* Check parameters */
mbed_official 610:813dcc80987e 818 assert_param(IS_DFSDM_CHANNEL_ALL_INSTANCE(hdfsdm_channel->Instance));
mbed_official 610:813dcc80987e 819
mbed_official 610:813dcc80987e 820 /* Check DFSDM channel state */
mbed_official 610:813dcc80987e 821 if(hdfsdm_channel->State != HAL_DFSDM_CHANNEL_STATE_READY)
mbed_official 610:813dcc80987e 822 {
mbed_official 610:813dcc80987e 823 /* Return error status */
mbed_official 610:813dcc80987e 824 status = HAL_ERROR;
mbed_official 610:813dcc80987e 825 }
mbed_official 610:813dcc80987e 826 else
mbed_official 610:813dcc80987e 827 {
mbed_official 610:813dcc80987e 828 /* Stop short circuit detection */
mbed_official 610:813dcc80987e 829 hdfsdm_channel->Instance->CHCFGR1 &= ~(DFSDM_CHCFGR1_SCDEN);
mbed_official 610:813dcc80987e 830
mbed_official 610:813dcc80987e 831 /* Clear short circuit detection flag */
mbed_official 610:813dcc80987e 832 channel = DFSDM_GetChannelFromInstance(hdfsdm_channel->Instance);
mbed_official 610:813dcc80987e 833 DFSDM_Filter0->ICR = (1 << (DFSDM_ICR_CLRSCDF_OFFSET + channel));
mbed_official 610:813dcc80987e 834 }
mbed_official 610:813dcc80987e 835 /* Return function status */
mbed_official 610:813dcc80987e 836 return status;
mbed_official 610:813dcc80987e 837 }
mbed_official 610:813dcc80987e 838
mbed_official 610:813dcc80987e 839 /**
mbed_official 610:813dcc80987e 840 * @brief This function allows to start short circuit detection in interrupt mode.
mbed_official 610:813dcc80987e 841 * @note Same mode has to be used for all channels
mbed_official 610:813dcc80987e 842 * @param hdfsdm_channel : DFSDM channel handle.
mbed_official 610:813dcc80987e 843 * @param Threshold : Short circuit detector threshold.
mbed_official 610:813dcc80987e 844 * This parameter must be a number between Min_Data = 0 and Max_Data = 255.
mbed_official 610:813dcc80987e 845 * @param BreakSignal : Break signals assigned to short circuit event.
mbed_official 610:813dcc80987e 846 * This parameter can be a values combination of @ref DFSDM_BreakSignals.
mbed_official 610:813dcc80987e 847 * @retval HAL status
mbed_official 610:813dcc80987e 848 */
mbed_official 610:813dcc80987e 849 HAL_StatusTypeDef HAL_DFSDM_ChannelScdStart_IT(DFSDM_Channel_HandleTypeDef *hdfsdm_channel,
mbed_official 610:813dcc80987e 850 uint32_t Threshold,
mbed_official 610:813dcc80987e 851 uint32_t BreakSignal)
mbed_official 610:813dcc80987e 852 {
mbed_official 610:813dcc80987e 853 HAL_StatusTypeDef status = HAL_OK;
mbed_official 610:813dcc80987e 854
mbed_official 610:813dcc80987e 855 /* Check parameters */
mbed_official 610:813dcc80987e 856 assert_param(IS_DFSDM_CHANNEL_ALL_INSTANCE(hdfsdm_channel->Instance));
mbed_official 610:813dcc80987e 857 assert_param(IS_DFSDM_CHANNEL_SCD_THRESHOLD(Threshold));
mbed_official 610:813dcc80987e 858 assert_param(IS_DFSDM_BREAK_SIGNALS(BreakSignal));
mbed_official 610:813dcc80987e 859
mbed_official 610:813dcc80987e 860 /* Check DFSDM channel state */
mbed_official 610:813dcc80987e 861 if(hdfsdm_channel->State != HAL_DFSDM_CHANNEL_STATE_READY)
mbed_official 610:813dcc80987e 862 {
mbed_official 610:813dcc80987e 863 /* Return error status */
mbed_official 610:813dcc80987e 864 status = HAL_ERROR;
mbed_official 610:813dcc80987e 865 }
mbed_official 610:813dcc80987e 866 else
mbed_official 610:813dcc80987e 867 {
mbed_official 610:813dcc80987e 868 /* Activate short circuit detection interrupt */
mbed_official 610:813dcc80987e 869 DFSDM_Filter0->CR2 |= DFSDM_CR2_SCDIE;
mbed_official 610:813dcc80987e 870
mbed_official 610:813dcc80987e 871 /* Configure threshold and break signals */
mbed_official 610:813dcc80987e 872 hdfsdm_channel->Instance->AWSCDR &= ~(DFSDM_AWSCDR_BKSCD | DFSDM_AWSCDR_SCDT);
mbed_official 610:813dcc80987e 873 hdfsdm_channel->Instance->AWSCDR |= ((BreakSignal << DFSDM_AWSCDR_BKSCD_OFFSET) | \
mbed_official 610:813dcc80987e 874 Threshold);
mbed_official 610:813dcc80987e 875
mbed_official 610:813dcc80987e 876 /* Start short circuit detection */
mbed_official 610:813dcc80987e 877 hdfsdm_channel->Instance->CHCFGR1 |= DFSDM_CHCFGR1_SCDEN;
mbed_official 610:813dcc80987e 878 }
mbed_official 610:813dcc80987e 879 /* Return function status */
mbed_official 610:813dcc80987e 880 return status;
mbed_official 610:813dcc80987e 881 }
mbed_official 610:813dcc80987e 882
mbed_official 610:813dcc80987e 883 /**
mbed_official 610:813dcc80987e 884 * @brief Short circuit detection callback.
mbed_official 610:813dcc80987e 885 * @param hdfsdm_channel : DFSDM channel handle.
mbed_official 610:813dcc80987e 886 * @retval None
mbed_official 610:813dcc80987e 887 */
mbed_official 610:813dcc80987e 888 __weak void HAL_DFSDM_ChannelScdCallback(DFSDM_Channel_HandleTypeDef *hdfsdm_channel)
mbed_official 610:813dcc80987e 889 {
mbed_official 610:813dcc80987e 890 /* NOTE : This function should not be modified, when the callback is needed,
mbed_official 610:813dcc80987e 891 the HAL_DFSDM_ChannelScdCallback could be implemented in the user file
mbed_official 610:813dcc80987e 892 */
mbed_official 610:813dcc80987e 893 }
mbed_official 610:813dcc80987e 894
mbed_official 610:813dcc80987e 895 /**
mbed_official 610:813dcc80987e 896 * @brief This function allows to stop short circuit detection in interrupt mode.
mbed_official 610:813dcc80987e 897 * @note Interrupt will be disabled for all channels
mbed_official 610:813dcc80987e 898 * @param hdfsdm_channel : DFSDM channel handle.
mbed_official 610:813dcc80987e 899 * @retval HAL status
mbed_official 610:813dcc80987e 900 */
mbed_official 610:813dcc80987e 901 HAL_StatusTypeDef HAL_DFSDM_ChannelScdStop_IT(DFSDM_Channel_HandleTypeDef *hdfsdm_channel)
mbed_official 610:813dcc80987e 902 {
mbed_official 610:813dcc80987e 903 HAL_StatusTypeDef status = HAL_OK;
mbed_official 610:813dcc80987e 904 uint32_t channel;
mbed_official 610:813dcc80987e 905
mbed_official 610:813dcc80987e 906 /* Check parameters */
mbed_official 610:813dcc80987e 907 assert_param(IS_DFSDM_CHANNEL_ALL_INSTANCE(hdfsdm_channel->Instance));
mbed_official 610:813dcc80987e 908
mbed_official 610:813dcc80987e 909 /* Check DFSDM channel state */
mbed_official 610:813dcc80987e 910 if(hdfsdm_channel->State != HAL_DFSDM_CHANNEL_STATE_READY)
mbed_official 610:813dcc80987e 911 {
mbed_official 610:813dcc80987e 912 /* Return error status */
mbed_official 610:813dcc80987e 913 status = HAL_ERROR;
mbed_official 610:813dcc80987e 914 }
mbed_official 610:813dcc80987e 915 else
mbed_official 610:813dcc80987e 916 {
mbed_official 610:813dcc80987e 917 /* Stop short circuit detection */
mbed_official 610:813dcc80987e 918 hdfsdm_channel->Instance->CHCFGR1 &= ~(DFSDM_CHCFGR1_SCDEN);
mbed_official 610:813dcc80987e 919
mbed_official 610:813dcc80987e 920 /* Clear short circuit detection flag */
mbed_official 610:813dcc80987e 921 channel = DFSDM_GetChannelFromInstance(hdfsdm_channel->Instance);
mbed_official 610:813dcc80987e 922 DFSDM_Filter0->ICR = (1 << (DFSDM_ICR_CLRSCDF_OFFSET + channel));
mbed_official 610:813dcc80987e 923
mbed_official 610:813dcc80987e 924 /* Disable short circuit detection interrupt */
mbed_official 610:813dcc80987e 925 DFSDM_Filter0->CR2 &= ~(DFSDM_CR2_SCDIE);
mbed_official 610:813dcc80987e 926 }
mbed_official 610:813dcc80987e 927 /* Return function status */
mbed_official 610:813dcc80987e 928 return status;
mbed_official 610:813dcc80987e 929 }
mbed_official 610:813dcc80987e 930
mbed_official 610:813dcc80987e 931 /**
mbed_official 610:813dcc80987e 932 * @brief This function allows to get channel analog watchdog value.
mbed_official 610:813dcc80987e 933 * @param hdfsdm_channel : DFSDM channel handle.
mbed_official 610:813dcc80987e 934 * @retval Channel analog watchdog value.
mbed_official 610:813dcc80987e 935 */
mbed_official 610:813dcc80987e 936 int16_t HAL_DFSDM_ChannelGetAwdValue(DFSDM_Channel_HandleTypeDef *hdfsdm_channel)
mbed_official 610:813dcc80987e 937 {
mbed_official 610:813dcc80987e 938 return (int16_t) hdfsdm_channel->Instance->CHWDATAR;
mbed_official 610:813dcc80987e 939 }
mbed_official 610:813dcc80987e 940
mbed_official 610:813dcc80987e 941 /**
mbed_official 610:813dcc80987e 942 * @brief This function allows to modify channel offset value.
mbed_official 610:813dcc80987e 943 * @param hdfsdm_channel : DFSDM channel handle.
mbed_official 610:813dcc80987e 944 * @param Offset : DFSDM channel offset.
mbed_official 610:813dcc80987e 945 * This parameter must be a number between Min_Data = -8388608 and Max_Data = 8388607.
mbed_official 610:813dcc80987e 946 * @retval HAL status.
mbed_official 610:813dcc80987e 947 */
mbed_official 610:813dcc80987e 948 HAL_StatusTypeDef HAL_DFSDM_ChannelModifyOffset(DFSDM_Channel_HandleTypeDef *hdfsdm_channel,
mbed_official 610:813dcc80987e 949 int32_t Offset)
mbed_official 610:813dcc80987e 950 {
mbed_official 610:813dcc80987e 951 HAL_StatusTypeDef status = HAL_OK;
mbed_official 610:813dcc80987e 952
mbed_official 610:813dcc80987e 953 /* Check parameters */
mbed_official 610:813dcc80987e 954 assert_param(IS_DFSDM_CHANNEL_ALL_INSTANCE(hdfsdm_channel->Instance));
mbed_official 610:813dcc80987e 955 assert_param(IS_DFSDM_CHANNEL_OFFSET(Offset));
mbed_official 610:813dcc80987e 956
mbed_official 610:813dcc80987e 957 /* Check DFSDM channel state */
mbed_official 610:813dcc80987e 958 if(hdfsdm_channel->State != HAL_DFSDM_CHANNEL_STATE_READY)
mbed_official 610:813dcc80987e 959 {
mbed_official 610:813dcc80987e 960 /* Return error status */
mbed_official 610:813dcc80987e 961 status = HAL_ERROR;
mbed_official 610:813dcc80987e 962 }
mbed_official 610:813dcc80987e 963 else
mbed_official 610:813dcc80987e 964 {
mbed_official 610:813dcc80987e 965 /* Modify channel offset */
mbed_official 610:813dcc80987e 966 hdfsdm_channel->Instance->CHCFGR2 &= ~(DFSDM_CHCFGR2_OFFSET);
mbed_official 610:813dcc80987e 967 hdfsdm_channel->Instance->CHCFGR2 |= (Offset << DFSDM_CHCFGR2_OFFSET_OFFSET);
mbed_official 610:813dcc80987e 968 }
mbed_official 610:813dcc80987e 969 /* Return function status */
mbed_official 610:813dcc80987e 970 return status;
mbed_official 610:813dcc80987e 971 }
mbed_official 610:813dcc80987e 972
mbed_official 610:813dcc80987e 973 /**
mbed_official 610:813dcc80987e 974 * @}
mbed_official 610:813dcc80987e 975 */
mbed_official 610:813dcc80987e 976
mbed_official 610:813dcc80987e 977 /** @defgroup DFSDM_Exported_Functions_Group3_Channel Channel state function
mbed_official 610:813dcc80987e 978 * @brief Channel state function
mbed_official 610:813dcc80987e 979 *
mbed_official 610:813dcc80987e 980 @verbatim
mbed_official 610:813dcc80987e 981 ==============================================================================
mbed_official 610:813dcc80987e 982 ##### Channel state function #####
mbed_official 610:813dcc80987e 983 ==============================================================================
mbed_official 610:813dcc80987e 984 [..] This section provides function allowing to:
mbed_official 610:813dcc80987e 985 (+) Get channel handle state.
mbed_official 610:813dcc80987e 986 @endverbatim
mbed_official 610:813dcc80987e 987 * @{
mbed_official 610:813dcc80987e 988 */
mbed_official 610:813dcc80987e 989
mbed_official 610:813dcc80987e 990 /**
mbed_official 610:813dcc80987e 991 * @brief This function allows to get the current DFSDM channel handle state.
mbed_official 610:813dcc80987e 992 * @param hdfsdm_channel : DFSDM channel handle.
mbed_official 610:813dcc80987e 993 * @retval DFSDM channel state.
mbed_official 610:813dcc80987e 994 */
mbed_official 610:813dcc80987e 995 HAL_DFSDM_Channel_StateTypeDef HAL_DFSDM_ChannelGetState(DFSDM_Channel_HandleTypeDef *hdfsdm_channel)
mbed_official 610:813dcc80987e 996 {
mbed_official 610:813dcc80987e 997 /* Return DFSDM channel handle state */
mbed_official 610:813dcc80987e 998 return hdfsdm_channel->State;
mbed_official 610:813dcc80987e 999 }
mbed_official 610:813dcc80987e 1000
mbed_official 610:813dcc80987e 1001 /**
mbed_official 610:813dcc80987e 1002 * @}
mbed_official 610:813dcc80987e 1003 */
mbed_official 610:813dcc80987e 1004
mbed_official 610:813dcc80987e 1005 /** @defgroup DFSDM_Exported_Functions_Group1_Filter Filter initialization and de-initialization functions
mbed_official 610:813dcc80987e 1006 * @brief Filter initialization and de-initialization functions
mbed_official 610:813dcc80987e 1007 *
mbed_official 610:813dcc80987e 1008 @verbatim
mbed_official 610:813dcc80987e 1009 ==============================================================================
mbed_official 610:813dcc80987e 1010 ##### Filter initialization and de-initialization functions #####
mbed_official 610:813dcc80987e 1011 ==============================================================================
mbed_official 610:813dcc80987e 1012 [..] This section provides functions allowing to:
mbed_official 610:813dcc80987e 1013 (+) Initialize the DFSDM filter.
mbed_official 610:813dcc80987e 1014 (+) De-initialize the DFSDM filter.
mbed_official 610:813dcc80987e 1015 @endverbatim
mbed_official 610:813dcc80987e 1016 * @{
mbed_official 610:813dcc80987e 1017 */
mbed_official 610:813dcc80987e 1018
mbed_official 610:813dcc80987e 1019 /**
mbed_official 610:813dcc80987e 1020 * @brief Initialize the DFSDM filter according to the specified parameters
mbed_official 610:813dcc80987e 1021 * in the DFSDM_FilterInitTypeDef structure and initialize the associated handle.
mbed_official 610:813dcc80987e 1022 * @param hdfsdm_filter : DFSDM filter handle.
mbed_official 610:813dcc80987e 1023 * @retval HAL status.
mbed_official 610:813dcc80987e 1024 */
mbed_official 610:813dcc80987e 1025 HAL_StatusTypeDef HAL_DFSDM_FilterInit(DFSDM_Filter_HandleTypeDef *hdfsdm_filter)
mbed_official 610:813dcc80987e 1026 {
mbed_official 610:813dcc80987e 1027 /* Check parameters */
mbed_official 610:813dcc80987e 1028 assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
mbed_official 610:813dcc80987e 1029 assert_param(IS_DFSDM_FILTER_REG_TRIGGER(hdfsdm_filter->Init.RegularParam.Trigger));
mbed_official 610:813dcc80987e 1030 assert_param(IS_FUNCTIONAL_STATE(hdfsdm_filter->Init.RegularParam.FastMode));
mbed_official 610:813dcc80987e 1031 assert_param(IS_FUNCTIONAL_STATE(hdfsdm_filter->Init.RegularParam.DmaMode));
mbed_official 610:813dcc80987e 1032 assert_param(IS_DFSDM_FILTER_INJ_TRIGGER(hdfsdm_filter->Init.InjectedParam.Trigger));
mbed_official 610:813dcc80987e 1033 assert_param(IS_FUNCTIONAL_STATE(hdfsdm_filter->Init.InjectedParam.ScanMode));
mbed_official 610:813dcc80987e 1034 assert_param(IS_FUNCTIONAL_STATE(hdfsdm_filter->Init.InjectedParam.DmaMode));
mbed_official 610:813dcc80987e 1035 assert_param(IS_DFSDM_FILTER_SINC_ORDER(hdfsdm_filter->Init.FilterParam.SincOrder));
mbed_official 610:813dcc80987e 1036 assert_param(IS_DFSDM_FILTER_OVS_RATIO(hdfsdm_filter->Init.FilterParam.Oversampling));
mbed_official 610:813dcc80987e 1037 assert_param(IS_DFSDM_FILTER_INTEGRATOR_OVS_RATIO(hdfsdm_filter->Init.FilterParam.IntOversampling));
mbed_official 610:813dcc80987e 1038
mbed_official 610:813dcc80987e 1039 /* Check DFSDM Channel handle */
mbed_official 610:813dcc80987e 1040 if(hdfsdm_filter == NULL)
mbed_official 610:813dcc80987e 1041 {
mbed_official 610:813dcc80987e 1042 return HAL_ERROR;
mbed_official 610:813dcc80987e 1043 }
mbed_official 610:813dcc80987e 1044
mbed_official 610:813dcc80987e 1045 /* Check parameters compatibility */
mbed_official 610:813dcc80987e 1046 if((hdfsdm_filter->Instance == DFSDM_Filter0) &&
mbed_official 610:813dcc80987e 1047 ((hdfsdm_filter->Init.RegularParam.Trigger == DFSDM_FILTER_SYNC_TRIGGER) ||
mbed_official 610:813dcc80987e 1048 (hdfsdm_filter->Init.InjectedParam.Trigger == DFSDM_FILTER_SYNC_TRIGGER)))
mbed_official 610:813dcc80987e 1049 {
mbed_official 610:813dcc80987e 1050 return HAL_ERROR;
mbed_official 610:813dcc80987e 1051 }
mbed_official 610:813dcc80987e 1052
mbed_official 610:813dcc80987e 1053 /* Initialize DFSDM filter variables with default values */
mbed_official 610:813dcc80987e 1054 hdfsdm_filter->RegularContMode = DFSDM_CONTINUOUS_CONV_OFF;
mbed_official 610:813dcc80987e 1055 hdfsdm_filter->InjectedChannelsNbr = 1;
mbed_official 610:813dcc80987e 1056 hdfsdm_filter->InjConvRemaining = 1;
mbed_official 610:813dcc80987e 1057 hdfsdm_filter->ErrorCode = DFSDM_FILTER_ERROR_NONE;
mbed_official 610:813dcc80987e 1058
mbed_official 610:813dcc80987e 1059 /* Call MSP init function */
mbed_official 610:813dcc80987e 1060 HAL_DFSDM_FilterMspInit(hdfsdm_filter);
mbed_official 610:813dcc80987e 1061
mbed_official 610:813dcc80987e 1062 /* Set regular parameters */
mbed_official 610:813dcc80987e 1063 hdfsdm_filter->Instance->CR1 &= ~(DFSDM_CR1_RSYNC);
mbed_official 610:813dcc80987e 1064 if(hdfsdm_filter->Init.RegularParam.FastMode == ENABLE)
mbed_official 610:813dcc80987e 1065 {
mbed_official 610:813dcc80987e 1066 hdfsdm_filter->Instance->CR1 |= DFSDM_CR1_FAST;
mbed_official 610:813dcc80987e 1067 }
mbed_official 610:813dcc80987e 1068 else
mbed_official 610:813dcc80987e 1069 {
mbed_official 610:813dcc80987e 1070 hdfsdm_filter->Instance->CR1 &= ~(DFSDM_CR1_FAST);
mbed_official 610:813dcc80987e 1071 }
mbed_official 610:813dcc80987e 1072
mbed_official 610:813dcc80987e 1073 if(hdfsdm_filter->Init.RegularParam.DmaMode == ENABLE)
mbed_official 610:813dcc80987e 1074 {
mbed_official 610:813dcc80987e 1075 hdfsdm_filter->Instance->CR1 |= DFSDM_CR1_RDMAEN;
mbed_official 610:813dcc80987e 1076 }
mbed_official 610:813dcc80987e 1077 else
mbed_official 610:813dcc80987e 1078 {
mbed_official 610:813dcc80987e 1079 hdfsdm_filter->Instance->CR1 &= ~(DFSDM_CR1_RDMAEN);
mbed_official 610:813dcc80987e 1080 }
mbed_official 610:813dcc80987e 1081
mbed_official 610:813dcc80987e 1082 /* Set injected parameters */
mbed_official 610:813dcc80987e 1083 hdfsdm_filter->Instance->CR1 &= ~(DFSDM_CR1_JSYNC | DFSDM_CR1_JEXTEN | DFSDM_CR1_JEXTSEL);
mbed_official 610:813dcc80987e 1084 if(hdfsdm_filter->Init.InjectedParam.Trigger == DFSDM_FILTER_EXT_TRIGGER)
mbed_official 610:813dcc80987e 1085 {
mbed_official 610:813dcc80987e 1086 assert_param(IS_DFSDM_FILTER_EXT_TRIG(hdfsdm_filter->Init.InjectedParam.ExtTrigger));
mbed_official 610:813dcc80987e 1087 assert_param(IS_DFSDM_FILTER_EXT_TRIG_EDGE(hdfsdm_filter->Init.InjectedParam.ExtTriggerEdge));
mbed_official 610:813dcc80987e 1088 hdfsdm_filter->Instance->CR1 |= (hdfsdm_filter->Init.InjectedParam.ExtTrigger);
mbed_official 610:813dcc80987e 1089 }
mbed_official 610:813dcc80987e 1090
mbed_official 610:813dcc80987e 1091 if(hdfsdm_filter->Init.InjectedParam.ScanMode == ENABLE)
mbed_official 610:813dcc80987e 1092 {
mbed_official 610:813dcc80987e 1093 hdfsdm_filter->Instance->CR1 |= DFSDM_CR1_JSCAN;
mbed_official 610:813dcc80987e 1094 }
mbed_official 610:813dcc80987e 1095 else
mbed_official 610:813dcc80987e 1096 {
mbed_official 610:813dcc80987e 1097 hdfsdm_filter->Instance->CR1 &= ~(DFSDM_CR1_JSCAN);
mbed_official 610:813dcc80987e 1098 }
mbed_official 610:813dcc80987e 1099
mbed_official 610:813dcc80987e 1100 if(hdfsdm_filter->Init.InjectedParam.DmaMode == ENABLE)
mbed_official 610:813dcc80987e 1101 {
mbed_official 610:813dcc80987e 1102 hdfsdm_filter->Instance->CR1 |= DFSDM_CR1_JDMAEN;
mbed_official 610:813dcc80987e 1103 }
mbed_official 610:813dcc80987e 1104 else
mbed_official 610:813dcc80987e 1105 {
mbed_official 610:813dcc80987e 1106 hdfsdm_filter->Instance->CR1 &= ~(DFSDM_CR1_JDMAEN);
mbed_official 610:813dcc80987e 1107 }
mbed_official 610:813dcc80987e 1108
mbed_official 610:813dcc80987e 1109 /* Set filter parameters */
mbed_official 610:813dcc80987e 1110 hdfsdm_filter->Instance->FCR &= ~(DFSDM_FCR_FORD | DFSDM_FCR_FOSR | DFSDM_FCR_IOSR);
mbed_official 610:813dcc80987e 1111 hdfsdm_filter->Instance->FCR |= (hdfsdm_filter->Init.FilterParam.SincOrder |
mbed_official 610:813dcc80987e 1112 ((hdfsdm_filter->Init.FilterParam.Oversampling - 1) << DFSDM_FCR_FOSR_OFFSET) |
mbed_official 610:813dcc80987e 1113 (hdfsdm_filter->Init.FilterParam.IntOversampling - 1));
mbed_official 610:813dcc80987e 1114
mbed_official 610:813dcc80987e 1115 /* Store regular and injected triggers and injected scan mode*/
mbed_official 610:813dcc80987e 1116 hdfsdm_filter->RegularTrigger = hdfsdm_filter->Init.RegularParam.Trigger;
mbed_official 610:813dcc80987e 1117 hdfsdm_filter->InjectedTrigger = hdfsdm_filter->Init.InjectedParam.Trigger;
mbed_official 610:813dcc80987e 1118 hdfsdm_filter->ExtTriggerEdge = hdfsdm_filter->Init.InjectedParam.ExtTriggerEdge;
mbed_official 610:813dcc80987e 1119 hdfsdm_filter->InjectedScanMode = hdfsdm_filter->Init.InjectedParam.ScanMode;
mbed_official 610:813dcc80987e 1120
mbed_official 610:813dcc80987e 1121 /* Enable DFSDM filter */
mbed_official 610:813dcc80987e 1122 hdfsdm_filter->Instance->CR1 |= DFSDM_CR1_DFEN;
mbed_official 610:813dcc80987e 1123
mbed_official 610:813dcc80987e 1124 /* Set DFSDM filter to ready state */
mbed_official 610:813dcc80987e 1125 hdfsdm_filter->State = HAL_DFSDM_FILTER_STATE_READY;
mbed_official 610:813dcc80987e 1126
mbed_official 610:813dcc80987e 1127 return HAL_OK;
mbed_official 610:813dcc80987e 1128 }
mbed_official 610:813dcc80987e 1129
mbed_official 610:813dcc80987e 1130 /**
mbed_official 610:813dcc80987e 1131 * @brief De-initializes the DFSDM filter.
mbed_official 610:813dcc80987e 1132 * @param hdfsdm_filter : DFSDM filter handle.
mbed_official 610:813dcc80987e 1133 * @retval HAL status.
mbed_official 610:813dcc80987e 1134 */
mbed_official 610:813dcc80987e 1135 HAL_StatusTypeDef HAL_DFSDM_FilterDeInit(DFSDM_Filter_HandleTypeDef *hdfsdm_filter)
mbed_official 610:813dcc80987e 1136 {
mbed_official 610:813dcc80987e 1137 /* Check parameters */
mbed_official 610:813dcc80987e 1138 assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
mbed_official 610:813dcc80987e 1139
mbed_official 610:813dcc80987e 1140 /* Check DFSDM filter handle */
mbed_official 610:813dcc80987e 1141 if(hdfsdm_filter == NULL)
mbed_official 610:813dcc80987e 1142 {
mbed_official 610:813dcc80987e 1143 return HAL_ERROR;
mbed_official 610:813dcc80987e 1144 }
mbed_official 610:813dcc80987e 1145
mbed_official 610:813dcc80987e 1146 /* Disable the DFSDM filter */
mbed_official 610:813dcc80987e 1147 hdfsdm_filter->Instance->CR1 &= ~(DFSDM_CR1_DFEN);
mbed_official 610:813dcc80987e 1148
mbed_official 610:813dcc80987e 1149 /* Call MSP deinit function */
mbed_official 610:813dcc80987e 1150 HAL_DFSDM_FilterMspDeInit(hdfsdm_filter);
mbed_official 610:813dcc80987e 1151
mbed_official 610:813dcc80987e 1152 /* Set DFSDM filter in reset state */
mbed_official 610:813dcc80987e 1153 hdfsdm_filter->State = HAL_DFSDM_FILTER_STATE_RESET;
mbed_official 610:813dcc80987e 1154
mbed_official 610:813dcc80987e 1155 return HAL_OK;
mbed_official 610:813dcc80987e 1156 }
mbed_official 610:813dcc80987e 1157
mbed_official 610:813dcc80987e 1158 /**
mbed_official 610:813dcc80987e 1159 * @brief Initializes the DFSDM filter MSP.
mbed_official 610:813dcc80987e 1160 * @param hdfsdm_filter : DFSDM filter handle.
mbed_official 610:813dcc80987e 1161 * @retval None
mbed_official 610:813dcc80987e 1162 */
mbed_official 610:813dcc80987e 1163 __weak void HAL_DFSDM_FilterMspInit(DFSDM_Filter_HandleTypeDef *hdfsdm_filter)
mbed_official 610:813dcc80987e 1164 {
mbed_official 610:813dcc80987e 1165 /* NOTE : This function should not be modified, when the function is needed,
mbed_official 610:813dcc80987e 1166 the HAL_DFSDM_FilterMspInit could be implemented in the user file.
mbed_official 610:813dcc80987e 1167 */
mbed_official 610:813dcc80987e 1168 }
mbed_official 610:813dcc80987e 1169
mbed_official 610:813dcc80987e 1170 /**
mbed_official 610:813dcc80987e 1171 * @brief De-initializes the DFSDM filter MSP.
mbed_official 610:813dcc80987e 1172 * @param hdfsdm_filter : DFSDM filter handle.
mbed_official 610:813dcc80987e 1173 * @retval None
mbed_official 610:813dcc80987e 1174 */
mbed_official 610:813dcc80987e 1175 __weak void HAL_DFSDM_FilterMspDeInit(DFSDM_Filter_HandleTypeDef *hdfsdm_filter)
mbed_official 610:813dcc80987e 1176 {
mbed_official 610:813dcc80987e 1177 /* NOTE : This function should not be modified, when the function is needed,
mbed_official 610:813dcc80987e 1178 the HAL_DFSDM_FilterMspDeInit could be implemented in the user file.
mbed_official 610:813dcc80987e 1179 */
mbed_official 610:813dcc80987e 1180 }
mbed_official 610:813dcc80987e 1181
mbed_official 610:813dcc80987e 1182 /**
mbed_official 610:813dcc80987e 1183 * @}
mbed_official 610:813dcc80987e 1184 */
mbed_official 610:813dcc80987e 1185
mbed_official 610:813dcc80987e 1186 /** @defgroup DFSDM_Exported_Functions_Group2_Filter Filter control functions
mbed_official 610:813dcc80987e 1187 * @brief Filter control functions
mbed_official 610:813dcc80987e 1188 *
mbed_official 610:813dcc80987e 1189 @verbatim
mbed_official 610:813dcc80987e 1190 ==============================================================================
mbed_official 610:813dcc80987e 1191 ##### Filter control functions #####
mbed_official 610:813dcc80987e 1192 ==============================================================================
mbed_official 610:813dcc80987e 1193 [..] This section provides functions allowing to:
mbed_official 610:813dcc80987e 1194 (+) Select channel and enable/disable continuous mode for regular conversion.
mbed_official 610:813dcc80987e 1195 (+) Select channels for injected conversion.
mbed_official 610:813dcc80987e 1196 @endverbatim
mbed_official 610:813dcc80987e 1197 * @{
mbed_official 610:813dcc80987e 1198 */
mbed_official 610:813dcc80987e 1199
mbed_official 610:813dcc80987e 1200 /**
mbed_official 610:813dcc80987e 1201 * @brief This function allows to select channel and to enable/disable
mbed_official 610:813dcc80987e 1202 * continuous mode for regular conversion.
mbed_official 610:813dcc80987e 1203 * @param hdfsdm_filter : DFSDM filter handle.
mbed_official 610:813dcc80987e 1204 * @param Channel : Channel for regular conversion.
mbed_official 610:813dcc80987e 1205 * This parameter can be a value of @ref DFSDM_Channel_Selection.
mbed_official 610:813dcc80987e 1206 * @param ContinuousMode : Enable/disable continuous mode for regular conversion.
mbed_official 610:813dcc80987e 1207 * This parameter can be a value of @ref DFSDM_ContinuousMode.
mbed_official 610:813dcc80987e 1208 * @retval HAL status
mbed_official 610:813dcc80987e 1209 */
mbed_official 610:813dcc80987e 1210 HAL_StatusTypeDef HAL_DFSDM_FilterConfigRegChannel(DFSDM_Filter_HandleTypeDef *hdfsdm_filter,
mbed_official 610:813dcc80987e 1211 uint32_t Channel,
mbed_official 610:813dcc80987e 1212 uint32_t ContinuousMode)
mbed_official 610:813dcc80987e 1213 {
mbed_official 610:813dcc80987e 1214 HAL_StatusTypeDef status = HAL_OK;
mbed_official 610:813dcc80987e 1215
mbed_official 610:813dcc80987e 1216 /* Check parameters */
mbed_official 610:813dcc80987e 1217 assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
mbed_official 610:813dcc80987e 1218 assert_param(IS_DFSDM_REGULAR_CHANNEL(Channel));
mbed_official 610:813dcc80987e 1219 assert_param(IS_DFSDM_CONTINUOUS_MODE(ContinuousMode));
mbed_official 610:813dcc80987e 1220
mbed_official 610:813dcc80987e 1221 /* Check DFSDM filter state */
mbed_official 610:813dcc80987e 1222 if((hdfsdm_filter->State != HAL_DFSDM_FILTER_STATE_RESET) &&
mbed_official 610:813dcc80987e 1223 (hdfsdm_filter->State != HAL_DFSDM_FILTER_STATE_ERROR))
mbed_official 610:813dcc80987e 1224 {
mbed_official 610:813dcc80987e 1225 /* Configure channel and continuous mode for regular conversion */
mbed_official 610:813dcc80987e 1226 hdfsdm_filter->Instance->CR1 &= ~(DFSDM_CR1_RCH | DFSDM_CR1_RCONT);
mbed_official 610:813dcc80987e 1227 if(ContinuousMode == DFSDM_CONTINUOUS_CONV_ON)
mbed_official 610:813dcc80987e 1228 {
mbed_official 610:813dcc80987e 1229 hdfsdm_filter->Instance->CR1 |= (uint32_t) (((Channel & DFSDM_MSB_MASK) << DFSDM_CR1_MSB_RCH_OFFSET) |
mbed_official 610:813dcc80987e 1230 DFSDM_CR1_RCONT);
mbed_official 610:813dcc80987e 1231 }
mbed_official 610:813dcc80987e 1232 else
mbed_official 610:813dcc80987e 1233 {
mbed_official 610:813dcc80987e 1234 hdfsdm_filter->Instance->CR1 |= (uint32_t) ((Channel & DFSDM_MSB_MASK) << DFSDM_CR1_MSB_RCH_OFFSET);
mbed_official 610:813dcc80987e 1235 }
mbed_official 610:813dcc80987e 1236 /* Store continuous mode information */
mbed_official 610:813dcc80987e 1237 hdfsdm_filter->RegularContMode = ContinuousMode;
mbed_official 610:813dcc80987e 1238 }
mbed_official 610:813dcc80987e 1239 else
mbed_official 610:813dcc80987e 1240 {
mbed_official 610:813dcc80987e 1241 status = HAL_ERROR;
mbed_official 610:813dcc80987e 1242 }
mbed_official 610:813dcc80987e 1243
mbed_official 610:813dcc80987e 1244 /* Return function status */
mbed_official 610:813dcc80987e 1245 return status;
mbed_official 610:813dcc80987e 1246 }
mbed_official 610:813dcc80987e 1247
mbed_official 610:813dcc80987e 1248 /**
mbed_official 610:813dcc80987e 1249 * @brief This function allows to select channels for injected conversion.
mbed_official 610:813dcc80987e 1250 * @param hdfsdm_filter : DFSDM filter handle.
mbed_official 610:813dcc80987e 1251 * @param Channel : Channels for injected conversion.
mbed_official 610:813dcc80987e 1252 * This parameter can be a values combination of @ref DFSDM_Channel_Selection.
mbed_official 610:813dcc80987e 1253 * @retval HAL status
mbed_official 610:813dcc80987e 1254 */
mbed_official 610:813dcc80987e 1255 HAL_StatusTypeDef HAL_DFSDM_FilterConfigInjChannel(DFSDM_Filter_HandleTypeDef *hdfsdm_filter,
mbed_official 610:813dcc80987e 1256 uint32_t Channel)
mbed_official 610:813dcc80987e 1257 {
mbed_official 610:813dcc80987e 1258 HAL_StatusTypeDef status = HAL_OK;
mbed_official 610:813dcc80987e 1259
mbed_official 610:813dcc80987e 1260 /* Check parameters */
mbed_official 610:813dcc80987e 1261 assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
mbed_official 610:813dcc80987e 1262 assert_param(IS_DFSDM_INJECTED_CHANNEL(Channel));
mbed_official 610:813dcc80987e 1263
mbed_official 610:813dcc80987e 1264 /* Check DFSDM filter state */
mbed_official 610:813dcc80987e 1265 if((hdfsdm_filter->State != HAL_DFSDM_FILTER_STATE_RESET) &&
mbed_official 610:813dcc80987e 1266 (hdfsdm_filter->State != HAL_DFSDM_FILTER_STATE_ERROR))
mbed_official 610:813dcc80987e 1267 {
mbed_official 610:813dcc80987e 1268 /* Configure channel for injected conversion */
mbed_official 610:813dcc80987e 1269 hdfsdm_filter->Instance->JCHGR = (uint32_t) (Channel & DFSDM_LSB_MASK);
mbed_official 610:813dcc80987e 1270 /* Store number of injected channels */
mbed_official 610:813dcc80987e 1271 hdfsdm_filter->InjectedChannelsNbr = DFSDM_GetInjChannelsNbr(Channel);
mbed_official 610:813dcc80987e 1272 /* Update number of injected channels remaining */
mbed_official 610:813dcc80987e 1273 hdfsdm_filter->InjConvRemaining = (hdfsdm_filter->InjectedScanMode == ENABLE) ? \
mbed_official 610:813dcc80987e 1274 hdfsdm_filter->InjectedChannelsNbr : 1;
mbed_official 610:813dcc80987e 1275 }
mbed_official 610:813dcc80987e 1276 else
mbed_official 610:813dcc80987e 1277 {
mbed_official 610:813dcc80987e 1278 status = HAL_ERROR;
mbed_official 610:813dcc80987e 1279 }
mbed_official 610:813dcc80987e 1280 /* Return function status */
mbed_official 610:813dcc80987e 1281 return status;
mbed_official 610:813dcc80987e 1282 }
mbed_official 610:813dcc80987e 1283
mbed_official 610:813dcc80987e 1284 /**
mbed_official 610:813dcc80987e 1285 * @}
mbed_official 610:813dcc80987e 1286 */
mbed_official 610:813dcc80987e 1287
mbed_official 610:813dcc80987e 1288 /** @defgroup DFSDM_Exported_Functions_Group3_Filter Filter operation functions
mbed_official 610:813dcc80987e 1289 * @brief Filter operation functions
mbed_official 610:813dcc80987e 1290 *
mbed_official 610:813dcc80987e 1291 @verbatim
mbed_official 610:813dcc80987e 1292 ==============================================================================
mbed_official 610:813dcc80987e 1293 ##### Filter operation functions #####
mbed_official 610:813dcc80987e 1294 ==============================================================================
mbed_official 610:813dcc80987e 1295 [..] This section provides functions allowing to:
mbed_official 610:813dcc80987e 1296 (+) Start conversion of regular/injected channel.
mbed_official 610:813dcc80987e 1297 (+) Poll for the end of regular/injected conversion.
mbed_official 610:813dcc80987e 1298 (+) Stop conversion of regular/injected channel.
mbed_official 610:813dcc80987e 1299 (+) Start conversion of regular/injected channel and enable interrupt.
mbed_official 610:813dcc80987e 1300 (+) Call the callback functions at the end of regular/injected conversions.
mbed_official 610:813dcc80987e 1301 (+) Stop conversion of regular/injected channel and disable interrupt.
mbed_official 610:813dcc80987e 1302 (+) Start conversion of regular/injected channel and enable DMA transfer.
mbed_official 610:813dcc80987e 1303 (+) Stop conversion of regular/injected channel and disable DMA transfer.
mbed_official 610:813dcc80987e 1304 (+) Start analog watchdog and enable interrupt.
mbed_official 610:813dcc80987e 1305 (+) Call the callback function when analog watchdog occurs.
mbed_official 610:813dcc80987e 1306 (+) Stop analog watchdog and disable interrupt.
mbed_official 610:813dcc80987e 1307 (+) Start extreme detector.
mbed_official 610:813dcc80987e 1308 (+) Stop extreme detector.
mbed_official 610:813dcc80987e 1309 (+) Get result of regular channel conversion.
mbed_official 610:813dcc80987e 1310 (+) Get result of injected channel conversion.
mbed_official 610:813dcc80987e 1311 (+) Get extreme detector maximum and minimum values.
mbed_official 610:813dcc80987e 1312 (+) Get conversion time.
mbed_official 610:813dcc80987e 1313 (+) Handle DFSDM interrupt request.
mbed_official 610:813dcc80987e 1314 @endverbatim
mbed_official 610:813dcc80987e 1315 * @{
mbed_official 610:813dcc80987e 1316 */
mbed_official 610:813dcc80987e 1317
mbed_official 610:813dcc80987e 1318 /**
mbed_official 610:813dcc80987e 1319 * @brief This function allows to start regular conversion in polling mode.
mbed_official 610:813dcc80987e 1320 * @note This function should be called only when DFSDM filter instance is
mbed_official 610:813dcc80987e 1321 * in idle state or if injected conversion is ongoing.
mbed_official 610:813dcc80987e 1322 * @param hdfsdm_filter : DFSDM filter handle.
mbed_official 610:813dcc80987e 1323 * @retval HAL status
mbed_official 610:813dcc80987e 1324 */
mbed_official 610:813dcc80987e 1325 HAL_StatusTypeDef HAL_DFSDM_FilterRegularStart(DFSDM_Filter_HandleTypeDef *hdfsdm_filter)
mbed_official 610:813dcc80987e 1326 {
mbed_official 610:813dcc80987e 1327 HAL_StatusTypeDef status = HAL_OK;
mbed_official 610:813dcc80987e 1328
mbed_official 610:813dcc80987e 1329 /* Check parameters */
mbed_official 610:813dcc80987e 1330 assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
mbed_official 610:813dcc80987e 1331
mbed_official 610:813dcc80987e 1332 /* Check DFSDM filter state */
mbed_official 610:813dcc80987e 1333 if((hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_READY) || \
mbed_official 610:813dcc80987e 1334 (hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_INJ))
mbed_official 610:813dcc80987e 1335 {
mbed_official 610:813dcc80987e 1336 /* Start regular conversion */
mbed_official 610:813dcc80987e 1337 DFSDM_RegConvStart(hdfsdm_filter);
mbed_official 610:813dcc80987e 1338 }
mbed_official 610:813dcc80987e 1339 else
mbed_official 610:813dcc80987e 1340 {
mbed_official 610:813dcc80987e 1341 status = HAL_ERROR;
mbed_official 610:813dcc80987e 1342 }
mbed_official 610:813dcc80987e 1343 /* Return function status */
mbed_official 610:813dcc80987e 1344 return status;
mbed_official 610:813dcc80987e 1345 }
mbed_official 610:813dcc80987e 1346
mbed_official 610:813dcc80987e 1347 /**
mbed_official 610:813dcc80987e 1348 * @brief This function allows to poll for the end of regular conversion.
mbed_official 610:813dcc80987e 1349 * @note This function should be called only if regular conversion is ongoing.
mbed_official 610:813dcc80987e 1350 * @param hdfsdm_filter : DFSDM filter handle.
mbed_official 610:813dcc80987e 1351 * @param Timeout : Timeout value in milliseconds.
mbed_official 610:813dcc80987e 1352 * @retval HAL status
mbed_official 610:813dcc80987e 1353 */
mbed_official 610:813dcc80987e 1354 HAL_StatusTypeDef HAL_DFSDM_FilterPollForRegConversion(DFSDM_Filter_HandleTypeDef *hdfsdm_filter,
mbed_official 610:813dcc80987e 1355 uint32_t Timeout)
mbed_official 610:813dcc80987e 1356 {
mbed_official 610:813dcc80987e 1357 uint32_t tickstart;
mbed_official 610:813dcc80987e 1358
mbed_official 610:813dcc80987e 1359 /* Check parameters */
mbed_official 610:813dcc80987e 1360 assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
mbed_official 610:813dcc80987e 1361
mbed_official 610:813dcc80987e 1362 /* Check DFSDM filter state */
mbed_official 610:813dcc80987e 1363 if((hdfsdm_filter->State != HAL_DFSDM_FILTER_STATE_REG) && \
mbed_official 610:813dcc80987e 1364 (hdfsdm_filter->State != HAL_DFSDM_FILTER_STATE_REG_INJ))
mbed_official 610:813dcc80987e 1365 {
mbed_official 610:813dcc80987e 1366 /* Return error status */
mbed_official 610:813dcc80987e 1367 return HAL_ERROR;
mbed_official 610:813dcc80987e 1368 }
mbed_official 610:813dcc80987e 1369 else
mbed_official 610:813dcc80987e 1370 {
mbed_official 610:813dcc80987e 1371 /* Get timeout */
mbed_official 610:813dcc80987e 1372 tickstart = HAL_GetTick();
mbed_official 610:813dcc80987e 1373
mbed_official 610:813dcc80987e 1374 /* Wait end of regular conversion */
mbed_official 610:813dcc80987e 1375 while((hdfsdm_filter->Instance->ISR & DFSDM_ISR_REOCF) != DFSDM_ISR_REOCF)
mbed_official 610:813dcc80987e 1376 {
mbed_official 610:813dcc80987e 1377 /* Check the Timeout */
mbed_official 610:813dcc80987e 1378 if(Timeout != HAL_MAX_DELAY)
mbed_official 610:813dcc80987e 1379 {
mbed_official 610:813dcc80987e 1380 if((Timeout == 0) || ((HAL_GetTick()-tickstart) > Timeout))
mbed_official 610:813dcc80987e 1381 {
mbed_official 610:813dcc80987e 1382 /* Return timeout status */
mbed_official 610:813dcc80987e 1383 return HAL_TIMEOUT;
mbed_official 610:813dcc80987e 1384 }
mbed_official 610:813dcc80987e 1385 }
mbed_official 610:813dcc80987e 1386 }
mbed_official 610:813dcc80987e 1387 /* Check if overrun occurs */
mbed_official 610:813dcc80987e 1388 if((hdfsdm_filter->Instance->ISR & DFSDM_ISR_ROVRF) == DFSDM_ISR_ROVRF)
mbed_official 610:813dcc80987e 1389 {
mbed_official 610:813dcc80987e 1390 /* Update error code and call error callback */
mbed_official 610:813dcc80987e 1391 hdfsdm_filter->ErrorCode = DFSDM_FILTER_ERROR_REGULAR_OVERRUN;
mbed_official 610:813dcc80987e 1392 HAL_DFSDM_FilterErrorCallback(hdfsdm_filter);
mbed_official 610:813dcc80987e 1393
mbed_official 610:813dcc80987e 1394 /* Clear regular overrun flag */
mbed_official 610:813dcc80987e 1395 hdfsdm_filter->Instance->ICR = DFSDM_ICR_CLRROVRF;
mbed_official 610:813dcc80987e 1396 }
mbed_official 610:813dcc80987e 1397 /* Update DFSDM filter state only if not continuous conversion and SW trigger */
mbed_official 610:813dcc80987e 1398 if((hdfsdm_filter->RegularContMode == DFSDM_CONTINUOUS_CONV_OFF) && \
mbed_official 610:813dcc80987e 1399 (hdfsdm_filter->RegularTrigger == DFSDM_FILTER_SW_TRIGGER))
mbed_official 610:813dcc80987e 1400 {
mbed_official 610:813dcc80987e 1401 hdfsdm_filter->State = (hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_REG) ? \
mbed_official 610:813dcc80987e 1402 HAL_DFSDM_FILTER_STATE_READY : HAL_DFSDM_FILTER_STATE_INJ;
mbed_official 610:813dcc80987e 1403 }
mbed_official 610:813dcc80987e 1404 /* Return function status */
mbed_official 610:813dcc80987e 1405 return HAL_OK;
mbed_official 610:813dcc80987e 1406 }
mbed_official 610:813dcc80987e 1407 }
mbed_official 610:813dcc80987e 1408
mbed_official 610:813dcc80987e 1409 /**
mbed_official 610:813dcc80987e 1410 * @brief This function allows to stop regular conversion in polling mode.
mbed_official 610:813dcc80987e 1411 * @note This function should be called only if regular conversion is ongoing.
mbed_official 610:813dcc80987e 1412 * @param hdfsdm_filter : DFSDM filter handle.
mbed_official 610:813dcc80987e 1413 * @retval HAL status
mbed_official 610:813dcc80987e 1414 */
mbed_official 610:813dcc80987e 1415 HAL_StatusTypeDef HAL_DFSDM_FilterRegularStop(DFSDM_Filter_HandleTypeDef *hdfsdm_filter)
mbed_official 610:813dcc80987e 1416 {
mbed_official 610:813dcc80987e 1417 HAL_StatusTypeDef status = HAL_OK;
mbed_official 610:813dcc80987e 1418
mbed_official 610:813dcc80987e 1419 /* Check parameters */
mbed_official 610:813dcc80987e 1420 assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
mbed_official 610:813dcc80987e 1421
mbed_official 610:813dcc80987e 1422 /* Check DFSDM filter state */
mbed_official 610:813dcc80987e 1423 if((hdfsdm_filter->State != HAL_DFSDM_FILTER_STATE_REG) && \
mbed_official 610:813dcc80987e 1424 (hdfsdm_filter->State != HAL_DFSDM_FILTER_STATE_REG_INJ))
mbed_official 610:813dcc80987e 1425 {
mbed_official 610:813dcc80987e 1426 /* Return error status */
mbed_official 610:813dcc80987e 1427 status = HAL_ERROR;
mbed_official 610:813dcc80987e 1428 }
mbed_official 610:813dcc80987e 1429 else
mbed_official 610:813dcc80987e 1430 {
mbed_official 610:813dcc80987e 1431 /* Stop regular conversion */
mbed_official 610:813dcc80987e 1432 DFSDM_RegConvStop(hdfsdm_filter);
mbed_official 610:813dcc80987e 1433 }
mbed_official 610:813dcc80987e 1434 /* Return function status */
mbed_official 610:813dcc80987e 1435 return status;
mbed_official 610:813dcc80987e 1436 }
mbed_official 610:813dcc80987e 1437
mbed_official 610:813dcc80987e 1438 /**
mbed_official 610:813dcc80987e 1439 * @brief This function allows to start regular conversion in interrupt mode.
mbed_official 610:813dcc80987e 1440 * @note This function should be called only when DFSDM filter instance is
mbed_official 610:813dcc80987e 1441 * in idle state or if injected conversion is ongoing.
mbed_official 610:813dcc80987e 1442 * @param hdfsdm_filter : DFSDM filter handle.
mbed_official 610:813dcc80987e 1443 * @retval HAL status
mbed_official 610:813dcc80987e 1444 */
mbed_official 610:813dcc80987e 1445 HAL_StatusTypeDef HAL_DFSDM_FilterRegularStart_IT(DFSDM_Filter_HandleTypeDef *hdfsdm_filter)
mbed_official 610:813dcc80987e 1446 {
mbed_official 610:813dcc80987e 1447 HAL_StatusTypeDef status = HAL_OK;
mbed_official 610:813dcc80987e 1448
mbed_official 610:813dcc80987e 1449 /* Check parameters */
mbed_official 610:813dcc80987e 1450 assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
mbed_official 610:813dcc80987e 1451
mbed_official 610:813dcc80987e 1452 /* Check DFSDM filter state */
mbed_official 610:813dcc80987e 1453 if((hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_READY) || \
mbed_official 610:813dcc80987e 1454 (hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_INJ))
mbed_official 610:813dcc80987e 1455 {
mbed_official 610:813dcc80987e 1456 /* Enable interrupts for regular conversions */
mbed_official 610:813dcc80987e 1457 hdfsdm_filter->Instance->CR2 |= (DFSDM_CR2_REOCIE | DFSDM_CR2_ROVRIE);
mbed_official 610:813dcc80987e 1458
mbed_official 610:813dcc80987e 1459 /* Start regular conversion */
mbed_official 610:813dcc80987e 1460 DFSDM_RegConvStart(hdfsdm_filter);
mbed_official 610:813dcc80987e 1461 }
mbed_official 610:813dcc80987e 1462 else
mbed_official 610:813dcc80987e 1463 {
mbed_official 610:813dcc80987e 1464 status = HAL_ERROR;
mbed_official 610:813dcc80987e 1465 }
mbed_official 610:813dcc80987e 1466 /* Return function status */
mbed_official 610:813dcc80987e 1467 return status;
mbed_official 610:813dcc80987e 1468 }
mbed_official 610:813dcc80987e 1469
mbed_official 610:813dcc80987e 1470 /**
mbed_official 610:813dcc80987e 1471 * @brief This function allows to stop regular conversion in interrupt mode.
mbed_official 610:813dcc80987e 1472 * @note This function should be called only if regular conversion is ongoing.
mbed_official 610:813dcc80987e 1473 * @param hdfsdm_filter : DFSDM filter handle.
mbed_official 610:813dcc80987e 1474 * @retval HAL status
mbed_official 610:813dcc80987e 1475 */
mbed_official 610:813dcc80987e 1476 HAL_StatusTypeDef HAL_DFSDM_FilterRegularStop_IT(DFSDM_Filter_HandleTypeDef *hdfsdm_filter)
mbed_official 610:813dcc80987e 1477 {
mbed_official 610:813dcc80987e 1478 HAL_StatusTypeDef status = HAL_OK;
mbed_official 610:813dcc80987e 1479
mbed_official 610:813dcc80987e 1480 /* Check parameters */
mbed_official 610:813dcc80987e 1481 assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
mbed_official 610:813dcc80987e 1482
mbed_official 610:813dcc80987e 1483 /* Check DFSDM filter state */
mbed_official 610:813dcc80987e 1484 if((hdfsdm_filter->State != HAL_DFSDM_FILTER_STATE_REG) && \
mbed_official 610:813dcc80987e 1485 (hdfsdm_filter->State != HAL_DFSDM_FILTER_STATE_REG_INJ))
mbed_official 610:813dcc80987e 1486 {
mbed_official 610:813dcc80987e 1487 /* Return error status */
mbed_official 610:813dcc80987e 1488 status = HAL_ERROR;
mbed_official 610:813dcc80987e 1489 }
mbed_official 610:813dcc80987e 1490 else
mbed_official 610:813dcc80987e 1491 {
mbed_official 610:813dcc80987e 1492 /* Disable interrupts for regular conversions */
mbed_official 610:813dcc80987e 1493 hdfsdm_filter->Instance->CR2 &= ~(DFSDM_CR2_REOCIE | DFSDM_CR2_ROVRIE);
mbed_official 610:813dcc80987e 1494
mbed_official 610:813dcc80987e 1495 /* Stop regular conversion */
mbed_official 610:813dcc80987e 1496 DFSDM_RegConvStop(hdfsdm_filter);
mbed_official 610:813dcc80987e 1497 }
mbed_official 610:813dcc80987e 1498 /* Return function status */
mbed_official 610:813dcc80987e 1499 return status;
mbed_official 610:813dcc80987e 1500 }
mbed_official 610:813dcc80987e 1501
mbed_official 610:813dcc80987e 1502 /**
mbed_official 610:813dcc80987e 1503 * @brief This function allows to start regular conversion in DMA mode.
mbed_official 610:813dcc80987e 1504 * @note This function should be called only when DFSDM filter instance is
mbed_official 610:813dcc80987e 1505 * in idle state or if injected conversion is ongoing.
mbed_official 610:813dcc80987e 1506 * Please note that data on buffer will contain signed regular conversion
mbed_official 610:813dcc80987e 1507 * value on 24 most significant bits and corresponding channel on 3 least
mbed_official 610:813dcc80987e 1508 * significant bits.
mbed_official 610:813dcc80987e 1509 * @param hdfsdm_filter : DFSDM filter handle.
mbed_official 610:813dcc80987e 1510 * @param pData : The destination buffer address.
mbed_official 610:813dcc80987e 1511 * @param Length : The length of data to be transferred from DFSDM filter to memory.
mbed_official 610:813dcc80987e 1512 * @retval HAL status
mbed_official 610:813dcc80987e 1513 */
mbed_official 610:813dcc80987e 1514 HAL_StatusTypeDef HAL_DFSDM_FilterRegularStart_DMA(DFSDM_Filter_HandleTypeDef *hdfsdm_filter,
mbed_official 610:813dcc80987e 1515 int32_t *pData,
mbed_official 610:813dcc80987e 1516 uint32_t Length)
mbed_official 610:813dcc80987e 1517 {
mbed_official 610:813dcc80987e 1518 HAL_StatusTypeDef status = HAL_OK;
mbed_official 610:813dcc80987e 1519
mbed_official 610:813dcc80987e 1520 /* Check parameters */
mbed_official 610:813dcc80987e 1521 assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
mbed_official 610:813dcc80987e 1522
mbed_official 610:813dcc80987e 1523 /* Check destination address and length */
mbed_official 610:813dcc80987e 1524 if((pData == NULL) || (Length == 0))
mbed_official 610:813dcc80987e 1525 {
mbed_official 610:813dcc80987e 1526 status = HAL_ERROR;
mbed_official 610:813dcc80987e 1527 }
mbed_official 610:813dcc80987e 1528 /* Check that DMA is enabled for regular conversion */
mbed_official 610:813dcc80987e 1529 else if((hdfsdm_filter->Instance->CR1 & DFSDM_CR1_RDMAEN) != DFSDM_CR1_RDMAEN)
mbed_official 610:813dcc80987e 1530 {
mbed_official 610:813dcc80987e 1531 status = HAL_ERROR;
mbed_official 610:813dcc80987e 1532 }
mbed_official 610:813dcc80987e 1533 /* Check parameters compatibility */
mbed_official 610:813dcc80987e 1534 else if((hdfsdm_filter->RegularTrigger == DFSDM_FILTER_SW_TRIGGER) && \
mbed_official 610:813dcc80987e 1535 (hdfsdm_filter->RegularContMode == DFSDM_CONTINUOUS_CONV_OFF) && \
mbed_official 610:813dcc80987e 1536 (hdfsdm_filter->hdmaReg->Init.Mode == DMA_NORMAL) && \
mbed_official 610:813dcc80987e 1537 (Length != 1))
mbed_official 610:813dcc80987e 1538 {
mbed_official 610:813dcc80987e 1539 status = HAL_ERROR;
mbed_official 610:813dcc80987e 1540 }
mbed_official 610:813dcc80987e 1541 else if((hdfsdm_filter->RegularTrigger == DFSDM_FILTER_SW_TRIGGER) && \
mbed_official 610:813dcc80987e 1542 (hdfsdm_filter->RegularContMode == DFSDM_CONTINUOUS_CONV_OFF) && \
mbed_official 610:813dcc80987e 1543 (hdfsdm_filter->hdmaReg->Init.Mode == DMA_CIRCULAR))
mbed_official 610:813dcc80987e 1544 {
mbed_official 610:813dcc80987e 1545 status = HAL_ERROR;
mbed_official 610:813dcc80987e 1546 }
mbed_official 610:813dcc80987e 1547 /* Check DFSDM filter state */
mbed_official 610:813dcc80987e 1548 else if((hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_READY) || \
mbed_official 610:813dcc80987e 1549 (hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_INJ))
mbed_official 610:813dcc80987e 1550 {
mbed_official 610:813dcc80987e 1551 /* Set callbacks on DMA handler */
mbed_official 610:813dcc80987e 1552 hdfsdm_filter->hdmaReg->XferCpltCallback = DFSDM_DMARegularConvCplt;
mbed_official 610:813dcc80987e 1553 hdfsdm_filter->hdmaReg->XferErrorCallback = DFSDM_DMAError;
mbed_official 610:813dcc80987e 1554 hdfsdm_filter->hdmaReg->XferHalfCpltCallback = (hdfsdm_filter->hdmaReg->Init.Mode == DMA_CIRCULAR) ?\
mbed_official 610:813dcc80987e 1555 DFSDM_DMARegularHalfConvCplt : NULL;
mbed_official 610:813dcc80987e 1556
mbed_official 610:813dcc80987e 1557 /* Start DMA in interrupt mode */
mbed_official 610:813dcc80987e 1558 if(HAL_DMA_Start_IT(hdfsdm_filter->hdmaReg, (uint32_t)&hdfsdm_filter->Instance->RDATAR, \
mbed_official 610:813dcc80987e 1559 (uint32_t) pData, Length) != HAL_OK)
mbed_official 610:813dcc80987e 1560 {
mbed_official 610:813dcc80987e 1561 /* Set DFSDM filter in error state */
mbed_official 610:813dcc80987e 1562 hdfsdm_filter->State = HAL_DFSDM_FILTER_STATE_ERROR;
mbed_official 610:813dcc80987e 1563 status = HAL_ERROR;
mbed_official 610:813dcc80987e 1564 }
mbed_official 610:813dcc80987e 1565 else
mbed_official 610:813dcc80987e 1566 {
mbed_official 610:813dcc80987e 1567 /* Start regular conversion */
mbed_official 610:813dcc80987e 1568 DFSDM_RegConvStart(hdfsdm_filter);
mbed_official 610:813dcc80987e 1569 }
mbed_official 610:813dcc80987e 1570 }
mbed_official 610:813dcc80987e 1571 else
mbed_official 610:813dcc80987e 1572 {
mbed_official 610:813dcc80987e 1573 status = HAL_ERROR;
mbed_official 610:813dcc80987e 1574 }
mbed_official 610:813dcc80987e 1575 /* Return function status */
mbed_official 610:813dcc80987e 1576 return status;
mbed_official 610:813dcc80987e 1577 }
mbed_official 610:813dcc80987e 1578
mbed_official 610:813dcc80987e 1579 /**
mbed_official 610:813dcc80987e 1580 * @brief This function allows to start regular conversion in DMA mode and to get
mbed_official 610:813dcc80987e 1581 * only the 16 most significant bits of conversion.
mbed_official 610:813dcc80987e 1582 * @note This function should be called only when DFSDM filter instance is
mbed_official 610:813dcc80987e 1583 * in idle state or if injected conversion is ongoing.
mbed_official 610:813dcc80987e 1584 * Please note that data on buffer will contain signed 16 most significant
mbed_official 610:813dcc80987e 1585 * bits of regular conversion.
mbed_official 610:813dcc80987e 1586 * @param hdfsdm_filter : DFSDM filter handle.
mbed_official 610:813dcc80987e 1587 * @param pData : The destination buffer address.
mbed_official 610:813dcc80987e 1588 * @param Length : The length of data to be transferred from DFSDM filter to memory.
mbed_official 610:813dcc80987e 1589 * @retval HAL status
mbed_official 610:813dcc80987e 1590 */
mbed_official 610:813dcc80987e 1591 HAL_StatusTypeDef HAL_DFSDM_FilterRegularMsbStart_DMA(DFSDM_Filter_HandleTypeDef *hdfsdm_filter,
mbed_official 610:813dcc80987e 1592 int16_t *pData,
mbed_official 610:813dcc80987e 1593 uint32_t Length)
mbed_official 610:813dcc80987e 1594 {
mbed_official 610:813dcc80987e 1595 HAL_StatusTypeDef status = HAL_OK;
mbed_official 610:813dcc80987e 1596
mbed_official 610:813dcc80987e 1597 /* Check parameters */
mbed_official 610:813dcc80987e 1598 assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
mbed_official 610:813dcc80987e 1599
mbed_official 610:813dcc80987e 1600 /* Check destination address and length */
mbed_official 610:813dcc80987e 1601 if((pData == NULL) || (Length == 0))
mbed_official 610:813dcc80987e 1602 {
mbed_official 610:813dcc80987e 1603 status = HAL_ERROR;
mbed_official 610:813dcc80987e 1604 }
mbed_official 610:813dcc80987e 1605 /* Check that DMA is enabled for regular conversion */
mbed_official 610:813dcc80987e 1606 else if((hdfsdm_filter->Instance->CR1 & DFSDM_CR1_RDMAEN) != DFSDM_CR1_RDMAEN)
mbed_official 610:813dcc80987e 1607 {
mbed_official 610:813dcc80987e 1608 status = HAL_ERROR;
mbed_official 610:813dcc80987e 1609 }
mbed_official 610:813dcc80987e 1610 /* Check parameters compatibility */
mbed_official 610:813dcc80987e 1611 else if((hdfsdm_filter->RegularTrigger == DFSDM_FILTER_SW_TRIGGER) && \
mbed_official 610:813dcc80987e 1612 (hdfsdm_filter->RegularContMode == DFSDM_CONTINUOUS_CONV_OFF) && \
mbed_official 610:813dcc80987e 1613 (hdfsdm_filter->hdmaReg->Init.Mode == DMA_NORMAL) && \
mbed_official 610:813dcc80987e 1614 (Length != 1))
mbed_official 610:813dcc80987e 1615 {
mbed_official 610:813dcc80987e 1616 status = HAL_ERROR;
mbed_official 610:813dcc80987e 1617 }
mbed_official 610:813dcc80987e 1618 else if((hdfsdm_filter->RegularTrigger == DFSDM_FILTER_SW_TRIGGER) && \
mbed_official 610:813dcc80987e 1619 (hdfsdm_filter->RegularContMode == DFSDM_CONTINUOUS_CONV_OFF) && \
mbed_official 610:813dcc80987e 1620 (hdfsdm_filter->hdmaReg->Init.Mode == DMA_CIRCULAR))
mbed_official 610:813dcc80987e 1621 {
mbed_official 610:813dcc80987e 1622 status = HAL_ERROR;
mbed_official 610:813dcc80987e 1623 }
mbed_official 610:813dcc80987e 1624 /* Check DFSDM filter state */
mbed_official 610:813dcc80987e 1625 else if((hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_READY) || \
mbed_official 610:813dcc80987e 1626 (hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_INJ))
mbed_official 610:813dcc80987e 1627 {
mbed_official 610:813dcc80987e 1628 /* Set callbacks on DMA handler */
mbed_official 610:813dcc80987e 1629 hdfsdm_filter->hdmaReg->XferCpltCallback = DFSDM_DMARegularConvCplt;
mbed_official 610:813dcc80987e 1630 hdfsdm_filter->hdmaReg->XferErrorCallback = DFSDM_DMAError;
mbed_official 610:813dcc80987e 1631 hdfsdm_filter->hdmaReg->XferHalfCpltCallback = (hdfsdm_filter->hdmaReg->Init.Mode == DMA_CIRCULAR) ?\
mbed_official 610:813dcc80987e 1632 DFSDM_DMARegularHalfConvCplt : NULL;
mbed_official 610:813dcc80987e 1633
mbed_official 610:813dcc80987e 1634 /* Start DMA in interrupt mode */
mbed_official 610:813dcc80987e 1635 if(HAL_DMA_Start_IT(hdfsdm_filter->hdmaReg, (uint32_t)(&hdfsdm_filter->Instance->RDATAR) + 2, \
mbed_official 610:813dcc80987e 1636 (uint32_t) pData, Length) != HAL_OK)
mbed_official 610:813dcc80987e 1637 {
mbed_official 610:813dcc80987e 1638 /* Set DFSDM filter in error state */
mbed_official 610:813dcc80987e 1639 hdfsdm_filter->State = HAL_DFSDM_FILTER_STATE_ERROR;
mbed_official 610:813dcc80987e 1640 status = HAL_ERROR;
mbed_official 610:813dcc80987e 1641 }
mbed_official 610:813dcc80987e 1642 else
mbed_official 610:813dcc80987e 1643 {
mbed_official 610:813dcc80987e 1644 /* Start regular conversion */
mbed_official 610:813dcc80987e 1645 DFSDM_RegConvStart(hdfsdm_filter);
mbed_official 610:813dcc80987e 1646 }
mbed_official 610:813dcc80987e 1647 }
mbed_official 610:813dcc80987e 1648 else
mbed_official 610:813dcc80987e 1649 {
mbed_official 610:813dcc80987e 1650 status = HAL_ERROR;
mbed_official 610:813dcc80987e 1651 }
mbed_official 610:813dcc80987e 1652 /* Return function status */
mbed_official 610:813dcc80987e 1653 return status;
mbed_official 610:813dcc80987e 1654 }
mbed_official 610:813dcc80987e 1655
mbed_official 610:813dcc80987e 1656 /**
mbed_official 610:813dcc80987e 1657 * @brief This function allows to stop regular conversion in DMA mode.
mbed_official 610:813dcc80987e 1658 * @note This function should be called only if regular conversion is ongoing.
mbed_official 610:813dcc80987e 1659 * @param hdfsdm_filter : DFSDM filter handle.
mbed_official 610:813dcc80987e 1660 * @retval HAL status
mbed_official 610:813dcc80987e 1661 */
mbed_official 610:813dcc80987e 1662 HAL_StatusTypeDef HAL_DFSDM_FilterRegularStop_DMA(DFSDM_Filter_HandleTypeDef *hdfsdm_filter)
mbed_official 610:813dcc80987e 1663 {
mbed_official 610:813dcc80987e 1664 HAL_StatusTypeDef status = HAL_OK;
mbed_official 610:813dcc80987e 1665
mbed_official 610:813dcc80987e 1666 /* Check parameters */
mbed_official 610:813dcc80987e 1667 assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
mbed_official 610:813dcc80987e 1668
mbed_official 610:813dcc80987e 1669 /* Check DFSDM filter state */
mbed_official 610:813dcc80987e 1670 if((hdfsdm_filter->State != HAL_DFSDM_FILTER_STATE_REG) && \
mbed_official 610:813dcc80987e 1671 (hdfsdm_filter->State != HAL_DFSDM_FILTER_STATE_REG_INJ))
mbed_official 610:813dcc80987e 1672 {
mbed_official 610:813dcc80987e 1673 /* Return error status */
mbed_official 610:813dcc80987e 1674 status = HAL_ERROR;
mbed_official 610:813dcc80987e 1675 }
mbed_official 610:813dcc80987e 1676 else
mbed_official 610:813dcc80987e 1677 {
mbed_official 610:813dcc80987e 1678 /* Stop current DMA transfer */
mbed_official 610:813dcc80987e 1679 if(HAL_DMA_Abort(hdfsdm_filter->hdmaReg) != HAL_OK)
mbed_official 610:813dcc80987e 1680 {
mbed_official 610:813dcc80987e 1681 /* Set DFSDM filter in error state */
mbed_official 610:813dcc80987e 1682 hdfsdm_filter->State = HAL_DFSDM_FILTER_STATE_ERROR;
mbed_official 610:813dcc80987e 1683 status = HAL_ERROR;
mbed_official 610:813dcc80987e 1684 }
mbed_official 610:813dcc80987e 1685 else
mbed_official 610:813dcc80987e 1686 {
mbed_official 610:813dcc80987e 1687 /* Stop regular conversion */
mbed_official 610:813dcc80987e 1688 DFSDM_RegConvStop(hdfsdm_filter);
mbed_official 610:813dcc80987e 1689 }
mbed_official 610:813dcc80987e 1690 }
mbed_official 610:813dcc80987e 1691 /* Return function status */
mbed_official 610:813dcc80987e 1692 return status;
mbed_official 610:813dcc80987e 1693 }
mbed_official 610:813dcc80987e 1694
mbed_official 610:813dcc80987e 1695 /**
mbed_official 610:813dcc80987e 1696 * @brief This function allows to get regular conversion value.
mbed_official 610:813dcc80987e 1697 * @param hdfsdm_filter : DFSDM filter handle.
mbed_official 610:813dcc80987e 1698 * @param Channel : Corresponding channel of regular conversion.
mbed_official 610:813dcc80987e 1699 * @retval Regular conversion value
mbed_official 610:813dcc80987e 1700 */
mbed_official 610:813dcc80987e 1701 int32_t HAL_DFSDM_FilterGetRegularValue(DFSDM_Filter_HandleTypeDef *hdfsdm_filter,
mbed_official 610:813dcc80987e 1702 uint32_t *Channel)
mbed_official 610:813dcc80987e 1703 {
mbed_official 610:813dcc80987e 1704 uint32_t reg = 0;
mbed_official 610:813dcc80987e 1705 int32_t value = 0;
mbed_official 610:813dcc80987e 1706
mbed_official 610:813dcc80987e 1707 /* Check parameters */
mbed_official 610:813dcc80987e 1708 assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
mbed_official 610:813dcc80987e 1709 assert_param(Channel != NULL);
mbed_official 610:813dcc80987e 1710
mbed_official 610:813dcc80987e 1711 /* Get value of data register for regular channel */
mbed_official 610:813dcc80987e 1712 reg = hdfsdm_filter->Instance->RDATAR;
mbed_official 610:813dcc80987e 1713
mbed_official 610:813dcc80987e 1714 /* Extract channel and regular conversion value */
mbed_official 610:813dcc80987e 1715 *Channel = (reg & DFSDM_RDATAR_RDATACH);
mbed_official 610:813dcc80987e 1716 value = ((int32_t)(reg & DFSDM_RDATAR_RDATA) >> DFSDM_RDATAR_DATA_OFFSET);
mbed_official 610:813dcc80987e 1717
mbed_official 610:813dcc80987e 1718 /* return regular conversion value */
mbed_official 610:813dcc80987e 1719 return value;
mbed_official 610:813dcc80987e 1720 }
mbed_official 610:813dcc80987e 1721
mbed_official 610:813dcc80987e 1722 /**
mbed_official 610:813dcc80987e 1723 * @brief This function allows to start injected conversion in polling mode.
mbed_official 610:813dcc80987e 1724 * @note This function should be called only when DFSDM filter instance is
mbed_official 610:813dcc80987e 1725 * in idle state or if regular conversion is ongoing.
mbed_official 610:813dcc80987e 1726 * @param hdfsdm_filter : DFSDM filter handle.
mbed_official 610:813dcc80987e 1727 * @retval HAL status
mbed_official 610:813dcc80987e 1728 */
mbed_official 610:813dcc80987e 1729 HAL_StatusTypeDef HAL_DFSDM_FilterInjectedStart(DFSDM_Filter_HandleTypeDef *hdfsdm_filter)
mbed_official 610:813dcc80987e 1730 {
mbed_official 610:813dcc80987e 1731 HAL_StatusTypeDef status = HAL_OK;
mbed_official 610:813dcc80987e 1732
mbed_official 610:813dcc80987e 1733 /* Check parameters */
mbed_official 610:813dcc80987e 1734 assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
mbed_official 610:813dcc80987e 1735
mbed_official 610:813dcc80987e 1736 /* Check DFSDM filter state */
mbed_official 610:813dcc80987e 1737 if((hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_READY) || \
mbed_official 610:813dcc80987e 1738 (hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_REG))
mbed_official 610:813dcc80987e 1739 {
mbed_official 610:813dcc80987e 1740 /* Start injected conversion */
mbed_official 610:813dcc80987e 1741 DFSDM_InjConvStart(hdfsdm_filter);
mbed_official 610:813dcc80987e 1742 }
mbed_official 610:813dcc80987e 1743 else
mbed_official 610:813dcc80987e 1744 {
mbed_official 610:813dcc80987e 1745 status = HAL_ERROR;
mbed_official 610:813dcc80987e 1746 }
mbed_official 610:813dcc80987e 1747 /* Return function status */
mbed_official 610:813dcc80987e 1748 return status;
mbed_official 610:813dcc80987e 1749 }
mbed_official 610:813dcc80987e 1750
mbed_official 610:813dcc80987e 1751 /**
mbed_official 610:813dcc80987e 1752 * @brief This function allows to poll for the end of injected conversion.
mbed_official 610:813dcc80987e 1753 * @note This function should be called only if injected conversion is ongoing.
mbed_official 610:813dcc80987e 1754 * @param hdfsdm_filter : DFSDM filter handle.
mbed_official 610:813dcc80987e 1755 * @param Timeout : Timeout value in milliseconds.
mbed_official 610:813dcc80987e 1756 * @retval HAL status
mbed_official 610:813dcc80987e 1757 */
mbed_official 610:813dcc80987e 1758 HAL_StatusTypeDef HAL_DFSDM_FilterPollForInjConversion(DFSDM_Filter_HandleTypeDef *hdfsdm_filter,
mbed_official 610:813dcc80987e 1759 uint32_t Timeout)
mbed_official 610:813dcc80987e 1760 {
mbed_official 610:813dcc80987e 1761 uint32_t tickstart;
mbed_official 610:813dcc80987e 1762
mbed_official 610:813dcc80987e 1763 /* Check parameters */
mbed_official 610:813dcc80987e 1764 assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
mbed_official 610:813dcc80987e 1765
mbed_official 610:813dcc80987e 1766 /* Check DFSDM filter state */
mbed_official 610:813dcc80987e 1767 if((hdfsdm_filter->State != HAL_DFSDM_FILTER_STATE_INJ) && \
mbed_official 610:813dcc80987e 1768 (hdfsdm_filter->State != HAL_DFSDM_FILTER_STATE_REG_INJ))
mbed_official 610:813dcc80987e 1769 {
mbed_official 610:813dcc80987e 1770 /* Return error status */
mbed_official 610:813dcc80987e 1771 return HAL_ERROR;
mbed_official 610:813dcc80987e 1772 }
mbed_official 610:813dcc80987e 1773 else
mbed_official 610:813dcc80987e 1774 {
mbed_official 610:813dcc80987e 1775 /* Get timeout */
mbed_official 610:813dcc80987e 1776 tickstart = HAL_GetTick();
mbed_official 610:813dcc80987e 1777
mbed_official 610:813dcc80987e 1778 /* Wait end of injected conversions */
mbed_official 610:813dcc80987e 1779 while((hdfsdm_filter->Instance->ISR & DFSDM_ISR_JEOCF) != DFSDM_ISR_JEOCF)
mbed_official 610:813dcc80987e 1780 {
mbed_official 610:813dcc80987e 1781 /* Check the Timeout */
mbed_official 610:813dcc80987e 1782 if(Timeout != HAL_MAX_DELAY)
mbed_official 610:813dcc80987e 1783 {
mbed_official 610:813dcc80987e 1784 if((Timeout == 0) || ((HAL_GetTick()-tickstart) > Timeout))
mbed_official 610:813dcc80987e 1785 {
mbed_official 610:813dcc80987e 1786 /* Return timeout status */
mbed_official 610:813dcc80987e 1787 return HAL_TIMEOUT;
mbed_official 610:813dcc80987e 1788 }
mbed_official 610:813dcc80987e 1789 }
mbed_official 610:813dcc80987e 1790 }
mbed_official 610:813dcc80987e 1791 /* Check if overrun occurs */
mbed_official 610:813dcc80987e 1792 if((hdfsdm_filter->Instance->ISR & DFSDM_ISR_JOVRF) == DFSDM_ISR_JOVRF)
mbed_official 610:813dcc80987e 1793 {
mbed_official 610:813dcc80987e 1794 /* Update error code and call error callback */
mbed_official 610:813dcc80987e 1795 hdfsdm_filter->ErrorCode = DFSDM_FILTER_ERROR_INJECTED_OVERRUN;
mbed_official 610:813dcc80987e 1796 HAL_DFSDM_FilterErrorCallback(hdfsdm_filter);
mbed_official 610:813dcc80987e 1797
mbed_official 610:813dcc80987e 1798 /* Clear injected overrun flag */
mbed_official 610:813dcc80987e 1799 hdfsdm_filter->Instance->ICR = DFSDM_ICR_CLRJOVRF;
mbed_official 610:813dcc80987e 1800 }
mbed_official 610:813dcc80987e 1801
mbed_official 610:813dcc80987e 1802 /* Update remaining injected conversions */
mbed_official 610:813dcc80987e 1803 hdfsdm_filter->InjConvRemaining--;
mbed_official 610:813dcc80987e 1804 if(hdfsdm_filter->InjConvRemaining == 0)
mbed_official 610:813dcc80987e 1805 {
mbed_official 610:813dcc80987e 1806 /* Update DFSDM filter state only if trigger is software */
mbed_official 610:813dcc80987e 1807 if(hdfsdm_filter->InjectedTrigger == DFSDM_FILTER_SW_TRIGGER)
mbed_official 610:813dcc80987e 1808 {
mbed_official 610:813dcc80987e 1809 hdfsdm_filter->State = (hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_INJ) ? \
mbed_official 610:813dcc80987e 1810 HAL_DFSDM_FILTER_STATE_READY : HAL_DFSDM_FILTER_STATE_REG;
mbed_official 610:813dcc80987e 1811 }
mbed_official 610:813dcc80987e 1812
mbed_official 610:813dcc80987e 1813 /* end of injected sequence, reset the value */
mbed_official 610:813dcc80987e 1814 hdfsdm_filter->InjConvRemaining = (hdfsdm_filter->InjectedScanMode == ENABLE) ? \
mbed_official 610:813dcc80987e 1815 hdfsdm_filter->InjectedChannelsNbr : 1;
mbed_official 610:813dcc80987e 1816 }
mbed_official 610:813dcc80987e 1817
mbed_official 610:813dcc80987e 1818 /* Return function status */
mbed_official 610:813dcc80987e 1819 return HAL_OK;
mbed_official 610:813dcc80987e 1820 }
mbed_official 610:813dcc80987e 1821 }
mbed_official 610:813dcc80987e 1822
mbed_official 610:813dcc80987e 1823 /**
mbed_official 610:813dcc80987e 1824 * @brief This function allows to stop injected conversion in polling mode.
mbed_official 610:813dcc80987e 1825 * @note This function should be called only if injected conversion is ongoing.
mbed_official 610:813dcc80987e 1826 * @param hdfsdm_filter : DFSDM filter handle.
mbed_official 610:813dcc80987e 1827 * @retval HAL status
mbed_official 610:813dcc80987e 1828 */
mbed_official 610:813dcc80987e 1829 HAL_StatusTypeDef HAL_DFSDM_FilterInjectedStop(DFSDM_Filter_HandleTypeDef *hdfsdm_filter)
mbed_official 610:813dcc80987e 1830 {
mbed_official 610:813dcc80987e 1831 HAL_StatusTypeDef status = HAL_OK;
mbed_official 610:813dcc80987e 1832
mbed_official 610:813dcc80987e 1833 /* Check parameters */
mbed_official 610:813dcc80987e 1834 assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
mbed_official 610:813dcc80987e 1835
mbed_official 610:813dcc80987e 1836 /* Check DFSDM filter state */
mbed_official 610:813dcc80987e 1837 if((hdfsdm_filter->State != HAL_DFSDM_FILTER_STATE_INJ) && \
mbed_official 610:813dcc80987e 1838 (hdfsdm_filter->State != HAL_DFSDM_FILTER_STATE_REG_INJ))
mbed_official 610:813dcc80987e 1839 {
mbed_official 610:813dcc80987e 1840 /* Return error status */
mbed_official 610:813dcc80987e 1841 status = HAL_ERROR;
mbed_official 610:813dcc80987e 1842 }
mbed_official 610:813dcc80987e 1843 else
mbed_official 610:813dcc80987e 1844 {
mbed_official 610:813dcc80987e 1845 /* Stop injected conversion */
mbed_official 610:813dcc80987e 1846 DFSDM_InjConvStop(hdfsdm_filter);
mbed_official 610:813dcc80987e 1847 }
mbed_official 610:813dcc80987e 1848 /* Return function status */
mbed_official 610:813dcc80987e 1849 return status;
mbed_official 610:813dcc80987e 1850 }
mbed_official 610:813dcc80987e 1851
mbed_official 610:813dcc80987e 1852 /**
mbed_official 610:813dcc80987e 1853 * @brief This function allows to start injected conversion in interrupt mode.
mbed_official 610:813dcc80987e 1854 * @note This function should be called only when DFSDM filter instance is
mbed_official 610:813dcc80987e 1855 * in idle state or if regular conversion is ongoing.
mbed_official 610:813dcc80987e 1856 * @param hdfsdm_filter : DFSDM filter handle.
mbed_official 610:813dcc80987e 1857 * @retval HAL status
mbed_official 610:813dcc80987e 1858 */
mbed_official 610:813dcc80987e 1859 HAL_StatusTypeDef HAL_DFSDM_FilterInjectedStart_IT(DFSDM_Filter_HandleTypeDef *hdfsdm_filter)
mbed_official 610:813dcc80987e 1860 {
mbed_official 610:813dcc80987e 1861 HAL_StatusTypeDef status = HAL_OK;
mbed_official 610:813dcc80987e 1862
mbed_official 610:813dcc80987e 1863 /* Check parameters */
mbed_official 610:813dcc80987e 1864 assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
mbed_official 610:813dcc80987e 1865
mbed_official 610:813dcc80987e 1866 /* Check DFSDM filter state */
mbed_official 610:813dcc80987e 1867 if((hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_READY) || \
mbed_official 610:813dcc80987e 1868 (hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_REG))
mbed_official 610:813dcc80987e 1869 {
mbed_official 610:813dcc80987e 1870 /* Enable interrupts for injected conversions */
mbed_official 610:813dcc80987e 1871 hdfsdm_filter->Instance->CR2 |= (DFSDM_CR2_JEOCIE | DFSDM_CR2_JOVRIE);
mbed_official 610:813dcc80987e 1872
mbed_official 610:813dcc80987e 1873 /* Start injected conversion */
mbed_official 610:813dcc80987e 1874 DFSDM_InjConvStart(hdfsdm_filter);
mbed_official 610:813dcc80987e 1875 }
mbed_official 610:813dcc80987e 1876 else
mbed_official 610:813dcc80987e 1877 {
mbed_official 610:813dcc80987e 1878 status = HAL_ERROR;
mbed_official 610:813dcc80987e 1879 }
mbed_official 610:813dcc80987e 1880 /* Return function status */
mbed_official 610:813dcc80987e 1881 return status;
mbed_official 610:813dcc80987e 1882 }
mbed_official 610:813dcc80987e 1883
mbed_official 610:813dcc80987e 1884 /**
mbed_official 610:813dcc80987e 1885 * @brief This function allows to stop injected conversion in interrupt mode.
mbed_official 610:813dcc80987e 1886 * @note This function should be called only if injected conversion is ongoing.
mbed_official 610:813dcc80987e 1887 * @param hdfsdm_filter : DFSDM filter handle.
mbed_official 610:813dcc80987e 1888 * @retval HAL status
mbed_official 610:813dcc80987e 1889 */
mbed_official 610:813dcc80987e 1890 HAL_StatusTypeDef HAL_DFSDM_FilterInjectedStop_IT(DFSDM_Filter_HandleTypeDef *hdfsdm_filter)
mbed_official 610:813dcc80987e 1891 {
mbed_official 610:813dcc80987e 1892 HAL_StatusTypeDef status = HAL_OK;
mbed_official 610:813dcc80987e 1893
mbed_official 610:813dcc80987e 1894 /* Check parameters */
mbed_official 610:813dcc80987e 1895 assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
mbed_official 610:813dcc80987e 1896
mbed_official 610:813dcc80987e 1897 /* Check DFSDM filter state */
mbed_official 610:813dcc80987e 1898 if((hdfsdm_filter->State != HAL_DFSDM_FILTER_STATE_INJ) && \
mbed_official 610:813dcc80987e 1899 (hdfsdm_filter->State != HAL_DFSDM_FILTER_STATE_REG_INJ))
mbed_official 610:813dcc80987e 1900 {
mbed_official 610:813dcc80987e 1901 /* Return error status */
mbed_official 610:813dcc80987e 1902 status = HAL_ERROR;
mbed_official 610:813dcc80987e 1903 }
mbed_official 610:813dcc80987e 1904 else
mbed_official 610:813dcc80987e 1905 {
mbed_official 610:813dcc80987e 1906 /* Disable interrupts for injected conversions */
mbed_official 610:813dcc80987e 1907 hdfsdm_filter->Instance->CR2 &= ~(DFSDM_CR2_JEOCIE | DFSDM_CR2_JOVRIE);
mbed_official 610:813dcc80987e 1908
mbed_official 610:813dcc80987e 1909 /* Stop injected conversion */
mbed_official 610:813dcc80987e 1910 DFSDM_InjConvStop(hdfsdm_filter);
mbed_official 610:813dcc80987e 1911 }
mbed_official 610:813dcc80987e 1912 /* Return function status */
mbed_official 610:813dcc80987e 1913 return status;
mbed_official 610:813dcc80987e 1914 }
mbed_official 610:813dcc80987e 1915
mbed_official 610:813dcc80987e 1916 /**
mbed_official 610:813dcc80987e 1917 * @brief This function allows to start injected conversion in DMA mode.
mbed_official 610:813dcc80987e 1918 * @note This function should be called only when DFSDM filter instance is
mbed_official 610:813dcc80987e 1919 * in idle state or if regular conversion is ongoing.
mbed_official 610:813dcc80987e 1920 * Please note that data on buffer will contain signed injected conversion
mbed_official 610:813dcc80987e 1921 * value on 24 most significant bits and corresponding channel on 3 least
mbed_official 610:813dcc80987e 1922 * significant bits.
mbed_official 610:813dcc80987e 1923 * @param hdfsdm_filter : DFSDM filter handle.
mbed_official 610:813dcc80987e 1924 * @param pData : The destination buffer address.
mbed_official 610:813dcc80987e 1925 * @param Length : The length of data to be transferred from DFSDM filter to memory.
mbed_official 610:813dcc80987e 1926 * @retval HAL status
mbed_official 610:813dcc80987e 1927 */
mbed_official 610:813dcc80987e 1928 HAL_StatusTypeDef HAL_DFSDM_FilterInjectedStart_DMA(DFSDM_Filter_HandleTypeDef *hdfsdm_filter,
mbed_official 610:813dcc80987e 1929 int32_t *pData,
mbed_official 610:813dcc80987e 1930 uint32_t Length)
mbed_official 610:813dcc80987e 1931 {
mbed_official 610:813dcc80987e 1932 HAL_StatusTypeDef status = HAL_OK;
mbed_official 610:813dcc80987e 1933
mbed_official 610:813dcc80987e 1934 /* Check parameters */
mbed_official 610:813dcc80987e 1935 assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
mbed_official 610:813dcc80987e 1936
mbed_official 610:813dcc80987e 1937 /* Check destination address and length */
mbed_official 610:813dcc80987e 1938 if((pData == NULL) || (Length == 0))
mbed_official 610:813dcc80987e 1939 {
mbed_official 610:813dcc80987e 1940 status = HAL_ERROR;
mbed_official 610:813dcc80987e 1941 }
mbed_official 610:813dcc80987e 1942 /* Check that DMA is enabled for injected conversion */
mbed_official 610:813dcc80987e 1943 else if((hdfsdm_filter->Instance->CR1 & DFSDM_CR1_JDMAEN) != DFSDM_CR1_JDMAEN)
mbed_official 610:813dcc80987e 1944 {
mbed_official 610:813dcc80987e 1945 status = HAL_ERROR;
mbed_official 610:813dcc80987e 1946 }
mbed_official 610:813dcc80987e 1947 /* Check parameters compatibility */
mbed_official 610:813dcc80987e 1948 else if((hdfsdm_filter->InjectedTrigger == DFSDM_FILTER_SW_TRIGGER) && \
mbed_official 610:813dcc80987e 1949 (hdfsdm_filter->hdmaInj->Init.Mode == DMA_NORMAL) && \
mbed_official 610:813dcc80987e 1950 (Length > hdfsdm_filter->InjConvRemaining))
mbed_official 610:813dcc80987e 1951 {
mbed_official 610:813dcc80987e 1952 status = HAL_ERROR;
mbed_official 610:813dcc80987e 1953 }
mbed_official 610:813dcc80987e 1954 else if((hdfsdm_filter->InjectedTrigger == DFSDM_FILTER_SW_TRIGGER) && \
mbed_official 610:813dcc80987e 1955 (hdfsdm_filter->hdmaInj->Init.Mode == DMA_CIRCULAR))
mbed_official 610:813dcc80987e 1956 {
mbed_official 610:813dcc80987e 1957 status = HAL_ERROR;
mbed_official 610:813dcc80987e 1958 }
mbed_official 610:813dcc80987e 1959 /* Check DFSDM filter state */
mbed_official 610:813dcc80987e 1960 else if((hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_READY) || \
mbed_official 610:813dcc80987e 1961 (hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_REG))
mbed_official 610:813dcc80987e 1962 {
mbed_official 610:813dcc80987e 1963 /* Set callbacks on DMA handler */
mbed_official 610:813dcc80987e 1964 hdfsdm_filter->hdmaInj->XferCpltCallback = DFSDM_DMAInjectedConvCplt;
mbed_official 610:813dcc80987e 1965 hdfsdm_filter->hdmaInj->XferErrorCallback = DFSDM_DMAError;
mbed_official 610:813dcc80987e 1966 hdfsdm_filter->hdmaInj->XferHalfCpltCallback = (hdfsdm_filter->hdmaInj->Init.Mode == DMA_CIRCULAR) ?\
mbed_official 610:813dcc80987e 1967 DFSDM_DMAInjectedHalfConvCplt : NULL;
mbed_official 610:813dcc80987e 1968
mbed_official 610:813dcc80987e 1969 /* Start DMA in interrupt mode */
mbed_official 610:813dcc80987e 1970 if(HAL_DMA_Start_IT(hdfsdm_filter->hdmaInj, (uint32_t)&hdfsdm_filter->Instance->JDATAR, \
mbed_official 610:813dcc80987e 1971 (uint32_t) pData, Length) != HAL_OK)
mbed_official 610:813dcc80987e 1972 {
mbed_official 610:813dcc80987e 1973 /* Set DFSDM filter in error state */
mbed_official 610:813dcc80987e 1974 hdfsdm_filter->State = HAL_DFSDM_FILTER_STATE_ERROR;
mbed_official 610:813dcc80987e 1975 status = HAL_ERROR;
mbed_official 610:813dcc80987e 1976 }
mbed_official 610:813dcc80987e 1977 else
mbed_official 610:813dcc80987e 1978 {
mbed_official 610:813dcc80987e 1979 /* Start injected conversion */
mbed_official 610:813dcc80987e 1980 DFSDM_InjConvStart(hdfsdm_filter);
mbed_official 610:813dcc80987e 1981 }
mbed_official 610:813dcc80987e 1982 }
mbed_official 610:813dcc80987e 1983 else
mbed_official 610:813dcc80987e 1984 {
mbed_official 610:813dcc80987e 1985 status = HAL_ERROR;
mbed_official 610:813dcc80987e 1986 }
mbed_official 610:813dcc80987e 1987 /* Return function status */
mbed_official 610:813dcc80987e 1988 return status;
mbed_official 610:813dcc80987e 1989 }
mbed_official 610:813dcc80987e 1990
mbed_official 610:813dcc80987e 1991 /**
mbed_official 610:813dcc80987e 1992 * @brief This function allows to start injected conversion in DMA mode and to get
mbed_official 610:813dcc80987e 1993 * only the 16 most significant bits of conversion.
mbed_official 610:813dcc80987e 1994 * @note This function should be called only when DFSDM filter instance is
mbed_official 610:813dcc80987e 1995 * in idle state or if regular conversion is ongoing.
mbed_official 610:813dcc80987e 1996 * Please note that data on buffer will contain signed 16 most significant
mbed_official 610:813dcc80987e 1997 * bits of injected conversion.
mbed_official 610:813dcc80987e 1998 * @param hdfsdm_filter : DFSDM filter handle.
mbed_official 610:813dcc80987e 1999 * @param pData : The destination buffer address.
mbed_official 610:813dcc80987e 2000 * @param Length : The length of data to be transferred from DFSDM filter to memory.
mbed_official 610:813dcc80987e 2001 * @retval HAL status
mbed_official 610:813dcc80987e 2002 */
mbed_official 610:813dcc80987e 2003 HAL_StatusTypeDef HAL_DFSDM_FilterInjectedMsbStart_DMA(DFSDM_Filter_HandleTypeDef *hdfsdm_filter,
mbed_official 610:813dcc80987e 2004 int16_t *pData,
mbed_official 610:813dcc80987e 2005 uint32_t Length)
mbed_official 610:813dcc80987e 2006 {
mbed_official 610:813dcc80987e 2007 HAL_StatusTypeDef status = HAL_OK;
mbed_official 610:813dcc80987e 2008
mbed_official 610:813dcc80987e 2009 /* Check parameters */
mbed_official 610:813dcc80987e 2010 assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
mbed_official 610:813dcc80987e 2011
mbed_official 610:813dcc80987e 2012 /* Check destination address and length */
mbed_official 610:813dcc80987e 2013 if((pData == NULL) || (Length == 0))
mbed_official 610:813dcc80987e 2014 {
mbed_official 610:813dcc80987e 2015 status = HAL_ERROR;
mbed_official 610:813dcc80987e 2016 }
mbed_official 610:813dcc80987e 2017 /* Check that DMA is enabled for injected conversion */
mbed_official 610:813dcc80987e 2018 else if((hdfsdm_filter->Instance->CR1 & DFSDM_CR1_JDMAEN) != DFSDM_CR1_JDMAEN)
mbed_official 610:813dcc80987e 2019 {
mbed_official 610:813dcc80987e 2020 status = HAL_ERROR;
mbed_official 610:813dcc80987e 2021 }
mbed_official 610:813dcc80987e 2022 /* Check parameters compatibility */
mbed_official 610:813dcc80987e 2023 else if((hdfsdm_filter->InjectedTrigger == DFSDM_FILTER_SW_TRIGGER) && \
mbed_official 610:813dcc80987e 2024 (hdfsdm_filter->hdmaInj->Init.Mode == DMA_NORMAL) && \
mbed_official 610:813dcc80987e 2025 (Length > hdfsdm_filter->InjConvRemaining))
mbed_official 610:813dcc80987e 2026 {
mbed_official 610:813dcc80987e 2027 status = HAL_ERROR;
mbed_official 610:813dcc80987e 2028 }
mbed_official 610:813dcc80987e 2029 else if((hdfsdm_filter->InjectedTrigger == DFSDM_FILTER_SW_TRIGGER) && \
mbed_official 610:813dcc80987e 2030 (hdfsdm_filter->hdmaInj->Init.Mode == DMA_CIRCULAR))
mbed_official 610:813dcc80987e 2031 {
mbed_official 610:813dcc80987e 2032 status = HAL_ERROR;
mbed_official 610:813dcc80987e 2033 }
mbed_official 610:813dcc80987e 2034 /* Check DFSDM filter state */
mbed_official 610:813dcc80987e 2035 else if((hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_READY) || \
mbed_official 610:813dcc80987e 2036 (hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_REG))
mbed_official 610:813dcc80987e 2037 {
mbed_official 610:813dcc80987e 2038 /* Set callbacks on DMA handler */
mbed_official 610:813dcc80987e 2039 hdfsdm_filter->hdmaInj->XferCpltCallback = DFSDM_DMAInjectedConvCplt;
mbed_official 610:813dcc80987e 2040 hdfsdm_filter->hdmaInj->XferErrorCallback = DFSDM_DMAError;
mbed_official 610:813dcc80987e 2041 hdfsdm_filter->hdmaInj->XferHalfCpltCallback = (hdfsdm_filter->hdmaInj->Init.Mode == DMA_CIRCULAR) ?\
mbed_official 610:813dcc80987e 2042 DFSDM_DMAInjectedHalfConvCplt : NULL;
mbed_official 610:813dcc80987e 2043
mbed_official 610:813dcc80987e 2044 /* Start DMA in interrupt mode */
mbed_official 610:813dcc80987e 2045 if(HAL_DMA_Start_IT(hdfsdm_filter->hdmaInj, (uint32_t)(&hdfsdm_filter->Instance->JDATAR) + 2, \
mbed_official 610:813dcc80987e 2046 (uint32_t) pData, Length) != HAL_OK)
mbed_official 610:813dcc80987e 2047 {
mbed_official 610:813dcc80987e 2048 /* Set DFSDM filter in error state */
mbed_official 610:813dcc80987e 2049 hdfsdm_filter->State = HAL_DFSDM_FILTER_STATE_ERROR;
mbed_official 610:813dcc80987e 2050 status = HAL_ERROR;
mbed_official 610:813dcc80987e 2051 }
mbed_official 610:813dcc80987e 2052 else
mbed_official 610:813dcc80987e 2053 {
mbed_official 610:813dcc80987e 2054 /* Start injected conversion */
mbed_official 610:813dcc80987e 2055 DFSDM_InjConvStart(hdfsdm_filter);
mbed_official 610:813dcc80987e 2056 }
mbed_official 610:813dcc80987e 2057 }
mbed_official 610:813dcc80987e 2058 else
mbed_official 610:813dcc80987e 2059 {
mbed_official 610:813dcc80987e 2060 status = HAL_ERROR;
mbed_official 610:813dcc80987e 2061 }
mbed_official 610:813dcc80987e 2062 /* Return function status */
mbed_official 610:813dcc80987e 2063 return status;
mbed_official 610:813dcc80987e 2064 }
mbed_official 610:813dcc80987e 2065
mbed_official 610:813dcc80987e 2066 /**
mbed_official 610:813dcc80987e 2067 * @brief This function allows to stop injected conversion in DMA mode.
mbed_official 610:813dcc80987e 2068 * @note This function should be called only if injected conversion is ongoing.
mbed_official 610:813dcc80987e 2069 * @param hdfsdm_filter : DFSDM filter handle.
mbed_official 610:813dcc80987e 2070 * @retval HAL status
mbed_official 610:813dcc80987e 2071 */
mbed_official 610:813dcc80987e 2072 HAL_StatusTypeDef HAL_DFSDM_FilterInjectedStop_DMA(DFSDM_Filter_HandleTypeDef *hdfsdm_filter)
mbed_official 610:813dcc80987e 2073 {
mbed_official 610:813dcc80987e 2074 HAL_StatusTypeDef status = HAL_OK;
mbed_official 610:813dcc80987e 2075
mbed_official 610:813dcc80987e 2076 /* Check parameters */
mbed_official 610:813dcc80987e 2077 assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
mbed_official 610:813dcc80987e 2078
mbed_official 610:813dcc80987e 2079 /* Check DFSDM filter state */
mbed_official 610:813dcc80987e 2080 if((hdfsdm_filter->State != HAL_DFSDM_FILTER_STATE_INJ) && \
mbed_official 610:813dcc80987e 2081 (hdfsdm_filter->State != HAL_DFSDM_FILTER_STATE_REG_INJ))
mbed_official 610:813dcc80987e 2082 {
mbed_official 610:813dcc80987e 2083 /* Return error status */
mbed_official 610:813dcc80987e 2084 status = HAL_ERROR;
mbed_official 610:813dcc80987e 2085 }
mbed_official 610:813dcc80987e 2086 else
mbed_official 610:813dcc80987e 2087 {
mbed_official 610:813dcc80987e 2088 /* Stop current DMA transfer */
mbed_official 610:813dcc80987e 2089 if(HAL_DMA_Abort(hdfsdm_filter->hdmaInj) != HAL_OK)
mbed_official 610:813dcc80987e 2090 {
mbed_official 610:813dcc80987e 2091 /* Set DFSDM filter in error state */
mbed_official 610:813dcc80987e 2092 hdfsdm_filter->State = HAL_DFSDM_FILTER_STATE_ERROR;
mbed_official 610:813dcc80987e 2093 status = HAL_ERROR;
mbed_official 610:813dcc80987e 2094 }
mbed_official 610:813dcc80987e 2095 else
mbed_official 610:813dcc80987e 2096 {
mbed_official 610:813dcc80987e 2097 /* Stop regular conversion */
mbed_official 610:813dcc80987e 2098 DFSDM_InjConvStop(hdfsdm_filter);
mbed_official 610:813dcc80987e 2099 }
mbed_official 610:813dcc80987e 2100 }
mbed_official 610:813dcc80987e 2101 /* Return function status */
mbed_official 610:813dcc80987e 2102 return status;
mbed_official 610:813dcc80987e 2103 }
mbed_official 610:813dcc80987e 2104
mbed_official 610:813dcc80987e 2105 /**
mbed_official 610:813dcc80987e 2106 * @brief This function allows to get injected conversion value.
mbed_official 610:813dcc80987e 2107 * @param hdfsdm_filter : DFSDM filter handle.
mbed_official 610:813dcc80987e 2108 * @param Channel : Corresponding channel of injected conversion.
mbed_official 610:813dcc80987e 2109 * @retval Injected conversion value
mbed_official 610:813dcc80987e 2110 */
mbed_official 610:813dcc80987e 2111 int32_t HAL_DFSDM_FilterGetInjectedValue(DFSDM_Filter_HandleTypeDef *hdfsdm_filter,
mbed_official 610:813dcc80987e 2112 uint32_t *Channel)
mbed_official 610:813dcc80987e 2113 {
mbed_official 610:813dcc80987e 2114 uint32_t reg = 0;
mbed_official 610:813dcc80987e 2115 int32_t value = 0;
mbed_official 610:813dcc80987e 2116
mbed_official 610:813dcc80987e 2117 /* Check parameters */
mbed_official 610:813dcc80987e 2118 assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
mbed_official 610:813dcc80987e 2119 assert_param(Channel != NULL);
mbed_official 610:813dcc80987e 2120
mbed_official 610:813dcc80987e 2121 /* Get value of data register for injected channel */
mbed_official 610:813dcc80987e 2122 reg = hdfsdm_filter->Instance->JDATAR;
mbed_official 610:813dcc80987e 2123
mbed_official 610:813dcc80987e 2124 /* Extract channel and injected conversion value */
mbed_official 610:813dcc80987e 2125 *Channel = (reg & DFSDM_JDATAR_JDATACH);
mbed_official 610:813dcc80987e 2126 value = ((int32_t)(reg & DFSDM_JDATAR_JDATA) >> DFSDM_JDATAR_DATA_OFFSET);
mbed_official 610:813dcc80987e 2127
mbed_official 610:813dcc80987e 2128 /* return regular conversion value */
mbed_official 610:813dcc80987e 2129 return value;
mbed_official 610:813dcc80987e 2130 }
mbed_official 610:813dcc80987e 2131
mbed_official 610:813dcc80987e 2132 /**
mbed_official 610:813dcc80987e 2133 * @brief This function allows to start filter analog watchdog in interrupt mode.
mbed_official 610:813dcc80987e 2134 * @param hdfsdm_filter : DFSDM filter handle.
mbed_official 610:813dcc80987e 2135 * @param awdParam : DFSDM filter analog watchdog parameters.
mbed_official 610:813dcc80987e 2136 * @retval HAL status
mbed_official 610:813dcc80987e 2137 */
mbed_official 610:813dcc80987e 2138 HAL_StatusTypeDef HAL_DFSDM_FilterAwdStart_IT(DFSDM_Filter_HandleTypeDef *hdfsdm_filter,
mbed_official 610:813dcc80987e 2139 DFSDM_Filter_AwdParamTypeDef *awdParam)
mbed_official 610:813dcc80987e 2140 {
mbed_official 610:813dcc80987e 2141 HAL_StatusTypeDef status = HAL_OK;
mbed_official 610:813dcc80987e 2142
mbed_official 610:813dcc80987e 2143 /* Check parameters */
mbed_official 610:813dcc80987e 2144 assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
mbed_official 610:813dcc80987e 2145 assert_param(IS_DFSDM_FILTER_AWD_DATA_SOURCE(awdParam->DataSource));
mbed_official 610:813dcc80987e 2146 assert_param(IS_DFSDM_INJECTED_CHANNEL(awdParam->Channel));
mbed_official 610:813dcc80987e 2147 assert_param(IS_DFSDM_FILTER_AWD_THRESHOLD(awdParam->HighThreshold));
mbed_official 610:813dcc80987e 2148 assert_param(IS_DFSDM_FILTER_AWD_THRESHOLD(awdParam->LowThreshold));
mbed_official 610:813dcc80987e 2149 assert_param(IS_DFSDM_BREAK_SIGNALS(awdParam->HighBreakSignal));
mbed_official 610:813dcc80987e 2150 assert_param(IS_DFSDM_BREAK_SIGNALS(awdParam->LowBreakSignal));
mbed_official 610:813dcc80987e 2151
mbed_official 610:813dcc80987e 2152 /* Check DFSDM filter state */
mbed_official 610:813dcc80987e 2153 if((hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_RESET) || \
mbed_official 610:813dcc80987e 2154 (hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_ERROR))
mbed_official 610:813dcc80987e 2155 {
mbed_official 610:813dcc80987e 2156 /* Return error status */
mbed_official 610:813dcc80987e 2157 status = HAL_ERROR;
mbed_official 610:813dcc80987e 2158 }
mbed_official 610:813dcc80987e 2159 else
mbed_official 610:813dcc80987e 2160 {
mbed_official 610:813dcc80987e 2161 /* Set analog watchdog data source */
mbed_official 610:813dcc80987e 2162 hdfsdm_filter->Instance->CR1 &= ~(DFSDM_CR1_AWFSEL);
mbed_official 610:813dcc80987e 2163 hdfsdm_filter->Instance->CR1 |= awdParam->DataSource;
mbed_official 610:813dcc80987e 2164
mbed_official 610:813dcc80987e 2165 /* Set thresholds and break signals */
mbed_official 610:813dcc80987e 2166 hdfsdm_filter->Instance->AWHTR &= ~(DFSDM_AWHTR_AWHT | DFSDM_AWHTR_BKAWH);
mbed_official 610:813dcc80987e 2167 hdfsdm_filter->Instance->AWHTR |= ((awdParam->HighThreshold << DFSDM_AWHTR_THRESHOLD_OFFSET) | \
mbed_official 610:813dcc80987e 2168 awdParam->HighBreakSignal);
mbed_official 610:813dcc80987e 2169 hdfsdm_filter->Instance->AWLTR &= ~(DFSDM_AWLTR_AWLT | DFSDM_AWLTR_BKAWL);
mbed_official 610:813dcc80987e 2170 hdfsdm_filter->Instance->AWLTR |= ((awdParam->LowThreshold << DFSDM_AWLTR_THRESHOLD_OFFSET) | \
mbed_official 610:813dcc80987e 2171 awdParam->LowBreakSignal);
mbed_official 610:813dcc80987e 2172
mbed_official 610:813dcc80987e 2173 /* Set channels and interrupt for analog watchdog */
mbed_official 610:813dcc80987e 2174 hdfsdm_filter->Instance->CR2 &= ~(DFSDM_CR2_AWDCH);
mbed_official 610:813dcc80987e 2175 hdfsdm_filter->Instance->CR2 |= (((awdParam->Channel & DFSDM_LSB_MASK) << DFSDM_CR2_AWDCH_OFFSET) | \
mbed_official 610:813dcc80987e 2176 DFSDM_CR2_AWDIE);
mbed_official 610:813dcc80987e 2177 }
mbed_official 610:813dcc80987e 2178 /* Return function status */
mbed_official 610:813dcc80987e 2179 return status;
mbed_official 610:813dcc80987e 2180 }
mbed_official 610:813dcc80987e 2181
mbed_official 610:813dcc80987e 2182 /**
mbed_official 610:813dcc80987e 2183 * @brief This function allows to stop filter analog watchdog in interrupt mode.
mbed_official 610:813dcc80987e 2184 * @param hdfsdm_filter : DFSDM filter handle.
mbed_official 610:813dcc80987e 2185 * @retval HAL status
mbed_official 610:813dcc80987e 2186 */
mbed_official 610:813dcc80987e 2187 HAL_StatusTypeDef HAL_DFSDM_FilterAwdStop_IT(DFSDM_Filter_HandleTypeDef *hdfsdm_filter)
mbed_official 610:813dcc80987e 2188 {
mbed_official 610:813dcc80987e 2189 HAL_StatusTypeDef status = HAL_OK;
mbed_official 610:813dcc80987e 2190
mbed_official 610:813dcc80987e 2191 /* Check parameters */
mbed_official 610:813dcc80987e 2192 assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
mbed_official 610:813dcc80987e 2193
mbed_official 610:813dcc80987e 2194 /* Check DFSDM filter state */
mbed_official 610:813dcc80987e 2195 if((hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_RESET) || \
mbed_official 610:813dcc80987e 2196 (hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_ERROR))
mbed_official 610:813dcc80987e 2197 {
mbed_official 610:813dcc80987e 2198 /* Return error status */
mbed_official 610:813dcc80987e 2199 status = HAL_ERROR;
mbed_official 610:813dcc80987e 2200 }
mbed_official 610:813dcc80987e 2201 else
mbed_official 610:813dcc80987e 2202 {
mbed_official 610:813dcc80987e 2203 /* Reset channels for analog watchdog and deactivate interrupt */
mbed_official 610:813dcc80987e 2204 hdfsdm_filter->Instance->CR2 &= ~(DFSDM_CR2_AWDCH | DFSDM_CR2_AWDIE);
mbed_official 610:813dcc80987e 2205
mbed_official 610:813dcc80987e 2206 /* Clear all analog watchdog flags */
mbed_official 610:813dcc80987e 2207 hdfsdm_filter->Instance->AWCFR = (DFSDM_AWCFR_CLRAWHTF | DFSDM_AWCFR_CLRAWLTF);
mbed_official 610:813dcc80987e 2208
mbed_official 610:813dcc80987e 2209 /* Reset thresholds and break signals */
mbed_official 610:813dcc80987e 2210 hdfsdm_filter->Instance->AWHTR &= ~(DFSDM_AWHTR_AWHT | DFSDM_AWHTR_BKAWH);
mbed_official 610:813dcc80987e 2211 hdfsdm_filter->Instance->AWLTR &= ~(DFSDM_AWLTR_AWLT | DFSDM_AWLTR_BKAWL);
mbed_official 610:813dcc80987e 2212
mbed_official 610:813dcc80987e 2213 /* Reset analog watchdog data source */
mbed_official 610:813dcc80987e 2214 hdfsdm_filter->Instance->CR1 &= ~(DFSDM_CR1_AWFSEL);
mbed_official 610:813dcc80987e 2215 }
mbed_official 610:813dcc80987e 2216 /* Return function status */
mbed_official 610:813dcc80987e 2217 return status;
mbed_official 610:813dcc80987e 2218 }
mbed_official 610:813dcc80987e 2219
mbed_official 610:813dcc80987e 2220 /**
mbed_official 610:813dcc80987e 2221 * @brief This function allows to start extreme detector feature.
mbed_official 610:813dcc80987e 2222 * @param hdfsdm_filter : DFSDM filter handle.
mbed_official 610:813dcc80987e 2223 * @param Channel : Channels where extreme detector is enabled.
mbed_official 610:813dcc80987e 2224 * This parameter can be a values combination of @ref DFSDM_Channel_Selection.
mbed_official 610:813dcc80987e 2225 * @retval HAL status
mbed_official 610:813dcc80987e 2226 */
mbed_official 610:813dcc80987e 2227 HAL_StatusTypeDef HAL_DFSDM_FilterExdStart(DFSDM_Filter_HandleTypeDef *hdfsdm_filter,
mbed_official 610:813dcc80987e 2228 uint32_t Channel)
mbed_official 610:813dcc80987e 2229 {
mbed_official 610:813dcc80987e 2230 HAL_StatusTypeDef status = HAL_OK;
mbed_official 610:813dcc80987e 2231
mbed_official 610:813dcc80987e 2232 /* Check parameters */
mbed_official 610:813dcc80987e 2233 assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
mbed_official 610:813dcc80987e 2234 assert_param(IS_DFSDM_INJECTED_CHANNEL(Channel));
mbed_official 610:813dcc80987e 2235
mbed_official 610:813dcc80987e 2236 /* Check DFSDM filter state */
mbed_official 610:813dcc80987e 2237 if((hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_RESET) || \
mbed_official 610:813dcc80987e 2238 (hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_ERROR))
mbed_official 610:813dcc80987e 2239 {
mbed_official 610:813dcc80987e 2240 /* Return error status */
mbed_official 610:813dcc80987e 2241 status = HAL_ERROR;
mbed_official 610:813dcc80987e 2242 }
mbed_official 610:813dcc80987e 2243 else
mbed_official 610:813dcc80987e 2244 {
mbed_official 610:813dcc80987e 2245 /* Set channels for extreme detector */
mbed_official 610:813dcc80987e 2246 hdfsdm_filter->Instance->CR2 &= ~(DFSDM_CR2_EXCH);
mbed_official 610:813dcc80987e 2247 hdfsdm_filter->Instance->CR2 |= ((Channel & DFSDM_LSB_MASK) << DFSDM_CR2_EXCH_OFFSET);
mbed_official 610:813dcc80987e 2248 }
mbed_official 610:813dcc80987e 2249 /* Return function status */
mbed_official 610:813dcc80987e 2250 return status;
mbed_official 610:813dcc80987e 2251 }
mbed_official 610:813dcc80987e 2252
mbed_official 610:813dcc80987e 2253 /**
mbed_official 610:813dcc80987e 2254 * @brief This function allows to stop extreme detector feature.
mbed_official 610:813dcc80987e 2255 * @param hdfsdm_filter : DFSDM filter handle.
mbed_official 610:813dcc80987e 2256 * @retval HAL status
mbed_official 610:813dcc80987e 2257 */
mbed_official 610:813dcc80987e 2258 HAL_StatusTypeDef HAL_DFSDM_FilterExdStop(DFSDM_Filter_HandleTypeDef *hdfsdm_filter)
mbed_official 610:813dcc80987e 2259 {
mbed_official 610:813dcc80987e 2260 HAL_StatusTypeDef status = HAL_OK;
mbed_official 610:813dcc80987e 2261 __IO uint32_t reg;
mbed_official 610:813dcc80987e 2262
mbed_official 610:813dcc80987e 2263 /* Check parameters */
mbed_official 610:813dcc80987e 2264 assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
mbed_official 610:813dcc80987e 2265
mbed_official 610:813dcc80987e 2266 /* Check DFSDM filter state */
mbed_official 610:813dcc80987e 2267 if((hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_RESET) || \
mbed_official 610:813dcc80987e 2268 (hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_ERROR))
mbed_official 610:813dcc80987e 2269 {
mbed_official 610:813dcc80987e 2270 /* Return error status */
mbed_official 610:813dcc80987e 2271 status = HAL_ERROR;
mbed_official 610:813dcc80987e 2272 }
mbed_official 610:813dcc80987e 2273 else
mbed_official 610:813dcc80987e 2274 {
mbed_official 610:813dcc80987e 2275 /* Reset channels for extreme detector */
mbed_official 610:813dcc80987e 2276 hdfsdm_filter->Instance->CR2 &= ~(DFSDM_CR2_EXCH);
mbed_official 610:813dcc80987e 2277
mbed_official 610:813dcc80987e 2278 /* Clear extreme detector values */
mbed_official 610:813dcc80987e 2279 reg = hdfsdm_filter->Instance->EXMAX;
mbed_official 610:813dcc80987e 2280 reg = hdfsdm_filter->Instance->EXMIN;
mbed_official 610:813dcc80987e 2281 UNUSED(reg); /* To avoid GCC warning */
mbed_official 610:813dcc80987e 2282 }
mbed_official 610:813dcc80987e 2283 /* Return function status */
mbed_official 610:813dcc80987e 2284 return status;
mbed_official 610:813dcc80987e 2285 }
mbed_official 610:813dcc80987e 2286
mbed_official 610:813dcc80987e 2287 /**
mbed_official 610:813dcc80987e 2288 * @brief This function allows to get extreme detector maximum value.
mbed_official 610:813dcc80987e 2289 * @param hdfsdm_filter : DFSDM filter handle.
mbed_official 610:813dcc80987e 2290 * @param Channel : Corresponding channel.
mbed_official 610:813dcc80987e 2291 * @retval Extreme detector maximum value
mbed_official 610:813dcc80987e 2292 * This value is between Min_Data = -8388608 and Max_Data = 8388607.
mbed_official 610:813dcc80987e 2293 */
mbed_official 610:813dcc80987e 2294 int32_t HAL_DFSDM_FilterGetExdMaxValue(DFSDM_Filter_HandleTypeDef *hdfsdm_filter,
mbed_official 610:813dcc80987e 2295 uint32_t *Channel)
mbed_official 610:813dcc80987e 2296 {
mbed_official 610:813dcc80987e 2297 uint32_t reg = 0;
mbed_official 610:813dcc80987e 2298 int32_t value = 0;
mbed_official 610:813dcc80987e 2299
mbed_official 610:813dcc80987e 2300 /* Check parameters */
mbed_official 610:813dcc80987e 2301 assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
mbed_official 610:813dcc80987e 2302 assert_param(Channel != NULL);
mbed_official 610:813dcc80987e 2303
mbed_official 610:813dcc80987e 2304 /* Get value of extreme detector maximum register */
mbed_official 610:813dcc80987e 2305 reg = hdfsdm_filter->Instance->EXMAX;
mbed_official 610:813dcc80987e 2306
mbed_official 610:813dcc80987e 2307 /* Extract channel and extreme detector maximum value */
mbed_official 610:813dcc80987e 2308 *Channel = (reg & DFSDM_EXMAX_EXMAXCH);
mbed_official 610:813dcc80987e 2309 value = ((int32_t)(reg & DFSDM_EXMAX_EXMAX) >> DFSDM_EXMAX_DATA_OFFSET);
mbed_official 610:813dcc80987e 2310
mbed_official 610:813dcc80987e 2311 /* return extreme detector maximum value */
mbed_official 610:813dcc80987e 2312 return value;
mbed_official 610:813dcc80987e 2313 }
mbed_official 610:813dcc80987e 2314
mbed_official 610:813dcc80987e 2315 /**
mbed_official 610:813dcc80987e 2316 * @brief This function allows to get extreme detector minimum value.
mbed_official 610:813dcc80987e 2317 * @param hdfsdm_filter : DFSDM filter handle.
mbed_official 610:813dcc80987e 2318 * @param Channel : Corresponding channel.
mbed_official 610:813dcc80987e 2319 * @retval Extreme detector minimum value
mbed_official 610:813dcc80987e 2320 * This value is between Min_Data = -8388608 and Max_Data = 8388607.
mbed_official 610:813dcc80987e 2321 */
mbed_official 610:813dcc80987e 2322 int32_t HAL_DFSDM_FilterGetExdMinValue(DFSDM_Filter_HandleTypeDef *hdfsdm_filter,
mbed_official 610:813dcc80987e 2323 uint32_t *Channel)
mbed_official 610:813dcc80987e 2324 {
mbed_official 610:813dcc80987e 2325 uint32_t reg = 0;
mbed_official 610:813dcc80987e 2326 int32_t value = 0;
mbed_official 610:813dcc80987e 2327
mbed_official 610:813dcc80987e 2328 /* Check parameters */
mbed_official 610:813dcc80987e 2329 assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
mbed_official 610:813dcc80987e 2330 assert_param(Channel != NULL);
mbed_official 610:813dcc80987e 2331
mbed_official 610:813dcc80987e 2332 /* Get value of extreme detector minimum register */
mbed_official 610:813dcc80987e 2333 reg = hdfsdm_filter->Instance->EXMIN;
mbed_official 610:813dcc80987e 2334
mbed_official 610:813dcc80987e 2335 /* Extract channel and extreme detector minimum value */
mbed_official 610:813dcc80987e 2336 *Channel = (reg & DFSDM_EXMIN_EXMINCH);
mbed_official 610:813dcc80987e 2337 value = ((int32_t)(reg & DFSDM_EXMIN_EXMIN) >> DFSDM_EXMIN_DATA_OFFSET);
mbed_official 610:813dcc80987e 2338
mbed_official 610:813dcc80987e 2339 /* return extreme detector minimum value */
mbed_official 610:813dcc80987e 2340 return value;
mbed_official 610:813dcc80987e 2341 }
mbed_official 610:813dcc80987e 2342
mbed_official 610:813dcc80987e 2343 /**
mbed_official 610:813dcc80987e 2344 * @brief This function allows to get conversion time value.
mbed_official 610:813dcc80987e 2345 * @param hdfsdm_filter : DFSDM filter handle.
mbed_official 610:813dcc80987e 2346 * @retval Conversion time value
mbed_official 610:813dcc80987e 2347 * @note To get time in second, this value has to be divided by DFSDM clock frequency.
mbed_official 610:813dcc80987e 2348 */
mbed_official 610:813dcc80987e 2349 uint32_t HAL_DFSDM_FilterGetConvTimeValue(DFSDM_Filter_HandleTypeDef *hdfsdm_filter)
mbed_official 610:813dcc80987e 2350 {
mbed_official 610:813dcc80987e 2351 uint32_t reg = 0;
mbed_official 610:813dcc80987e 2352 uint32_t value = 0;
mbed_official 610:813dcc80987e 2353
mbed_official 610:813dcc80987e 2354 /* Check parameters */
mbed_official 610:813dcc80987e 2355 assert_param(IS_DFSDM_FILTER_ALL_INSTANCE(hdfsdm_filter->Instance));
mbed_official 610:813dcc80987e 2356
mbed_official 610:813dcc80987e 2357 /* Get value of conversion timer register */
mbed_official 610:813dcc80987e 2358 reg = hdfsdm_filter->Instance->CNVTIMR;
mbed_official 610:813dcc80987e 2359
mbed_official 610:813dcc80987e 2360 /* Extract conversion time value */
mbed_official 610:813dcc80987e 2361 value = ((reg & DFSDM_CNVTIMR_CNVCNT) >> DFSDM_CNVTIMR_DATA_OFFSET);
mbed_official 610:813dcc80987e 2362
mbed_official 610:813dcc80987e 2363 /* return extreme detector minimum value */
mbed_official 610:813dcc80987e 2364 return value;
mbed_official 610:813dcc80987e 2365 }
mbed_official 610:813dcc80987e 2366
mbed_official 610:813dcc80987e 2367 /**
mbed_official 610:813dcc80987e 2368 * @brief This function handles the DFSDM interrupts.
mbed_official 610:813dcc80987e 2369 * @param hdfsdm_filter : DFSDM filter handle.
mbed_official 610:813dcc80987e 2370 * @retval None
mbed_official 610:813dcc80987e 2371 */
mbed_official 610:813dcc80987e 2372 void HAL_DFSDM_IRQHandler(DFSDM_Filter_HandleTypeDef *hdfsdm_filter)
mbed_official 610:813dcc80987e 2373 {
mbed_official 610:813dcc80987e 2374 /* Check if overrun occurs during regular conversion */
mbed_official 610:813dcc80987e 2375 if(((hdfsdm_filter->Instance->ISR & DFSDM_ISR_ROVRF) != 0) && \
mbed_official 610:813dcc80987e 2376 ((hdfsdm_filter->Instance->CR2 & DFSDM_CR2_ROVRIE) != 0))
mbed_official 610:813dcc80987e 2377 {
mbed_official 610:813dcc80987e 2378 /* Clear regular overrun flag */
mbed_official 610:813dcc80987e 2379 hdfsdm_filter->Instance->ICR = DFSDM_ICR_CLRROVRF;
mbed_official 610:813dcc80987e 2380
mbed_official 610:813dcc80987e 2381 /* Update error code */
mbed_official 610:813dcc80987e 2382 hdfsdm_filter->ErrorCode = DFSDM_FILTER_ERROR_REGULAR_OVERRUN;
mbed_official 610:813dcc80987e 2383
mbed_official 610:813dcc80987e 2384 /* Call error callback */
mbed_official 610:813dcc80987e 2385 HAL_DFSDM_FilterErrorCallback(hdfsdm_filter);
mbed_official 610:813dcc80987e 2386 }
mbed_official 610:813dcc80987e 2387 /* Check if overrun occurs during injected conversion */
mbed_official 610:813dcc80987e 2388 else if(((hdfsdm_filter->Instance->ISR & DFSDM_ISR_JOVRF) != 0) && \
mbed_official 610:813dcc80987e 2389 ((hdfsdm_filter->Instance->CR2 & DFSDM_CR2_JOVRIE) != 0))
mbed_official 610:813dcc80987e 2390 {
mbed_official 610:813dcc80987e 2391 /* Clear injected overrun flag */
mbed_official 610:813dcc80987e 2392 hdfsdm_filter->Instance->ICR = DFSDM_ICR_CLRJOVRF;
mbed_official 610:813dcc80987e 2393
mbed_official 610:813dcc80987e 2394 /* Update error code */
mbed_official 610:813dcc80987e 2395 hdfsdm_filter->ErrorCode = DFSDM_FILTER_ERROR_INJECTED_OVERRUN;
mbed_official 610:813dcc80987e 2396
mbed_official 610:813dcc80987e 2397 /* Call error callback */
mbed_official 610:813dcc80987e 2398 HAL_DFSDM_FilterErrorCallback(hdfsdm_filter);
mbed_official 610:813dcc80987e 2399 }
mbed_official 610:813dcc80987e 2400 /* Check if end of regular conversion */
mbed_official 610:813dcc80987e 2401 else if(((hdfsdm_filter->Instance->ISR & DFSDM_ISR_REOCF) != 0) && \
mbed_official 610:813dcc80987e 2402 ((hdfsdm_filter->Instance->CR2 & DFSDM_CR2_REOCIE) != 0))
mbed_official 610:813dcc80987e 2403 {
mbed_official 610:813dcc80987e 2404 /* Call regular conversion complete callback */
mbed_official 610:813dcc80987e 2405 HAL_DFSDM_FilterRegConvCpltCallback(hdfsdm_filter);
mbed_official 610:813dcc80987e 2406
mbed_official 610:813dcc80987e 2407 /* End of conversion if mode is not continuous and software trigger */
mbed_official 610:813dcc80987e 2408 if((hdfsdm_filter->RegularContMode == DFSDM_CONTINUOUS_CONV_OFF) && \
mbed_official 610:813dcc80987e 2409 (hdfsdm_filter->RegularTrigger == DFSDM_FILTER_SW_TRIGGER))
mbed_official 610:813dcc80987e 2410 {
mbed_official 610:813dcc80987e 2411 /* Disable interrupts for regular conversions */
mbed_official 610:813dcc80987e 2412 hdfsdm_filter->Instance->CR2 &= ~(DFSDM_CR2_REOCIE);
mbed_official 610:813dcc80987e 2413
mbed_official 610:813dcc80987e 2414 /* Update DFSDM filter state */
mbed_official 610:813dcc80987e 2415 hdfsdm_filter->State = (hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_REG) ? \
mbed_official 610:813dcc80987e 2416 HAL_DFSDM_FILTER_STATE_READY : HAL_DFSDM_FILTER_STATE_INJ;
mbed_official 610:813dcc80987e 2417 }
mbed_official 610:813dcc80987e 2418 }
mbed_official 610:813dcc80987e 2419 /* Check if end of injected conversion */
mbed_official 610:813dcc80987e 2420 else if(((hdfsdm_filter->Instance->ISR & DFSDM_ISR_JEOCF) != 0) && \
mbed_official 610:813dcc80987e 2421 ((hdfsdm_filter->Instance->CR2 & DFSDM_CR2_JEOCIE) != 0))
mbed_official 610:813dcc80987e 2422 {
mbed_official 610:813dcc80987e 2423 /* Call injected conversion complete callback */
mbed_official 610:813dcc80987e 2424 HAL_DFSDM_FilterInjConvCpltCallback(hdfsdm_filter);
mbed_official 610:813dcc80987e 2425
mbed_official 610:813dcc80987e 2426 /* Update remaining injected conversions */
mbed_official 610:813dcc80987e 2427 hdfsdm_filter->InjConvRemaining--;
mbed_official 610:813dcc80987e 2428 if(hdfsdm_filter->InjConvRemaining == 0)
mbed_official 610:813dcc80987e 2429 {
mbed_official 610:813dcc80987e 2430 /* End of conversion if trigger is software */
mbed_official 610:813dcc80987e 2431 if(hdfsdm_filter->InjectedTrigger == DFSDM_FILTER_SW_TRIGGER)
mbed_official 610:813dcc80987e 2432 {
mbed_official 610:813dcc80987e 2433 /* Disable interrupts for injected conversions */
mbed_official 610:813dcc80987e 2434 hdfsdm_filter->Instance->CR2 &= ~(DFSDM_CR2_JEOCIE);
mbed_official 610:813dcc80987e 2435
mbed_official 610:813dcc80987e 2436 /* Update DFSDM filter state */
mbed_official 610:813dcc80987e 2437 hdfsdm_filter->State = (hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_INJ) ? \
mbed_official 610:813dcc80987e 2438 HAL_DFSDM_FILTER_STATE_READY : HAL_DFSDM_FILTER_STATE_REG;
mbed_official 610:813dcc80987e 2439 }
mbed_official 610:813dcc80987e 2440 /* end of injected sequence, reset the value */
mbed_official 610:813dcc80987e 2441 hdfsdm_filter->InjConvRemaining = (hdfsdm_filter->InjectedScanMode == ENABLE) ? \
mbed_official 610:813dcc80987e 2442 hdfsdm_filter->InjectedChannelsNbr : 1;
mbed_official 610:813dcc80987e 2443 }
mbed_official 610:813dcc80987e 2444 }
mbed_official 610:813dcc80987e 2445 /* Check if analog watchdog occurs */
mbed_official 610:813dcc80987e 2446 else if(((hdfsdm_filter->Instance->ISR & DFSDM_ISR_AWDF) != 0) && \
mbed_official 610:813dcc80987e 2447 ((hdfsdm_filter->Instance->CR2 & DFSDM_CR2_AWDIE) != 0))
mbed_official 610:813dcc80987e 2448 {
mbed_official 610:813dcc80987e 2449 uint32_t reg = 0;
mbed_official 610:813dcc80987e 2450 uint32_t threshold = 0;
mbed_official 610:813dcc80987e 2451 uint32_t channel = 0;
mbed_official 610:813dcc80987e 2452
mbed_official 610:813dcc80987e 2453 /* Get channel and threshold */
mbed_official 610:813dcc80987e 2454 reg = hdfsdm_filter->Instance->AWSR;
mbed_official 610:813dcc80987e 2455 threshold = (reg & DFSDM_AWSR_AWLTF) ? DFSDM_AWD_LOW_THRESHOLD : DFSDM_AWD_HIGH_THRESHOLD;
mbed_official 610:813dcc80987e 2456 if(threshold == DFSDM_AWD_HIGH_THRESHOLD)
mbed_official 610:813dcc80987e 2457 {
mbed_official 610:813dcc80987e 2458 reg = reg >> DFSDM_AWSR_HIGH_OFFSET;
mbed_official 610:813dcc80987e 2459 }
mbed_official 610:813dcc80987e 2460 while((reg & 1) == 0)
mbed_official 610:813dcc80987e 2461 {
mbed_official 610:813dcc80987e 2462 channel++;
mbed_official 610:813dcc80987e 2463 reg = reg >> 1;
mbed_official 610:813dcc80987e 2464 }
mbed_official 610:813dcc80987e 2465 /* Clear analog watchdog flag */
mbed_official 610:813dcc80987e 2466 hdfsdm_filter->Instance->AWCFR = (threshold == DFSDM_AWD_HIGH_THRESHOLD) ? \
mbed_official 610:813dcc80987e 2467 (1 << (DFSDM_AWSR_HIGH_OFFSET + channel)) : \
mbed_official 610:813dcc80987e 2468 (1 << channel);
mbed_official 610:813dcc80987e 2469
mbed_official 610:813dcc80987e 2470 /* Call analog watchdog callback */
mbed_official 610:813dcc80987e 2471 HAL_DFSDM_FilterAwdCallback(hdfsdm_filter, channel, threshold);
mbed_official 610:813dcc80987e 2472 }
mbed_official 610:813dcc80987e 2473 /* Check if clock absence occurs */
mbed_official 610:813dcc80987e 2474 else if((hdfsdm_filter->Instance == DFSDM_Filter0) && \
mbed_official 610:813dcc80987e 2475 ((hdfsdm_filter->Instance->ISR & DFSDM_ISR_CKABF) != 0) && \
mbed_official 610:813dcc80987e 2476 ((hdfsdm_filter->Instance->CR2 & DFSDM_CR2_CKABIE) != 0))
mbed_official 610:813dcc80987e 2477 {
mbed_official 610:813dcc80987e 2478 uint32_t reg = 0;
mbed_official 610:813dcc80987e 2479 uint32_t channel = 0;
mbed_official 610:813dcc80987e 2480
mbed_official 610:813dcc80987e 2481 reg = ((hdfsdm_filter->Instance->ISR & DFSDM_ISR_CKABF) >> DFSDM_ISR_CKABF_OFFSET);
mbed_official 610:813dcc80987e 2482
mbed_official 610:813dcc80987e 2483 while(channel < DFSDM_CHANNEL_NUMBER)
mbed_official 610:813dcc80987e 2484 {
mbed_official 610:813dcc80987e 2485 /* Check if flag is set and corresponding channel is enabled */
mbed_official 610:813dcc80987e 2486 if((reg & 1) && (a_dfsdmChannelHandle[channel] != NULL))
mbed_official 610:813dcc80987e 2487 {
mbed_official 610:813dcc80987e 2488 /* Check clock absence has been enabled for this channel */
mbed_official 610:813dcc80987e 2489 if((a_dfsdmChannelHandle[channel]->Instance->CHCFGR1 & DFSDM_CHCFGR1_CKABEN) != 0)
mbed_official 610:813dcc80987e 2490 {
mbed_official 610:813dcc80987e 2491 /* Clear clock absence flag */
mbed_official 610:813dcc80987e 2492 hdfsdm_filter->Instance->ICR = (1 << (DFSDM_ICR_CLRCKABF_OFFSET + channel));
mbed_official 610:813dcc80987e 2493
mbed_official 610:813dcc80987e 2494 /* Call clock absence callback */
mbed_official 610:813dcc80987e 2495 HAL_DFSDM_ChannelCkabCallback(a_dfsdmChannelHandle[channel]);
mbed_official 610:813dcc80987e 2496 }
mbed_official 610:813dcc80987e 2497 }
mbed_official 610:813dcc80987e 2498 channel++;
mbed_official 610:813dcc80987e 2499 reg = reg >> 1;
mbed_official 610:813dcc80987e 2500 }
mbed_official 610:813dcc80987e 2501 }
mbed_official 610:813dcc80987e 2502 /* Check if short circuit detection occurs */
mbed_official 610:813dcc80987e 2503 else if((hdfsdm_filter->Instance == DFSDM_Filter0) && \
mbed_official 610:813dcc80987e 2504 ((hdfsdm_filter->Instance->ISR & DFSDM_ISR_SCDF) != 0) && \
mbed_official 610:813dcc80987e 2505 ((hdfsdm_filter->Instance->CR2 & DFSDM_CR2_SCDIE) != 0))
mbed_official 610:813dcc80987e 2506 {
mbed_official 610:813dcc80987e 2507 uint32_t reg = 0;
mbed_official 610:813dcc80987e 2508 uint32_t channel = 0;
mbed_official 610:813dcc80987e 2509
mbed_official 610:813dcc80987e 2510 /* Get channel */
mbed_official 610:813dcc80987e 2511 reg = ((hdfsdm_filter->Instance->ISR & DFSDM_ISR_SCDF) >> DFSDM_ISR_SCDF_OFFSET);
mbed_official 610:813dcc80987e 2512 while((reg & 1) == 0)
mbed_official 610:813dcc80987e 2513 {
mbed_official 610:813dcc80987e 2514 channel++;
mbed_official 610:813dcc80987e 2515 reg = reg >> 1;
mbed_official 610:813dcc80987e 2516 }
mbed_official 610:813dcc80987e 2517
mbed_official 610:813dcc80987e 2518 /* Clear short circuit detection flag */
mbed_official 610:813dcc80987e 2519 hdfsdm_filter->Instance->ICR = (1 << (DFSDM_ICR_CLRSCDF_OFFSET + channel));
mbed_official 610:813dcc80987e 2520
mbed_official 610:813dcc80987e 2521 /* Call short circuit detection callback */
mbed_official 610:813dcc80987e 2522 HAL_DFSDM_ChannelScdCallback(a_dfsdmChannelHandle[channel]);
mbed_official 610:813dcc80987e 2523 }
mbed_official 610:813dcc80987e 2524 }
mbed_official 610:813dcc80987e 2525
mbed_official 610:813dcc80987e 2526 /**
mbed_official 610:813dcc80987e 2527 * @brief Regular conversion complete callback.
mbed_official 610:813dcc80987e 2528 * @note In interrupt mode, user has to read conversion value in this function
mbed_official 610:813dcc80987e 2529 * using HAL_DFSDM_FilterGetRegularValue.
mbed_official 610:813dcc80987e 2530 * @param hdfsdm_filter : DFSDM filter handle.
mbed_official 610:813dcc80987e 2531 * @retval None
mbed_official 610:813dcc80987e 2532 */
mbed_official 610:813dcc80987e 2533 __weak void HAL_DFSDM_FilterRegConvCpltCallback(DFSDM_Filter_HandleTypeDef *hdfsdm_filter)
mbed_official 610:813dcc80987e 2534 {
mbed_official 610:813dcc80987e 2535 /* NOTE : This function should not be modified, when the callback is needed,
mbed_official 610:813dcc80987e 2536 the HAL_DFSDM_FilterRegConvCpltCallback could be implemented in the user file.
mbed_official 610:813dcc80987e 2537 */
mbed_official 610:813dcc80987e 2538 }
mbed_official 610:813dcc80987e 2539
mbed_official 610:813dcc80987e 2540 /**
mbed_official 610:813dcc80987e 2541 * @brief Half regular conversion complete callback.
mbed_official 610:813dcc80987e 2542 * @param hdfsdm_filter : DFSDM filter handle.
mbed_official 610:813dcc80987e 2543 * @retval None
mbed_official 610:813dcc80987e 2544 */
mbed_official 610:813dcc80987e 2545 __weak void HAL_DFSDM_FilterRegConvHalfCpltCallback(DFSDM_Filter_HandleTypeDef *hdfsdm_filter)
mbed_official 610:813dcc80987e 2546 {
mbed_official 610:813dcc80987e 2547 /* NOTE : This function should not be modified, when the callback is needed,
mbed_official 610:813dcc80987e 2548 the HAL_DFSDM_FilterRegConvHalfCpltCallback could be implemented in the user file.
mbed_official 610:813dcc80987e 2549 */
mbed_official 610:813dcc80987e 2550 }
mbed_official 610:813dcc80987e 2551
mbed_official 610:813dcc80987e 2552 /**
mbed_official 610:813dcc80987e 2553 * @brief Injected conversion complete callback.
mbed_official 610:813dcc80987e 2554 * @note In interrupt mode, user has to read conversion value in this function
mbed_official 610:813dcc80987e 2555 * using HAL_DFSDM_FilterGetInjectedValue.
mbed_official 610:813dcc80987e 2556 * @param hdfsdm_filter : DFSDM filter handle.
mbed_official 610:813dcc80987e 2557 * @retval None
mbed_official 610:813dcc80987e 2558 */
mbed_official 610:813dcc80987e 2559 __weak void HAL_DFSDM_FilterInjConvCpltCallback(DFSDM_Filter_HandleTypeDef *hdfsdm_filter)
mbed_official 610:813dcc80987e 2560 {
mbed_official 610:813dcc80987e 2561 /* NOTE : This function should not be modified, when the callback is needed,
mbed_official 610:813dcc80987e 2562 the HAL_DFSDM_FilterInjConvCpltCallback could be implemented in the user file.
mbed_official 610:813dcc80987e 2563 */
mbed_official 610:813dcc80987e 2564 }
mbed_official 610:813dcc80987e 2565
mbed_official 610:813dcc80987e 2566 /**
mbed_official 610:813dcc80987e 2567 * @brief Half injected conversion complete callback.
mbed_official 610:813dcc80987e 2568 * @param hdfsdm_filter : DFSDM filter handle.
mbed_official 610:813dcc80987e 2569 * @retval None
mbed_official 610:813dcc80987e 2570 */
mbed_official 610:813dcc80987e 2571 __weak void HAL_DFSDM_FilterInjConvHalfCpltCallback(DFSDM_Filter_HandleTypeDef *hdfsdm_filter)
mbed_official 610:813dcc80987e 2572 {
mbed_official 610:813dcc80987e 2573 /* NOTE : This function should not be modified, when the callback is needed,
mbed_official 610:813dcc80987e 2574 the HAL_DFSDM_FilterInjConvHalfCpltCallback could be implemented in the user file.
mbed_official 610:813dcc80987e 2575 */
mbed_official 610:813dcc80987e 2576 }
mbed_official 610:813dcc80987e 2577
mbed_official 610:813dcc80987e 2578 /**
mbed_official 610:813dcc80987e 2579 * @brief Filter analog watchdog callback.
mbed_official 610:813dcc80987e 2580 * @param hdfsdm_filter : DFSDM filter handle.
mbed_official 610:813dcc80987e 2581 * @param Channel : Corresponding channel.
mbed_official 610:813dcc80987e 2582 * @param Threshold : Low or high threshold has been reached.
mbed_official 610:813dcc80987e 2583 * @retval None
mbed_official 610:813dcc80987e 2584 */
mbed_official 610:813dcc80987e 2585 __weak void HAL_DFSDM_FilterAwdCallback(DFSDM_Filter_HandleTypeDef *hdfsdm_filter,
mbed_official 610:813dcc80987e 2586 uint32_t Channel, uint32_t Threshold)
mbed_official 610:813dcc80987e 2587 {
mbed_official 610:813dcc80987e 2588 /* NOTE : This function should not be modified, when the callback is needed,
mbed_official 610:813dcc80987e 2589 the HAL_DFSDM_FilterAwdCallback could be implemented in the user file.
mbed_official 610:813dcc80987e 2590 */
mbed_official 610:813dcc80987e 2591 }
mbed_official 610:813dcc80987e 2592
mbed_official 610:813dcc80987e 2593 /**
mbed_official 610:813dcc80987e 2594 * @brief Error callback.
mbed_official 610:813dcc80987e 2595 * @param hdfsdm_filter : DFSDM filter handle.
mbed_official 610:813dcc80987e 2596 * @retval None
mbed_official 610:813dcc80987e 2597 */
mbed_official 610:813dcc80987e 2598 __weak void HAL_DFSDM_FilterErrorCallback(DFSDM_Filter_HandleTypeDef *hdfsdm_filter)
mbed_official 610:813dcc80987e 2599 {
mbed_official 610:813dcc80987e 2600 /* NOTE : This function should not be modified, when the callback is needed,
mbed_official 610:813dcc80987e 2601 the HAL_DFSDM_FilterErrorCallback could be implemented in the user file.
mbed_official 610:813dcc80987e 2602 */
mbed_official 610:813dcc80987e 2603 }
mbed_official 610:813dcc80987e 2604
mbed_official 610:813dcc80987e 2605 /**
mbed_official 610:813dcc80987e 2606 * @}
mbed_official 610:813dcc80987e 2607 */
mbed_official 610:813dcc80987e 2608
mbed_official 610:813dcc80987e 2609 /** @defgroup DFSDM_Exported_Functions_Group4_Filter Filter state functions
mbed_official 610:813dcc80987e 2610 * @brief Filter state functions
mbed_official 610:813dcc80987e 2611 *
mbed_official 610:813dcc80987e 2612 @verbatim
mbed_official 610:813dcc80987e 2613 ==============================================================================
mbed_official 610:813dcc80987e 2614 ##### Filter state functions #####
mbed_official 610:813dcc80987e 2615 ==============================================================================
mbed_official 610:813dcc80987e 2616 [..] This section provides functions allowing to:
mbed_official 610:813dcc80987e 2617 (+) Get the DFSDM filter state.
mbed_official 610:813dcc80987e 2618 (+) Get the DFSDM filter error.
mbed_official 610:813dcc80987e 2619 @endverbatim
mbed_official 610:813dcc80987e 2620 * @{
mbed_official 610:813dcc80987e 2621 */
mbed_official 610:813dcc80987e 2622
mbed_official 610:813dcc80987e 2623 /**
mbed_official 610:813dcc80987e 2624 * @brief This function allows to get the current DFSDM filter handle state.
mbed_official 610:813dcc80987e 2625 * @param hdfsdm_filter : DFSDM filter handle.
mbed_official 610:813dcc80987e 2626 * @retval DFSDM filter state.
mbed_official 610:813dcc80987e 2627 */
mbed_official 610:813dcc80987e 2628 HAL_DFSDM_Filter_StateTypeDef HAL_DFSDM_FilterGetState(DFSDM_Filter_HandleTypeDef *hdfsdm_filter)
mbed_official 610:813dcc80987e 2629 {
mbed_official 610:813dcc80987e 2630 /* Return DFSDM filter handle state */
mbed_official 610:813dcc80987e 2631 return hdfsdm_filter->State;
mbed_official 610:813dcc80987e 2632 }
mbed_official 610:813dcc80987e 2633
mbed_official 610:813dcc80987e 2634 /**
mbed_official 610:813dcc80987e 2635 * @brief This function allows to get the current DFSDM filter error.
mbed_official 610:813dcc80987e 2636 * @param hdfsdm_filter : DFSDM filter handle.
mbed_official 610:813dcc80987e 2637 * @retval DFSDM filter error code.
mbed_official 610:813dcc80987e 2638 */
mbed_official 610:813dcc80987e 2639 uint32_t HAL_DFSDM_FilterGetError(DFSDM_Filter_HandleTypeDef *hdfsdm_filter)
mbed_official 610:813dcc80987e 2640 {
mbed_official 610:813dcc80987e 2641 return hdfsdm_filter->ErrorCode;
mbed_official 610:813dcc80987e 2642 }
mbed_official 610:813dcc80987e 2643
mbed_official 610:813dcc80987e 2644 /**
mbed_official 610:813dcc80987e 2645 * @}
mbed_official 610:813dcc80987e 2646 */
mbed_official 610:813dcc80987e 2647
mbed_official 610:813dcc80987e 2648 /**
mbed_official 610:813dcc80987e 2649 * @}
mbed_official 610:813dcc80987e 2650 */
mbed_official 610:813dcc80987e 2651 /* End of exported functions -------------------------------------------------*/
mbed_official 610:813dcc80987e 2652
mbed_official 610:813dcc80987e 2653 /* Private functions ---------------------------------------------------------*/
mbed_official 610:813dcc80987e 2654 /** @addtogroup DFSDM_Private_Functions DFSDM Private Functions
mbed_official 610:813dcc80987e 2655 * @{
mbed_official 610:813dcc80987e 2656 */
mbed_official 610:813dcc80987e 2657
mbed_official 610:813dcc80987e 2658 /**
mbed_official 610:813dcc80987e 2659 * @brief DMA half transfer complete callback for regular conversion.
mbed_official 610:813dcc80987e 2660 * @param hdma : DMA handle.
mbed_official 610:813dcc80987e 2661 * @retval None
mbed_official 610:813dcc80987e 2662 */
mbed_official 610:813dcc80987e 2663 static void DFSDM_DMARegularHalfConvCplt(DMA_HandleTypeDef *hdma)
mbed_official 610:813dcc80987e 2664 {
mbed_official 610:813dcc80987e 2665 /* Get DFSDM filter handle */
mbed_official 610:813dcc80987e 2666 DFSDM_Filter_HandleTypeDef* hdfsdm_filter = (DFSDM_Filter_HandleTypeDef*) ((DMA_HandleTypeDef*)hdma)->Parent;
mbed_official 610:813dcc80987e 2667
mbed_official 610:813dcc80987e 2668 /* Call regular half conversion complete callback */
mbed_official 610:813dcc80987e 2669 HAL_DFSDM_FilterRegConvHalfCpltCallback(hdfsdm_filter);
mbed_official 610:813dcc80987e 2670 }
mbed_official 610:813dcc80987e 2671
mbed_official 610:813dcc80987e 2672 /**
mbed_official 610:813dcc80987e 2673 * @brief DMA transfer complete callback for regular conversion.
mbed_official 610:813dcc80987e 2674 * @param hdma : DMA handle.
mbed_official 610:813dcc80987e 2675 * @retval None
mbed_official 610:813dcc80987e 2676 */
mbed_official 610:813dcc80987e 2677 static void DFSDM_DMARegularConvCplt(DMA_HandleTypeDef *hdma)
mbed_official 610:813dcc80987e 2678 {
mbed_official 610:813dcc80987e 2679 /* Get DFSDM filter handle */
mbed_official 610:813dcc80987e 2680 DFSDM_Filter_HandleTypeDef* hdfsdm_filter = (DFSDM_Filter_HandleTypeDef*) ((DMA_HandleTypeDef*)hdma)->Parent;
mbed_official 610:813dcc80987e 2681
mbed_official 610:813dcc80987e 2682 /* Call regular conversion complete callback */
mbed_official 610:813dcc80987e 2683 HAL_DFSDM_FilterRegConvCpltCallback(hdfsdm_filter);
mbed_official 610:813dcc80987e 2684 }
mbed_official 610:813dcc80987e 2685
mbed_official 610:813dcc80987e 2686 /**
mbed_official 610:813dcc80987e 2687 * @brief DMA half transfer complete callback for injected conversion.
mbed_official 610:813dcc80987e 2688 * @param hdma : DMA handle.
mbed_official 610:813dcc80987e 2689 * @retval None
mbed_official 610:813dcc80987e 2690 */
mbed_official 610:813dcc80987e 2691 static void DFSDM_DMAInjectedHalfConvCplt(DMA_HandleTypeDef *hdma)
mbed_official 610:813dcc80987e 2692 {
mbed_official 610:813dcc80987e 2693 /* Get DFSDM filter handle */
mbed_official 610:813dcc80987e 2694 DFSDM_Filter_HandleTypeDef* hdfsdm_filter = (DFSDM_Filter_HandleTypeDef*) ((DMA_HandleTypeDef*)hdma)->Parent;
mbed_official 610:813dcc80987e 2695
mbed_official 610:813dcc80987e 2696 /* Call injected half conversion complete callback */
mbed_official 610:813dcc80987e 2697 HAL_DFSDM_FilterInjConvHalfCpltCallback(hdfsdm_filter);
mbed_official 610:813dcc80987e 2698 }
mbed_official 610:813dcc80987e 2699
mbed_official 610:813dcc80987e 2700 /**
mbed_official 610:813dcc80987e 2701 * @brief DMA transfer complete callback for injected conversion.
mbed_official 610:813dcc80987e 2702 * @param hdma : DMA handle.
mbed_official 610:813dcc80987e 2703 * @retval None
mbed_official 610:813dcc80987e 2704 */
mbed_official 610:813dcc80987e 2705 static void DFSDM_DMAInjectedConvCplt(DMA_HandleTypeDef *hdma)
mbed_official 610:813dcc80987e 2706 {
mbed_official 610:813dcc80987e 2707 /* Get DFSDM filter handle */
mbed_official 610:813dcc80987e 2708 DFSDM_Filter_HandleTypeDef* hdfsdm_filter = (DFSDM_Filter_HandleTypeDef*) ((DMA_HandleTypeDef*)hdma)->Parent;
mbed_official 610:813dcc80987e 2709
mbed_official 610:813dcc80987e 2710 /* Call injected conversion complete callback */
mbed_official 610:813dcc80987e 2711 HAL_DFSDM_FilterInjConvCpltCallback(hdfsdm_filter);
mbed_official 610:813dcc80987e 2712 }
mbed_official 610:813dcc80987e 2713
mbed_official 610:813dcc80987e 2714 /**
mbed_official 610:813dcc80987e 2715 * @brief DMA error callback.
mbed_official 610:813dcc80987e 2716 * @param hdma : DMA handle.
mbed_official 610:813dcc80987e 2717 * @retval None
mbed_official 610:813dcc80987e 2718 */
mbed_official 610:813dcc80987e 2719 static void DFSDM_DMAError(DMA_HandleTypeDef *hdma)
mbed_official 610:813dcc80987e 2720 {
mbed_official 610:813dcc80987e 2721 /* Get DFSDM filter handle */
mbed_official 610:813dcc80987e 2722 DFSDM_Filter_HandleTypeDef* hdfsdm_filter = (DFSDM_Filter_HandleTypeDef*) ((DMA_HandleTypeDef*)hdma)->Parent;
mbed_official 610:813dcc80987e 2723
mbed_official 610:813dcc80987e 2724 /* Update error code */
mbed_official 610:813dcc80987e 2725 hdfsdm_filter->ErrorCode = DFSDM_FILTER_ERROR_DMA;
mbed_official 610:813dcc80987e 2726
mbed_official 610:813dcc80987e 2727 /* Call error callback */
mbed_official 610:813dcc80987e 2728 HAL_DFSDM_FilterErrorCallback(hdfsdm_filter);
mbed_official 610:813dcc80987e 2729 }
mbed_official 610:813dcc80987e 2730
mbed_official 610:813dcc80987e 2731 /**
mbed_official 610:813dcc80987e 2732 * @brief This function allows to get the number of injected channels.
mbed_official 610:813dcc80987e 2733 * @param Channels : bitfield of injected channels.
mbed_official 610:813dcc80987e 2734 * @retval Number of injected channels.
mbed_official 610:813dcc80987e 2735 */
mbed_official 610:813dcc80987e 2736 static uint32_t DFSDM_GetInjChannelsNbr(uint32_t Channels)
mbed_official 610:813dcc80987e 2737 {
mbed_official 610:813dcc80987e 2738 uint32_t nbChannels = 0;
mbed_official 610:813dcc80987e 2739 uint32_t tmp;
mbed_official 610:813dcc80987e 2740
mbed_official 610:813dcc80987e 2741 /* Get the number of channels from bitfield */
mbed_official 610:813dcc80987e 2742 tmp = (uint32_t) (Channels & DFSDM_LSB_MASK);
mbed_official 610:813dcc80987e 2743 while(tmp != 0)
mbed_official 610:813dcc80987e 2744 {
mbed_official 610:813dcc80987e 2745 if(tmp & 1)
mbed_official 610:813dcc80987e 2746 {
mbed_official 610:813dcc80987e 2747 nbChannels++;
mbed_official 610:813dcc80987e 2748 }
mbed_official 610:813dcc80987e 2749 tmp = (uint32_t) (tmp >> 1);
mbed_official 610:813dcc80987e 2750 }
mbed_official 610:813dcc80987e 2751 return nbChannels;
mbed_official 610:813dcc80987e 2752 }
mbed_official 610:813dcc80987e 2753
mbed_official 610:813dcc80987e 2754 /**
mbed_official 610:813dcc80987e 2755 * @brief This function allows to get the channel number from channel instance.
mbed_official 610:813dcc80987e 2756 * @param Instance : DFSDM channel instance.
mbed_official 610:813dcc80987e 2757 * @retval Channel number.
mbed_official 610:813dcc80987e 2758 */
mbed_official 610:813dcc80987e 2759 static uint32_t DFSDM_GetChannelFromInstance(DFSDM_Channel_TypeDef* Instance)
mbed_official 610:813dcc80987e 2760 {
mbed_official 610:813dcc80987e 2761 uint32_t channel = 0;
mbed_official 610:813dcc80987e 2762
mbed_official 610:813dcc80987e 2763 /* Get channel from instance */
mbed_official 610:813dcc80987e 2764 if(Instance == DFSDM_Channel0)
mbed_official 610:813dcc80987e 2765 {
mbed_official 610:813dcc80987e 2766 channel = 0;
mbed_official 610:813dcc80987e 2767 }
mbed_official 610:813dcc80987e 2768 else if(Instance == DFSDM_Channel1)
mbed_official 610:813dcc80987e 2769 {
mbed_official 610:813dcc80987e 2770 channel = 1;
mbed_official 610:813dcc80987e 2771 }
mbed_official 610:813dcc80987e 2772 else if(Instance == DFSDM_Channel2)
mbed_official 610:813dcc80987e 2773 {
mbed_official 610:813dcc80987e 2774 channel = 2;
mbed_official 610:813dcc80987e 2775 }
mbed_official 610:813dcc80987e 2776 else if(Instance == DFSDM_Channel3)
mbed_official 610:813dcc80987e 2777 {
mbed_official 610:813dcc80987e 2778 channel = 3;
mbed_official 610:813dcc80987e 2779 }
mbed_official 610:813dcc80987e 2780 else if(Instance == DFSDM_Channel4)
mbed_official 610:813dcc80987e 2781 {
mbed_official 610:813dcc80987e 2782 channel = 4;
mbed_official 610:813dcc80987e 2783 }
mbed_official 610:813dcc80987e 2784 else if(Instance == DFSDM_Channel5)
mbed_official 610:813dcc80987e 2785 {
mbed_official 610:813dcc80987e 2786 channel = 5;
mbed_official 610:813dcc80987e 2787 }
mbed_official 610:813dcc80987e 2788 else if(Instance == DFSDM_Channel6)
mbed_official 610:813dcc80987e 2789 {
mbed_official 610:813dcc80987e 2790 channel = 6;
mbed_official 610:813dcc80987e 2791 }
mbed_official 610:813dcc80987e 2792 else if(Instance == DFSDM_Channel7)
mbed_official 610:813dcc80987e 2793 {
mbed_official 610:813dcc80987e 2794 channel = 7;
mbed_official 610:813dcc80987e 2795 }
mbed_official 610:813dcc80987e 2796
mbed_official 610:813dcc80987e 2797 return channel;
mbed_official 610:813dcc80987e 2798 }
mbed_official 610:813dcc80987e 2799
mbed_official 610:813dcc80987e 2800 /**
mbed_official 610:813dcc80987e 2801 * @brief This function allows to really start regular conversion.
mbed_official 610:813dcc80987e 2802 * @param hdfsdm_filter : DFSDM filter handle.
mbed_official 610:813dcc80987e 2803 * @retval None
mbed_official 610:813dcc80987e 2804 */
mbed_official 610:813dcc80987e 2805 static void DFSDM_RegConvStart(DFSDM_Filter_HandleTypeDef* hdfsdm_filter)
mbed_official 610:813dcc80987e 2806 {
mbed_official 610:813dcc80987e 2807 /* Check regular trigger */
mbed_official 610:813dcc80987e 2808 if(hdfsdm_filter->RegularTrigger == DFSDM_FILTER_SW_TRIGGER)
mbed_official 610:813dcc80987e 2809 {
mbed_official 610:813dcc80987e 2810 /* Software start of regular conversion */
mbed_official 610:813dcc80987e 2811 hdfsdm_filter->Instance->CR1 |= DFSDM_CR1_RSWSTART;
mbed_official 610:813dcc80987e 2812 }
mbed_official 610:813dcc80987e 2813 else /* synchronous trigger */
mbed_official 610:813dcc80987e 2814 {
mbed_official 610:813dcc80987e 2815 /* Disable DFSDM filter */
mbed_official 610:813dcc80987e 2816 hdfsdm_filter->Instance->CR1 &= ~(DFSDM_CR1_DFEN);
mbed_official 610:813dcc80987e 2817
mbed_official 610:813dcc80987e 2818 /* Set RSYNC bit in DFSDM_CR1 register */
mbed_official 610:813dcc80987e 2819 hdfsdm_filter->Instance->CR1 |= DFSDM_CR1_RSYNC;
mbed_official 610:813dcc80987e 2820
mbed_official 610:813dcc80987e 2821 /* Enable DFSDM filter */
mbed_official 610:813dcc80987e 2822 hdfsdm_filter->Instance->CR1 |= DFSDM_CR1_DFEN;
mbed_official 610:813dcc80987e 2823
mbed_official 610:813dcc80987e 2824 /* If injected conversion was in progress, restart it */
mbed_official 610:813dcc80987e 2825 if(hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_INJ)
mbed_official 610:813dcc80987e 2826 {
mbed_official 610:813dcc80987e 2827 if(hdfsdm_filter->InjectedTrigger == DFSDM_FILTER_SW_TRIGGER)
mbed_official 610:813dcc80987e 2828 {
mbed_official 610:813dcc80987e 2829 hdfsdm_filter->Instance->CR1 |= DFSDM_CR1_JSWSTART;
mbed_official 610:813dcc80987e 2830 }
mbed_official 610:813dcc80987e 2831 /* Update remaining injected conversions */
mbed_official 610:813dcc80987e 2832 hdfsdm_filter->InjConvRemaining = (hdfsdm_filter->InjectedScanMode == ENABLE) ? \
mbed_official 610:813dcc80987e 2833 hdfsdm_filter->InjectedChannelsNbr : 1;
mbed_official 610:813dcc80987e 2834 }
mbed_official 610:813dcc80987e 2835 }
mbed_official 610:813dcc80987e 2836 /* Update DFSDM filter state */
mbed_official 610:813dcc80987e 2837 hdfsdm_filter->State = (hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_READY) ? \
mbed_official 610:813dcc80987e 2838 HAL_DFSDM_FILTER_STATE_REG : HAL_DFSDM_FILTER_STATE_REG_INJ;
mbed_official 610:813dcc80987e 2839 }
mbed_official 610:813dcc80987e 2840
mbed_official 610:813dcc80987e 2841 /**
mbed_official 610:813dcc80987e 2842 * @brief This function allows to really stop regular conversion.
mbed_official 610:813dcc80987e 2843 * @param hdfsdm_filter : DFSDM filter handle.
mbed_official 610:813dcc80987e 2844 * @retval None
mbed_official 610:813dcc80987e 2845 */
mbed_official 610:813dcc80987e 2846 static void DFSDM_RegConvStop(DFSDM_Filter_HandleTypeDef* hdfsdm_filter)
mbed_official 610:813dcc80987e 2847 {
mbed_official 610:813dcc80987e 2848 /* Disable DFSDM filter */
mbed_official 610:813dcc80987e 2849 hdfsdm_filter->Instance->CR1 &= ~(DFSDM_CR1_DFEN);
mbed_official 610:813dcc80987e 2850
mbed_official 610:813dcc80987e 2851 /* If regular trigger was synchronous, reset RSYNC bit in DFSDM_CR1 register */
mbed_official 610:813dcc80987e 2852 if(hdfsdm_filter->RegularTrigger == DFSDM_FILTER_SYNC_TRIGGER)
mbed_official 610:813dcc80987e 2853 {
mbed_official 610:813dcc80987e 2854 hdfsdm_filter->Instance->CR1 &= ~(DFSDM_CR1_RSYNC);
mbed_official 610:813dcc80987e 2855 }
mbed_official 610:813dcc80987e 2856
mbed_official 610:813dcc80987e 2857 /* Enable DFSDM filter */
mbed_official 610:813dcc80987e 2858 hdfsdm_filter->Instance->CR1 |= DFSDM_CR1_DFEN;
mbed_official 610:813dcc80987e 2859
mbed_official 610:813dcc80987e 2860 /* If injected conversion was in progress, restart it */
mbed_official 610:813dcc80987e 2861 if(hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_REG_INJ)
mbed_official 610:813dcc80987e 2862 {
mbed_official 610:813dcc80987e 2863 if(hdfsdm_filter->InjectedTrigger == DFSDM_FILTER_SW_TRIGGER)
mbed_official 610:813dcc80987e 2864 {
mbed_official 610:813dcc80987e 2865 hdfsdm_filter->Instance->CR1 |= DFSDM_CR1_JSWSTART;
mbed_official 610:813dcc80987e 2866 }
mbed_official 610:813dcc80987e 2867 /* Update remaining injected conversions */
mbed_official 610:813dcc80987e 2868 hdfsdm_filter->InjConvRemaining = (hdfsdm_filter->InjectedScanMode == ENABLE) ? \
mbed_official 610:813dcc80987e 2869 hdfsdm_filter->InjectedChannelsNbr : 1;
mbed_official 610:813dcc80987e 2870 }
mbed_official 610:813dcc80987e 2871
mbed_official 610:813dcc80987e 2872 /* Update DFSDM filter state */
mbed_official 610:813dcc80987e 2873 hdfsdm_filter->State = (hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_REG) ? \
mbed_official 610:813dcc80987e 2874 HAL_DFSDM_FILTER_STATE_READY : HAL_DFSDM_FILTER_STATE_INJ;
mbed_official 610:813dcc80987e 2875 }
mbed_official 610:813dcc80987e 2876
mbed_official 610:813dcc80987e 2877 /**
mbed_official 610:813dcc80987e 2878 * @brief This function allows to really start injected conversion.
mbed_official 610:813dcc80987e 2879 * @param hdfsdm_filter : DFSDM filter handle.
mbed_official 610:813dcc80987e 2880 * @retval None
mbed_official 610:813dcc80987e 2881 */
mbed_official 610:813dcc80987e 2882 static void DFSDM_InjConvStart(DFSDM_Filter_HandleTypeDef* hdfsdm_filter)
mbed_official 610:813dcc80987e 2883 {
mbed_official 610:813dcc80987e 2884 /* Check injected trigger */
mbed_official 610:813dcc80987e 2885 if(hdfsdm_filter->InjectedTrigger == DFSDM_FILTER_SW_TRIGGER)
mbed_official 610:813dcc80987e 2886 {
mbed_official 610:813dcc80987e 2887 /* Software start of injected conversion */
mbed_official 610:813dcc80987e 2888 hdfsdm_filter->Instance->CR1 |= DFSDM_CR1_JSWSTART;
mbed_official 610:813dcc80987e 2889 }
mbed_official 610:813dcc80987e 2890 else /* external or synchronous trigger */
mbed_official 610:813dcc80987e 2891 {
mbed_official 610:813dcc80987e 2892 /* Disable DFSDM filter */
mbed_official 610:813dcc80987e 2893 hdfsdm_filter->Instance->CR1 &= ~(DFSDM_CR1_DFEN);
mbed_official 610:813dcc80987e 2894
mbed_official 610:813dcc80987e 2895 if(hdfsdm_filter->InjectedTrigger == DFSDM_FILTER_SYNC_TRIGGER)
mbed_official 610:813dcc80987e 2896 {
mbed_official 610:813dcc80987e 2897 /* Set JSYNC bit in DFSDM_CR1 register */
mbed_official 610:813dcc80987e 2898 hdfsdm_filter->Instance->CR1 |= DFSDM_CR1_JSYNC;
mbed_official 610:813dcc80987e 2899 }
mbed_official 610:813dcc80987e 2900 else /* external trigger */
mbed_official 610:813dcc80987e 2901 {
mbed_official 610:813dcc80987e 2902 /* Set JEXTEN[1:0] bits in DFSDM_CR1 register */
mbed_official 610:813dcc80987e 2903 hdfsdm_filter->Instance->CR1 |= hdfsdm_filter->ExtTriggerEdge;
mbed_official 610:813dcc80987e 2904 }
mbed_official 610:813dcc80987e 2905
mbed_official 610:813dcc80987e 2906 /* Enable DFSDM filter */
mbed_official 610:813dcc80987e 2907 hdfsdm_filter->Instance->CR1 |= DFSDM_CR1_DFEN;
mbed_official 610:813dcc80987e 2908
mbed_official 610:813dcc80987e 2909 /* If regular conversion was in progress, restart it */
mbed_official 610:813dcc80987e 2910 if((hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_REG) && \
mbed_official 610:813dcc80987e 2911 (hdfsdm_filter->RegularTrigger == DFSDM_FILTER_SW_TRIGGER))
mbed_official 610:813dcc80987e 2912 {
mbed_official 610:813dcc80987e 2913 hdfsdm_filter->Instance->CR1 |= DFSDM_CR1_RSWSTART;
mbed_official 610:813dcc80987e 2914 }
mbed_official 610:813dcc80987e 2915 }
mbed_official 610:813dcc80987e 2916 /* Update DFSDM filter state */
mbed_official 610:813dcc80987e 2917 hdfsdm_filter->State = (hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_READY) ? \
mbed_official 610:813dcc80987e 2918 HAL_DFSDM_FILTER_STATE_INJ : HAL_DFSDM_FILTER_STATE_REG_INJ;
mbed_official 610:813dcc80987e 2919 }
mbed_official 610:813dcc80987e 2920
mbed_official 610:813dcc80987e 2921 /**
mbed_official 610:813dcc80987e 2922 * @brief This function allows to really stop injected conversion.
mbed_official 610:813dcc80987e 2923 * @param hdfsdm_filter : DFSDM filter handle.
mbed_official 610:813dcc80987e 2924 * @retval None
mbed_official 610:813dcc80987e 2925 */
mbed_official 610:813dcc80987e 2926 static void DFSDM_InjConvStop(DFSDM_Filter_HandleTypeDef* hdfsdm_filter)
mbed_official 610:813dcc80987e 2927 {
mbed_official 610:813dcc80987e 2928 /* Disable DFSDM filter */
mbed_official 610:813dcc80987e 2929 hdfsdm_filter->Instance->CR1 &= ~(DFSDM_CR1_DFEN);
mbed_official 610:813dcc80987e 2930
mbed_official 610:813dcc80987e 2931 /* If injected trigger was synchronous, reset JSYNC bit in DFSDM_CR1 register */
mbed_official 610:813dcc80987e 2932 if(hdfsdm_filter->InjectedTrigger == DFSDM_FILTER_SYNC_TRIGGER)
mbed_official 610:813dcc80987e 2933 {
mbed_official 610:813dcc80987e 2934 hdfsdm_filter->Instance->CR1 &= ~(DFSDM_CR1_JSYNC);
mbed_official 610:813dcc80987e 2935 }
mbed_official 610:813dcc80987e 2936 else if(hdfsdm_filter->InjectedTrigger == DFSDM_FILTER_EXT_TRIGGER)
mbed_official 610:813dcc80987e 2937 {
mbed_official 610:813dcc80987e 2938 /* Reset JEXTEN[1:0] bits in DFSDM_CR1 register */
mbed_official 610:813dcc80987e 2939 hdfsdm_filter->Instance->CR1 &= ~(DFSDM_CR1_JEXTEN);
mbed_official 610:813dcc80987e 2940 }
mbed_official 610:813dcc80987e 2941
mbed_official 610:813dcc80987e 2942 /* Enable DFSDM filter */
mbed_official 610:813dcc80987e 2943 hdfsdm_filter->Instance->CR1 |= DFSDM_CR1_DFEN;
mbed_official 610:813dcc80987e 2944
mbed_official 610:813dcc80987e 2945 /* If regular conversion was in progress, restart it */
mbed_official 610:813dcc80987e 2946 if((hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_REG_INJ) && \
mbed_official 610:813dcc80987e 2947 (hdfsdm_filter->RegularTrigger == DFSDM_FILTER_SW_TRIGGER))
mbed_official 610:813dcc80987e 2948 {
mbed_official 610:813dcc80987e 2949 hdfsdm_filter->Instance->CR1 |= DFSDM_CR1_RSWSTART;
mbed_official 610:813dcc80987e 2950 }
mbed_official 610:813dcc80987e 2951
mbed_official 610:813dcc80987e 2952 /* Update remaining injected conversions */
mbed_official 610:813dcc80987e 2953 hdfsdm_filter->InjConvRemaining = (hdfsdm_filter->InjectedScanMode == ENABLE) ? \
mbed_official 610:813dcc80987e 2954 hdfsdm_filter->InjectedChannelsNbr : 1;
mbed_official 610:813dcc80987e 2955
mbed_official 610:813dcc80987e 2956 /* Update DFSDM filter state */
mbed_official 610:813dcc80987e 2957 hdfsdm_filter->State = (hdfsdm_filter->State == HAL_DFSDM_FILTER_STATE_INJ) ? \
mbed_official 610:813dcc80987e 2958 HAL_DFSDM_FILTER_STATE_READY : HAL_DFSDM_FILTER_STATE_REG;
mbed_official 610:813dcc80987e 2959 }
mbed_official 610:813dcc80987e 2960
mbed_official 610:813dcc80987e 2961 /**
mbed_official 610:813dcc80987e 2962 * @}
mbed_official 610:813dcc80987e 2963 */
mbed_official 610:813dcc80987e 2964 /* End of private functions --------------------------------------------------*/
mbed_official 610:813dcc80987e 2965
mbed_official 610:813dcc80987e 2966 /**
mbed_official 610:813dcc80987e 2967 * @}
mbed_official 610:813dcc80987e 2968 */
mbed_official 610:813dcc80987e 2969 #endif /* HAL_DFSDM_MODULE_ENABLED */
mbed_official 610:813dcc80987e 2970 /**
mbed_official 610:813dcc80987e 2971 * @}
mbed_official 610:813dcc80987e 2972 */
mbed_official 610:813dcc80987e 2973
mbed_official 610:813dcc80987e 2974 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/