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@579:53297373a894, 2015-07-01 (annotated)

Committer:
mbed_official
Date:
Wed Jul 01 09:45:11 2015 +0100
Revision:
579:53297373a894
Parent:
489:119543c9f674 
Synchronized with git revision d5b4d2ab9c47edb4dc5776e7177b0c2263459081



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



Initial version of drivers for SAMR21

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 489:119543c9f674 5 * @version V1.2.0
mbed_official 489:119543c9f674 6 * @date 06-February-2015
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 489:119543c9f674 104 * <h2><center>&copy; COPYRIGHT(c) 2015 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 489:119543c9f674 138 /** @addtogroup 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 489:119543c9f674 162 static HAL_StatusTypeDef IRDA_EndTransmit_IT(IRDA_HandleTypeDef *hirda);
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 489:119543c9f674 166 /** @addtogroup IRDA_Exported_Functions
mbed_official 376:cb4d9db17537 167 * @{
mbed_official 376:cb4d9db17537 168 */
mbed_official 376:cb4d9db17537 169
mbed_official 489:119543c9f674 170 /** @addtogroup IRDA_Exported_Functions_Group1
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 489:119543c9f674 225 if(hirda == 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 489:119543c9f674 271 if(hirda == 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 489:119543c9f674 323 /** @addtogroup IRDA_Exported_Functions_Group2
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 489:119543c9f674 385 if((pData == 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 489:119543c9f674 465 if((pData == 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 489:119543c9f674 488 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 489:119543c9f674 543 if((pData == 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 489:119543c9f674 571 /* Enable the IRDA Transmit Data Register Empty Interrupt */
mbed_official 489:119543c9f674 572 __HAL_IRDA_ENABLE_IT(hirda, IRDA_IT_TXE);
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 489:119543c9f674 593 if((pData == 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 489:119543c9f674 607 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 489:119543c9f674 652 if((pData == 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 489:119543c9f674 688 /* Clear the TC flag in the SR register by writing 0 to it */
mbed_official 489:119543c9f674 689 __HAL_IRDA_CLEAR_FLAG(hirda, IRDA_FLAG_TC);
mbed_official 489:119543c9f674 690
mbed_official 376:cb4d9db17537 691 /* Enable the DMA transfer for transmit request by setting the DMAT bit
mbed_official 376:cb4d9db17537 692 in the IRDA CR3 register */
mbed_official 376:cb4d9db17537 693 hirda->Instance->CR3 |= USART_CR3_DMAT;
mbed_official 376:cb4d9db17537 694
mbed_official 376:cb4d9db17537 695 /* Process Unlocked */
mbed_official 376:cb4d9db17537 696 __HAL_UNLOCK(hirda);
mbed_official 376:cb4d9db17537 697
mbed_official 376:cb4d9db17537 698 return HAL_OK;
mbed_official 376:cb4d9db17537 699 }
mbed_official 376:cb4d9db17537 700 else
mbed_official 376:cb4d9db17537 701 {
mbed_official 376:cb4d9db17537 702 return HAL_BUSY;
mbed_official 376:cb4d9db17537 703 }
mbed_official 376:cb4d9db17537 704 }
mbed_official 376:cb4d9db17537 705
mbed_official 376:cb4d9db17537 706 /**
mbed_official 376:cb4d9db17537 707 * @brief Receive an amount of data in DMA mode
mbed_official 376:cb4d9db17537 708 * @param hirda: IRDA handle
mbed_official 376:cb4d9db17537 709 * @param pData: pointer to data buffer
mbed_official 376:cb4d9db17537 710 * @param Size: amount of data to be received
mbed_official 376:cb4d9db17537 711 * @note When the IRDA parity is enabled (PCE = 1), the received data contain
mbed_official 376:cb4d9db17537 712 * the parity bit (MSB position)
mbed_official 376:cb4d9db17537 713 * @retval HAL status
mbed_official 376:cb4d9db17537 714 */
mbed_official 376:cb4d9db17537 715 HAL_StatusTypeDef HAL_IRDA_Receive_DMA(IRDA_HandleTypeDef *hirda, uint8_t *pData, uint16_t Size)
mbed_official 376:cb4d9db17537 716 {
mbed_official 376:cb4d9db17537 717 uint32_t *tmp;
mbed_official 376:cb4d9db17537 718
mbed_official 376:cb4d9db17537 719 if ((hirda->State == HAL_IRDA_STATE_READY) || (hirda->State == HAL_IRDA_STATE_BUSY_TX))
mbed_official 376:cb4d9db17537 720 {
mbed_official 489:119543c9f674 721 if((pData == NULL) || (Size == 0))
mbed_official 376:cb4d9db17537 722 {
mbed_official 376:cb4d9db17537 723 return HAL_ERROR;
mbed_official 376:cb4d9db17537 724 }
mbed_official 376:cb4d9db17537 725
mbed_official 376:cb4d9db17537 726 /* Process Locked */
mbed_official 376:cb4d9db17537 727 __HAL_LOCK(hirda);
mbed_official 376:cb4d9db17537 728
mbed_official 376:cb4d9db17537 729 hirda->pRxBuffPtr = pData;
mbed_official 376:cb4d9db17537 730 hirda->RxXferSize = Size;
mbed_official 376:cb4d9db17537 731
mbed_official 376:cb4d9db17537 732 hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
mbed_official 376:cb4d9db17537 733 if(hirda->State == HAL_IRDA_STATE_BUSY_TX)
mbed_official 376:cb4d9db17537 734 {
mbed_official 376:cb4d9db17537 735 hirda->State = HAL_IRDA_STATE_BUSY_TX_RX;
mbed_official 376:cb4d9db17537 736 }
mbed_official 376:cb4d9db17537 737 else
mbed_official 376:cb4d9db17537 738 {
mbed_official 376:cb4d9db17537 739 hirda->State = HAL_IRDA_STATE_BUSY_RX;
mbed_official 376:cb4d9db17537 740 }
mbed_official 376:cb4d9db17537 741
mbed_official 376:cb4d9db17537 742 /* Set the IRDA DMA transfer complete callback */
mbed_official 376:cb4d9db17537 743 hirda->hdmarx->XferCpltCallback = IRDA_DMAReceiveCplt;
mbed_official 376:cb4d9db17537 744
mbed_official 376:cb4d9db17537 745 /* Set the IRDA DMA half transfer complete callback */
mbed_official 376:cb4d9db17537 746 hirda->hdmarx->XferHalfCpltCallback = IRDA_DMAReceiveHalfCplt;
mbed_official 376:cb4d9db17537 747
mbed_official 376:cb4d9db17537 748 /* Set the DMA error callback */
mbed_official 376:cb4d9db17537 749 hirda->hdmarx->XferErrorCallback = IRDA_DMAError;
mbed_official 376:cb4d9db17537 750
mbed_official 376:cb4d9db17537 751 /* Enable the DMA channel */
mbed_official 376:cb4d9db17537 752 tmp = (uint32_t*)&pData;
mbed_official 376:cb4d9db17537 753 HAL_DMA_Start_IT(hirda->hdmarx, (uint32_t)&hirda->Instance->RDR, *(uint32_t*)tmp, Size);
mbed_official 376:cb4d9db17537 754
mbed_official 376:cb4d9db17537 755 /* Enable the DMA transfer for the receiver request by setting the DMAR bit
mbed_official 376:cb4d9db17537 756 in the IRDA CR3 register */
mbed_official 376:cb4d9db17537 757 hirda->Instance->CR3 |= USART_CR3_DMAR;
mbed_official 376:cb4d9db17537 758
mbed_official 376:cb4d9db17537 759 /* Process Unlocked */
mbed_official 376:cb4d9db17537 760 __HAL_UNLOCK(hirda);
mbed_official 376:cb4d9db17537 761
mbed_official 376:cb4d9db17537 762 return HAL_OK;
mbed_official 376:cb4d9db17537 763 }
mbed_official 376:cb4d9db17537 764 else
mbed_official 376:cb4d9db17537 765 {
mbed_official 376:cb4d9db17537 766 return HAL_BUSY;
mbed_official 376:cb4d9db17537 767 }
mbed_official 376:cb4d9db17537 768 }
mbed_official 376:cb4d9db17537 769
mbed_official 376:cb4d9db17537 770 /**
mbed_official 376:cb4d9db17537 771 * @brief Pauses the DMA Transfer.
mbed_official 376:cb4d9db17537 772 * @param hirda: pointer to a IRDA_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 773 * the configuration information for the specified IRDA module.
mbed_official 376:cb4d9db17537 774 * @retval HAL status
mbed_official 376:cb4d9db17537 775 */
mbed_official 376:cb4d9db17537 776 HAL_StatusTypeDef HAL_IRDA_DMAPause(IRDA_HandleTypeDef *hirda)
mbed_official 376:cb4d9db17537 777 {
mbed_official 376:cb4d9db17537 778 /* Process Locked */
mbed_official 376:cb4d9db17537 779 __HAL_LOCK(hirda);
mbed_official 376:cb4d9db17537 780
mbed_official 376:cb4d9db17537 781 if(hirda->State == HAL_IRDA_STATE_BUSY_TX)
mbed_official 376:cb4d9db17537 782 {
mbed_official 376:cb4d9db17537 783 /* Disable the UART DMA Tx request */
mbed_official 376:cb4d9db17537 784 hirda->Instance->CR3 &= (uint32_t)(~USART_CR3_DMAT);
mbed_official 376:cb4d9db17537 785 }
mbed_official 376:cb4d9db17537 786 else if(hirda->State == HAL_IRDA_STATE_BUSY_RX)
mbed_official 376:cb4d9db17537 787 {
mbed_official 376:cb4d9db17537 788 /* Disable the UART DMA Rx request */
mbed_official 376:cb4d9db17537 789 hirda->Instance->CR3 &= (uint32_t)(~USART_CR3_DMAR);
mbed_official 376:cb4d9db17537 790 }
mbed_official 376:cb4d9db17537 791 else if (hirda->State == HAL_IRDA_STATE_BUSY_TX_RX)
mbed_official 376:cb4d9db17537 792 {
mbed_official 376:cb4d9db17537 793 /* Disable the UART DMA Tx & Rx requests */
mbed_official 376:cb4d9db17537 794 hirda->Instance->CR3 &= (uint32_t)(~USART_CR3_DMAT);
mbed_official 376:cb4d9db17537 795 hirda->Instance->CR3 &= (uint32_t)(~USART_CR3_DMAR);
mbed_official 376:cb4d9db17537 796 }
mbed_official 376:cb4d9db17537 797
mbed_official 376:cb4d9db17537 798 /* Process Unlocked */
mbed_official 376:cb4d9db17537 799 __HAL_UNLOCK(hirda);
mbed_official 376:cb4d9db17537 800
mbed_official 376:cb4d9db17537 801 return HAL_OK;
mbed_official 376:cb4d9db17537 802 }
mbed_official 376:cb4d9db17537 803
mbed_official 376:cb4d9db17537 804 /**
mbed_official 376:cb4d9db17537 805 * @brief Resumes the DMA Transfer.
mbed_official 376:cb4d9db17537 806 * @param hirda: pointer to a IRDA_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 807 * the configuration information for the specified UART module.
mbed_official 376:cb4d9db17537 808 * @retval HAL status
mbed_official 376:cb4d9db17537 809 */
mbed_official 376:cb4d9db17537 810 HAL_StatusTypeDef HAL_IRDA_DMAResume(IRDA_HandleTypeDef *hirda)
mbed_official 376:cb4d9db17537 811 {
mbed_official 376:cb4d9db17537 812 /* Process Locked */
mbed_official 376:cb4d9db17537 813 __HAL_LOCK(hirda);
mbed_official 376:cb4d9db17537 814
mbed_official 376:cb4d9db17537 815 if(hirda->State == HAL_IRDA_STATE_BUSY_TX)
mbed_official 376:cb4d9db17537 816 {
mbed_official 376:cb4d9db17537 817 /* Enable the UART DMA Tx request */
mbed_official 376:cb4d9db17537 818 hirda->Instance->CR3 |= USART_CR3_DMAT;
mbed_official 376:cb4d9db17537 819 }
mbed_official 376:cb4d9db17537 820 else if(hirda->State == HAL_IRDA_STATE_BUSY_RX)
mbed_official 376:cb4d9db17537 821 {
mbed_official 376:cb4d9db17537 822 /* Clear the Overrun flag before resumming the Rx transfer*/
mbed_official 376:cb4d9db17537 823 __HAL_IRDA_CLEAR_IT(hirda, IRDA_CLEAR_OREF);
mbed_official 376:cb4d9db17537 824
mbed_official 376:cb4d9db17537 825 /* Enable the UART DMA Rx request */
mbed_official 376:cb4d9db17537 826 hirda->Instance->CR3 |= USART_CR3_DMAR;
mbed_official 376:cb4d9db17537 827 }
mbed_official 376:cb4d9db17537 828 else if(hirda->State == HAL_IRDA_STATE_BUSY_TX_RX)
mbed_official 376:cb4d9db17537 829 {
mbed_official 376:cb4d9db17537 830 /* Clear the Overrun flag before resumming the Rx transfer*/
mbed_official 376:cb4d9db17537 831 __HAL_IRDA_CLEAR_IT(hirda, IRDA_CLEAR_OREF);
mbed_official 376:cb4d9db17537 832
mbed_official 376:cb4d9db17537 833 /* Enable the UART DMA Tx & Rx request */
mbed_official 376:cb4d9db17537 834 hirda->Instance->CR3 |= USART_CR3_DMAT;
mbed_official 376:cb4d9db17537 835 hirda->Instance->CR3 |= USART_CR3_DMAR;
mbed_official 376:cb4d9db17537 836 }
mbed_official 376:cb4d9db17537 837
mbed_official 376:cb4d9db17537 838 /* Process Unlocked */
mbed_official 376:cb4d9db17537 839 __HAL_UNLOCK(hirda);
mbed_official 376:cb4d9db17537 840
mbed_official 376:cb4d9db17537 841 return HAL_OK;
mbed_official 376:cb4d9db17537 842 }
mbed_official 376:cb4d9db17537 843
mbed_official 376:cb4d9db17537 844 /**
mbed_official 376:cb4d9db17537 845 * @brief Stops the DMA Transfer.
mbed_official 376:cb4d9db17537 846 * @param hirda: pointer to a IRDA_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 847 * the configuration information for the specified UART module.
mbed_official 376:cb4d9db17537 848 * @retval HAL status
mbed_official 376:cb4d9db17537 849 */
mbed_official 376:cb4d9db17537 850 HAL_StatusTypeDef HAL_IRDA_DMAStop(IRDA_HandleTypeDef *hirda)
mbed_official 376:cb4d9db17537 851 {
mbed_official 376:cb4d9db17537 852 /* The Lock is not implemented on this API to allow the user application
mbed_official 376:cb4d9db17537 853 to call the HAL UART API under callbacks HAL_UART_TxCpltCallback() / HAL_UART_RxCpltCallback():
mbed_official 376:cb4d9db17537 854 when calling HAL_DMA_Abort() API the DMA TX/RX Transfer complete interrupt is generated
mbed_official 376:cb4d9db17537 855 and the correspond call back is executed HAL_UART_TxCpltCallback() / HAL_UART_RxCpltCallback()
mbed_official 376:cb4d9db17537 856 */
mbed_official 376:cb4d9db17537 857
mbed_official 376:cb4d9db17537 858 /* Disable the UART Tx/Rx DMA requests */
mbed_official 376:cb4d9db17537 859 hirda->Instance->CR3 &= ~USART_CR3_DMAT;
mbed_official 376:cb4d9db17537 860 hirda->Instance->CR3 &= ~USART_CR3_DMAR;
mbed_official 376:cb4d9db17537 861
mbed_official 376:cb4d9db17537 862 /* Abort the UART DMA tx channel */
mbed_official 489:119543c9f674 863 if(hirda->hdmatx != NULL)
mbed_official 376:cb4d9db17537 864 {
mbed_official 376:cb4d9db17537 865 HAL_DMA_Abort(hirda->hdmatx);
mbed_official 376:cb4d9db17537 866 }
mbed_official 376:cb4d9db17537 867 /* Abort the UART DMA rx channel */
mbed_official 489:119543c9f674 868 if(hirda->hdmarx != NULL)
mbed_official 376:cb4d9db17537 869 {
mbed_official 376:cb4d9db17537 870 HAL_DMA_Abort(hirda->hdmarx);
mbed_official 376:cb4d9db17537 871 }
mbed_official 376:cb4d9db17537 872
mbed_official 376:cb4d9db17537 873 hirda->State = HAL_IRDA_STATE_READY;
mbed_official 376:cb4d9db17537 874
mbed_official 376:cb4d9db17537 875 return HAL_OK;
mbed_official 376:cb4d9db17537 876 }
mbed_official 376:cb4d9db17537 877
mbed_official 376:cb4d9db17537 878 /**
mbed_official 376:cb4d9db17537 879 * @brief This function handles IRDA interrupt request.
mbed_official 376:cb4d9db17537 880 * @param hirda: IRDA handle
mbed_official 376:cb4d9db17537 881 * @retval None
mbed_official 376:cb4d9db17537 882 */
mbed_official 376:cb4d9db17537 883 void HAL_IRDA_IRQHandler(IRDA_HandleTypeDef *hirda)
mbed_official 376:cb4d9db17537 884 {
mbed_official 376:cb4d9db17537 885 /* IRDA parity error interrupt occurred -------------------------------------*/
mbed_official 376:cb4d9db17537 886 if((__HAL_IRDA_GET_IT(hirda, IRDA_IT_PE) != RESET) && (__HAL_IRDA_GET_IT_SOURCE(hirda, IRDA_IT_PE) != RESET))
mbed_official 376:cb4d9db17537 887 {
mbed_official 489:119543c9f674 888 __HAL_IRDA_CLEAR_PEFLAG(hirda);
mbed_official 376:cb4d9db17537 889
mbed_official 376:cb4d9db17537 890 hirda->ErrorCode |= HAL_IRDA_ERROR_PE;
mbed_official 376:cb4d9db17537 891 /* Set the IRDA state ready to be able to start again the process */
mbed_official 376:cb4d9db17537 892 hirda->State = HAL_IRDA_STATE_READY;
mbed_official 376:cb4d9db17537 893 }
mbed_official 376:cb4d9db17537 894
mbed_official 376:cb4d9db17537 895 /* IRDA frame error interrupt occured --------------------------------------*/
mbed_official 376:cb4d9db17537 896 if((__HAL_IRDA_GET_IT(hirda, IRDA_IT_FE) != RESET) && (__HAL_IRDA_GET_IT_SOURCE(hirda, IRDA_IT_ERR) != RESET))
mbed_official 376:cb4d9db17537 897 {
mbed_official 489:119543c9f674 898 __HAL_IRDA_CLEAR_FEFLAG(hirda);
mbed_official 376:cb4d9db17537 899
mbed_official 376:cb4d9db17537 900 hirda->ErrorCode |= HAL_IRDA_ERROR_FE;
mbed_official 376:cb4d9db17537 901 /* Set the IRDA state ready to be able to start again the process */
mbed_official 376:cb4d9db17537 902 hirda->State = HAL_IRDA_STATE_READY;
mbed_official 376:cb4d9db17537 903 }
mbed_official 376:cb4d9db17537 904
mbed_official 376:cb4d9db17537 905 /* IRDA noise error interrupt occured --------------------------------------*/
mbed_official 376:cb4d9db17537 906 if((__HAL_IRDA_GET_IT(hirda, IRDA_IT_NE) != RESET) && (__HAL_IRDA_GET_IT_SOURCE(hirda, IRDA_IT_ERR) != RESET))
mbed_official 376:cb4d9db17537 907 {
mbed_official 489:119543c9f674 908 __HAL_IRDA_CLEAR_NEFLAG(hirda);
mbed_official 376:cb4d9db17537 909
mbed_official 376:cb4d9db17537 910 hirda->ErrorCode |= HAL_IRDA_ERROR_NE;
mbed_official 376:cb4d9db17537 911 /* Set the IRDA state ready to be able to start again the process */
mbed_official 376:cb4d9db17537 912 hirda->State = HAL_IRDA_STATE_READY;
mbed_official 376:cb4d9db17537 913 }
mbed_official 376:cb4d9db17537 914
mbed_official 376:cb4d9db17537 915 /* IRDA Over-Run interrupt occured -----------------------------------------*/
mbed_official 376:cb4d9db17537 916 if((__HAL_IRDA_GET_IT(hirda, IRDA_IT_ORE) != RESET) && (__HAL_IRDA_GET_IT_SOURCE(hirda, IRDA_IT_ERR) != RESET))
mbed_official 376:cb4d9db17537 917 {
mbed_official 489:119543c9f674 918 __HAL_IRDA_CLEAR_OREFLAG(hirda);
mbed_official 376:cb4d9db17537 919
mbed_official 376:cb4d9db17537 920 hirda->ErrorCode |= HAL_IRDA_ERROR_ORE;
mbed_official 376:cb4d9db17537 921 /* Set the IRDA state ready to be able to start again the process */
mbed_official 376:cb4d9db17537 922 hirda->State = HAL_IRDA_STATE_READY;
mbed_official 376:cb4d9db17537 923 }
mbed_official 376:cb4d9db17537 924
mbed_official 376:cb4d9db17537 925 /* Call IRDA Error Call back function if need be --------------------------*/
mbed_official 376:cb4d9db17537 926 if(hirda->ErrorCode != HAL_IRDA_ERROR_NONE)
mbed_official 376:cb4d9db17537 927 {
mbed_official 376:cb4d9db17537 928 HAL_IRDA_ErrorCallback(hirda);
mbed_official 376:cb4d9db17537 929 }
mbed_official 376:cb4d9db17537 930
mbed_official 376:cb4d9db17537 931 /* IRDA in mode Receiver ---------------------------------------------------*/
mbed_official 376:cb4d9db17537 932 if((__HAL_IRDA_GET_IT(hirda, IRDA_IT_RXNE) != RESET) && (__HAL_IRDA_GET_IT_SOURCE(hirda, IRDA_IT_RXNE) != RESET))
mbed_official 376:cb4d9db17537 933 {
mbed_official 376:cb4d9db17537 934 IRDA_Receive_IT(hirda);
mbed_official 376:cb4d9db17537 935 /* Clear RXNE interrupt flag */
mbed_official 376:cb4d9db17537 936 __HAL_IRDA_SEND_REQ(hirda, IRDA_RXDATA_FLUSH_REQUEST);
mbed_official 376:cb4d9db17537 937 }
mbed_official 376:cb4d9db17537 938
mbed_official 376:cb4d9db17537 939 /* IRDA in mode Transmitter ------------------------------------------------*/
mbed_official 376:cb4d9db17537 940 if((__HAL_IRDA_GET_IT(hirda, IRDA_IT_TXE) != RESET) &&(__HAL_IRDA_GET_IT_SOURCE(hirda, IRDA_IT_TXE) != RESET))
mbed_official 376:cb4d9db17537 941 {
mbed_official 376:cb4d9db17537 942 IRDA_Transmit_IT(hirda);
mbed_official 376:cb4d9db17537 943 }
mbed_official 489:119543c9f674 944
mbed_official 489:119543c9f674 945 /* IRDA in mode Transmitter (transmission end) -----------------------------*/
mbed_official 489:119543c9f674 946 if((__HAL_IRDA_GET_IT(hirda, IRDA_IT_TC) != RESET) &&(__HAL_IRDA_GET_IT_SOURCE(hirda, IRDA_IT_TC) != RESET))
mbed_official 489:119543c9f674 947 {
mbed_official 489:119543c9f674 948 IRDA_EndTransmit_IT(hirda);
mbed_official 489:119543c9f674 949 }
mbed_official 489:119543c9f674 950
mbed_official 376:cb4d9db17537 951 }
mbed_official 376:cb4d9db17537 952
mbed_official 376:cb4d9db17537 953 /**
mbed_official 376:cb4d9db17537 954 * @brief Tx Half Transfer completed callback
mbed_official 376:cb4d9db17537 955 * @param hirda: irda handle
mbed_official 376:cb4d9db17537 956 * @retval None
mbed_official 376:cb4d9db17537 957 */
mbed_official 376:cb4d9db17537 958 __weak void HAL_IRDA_TxHalfCpltCallback(IRDA_HandleTypeDef *hirda)
mbed_official 376:cb4d9db17537 959 {
mbed_official 376:cb4d9db17537 960 /* NOTE : This function should not be modified, when the callback is needed,
mbed_official 376:cb4d9db17537 961 the HAL_IRDA_TxHalfCpltCallback can be implemented in the user file
mbed_official 376:cb4d9db17537 962 */
mbed_official 376:cb4d9db17537 963 }
mbed_official 376:cb4d9db17537 964
mbed_official 376:cb4d9db17537 965 /**
mbed_official 376:cb4d9db17537 966 * @brief Tx Transfer completed callback
mbed_official 376:cb4d9db17537 967 * @param hirda: irda handle
mbed_official 376:cb4d9db17537 968 * @retval None
mbed_official 376:cb4d9db17537 969 */
mbed_official 376:cb4d9db17537 970 __weak void HAL_IRDA_TxCpltCallback(IRDA_HandleTypeDef *hirda)
mbed_official 376:cb4d9db17537 971 {
mbed_official 376:cb4d9db17537 972 /* NOTE : This function should not be modified, when the callback is needed,
mbed_official 376:cb4d9db17537 973 the HAL_IRDA_TxCpltCallback can be implemented in the user file
mbed_official 376:cb4d9db17537 974 */
mbed_official 376:cb4d9db17537 975 }
mbed_official 376:cb4d9db17537 976
mbed_official 376:cb4d9db17537 977 /**
mbed_official 376:cb4d9db17537 978 * @brief Rx Half Transfer completed callback
mbed_official 376:cb4d9db17537 979 * @param hirda: irda handle
mbed_official 376:cb4d9db17537 980 * @retval None
mbed_official 376:cb4d9db17537 981 */
mbed_official 376:cb4d9db17537 982 __weak void HAL_IRDA_RxHalfCpltCallback(IRDA_HandleTypeDef *hirda)
mbed_official 376:cb4d9db17537 983 {
mbed_official 376:cb4d9db17537 984 /* NOTE : This function should not be modified, when the callback is needed,
mbed_official 376:cb4d9db17537 985 the HAL_IRDA_RxHalfCpltCallback can be implemented in the user file
mbed_official 376:cb4d9db17537 986 */
mbed_official 376:cb4d9db17537 987 }
mbed_official 376:cb4d9db17537 988
mbed_official 376:cb4d9db17537 989 /**
mbed_official 376:cb4d9db17537 990 * @brief Rx Transfer completed callback
mbed_official 376:cb4d9db17537 991 * @param hirda: irda handle
mbed_official 376:cb4d9db17537 992 * @retval None
mbed_official 376:cb4d9db17537 993 */
mbed_official 376:cb4d9db17537 994 __weak void HAL_IRDA_RxCpltCallback(IRDA_HandleTypeDef *hirda)
mbed_official 376:cb4d9db17537 995 {
mbed_official 376:cb4d9db17537 996 /* NOTE : This function should not be modified, when the callback is needed,
mbed_official 376:cb4d9db17537 997 the HAL_IRDA_RxCpltCallback can be implemented in the user file
mbed_official 376:cb4d9db17537 998 */
mbed_official 376:cb4d9db17537 999 }
mbed_official 376:cb4d9db17537 1000
mbed_official 376:cb4d9db17537 1001 /**
mbed_official 376:cb4d9db17537 1002 * @brief IRDA error callback
mbed_official 376:cb4d9db17537 1003 * @param hirda: IRDA handle
mbed_official 376:cb4d9db17537 1004 * @retval None
mbed_official 376:cb4d9db17537 1005 */
mbed_official 376:cb4d9db17537 1006 __weak void HAL_IRDA_ErrorCallback(IRDA_HandleTypeDef *hirda)
mbed_official 376:cb4d9db17537 1007 {
mbed_official 376:cb4d9db17537 1008 /* NOTE : This function should not be modified, when the callback is needed,
mbed_official 376:cb4d9db17537 1009 the HAL_IRDA_ErrorCallback can be implemented in the user file
mbed_official 376:cb4d9db17537 1010 */
mbed_official 376:cb4d9db17537 1011 }
mbed_official 376:cb4d9db17537 1012
mbed_official 376:cb4d9db17537 1013 /**
mbed_official 376:cb4d9db17537 1014 * @}
mbed_official 376:cb4d9db17537 1015 */
mbed_official 376:cb4d9db17537 1016
mbed_official 489:119543c9f674 1017 /** @addtogroup IRDA_Exported_Functions_Group3
mbed_official 376:cb4d9db17537 1018 * @brief IRDA control functions
mbed_official 376:cb4d9db17537 1019 *
mbed_official 376:cb4d9db17537 1020 @verbatim
mbed_official 376:cb4d9db17537 1021 ===============================================================================
mbed_official 376:cb4d9db17537 1022 ##### Peripheral Control functions #####
mbed_official 376:cb4d9db17537 1023 ===============================================================================
mbed_official 376:cb4d9db17537 1024 [..]
mbed_official 376:cb4d9db17537 1025 This subsection provides a set of functions allowing to control the IRDA.
mbed_official 376:cb4d9db17537 1026 (+) HAL_IRDA_GetState() API can be helpful to check in run-time the state of the IRDA peripheral.
mbed_official 376:cb4d9db17537 1027 (+) IRDA_SetConfig() API is used to configure the IRDA communications parameters.
mbed_official 376:cb4d9db17537 1028 @endverbatim
mbed_official 376:cb4d9db17537 1029 * @{
mbed_official 376:cb4d9db17537 1030 */
mbed_official 376:cb4d9db17537 1031
mbed_official 376:cb4d9db17537 1032 /**
mbed_official 376:cb4d9db17537 1033 * @brief return the IRDA state
mbed_official 376:cb4d9db17537 1034 * @param hirda: irda handle
mbed_official 376:cb4d9db17537 1035 * @retval HAL state
mbed_official 376:cb4d9db17537 1036 */
mbed_official 376:cb4d9db17537 1037 HAL_IRDA_StateTypeDef HAL_IRDA_GetState(IRDA_HandleTypeDef *hirda)
mbed_official 376:cb4d9db17537 1038 {
mbed_official 376:cb4d9db17537 1039 return hirda->State;
mbed_official 376:cb4d9db17537 1040 }
mbed_official 376:cb4d9db17537 1041
mbed_official 376:cb4d9db17537 1042 /**
mbed_official 376:cb4d9db17537 1043 * @brief Return the IRDA error code
mbed_official 376:cb4d9db17537 1044 * @param hirda : pointer to a IRDA_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1045 * the configuration information for the specified IRDA.
mbed_official 376:cb4d9db17537 1046 * @retval IRDA Error Code
mbed_official 376:cb4d9db17537 1047 */
mbed_official 376:cb4d9db17537 1048 uint32_t HAL_IRDA_GetError(IRDA_HandleTypeDef *hirda)
mbed_official 376:cb4d9db17537 1049 {
mbed_official 376:cb4d9db17537 1050 return hirda->ErrorCode;
mbed_official 376:cb4d9db17537 1051 }
mbed_official 376:cb4d9db17537 1052
mbed_official 376:cb4d9db17537 1053 /**
mbed_official 376:cb4d9db17537 1054 * @}
mbed_official 376:cb4d9db17537 1055 */
mbed_official 376:cb4d9db17537 1056
mbed_official 376:cb4d9db17537 1057 /**
mbed_official 376:cb4d9db17537 1058 * @brief Configure the IRDA peripheral
mbed_official 376:cb4d9db17537 1059 * @param hirda: irda handle
mbed_official 376:cb4d9db17537 1060 * @retval None
mbed_official 376:cb4d9db17537 1061 */
mbed_official 376:cb4d9db17537 1062 static void IRDA_SetConfig(IRDA_HandleTypeDef *hirda)
mbed_official 376:cb4d9db17537 1063 {
mbed_official 376:cb4d9db17537 1064 uint32_t tmpreg = 0x00000000;
mbed_official 376:cb4d9db17537 1065 uint32_t clocksource = 0x00000000;
mbed_official 376:cb4d9db17537 1066
mbed_official 376:cb4d9db17537 1067 /* Check the communication parameters */
mbed_official 376:cb4d9db17537 1068 assert_param(IS_IRDA_BAUDRATE(hirda->Init.BaudRate));
mbed_official 376:cb4d9db17537 1069 assert_param(IS_IRDA_WORD_LENGTH(hirda->Init.WordLength));
mbed_official 376:cb4d9db17537 1070 assert_param(IS_IRDA_PARITY(hirda->Init.Parity));
mbed_official 376:cb4d9db17537 1071 assert_param(IS_IRDA_TX_RX_MODE(hirda->Init.Mode));
mbed_official 376:cb4d9db17537 1072 assert_param(IS_IRDA_PRESCALER(hirda->Init.Prescaler));
mbed_official 376:cb4d9db17537 1073 assert_param(IS_IRDA_POWERMODE(hirda->Init.PowerMode));
mbed_official 376:cb4d9db17537 1074 /*-------------------------- USART CR1 Configuration -----------------------*/
mbed_official 376:cb4d9db17537 1075 /* Configure the IRDA Word Length, Parity and transfer Mode:
mbed_official 376:cb4d9db17537 1076 Set the M bits according to hirda->Init.WordLength value
mbed_official 376:cb4d9db17537 1077 Set PCE and PS bits according to hirda->Init.Parity value
mbed_official 376:cb4d9db17537 1078 Set TE and RE bits according to hirda->Init.Mode value */
mbed_official 376:cb4d9db17537 1079 tmpreg = (uint32_t)hirda->Init.WordLength | hirda->Init.Parity | hirda->Init.Mode ;
mbed_official 376:cb4d9db17537 1080
mbed_official 376:cb4d9db17537 1081 MODIFY_REG(hirda->Instance->CR1, IRDA_CR1_FIELDS, tmpreg);
mbed_official 376:cb4d9db17537 1082
mbed_official 376:cb4d9db17537 1083 /*-------------------------- USART CR3 Configuration -----------------------*/
mbed_official 376:cb4d9db17537 1084 MODIFY_REG(hirda->Instance->CR3, USART_CR3_IRLP, hirda->Init.PowerMode);
mbed_official 376:cb4d9db17537 1085
mbed_official 376:cb4d9db17537 1086 /*-------------------------- USART GTPR Configuration ----------------------*/
mbed_official 376:cb4d9db17537 1087 MODIFY_REG(hirda->Instance->GTPR, (uint32_t)USART_GTPR_PSC, hirda->Init.Prescaler);
mbed_official 376:cb4d9db17537 1088
mbed_official 376:cb4d9db17537 1089 /*-------------------------- USART BRR Configuration -----------------------*/
mbed_official 489:119543c9f674 1090 IRDA_GETCLOCKSOURCE(hirda, clocksource);
mbed_official 376:cb4d9db17537 1091 switch (clocksource)
mbed_official 376:cb4d9db17537 1092 {
mbed_official 376:cb4d9db17537 1093 case IRDA_CLOCKSOURCE_PCLK1:
mbed_official 376:cb4d9db17537 1094 hirda->Instance->BRR = (uint16_t)(HAL_RCC_GetPCLK1Freq() / hirda->Init.BaudRate);
mbed_official 376:cb4d9db17537 1095 break;
mbed_official 376:cb4d9db17537 1096 case IRDA_CLOCKSOURCE_PCLK2:
mbed_official 376:cb4d9db17537 1097 hirda->Instance->BRR = (uint16_t)(HAL_RCC_GetPCLK2Freq() / hirda->Init.BaudRate);
mbed_official 376:cb4d9db17537 1098 break;
mbed_official 376:cb4d9db17537 1099 case IRDA_CLOCKSOURCE_HSI:
mbed_official 376:cb4d9db17537 1100 hirda->Instance->BRR = (uint16_t)(HSI_VALUE / hirda->Init.BaudRate);
mbed_official 376:cb4d9db17537 1101 break;
mbed_official 376:cb4d9db17537 1102 case IRDA_CLOCKSOURCE_SYSCLK:
mbed_official 376:cb4d9db17537 1103 hirda->Instance->BRR = (uint16_t)(HAL_RCC_GetSysClockFreq() / hirda->Init.BaudRate);
mbed_official 376:cb4d9db17537 1104 break;
mbed_official 376:cb4d9db17537 1105 case IRDA_CLOCKSOURCE_LSE:
mbed_official 376:cb4d9db17537 1106 hirda->Instance->BRR = (uint16_t)(LSE_VALUE / hirda->Init.BaudRate);
mbed_official 376:cb4d9db17537 1107 break;
mbed_official 376:cb4d9db17537 1108 default:
mbed_official 376:cb4d9db17537 1109 break;
mbed_official 376:cb4d9db17537 1110 }
mbed_official 376:cb4d9db17537 1111 }
mbed_official 376:cb4d9db17537 1112
mbed_official 376:cb4d9db17537 1113 /**
mbed_official 376:cb4d9db17537 1114 * @brief Check the IRDA Idle State
mbed_official 376:cb4d9db17537 1115 * @param hirda: IRDA handle
mbed_official 376:cb4d9db17537 1116 * @retval HAL status
mbed_official 376:cb4d9db17537 1117 */
mbed_official 376:cb4d9db17537 1118 static HAL_StatusTypeDef IRDA_CheckIdleState(IRDA_HandleTypeDef *hirda)
mbed_official 376:cb4d9db17537 1119 {
mbed_official 376:cb4d9db17537 1120 /* Initialize the IRDA ErrorCode */
mbed_official 376:cb4d9db17537 1121 hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
mbed_official 376:cb4d9db17537 1122
mbed_official 376:cb4d9db17537 1123 /* Check if the Transmitter is enabled */
mbed_official 376:cb4d9db17537 1124 if((hirda->Instance->CR1 & USART_CR1_TE) == USART_CR1_TE)
mbed_official 376:cb4d9db17537 1125 {
mbed_official 376:cb4d9db17537 1126 /* Wait until TEACK flag is set */
mbed_official 376:cb4d9db17537 1127 if(IRDA_WaitOnFlagUntilTimeout(hirda, USART_ISR_TEACK, 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 /* Check if the Receiver is enabled */
mbed_official 376:cb4d9db17537 1134 if((hirda->Instance->CR1 & USART_CR1_RE) == USART_CR1_RE)
mbed_official 376:cb4d9db17537 1135 {
mbed_official 376:cb4d9db17537 1136 if(IRDA_WaitOnFlagUntilTimeout(hirda, USART_ISR_REACK, RESET, TEACK_REACK_TIMEOUT) != HAL_OK)
mbed_official 376:cb4d9db17537 1137 {
mbed_official 376:cb4d9db17537 1138 hirda->State= HAL_IRDA_STATE_TIMEOUT;
mbed_official 376:cb4d9db17537 1139 return HAL_TIMEOUT;
mbed_official 376:cb4d9db17537 1140 }
mbed_official 376:cb4d9db17537 1141 }
mbed_official 376:cb4d9db17537 1142 /* Process Unlocked */
mbed_official 376:cb4d9db17537 1143 __HAL_UNLOCK(hirda);
mbed_official 376:cb4d9db17537 1144
mbed_official 376:cb4d9db17537 1145 /* Initialize the IRDA state*/
mbed_official 376:cb4d9db17537 1146 hirda->State= HAL_IRDA_STATE_READY;
mbed_official 376:cb4d9db17537 1147
mbed_official 376:cb4d9db17537 1148 return HAL_OK;
mbed_official 376:cb4d9db17537 1149 }
mbed_official 376:cb4d9db17537 1150
mbed_official 376:cb4d9db17537 1151 /**
mbed_official 376:cb4d9db17537 1152 * @brief Handle IRDA Communication Timeout.
mbed_official 376:cb4d9db17537 1153 * @param hirda: IRDA handle
mbed_official 376:cb4d9db17537 1154 * @param Flag: specifies the IRDA flag to check.
mbed_official 376:cb4d9db17537 1155 * @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 1156 * @param Timeout: Timeout duration
mbed_official 376:cb4d9db17537 1157 * @retval HAL status
mbed_official 376:cb4d9db17537 1158 */
mbed_official 376:cb4d9db17537 1159 static HAL_StatusTypeDef IRDA_WaitOnFlagUntilTimeout(IRDA_HandleTypeDef *hirda, uint32_t Flag, FlagStatus Status, uint32_t Timeout)
mbed_official 376:cb4d9db17537 1160 {
mbed_official 376:cb4d9db17537 1161 uint32_t tickstart = 0x00;
mbed_official 376:cb4d9db17537 1162 tickstart = HAL_GetTick();
mbed_official 376:cb4d9db17537 1163
mbed_official 376:cb4d9db17537 1164 /* Wait until flag is set */
mbed_official 376:cb4d9db17537 1165 if(Status == RESET)
mbed_official 376:cb4d9db17537 1166 {
mbed_official 376:cb4d9db17537 1167 while(__HAL_IRDA_GET_FLAG(hirda, Flag) == RESET)
mbed_official 376:cb4d9db17537 1168 {
mbed_official 376:cb4d9db17537 1169 /* Check for the Timeout */
mbed_official 376:cb4d9db17537 1170 if(Timeout != HAL_MAX_DELAY)
mbed_official 376:cb4d9db17537 1171 {
mbed_official 376:cb4d9db17537 1172 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 376:cb4d9db17537 1173 {
mbed_official 376:cb4d9db17537 1174 /* Disable TXE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts for the interrupt process */
mbed_official 376:cb4d9db17537 1175 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_TXE);
mbed_official 376:cb4d9db17537 1176 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_RXNE);
mbed_official 376:cb4d9db17537 1177 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_PE);
mbed_official 376:cb4d9db17537 1178 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_ERR);
mbed_official 376:cb4d9db17537 1179
mbed_official 489:119543c9f674 1180 hirda->State= HAL_IRDA_STATE_READY;
mbed_official 376:cb4d9db17537 1181
mbed_official 376:cb4d9db17537 1182 /* Process Unlocked */
mbed_official 376:cb4d9db17537 1183 __HAL_UNLOCK(hirda);
mbed_official 376:cb4d9db17537 1184
mbed_official 376:cb4d9db17537 1185 return HAL_TIMEOUT;
mbed_official 376:cb4d9db17537 1186 }
mbed_official 376:cb4d9db17537 1187 }
mbed_official 376:cb4d9db17537 1188 }
mbed_official 376:cb4d9db17537 1189 }
mbed_official 376:cb4d9db17537 1190 else
mbed_official 376:cb4d9db17537 1191 {
mbed_official 376:cb4d9db17537 1192 while(__HAL_IRDA_GET_FLAG(hirda, Flag) != RESET)
mbed_official 376:cb4d9db17537 1193 {
mbed_official 376:cb4d9db17537 1194 /* Check for the Timeout */
mbed_official 376:cb4d9db17537 1195 if(Timeout != HAL_MAX_DELAY)
mbed_official 376:cb4d9db17537 1196 {
mbed_official 376:cb4d9db17537 1197 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 376:cb4d9db17537 1198 {
mbed_official 376:cb4d9db17537 1199 /* Disable TXE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts for the interrupt process */
mbed_official 376:cb4d9db17537 1200 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_TXE);
mbed_official 376:cb4d9db17537 1201 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_RXNE);
mbed_official 376:cb4d9db17537 1202 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_PE);
mbed_official 376:cb4d9db17537 1203 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_ERR);
mbed_official 376:cb4d9db17537 1204
mbed_official 489:119543c9f674 1205 hirda->State= HAL_IRDA_STATE_READY;
mbed_official 376:cb4d9db17537 1206
mbed_official 376:cb4d9db17537 1207 /* Process Unlocked */
mbed_official 376:cb4d9db17537 1208 __HAL_UNLOCK(hirda);
mbed_official 376:cb4d9db17537 1209
mbed_official 376:cb4d9db17537 1210 return HAL_TIMEOUT;
mbed_official 376:cb4d9db17537 1211 }
mbed_official 376:cb4d9db17537 1212 }
mbed_official 376:cb4d9db17537 1213 }
mbed_official 376:cb4d9db17537 1214 }
mbed_official 376:cb4d9db17537 1215 return HAL_OK;
mbed_official 376:cb4d9db17537 1216 }
mbed_official 376:cb4d9db17537 1217
mbed_official 376:cb4d9db17537 1218 /**
mbed_official 376:cb4d9db17537 1219 * @brief Receive an amount of data in non blocking mode.
mbed_official 376:cb4d9db17537 1220 * Function called under interruption only, once
mbed_official 376:cb4d9db17537 1221 * interruptions have been enabled by HAL_IRDA_Transmit_IT()
mbed_official 376:cb4d9db17537 1222 * @param hirda: IRDA handle
mbed_official 376:cb4d9db17537 1223 * @retval HAL status
mbed_official 376:cb4d9db17537 1224 */
mbed_official 376:cb4d9db17537 1225 static HAL_StatusTypeDef IRDA_Transmit_IT(IRDA_HandleTypeDef *hirda)
mbed_official 376:cb4d9db17537 1226 {
mbed_official 376:cb4d9db17537 1227 uint16_t* tmp;
mbed_official 376:cb4d9db17537 1228
mbed_official 376:cb4d9db17537 1229 if((hirda->State == HAL_IRDA_STATE_BUSY_TX) || (hirda->State == HAL_IRDA_STATE_BUSY_TX_RX))
mbed_official 376:cb4d9db17537 1230 {
mbed_official 489:119543c9f674 1231
mbed_official 376:cb4d9db17537 1232 if(hirda->TxXferCount == 0)
mbed_official 376:cb4d9db17537 1233 {
mbed_official 489:119543c9f674 1234 /* Disable the IRDA Transmit Data Register Empty Interrupt */
mbed_official 376:cb4d9db17537 1235 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_TXE);
mbed_official 489:119543c9f674 1236
mbed_official 489:119543c9f674 1237 /* Enable the IRDA Transmit Complete Interrupt */
mbed_official 489:119543c9f674 1238 __HAL_IRDA_ENABLE_IT(hirda, IRDA_IT_TC);
mbed_official 376:cb4d9db17537 1239
mbed_official 376:cb4d9db17537 1240 return HAL_OK;
mbed_official 376:cb4d9db17537 1241 }
mbed_official 376:cb4d9db17537 1242 else
mbed_official 376:cb4d9db17537 1243 {
mbed_official 376:cb4d9db17537 1244 if ((hirda->Init.WordLength == IRDA_WORDLENGTH_9B) && (hirda->Init.Parity == IRDA_PARITY_NONE))
mbed_official 376:cb4d9db17537 1245 {
mbed_official 376:cb4d9db17537 1246 tmp = (uint16_t*) hirda->pTxBuffPtr;
mbed_official 376:cb4d9db17537 1247 hirda->Instance->TDR = (*tmp & (uint16_t)0x01FF);
mbed_official 376:cb4d9db17537 1248 hirda->pTxBuffPtr += 2;
mbed_official 376:cb4d9db17537 1249 }
mbed_official 376:cb4d9db17537 1250 else
mbed_official 376:cb4d9db17537 1251 {
mbed_official 376:cb4d9db17537 1252 hirda->Instance->TDR = (uint8_t)(*hirda->pTxBuffPtr++ & (uint8_t)0xFF);
mbed_official 376:cb4d9db17537 1253 }
mbed_official 376:cb4d9db17537 1254 hirda->TxXferCount--;
mbed_official 376:cb4d9db17537 1255 return HAL_OK;
mbed_official 376:cb4d9db17537 1256 }
mbed_official 376:cb4d9db17537 1257 }
mbed_official 376:cb4d9db17537 1258 else
mbed_official 376:cb4d9db17537 1259 {
mbed_official 376:cb4d9db17537 1260 return HAL_BUSY;
mbed_official 376:cb4d9db17537 1261 }
mbed_official 376:cb4d9db17537 1262 }
mbed_official 489:119543c9f674 1263 /**
mbed_official 489:119543c9f674 1264 * @brief Wraps up transmission in non blocking mode.
mbed_official 489:119543c9f674 1265 * @param hirda: pointer to a IRDA_HandleTypeDef structure that contains
mbed_official 489:119543c9f674 1266 * the configuration information for the specified IRDA module.
mbed_official 489:119543c9f674 1267 * @retval HAL status
mbed_official 489:119543c9f674 1268 */
mbed_official 489:119543c9f674 1269 static HAL_StatusTypeDef IRDA_EndTransmit_IT(IRDA_HandleTypeDef *hirda)
mbed_official 489:119543c9f674 1270 {
mbed_official 489:119543c9f674 1271 /* Disable the IRDA Transmit Complete Interrupt */
mbed_official 489:119543c9f674 1272 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_TC);
mbed_official 489:119543c9f674 1273
mbed_official 489:119543c9f674 1274 /* Check if a receive process is ongoing or not */
mbed_official 489:119543c9f674 1275 if(hirda->State == HAL_IRDA_STATE_BUSY_TX_RX)
mbed_official 489:119543c9f674 1276 {
mbed_official 489:119543c9f674 1277 hirda->State = HAL_IRDA_STATE_BUSY_RX;
mbed_official 489:119543c9f674 1278 }
mbed_official 489:119543c9f674 1279 else
mbed_official 489:119543c9f674 1280 {
mbed_official 489:119543c9f674 1281 /* Disable the IRDA Error Interrupt: (Frame error, noise error, overrun error) */
mbed_official 489:119543c9f674 1282 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_ERR);
mbed_official 489:119543c9f674 1283
mbed_official 489:119543c9f674 1284 hirda->State = HAL_IRDA_STATE_READY;
mbed_official 489:119543c9f674 1285 }
mbed_official 489:119543c9f674 1286
mbed_official 489:119543c9f674 1287 HAL_IRDA_TxCpltCallback(hirda);
mbed_official 489:119543c9f674 1288
mbed_official 489:119543c9f674 1289 return HAL_OK;
mbed_official 489:119543c9f674 1290 }
mbed_official 376:cb4d9db17537 1291
mbed_official 376:cb4d9db17537 1292 /**
mbed_official 376:cb4d9db17537 1293 * @brief Receive an amount of data in non blocking mode.
mbed_official 376:cb4d9db17537 1294 * Function called under interruption only, once
mbed_official 376:cb4d9db17537 1295 * interruptions have been enabled by HAL_IRDA_Receive_IT()
mbed_official 376:cb4d9db17537 1296 * @param hirda: IRDA handle
mbed_official 376:cb4d9db17537 1297 * @retval HAL status
mbed_official 376:cb4d9db17537 1298 */
mbed_official 376:cb4d9db17537 1299 static HAL_StatusTypeDef IRDA_Receive_IT(IRDA_HandleTypeDef *hirda)
mbed_official 376:cb4d9db17537 1300 {
mbed_official 376:cb4d9db17537 1301 uint16_t* tmp;
mbed_official 376:cb4d9db17537 1302 uint16_t uhMask = hirda->Mask;
mbed_official 376:cb4d9db17537 1303
mbed_official 376:cb4d9db17537 1304 if ((hirda->State == HAL_IRDA_STATE_BUSY_RX) || (hirda->State == HAL_IRDA_STATE_BUSY_TX_RX))
mbed_official 376:cb4d9db17537 1305 {
mbed_official 376:cb4d9db17537 1306 if ((hirda->Init.WordLength == IRDA_WORDLENGTH_9B) && (hirda->Init.Parity == IRDA_PARITY_NONE))
mbed_official 376:cb4d9db17537 1307 {
mbed_official 376:cb4d9db17537 1308 tmp = (uint16_t*) hirda->pRxBuffPtr ;
mbed_official 376:cb4d9db17537 1309 *tmp = (uint16_t)(hirda->Instance->RDR & uhMask);
mbed_official 376:cb4d9db17537 1310 hirda->pRxBuffPtr +=2;
mbed_official 376:cb4d9db17537 1311 }
mbed_official 376:cb4d9db17537 1312 else
mbed_official 376:cb4d9db17537 1313 {
mbed_official 376:cb4d9db17537 1314 *hirda->pRxBuffPtr++ = (uint8_t)(hirda->Instance->RDR & (uint8_t)uhMask);
mbed_official 376:cb4d9db17537 1315 }
mbed_official 376:cb4d9db17537 1316
mbed_official 376:cb4d9db17537 1317 if(--hirda->RxXferCount == 0)
mbed_official 376:cb4d9db17537 1318 {
mbed_official 376:cb4d9db17537 1319 while(HAL_IS_BIT_SET(hirda->Instance->ISR, IRDA_FLAG_RXNE))
mbed_official 376:cb4d9db17537 1320 {
mbed_official 376:cb4d9db17537 1321 }
mbed_official 376:cb4d9db17537 1322 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_RXNE);
mbed_official 376:cb4d9db17537 1323
mbed_official 376:cb4d9db17537 1324 if(hirda->State == HAL_IRDA_STATE_BUSY_TX_RX)
mbed_official 376:cb4d9db17537 1325 {
mbed_official 376:cb4d9db17537 1326 hirda->State = HAL_IRDA_STATE_BUSY_TX;
mbed_official 376:cb4d9db17537 1327 }
mbed_official 376:cb4d9db17537 1328 else
mbed_official 376:cb4d9db17537 1329 {
mbed_official 376:cb4d9db17537 1330 /* Disable the IRDA Parity Error Interrupt */
mbed_official 376:cb4d9db17537 1331 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_PE);
mbed_official 376:cb4d9db17537 1332
mbed_official 376:cb4d9db17537 1333 /* Disable the IRDA Error Interrupt: (Frame error, noise error, overrun error) */
mbed_official 376:cb4d9db17537 1334 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_ERR);
mbed_official 376:cb4d9db17537 1335
mbed_official 376:cb4d9db17537 1336 hirda->State = HAL_IRDA_STATE_READY;
mbed_official 376:cb4d9db17537 1337 }
mbed_official 376:cb4d9db17537 1338
mbed_official 376:cb4d9db17537 1339 HAL_IRDA_RxCpltCallback(hirda);
mbed_official 376:cb4d9db17537 1340
mbed_official 376:cb4d9db17537 1341 return HAL_OK;
mbed_official 376:cb4d9db17537 1342 }
mbed_official 376:cb4d9db17537 1343
mbed_official 376:cb4d9db17537 1344 return HAL_OK;
mbed_official 376:cb4d9db17537 1345 }
mbed_official 376:cb4d9db17537 1346 else
mbed_official 376:cb4d9db17537 1347 {
mbed_official 376:cb4d9db17537 1348 return HAL_BUSY;
mbed_official 376:cb4d9db17537 1349 }
mbed_official 376:cb4d9db17537 1350 }
mbed_official 376:cb4d9db17537 1351
mbed_official 376:cb4d9db17537 1352 /**
mbed_official 376:cb4d9db17537 1353 * @brief DMA IRDA Tx transfer completed callback
mbed_official 376:cb4d9db17537 1354 * @param hdma: DMA handle
mbed_official 376:cb4d9db17537 1355 * @retval None
mbed_official 376:cb4d9db17537 1356 */
mbed_official 376:cb4d9db17537 1357 static void IRDA_DMATransmitCplt(DMA_HandleTypeDef *hdma)
mbed_official 376:cb4d9db17537 1358 {
mbed_official 376:cb4d9db17537 1359 IRDA_HandleTypeDef* hirda = ( IRDA_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official 489:119543c9f674 1360
mbed_official 376:cb4d9db17537 1361 /* DMA Normal mode */
mbed_official 489:119543c9f674 1362 if ( HAL_IS_BIT_CLR(hdma->Instance->CCR, DMA_CCR_CIRC) )
mbed_official 376:cb4d9db17537 1363 {
mbed_official 376:cb4d9db17537 1364 hirda->TxXferCount = 0;
mbed_official 489:119543c9f674 1365
mbed_official 489:119543c9f674 1366 /* Disable the DMA transfer for transmit request by resetting the DMAT bit
mbed_official 489:119543c9f674 1367 in the IRDA CR3 register */
mbed_official 489:119543c9f674 1368 hirda->Instance->CR3 &= ~(USART_CR3_DMAT);
mbed_official 489:119543c9f674 1369
mbed_official 489:119543c9f674 1370 /* Enable the IRDA Transmit Complete Interrupt */
mbed_official 489:119543c9f674 1371 __HAL_IRDA_ENABLE_IT(hirda, IRDA_IT_TC);
mbed_official 376:cb4d9db17537 1372 }
mbed_official 376:cb4d9db17537 1373 /* DMA Circular mode */
mbed_official 376:cb4d9db17537 1374 else
mbed_official 376:cb4d9db17537 1375 {
mbed_official 376:cb4d9db17537 1376 HAL_IRDA_TxCpltCallback(hirda);
mbed_official 376:cb4d9db17537 1377 }
mbed_official 376:cb4d9db17537 1378 }
mbed_official 376:cb4d9db17537 1379
mbed_official 376:cb4d9db17537 1380 /**
mbed_official 376:cb4d9db17537 1381 * @brief DMA IRDA receive process half complete callback
mbed_official 376:cb4d9db17537 1382 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1383 * the configuration information for the specified DMA module.
mbed_official 376:cb4d9db17537 1384 * @retval None
mbed_official 376:cb4d9db17537 1385 */
mbed_official 376:cb4d9db17537 1386 static void IRDA_DMATransmitHalfCplt(DMA_HandleTypeDef *hdma)
mbed_official 376:cb4d9db17537 1387 {
mbed_official 376:cb4d9db17537 1388 IRDA_HandleTypeDef* hirda = ( IRDA_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official 376:cb4d9db17537 1389
mbed_official 376:cb4d9db17537 1390 HAL_IRDA_TxHalfCpltCallback(hirda);
mbed_official 376:cb4d9db17537 1391 }
mbed_official 376:cb4d9db17537 1392
mbed_official 376:cb4d9db17537 1393 /**
mbed_official 376:cb4d9db17537 1394 * @brief DMA IRDA Rx Transfer completed callback
mbed_official 376:cb4d9db17537 1395 * @param hdma: DMA handle
mbed_official 376:cb4d9db17537 1396 * @retval None
mbed_official 376:cb4d9db17537 1397 */
mbed_official 376:cb4d9db17537 1398 static void IRDA_DMAReceiveCplt(DMA_HandleTypeDef *hdma)
mbed_official 376:cb4d9db17537 1399 {
mbed_official 376:cb4d9db17537 1400 IRDA_HandleTypeDef* hirda = ( IRDA_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official 376:cb4d9db17537 1401 /* DMA Normal mode */
mbed_official 376:cb4d9db17537 1402 if((hdma->Instance->CCR & DMA_CCR_CIRC) == 0)
mbed_official 376:cb4d9db17537 1403 {
mbed_official 376:cb4d9db17537 1404 hirda->RxXferCount = 0;
mbed_official 376:cb4d9db17537 1405
mbed_official 376:cb4d9db17537 1406 /* Disable the DMA transfer for the receiver request by setting the DMAR bit
mbed_official 376:cb4d9db17537 1407 in the IRDA CR3 register */
mbed_official 376:cb4d9db17537 1408 hirda->Instance->CR3 &= (uint16_t)~((uint16_t)USART_CR3_DMAR);
mbed_official 376:cb4d9db17537 1409
mbed_official 376:cb4d9db17537 1410 if(hirda->State == HAL_IRDA_STATE_BUSY_TX_RX)
mbed_official 376:cb4d9db17537 1411 {
mbed_official 376:cb4d9db17537 1412 hirda->State = HAL_IRDA_STATE_BUSY_TX;
mbed_official 376:cb4d9db17537 1413 }
mbed_official 376:cb4d9db17537 1414 else
mbed_official 376:cb4d9db17537 1415 {
mbed_official 376:cb4d9db17537 1416 hirda->State = HAL_IRDA_STATE_READY;
mbed_official 376:cb4d9db17537 1417 }
mbed_official 376:cb4d9db17537 1418 }
mbed_official 376:cb4d9db17537 1419
mbed_official 376:cb4d9db17537 1420 HAL_IRDA_RxCpltCallback(hirda);
mbed_official 376:cb4d9db17537 1421 }
mbed_official 376:cb4d9db17537 1422
mbed_official 376:cb4d9db17537 1423 /**
mbed_official 376:cb4d9db17537 1424 * @brief DMA IRDA receive process half complete callback
mbed_official 376:cb4d9db17537 1425 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1426 * the configuration information for the specified DMA module.
mbed_official 376:cb4d9db17537 1427 * @retval None
mbed_official 376:cb4d9db17537 1428 */
mbed_official 376:cb4d9db17537 1429 static void IRDA_DMAReceiveHalfCplt(DMA_HandleTypeDef *hdma)
mbed_official 376:cb4d9db17537 1430 {
mbed_official 376:cb4d9db17537 1431 IRDA_HandleTypeDef* hirda = ( IRDA_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official 376:cb4d9db17537 1432
mbed_official 376:cb4d9db17537 1433 HAL_IRDA_RxHalfCpltCallback(hirda);
mbed_official 376:cb4d9db17537 1434 }
mbed_official 376:cb4d9db17537 1435
mbed_official 376:cb4d9db17537 1436 /**
mbed_official 376:cb4d9db17537 1437 * @brief DMA IRDA communication error callback
mbed_official 376:cb4d9db17537 1438 * @param hdma: DMA handle
mbed_official 376:cb4d9db17537 1439 * @retval None
mbed_official 376:cb4d9db17537 1440 */
mbed_official 376:cb4d9db17537 1441 static void IRDA_DMAError(DMA_HandleTypeDef *hdma)
mbed_official 376:cb4d9db17537 1442 {
mbed_official 376:cb4d9db17537 1443 IRDA_HandleTypeDef* hirda = ( IRDA_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official 376:cb4d9db17537 1444 hirda->RxXferCount = 0;
mbed_official 376:cb4d9db17537 1445 hirda->TxXferCount = 0;
mbed_official 376:cb4d9db17537 1446 hirda->State= HAL_IRDA_STATE_READY;
mbed_official 376:cb4d9db17537 1447 hirda->ErrorCode |= HAL_IRDA_ERROR_DMA;
mbed_official 376:cb4d9db17537 1448 HAL_IRDA_ErrorCallback(hirda);
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 #endif /* HAL_IRDA_MODULE_ENABLED */
mbed_official 376:cb4d9db17537 1456 /**
mbed_official 376:cb4d9db17537 1457 * @}
mbed_official 376:cb4d9db17537 1458 */
mbed_official 376:cb4d9db17537 1459
mbed_official 376:cb4d9db17537 1460 /**
mbed_official 376:cb4d9db17537 1461 * @}
mbed_official 376:cb4d9db17537 1462 */
mbed_official 376:cb4d9db17537 1463
mbed_official 376:cb4d9db17537 1464 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
mbed_official 489:119543c9f674 1465