long dao / mbed-src

Mbed for VNG board

Fork of mbed-src by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32L1/stm32l1xx_hal_irda.c@394:83f921546702, 2014-11-07 (annotated)

Committer:
mbed_official
Date:
Fri Nov 07 15:45:07 2014 +0000
Revision:
394:83f921546702
Parent:
targets/cmsis/TARGET_STM/TARGET_NUCLEO_L152RE/stm32l1xx_hal_irda.c@354:e67efb2aab0e 
Synchronized with git revision aab52cb7ec5a665869e507dd988bbfd55b7e087e



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



Tests: Fix cpputest testrunner

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****/