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