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_STM32L0/stm32l0xx_hal_irda.c@387:643a59b3dbac, 2014-11-05 (annotated)

Committer:
mbed_official
Date:
Wed Nov 05 14:30:08 2014 +0000
Revision:
387:643a59b3dbac
Parent:
382:ee426a420dbb
Child:
489:119543c9f674
Synchronized with git revision cfeccf154f8f92c3ea9c0c881c577c154537aecc



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



Exporters: STM32L053R8 - IAR exporter

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mbed_official 376:cb4d9db17537 1 /**
mbed_official 376:cb4d9db17537 2 ******************************************************************************
mbed_official 376:cb4d9db17537 3 * @file stm32l0xx_hal_irda.c
mbed_official 376:cb4d9db17537 4 * @author MCD Application Team
mbed_official 376:cb4d9db17537 5 * @version V1.1.0
mbed_official 376:cb4d9db17537 6 * @date 18-June-2014
mbed_official 376:cb4d9db17537 7 * @brief IRDA HAL module driver.
mbed_official 376:cb4d9db17537 8 *
mbed_official 376:cb4d9db17537 9 * This file provides firmware functions to manage the following
mbed_official 376:cb4d9db17537 10 * functionalities of the IrDA (Infrared Data Association) Peripheral
mbed_official 376:cb4d9db17537 11 * (IRDA)
mbed_official 376:cb4d9db17537 12 * + Initialization and de-initialization functions
mbed_official 376:cb4d9db17537 13 * + IO operation functions
mbed_official 376:cb4d9db17537 14 * + Peripheral Control functions
mbed_official 376:cb4d9db17537 15 *
mbed_official 376:cb4d9db17537 16 *
mbed_official 376:cb4d9db17537 17 @verbatim
mbed_official 376:cb4d9db17537 18 ===============================================================================
mbed_official 376:cb4d9db17537 19 ##### How to use this driver #####
mbed_official 376:cb4d9db17537 20 ===============================================================================
mbed_official 376:cb4d9db17537 21 [..]
mbed_official 376:cb4d9db17537 22 The IRDA HAL driver can be used as follows:
mbed_official 376:cb4d9db17537 23
mbed_official 376:cb4d9db17537 24
mbed_official 376:cb4d9db17537 25 (#) Declare a IRDA_HandleTypeDef handle structure.
mbed_official 376:cb4d9db17537 26 (#) Initialize the IRDA low level resources by implementing the HAL_IRDA_MspInit() API:
mbed_official 376:cb4d9db17537 27 (##) Enable the USARTx interface clock.
mbed_official 376:cb4d9db17537 28 (##) IRDA pins configuration:
mbed_official 376:cb4d9db17537 29 (+) Enable the clock for the IRDA GPIOs.
mbed_official 376:cb4d9db17537 30 (+) Configure these IRDA pins as alternate function pull-up.
mbed_official 376:cb4d9db17537 31 (##) NVIC configuration if you need to use interrupt process (HAL_IRDA_Transmit_IT()
mbed_official 376:cb4d9db17537 32 and HAL_IRDA_Receive_IT() APIs):
mbed_official 376:cb4d9db17537 33 (+) Configure the USARTx interrupt priority.
mbed_official 376:cb4d9db17537 34 (+) Enable the NVIC USART IRQ handle.
mbed_official 376:cb4d9db17537 35 (##) DMA Configuration if you need to use DMA process (HAL_IRDA_Transmit_DMA()
mbed_official 376:cb4d9db17537 36 and HAL_IRDA_Receive_DMA() APIs):
mbed_official 376:cb4d9db17537 37 (+) Declare a DMA handle structure for the Tx/Rx channel.
mbed_official 376:cb4d9db17537 38 (+) Enable the DMAx interface clock.
mbed_official 376:cb4d9db17537 39 (+) Configure the declared DMA handle structure with the required Tx/Rx parameters.
mbed_official 376:cb4d9db17537 40 (+) Configure the DMA Tx/Rx channel.
mbed_official 376:cb4d9db17537 41 (+) Associate the initilalized DMA handle to the IRDA DMA Tx/Rx handle.
mbed_official 376:cb4d9db17537 42 (+) Configure the priority and enable the NVIC for the transfer complete interrupt on the DMA Tx/Rx channel.
mbed_official 376:cb4d9db17537 43
mbed_official 376:cb4d9db17537 44 (#) Program the Baud Rate, Word Length, Parity, IrDA Mode, Prescaler
mbed_official 376:cb4d9db17537 45 and Mode(Receiver/Transmitter) in the hirda Init structure.
mbed_official 376:cb4d9db17537 46
mbed_official 376:cb4d9db17537 47 (#) Initialize the IRDA registers by calling the HAL_IRDA_Init() API:
mbed_official 376:cb4d9db17537 48 (++) This API configures also the low level Hardware GPIO, CLOCK, CORTEX...etc)
mbed_official 376:cb4d9db17537 49 by calling the customed HAL_IRDA_MspInit() API.
mbed_official 376:cb4d9db17537 50 -@@- The specific IRDA interrupts (Transmission complete interrupt,
mbed_official 376:cb4d9db17537 51 RXNE interrupt and Error Interrupts) will be managed using the macros
mbed_official 376:cb4d9db17537 52 __HAL_IRDA_ENABLE_IT() and __HAL_IRDA_DISABLE_IT() inside the transmit and receive process.
mbed_official 376:cb4d9db17537 53
mbed_official 376:cb4d9db17537 54 (#) Three operation modes are available within this driver :
mbed_official 376:cb4d9db17537 55
mbed_official 376:cb4d9db17537 56 *** Polling mode IO operation ***
mbed_official 376:cb4d9db17537 57 =================================
mbed_official 376:cb4d9db17537 58 [..]
mbed_official 376:cb4d9db17537 59 (+) Send an amount of data in blocking mode using HAL_IRDA_Transmit()
mbed_official 376:cb4d9db17537 60 (+) Receive an amount of data in blocking mode using HAL_IRDA_Receive()
mbed_official 376:cb4d9db17537 61
mbed_official 376:cb4d9db17537 62 *** Interrupt mode IO operation ***
mbed_official 376:cb4d9db17537 63 ===================================
mbed_official 376:cb4d9db17537 64 [..]
mbed_official 376:cb4d9db17537 65 (+) Send an amount of data in non blocking mode using HAL_IRDA_Transmit_IT()
mbed_official 376:cb4d9db17537 66 (+) At transmission end of transfer HAL_IRDA_TxCpltCallback is executed and user can
mbed_official 376:cb4d9db17537 67 add his own code by customization of function pointer HAL_IRDA_TxCpltCallback
mbed_official 376:cb4d9db17537 68 (+) Receive an amount of data in non blocking mode using HAL_IRDA_Receive_IT()
mbed_official 376:cb4d9db17537 69 (+) At reception end of transfer HAL_IRDA_RxCpltCallback is executed and user can
mbed_official 376:cb4d9db17537 70 add his own code by customization of function pointer HAL_IRDA_RxCpltCallback
mbed_official 376:cb4d9db17537 71 (+) In case of transfer Error, HAL_IRDA_ErrorCallback() function is executed and user can
mbed_official 376:cb4d9db17537 72 add his own code by customization of function pointer HAL_IRDA_ErrorCallback
mbed_official 376:cb4d9db17537 73
mbed_official 376:cb4d9db17537 74 *** DMA mode IO operation ***
mbed_official 376:cb4d9db17537 75 =============================
mbed_official 376:cb4d9db17537 76 [..]
mbed_official 376:cb4d9db17537 77 (+) Send an amount of data in non blocking mode (DMA) using HAL_IRDA_Transmit_DMA()
mbed_official 376:cb4d9db17537 78 (+) At transmission end of transfer HAL_IRDA_TxCpltCallback is executed and user can
mbed_official 376:cb4d9db17537 79 add his own code by customization of function pointer HAL_IRDA_TxCpltCallback
mbed_official 376:cb4d9db17537 80 (+) Receive an amount of data in non blocking mode (DMA) using HAL_IRDA_Receive_DMA()
mbed_official 376:cb4d9db17537 81 (+) At reception end of transfer HAL_IRDA_RxCpltCallback is executed and user can
mbed_official 376:cb4d9db17537 82 add his own code by customization of function pointer HAL_IRDA_RxCpltCallback
mbed_official 376:cb4d9db17537 83 (+) In case of transfer Error, HAL_IRDA_ErrorCallback() function is executed and user can
mbed_official 376:cb4d9db17537 84 add his own code by customization of function pointer HAL_IRDA_ErrorCallback
mbed_official 376:cb4d9db17537 85
mbed_official 376:cb4d9db17537 86 *** IRDA HAL driver macros list ***
mbed_official 376:cb4d9db17537 87 ===================================
mbed_official 376:cb4d9db17537 88 [..]
mbed_official 376:cb4d9db17537 89 Below the list of most used macros in IRDA HAL driver.
mbed_official 376:cb4d9db17537 90
mbed_official 376:cb4d9db17537 91 (+) __HAL_IRDA_ENABLE: Enable the IRDA peripheral
mbed_official 376:cb4d9db17537 92 (+) __HAL_IRDA_DISABLE: Disable the IRDA peripheral
mbed_official 376:cb4d9db17537 93 (+) __HAL_IRDA_GET_FLAG : Checks whether the specified IRDA flag is set or not
mbed_official 376:cb4d9db17537 94 (+) __HAL_IRDA_CLEAR_FLAG : Clears the specified IRDA pending flag
mbed_official 376:cb4d9db17537 95 (+) __HAL_IRDA_ENABLE_IT: Enables the specified IRDA interrupt
mbed_official 376:cb4d9db17537 96 (+) __HAL_IRDA_DISABLE_IT: Disables the specified IRDA interrupt
mbed_official 376:cb4d9db17537 97
mbed_official 376:cb4d9db17537 98 (@) You can refer to the IRDA HAL driver header file for more useful macros
mbed_official 376:cb4d9db17537 99
mbed_official 376:cb4d9db17537 100 @endverbatim
mbed_official 376:cb4d9db17537 101 ******************************************************************************
mbed_official 376:cb4d9db17537 102 * @attention
mbed_official 376:cb4d9db17537 103 *
mbed_official 376:cb4d9db17537 104 * <h2><center>&copy; COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
mbed_official 376:cb4d9db17537 105 *
mbed_official 376:cb4d9db17537 106 * Redistribution and use in source and binary forms, with or without modification,
mbed_official 376:cb4d9db17537 107 * are permitted provided that the following conditions are met:
mbed_official 376:cb4d9db17537 108 * 1. Redistributions of source code must retain the above copyright notice,
mbed_official 376:cb4d9db17537 109 * this list of conditions and the following disclaimer.
mbed_official 376:cb4d9db17537 110 * 2. Redistributions in binary form must reproduce the above copyright notice,
mbed_official 376:cb4d9db17537 111 * this list of conditions and the following disclaimer in the documentation
mbed_official 376:cb4d9db17537 112 * and/or other materials provided with the distribution.
mbed_official 376:cb4d9db17537 113 * 3. Neither the name of STMicroelectronics nor the names of its contributors
mbed_official 376:cb4d9db17537 114 * may be used to endorse or promote products derived from this software
mbed_official 376:cb4d9db17537 115 * without specific prior written permission.
mbed_official 376:cb4d9db17537 116 *
mbed_official 376:cb4d9db17537 117 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
mbed_official 376:cb4d9db17537 118 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
mbed_official 376:cb4d9db17537 119 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
mbed_official 376:cb4d9db17537 120 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
mbed_official 376:cb4d9db17537 121 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
mbed_official 376:cb4d9db17537 122 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
mbed_official 376:cb4d9db17537 123 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
mbed_official 376:cb4d9db17537 124 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
mbed_official 376:cb4d9db17537 125 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
mbed_official 376:cb4d9db17537 126 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
mbed_official 376:cb4d9db17537 127 *
mbed_official 376:cb4d9db17537 128 ******************************************************************************
mbed_official 376:cb4d9db17537 129 */
mbed_official 376:cb4d9db17537 130
mbed_official 376:cb4d9db17537 131 /* Includes ------------------------------------------------------------------*/
mbed_official 376:cb4d9db17537 132 #include "stm32l0xx_hal.h"
mbed_official 376:cb4d9db17537 133
mbed_official 376:cb4d9db17537 134 /** @addtogroup STM32L0xx_HAL_Driver
mbed_official 376:cb4d9db17537 135 * @{
mbed_official 376:cb4d9db17537 136 */
mbed_official 376:cb4d9db17537 137
mbed_official 376:cb4d9db17537 138 /** @defgroup IRDA
mbed_official 376:cb4d9db17537 139 * @brief IRDA HAL module driver
mbed_official 376:cb4d9db17537 140 * @{
mbed_official 376:cb4d9db17537 141 */
mbed_official 376:cb4d9db17537 142 #ifdef HAL_IRDA_MODULE_ENABLED
mbed_official 376:cb4d9db17537 143
mbed_official 376:cb4d9db17537 144 /* Private typedef -----------------------------------------------------------*/
mbed_official 376:cb4d9db17537 145 /* Private define ------------------------------------------------------------*/
mbed_official 376:cb4d9db17537 146 #define TEACK_REACK_TIMEOUT 1000
mbed_official 376:cb4d9db17537 147 #define HAL_IRDA_TXDMA_TIMEOUTVALUE 22000
mbed_official 376:cb4d9db17537 148 #define IRDA_CR1_FIELDS ((uint32_t)(USART_CR1_M | USART_CR1_PCE \
mbed_official 376:cb4d9db17537 149 | USART_CR1_PS | USART_CR1_TE | USART_CR1_RE))
mbed_official 376:cb4d9db17537 150 /* Private macro -------------------------------------------------------------*/
mbed_official 376:cb4d9db17537 151 /* Private variables ---------------------------------------------------------*/
mbed_official 376:cb4d9db17537 152 /* Private function prototypes -----------------------------------------------*/
mbed_official 376:cb4d9db17537 153 static void IRDA_DMATransmitCplt(DMA_HandleTypeDef *hdma);
mbed_official 376:cb4d9db17537 154 static void IRDA_DMATransmitHalfCplt(DMA_HandleTypeDef *hdma);
mbed_official 376:cb4d9db17537 155 static void IRDA_DMAReceiveCplt(DMA_HandleTypeDef *hdma);
mbed_official 376:cb4d9db17537 156 static void IRDA_DMAReceiveHalfCplt(DMA_HandleTypeDef *hdma);
mbed_official 376:cb4d9db17537 157 static void IRDA_DMAError(DMA_HandleTypeDef *hdma);
mbed_official 376:cb4d9db17537 158 static void IRDA_SetConfig (IRDA_HandleTypeDef *hirda);
mbed_official 376:cb4d9db17537 159 static HAL_StatusTypeDef IRDA_CheckIdleState(IRDA_HandleTypeDef *hirda);
mbed_official 376:cb4d9db17537 160 static HAL_StatusTypeDef IRDA_WaitOnFlagUntilTimeout(IRDA_HandleTypeDef *hirda, uint32_t Flag, FlagStatus Status, uint32_t Timeout);
mbed_official 376:cb4d9db17537 161 static HAL_StatusTypeDef IRDA_Transmit_IT(IRDA_HandleTypeDef *hirda);
mbed_official 376:cb4d9db17537 162
mbed_official 376:cb4d9db17537 163 static HAL_StatusTypeDef IRDA_Receive_IT(IRDA_HandleTypeDef *hirda);
mbed_official 376:cb4d9db17537 164 /* Private functions ---------------------------------------------------------*/
mbed_official 376:cb4d9db17537 165
mbed_official 376:cb4d9db17537 166 /** @defgroup IRDA_Private_Functions
mbed_official 376:cb4d9db17537 167 * @{
mbed_official 376:cb4d9db17537 168 */
mbed_official 376:cb4d9db17537 169
mbed_official 376:cb4d9db17537 170 /** @defgroup IRDA_Group1 Initialization/de-initialization functions
mbed_official 376:cb4d9db17537 171 * @brief Initialization and Configuration functions
mbed_official 376:cb4d9db17537 172 *
mbed_official 376:cb4d9db17537 173 @verbatim
mbed_official 376:cb4d9db17537 174 ===============================================================================
mbed_official 376:cb4d9db17537 175 ##### Initialization and Configuration functions #####
mbed_official 376:cb4d9db17537 176 ===============================================================================
mbed_official 376:cb4d9db17537 177 [..]
mbed_official 376:cb4d9db17537 178 This subsection provides a set of functions allowing to initialize the USARTx
mbed_official 376:cb4d9db17537 179 in asynchronous IRDA mode.
mbed_official 376:cb4d9db17537 180 (+) For the asynchronous mode only these parameters can be configured:
mbed_official 376:cb4d9db17537 181 (++) Baud Rate
mbed_official 376:cb4d9db17537 182 (++) Word Length
mbed_official 376:cb4d9db17537 183 (++) Parity: If the parity is enabled, then the MSB bit of the data written
mbed_official 376:cb4d9db17537 184 in the data register is transmitted but is changed by the parity bit.
mbed_official 376:cb4d9db17537 185 Depending on the frame length defined by the M bit (8-bits or 9-bits)
mbed_official 376:cb4d9db17537 186 or by the M1 and M0 bits (7-bit, 8-bit or 9-bit),
mbed_official 376:cb4d9db17537 187 the possible IRDA frame formats are as listed in the following table:
mbed_official 376:cb4d9db17537 188 +---------------------------------------------------------------+
mbed_official 376:cb4d9db17537 189 | M1M0 bits | PCE bit | IRDA frame |
mbed_official 376:cb4d9db17537 190 |-----------|-----------|---------------------------------------|
mbed_official 376:cb4d9db17537 191 | 00 | 0 | | SB | 8-bit data | STB | |
mbed_official 376:cb4d9db17537 192 |-----------|-----------|---------------------------------------|
mbed_official 376:cb4d9db17537 193 | 00 | 1 | | SB | 7-bit data | PB | STB | |
mbed_official 376:cb4d9db17537 194 |-----------|-----------|---------------------------------------|
mbed_official 376:cb4d9db17537 195 | 01 | 0 | | SB | 9-bit data | STB | |
mbed_official 376:cb4d9db17537 196 |-----------|-----------|---------------------------------------|
mbed_official 376:cb4d9db17537 197 | 01 | 1 | | SB | 8-bit data | PB | STB | |
mbed_official 376:cb4d9db17537 198 |-----------------------|---------------------------------------|
mbed_official 376:cb4d9db17537 199 | 10 | 0 | | SB | 7-bit data | STB | |
mbed_official 376:cb4d9db17537 200 |-----------|-----------|---------------------------------------|
mbed_official 376:cb4d9db17537 201 | 10 | 1 | | SB | 6-bit data | PB | STB | |
mbed_official 376:cb4d9db17537 202 +---------------------------------------------------------------+
mbed_official 376:cb4d9db17537 203
mbed_official 376:cb4d9db17537 204 (++) Power mode
mbed_official 376:cb4d9db17537 205 (++) Prescaler setting
mbed_official 376:cb4d9db17537 206 (++) Receiver/transmitter modes
mbed_official 376:cb4d9db17537 207
mbed_official 376:cb4d9db17537 208 [..]
mbed_official 376:cb4d9db17537 209 The HAL_IRDA_Init() API follows the USART asynchronous configuration procedures
mbed_official 376:cb4d9db17537 210 (details for the procedures are available in reference manual).
mbed_official 376:cb4d9db17537 211
mbed_official 376:cb4d9db17537 212 @endverbatim
mbed_official 376:cb4d9db17537 213 * @{
mbed_official 376:cb4d9db17537 214 */
mbed_official 376:cb4d9db17537 215
mbed_official 376:cb4d9db17537 216 /**
mbed_official 376:cb4d9db17537 217 * @brief Initializes the IRDA mode according to the specified
mbed_official 376:cb4d9db17537 218 * parameters in the IRDA_InitTypeDef and creates the associated handle .
mbed_official 376:cb4d9db17537 219 * @param hirda: IRDA handle
mbed_official 376:cb4d9db17537 220 * @retval HAL status
mbed_official 376:cb4d9db17537 221 */
mbed_official 376:cb4d9db17537 222 HAL_StatusTypeDef HAL_IRDA_Init(IRDA_HandleTypeDef *hirda)
mbed_official 376:cb4d9db17537 223 {
mbed_official 376:cb4d9db17537 224 /* Check the IRDA handle allocation */
mbed_official 387:643a59b3dbac 225 if(hirda == HAL_NULL)
mbed_official 376:cb4d9db17537 226 {
mbed_official 376:cb4d9db17537 227 return HAL_ERROR;
mbed_official 376:cb4d9db17537 228 }
mbed_official 376:cb4d9db17537 229
mbed_official 376:cb4d9db17537 230 /* Check the USART/UART associated to the IRDA handle */
mbed_official 376:cb4d9db17537 231 assert_param(IS_IRDA_INSTANCE(hirda->Instance));
mbed_official 376:cb4d9db17537 232
mbed_official 376:cb4d9db17537 233 if(hirda->State == HAL_IRDA_STATE_RESET)
mbed_official 376:cb4d9db17537 234 {
mbed_official 376:cb4d9db17537 235 /* Init the low level hardware : GPIO, CLOCK, CORTEX */
mbed_official 376:cb4d9db17537 236 HAL_IRDA_MspInit(hirda);
mbed_official 376:cb4d9db17537 237 }
mbed_official 376:cb4d9db17537 238
mbed_official 376:cb4d9db17537 239 hirda->State = HAL_IRDA_STATE_BUSY;
mbed_official 376:cb4d9db17537 240
mbed_official 376:cb4d9db17537 241 /* Disable the Peripheral to update the configuration registers */
mbed_official 376:cb4d9db17537 242 __HAL_IRDA_DISABLE(hirda);
mbed_official 376:cb4d9db17537 243
mbed_official 376:cb4d9db17537 244 /* Set the IRDA Communication parameters */
mbed_official 376:cb4d9db17537 245 IRDA_SetConfig(hirda);
mbed_official 376:cb4d9db17537 246
mbed_official 376:cb4d9db17537 247 /* In IRDA mode, the following bits must be kept cleared:
mbed_official 376:cb4d9db17537 248 - LINEN, STOP and CLKEN bits in the USART_CR2 register,
mbed_official 376:cb4d9db17537 249 - SCEN and HDSEL bits in the USART_CR3 register.*/
mbed_official 376:cb4d9db17537 250 hirda->Instance->CR2 &= ~(USART_CR2_LINEN | USART_CR2_CLKEN | USART_CR2_STOP);
mbed_official 376:cb4d9db17537 251 hirda->Instance->CR3 &= ~(USART_CR3_SCEN | USART_CR3_HDSEL);
mbed_official 376:cb4d9db17537 252
mbed_official 376:cb4d9db17537 253 /* set the UART/USART in IRDA mode */
mbed_official 376:cb4d9db17537 254 hirda->Instance->CR3 |= USART_CR3_IREN;
mbed_official 376:cb4d9db17537 255
mbed_official 376:cb4d9db17537 256 /* Enable the Peripheral */
mbed_official 376:cb4d9db17537 257 __HAL_IRDA_ENABLE(hirda);
mbed_official 376:cb4d9db17537 258
mbed_official 376:cb4d9db17537 259 /* TEACK and/or REACK to check before moving hirda->State to Ready */
mbed_official 376:cb4d9db17537 260 return (IRDA_CheckIdleState(hirda));
mbed_official 376:cb4d9db17537 261 }
mbed_official 376:cb4d9db17537 262
mbed_official 376:cb4d9db17537 263 /**
mbed_official 376:cb4d9db17537 264 * @brief DeInitializes the IRDA peripheral
mbed_official 376:cb4d9db17537 265 * @param hirda: IRDA handle
mbed_official 376:cb4d9db17537 266 * @retval HAL status
mbed_official 376:cb4d9db17537 267 */
mbed_official 376:cb4d9db17537 268 HAL_StatusTypeDef HAL_IRDA_DeInit(IRDA_HandleTypeDef *hirda)
mbed_official 376:cb4d9db17537 269 {
mbed_official 376:cb4d9db17537 270 /* Check the IRDA handle allocation */
mbed_official 387:643a59b3dbac 271 if(hirda == HAL_NULL)
mbed_official 376:cb4d9db17537 272 {
mbed_official 376:cb4d9db17537 273 return HAL_ERROR;
mbed_official 376:cb4d9db17537 274 }
mbed_official 376:cb4d9db17537 275
mbed_official 376:cb4d9db17537 276 /* Check the USART/UART associated to the IRDA handle */
mbed_official 376:cb4d9db17537 277 assert_param(IS_IRDA_INSTANCE(hirda->Instance));
mbed_official 376:cb4d9db17537 278
mbed_official 376:cb4d9db17537 279 hirda->State = HAL_IRDA_STATE_BUSY;
mbed_official 376:cb4d9db17537 280
mbed_official 376:cb4d9db17537 281 /* DeInit the low level hardware */
mbed_official 376:cb4d9db17537 282 HAL_IRDA_MspDeInit(hirda);
mbed_official 376:cb4d9db17537 283 /* Disable the Peripheral */
mbed_official 376:cb4d9db17537 284 __HAL_IRDA_DISABLE(hirda);
mbed_official 376:cb4d9db17537 285
mbed_official 376:cb4d9db17537 286 hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
mbed_official 376:cb4d9db17537 287 hirda->State = HAL_IRDA_STATE_RESET;
mbed_official 376:cb4d9db17537 288
mbed_official 376:cb4d9db17537 289 /* Release Lock */
mbed_official 376:cb4d9db17537 290 __HAL_UNLOCK(hirda);
mbed_official 376:cb4d9db17537 291
mbed_official 376:cb4d9db17537 292 return HAL_OK;
mbed_official 376:cb4d9db17537 293 }
mbed_official 376:cb4d9db17537 294
mbed_official 376:cb4d9db17537 295 /**
mbed_official 376:cb4d9db17537 296 * @brief IRDA MSP Init
mbed_official 376:cb4d9db17537 297 * @param hirda: IRDA handle
mbed_official 376:cb4d9db17537 298 * @retval None
mbed_official 376:cb4d9db17537 299 */
mbed_official 376:cb4d9db17537 300 __weak void HAL_IRDA_MspInit(IRDA_HandleTypeDef *hirda)
mbed_official 376:cb4d9db17537 301 {
mbed_official 376:cb4d9db17537 302 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 376:cb4d9db17537 303 the HAL_IRDA_MspInit could be implented in the user file
mbed_official 376:cb4d9db17537 304 */
mbed_official 376:cb4d9db17537 305 }
mbed_official 376:cb4d9db17537 306
mbed_official 376:cb4d9db17537 307 /**
mbed_official 376:cb4d9db17537 308 * @brief IRDA MSP DeInit
mbed_official 376:cb4d9db17537 309 * @param hirda: IRDA handle
mbed_official 376:cb4d9db17537 310 * @retval None
mbed_official 376:cb4d9db17537 311 */
mbed_official 376:cb4d9db17537 312 __weak void HAL_IRDA_MspDeInit(IRDA_HandleTypeDef *hirda)
mbed_official 376:cb4d9db17537 313 {
mbed_official 376:cb4d9db17537 314 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 376:cb4d9db17537 315 the HAL_IRDA_MspDeInit could be implented in the user file
mbed_official 376:cb4d9db17537 316 */
mbed_official 376:cb4d9db17537 317 }
mbed_official 376:cb4d9db17537 318
mbed_official 376:cb4d9db17537 319 /**
mbed_official 376:cb4d9db17537 320 * @}
mbed_official 376:cb4d9db17537 321 */
mbed_official 376:cb4d9db17537 322
mbed_official 376:cb4d9db17537 323 /** @defgroup IRDA_Group2 IO operation functions
mbed_official 376:cb4d9db17537 324 * @brief IRDA Transmit-Receive functions
mbed_official 376:cb4d9db17537 325 *
mbed_official 376:cb4d9db17537 326 @verbatim
mbed_official 376:cb4d9db17537 327 ===============================================================================
mbed_official 376:cb4d9db17537 328 ##### IO operation functions #####
mbed_official 376:cb4d9db17537 329 ===============================================================================
mbed_official 376:cb4d9db17537 330 [..]
mbed_official 376:cb4d9db17537 331 This subsection provides a set of functions allowing to manage the IRDA asynchronous
mbed_official 376:cb4d9db17537 332 data transfers.
mbed_official 376:cb4d9db17537 333
mbed_official 376:cb4d9db17537 334 (#) There are two modes of transfer:
mbed_official 376:cb4d9db17537 335 (++) Blocking mode: the communication is performed in polling mode.
mbed_official 376:cb4d9db17537 336 The HAL status of all data processing is returned by the same function
mbed_official 376:cb4d9db17537 337 after finishing transfer.
mbed_official 376:cb4d9db17537 338 (++) No-Blocking mode: the communication is performed using Interrupts
mbed_official 376:cb4d9db17537 339 or DMA, these API's return the HAL status.
mbed_official 376:cb4d9db17537 340 The end of the data processing will be indicated through the
mbed_official 376:cb4d9db17537 341 dedicated IRDA IRQ when using Interrupt mode or the DMA IRQ when
mbed_official 376:cb4d9db17537 342 using DMA mode.
mbed_official 376:cb4d9db17537 343 The HAL_IRDA_TxCpltCallback(), HAL_IRDA_RxCpltCallback() user callbacks
mbed_official 376:cb4d9db17537 344 will be executed respectivelly at the end of the Transmit or Receive process
mbed_official 376:cb4d9db17537 345 The HAL_IRDA_ErrorCallback() user callback will be executed when a communication error is detected
mbed_official 376:cb4d9db17537 346
mbed_official 376:cb4d9db17537 347 (#) Blocking mode API's are :
mbed_official 376:cb4d9db17537 348 (++) HAL_IRDA_Transmit()
mbed_official 376:cb4d9db17537 349 (++) HAL_IRDA_Receive()
mbed_official 376:cb4d9db17537 350
mbed_official 376:cb4d9db17537 351 (#) Non-Blocking mode API's with Interrupt are :
mbed_official 376:cb4d9db17537 352 (++) HAL_IRDA_Transmit_IT()
mbed_official 376:cb4d9db17537 353 (++) HAL_IRDA_Receive_IT()
mbed_official 376:cb4d9db17537 354 (++) HAL_IRDA_IRQHandler()
mbed_official 376:cb4d9db17537 355 (++) IRDA_Transmit_IT()
mbed_official 376:cb4d9db17537 356 (++) IRDA_Receive_IT()
mbed_official 376:cb4d9db17537 357
mbed_official 376:cb4d9db17537 358 (#) Non-Blocking mode functions with DMA are :
mbed_official 376:cb4d9db17537 359 (++) HAL_IRDA_Transmit_DMA()
mbed_official 376:cb4d9db17537 360 (++) HAL_IRDA_Receive_DMA()
mbed_official 376:cb4d9db17537 361
mbed_official 376:cb4d9db17537 362 (#) A set of Transfer Complete Callbacks are provided in No_Blocking mode:
mbed_official 376:cb4d9db17537 363 (++) HAL_IRDA_TxCpltCallback()
mbed_official 376:cb4d9db17537 364 (++) HAL_IRDA_RxCpltCallback()
mbed_official 376:cb4d9db17537 365 (++) HAL_IRDA_ErrorCallback()
mbed_official 376:cb4d9db17537 366
mbed_official 376:cb4d9db17537 367 @endverbatim
mbed_official 376:cb4d9db17537 368 * @{
mbed_official 376:cb4d9db17537 369 */
mbed_official 376:cb4d9db17537 370
mbed_official 376:cb4d9db17537 371 /**
mbed_official 376:cb4d9db17537 372 * @brief Send an amount of data in blocking mode
mbed_official 376:cb4d9db17537 373 * @param hirda: IRDA handle
mbed_official 376:cb4d9db17537 374 * @param pData: pointer to data buffer
mbed_official 376:cb4d9db17537 375 * @param Size: amount of data to be sent
mbed_official 376:cb4d9db17537 376 * @param Timeout: Duration of the timeout
mbed_official 376:cb4d9db17537 377 * @retval HAL status
mbed_official 376:cb4d9db17537 378 */
mbed_official 376:cb4d9db17537 379 HAL_StatusTypeDef HAL_IRDA_Transmit(IRDA_HandleTypeDef *hirda, uint8_t *pData, uint16_t Size, uint32_t Timeout)
mbed_official 376:cb4d9db17537 380 {
mbed_official 376:cb4d9db17537 381 uint16_t* tmp;
mbed_official 376:cb4d9db17537 382
mbed_official 376:cb4d9db17537 383 if ((hirda->State == HAL_IRDA_STATE_READY) || (hirda->State == HAL_IRDA_STATE_BUSY_RX))
mbed_official 376:cb4d9db17537 384 {
mbed_official 387:643a59b3dbac 385 if((pData == HAL_NULL) || (Size == 0))
mbed_official 376:cb4d9db17537 386 {
mbed_official 376:cb4d9db17537 387 return HAL_ERROR;
mbed_official 376:cb4d9db17537 388 }
mbed_official 376:cb4d9db17537 389
mbed_official 376:cb4d9db17537 390 /* Process Locked */
mbed_official 376:cb4d9db17537 391 __HAL_LOCK(hirda);
mbed_official 376:cb4d9db17537 392 hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
mbed_official 376:cb4d9db17537 393
mbed_official 376:cb4d9db17537 394 if(hirda->State == HAL_IRDA_STATE_BUSY_RX)
mbed_official 376:cb4d9db17537 395 {
mbed_official 376:cb4d9db17537 396 hirda->State = HAL_IRDA_STATE_BUSY_TX_RX;
mbed_official 376:cb4d9db17537 397 }
mbed_official 376:cb4d9db17537 398 else
mbed_official 376:cb4d9db17537 399 {
mbed_official 376:cb4d9db17537 400 hirda->State = HAL_IRDA_STATE_BUSY_TX;
mbed_official 376:cb4d9db17537 401 }
mbed_official 376:cb4d9db17537 402
mbed_official 376:cb4d9db17537 403 hirda->TxXferSize = Size;
mbed_official 376:cb4d9db17537 404 hirda->TxXferCount = Size;
mbed_official 376:cb4d9db17537 405 while(hirda->TxXferCount > 0)
mbed_official 376:cb4d9db17537 406 {
mbed_official 376:cb4d9db17537 407 hirda->TxXferCount--;
mbed_official 376:cb4d9db17537 408
mbed_official 376:cb4d9db17537 409 if(IRDA_WaitOnFlagUntilTimeout(hirda, IRDA_FLAG_TXE, RESET, Timeout) != HAL_OK)
mbed_official 376:cb4d9db17537 410 {
mbed_official 376:cb4d9db17537 411 return HAL_TIMEOUT;
mbed_official 376:cb4d9db17537 412 }
mbed_official 376:cb4d9db17537 413 if ((hirda->Init.WordLength == IRDA_WORDLENGTH_9B) && (hirda->Init.Parity == IRDA_PARITY_NONE))
mbed_official 376:cb4d9db17537 414 {
mbed_official 376:cb4d9db17537 415 tmp = (uint16_t*) pData;
mbed_official 376:cb4d9db17537 416 hirda->Instance->TDR = (*tmp & (uint16_t)0x01FF);
mbed_official 376:cb4d9db17537 417 pData +=2;
mbed_official 376:cb4d9db17537 418 }
mbed_official 376:cb4d9db17537 419 else
mbed_official 376:cb4d9db17537 420 {
mbed_official 376:cb4d9db17537 421 hirda->Instance->TDR = (*pData++ & (uint8_t)0xFF);
mbed_official 376:cb4d9db17537 422 }
mbed_official 376:cb4d9db17537 423 }
mbed_official 376:cb4d9db17537 424
mbed_official 376:cb4d9db17537 425 if(IRDA_WaitOnFlagUntilTimeout(hirda, IRDA_FLAG_TC, RESET, Timeout) != HAL_OK)
mbed_official 376:cb4d9db17537 426 {
mbed_official 376:cb4d9db17537 427 return HAL_TIMEOUT;
mbed_official 376:cb4d9db17537 428 }
mbed_official 376:cb4d9db17537 429
mbed_official 376:cb4d9db17537 430 if(hirda->State == HAL_IRDA_STATE_BUSY_TX_RX)
mbed_official 376:cb4d9db17537 431 {
mbed_official 376:cb4d9db17537 432 hirda->State = HAL_IRDA_STATE_BUSY_RX;
mbed_official 376:cb4d9db17537 433 }
mbed_official 376:cb4d9db17537 434 else
mbed_official 376:cb4d9db17537 435 {
mbed_official 376:cb4d9db17537 436 hirda->State = HAL_IRDA_STATE_READY;
mbed_official 376:cb4d9db17537 437 }
mbed_official 376:cb4d9db17537 438
mbed_official 376:cb4d9db17537 439 /* Process Unlocked */
mbed_official 376:cb4d9db17537 440 __HAL_UNLOCK(hirda);
mbed_official 376:cb4d9db17537 441
mbed_official 376:cb4d9db17537 442 return HAL_OK;
mbed_official 376:cb4d9db17537 443 }
mbed_official 376:cb4d9db17537 444 else
mbed_official 376:cb4d9db17537 445 {
mbed_official 376:cb4d9db17537 446 return HAL_BUSY;
mbed_official 376:cb4d9db17537 447 }
mbed_official 376:cb4d9db17537 448 }
mbed_official 376:cb4d9db17537 449
mbed_official 376:cb4d9db17537 450 /**
mbed_official 376:cb4d9db17537 451 * @brief Receive an amount of data in blocking mode
mbed_official 376:cb4d9db17537 452 * @param hirda: IRDA handle
mbed_official 376:cb4d9db17537 453 * @param pData: pointer to data buffer
mbed_official 376:cb4d9db17537 454 * @param Size: amount of data to be received
mbed_official 376:cb4d9db17537 455 * @param Timeout: Duration of the timeout
mbed_official 376:cb4d9db17537 456 * @retval HAL status
mbed_official 376:cb4d9db17537 457 */
mbed_official 376:cb4d9db17537 458 HAL_StatusTypeDef HAL_IRDA_Receive(IRDA_HandleTypeDef *hirda, uint8_t *pData, uint16_t Size, uint32_t Timeout)
mbed_official 376:cb4d9db17537 459 {
mbed_official 376:cb4d9db17537 460 uint16_t* tmp;
mbed_official 376:cb4d9db17537 461 uint16_t uhMask;
mbed_official 376:cb4d9db17537 462
mbed_official 376:cb4d9db17537 463 if ((hirda->State == HAL_IRDA_STATE_READY) || (hirda->State == HAL_IRDA_STATE_BUSY_TX))
mbed_official 376:cb4d9db17537 464 {
mbed_official 387:643a59b3dbac 465 if((pData == HAL_NULL) || (Size == 0))
mbed_official 376:cb4d9db17537 466 {
mbed_official 376:cb4d9db17537 467 return HAL_ERROR;
mbed_official 376:cb4d9db17537 468 }
mbed_official 376:cb4d9db17537 469
mbed_official 376:cb4d9db17537 470 /* Process Locked */
mbed_official 376:cb4d9db17537 471 __HAL_LOCK(hirda);
mbed_official 376:cb4d9db17537 472 hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
mbed_official 376:cb4d9db17537 473
mbed_official 376:cb4d9db17537 474 if(hirda->State == HAL_IRDA_STATE_BUSY_TX)
mbed_official 376:cb4d9db17537 475 {
mbed_official 376:cb4d9db17537 476 hirda->State = HAL_IRDA_STATE_BUSY_TX_RX;
mbed_official 376:cb4d9db17537 477 }
mbed_official 376:cb4d9db17537 478 else
mbed_official 376:cb4d9db17537 479 {
mbed_official 376:cb4d9db17537 480 hirda->State = HAL_IRDA_STATE_BUSY_RX;
mbed_official 376:cb4d9db17537 481 }
mbed_official 376:cb4d9db17537 482
mbed_official 376:cb4d9db17537 483 hirda->RxXferSize = Size;
mbed_official 376:cb4d9db17537 484 hirda->RxXferCount = Size;
mbed_official 376:cb4d9db17537 485
mbed_official 376:cb4d9db17537 486 /* Computation of the mask to apply to the RDR register
mbed_official 376:cb4d9db17537 487 of the UART associated to the IRDA */
mbed_official 376:cb4d9db17537 488 __HAL_IRDA_MASK_COMPUTATION(hirda);
mbed_official 376:cb4d9db17537 489 uhMask = hirda->Mask;
mbed_official 376:cb4d9db17537 490
mbed_official 376:cb4d9db17537 491 /* Check data remaining to be received */
mbed_official 376:cb4d9db17537 492 while(hirda->RxXferCount > 0)
mbed_official 376:cb4d9db17537 493 {
mbed_official 376:cb4d9db17537 494 hirda->RxXferCount--;
mbed_official 376:cb4d9db17537 495
mbed_official 376:cb4d9db17537 496 if(IRDA_WaitOnFlagUntilTimeout(hirda, IRDA_FLAG_RXNE, RESET, Timeout) != HAL_OK)
mbed_official 376:cb4d9db17537 497 {
mbed_official 376:cb4d9db17537 498 return HAL_TIMEOUT;
mbed_official 376:cb4d9db17537 499 }
mbed_official 376:cb4d9db17537 500 if ((hirda->Init.WordLength == IRDA_WORDLENGTH_9B) && (hirda->Init.Parity == IRDA_PARITY_NONE))
mbed_official 376:cb4d9db17537 501 {
mbed_official 376:cb4d9db17537 502 tmp = (uint16_t*) pData ;
mbed_official 376:cb4d9db17537 503 *tmp = (uint16_t)(hirda->Instance->RDR & uhMask);
mbed_official 376:cb4d9db17537 504 pData +=2;
mbed_official 376:cb4d9db17537 505 }
mbed_official 376:cb4d9db17537 506 else
mbed_official 376:cb4d9db17537 507 {
mbed_official 376:cb4d9db17537 508 *pData++ = (uint8_t)(hirda->Instance->RDR & (uint8_t)uhMask);
mbed_official 376:cb4d9db17537 509 }
mbed_official 376:cb4d9db17537 510 }
mbed_official 376:cb4d9db17537 511
mbed_official 376:cb4d9db17537 512 if(hirda->State == HAL_IRDA_STATE_BUSY_TX_RX)
mbed_official 376:cb4d9db17537 513 {
mbed_official 376:cb4d9db17537 514 hirda->State = HAL_IRDA_STATE_BUSY_TX;
mbed_official 376:cb4d9db17537 515 }
mbed_official 376:cb4d9db17537 516 else
mbed_official 376:cb4d9db17537 517 {
mbed_official 376:cb4d9db17537 518 hirda->State = HAL_IRDA_STATE_READY;
mbed_official 376:cb4d9db17537 519 }
mbed_official 376:cb4d9db17537 520
mbed_official 376:cb4d9db17537 521 /* Process Unlocked */
mbed_official 376:cb4d9db17537 522 __HAL_UNLOCK(hirda);
mbed_official 376:cb4d9db17537 523
mbed_official 376:cb4d9db17537 524 return HAL_OK;
mbed_official 376:cb4d9db17537 525 }
mbed_official 376:cb4d9db17537 526 else
mbed_official 376:cb4d9db17537 527 {
mbed_official 376:cb4d9db17537 528 return HAL_BUSY;
mbed_official 376:cb4d9db17537 529 }
mbed_official 376:cb4d9db17537 530 }
mbed_official 376:cb4d9db17537 531
mbed_official 376:cb4d9db17537 532 /**
mbed_official 376:cb4d9db17537 533 * @brief Send an amount of data in interrupt mode
mbed_official 376:cb4d9db17537 534 * @param hirda: IRDA handle
mbed_official 376:cb4d9db17537 535 * @param pData: pointer to data buffer
mbed_official 376:cb4d9db17537 536 * @param Size: amount of data to be sent
mbed_official 376:cb4d9db17537 537 * @retval HAL status
mbed_official 376:cb4d9db17537 538 */
mbed_official 376:cb4d9db17537 539 HAL_StatusTypeDef HAL_IRDA_Transmit_IT(IRDA_HandleTypeDef *hirda, uint8_t *pData, uint16_t Size)
mbed_official 376:cb4d9db17537 540 {
mbed_official 376:cb4d9db17537 541 if ((hirda->State == HAL_IRDA_STATE_READY) || (hirda->State == HAL_IRDA_STATE_BUSY_RX))
mbed_official 376:cb4d9db17537 542 {
mbed_official 387:643a59b3dbac 543 if((pData == HAL_NULL) || (Size == 0))
mbed_official 376:cb4d9db17537 544 {
mbed_official 376:cb4d9db17537 545 return HAL_ERROR;
mbed_official 376:cb4d9db17537 546 }
mbed_official 376:cb4d9db17537 547
mbed_official 376:cb4d9db17537 548 /* Process Locked */
mbed_official 376:cb4d9db17537 549 __HAL_LOCK(hirda);
mbed_official 376:cb4d9db17537 550
mbed_official 376:cb4d9db17537 551 hirda->pTxBuffPtr = pData;
mbed_official 376:cb4d9db17537 552 hirda->TxXferSize = Size;
mbed_official 376:cb4d9db17537 553 hirda->TxXferCount = Size;
mbed_official 376:cb4d9db17537 554
mbed_official 376:cb4d9db17537 555 hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
mbed_official 376:cb4d9db17537 556 if(hirda->State == HAL_IRDA_STATE_BUSY_RX)
mbed_official 376:cb4d9db17537 557 {
mbed_official 376:cb4d9db17537 558 hirda->State = HAL_IRDA_STATE_BUSY_TX_RX;
mbed_official 376:cb4d9db17537 559 }
mbed_official 376:cb4d9db17537 560 else
mbed_official 376:cb4d9db17537 561 {
mbed_official 376:cb4d9db17537 562 hirda->State = HAL_IRDA_STATE_BUSY_TX;
mbed_official 376:cb4d9db17537 563 }
mbed_official 376:cb4d9db17537 564
mbed_official 376:cb4d9db17537 565 /* Enable the IRDA Error Interrupt: (Frame error, noise error, overrun error) */
mbed_official 376:cb4d9db17537 566 __HAL_IRDA_ENABLE_IT(hirda, IRDA_IT_ERR);
mbed_official 376:cb4d9db17537 567
mbed_official 376:cb4d9db17537 568 /* Process Unlocked */
mbed_official 376:cb4d9db17537 569 __HAL_UNLOCK(hirda);
mbed_official 376:cb4d9db17537 570
mbed_official 376:cb4d9db17537 571 /* Enable the IRDA Transmit Complete Interrupt */
mbed_official 376:cb4d9db17537 572 __HAL_IRDA_ENABLE_IT(hirda, IRDA_IT_TC);
mbed_official 376:cb4d9db17537 573
mbed_official 376:cb4d9db17537 574 return HAL_OK;
mbed_official 376:cb4d9db17537 575 }
mbed_official 376:cb4d9db17537 576 else
mbed_official 376:cb4d9db17537 577 {
mbed_official 376:cb4d9db17537 578 return HAL_BUSY;
mbed_official 376:cb4d9db17537 579 }
mbed_official 376:cb4d9db17537 580 }
mbed_official 376:cb4d9db17537 581
mbed_official 376:cb4d9db17537 582 /**
mbed_official 376:cb4d9db17537 583 * @brief Receive an amount of data in interrupt mode
mbed_official 376:cb4d9db17537 584 * @param hirda: IRDA handle
mbed_official 376:cb4d9db17537 585 * @param pData: pointer to data buffer
mbed_official 376:cb4d9db17537 586 * @param Size: amount of data to be received
mbed_official 376:cb4d9db17537 587 * @retval HAL status
mbed_official 376:cb4d9db17537 588 */
mbed_official 376:cb4d9db17537 589 HAL_StatusTypeDef HAL_IRDA_Receive_IT(IRDA_HandleTypeDef *hirda, uint8_t *pData, uint16_t Size)
mbed_official 376:cb4d9db17537 590 {
mbed_official 376:cb4d9db17537 591 if ((hirda->State == HAL_IRDA_STATE_READY) || (hirda->State == HAL_IRDA_STATE_BUSY_TX))
mbed_official 376:cb4d9db17537 592 {
mbed_official 387:643a59b3dbac 593 if((pData == HAL_NULL) || (Size == 0))
mbed_official 376:cb4d9db17537 594 {
mbed_official 376:cb4d9db17537 595 return HAL_ERROR;
mbed_official 376:cb4d9db17537 596 }
mbed_official 376:cb4d9db17537 597
mbed_official 376:cb4d9db17537 598 /* Process Locked */
mbed_official 376:cb4d9db17537 599 __HAL_LOCK(hirda);
mbed_official 376:cb4d9db17537 600
mbed_official 376:cb4d9db17537 601 hirda->pRxBuffPtr = pData;
mbed_official 376:cb4d9db17537 602 hirda->RxXferSize = Size;
mbed_official 376:cb4d9db17537 603 hirda->RxXferCount = Size;
mbed_official 376:cb4d9db17537 604
mbed_official 376:cb4d9db17537 605 /* Computation of the mask to apply to the RDR register
mbed_official 376:cb4d9db17537 606 of the UART associated to the IRDA */
mbed_official 376:cb4d9db17537 607 __HAL_IRDA_MASK_COMPUTATION(hirda);
mbed_official 376:cb4d9db17537 608
mbed_official 376:cb4d9db17537 609 hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
mbed_official 376:cb4d9db17537 610 if(hirda->State == HAL_IRDA_STATE_BUSY_TX)
mbed_official 376:cb4d9db17537 611 {
mbed_official 376:cb4d9db17537 612 hirda->State = HAL_IRDA_STATE_BUSY_TX_RX;
mbed_official 376:cb4d9db17537 613 }
mbed_official 376:cb4d9db17537 614 else
mbed_official 376:cb4d9db17537 615 {
mbed_official 376:cb4d9db17537 616 hirda->State = HAL_IRDA_STATE_BUSY_RX;
mbed_official 376:cb4d9db17537 617 }
mbed_official 376:cb4d9db17537 618
mbed_official 376:cb4d9db17537 619 /* Enable the IRDA Parity Error Interrupt */
mbed_official 376:cb4d9db17537 620 __HAL_IRDA_ENABLE_IT(hirda, IRDA_IT_PE);
mbed_official 376:cb4d9db17537 621
mbed_official 376:cb4d9db17537 622 /* Enable the IRDA Error Interrupt: (Frame error, noise error, overrun error) */
mbed_official 376:cb4d9db17537 623 __HAL_IRDA_ENABLE_IT(hirda, IRDA_IT_ERR);
mbed_official 376:cb4d9db17537 624
mbed_official 376:cb4d9db17537 625 /* Process Unlocked */
mbed_official 376:cb4d9db17537 626 __HAL_UNLOCK(hirda);
mbed_official 376:cb4d9db17537 627
mbed_official 376:cb4d9db17537 628 /* Enable the IRDA Data Register not empty Interrupt */
mbed_official 376:cb4d9db17537 629 __HAL_IRDA_ENABLE_IT(hirda, IRDA_IT_RXNE);
mbed_official 376:cb4d9db17537 630
mbed_official 376:cb4d9db17537 631 return HAL_OK;
mbed_official 376:cb4d9db17537 632 }
mbed_official 376:cb4d9db17537 633 else
mbed_official 376:cb4d9db17537 634 {
mbed_official 376:cb4d9db17537 635 return HAL_BUSY;
mbed_official 376:cb4d9db17537 636 }
mbed_official 376:cb4d9db17537 637 }
mbed_official 376:cb4d9db17537 638
mbed_official 376:cb4d9db17537 639 /**
mbed_official 376:cb4d9db17537 640 * @brief Send an amount of data in DMA mode
mbed_official 376:cb4d9db17537 641 * @param hirda: IRDA handle
mbed_official 376:cb4d9db17537 642 * @param pData: pointer to data buffer
mbed_official 376:cb4d9db17537 643 * @param Size: amount of data to be sent
mbed_official 376:cb4d9db17537 644 * @retval HAL status
mbed_official 376:cb4d9db17537 645 */
mbed_official 376:cb4d9db17537 646 HAL_StatusTypeDef HAL_IRDA_Transmit_DMA(IRDA_HandleTypeDef *hirda, uint8_t *pData, uint16_t Size)
mbed_official 376:cb4d9db17537 647 {
mbed_official 376:cb4d9db17537 648 uint32_t *tmp;
mbed_official 376:cb4d9db17537 649
mbed_official 376:cb4d9db17537 650 if ((hirda->State == HAL_IRDA_STATE_READY) || (hirda->State == HAL_IRDA_STATE_BUSY_RX))
mbed_official 376:cb4d9db17537 651 {
mbed_official 387:643a59b3dbac 652 if((pData == HAL_NULL) || (Size == 0))
mbed_official 376:cb4d9db17537 653 {
mbed_official 376:cb4d9db17537 654 return HAL_ERROR;
mbed_official 376:cb4d9db17537 655 }
mbed_official 376:cb4d9db17537 656
mbed_official 376:cb4d9db17537 657 /* Process Locked */
mbed_official 376:cb4d9db17537 658 __HAL_LOCK(hirda);
mbed_official 376:cb4d9db17537 659
mbed_official 376:cb4d9db17537 660 hirda->pTxBuffPtr = pData;
mbed_official 376:cb4d9db17537 661 hirda->TxXferSize = Size;
mbed_official 376:cb4d9db17537 662 hirda->TxXferCount = Size;
mbed_official 376:cb4d9db17537 663
mbed_official 376:cb4d9db17537 664 hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
mbed_official 376:cb4d9db17537 665
mbed_official 376:cb4d9db17537 666 if(hirda->State == HAL_IRDA_STATE_BUSY_RX)
mbed_official 376:cb4d9db17537 667 {
mbed_official 376:cb4d9db17537 668 hirda->State = HAL_IRDA_STATE_BUSY_TX_RX;
mbed_official 376:cb4d9db17537 669 }
mbed_official 376:cb4d9db17537 670 else
mbed_official 376:cb4d9db17537 671 {
mbed_official 376:cb4d9db17537 672 hirda->State = HAL_IRDA_STATE_BUSY_TX;
mbed_official 376:cb4d9db17537 673 }
mbed_official 376:cb4d9db17537 674
mbed_official 376:cb4d9db17537 675 /* Set the IRDA DMA transfer complete callback */
mbed_official 376:cb4d9db17537 676 hirda->hdmatx->XferCpltCallback = IRDA_DMATransmitCplt;
mbed_official 376:cb4d9db17537 677
mbed_official 376:cb4d9db17537 678 /* Set the IRDA DMA half transfer complete callback */
mbed_official 376:cb4d9db17537 679 hirda->hdmatx->XferHalfCpltCallback = IRDA_DMATransmitHalfCplt;
mbed_official 376:cb4d9db17537 680
mbed_official 376:cb4d9db17537 681 /* Set the DMA error callback */
mbed_official 376:cb4d9db17537 682 hirda->hdmatx->XferErrorCallback = IRDA_DMAError;
mbed_official 376:cb4d9db17537 683
mbed_official 376:cb4d9db17537 684 /* Enable the IRDA transmit DMA channel */
mbed_official 376:cb4d9db17537 685 tmp = (uint32_t*)&pData;
mbed_official 376:cb4d9db17537 686 HAL_DMA_Start_IT(hirda->hdmatx, *(uint32_t*)tmp, (uint32_t)&hirda->Instance->TDR, Size);
mbed_official 376:cb4d9db17537 687
mbed_official 376:cb4d9db17537 688 /* Enable the DMA transfer for transmit request by setting the DMAT bit
mbed_official 376:cb4d9db17537 689 in the IRDA CR3 register */
mbed_official 376:cb4d9db17537 690 hirda->Instance->CR3 |= USART_CR3_DMAT;
mbed_official 376:cb4d9db17537 691
mbed_official 376:cb4d9db17537 692 /* Process Unlocked */
mbed_official 376:cb4d9db17537 693 __HAL_UNLOCK(hirda);
mbed_official 376:cb4d9db17537 694
mbed_official 376:cb4d9db17537 695 return HAL_OK;
mbed_official 376:cb4d9db17537 696 }
mbed_official 376:cb4d9db17537 697 else
mbed_official 376:cb4d9db17537 698 {
mbed_official 376:cb4d9db17537 699 return HAL_BUSY;
mbed_official 376:cb4d9db17537 700 }
mbed_official 376:cb4d9db17537 701 }
mbed_official 376:cb4d9db17537 702
mbed_official 376:cb4d9db17537 703 /**
mbed_official 376:cb4d9db17537 704 * @brief Receive an amount of data in DMA mode
mbed_official 376:cb4d9db17537 705 * @param hirda: IRDA handle
mbed_official 376:cb4d9db17537 706 * @param pData: pointer to data buffer
mbed_official 376:cb4d9db17537 707 * @param Size: amount of data to be received
mbed_official 376:cb4d9db17537 708 * @note When the IRDA parity is enabled (PCE = 1), the received data contain
mbed_official 376:cb4d9db17537 709 * the parity bit (MSB position)
mbed_official 376:cb4d9db17537 710 * @retval HAL status
mbed_official 376:cb4d9db17537 711 */
mbed_official 376:cb4d9db17537 712 HAL_StatusTypeDef HAL_IRDA_Receive_DMA(IRDA_HandleTypeDef *hirda, uint8_t *pData, uint16_t Size)
mbed_official 376:cb4d9db17537 713 {
mbed_official 376:cb4d9db17537 714 uint32_t *tmp;
mbed_official 376:cb4d9db17537 715
mbed_official 376:cb4d9db17537 716 if ((hirda->State == HAL_IRDA_STATE_READY) || (hirda->State == HAL_IRDA_STATE_BUSY_TX))
mbed_official 376:cb4d9db17537 717 {
mbed_official 387:643a59b3dbac 718 if((pData == HAL_NULL) || (Size == 0))
mbed_official 376:cb4d9db17537 719 {
mbed_official 376:cb4d9db17537 720 return HAL_ERROR;
mbed_official 376:cb4d9db17537 721 }
mbed_official 376:cb4d9db17537 722
mbed_official 376:cb4d9db17537 723 /* Process Locked */
mbed_official 376:cb4d9db17537 724 __HAL_LOCK(hirda);
mbed_official 376:cb4d9db17537 725
mbed_official 376:cb4d9db17537 726 hirda->pRxBuffPtr = pData;
mbed_official 376:cb4d9db17537 727 hirda->RxXferSize = Size;
mbed_official 376:cb4d9db17537 728
mbed_official 376:cb4d9db17537 729 hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
mbed_official 376:cb4d9db17537 730 if(hirda->State == HAL_IRDA_STATE_BUSY_TX)
mbed_official 376:cb4d9db17537 731 {
mbed_official 376:cb4d9db17537 732 hirda->State = HAL_IRDA_STATE_BUSY_TX_RX;
mbed_official 376:cb4d9db17537 733 }
mbed_official 376:cb4d9db17537 734 else
mbed_official 376:cb4d9db17537 735 {
mbed_official 376:cb4d9db17537 736 hirda->State = HAL_IRDA_STATE_BUSY_RX;
mbed_official 376:cb4d9db17537 737 }
mbed_official 376:cb4d9db17537 738
mbed_official 376:cb4d9db17537 739 /* Set the IRDA DMA transfer complete callback */
mbed_official 376:cb4d9db17537 740 hirda->hdmarx->XferCpltCallback = IRDA_DMAReceiveCplt;
mbed_official 376:cb4d9db17537 741
mbed_official 376:cb4d9db17537 742 /* Set the IRDA DMA half transfer complete callback */
mbed_official 376:cb4d9db17537 743 hirda->hdmarx->XferHalfCpltCallback = IRDA_DMAReceiveHalfCplt;
mbed_official 376:cb4d9db17537 744
mbed_official 376:cb4d9db17537 745 /* Set the DMA error callback */
mbed_official 376:cb4d9db17537 746 hirda->hdmarx->XferErrorCallback = IRDA_DMAError;
mbed_official 376:cb4d9db17537 747
mbed_official 376:cb4d9db17537 748 /* Enable the DMA channel */
mbed_official 376:cb4d9db17537 749 tmp = (uint32_t*)&pData;
mbed_official 376:cb4d9db17537 750 HAL_DMA_Start_IT(hirda->hdmarx, (uint32_t)&hirda->Instance->RDR, *(uint32_t*)tmp, Size);
mbed_official 376:cb4d9db17537 751
mbed_official 376:cb4d9db17537 752 /* Enable the DMA transfer for the receiver request by setting the DMAR bit
mbed_official 376:cb4d9db17537 753 in the IRDA CR3 register */
mbed_official 376:cb4d9db17537 754 hirda->Instance->CR3 |= USART_CR3_DMAR;
mbed_official 376:cb4d9db17537 755
mbed_official 376:cb4d9db17537 756 /* Process Unlocked */
mbed_official 376:cb4d9db17537 757 __HAL_UNLOCK(hirda);
mbed_official 376:cb4d9db17537 758
mbed_official 376:cb4d9db17537 759 return HAL_OK;
mbed_official 376:cb4d9db17537 760 }
mbed_official 376:cb4d9db17537 761 else
mbed_official 376:cb4d9db17537 762 {
mbed_official 376:cb4d9db17537 763 return HAL_BUSY;
mbed_official 376:cb4d9db17537 764 }
mbed_official 376:cb4d9db17537 765 }
mbed_official 376:cb4d9db17537 766
mbed_official 376:cb4d9db17537 767 /**
mbed_official 376:cb4d9db17537 768 * @brief Pauses the DMA Transfer.
mbed_official 376:cb4d9db17537 769 * @param hirda: pointer to a IRDA_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 770 * the configuration information for the specified IRDA module.
mbed_official 376:cb4d9db17537 771 * @retval HAL status
mbed_official 376:cb4d9db17537 772 */
mbed_official 376:cb4d9db17537 773 HAL_StatusTypeDef HAL_IRDA_DMAPause(IRDA_HandleTypeDef *hirda)
mbed_official 376:cb4d9db17537 774 {
mbed_official 376:cb4d9db17537 775 /* Process Locked */
mbed_official 376:cb4d9db17537 776 __HAL_LOCK(hirda);
mbed_official 376:cb4d9db17537 777
mbed_official 376:cb4d9db17537 778 if(hirda->State == HAL_IRDA_STATE_BUSY_TX)
mbed_official 376:cb4d9db17537 779 {
mbed_official 376:cb4d9db17537 780 /* Disable the UART DMA Tx request */
mbed_official 376:cb4d9db17537 781 hirda->Instance->CR3 &= (uint32_t)(~USART_CR3_DMAT);
mbed_official 376:cb4d9db17537 782 }
mbed_official 376:cb4d9db17537 783 else if(hirda->State == HAL_IRDA_STATE_BUSY_RX)
mbed_official 376:cb4d9db17537 784 {
mbed_official 376:cb4d9db17537 785 /* Disable the UART DMA Rx request */
mbed_official 376:cb4d9db17537 786 hirda->Instance->CR3 &= (uint32_t)(~USART_CR3_DMAR);
mbed_official 376:cb4d9db17537 787 }
mbed_official 376:cb4d9db17537 788 else if (hirda->State == HAL_IRDA_STATE_BUSY_TX_RX)
mbed_official 376:cb4d9db17537 789 {
mbed_official 376:cb4d9db17537 790 /* Disable the UART DMA Tx & Rx requests */
mbed_official 376:cb4d9db17537 791 hirda->Instance->CR3 &= (uint32_t)(~USART_CR3_DMAT);
mbed_official 376:cb4d9db17537 792 hirda->Instance->CR3 &= (uint32_t)(~USART_CR3_DMAR);
mbed_official 376:cb4d9db17537 793 }
mbed_official 376:cb4d9db17537 794
mbed_official 376:cb4d9db17537 795 /* Process Unlocked */
mbed_official 376:cb4d9db17537 796 __HAL_UNLOCK(hirda);
mbed_official 376:cb4d9db17537 797
mbed_official 376:cb4d9db17537 798 return HAL_OK;
mbed_official 376:cb4d9db17537 799 }
mbed_official 376:cb4d9db17537 800
mbed_official 376:cb4d9db17537 801 /**
mbed_official 376:cb4d9db17537 802 * @brief Resumes the DMA Transfer.
mbed_official 376:cb4d9db17537 803 * @param hirda: pointer to a IRDA_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 804 * the configuration information for the specified UART module.
mbed_official 376:cb4d9db17537 805 * @retval HAL status
mbed_official 376:cb4d9db17537 806 */
mbed_official 376:cb4d9db17537 807 HAL_StatusTypeDef HAL_IRDA_DMAResume(IRDA_HandleTypeDef *hirda)
mbed_official 376:cb4d9db17537 808 {
mbed_official 376:cb4d9db17537 809 /* Process Locked */
mbed_official 376:cb4d9db17537 810 __HAL_LOCK(hirda);
mbed_official 376:cb4d9db17537 811
mbed_official 376:cb4d9db17537 812 if(hirda->State == HAL_IRDA_STATE_BUSY_TX)
mbed_official 376:cb4d9db17537 813 {
mbed_official 376:cb4d9db17537 814 /* Enable the UART DMA Tx request */
mbed_official 376:cb4d9db17537 815 hirda->Instance->CR3 |= USART_CR3_DMAT;
mbed_official 376:cb4d9db17537 816 }
mbed_official 376:cb4d9db17537 817 else if(hirda->State == HAL_IRDA_STATE_BUSY_RX)
mbed_official 376:cb4d9db17537 818 {
mbed_official 376:cb4d9db17537 819 /* Clear the Overrun flag before resumming the Rx transfer*/
mbed_official 376:cb4d9db17537 820 __HAL_IRDA_CLEAR_IT(hirda, IRDA_CLEAR_OREF);
mbed_official 376:cb4d9db17537 821
mbed_official 376:cb4d9db17537 822 /* Enable the UART DMA Rx request */
mbed_official 376:cb4d9db17537 823 hirda->Instance->CR3 |= USART_CR3_DMAR;
mbed_official 376:cb4d9db17537 824 }
mbed_official 376:cb4d9db17537 825 else if(hirda->State == HAL_IRDA_STATE_BUSY_TX_RX)
mbed_official 376:cb4d9db17537 826 {
mbed_official 376:cb4d9db17537 827 /* Clear the Overrun flag before resumming the Rx transfer*/
mbed_official 376:cb4d9db17537 828 __HAL_IRDA_CLEAR_IT(hirda, IRDA_CLEAR_OREF);
mbed_official 376:cb4d9db17537 829
mbed_official 376:cb4d9db17537 830 /* Enable the UART DMA Tx & Rx request */
mbed_official 376:cb4d9db17537 831 hirda->Instance->CR3 |= USART_CR3_DMAT;
mbed_official 376:cb4d9db17537 832 hirda->Instance->CR3 |= USART_CR3_DMAR;
mbed_official 376:cb4d9db17537 833 }
mbed_official 376:cb4d9db17537 834
mbed_official 376:cb4d9db17537 835 /* Process Unlocked */
mbed_official 376:cb4d9db17537 836 __HAL_UNLOCK(hirda);
mbed_official 376:cb4d9db17537 837
mbed_official 376:cb4d9db17537 838 return HAL_OK;
mbed_official 376:cb4d9db17537 839 }
mbed_official 376:cb4d9db17537 840
mbed_official 376:cb4d9db17537 841 /**
mbed_official 376:cb4d9db17537 842 * @brief Stops the DMA Transfer.
mbed_official 376:cb4d9db17537 843 * @param hirda: pointer to a IRDA_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 844 * the configuration information for the specified UART module.
mbed_official 376:cb4d9db17537 845 * @retval HAL status
mbed_official 376:cb4d9db17537 846 */
mbed_official 376:cb4d9db17537 847 HAL_StatusTypeDef HAL_IRDA_DMAStop(IRDA_HandleTypeDef *hirda)
mbed_official 376:cb4d9db17537 848 {
mbed_official 376:cb4d9db17537 849 /* The Lock is not implemented on this API to allow the user application
mbed_official 376:cb4d9db17537 850 to call the HAL UART API under callbacks HAL_UART_TxCpltCallback() / HAL_UART_RxCpltCallback():
mbed_official 376:cb4d9db17537 851 when calling HAL_DMA_Abort() API the DMA TX/RX Transfer complete interrupt is generated
mbed_official 376:cb4d9db17537 852 and the correspond call back is executed HAL_UART_TxCpltCallback() / HAL_UART_RxCpltCallback()
mbed_official 376:cb4d9db17537 853 */
mbed_official 376:cb4d9db17537 854
mbed_official 376:cb4d9db17537 855 /* Disable the UART Tx/Rx DMA requests */
mbed_official 376:cb4d9db17537 856 hirda->Instance->CR3 &= ~USART_CR3_DMAT;
mbed_official 376:cb4d9db17537 857 hirda->Instance->CR3 &= ~USART_CR3_DMAR;
mbed_official 376:cb4d9db17537 858
mbed_official 376:cb4d9db17537 859 /* Abort the UART DMA tx channel */
mbed_official 387:643a59b3dbac 860 if(hirda->hdmatx != HAL_NULL)
mbed_official 376:cb4d9db17537 861 {
mbed_official 376:cb4d9db17537 862 HAL_DMA_Abort(hirda->hdmatx);
mbed_official 376:cb4d9db17537 863 }
mbed_official 376:cb4d9db17537 864 /* Abort the UART DMA rx channel */
mbed_official 387:643a59b3dbac 865 if(hirda->hdmarx != HAL_NULL)
mbed_official 376:cb4d9db17537 866 {
mbed_official 376:cb4d9db17537 867 HAL_DMA_Abort(hirda->hdmarx);
mbed_official 376:cb4d9db17537 868 }
mbed_official 376:cb4d9db17537 869
mbed_official 376:cb4d9db17537 870 hirda->State = HAL_IRDA_STATE_READY;
mbed_official 376:cb4d9db17537 871
mbed_official 376:cb4d9db17537 872 return HAL_OK;
mbed_official 376:cb4d9db17537 873 }
mbed_official 376:cb4d9db17537 874
mbed_official 376:cb4d9db17537 875 /**
mbed_official 376:cb4d9db17537 876 * @brief This function handles IRDA interrupt request.
mbed_official 376:cb4d9db17537 877 * @param hirda: IRDA handle
mbed_official 376:cb4d9db17537 878 * @retval None
mbed_official 376:cb4d9db17537 879 */
mbed_official 376:cb4d9db17537 880 void HAL_IRDA_IRQHandler(IRDA_HandleTypeDef *hirda)
mbed_official 376:cb4d9db17537 881 {
mbed_official 376:cb4d9db17537 882 /* IRDA parity error interrupt occurred -------------------------------------*/
mbed_official 376:cb4d9db17537 883 if((__HAL_IRDA_GET_IT(hirda, IRDA_IT_PE) != RESET) && (__HAL_IRDA_GET_IT_SOURCE(hirda, IRDA_IT_PE) != RESET))
mbed_official 376:cb4d9db17537 884 {
mbed_official 376:cb4d9db17537 885 __HAL_IRDA_CLEAR_IT(hirda, IRDA_CLEAR_PEF);
mbed_official 376:cb4d9db17537 886
mbed_official 376:cb4d9db17537 887 hirda->ErrorCode |= HAL_IRDA_ERROR_PE;
mbed_official 376:cb4d9db17537 888 /* Set the IRDA state ready to be able to start again the process */
mbed_official 376:cb4d9db17537 889 hirda->State = HAL_IRDA_STATE_READY;
mbed_official 376:cb4d9db17537 890 }
mbed_official 376:cb4d9db17537 891
mbed_official 376:cb4d9db17537 892 /* IRDA frame error interrupt occured --------------------------------------*/
mbed_official 376:cb4d9db17537 893 if((__HAL_IRDA_GET_IT(hirda, IRDA_IT_FE) != RESET) && (__HAL_IRDA_GET_IT_SOURCE(hirda, IRDA_IT_ERR) != RESET))
mbed_official 376:cb4d9db17537 894 {
mbed_official 376:cb4d9db17537 895 __HAL_IRDA_CLEAR_IT(hirda, IRDA_CLEAR_FEF);
mbed_official 376:cb4d9db17537 896
mbed_official 376:cb4d9db17537 897 hirda->ErrorCode |= HAL_IRDA_ERROR_FE;
mbed_official 376:cb4d9db17537 898 /* Set the IRDA state ready to be able to start again the process */
mbed_official 376:cb4d9db17537 899 hirda->State = HAL_IRDA_STATE_READY;
mbed_official 376:cb4d9db17537 900 }
mbed_official 376:cb4d9db17537 901
mbed_official 376:cb4d9db17537 902 /* IRDA noise error interrupt occured --------------------------------------*/
mbed_official 376:cb4d9db17537 903 if((__HAL_IRDA_GET_IT(hirda, IRDA_IT_NE) != RESET) && (__HAL_IRDA_GET_IT_SOURCE(hirda, IRDA_IT_ERR) != RESET))
mbed_official 376:cb4d9db17537 904 {
mbed_official 376:cb4d9db17537 905 __HAL_IRDA_CLEAR_IT(hirda, IRDA_CLEAR_NEF);
mbed_official 376:cb4d9db17537 906
mbed_official 376:cb4d9db17537 907 hirda->ErrorCode |= HAL_IRDA_ERROR_NE;
mbed_official 376:cb4d9db17537 908 /* Set the IRDA state ready to be able to start again the process */
mbed_official 376:cb4d9db17537 909 hirda->State = HAL_IRDA_STATE_READY;
mbed_official 376:cb4d9db17537 910 }
mbed_official 376:cb4d9db17537 911
mbed_official 376:cb4d9db17537 912 /* IRDA Over-Run interrupt occured -----------------------------------------*/
mbed_official 376:cb4d9db17537 913 if((__HAL_IRDA_GET_IT(hirda, IRDA_IT_ORE) != RESET) && (__HAL_IRDA_GET_IT_SOURCE(hirda, IRDA_IT_ERR) != RESET))
mbed_official 376:cb4d9db17537 914 {
mbed_official 376:cb4d9db17537 915 __HAL_IRDA_CLEAR_IT(hirda, IRDA_CLEAR_OREF);
mbed_official 376:cb4d9db17537 916
mbed_official 376:cb4d9db17537 917 hirda->ErrorCode |= HAL_IRDA_ERROR_ORE;
mbed_official 376:cb4d9db17537 918 /* Set the IRDA state ready to be able to start again the process */
mbed_official 376:cb4d9db17537 919 hirda->State = HAL_IRDA_STATE_READY;
mbed_official 376:cb4d9db17537 920 }
mbed_official 376:cb4d9db17537 921
mbed_official 376:cb4d9db17537 922 /* Call IRDA Error Call back function if need be --------------------------*/
mbed_official 376:cb4d9db17537 923 if(hirda->ErrorCode != HAL_IRDA_ERROR_NONE)
mbed_official 376:cb4d9db17537 924 {
mbed_official 376:cb4d9db17537 925 HAL_IRDA_ErrorCallback(hirda);
mbed_official 376:cb4d9db17537 926 }
mbed_official 376:cb4d9db17537 927
mbed_official 376:cb4d9db17537 928 /* IRDA in mode Receiver ---------------------------------------------------*/
mbed_official 376:cb4d9db17537 929 if((__HAL_IRDA_GET_IT(hirda, IRDA_IT_RXNE) != RESET) && (__HAL_IRDA_GET_IT_SOURCE(hirda, IRDA_IT_RXNE) != RESET))
mbed_official 376:cb4d9db17537 930 {
mbed_official 376:cb4d9db17537 931 IRDA_Receive_IT(hirda);
mbed_official 376:cb4d9db17537 932 /* Clear RXNE interrupt flag */
mbed_official 376:cb4d9db17537 933 __HAL_IRDA_SEND_REQ(hirda, IRDA_RXDATA_FLUSH_REQUEST);
mbed_official 376:cb4d9db17537 934 }
mbed_official 376:cb4d9db17537 935
mbed_official 376:cb4d9db17537 936 /* IRDA in mode Transmitter ------------------------------------------------*/
mbed_official 376:cb4d9db17537 937 if((__HAL_IRDA_GET_IT(hirda, IRDA_IT_TXE) != RESET) &&(__HAL_IRDA_GET_IT_SOURCE(hirda, IRDA_IT_TXE) != RESET))
mbed_official 376:cb4d9db17537 938 {
mbed_official 376:cb4d9db17537 939 IRDA_Transmit_IT(hirda);
mbed_official 376:cb4d9db17537 940 }
mbed_official 376:cb4d9db17537 941
mbed_official 376:cb4d9db17537 942 }
mbed_official 376:cb4d9db17537 943
mbed_official 376:cb4d9db17537 944 /**
mbed_official 376:cb4d9db17537 945 * @brief Tx Half Transfer completed callback
mbed_official 376:cb4d9db17537 946 * @param hirda: irda handle
mbed_official 376:cb4d9db17537 947 * @retval None
mbed_official 376:cb4d9db17537 948 */
mbed_official 376:cb4d9db17537 949 __weak void HAL_IRDA_TxHalfCpltCallback(IRDA_HandleTypeDef *hirda)
mbed_official 376:cb4d9db17537 950 {
mbed_official 376:cb4d9db17537 951 /* NOTE : This function should not be modified, when the callback is needed,
mbed_official 376:cb4d9db17537 952 the HAL_IRDA_TxHalfCpltCallback can be implemented in the user file
mbed_official 376:cb4d9db17537 953 */
mbed_official 376:cb4d9db17537 954 }
mbed_official 376:cb4d9db17537 955
mbed_official 376:cb4d9db17537 956 /**
mbed_official 376:cb4d9db17537 957 * @brief Tx Transfer completed callback
mbed_official 376:cb4d9db17537 958 * @param hirda: irda handle
mbed_official 376:cb4d9db17537 959 * @retval None
mbed_official 376:cb4d9db17537 960 */
mbed_official 376:cb4d9db17537 961 __weak void HAL_IRDA_TxCpltCallback(IRDA_HandleTypeDef *hirda)
mbed_official 376:cb4d9db17537 962 {
mbed_official 376:cb4d9db17537 963 /* NOTE : This function should not be modified, when the callback is needed,
mbed_official 376:cb4d9db17537 964 the HAL_IRDA_TxCpltCallback can be implemented in the user file
mbed_official 376:cb4d9db17537 965 */
mbed_official 376:cb4d9db17537 966 }
mbed_official 376:cb4d9db17537 967
mbed_official 376:cb4d9db17537 968 /**
mbed_official 376:cb4d9db17537 969 * @brief Rx Half Transfer completed callback
mbed_official 376:cb4d9db17537 970 * @param hirda: irda handle
mbed_official 376:cb4d9db17537 971 * @retval None
mbed_official 376:cb4d9db17537 972 */
mbed_official 376:cb4d9db17537 973 __weak void HAL_IRDA_RxHalfCpltCallback(IRDA_HandleTypeDef *hirda)
mbed_official 376:cb4d9db17537 974 {
mbed_official 376:cb4d9db17537 975 /* NOTE : This function should not be modified, when the callback is needed,
mbed_official 376:cb4d9db17537 976 the HAL_IRDA_RxHalfCpltCallback can be implemented in the user file
mbed_official 376:cb4d9db17537 977 */
mbed_official 376:cb4d9db17537 978 }
mbed_official 376:cb4d9db17537 979
mbed_official 376:cb4d9db17537 980 /**
mbed_official 376:cb4d9db17537 981 * @brief Rx Transfer completed callback
mbed_official 376:cb4d9db17537 982 * @param hirda: irda handle
mbed_official 376:cb4d9db17537 983 * @retval None
mbed_official 376:cb4d9db17537 984 */
mbed_official 376:cb4d9db17537 985 __weak void HAL_IRDA_RxCpltCallback(IRDA_HandleTypeDef *hirda)
mbed_official 376:cb4d9db17537 986 {
mbed_official 376:cb4d9db17537 987 /* NOTE : This function should not be modified, when the callback is needed,
mbed_official 376:cb4d9db17537 988 the HAL_IRDA_RxCpltCallback can be implemented in the user file
mbed_official 376:cb4d9db17537 989 */
mbed_official 376:cb4d9db17537 990 }
mbed_official 376:cb4d9db17537 991
mbed_official 376:cb4d9db17537 992 /**
mbed_official 376:cb4d9db17537 993 * @brief IRDA error callback
mbed_official 376:cb4d9db17537 994 * @param hirda: IRDA handle
mbed_official 376:cb4d9db17537 995 * @retval None
mbed_official 376:cb4d9db17537 996 */
mbed_official 376:cb4d9db17537 997 __weak void HAL_IRDA_ErrorCallback(IRDA_HandleTypeDef *hirda)
mbed_official 376:cb4d9db17537 998 {
mbed_official 376:cb4d9db17537 999 /* NOTE : This function should not be modified, when the callback is needed,
mbed_official 376:cb4d9db17537 1000 the HAL_IRDA_ErrorCallback can be implemented in the user file
mbed_official 376:cb4d9db17537 1001 */
mbed_official 376:cb4d9db17537 1002 }
mbed_official 376:cb4d9db17537 1003
mbed_official 376:cb4d9db17537 1004 /**
mbed_official 376:cb4d9db17537 1005 * @}
mbed_official 376:cb4d9db17537 1006 */
mbed_official 376:cb4d9db17537 1007
mbed_official 376:cb4d9db17537 1008 /** @defgroup IRDA_Group3 Peripheral Control functions
mbed_official 376:cb4d9db17537 1009 * @brief IRDA control functions
mbed_official 376:cb4d9db17537 1010 *
mbed_official 376:cb4d9db17537 1011 @verbatim
mbed_official 376:cb4d9db17537 1012 ===============================================================================
mbed_official 376:cb4d9db17537 1013 ##### Peripheral Control functions #####
mbed_official 376:cb4d9db17537 1014 ===============================================================================
mbed_official 376:cb4d9db17537 1015 [..]
mbed_official 376:cb4d9db17537 1016 This subsection provides a set of functions allowing to control the IRDA.
mbed_official 376:cb4d9db17537 1017 (+) HAL_IRDA_GetState() API can be helpful to check in run-time the state of the IRDA peripheral.
mbed_official 376:cb4d9db17537 1018 (+) IRDA_SetConfig() API is used to configure the IRDA communications parameters.
mbed_official 376:cb4d9db17537 1019 @endverbatim
mbed_official 376:cb4d9db17537 1020 * @{
mbed_official 376:cb4d9db17537 1021 */
mbed_official 376:cb4d9db17537 1022
mbed_official 376:cb4d9db17537 1023 /**
mbed_official 376:cb4d9db17537 1024 * @brief return the IRDA state
mbed_official 376:cb4d9db17537 1025 * @param hirda: irda handle
mbed_official 376:cb4d9db17537 1026 * @retval HAL state
mbed_official 376:cb4d9db17537 1027 */
mbed_official 376:cb4d9db17537 1028 HAL_IRDA_StateTypeDef HAL_IRDA_GetState(IRDA_HandleTypeDef *hirda)
mbed_official 376:cb4d9db17537 1029 {
mbed_official 376:cb4d9db17537 1030 return hirda->State;
mbed_official 376:cb4d9db17537 1031 }
mbed_official 376:cb4d9db17537 1032
mbed_official 376:cb4d9db17537 1033 /**
mbed_official 376:cb4d9db17537 1034 * @brief Return the IRDA error code
mbed_official 376:cb4d9db17537 1035 * @param hirda : pointer to a IRDA_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1036 * the configuration information for the specified IRDA.
mbed_official 376:cb4d9db17537 1037 * @retval IRDA Error Code
mbed_official 376:cb4d9db17537 1038 */
mbed_official 376:cb4d9db17537 1039 uint32_t HAL_IRDA_GetError(IRDA_HandleTypeDef *hirda)
mbed_official 376:cb4d9db17537 1040 {
mbed_official 376:cb4d9db17537 1041 return hirda->ErrorCode;
mbed_official 376:cb4d9db17537 1042 }
mbed_official 376:cb4d9db17537 1043
mbed_official 376:cb4d9db17537 1044 /**
mbed_official 376:cb4d9db17537 1045 * @}
mbed_official 376:cb4d9db17537 1046 */
mbed_official 376:cb4d9db17537 1047
mbed_official 376:cb4d9db17537 1048 /**
mbed_official 376:cb4d9db17537 1049 * @brief Configure the IRDA peripheral
mbed_official 376:cb4d9db17537 1050 * @param hirda: irda handle
mbed_official 376:cb4d9db17537 1051 * @retval None
mbed_official 376:cb4d9db17537 1052 */
mbed_official 376:cb4d9db17537 1053 static void IRDA_SetConfig(IRDA_HandleTypeDef *hirda)
mbed_official 376:cb4d9db17537 1054 {
mbed_official 376:cb4d9db17537 1055 uint32_t tmpreg = 0x00000000;
mbed_official 376:cb4d9db17537 1056 uint32_t clocksource = 0x00000000;
mbed_official 376:cb4d9db17537 1057
mbed_official 376:cb4d9db17537 1058 /* Check the communication parameters */
mbed_official 376:cb4d9db17537 1059 assert_param(IS_IRDA_BAUDRATE(hirda->Init.BaudRate));
mbed_official 376:cb4d9db17537 1060 assert_param(IS_IRDA_WORD_LENGTH(hirda->Init.WordLength));
mbed_official 376:cb4d9db17537 1061 assert_param(IS_IRDA_PARITY(hirda->Init.Parity));
mbed_official 376:cb4d9db17537 1062 assert_param(IS_IRDA_TX_RX_MODE(hirda->Init.Mode));
mbed_official 376:cb4d9db17537 1063 assert_param(IS_IRDA_PRESCALER(hirda->Init.Prescaler));
mbed_official 376:cb4d9db17537 1064 assert_param(IS_IRDA_POWERMODE(hirda->Init.PowerMode));
mbed_official 376:cb4d9db17537 1065 /*-------------------------- USART CR1 Configuration -----------------------*/
mbed_official 376:cb4d9db17537 1066 /* Configure the IRDA Word Length, Parity and transfer Mode:
mbed_official 376:cb4d9db17537 1067 Set the M bits according to hirda->Init.WordLength value
mbed_official 376:cb4d9db17537 1068 Set PCE and PS bits according to hirda->Init.Parity value
mbed_official 376:cb4d9db17537 1069 Set TE and RE bits according to hirda->Init.Mode value */
mbed_official 376:cb4d9db17537 1070 tmpreg = (uint32_t)hirda->Init.WordLength | hirda->Init.Parity | hirda->Init.Mode ;
mbed_official 376:cb4d9db17537 1071
mbed_official 376:cb4d9db17537 1072 MODIFY_REG(hirda->Instance->CR1, IRDA_CR1_FIELDS, tmpreg);
mbed_official 376:cb4d9db17537 1073
mbed_official 376:cb4d9db17537 1074 /*-------------------------- USART CR3 Configuration -----------------------*/
mbed_official 376:cb4d9db17537 1075 MODIFY_REG(hirda->Instance->CR3, USART_CR3_IRLP, hirda->Init.PowerMode);
mbed_official 376:cb4d9db17537 1076
mbed_official 376:cb4d9db17537 1077 /*-------------------------- USART GTPR Configuration ----------------------*/
mbed_official 376:cb4d9db17537 1078 MODIFY_REG(hirda->Instance->GTPR, (uint32_t)USART_GTPR_PSC, hirda->Init.Prescaler);
mbed_official 376:cb4d9db17537 1079
mbed_official 376:cb4d9db17537 1080 /*-------------------------- USART BRR Configuration -----------------------*/
mbed_official 376:cb4d9db17537 1081 __HAL_IRDA_GETCLOCKSOURCE(hirda, clocksource);
mbed_official 376:cb4d9db17537 1082 switch (clocksource)
mbed_official 376:cb4d9db17537 1083 {
mbed_official 376:cb4d9db17537 1084 case IRDA_CLOCKSOURCE_PCLK1:
mbed_official 376:cb4d9db17537 1085 hirda->Instance->BRR = (uint16_t)(HAL_RCC_GetPCLK1Freq() / hirda->Init.BaudRate);
mbed_official 376:cb4d9db17537 1086 break;
mbed_official 376:cb4d9db17537 1087 case IRDA_CLOCKSOURCE_PCLK2:
mbed_official 376:cb4d9db17537 1088 hirda->Instance->BRR = (uint16_t)(HAL_RCC_GetPCLK2Freq() / hirda->Init.BaudRate);
mbed_official 376:cb4d9db17537 1089 break;
mbed_official 376:cb4d9db17537 1090 case IRDA_CLOCKSOURCE_HSI:
mbed_official 376:cb4d9db17537 1091 hirda->Instance->BRR = (uint16_t)(HSI_VALUE / hirda->Init.BaudRate);
mbed_official 376:cb4d9db17537 1092 break;
mbed_official 376:cb4d9db17537 1093 case IRDA_CLOCKSOURCE_SYSCLK:
mbed_official 376:cb4d9db17537 1094 hirda->Instance->BRR = (uint16_t)(HAL_RCC_GetSysClockFreq() / hirda->Init.BaudRate);
mbed_official 376:cb4d9db17537 1095 break;
mbed_official 376:cb4d9db17537 1096 case IRDA_CLOCKSOURCE_LSE:
mbed_official 376:cb4d9db17537 1097 hirda->Instance->BRR = (uint16_t)(LSE_VALUE / hirda->Init.BaudRate);
mbed_official 376:cb4d9db17537 1098 break;
mbed_official 376:cb4d9db17537 1099 default:
mbed_official 376:cb4d9db17537 1100 break;
mbed_official 376:cb4d9db17537 1101 }
mbed_official 376:cb4d9db17537 1102 }
mbed_official 376:cb4d9db17537 1103
mbed_official 376:cb4d9db17537 1104 /**
mbed_official 376:cb4d9db17537 1105 * @brief Check the IRDA Idle State
mbed_official 376:cb4d9db17537 1106 * @param hirda: IRDA handle
mbed_official 376:cb4d9db17537 1107 * @retval HAL status
mbed_official 376:cb4d9db17537 1108 */
mbed_official 376:cb4d9db17537 1109 static HAL_StatusTypeDef IRDA_CheckIdleState(IRDA_HandleTypeDef *hirda)
mbed_official 376:cb4d9db17537 1110 {
mbed_official 376:cb4d9db17537 1111 /* Initialize the IRDA ErrorCode */
mbed_official 376:cb4d9db17537 1112 hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
mbed_official 376:cb4d9db17537 1113
mbed_official 376:cb4d9db17537 1114 /* Check if the Transmitter is enabled */
mbed_official 376:cb4d9db17537 1115 if((hirda->Instance->CR1 & USART_CR1_TE) == USART_CR1_TE)
mbed_official 376:cb4d9db17537 1116 {
mbed_official 376:cb4d9db17537 1117 /* Wait until TEACK flag is set */
mbed_official 376:cb4d9db17537 1118 if(IRDA_WaitOnFlagUntilTimeout(hirda, USART_ISR_TEACK, RESET, TEACK_REACK_TIMEOUT) != HAL_OK)
mbed_official 376:cb4d9db17537 1119 {
mbed_official 376:cb4d9db17537 1120 hirda->State= HAL_IRDA_STATE_TIMEOUT;
mbed_official 376:cb4d9db17537 1121 return HAL_TIMEOUT;
mbed_official 376:cb4d9db17537 1122 }
mbed_official 376:cb4d9db17537 1123 }
mbed_official 376:cb4d9db17537 1124 /* Check if the Receiver is enabled */
mbed_official 376:cb4d9db17537 1125 if((hirda->Instance->CR1 & USART_CR1_RE) == USART_CR1_RE)
mbed_official 376:cb4d9db17537 1126 {
mbed_official 376:cb4d9db17537 1127 if(IRDA_WaitOnFlagUntilTimeout(hirda, USART_ISR_REACK, RESET, TEACK_REACK_TIMEOUT) != HAL_OK)
mbed_official 376:cb4d9db17537 1128 {
mbed_official 376:cb4d9db17537 1129 hirda->State= HAL_IRDA_STATE_TIMEOUT;
mbed_official 376:cb4d9db17537 1130 return HAL_TIMEOUT;
mbed_official 376:cb4d9db17537 1131 }
mbed_official 376:cb4d9db17537 1132 }
mbed_official 376:cb4d9db17537 1133 /* Process Unlocked */
mbed_official 376:cb4d9db17537 1134 __HAL_UNLOCK(hirda);
mbed_official 376:cb4d9db17537 1135
mbed_official 376:cb4d9db17537 1136 /* Initialize the IRDA state*/
mbed_official 376:cb4d9db17537 1137 hirda->State= HAL_IRDA_STATE_READY;
mbed_official 376:cb4d9db17537 1138
mbed_official 376:cb4d9db17537 1139 return HAL_OK;
mbed_official 376:cb4d9db17537 1140 }
mbed_official 376:cb4d9db17537 1141
mbed_official 376:cb4d9db17537 1142 /**
mbed_official 376:cb4d9db17537 1143 * @brief Handle IRDA Communication Timeout.
mbed_official 376:cb4d9db17537 1144 * @param hirda: IRDA handle
mbed_official 376:cb4d9db17537 1145 * @param Flag: specifies the IRDA flag to check.
mbed_official 376:cb4d9db17537 1146 * @param Status: the flag status (SET or RESET). The function is locked in a while loop as long as the flag remains set to Status.
mbed_official 376:cb4d9db17537 1147 * @param Timeout: Timeout duration
mbed_official 376:cb4d9db17537 1148 * @retval HAL status
mbed_official 376:cb4d9db17537 1149 */
mbed_official 376:cb4d9db17537 1150 static HAL_StatusTypeDef IRDA_WaitOnFlagUntilTimeout(IRDA_HandleTypeDef *hirda, uint32_t Flag, FlagStatus Status, uint32_t Timeout)
mbed_official 376:cb4d9db17537 1151 {
mbed_official 376:cb4d9db17537 1152 uint32_t tickstart = 0x00;
mbed_official 376:cb4d9db17537 1153 tickstart = HAL_GetTick();
mbed_official 376:cb4d9db17537 1154
mbed_official 376:cb4d9db17537 1155 /* Wait until flag is set */
mbed_official 376:cb4d9db17537 1156 if(Status == RESET)
mbed_official 376:cb4d9db17537 1157 {
mbed_official 376:cb4d9db17537 1158 while(__HAL_IRDA_GET_FLAG(hirda, Flag) == RESET)
mbed_official 376:cb4d9db17537 1159 {
mbed_official 376:cb4d9db17537 1160 /* Check for the Timeout */
mbed_official 376:cb4d9db17537 1161 if(Timeout != HAL_MAX_DELAY)
mbed_official 376:cb4d9db17537 1162 {
mbed_official 376:cb4d9db17537 1163 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 376:cb4d9db17537 1164 {
mbed_official 376:cb4d9db17537 1165 /* Disable TXE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts for the interrupt process */
mbed_official 376:cb4d9db17537 1166 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_TXE);
mbed_official 376:cb4d9db17537 1167 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_RXNE);
mbed_official 376:cb4d9db17537 1168 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_PE);
mbed_official 376:cb4d9db17537 1169 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_ERR);
mbed_official 376:cb4d9db17537 1170
mbed_official 376:cb4d9db17537 1171 hirda->State= HAL_IRDA_STATE_TIMEOUT;
mbed_official 376:cb4d9db17537 1172
mbed_official 376:cb4d9db17537 1173 /* Process Unlocked */
mbed_official 376:cb4d9db17537 1174 __HAL_UNLOCK(hirda);
mbed_official 376:cb4d9db17537 1175
mbed_official 376:cb4d9db17537 1176 return HAL_TIMEOUT;
mbed_official 376:cb4d9db17537 1177 }
mbed_official 376:cb4d9db17537 1178 }
mbed_official 376:cb4d9db17537 1179 }
mbed_official 376:cb4d9db17537 1180 }
mbed_official 376:cb4d9db17537 1181 else
mbed_official 376:cb4d9db17537 1182 {
mbed_official 376:cb4d9db17537 1183 while(__HAL_IRDA_GET_FLAG(hirda, Flag) != RESET)
mbed_official 376:cb4d9db17537 1184 {
mbed_official 376:cb4d9db17537 1185 /* Check for the Timeout */
mbed_official 376:cb4d9db17537 1186 if(Timeout != HAL_MAX_DELAY)
mbed_official 376:cb4d9db17537 1187 {
mbed_official 376:cb4d9db17537 1188 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 376:cb4d9db17537 1189 {
mbed_official 376:cb4d9db17537 1190 /* Disable TXE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts for the interrupt process */
mbed_official 376:cb4d9db17537 1191 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_TXE);
mbed_official 376:cb4d9db17537 1192 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_RXNE);
mbed_official 376:cb4d9db17537 1193 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_PE);
mbed_official 376:cb4d9db17537 1194 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_ERR);
mbed_official 376:cb4d9db17537 1195
mbed_official 376:cb4d9db17537 1196 hirda->State= HAL_IRDA_STATE_TIMEOUT;
mbed_official 376:cb4d9db17537 1197
mbed_official 376:cb4d9db17537 1198 /* Process Unlocked */
mbed_official 376:cb4d9db17537 1199 __HAL_UNLOCK(hirda);
mbed_official 376:cb4d9db17537 1200
mbed_official 376:cb4d9db17537 1201 return HAL_TIMEOUT;
mbed_official 376:cb4d9db17537 1202 }
mbed_official 376:cb4d9db17537 1203 }
mbed_official 376:cb4d9db17537 1204 }
mbed_official 376:cb4d9db17537 1205 }
mbed_official 376:cb4d9db17537 1206 return HAL_OK;
mbed_official 376:cb4d9db17537 1207 }
mbed_official 376:cb4d9db17537 1208
mbed_official 376:cb4d9db17537 1209 /**
mbed_official 376:cb4d9db17537 1210 * @brief Receive an amount of data in non blocking mode.
mbed_official 376:cb4d9db17537 1211 * Function called under interruption only, once
mbed_official 376:cb4d9db17537 1212 * interruptions have been enabled by HAL_IRDA_Transmit_IT()
mbed_official 376:cb4d9db17537 1213 * @param hirda: IRDA handle
mbed_official 376:cb4d9db17537 1214 * @retval HAL status
mbed_official 376:cb4d9db17537 1215 */
mbed_official 376:cb4d9db17537 1216 static HAL_StatusTypeDef IRDA_Transmit_IT(IRDA_HandleTypeDef *hirda)
mbed_official 376:cb4d9db17537 1217 {
mbed_official 376:cb4d9db17537 1218 uint16_t* tmp;
mbed_official 376:cb4d9db17537 1219
mbed_official 376:cb4d9db17537 1220 if((hirda->State == HAL_IRDA_STATE_BUSY_TX) || (hirda->State == HAL_IRDA_STATE_BUSY_TX_RX))
mbed_official 376:cb4d9db17537 1221 {
mbed_official 376:cb4d9db17537 1222 if(hirda->TxXferCount == 0)
mbed_official 376:cb4d9db17537 1223 {
mbed_official 376:cb4d9db17537 1224 /* Disable the IRDA Transmit Complete Interrupt */
mbed_official 376:cb4d9db17537 1225 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_TXE);
mbed_official 376:cb4d9db17537 1226
mbed_official 376:cb4d9db17537 1227 if(hirda->State == HAL_IRDA_STATE_BUSY_TX_RX)
mbed_official 376:cb4d9db17537 1228 {
mbed_official 376:cb4d9db17537 1229 hirda->State = HAL_IRDA_STATE_BUSY_RX;
mbed_official 376:cb4d9db17537 1230 }
mbed_official 376:cb4d9db17537 1231 else
mbed_official 376:cb4d9db17537 1232 {
mbed_official 376:cb4d9db17537 1233 /* Disable the IRDA Error Interrupt: (Frame error, noise error, overrun error) */
mbed_official 376:cb4d9db17537 1234 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_ERR);
mbed_official 376:cb4d9db17537 1235
mbed_official 376:cb4d9db17537 1236 hirda->State = HAL_IRDA_STATE_READY;
mbed_official 376:cb4d9db17537 1237 }
mbed_official 376:cb4d9db17537 1238
mbed_official 376:cb4d9db17537 1239 HAL_IRDA_TxCpltCallback(hirda);
mbed_official 376:cb4d9db17537 1240
mbed_official 376:cb4d9db17537 1241 return HAL_OK;
mbed_official 376:cb4d9db17537 1242 }
mbed_official 376:cb4d9db17537 1243 else
mbed_official 376:cb4d9db17537 1244 {
mbed_official 376:cb4d9db17537 1245 if ((hirda->Init.WordLength == IRDA_WORDLENGTH_9B) && (hirda->Init.Parity == IRDA_PARITY_NONE))
mbed_official 376:cb4d9db17537 1246 {
mbed_official 376:cb4d9db17537 1247 tmp = (uint16_t*) hirda->pTxBuffPtr;
mbed_official 376:cb4d9db17537 1248 hirda->Instance->TDR = (*tmp & (uint16_t)0x01FF);
mbed_official 376:cb4d9db17537 1249 hirda->pTxBuffPtr += 2;
mbed_official 376:cb4d9db17537 1250 }
mbed_official 376:cb4d9db17537 1251 else
mbed_official 376:cb4d9db17537 1252 {
mbed_official 376:cb4d9db17537 1253 hirda->Instance->TDR = (uint8_t)(*hirda->pTxBuffPtr++ & (uint8_t)0xFF);
mbed_official 376:cb4d9db17537 1254 }
mbed_official 376:cb4d9db17537 1255 hirda->TxXferCount--;
mbed_official 376:cb4d9db17537 1256 return HAL_OK;
mbed_official 376:cb4d9db17537 1257 }
mbed_official 376:cb4d9db17537 1258 }
mbed_official 376:cb4d9db17537 1259 else
mbed_official 376:cb4d9db17537 1260 {
mbed_official 376:cb4d9db17537 1261 return HAL_BUSY;
mbed_official 376:cb4d9db17537 1262 }
mbed_official 376:cb4d9db17537 1263 }
mbed_official 376:cb4d9db17537 1264
mbed_official 376:cb4d9db17537 1265 /**
mbed_official 376:cb4d9db17537 1266 * @brief Receive an amount of data in non blocking mode.
mbed_official 376:cb4d9db17537 1267 * Function called under interruption only, once
mbed_official 376:cb4d9db17537 1268 * interruptions have been enabled by HAL_IRDA_Receive_IT()
mbed_official 376:cb4d9db17537 1269 * @param hirda: IRDA handle
mbed_official 376:cb4d9db17537 1270 * @retval HAL status
mbed_official 376:cb4d9db17537 1271 */
mbed_official 376:cb4d9db17537 1272 static HAL_StatusTypeDef IRDA_Receive_IT(IRDA_HandleTypeDef *hirda)
mbed_official 376:cb4d9db17537 1273 {
mbed_official 376:cb4d9db17537 1274 uint16_t* tmp;
mbed_official 376:cb4d9db17537 1275 uint16_t uhMask = hirda->Mask;
mbed_official 376:cb4d9db17537 1276
mbed_official 376:cb4d9db17537 1277 if ((hirda->State == HAL_IRDA_STATE_BUSY_RX) || (hirda->State == HAL_IRDA_STATE_BUSY_TX_RX))
mbed_official 376:cb4d9db17537 1278 {
mbed_official 376:cb4d9db17537 1279 if ((hirda->Init.WordLength == IRDA_WORDLENGTH_9B) && (hirda->Init.Parity == IRDA_PARITY_NONE))
mbed_official 376:cb4d9db17537 1280 {
mbed_official 376:cb4d9db17537 1281 tmp = (uint16_t*) hirda->pRxBuffPtr ;
mbed_official 376:cb4d9db17537 1282 *tmp = (uint16_t)(hirda->Instance->RDR & uhMask);
mbed_official 376:cb4d9db17537 1283 hirda->pRxBuffPtr +=2;
mbed_official 376:cb4d9db17537 1284 }
mbed_official 376:cb4d9db17537 1285 else
mbed_official 376:cb4d9db17537 1286 {
mbed_official 376:cb4d9db17537 1287 *hirda->pRxBuffPtr++ = (uint8_t)(hirda->Instance->RDR & (uint8_t)uhMask);
mbed_official 376:cb4d9db17537 1288 }
mbed_official 376:cb4d9db17537 1289
mbed_official 376:cb4d9db17537 1290 if(--hirda->RxXferCount == 0)
mbed_official 376:cb4d9db17537 1291 {
mbed_official 376:cb4d9db17537 1292 while(HAL_IS_BIT_SET(hirda->Instance->ISR, IRDA_FLAG_RXNE))
mbed_official 376:cb4d9db17537 1293 {
mbed_official 376:cb4d9db17537 1294 }
mbed_official 376:cb4d9db17537 1295 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_RXNE);
mbed_official 376:cb4d9db17537 1296
mbed_official 376:cb4d9db17537 1297 if(hirda->State == HAL_IRDA_STATE_BUSY_TX_RX)
mbed_official 376:cb4d9db17537 1298 {
mbed_official 376:cb4d9db17537 1299 hirda->State = HAL_IRDA_STATE_BUSY_TX;
mbed_official 376:cb4d9db17537 1300 }
mbed_official 376:cb4d9db17537 1301 else
mbed_official 376:cb4d9db17537 1302 {
mbed_official 376:cb4d9db17537 1303 /* Disable the IRDA Parity Error Interrupt */
mbed_official 376:cb4d9db17537 1304 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_PE);
mbed_official 376:cb4d9db17537 1305
mbed_official 376:cb4d9db17537 1306 /* Disable the IRDA Error Interrupt: (Frame error, noise error, overrun error) */
mbed_official 376:cb4d9db17537 1307 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_ERR);
mbed_official 376:cb4d9db17537 1308
mbed_official 376:cb4d9db17537 1309 hirda->State = HAL_IRDA_STATE_READY;
mbed_official 376:cb4d9db17537 1310 }
mbed_official 376:cb4d9db17537 1311
mbed_official 376:cb4d9db17537 1312 HAL_IRDA_RxCpltCallback(hirda);
mbed_official 376:cb4d9db17537 1313
mbed_official 376:cb4d9db17537 1314 return HAL_OK;
mbed_official 376:cb4d9db17537 1315 }
mbed_official 376:cb4d9db17537 1316
mbed_official 376:cb4d9db17537 1317 return HAL_OK;
mbed_official 376:cb4d9db17537 1318 }
mbed_official 376:cb4d9db17537 1319 else
mbed_official 376:cb4d9db17537 1320 {
mbed_official 376:cb4d9db17537 1321 return HAL_BUSY;
mbed_official 376:cb4d9db17537 1322 }
mbed_official 376:cb4d9db17537 1323 }
mbed_official 376:cb4d9db17537 1324
mbed_official 376:cb4d9db17537 1325 /**
mbed_official 376:cb4d9db17537 1326 * @brief DMA IRDA Tx transfer completed callback
mbed_official 376:cb4d9db17537 1327 * @param hdma: DMA handle
mbed_official 376:cb4d9db17537 1328 * @retval None
mbed_official 376:cb4d9db17537 1329 */
mbed_official 376:cb4d9db17537 1330 static void IRDA_DMATransmitCplt(DMA_HandleTypeDef *hdma)
mbed_official 376:cb4d9db17537 1331 {
mbed_official 376:cb4d9db17537 1332 IRDA_HandleTypeDef* hirda = ( IRDA_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official 376:cb4d9db17537 1333
mbed_official 376:cb4d9db17537 1334 /* DMA Normal mode */
mbed_official 376:cb4d9db17537 1335 if((hdma->Instance->CCR & DMA_CCR_CIRC) == 0)
mbed_official 376:cb4d9db17537 1336 {
mbed_official 376:cb4d9db17537 1337 hirda->TxXferCount = 0;
mbed_official 376:cb4d9db17537 1338
mbed_official 376:cb4d9db17537 1339 /* Disable the DMA transfer for transmit request by setting the DMAT bit
mbed_official 376:cb4d9db17537 1340 in the IRDA CR3 register */
mbed_official 376:cb4d9db17537 1341 hirda->Instance->CR3 &= (uint16_t)~((uint16_t)USART_CR3_DMAT);
mbed_official 376:cb4d9db17537 1342
mbed_official 376:cb4d9db17537 1343 /* Wait for IRDA TC Flag */
mbed_official 376:cb4d9db17537 1344 if(IRDA_WaitOnFlagUntilTimeout(hirda, IRDA_FLAG_TC, RESET, HAL_IRDA_TXDMA_TIMEOUTVALUE) != HAL_OK)
mbed_official 376:cb4d9db17537 1345 {
mbed_official 376:cb4d9db17537 1346 /* Timeout Occured */
mbed_official 376:cb4d9db17537 1347 hirda->State = HAL_IRDA_STATE_TIMEOUT;
mbed_official 376:cb4d9db17537 1348 HAL_IRDA_ErrorCallback(hirda);
mbed_official 376:cb4d9db17537 1349 }
mbed_official 376:cb4d9db17537 1350 else
mbed_official 376:cb4d9db17537 1351 {
mbed_official 376:cb4d9db17537 1352 /* No Timeout */
mbed_official 376:cb4d9db17537 1353
mbed_official 376:cb4d9db17537 1354 if(hirda->State == HAL_IRDA_STATE_BUSY_TX_RX)
mbed_official 376:cb4d9db17537 1355 {
mbed_official 376:cb4d9db17537 1356 hirda->State = HAL_IRDA_STATE_BUSY_RX;
mbed_official 376:cb4d9db17537 1357 }
mbed_official 376:cb4d9db17537 1358 else
mbed_official 376:cb4d9db17537 1359 {
mbed_official 376:cb4d9db17537 1360 hirda->State = HAL_IRDA_STATE_READY;
mbed_official 376:cb4d9db17537 1361 }
mbed_official 376:cb4d9db17537 1362 HAL_IRDA_TxCpltCallback(hirda);
mbed_official 376:cb4d9db17537 1363 }
mbed_official 376:cb4d9db17537 1364 }
mbed_official 376:cb4d9db17537 1365 /* DMA Circular mode */
mbed_official 376:cb4d9db17537 1366 else
mbed_official 376:cb4d9db17537 1367 {
mbed_official 376:cb4d9db17537 1368 HAL_IRDA_TxCpltCallback(hirda);
mbed_official 376:cb4d9db17537 1369 }
mbed_official 376:cb4d9db17537 1370 }
mbed_official 376:cb4d9db17537 1371
mbed_official 376:cb4d9db17537 1372 /**
mbed_official 376:cb4d9db17537 1373 * @brief DMA IRDA receive process half complete callback
mbed_official 376:cb4d9db17537 1374 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1375 * the configuration information for the specified DMA module.
mbed_official 376:cb4d9db17537 1376 * @retval None
mbed_official 376:cb4d9db17537 1377 */
mbed_official 376:cb4d9db17537 1378 static void IRDA_DMATransmitHalfCplt(DMA_HandleTypeDef *hdma)
mbed_official 376:cb4d9db17537 1379 {
mbed_official 376:cb4d9db17537 1380 IRDA_HandleTypeDef* hirda = ( IRDA_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official 376:cb4d9db17537 1381
mbed_official 376:cb4d9db17537 1382 HAL_IRDA_TxHalfCpltCallback(hirda);
mbed_official 376:cb4d9db17537 1383 }
mbed_official 376:cb4d9db17537 1384
mbed_official 376:cb4d9db17537 1385 /**
mbed_official 376:cb4d9db17537 1386 * @brief DMA IRDA Rx Transfer completed callback
mbed_official 376:cb4d9db17537 1387 * @param hdma: DMA handle
mbed_official 376:cb4d9db17537 1388 * @retval None
mbed_official 376:cb4d9db17537 1389 */
mbed_official 376:cb4d9db17537 1390 static void IRDA_DMAReceiveCplt(DMA_HandleTypeDef *hdma)
mbed_official 376:cb4d9db17537 1391 {
mbed_official 376:cb4d9db17537 1392 IRDA_HandleTypeDef* hirda = ( IRDA_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official 376:cb4d9db17537 1393 /* DMA Normal mode */
mbed_official 376:cb4d9db17537 1394 if((hdma->Instance->CCR & DMA_CCR_CIRC) == 0)
mbed_official 376:cb4d9db17537 1395 {
mbed_official 376:cb4d9db17537 1396 hirda->RxXferCount = 0;
mbed_official 376:cb4d9db17537 1397
mbed_official 376:cb4d9db17537 1398 /* Disable the DMA transfer for the receiver request by setting the DMAR bit
mbed_official 376:cb4d9db17537 1399 in the IRDA CR3 register */
mbed_official 376:cb4d9db17537 1400 hirda->Instance->CR3 &= (uint16_t)~((uint16_t)USART_CR3_DMAR);
mbed_official 376:cb4d9db17537 1401
mbed_official 376:cb4d9db17537 1402 if(hirda->State == HAL_IRDA_STATE_BUSY_TX_RX)
mbed_official 376:cb4d9db17537 1403 {
mbed_official 376:cb4d9db17537 1404 hirda->State = HAL_IRDA_STATE_BUSY_TX;
mbed_official 376:cb4d9db17537 1405 }
mbed_official 376:cb4d9db17537 1406 else
mbed_official 376:cb4d9db17537 1407 {
mbed_official 376:cb4d9db17537 1408 hirda->State = HAL_IRDA_STATE_READY;
mbed_official 376:cb4d9db17537 1409 }
mbed_official 376:cb4d9db17537 1410 }
mbed_official 376:cb4d9db17537 1411
mbed_official 376:cb4d9db17537 1412 HAL_IRDA_RxCpltCallback(hirda);
mbed_official 376:cb4d9db17537 1413 }
mbed_official 376:cb4d9db17537 1414
mbed_official 376:cb4d9db17537 1415 /**
mbed_official 376:cb4d9db17537 1416 * @brief DMA IRDA receive process half complete callback
mbed_official 376:cb4d9db17537 1417 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1418 * the configuration information for the specified DMA module.
mbed_official 376:cb4d9db17537 1419 * @retval None
mbed_official 376:cb4d9db17537 1420 */
mbed_official 376:cb4d9db17537 1421 static void IRDA_DMAReceiveHalfCplt(DMA_HandleTypeDef *hdma)
mbed_official 376:cb4d9db17537 1422 {
mbed_official 376:cb4d9db17537 1423 IRDA_HandleTypeDef* hirda = ( IRDA_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official 376:cb4d9db17537 1424
mbed_official 376:cb4d9db17537 1425 HAL_IRDA_RxHalfCpltCallback(hirda);
mbed_official 376:cb4d9db17537 1426 }
mbed_official 376:cb4d9db17537 1427
mbed_official 376:cb4d9db17537 1428 /**
mbed_official 376:cb4d9db17537 1429 * @brief DMA IRDA communication error callback
mbed_official 376:cb4d9db17537 1430 * @param hdma: DMA handle
mbed_official 376:cb4d9db17537 1431 * @retval None
mbed_official 376:cb4d9db17537 1432 */
mbed_official 376:cb4d9db17537 1433 static void IRDA_DMAError(DMA_HandleTypeDef *hdma)
mbed_official 376:cb4d9db17537 1434 {
mbed_official 376:cb4d9db17537 1435 IRDA_HandleTypeDef* hirda = ( IRDA_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official 376:cb4d9db17537 1436 hirda->RxXferCount = 0;
mbed_official 376:cb4d9db17537 1437 hirda->TxXferCount = 0;
mbed_official 376:cb4d9db17537 1438 hirda->State= HAL_IRDA_STATE_READY;
mbed_official 376:cb4d9db17537 1439 hirda->ErrorCode |= HAL_IRDA_ERROR_DMA;
mbed_official 376:cb4d9db17537 1440 HAL_IRDA_ErrorCallback(hirda);
mbed_official 376:cb4d9db17537 1441 }
mbed_official 376:cb4d9db17537 1442
mbed_official 376:cb4d9db17537 1443 /**
mbed_official 376:cb4d9db17537 1444 * @}
mbed_official 376:cb4d9db17537 1445 */
mbed_official 376:cb4d9db17537 1446
mbed_official 376:cb4d9db17537 1447 #endif /* HAL_IRDA_MODULE_ENABLED */
mbed_official 376:cb4d9db17537 1448 /**
mbed_official 376:cb4d9db17537 1449 * @}
mbed_official 376:cb4d9db17537 1450 */
mbed_official 376:cb4d9db17537 1451
mbed_official 376:cb4d9db17537 1452 /**
mbed_official 376:cb4d9db17537 1453 * @}
mbed_official 376:cb4d9db17537 1454 */
mbed_official 376:cb4d9db17537 1455
mbed_official 376:cb4d9db17537 1456 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/