1 /** 2 ****************************************************************************** 3 * @file stm32f1xx_hal_irda.h 4 * @author MCD Application Team 5 * @brief Header file of IRDA HAL module. 6 ****************************************************************************** 7 * @attention 8 * 9 * <h2><center>© Copyright (c) 2016 STMicroelectronics. 10 * All rights reserved.</center></h2> 11 * 12 * This software component is licensed by ST under BSD 3-Clause license, 13 * the "License"; You may not use this file except in compliance with the 14 * License. You may obtain a copy of the License at: 15 * opensource.org/licenses/BSD-3-Clause 16 * 17 ****************************************************************************** 18 */ 19 20 /* Define to prevent recursive inclusion -------------------------------------*/ 21 #ifndef __STM32F1xx_HAL_IRDA_H 22 #define __STM32F1xx_HAL_IRDA_H 23 24 #ifdef __cplusplus 25 extern "C" { 26 #endif 27 28 /* Includes ------------------------------------------------------------------*/ 29 #include "stm32f1xx_hal_def.h" 30 31 /** @addtogroup STM32F1xx_HAL_Driver 32 * @{ 33 */ 34 35 /** @addtogroup IRDA 36 * @{ 37 */ 38 39 /* Exported types ------------------------------------------------------------*/ 40 /** @defgroup IRDA_Exported_Types IRDA Exported Types 41 * @{ 42 */ 43 /** 44 * @brief IRDA Init Structure definition 45 */ 46 typedef struct 47 { 48 uint32_t BaudRate; /*!< This member configures the IRDA communication baud rate. 49 The baud rate is computed using the following formula: 50 - IntegerDivider = ((PCLKx) / (16 * (hirda->Init.BaudRate))) 51 - FractionalDivider = ((IntegerDivider - ((uint32_t) IntegerDivider)) * 16) + 0.5 */ 52 53 uint32_t WordLength; /*!< Specifies the number of data bits transmitted or received in a frame. 54 This parameter can be a value of @ref IRDA_Word_Length */ 55 56 uint32_t Parity; /*!< Specifies the parity mode. 57 This parameter can be a value of @ref IRDA_Parity 58 @note When parity is enabled, the computed parity is inserted 59 at the MSB position of the transmitted data (9th bit when 60 the word length is set to 9 data bits; 8th bit when the 61 word length is set to 8 data bits). */ 62 63 uint32_t Mode; /*!< Specifies whether the Receive or Transmit mode is enabled or disabled. 64 This parameter can be a value of @ref IRDA_Mode */ 65 66 uint8_t Prescaler; /*!< Specifies the Prescaler value to be programmed 67 in the IrDA low-power Baud Register, for defining pulse width on which 68 burst acceptance/rejection will be decided. This value is used as divisor 69 of system clock to achieve required pulse width. */ 70 71 uint32_t IrDAMode; /*!< Specifies the IrDA mode 72 This parameter can be a value of @ref IRDA_Low_Power */ 73 } IRDA_InitTypeDef; 74 75 /** 76 * @brief HAL IRDA State structures definition 77 * @note HAL IRDA State value is a combination of 2 different substates: gState and RxState. 78 * - gState contains IRDA state information related to global Handle management 79 * and also information related to Tx operations. 80 * gState value coding follow below described bitmap : 81 * b7-b6 Error information 82 * 00 : No Error 83 * 01 : (Not Used) 84 * 10 : Timeout 85 * 11 : Error 86 * b5 IP initialisation status 87 * 0 : Reset (IP not initialized) 88 * 1 : Init done (IP initialized. HAL IRDA Init function already called) 89 * b4-b3 (not used) 90 * xx : Should be set to 00 91 * b2 Intrinsic process state 92 * 0 : Ready 93 * 1 : Busy (IP busy with some configuration or internal operations) 94 * b1 (not used) 95 * x : Should be set to 0 96 * b0 Tx state 97 * 0 : Ready (no Tx operation ongoing) 98 * 1 : Busy (Tx operation ongoing) 99 * - RxState contains information related to Rx operations. 100 * RxState value coding follow below described bitmap : 101 * b7-b6 (not used) 102 * xx : Should be set to 00 103 * b5 IP initialisation status 104 * 0 : Reset (IP not initialized) 105 * 1 : Init done (IP initialized) 106 * b4-b2 (not used) 107 * xxx : Should be set to 000 108 * b1 Rx state 109 * 0 : Ready (no Rx operation ongoing) 110 * 1 : Busy (Rx operation ongoing) 111 * b0 (not used) 112 * x : Should be set to 0. 113 */ 114 typedef enum 115 { 116 HAL_IRDA_STATE_RESET = 0x00U, /*!< Peripheral is not yet Initialized 117 Value is allowed for gState and RxState */ 118 HAL_IRDA_STATE_READY = 0x20U, /*!< Peripheral Initialized and ready for use 119 Value is allowed for gState and RxState */ 120 HAL_IRDA_STATE_BUSY = 0x24U, /*!< An internal process is ongoing 121 Value is allowed for gState only */ 122 HAL_IRDA_STATE_BUSY_TX = 0x21U, /*!< Data Transmission process is ongoing 123 Value is allowed for gState only */ 124 HAL_IRDA_STATE_BUSY_RX = 0x22U, /*!< Data Reception process is ongoing 125 Value is allowed for RxState only */ 126 HAL_IRDA_STATE_BUSY_TX_RX = 0x23U, /*!< Data Transmission and Reception process is ongoing 127 Not to be used for neither gState nor RxState. 128 Value is result of combination (Or) between gState and RxState values */ 129 HAL_IRDA_STATE_TIMEOUT = 0xA0U, /*!< Timeout state 130 Value is allowed for gState only */ 131 HAL_IRDA_STATE_ERROR = 0xE0U /*!< Error 132 Value is allowed for gState only */ 133 } HAL_IRDA_StateTypeDef; 134 135 /** 136 * @brief IRDA handle Structure definition 137 */ 138 #if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1) 139 typedef struct __IRDA_HandleTypeDef 140 #else 141 typedef struct 142 #endif /* USE_HAL_IRDA_REGISTER_CALLBACKS */ 143 { 144 USART_TypeDef *Instance; /*!< USART registers base address */ 145 146 IRDA_InitTypeDef Init; /*!< IRDA communication parameters */ 147 148 uint8_t *pTxBuffPtr; /*!< Pointer to IRDA Tx transfer Buffer */ 149 150 uint16_t TxXferSize; /*!< IRDA Tx Transfer size */ 151 152 __IO uint16_t TxXferCount; /*!< IRDA Tx Transfer Counter */ 153 154 uint8_t *pRxBuffPtr; /*!< Pointer to IRDA Rx transfer Buffer */ 155 156 uint16_t RxXferSize; /*!< IRDA Rx Transfer size */ 157 158 __IO uint16_t RxXferCount; /*!< IRDA Rx Transfer Counter */ 159 160 DMA_HandleTypeDef *hdmatx; /*!< IRDA Tx DMA Handle parameters */ 161 162 DMA_HandleTypeDef *hdmarx; /*!< IRDA Rx DMA Handle parameters */ 163 164 HAL_LockTypeDef Lock; /*!< Locking object */ 165 166 __IO HAL_IRDA_StateTypeDef gState; /*!< IRDA state information related to global Handle management 167 and also related to Tx operations. 168 This parameter can be a value of @ref HAL_IRDA_StateTypeDef */ 169 170 __IO HAL_IRDA_StateTypeDef RxState; /*!< IRDA state information related to Rx operations. 171 This parameter can be a value of @ref HAL_IRDA_StateTypeDef */ 172 173 __IO uint32_t ErrorCode; /*!< IRDA Error code */ 174 175 #if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1) 176 void (* TxHalfCpltCallback)(struct __IRDA_HandleTypeDef *hirda); /*!< IRDA Tx Half Complete Callback */ 177 178 void (* TxCpltCallback)(struct __IRDA_HandleTypeDef *hirda); /*!< IRDA Tx Complete Callback */ 179 180 void (* RxHalfCpltCallback)(struct __IRDA_HandleTypeDef *hirda); /*!< IRDA Rx Half Complete Callback */ 181 182 void (* RxCpltCallback)(struct __IRDA_HandleTypeDef *hirda); /*!< IRDA Rx Complete Callback */ 183 184 void (* ErrorCallback)(struct __IRDA_HandleTypeDef *hirda); /*!< IRDA Error Callback */ 185 186 void (* AbortCpltCallback)(struct __IRDA_HandleTypeDef *hirda); /*!< IRDA Abort Complete Callback */ 187 188 void (* AbortTransmitCpltCallback)(struct __IRDA_HandleTypeDef *hirda); /*!< IRDA Abort Transmit Complete Callback */ 189 190 void (* AbortReceiveCpltCallback)(struct __IRDA_HandleTypeDef *hirda); /*!< IRDA Abort Receive Complete Callback */ 191 192 193 void (* MspInitCallback)(struct __IRDA_HandleTypeDef *hirda); /*!< IRDA Msp Init callback */ 194 195 void (* MspDeInitCallback)(struct __IRDA_HandleTypeDef *hirda); /*!< IRDA Msp DeInit callback */ 196 #endif /* USE_HAL_IRDA_REGISTER_CALLBACKS */ 197 198 } IRDA_HandleTypeDef; 199 200 #if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1) 201 /** 202 * @brief HAL IRDA Callback ID enumeration definition 203 */ 204 typedef enum 205 { 206 HAL_IRDA_TX_HALFCOMPLETE_CB_ID = 0x00U, /*!< IRDA Tx Half Complete Callback ID */ 207 HAL_IRDA_TX_COMPLETE_CB_ID = 0x01U, /*!< IRDA Tx Complete Callback ID */ 208 HAL_IRDA_RX_HALFCOMPLETE_CB_ID = 0x02U, /*!< IRDA Rx Half Complete Callback ID */ 209 HAL_IRDA_RX_COMPLETE_CB_ID = 0x03U, /*!< IRDA Rx Complete Callback ID */ 210 HAL_IRDA_ERROR_CB_ID = 0x04U, /*!< IRDA Error Callback ID */ 211 HAL_IRDA_ABORT_COMPLETE_CB_ID = 0x05U, /*!< IRDA Abort Complete Callback ID */ 212 HAL_IRDA_ABORT_TRANSMIT_COMPLETE_CB_ID = 0x06U, /*!< IRDA Abort Transmit Complete Callback ID */ 213 HAL_IRDA_ABORT_RECEIVE_COMPLETE_CB_ID = 0x07U, /*!< IRDA Abort Receive Complete Callback ID */ 214 215 HAL_IRDA_MSPINIT_CB_ID = 0x08U, /*!< IRDA MspInit callback ID */ 216 HAL_IRDA_MSPDEINIT_CB_ID = 0x09U /*!< IRDA MspDeInit callback ID */ 217 218 } HAL_IRDA_CallbackIDTypeDef; 219 220 /** 221 * @brief HAL IRDA Callback pointer definition 222 */ 223 typedef void (*pIRDA_CallbackTypeDef)(IRDA_HandleTypeDef *hirda); /*!< pointer to an IRDA callback function */ 224 225 #endif /* USE_HAL_IRDA_REGISTER_CALLBACKS */ 226 227 /** 228 * @} 229 */ 230 231 /* Exported constants --------------------------------------------------------*/ 232 /** @defgroup IRDA_Exported_Constants IRDA Exported constants 233 * @{ 234 */ 235 /** @defgroup IRDA_Error_Code IRDA Error Code 236 * @{ 237 */ 238 #define HAL_IRDA_ERROR_NONE 0x00000000U /*!< No error */ 239 #define HAL_IRDA_ERROR_PE 0x00000001U /*!< Parity error */ 240 #define HAL_IRDA_ERROR_NE 0x00000002U /*!< Noise error */ 241 #define HAL_IRDA_ERROR_FE 0x00000004U /*!< Frame error */ 242 #define HAL_IRDA_ERROR_ORE 0x00000008U /*!< Overrun error */ 243 #define HAL_IRDA_ERROR_DMA 0x00000010U /*!< DMA transfer error */ 244 #if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1) 245 #define HAL_IRDA_ERROR_INVALID_CALLBACK ((uint32_t)0x00000020U) /*!< Invalid Callback error */ 246 #endif /* USE_HAL_IRDA_REGISTER_CALLBACKS */ 247 /** 248 * @} 249 */ 250 251 /** @defgroup IRDA_Word_Length IRDA Word Length 252 * @{ 253 */ 254 #define IRDA_WORDLENGTH_8B 0x00000000U 255 #define IRDA_WORDLENGTH_9B ((uint32_t)USART_CR1_M) 256 /** 257 * @} 258 */ 259 260 /** @defgroup IRDA_Parity IRDA Parity 261 * @{ 262 */ 263 #define IRDA_PARITY_NONE 0x00000000U 264 #define IRDA_PARITY_EVEN ((uint32_t)USART_CR1_PCE) 265 #define IRDA_PARITY_ODD ((uint32_t)(USART_CR1_PCE | USART_CR1_PS)) 266 /** 267 * @} 268 */ 269 270 /** @defgroup IRDA_Mode IRDA Transfer Mode 271 * @{ 272 */ 273 #define IRDA_MODE_RX ((uint32_t)USART_CR1_RE) 274 #define IRDA_MODE_TX ((uint32_t)USART_CR1_TE) 275 #define IRDA_MODE_TX_RX ((uint32_t)(USART_CR1_TE |USART_CR1_RE)) 276 /** 277 * @} 278 */ 279 280 /** @defgroup IRDA_Low_Power IRDA Low Power 281 * @{ 282 */ 283 #define IRDA_POWERMODE_LOWPOWER ((uint32_t)USART_CR3_IRLP) 284 #define IRDA_POWERMODE_NORMAL 0x00000000U 285 /** 286 * @} 287 */ 288 289 /** @defgroup IRDA_Flags IRDA Flags 290 * Elements values convention: 0xXXXX 291 * - 0xXXXX : Flag mask in the SR register 292 * @{ 293 */ 294 #define IRDA_FLAG_TXE ((uint32_t)USART_SR_TXE) 295 #define IRDA_FLAG_TC ((uint32_t)USART_SR_TC) 296 #define IRDA_FLAG_RXNE ((uint32_t)USART_SR_RXNE) 297 #define IRDA_FLAG_IDLE ((uint32_t)USART_SR_IDLE) 298 #define IRDA_FLAG_ORE ((uint32_t)USART_SR_ORE) 299 #define IRDA_FLAG_NE ((uint32_t)USART_SR_NE) 300 #define IRDA_FLAG_FE ((uint32_t)USART_SR_FE) 301 #define IRDA_FLAG_PE ((uint32_t)USART_SR_PE) 302 /** 303 * @} 304 */ 305 306 /** @defgroup IRDA_Interrupt_definition IRDA Interrupt Definitions 307 * Elements values convention: 0xY000XXXX 308 * - XXXX : Interrupt mask in the XX register 309 * - Y : Interrupt source register (2bits) 310 * - 01: CR1 register 311 * - 10: CR2 register 312 * - 11: CR3 register 313 * @{ 314 */ 315 #define IRDA_IT_PE ((uint32_t)(IRDA_CR1_REG_INDEX << 28U | USART_CR1_PEIE)) 316 #define IRDA_IT_TXE ((uint32_t)(IRDA_CR1_REG_INDEX << 28U | USART_CR1_TXEIE)) 317 #define IRDA_IT_TC ((uint32_t)(IRDA_CR1_REG_INDEX << 28U | USART_CR1_TCIE)) 318 #define IRDA_IT_RXNE ((uint32_t)(IRDA_CR1_REG_INDEX << 28U | USART_CR1_RXNEIE)) 319 #define IRDA_IT_IDLE ((uint32_t)(IRDA_CR1_REG_INDEX << 28U | USART_CR1_IDLEIE)) 320 321 #define IRDA_IT_LBD ((uint32_t)(IRDA_CR2_REG_INDEX << 28U | USART_CR2_LBDIE)) 322 323 #define IRDA_IT_CTS ((uint32_t)(IRDA_CR3_REG_INDEX << 28U | USART_CR3_CTSIE)) 324 #define IRDA_IT_ERR ((uint32_t)(IRDA_CR3_REG_INDEX << 28U | USART_CR3_EIE)) 325 /** 326 * @} 327 */ 328 329 /** 330 * @} 331 */ 332 333 /* Exported macro ------------------------------------------------------------*/ 334 /** @defgroup IRDA_Exported_Macros IRDA Exported Macros 335 * @{ 336 */ 337 338 /** @brief Reset IRDA handle gstate & RxState 339 * @param __HANDLE__ specifies the IRDA Handle. 340 * IRDA Handle selects the USARTx or UARTy peripheral 341 * (USART,UART availability and x,y values depending on device). 342 * @retval None 343 */ 344 #if USE_HAL_IRDA_REGISTER_CALLBACKS == 1 345 #define __HAL_IRDA_RESET_HANDLE_STATE(__HANDLE__) do{ \ 346 (__HANDLE__)->gState = HAL_IRDA_STATE_RESET; \ 347 (__HANDLE__)->RxState = HAL_IRDA_STATE_RESET; \ 348 (__HANDLE__)->MspInitCallback = NULL; \ 349 (__HANDLE__)->MspDeInitCallback = NULL; \ 350 } while(0U) 351 #else 352 #define __HAL_IRDA_RESET_HANDLE_STATE(__HANDLE__) do{ \ 353 (__HANDLE__)->gState = HAL_IRDA_STATE_RESET; \ 354 (__HANDLE__)->RxState = HAL_IRDA_STATE_RESET; \ 355 } while(0U) 356 #endif /*USE_HAL_IRDA_REGISTER_CALLBACKS */ 357 358 /** @brief Flush the IRDA DR register 359 * @param __HANDLE__ specifies the IRDA Handle. 360 * IRDA Handle selects the USARTx or UARTy peripheral 361 * (USART,UART availability and x,y values depending on device). 362 * @retval None 363 */ 364 #define __HAL_IRDA_FLUSH_DRREGISTER(__HANDLE__) ((__HANDLE__)->Instance->DR) 365 366 /** @brief Check whether the specified IRDA flag is set or not. 367 * @param __HANDLE__ specifies the IRDA Handle. 368 * IRDA Handle selects the USARTx or UARTy peripheral 369 * (USART,UART availability and x,y values depending on device). 370 * @param __FLAG__ specifies the flag to check. 371 * This parameter can be one of the following values: 372 * @arg IRDA_FLAG_TXE: Transmit data register empty flag 373 * @arg IRDA_FLAG_TC: Transmission Complete flag 374 * @arg IRDA_FLAG_RXNE: Receive data register not empty flag 375 * @arg IRDA_FLAG_IDLE: Idle Line detection flag 376 * @arg IRDA_FLAG_ORE: OverRun Error flag 377 * @arg IRDA_FLAG_NE: Noise Error flag 378 * @arg IRDA_FLAG_FE: Framing Error flag 379 * @arg IRDA_FLAG_PE: Parity Error flag 380 * @retval The new state of __FLAG__ (TRUE or FALSE). 381 */ 382 #define __HAL_IRDA_GET_FLAG(__HANDLE__, __FLAG__) (((__HANDLE__)->Instance->SR & (__FLAG__)) == (__FLAG__)) 383 384 /** @brief Clear the specified IRDA pending flag. 385 * @param __HANDLE__ specifies the IRDA Handle. 386 * IRDA Handle selects the USARTx or UARTy peripheral 387 * (USART,UART availability and x,y values depending on device). 388 * @param __FLAG__ specifies the flag to check. 389 * This parameter can be any combination of the following values: 390 * @arg IRDA_FLAG_TC: Transmission Complete flag. 391 * @arg IRDA_FLAG_RXNE: Receive data register not empty flag. 392 * 393 * @note PE (Parity error), FE (Framing error), NE (Noise error), ORE (OverRun 394 * error) and IDLE (Idle line detected) flags are cleared by software 395 * sequence: a read operation to USART_SR register followed by a read 396 * operation to USART_DR register. 397 * @note RXNE flag can be also cleared by a read to the USART_DR register. 398 * @note TC flag can be also cleared by software sequence: a read operation to 399 * USART_SR register followed by a write operation to USART_DR register. 400 * @note TXE flag is cleared only by a write to the USART_DR register. 401 * @retval None 402 */ 403 #define __HAL_IRDA_CLEAR_FLAG(__HANDLE__, __FLAG__) ((__HANDLE__)->Instance->SR = ~(__FLAG__)) 404 405 /** @brief Clear the IRDA PE pending flag. 406 * @param __HANDLE__ specifies the IRDA Handle. 407 * IRDA Handle selects the USARTx or UARTy peripheral 408 * (USART,UART availability and x,y values depending on device). 409 * @retval None 410 */ 411 #define __HAL_IRDA_CLEAR_PEFLAG(__HANDLE__) \ 412 do{ \ 413 __IO uint32_t tmpreg = 0x00U; \ 414 tmpreg = (__HANDLE__)->Instance->SR; \ 415 tmpreg = (__HANDLE__)->Instance->DR; \ 416 UNUSED(tmpreg); \ 417 } while(0U) 418 419 /** @brief Clear the IRDA FE pending flag. 420 * @param __HANDLE__ specifies the IRDA Handle. 421 * IRDA Handle selects the USARTx or UARTy peripheral 422 * (USART,UART availability and x,y values depending on device). 423 * @retval None 424 */ 425 #define __HAL_IRDA_CLEAR_FEFLAG(__HANDLE__) __HAL_IRDA_CLEAR_PEFLAG(__HANDLE__) 426 427 /** @brief Clear the IRDA NE pending flag. 428 * @param __HANDLE__ specifies the IRDA Handle. 429 * IRDA Handle selects the USARTx or UARTy peripheral 430 * (USART,UART availability and x,y values depending on device). 431 * @retval None 432 */ 433 #define __HAL_IRDA_CLEAR_NEFLAG(__HANDLE__) __HAL_IRDA_CLEAR_PEFLAG(__HANDLE__) 434 435 /** @brief Clear the IRDA ORE pending flag. 436 * @param __HANDLE__ specifies the IRDA Handle. 437 * IRDA Handle selects the USARTx or UARTy peripheral 438 * (USART,UART availability and x,y values depending on device). 439 * @retval None 440 */ 441 #define __HAL_IRDA_CLEAR_OREFLAG(__HANDLE__) __HAL_IRDA_CLEAR_PEFLAG(__HANDLE__) 442 443 /** @brief Clear the IRDA IDLE pending flag. 444 * @param __HANDLE__ specifies the IRDA Handle. 445 * IRDA Handle selects the USARTx or UARTy peripheral 446 * (USART,UART availability and x,y values depending on device). 447 * @retval None 448 */ 449 #define __HAL_IRDA_CLEAR_IDLEFLAG(__HANDLE__) __HAL_IRDA_CLEAR_PEFLAG(__HANDLE__) 450 451 /** @brief Enable the specified IRDA interrupt. 452 * @param __HANDLE__ specifies the IRDA Handle. 453 * IRDA Handle selects the USARTx or UARTy peripheral 454 * (USART,UART availability and x,y values depending on device). 455 * @param __INTERRUPT__ specifies the IRDA interrupt source to enable. 456 * This parameter can be one of the following values: 457 * @arg IRDA_IT_TXE: Transmit Data Register empty interrupt 458 * @arg IRDA_IT_TC: Transmission complete interrupt 459 * @arg IRDA_IT_RXNE: Receive Data register not empty interrupt 460 * @arg IRDA_IT_IDLE: Idle line detection interrupt 461 * @arg IRDA_IT_PE: Parity Error interrupt 462 * @arg IRDA_IT_ERR: Error interrupt(Frame error, noise error, overrun error) 463 * @retval None 464 */ 465 #define __HAL_IRDA_ENABLE_IT(__HANDLE__, __INTERRUPT__) ((((__INTERRUPT__) >> 28U) == IRDA_CR1_REG_INDEX)? ((__HANDLE__)->Instance->CR1 |= ((__INTERRUPT__) & IRDA_IT_MASK)): \ 466 (((__INTERRUPT__) >> 28U) == IRDA_CR2_REG_INDEX)? ((__HANDLE__)->Instance->CR2 |= ((__INTERRUPT__) & IRDA_IT_MASK)): \ 467 ((__HANDLE__)->Instance->CR3 |= ((__INTERRUPT__) & IRDA_IT_MASK))) 468 /** @brief Disable the specified IRDA interrupt. 469 * @param __HANDLE__ specifies the IRDA Handle. 470 * IRDA Handle selects the USARTx or UARTy peripheral 471 * (USART,UART availability and x,y values depending on device). 472 * @param __INTERRUPT__ specifies the IRDA interrupt source to disable. 473 * This parameter can be one of the following values: 474 * @arg IRDA_IT_TXE: Transmit Data Register empty interrupt 475 * @arg IRDA_IT_TC: Transmission complete interrupt 476 * @arg IRDA_IT_RXNE: Receive Data register not empty interrupt 477 * @arg IRDA_IT_IDLE: Idle line detection interrupt 478 * @arg IRDA_IT_PE: Parity Error interrupt 479 * @arg IRDA_IT_ERR: Error interrupt(Frame error, noise error, overrun error) 480 * @retval None 481 */ 482 #define __HAL_IRDA_DISABLE_IT(__HANDLE__, __INTERRUPT__) ((((__INTERRUPT__) >> 28U) == IRDA_CR1_REG_INDEX)? ((__HANDLE__)->Instance->CR1 &= ~((__INTERRUPT__) & IRDA_IT_MASK)): \ 483 (((__INTERRUPT__) >> 28U) == IRDA_CR2_REG_INDEX)? ((__HANDLE__)->Instance->CR2 &= ~((__INTERRUPT__) & IRDA_IT_MASK)): \ 484 ((__HANDLE__)->Instance->CR3 &= ~ ((__INTERRUPT__) & IRDA_IT_MASK))) 485 486 /** @brief Check whether the specified IRDA interrupt has occurred or not. 487 * @param __HANDLE__ specifies the IRDA Handle. 488 * IRDA Handle selects the USARTx or UARTy peripheral 489 * (USART,UART availability and x,y values depending on device). 490 * @param __IT__ specifies the IRDA interrupt source to check. 491 * This parameter can be one of the following values: 492 * @arg IRDA_IT_TXE: Transmit Data Register empty interrupt 493 * @arg IRDA_IT_TC: Transmission complete interrupt 494 * @arg IRDA_IT_RXNE: Receive Data register not empty interrupt 495 * @arg IRDA_IT_IDLE: Idle line detection interrupt 496 * @arg IRDA_IT_ERR: Error interrupt 497 * @arg IRDA_IT_PE: Parity Error interrupt 498 * @retval The new state of __IT__ (TRUE or FALSE). 499 */ 500 #define __HAL_IRDA_GET_IT_SOURCE(__HANDLE__, __IT__) (((((__IT__) >> 28U) == IRDA_CR1_REG_INDEX)? (__HANDLE__)->Instance->CR1:(((((uint32_t)(__IT__)) >> 28U) == IRDA_CR2_REG_INDEX)? \ 501 (__HANDLE__)->Instance->CR2 : (__HANDLE__)->Instance->CR3)) & (((uint32_t)(__IT__)) & IRDA_IT_MASK)) 502 503 /** @brief Enable UART/USART associated to IRDA Handle 504 * @param __HANDLE__ specifies the IRDA Handle. 505 * IRDA Handle selects the USARTx or UARTy peripheral 506 * (USART,UART availability and x,y values depending on device). 507 * @retval None 508 */ 509 #define __HAL_IRDA_ENABLE(__HANDLE__) (SET_BIT((__HANDLE__)->Instance->CR1, USART_CR1_UE)) 510 511 /** @brief Disable UART/USART associated to IRDA Handle 512 * @param __HANDLE__ specifies the IRDA Handle. 513 * IRDA Handle selects the USARTx or UARTy peripheral 514 * (USART,UART availability and x,y values depending on device). 515 * @retval None 516 */ 517 #define __HAL_IRDA_DISABLE(__HANDLE__) (CLEAR_BIT((__HANDLE__)->Instance->CR1, USART_CR1_UE)) 518 519 /** 520 * @} 521 */ 522 523 /* Exported functions --------------------------------------------------------*/ 524 /** @addtogroup IRDA_Exported_Functions 525 * @{ 526 */ 527 528 /** @addtogroup IRDA_Exported_Functions_Group1 529 * @{ 530 */ 531 /* Initialization/de-initialization functions **********************************/ 532 HAL_StatusTypeDef HAL_IRDA_Init(IRDA_HandleTypeDef *hirda); 533 HAL_StatusTypeDef HAL_IRDA_DeInit(IRDA_HandleTypeDef *hirda); 534 void HAL_IRDA_MspInit(IRDA_HandleTypeDef *hirda); 535 void HAL_IRDA_MspDeInit(IRDA_HandleTypeDef *hirda); 536 537 #if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1) 538 /* Callbacks Register/UnRegister functions ***********************************/ 539 HAL_StatusTypeDef HAL_IRDA_RegisterCallback(IRDA_HandleTypeDef *hirda, HAL_IRDA_CallbackIDTypeDef CallbackID, pIRDA_CallbackTypeDef pCallback); 540 HAL_StatusTypeDef HAL_IRDA_UnRegisterCallback(IRDA_HandleTypeDef *hirda, HAL_IRDA_CallbackIDTypeDef CallbackID); 541 #endif /* USE_HAL_IRDA_REGISTER_CALLBACKS */ 542 543 /** 544 * @} 545 */ 546 547 /** @addtogroup IRDA_Exported_Functions_Group2 548 * @{ 549 */ 550 /* IO operation functions *******************************************************/ 551 HAL_StatusTypeDef HAL_IRDA_Transmit(IRDA_HandleTypeDef *hirda, uint8_t *pData, uint16_t Size, uint32_t Timeout); 552 HAL_StatusTypeDef HAL_IRDA_Receive(IRDA_HandleTypeDef *hirda, uint8_t *pData, uint16_t Size, uint32_t Timeout); 553 HAL_StatusTypeDef HAL_IRDA_Transmit_IT(IRDA_HandleTypeDef *hirda, uint8_t *pData, uint16_t Size); 554 HAL_StatusTypeDef HAL_IRDA_Receive_IT(IRDA_HandleTypeDef *hirda, uint8_t *pData, uint16_t Size); 555 HAL_StatusTypeDef HAL_IRDA_Transmit_DMA(IRDA_HandleTypeDef *hirda, uint8_t *pData, uint16_t Size); 556 HAL_StatusTypeDef HAL_IRDA_Receive_DMA(IRDA_HandleTypeDef *hirda, uint8_t *pData, uint16_t Size); 557 HAL_StatusTypeDef HAL_IRDA_DMAPause(IRDA_HandleTypeDef *hirda); 558 HAL_StatusTypeDef HAL_IRDA_DMAResume(IRDA_HandleTypeDef *hirda); 559 HAL_StatusTypeDef HAL_IRDA_DMAStop(IRDA_HandleTypeDef *hirda); 560 /* Transfer Abort functions */ 561 HAL_StatusTypeDef HAL_IRDA_Abort(IRDA_HandleTypeDef *hirda); 562 HAL_StatusTypeDef HAL_IRDA_AbortTransmit(IRDA_HandleTypeDef *hirda); 563 HAL_StatusTypeDef HAL_IRDA_AbortReceive(IRDA_HandleTypeDef *hirda); 564 HAL_StatusTypeDef HAL_IRDA_Abort_IT(IRDA_HandleTypeDef *hirda); 565 HAL_StatusTypeDef HAL_IRDA_AbortTransmit_IT(IRDA_HandleTypeDef *hirda); 566 HAL_StatusTypeDef HAL_IRDA_AbortReceive_IT(IRDA_HandleTypeDef *hirda); 567 568 void HAL_IRDA_IRQHandler(IRDA_HandleTypeDef *hirda); 569 void HAL_IRDA_TxCpltCallback(IRDA_HandleTypeDef *hirda); 570 void HAL_IRDA_RxCpltCallback(IRDA_HandleTypeDef *hirda); 571 void HAL_IRDA_TxHalfCpltCallback(IRDA_HandleTypeDef *hirda); 572 void HAL_IRDA_RxHalfCpltCallback(IRDA_HandleTypeDef *hirda); 573 void HAL_IRDA_ErrorCallback(IRDA_HandleTypeDef *hirda); 574 void HAL_IRDA_AbortCpltCallback(IRDA_HandleTypeDef *hirda); 575 void HAL_IRDA_AbortTransmitCpltCallback(IRDA_HandleTypeDef *hirda); 576 void HAL_IRDA_AbortReceiveCpltCallback(IRDA_HandleTypeDef *hirda); 577 /** 578 * @} 579 */ 580 581 /** @addtogroup IRDA_Exported_Functions_Group3 582 * @{ 583 */ 584 /* Peripheral State functions **************************************************/ 585 HAL_IRDA_StateTypeDef HAL_IRDA_GetState(IRDA_HandleTypeDef *hirda); 586 uint32_t HAL_IRDA_GetError(IRDA_HandleTypeDef *hirda); 587 /** 588 * @} 589 */ 590 591 /** 592 * @} 593 */ 594 595 /* Private types -------------------------------------------------------------*/ 596 /* Private variables ---------------------------------------------------------*/ 597 /* Private constants ---------------------------------------------------------*/ 598 /** @defgroup IRDA_Private_Constants IRDA Private Constants 599 * @{ 600 */ 601 602 /** @brief IRDA interruptions flag mask 603 * 604 */ 605 #define IRDA_IT_MASK ((uint32_t) USART_CR1_PEIE | USART_CR1_TXEIE | USART_CR1_TCIE | USART_CR1_RXNEIE | \ 606 USART_CR1_IDLEIE | USART_CR2_LBDIE | USART_CR3_CTSIE | USART_CR3_EIE ) 607 608 #define IRDA_CR1_REG_INDEX 1U 609 #define IRDA_CR2_REG_INDEX 2U 610 #define IRDA_CR3_REG_INDEX 3U 611 /** 612 * @} 613 */ 614 615 /* Private macros --------------------------------------------------------*/ 616 /** @defgroup IRDA_Private_Macros IRDA Private Macros 617 * @{ 618 */ 619 #define IS_IRDA_WORD_LENGTH(LENGTH) (((LENGTH) == IRDA_WORDLENGTH_8B) || \ 620 ((LENGTH) == IRDA_WORDLENGTH_9B)) 621 622 #define IS_IRDA_PARITY(PARITY) (((PARITY) == IRDA_PARITY_NONE) || \ 623 ((PARITY) == IRDA_PARITY_EVEN) || \ 624 ((PARITY) == IRDA_PARITY_ODD)) 625 626 #define IS_IRDA_MODE(MODE) ((((MODE) & 0x0000FFF3U) == 0x00U) && ((MODE) != 0x00000000U)) 627 628 #define IS_IRDA_POWERMODE(MODE) (((MODE) == IRDA_POWERMODE_LOWPOWER) || \ 629 ((MODE) == IRDA_POWERMODE_NORMAL)) 630 631 #define IS_IRDA_BAUDRATE(BAUDRATE) ((BAUDRATE) < 115201U) 632 633 #define IRDA_DIV(_PCLK_, _BAUD_) (((_PCLK_)*25U)/(4U*(_BAUD_))) 634 635 #define IRDA_DIVMANT(_PCLK_, _BAUD_) (IRDA_DIV((_PCLK_), (_BAUD_))/100U) 636 637 #define IRDA_DIVFRAQ(_PCLK_, _BAUD_) ((((IRDA_DIV((_PCLK_), (_BAUD_)) - (IRDA_DIVMANT((_PCLK_), (_BAUD_)) * 100U)) * 16U) + 50U) / 100U) 638 639 /* UART BRR = mantissa + overflow + fraction 640 = (UART DIVMANT << 4) + (UART DIVFRAQ & 0xF0) + (UART DIVFRAQ & 0x0FU) */ 641 #define IRDA_BRR(_PCLK_, _BAUD_) (((IRDA_DIVMANT((_PCLK_), (_BAUD_)) << 4U) + \ 642 (IRDA_DIVFRAQ((_PCLK_), (_BAUD_)) & 0xF0U)) + \ 643 (IRDA_DIVFRAQ((_PCLK_), (_BAUD_)) & 0x0FU)) 644 645 /** 646 * @} 647 */ 648 649 /* Private functions ---------------------------------------------------------*/ 650 /** @defgroup IRDA_Private_Functions IRDA Private Functions 651 * @{ 652 */ 653 654 /** 655 * @} 656 */ 657 658 /** 659 * @} 660 */ 661 662 /** 663 * @} 664 */ 665 666 #ifdef __cplusplus 667 } 668 #endif 669 670 #endif /* __STM32F1xx_HAL_IRDA_H */ 671 672 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ 673
