git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/CORTEX_M7_STM32F7_STM32756G-EVAL_IAR_Keil/ST_Library/include/stm32f7xx_hal_irda.h

   1 /**\r
   2   ******************************************************************************\r
   3   * @file    stm32f7xx_hal_irda.h\r
   4   * @author  MCD Application Team\r
   5   * @version V1.0.0RC1\r
   6   * @date    24-March-2015\r
   7   * @brief   Header file of IRDA HAL module.\r
   8   ******************************************************************************\r
   9   * @attention\r
  10   *\r
  11   * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>\r
  12   *\r
  13   * Redistribution and use in source and binary forms, with or without modification,\r
  14   * are permitted provided that the following conditions are met:\r
  15   *   1. Redistributions of source code must retain the above copyright notice,\r
  16   *      this list of conditions and the following disclaimer.\r
  17   *   2. Redistributions in binary form must reproduce the above copyright notice,\r
  18   *      this list of conditions and the following disclaimer in the documentation\r
  19   *      and/or other materials provided with the distribution.\r
  20   *   3. Neither the name of STMicroelectronics nor the names of its contributors\r
  21   *      may be used to endorse or promote products derived from this software\r
  22   *      without specific prior written permission.\r
  23   *\r
  24   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"\r
  25   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
  26   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\r
  27   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\r
  28   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\r
  29   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\r
  30   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\r
  31   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\r
  32   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\r
  33   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
  34   *\r
  35   ******************************************************************************\r
  36   */ \r
  37 \r
  38 /* Define to prevent recursive inclusion -------------------------------------*/\r
  39 #ifndef __STM32F7xx_HAL_IRDA_H\r
  40 #define __STM32F7xx_HAL_IRDA_H\r
  41 \r
  42 #ifdef __cplusplus\r
  43  extern "C" {\r
  44 #endif\r
  45 \r
  46 /* Includes ------------------------------------------------------------------*/\r
  47 #include "stm32f7xx_hal_def.h"\r
  48 \r
  49 /** @addtogroup STM32F7xx_HAL_Driver\r
  50   * @{\r
  51   */\r
  52 \r
  53 /** @addtogroup IRDA\r
  54   * @{\r
  55   */ \r
  56 \r
  57 /* Exported types ------------------------------------------------------------*/ \r
  58 /** @defgroup IRDA_Exported_Types IRDA Exported Types\r
  59   * @{\r
  60   */\r
  61 /** \r
  62   * @brief IRDA Init Structure definition  \r
  63   */ \r
  64 typedef struct\r
  65 {\r
  66   uint32_t BaudRate;                  /*!< This member configures the IRDA communication baud rate.\r
  67                                            The baud rate register is computed using the following formula:\r
  68                                               Baud Rate Register = ((PCLKx) / ((hirda->Init.BaudRate))) */\r
  69 \r
  70   uint32_t WordLength;                /*!< Specifies the number of data bits transmitted or received in a frame.\r
  71                                            This parameter can be a value of @ref IRDAEx_Word_Length */\r
  72 \r
  73   uint32_t Parity;                    /*!< Specifies the parity mode.\r
  74                                            This parameter can be a value of @ref IRDA_Parity\r
  75                                            @note When parity is enabled, the computed parity is inserted\r
  76                                                  at the MSB position of the transmitted data (9th bit when\r
  77                                                  the word length is set to 9 data bits; 8th bit when the\r
  78                                                  word length is set to 8 data bits). */\r
  79  \r
  80   uint16_t Mode;                      /*!< Specifies wether the Receive or Transmit mode is enabled or disabled.\r
  81                                            This parameter can be a value of @ref IRDA_Mode */\r
  82   \r
  83   uint8_t  Prescaler;                 /*!< Specifies the Prescaler value for dividing the UART/USART source clock\r
  84                                            to achieve low-power frequency.\r
  85                                            @note Prescaler value 0 is forbidden */\r
  86   \r
  87   uint16_t PowerMode;                 /*!< Specifies the IRDA power mode.\r
  88                                            This parameter can be a value of @ref IRDA_Low_Power */\r
  89 }IRDA_InitTypeDef;\r
  90 \r
  91 /** \r
  92   * @brief HAL State structures definition  \r
  93   */ \r
  94 typedef enum\r
  95 {\r
  96   HAL_IRDA_STATE_RESET             = 0x00,    /*!< Peripheral is not yet Initialized */\r
  97   HAL_IRDA_STATE_READY             = 0x01,    /*!< Peripheral Initialized and ready for use */\r
  98   HAL_IRDA_STATE_BUSY              = 0x02,    /*!< An internal process is ongoing */\r
  99   HAL_IRDA_STATE_BUSY_TX           = 0x12,    /*!< Data Transmission process is ongoing */\r
 100   HAL_IRDA_STATE_BUSY_RX           = 0x22,    /*!< Data Reception process is ongoing */\r
 101   HAL_IRDA_STATE_BUSY_TX_RX        = 0x32,    /*!< Data Transmission and Reception process is ongoing */\r
 102   HAL_IRDA_STATE_TIMEOUT           = 0x03,    /*!< Timeout state */\r
 103   HAL_IRDA_STATE_ERROR             = 0x04     /*!< Error */\r
 104 }HAL_IRDA_StateTypeDef;\r
 105 \r
 106 /**\r
 107   * @brief IRDA clock sources definition\r
 108   */\r
 109 typedef enum\r
 110 {\r
 111   IRDA_CLOCKSOURCE_PCLK1      = 0x00,    /*!< PCLK1 clock source  */\r
 112   IRDA_CLOCKSOURCE_PCLK2      = 0x01,    /*!< PCLK2 clock source  */\r
 113   IRDA_CLOCKSOURCE_HSI        = 0x02,    /*!< HSI clock source    */\r
 114   IRDA_CLOCKSOURCE_SYSCLK     = 0x04,    /*!< SYSCLK clock source */\r
 115   IRDA_CLOCKSOURCE_LSE        = 0x08     /*!< LSE clock source     */\r
 116 }IRDA_ClockSourceTypeDef;\r
 117 \r
 118 /** \r
 119   * @brief  IRDA handle Structure definition  \r
 120   */\r
 121 typedef struct\r
 122 {\r
 123   USART_TypeDef            *Instance;        /* IRDA registers base address        */\r
 124 \r
 125   IRDA_InitTypeDef         Init;             /* IRDA communication parameters      */\r
 126 \r
 127   uint8_t                  *pTxBuffPtr;      /* Pointer to IRDA Tx transfer Buffer */\r
 128 \r
 129   uint16_t                 TxXferSize;       /* IRDA Tx Transfer size              */\r
 130 \r
 131   uint16_t                 TxXferCount;      /* IRDA Tx Transfer Counter           */\r
 132 \r
 133   uint8_t                  *pRxBuffPtr;      /* Pointer to IRDA Rx transfer Buffer */\r
 134 \r
 135   uint16_t                 RxXferSize;       /* IRDA Rx Transfer size              */\r
 136 \r
 137   uint16_t                 RxXferCount;      /* IRDA Rx Transfer Counter           */\r
 138 \r
 139   uint16_t                 Mask;             /* IRDA RX RDR register mask         */\r
 140 \r
 141   DMA_HandleTypeDef        *hdmatx;          /* IRDA Tx DMA Handle parameters      */\r
 142 \r
 143   DMA_HandleTypeDef        *hdmarx;          /* IRDA Rx DMA Handle parameters      */\r
 144 \r
 145   HAL_LockTypeDef          Lock;             /* Locking object                     */\r
 146 \r
 147   __IO HAL_IRDA_StateTypeDef    State;       /* IRDA communication state           */\r
 148 \r
 149   __IO uint32_t    ErrorCode;   /* IRDA Error code                    */\r
 150 \r
 151 }IRDA_HandleTypeDef;\r
 152 \r
 153 /**\r
 154   * @}\r
 155   */ \r
 156 \r
 157 /** \r
 158   * @brief  IRDA Configuration enumeration values definition  \r
 159   */\r
 160 \r
 161 /* Exported constants --------------------------------------------------------*/\r
 162 /** @defgroup IRDA_Exported_Constants IRDA Exported constants\r
 163   * @{\r
 164   */\r
 165 /** @defgroup IRDA_Error_Code IRDA Error Code\r
 166   * @brief    IRDA Error Code \r
 167   * @{\r
 168   */ \r
 169 \r
 170 #define HAL_IRDA_ERROR_NONE      ((uint32_t)0x00000000)    /*!< No error            */\r
 171 #define HAL_IRDA_ERROR_PE        ((uint32_t)0x00000001)    /*!< Parity error        */\r
 172 #define HAL_IRDA_ERROR_NE        ((uint32_t)0x00000002)    /*!< Noise error         */\r
 173 #define HAL_IRDA_ERROR_FE        ((uint32_t)0x00000004)    /*!< frame error         */\r
 174 #define HAL_IRDA_ERROR_ORE       ((uint32_t)0x00000008)    /*!< Overrun error       */\r
 175 #define HAL_IRDA_ERROR_DMA       ((uint32_t)0x00000010)    /*!< DMA transfer error  */\r
 176 /**\r
 177   * @}\r
 178   */\r
 179 \r
 180 /** @defgroup IRDA_Parity IRDA Parity\r
 181   * @{\r
 182   */ \r
 183 #define IRDA_PARITY_NONE                    ((uint32_t)0x0000)\r
 184 #define IRDA_PARITY_EVEN                    ((uint32_t)USART_CR1_PCE)\r
 185 #define IRDA_PARITY_ODD                     ((uint32_t)(USART_CR1_PCE | USART_CR1_PS)) \r
 186 /**\r
 187   * @}\r
 188   */ \r
 189 \r
 190 \r
 191 /** @defgroup IRDA_Transfer_Mode IRDA Transfer Mode\r
 192   * @{\r
 193   */ \r
 194 #define IRDA_MODE_RX                        ((uint32_t)USART_CR1_RE)\r
 195 #define IRDA_MODE_TX                        ((uint32_t)USART_CR1_TE)\r
 196 #define IRDA_MODE_TX_RX                     ((uint32_t)(USART_CR1_TE |USART_CR1_RE))\r
 197 /**\r
 198   * @}\r
 199   */\r
 200 \r
 201 /** @defgroup IRDA_Low_Power IRDA Low Power\r
 202   * @{\r
 203   */\r
 204 #define IRDA_POWERMODE_NORMAL                    ((uint32_t)0x0000)\r
 205 #define IRDA_POWERMODE_LOWPOWER                  ((uint32_t)USART_CR3_IRLP)\r
 206 /**\r
 207   * @}\r
 208   */\r
 209     \r
 210  /** @defgroup IRDA_State IRDA State\r
 211   * @{\r
 212   */ \r
 213 #define IRDA_STATE_DISABLE                  ((uint32_t)0x0000)\r
 214 #define IRDA_STATE_ENABLE                   ((uint32_t)USART_CR1_UE)\r
 215 /**\r
 216   * @}\r
 217   */\r
 218 \r
 219  /** @defgroup IRDA_Mode IRDA Mode\r
 220   * @{\r
 221   */ \r
 222 #define IRDA_MODE_DISABLE                  ((uint32_t)0x0000)\r
 223 #define IRDA_MODE_ENABLE                   ((uint32_t)USART_CR3_IREN)\r
 224 /**\r
 225   * @}\r
 226   */\r
 227 \r
 228 /** @defgroup IRDA_One_Bit IRDA One Bit\r
 229   * @{\r
 230   */\r
 231 #define IRDA_ONE_BIT_SAMPLE_DISABLE          ((uint32_t)0x00000000)\r
 232 #define IRDA_ONE_BIT_SAMPLE_ENABLE           ((uint32_t)USART_CR3_ONEBIT)\r
 233 /**\r
 234   * @}\r
 235   */  \r
 236   \r
 237 /** @defgroup IRDA_DMA_Tx IRDA DMA Tx\r
 238   * @{\r
 239   */\r
 240 #define IRDA_DMA_TX_DISABLE          ((uint32_t)0x00000000)\r
 241 #define IRDA_DMA_TX_ENABLE           ((uint32_t)USART_CR3_DMAT)\r
 242 /**\r
 243   * @}\r
 244   */  \r
 245   \r
 246 /** @defgroup IRDA_DMA_Rx IRDA DMA Rx\r
 247   * @{\r
 248   */\r
 249 #define IRDA_DMA_RX_DISABLE           ((uint32_t)0x0000)\r
 250 #define IRDA_DMA_RX_ENABLE            ((uint32_t)USART_CR3_DMAR)\r
 251 /**\r
 252   * @}\r
 253   */\r
 254   \r
 255 /** @defgroup IRDA_Flags IRDA Flags\r
 256   *        Elements values convention: 0xXXXX\r
 257   *           - 0xXXXX  : Flag mask in the ISR register\r
 258   * @{\r
 259   */\r
 260 #define IRDA_FLAG_REACK                     ((uint32_t)0x00400000)\r
 261 #define IRDA_FLAG_TEACK                     ((uint32_t)0x00200000)  \r
 262 #define IRDA_FLAG_BUSY                      ((uint32_t)0x00010000)\r
 263 #define IRDA_FLAG_ABRF                      ((uint32_t)0x00008000)  \r
 264 #define IRDA_FLAG_ABRE                      ((uint32_t)0x00004000)\r
 265 #define IRDA_FLAG_TXE                       ((uint32_t)0x00000080)\r
 266 #define IRDA_FLAG_TC                        ((uint32_t)0x00000040)\r
 267 #define IRDA_FLAG_RXNE                      ((uint32_t)0x00000020)\r
 268 #define IRDA_FLAG_ORE                       ((uint32_t)0x00000008)\r
 269 #define IRDA_FLAG_NE                        ((uint32_t)0x00000004)\r
 270 #define IRDA_FLAG_FE                        ((uint32_t)0x00000002)\r
 271 #define IRDA_FLAG_PE                        ((uint32_t)0x00000001)\r
 272 /**\r
 273   * @}\r
 274   */ \r
 275 \r
 276 /** @defgroup IRDA_Interrupt_definition IRDA Interrupt definition\r
 277   *        Elements values convention: 0000ZZZZ0XXYYYYYb\r
 278   *           - YYYYY  : Interrupt source position in the XX register (5bits)\r
 279   *           - XX  : Interrupt source register (2bits)\r
 280   *                 - 01: CR1 register\r
 281   *                 - 10: CR2 register\r
 282   *                 - 11: CR3 register\r
 283   *           - ZZZZ  : Flag position in the ISR register(4bits)\r
 284   * @{   \r
 285   */  \r
 286 #define IRDA_IT_PE                          ((uint16_t)0x0028)\r
 287 #define IRDA_IT_TXE                         ((uint16_t)0x0727)\r
 288 #define IRDA_IT_TC                          ((uint16_t)0x0626)\r
 289 #define IRDA_IT_RXNE                        ((uint16_t)0x0525)\r
 290 #define IRDA_IT_IDLE                        ((uint16_t)0x0424)\r
 291 \r
 292 \r
 293                                 \r
 294 /**       Elements values convention: 000000000XXYYYYYb\r
 295   *           - YYYYY  : Interrupt source position in the XX register (5bits)\r
 296   *           - XX  : Interrupt source register (2bits)\r
 297   *                 - 01: CR1 register\r
 298   *                 - 10: CR2 register\r
 299   *                 - 11: CR3 register\r
 300   */\r
 301 #define IRDA_IT_ERR                         ((uint16_t)0x0060)\r
 302 \r
 303 /**       Elements values convention: 0000ZZZZ00000000b\r
 304   *           - ZZZZ  : Flag position in the ISR register(4bits)\r
 305   */\r
 306 #define IRDA_IT_ORE                         ((uint16_t)0x0300)\r
 307 #define IRDA_IT_NE                          ((uint16_t)0x0200)\r
 308 #define IRDA_IT_FE                          ((uint16_t)0x0100)\r
 309 /**\r
 310   * @}\r
 311   */\r
 312   \r
 313 /** @defgroup IRDA_IT_CLEAR_Flags IRDA IT CLEAR Flags\r
 314   * @{\r
 315   */\r
 316 #define IRDA_CLEAR_PEF                       USART_ICR_PECF            /*!< Parity Error Clear Flag */          \r
 317 #define IRDA_CLEAR_FEF                       USART_ICR_FECF            /*!< Framing Error Clear Flag */         \r
 318 #define IRDA_CLEAR_NEF                       USART_ICR_NCF             /*!< Noise detected Clear Flag */        \r
 319 #define IRDA_CLEAR_OREF                      USART_ICR_ORECF           /*!< OverRun Error Clear Flag */         \r
 320 #define IRDA_CLEAR_TCF                       USART_ICR_TCCF            /*!< Transmission Complete Clear Flag */ \r
 321 /**\r
 322   * @}\r
 323   */ \r
 324 \r
 325 \r
 326 \r
 327 /** @defgroup IRDA_Request_Parameters IRDA Request Parameters\r
 328   * @{\r
 329   */\r
 330 #define IRDA_AUTOBAUD_REQUEST            ((uint16_t)USART_RQR_ABRRQ)        /*!< Auto-Baud Rate Request */     \r
 331 #define IRDA_RXDATA_FLUSH_REQUEST        ((uint16_t)USART_RQR_RXFRQ)        /*!< Receive Data flush Request */ \r
 332 #define IRDA_TXDATA_FLUSH_REQUEST        ((uint16_t)USART_RQR_TXFRQ)        /*!< Transmit data flush Request */\r
 333 /**\r
 334   * @}\r
 335   */\r
 336   \r
 337 /**\r
 338  * @}\r
 339  */\r
 340 \r
 341   \r
 342 /* Exported macro ------------------------------------------------------------*/\r
 343 /** @defgroup IRDA_Exported_Macros IRDA Exported Macros\r
 344   * @{\r
 345   */\r
 346 \r
 347 /** @brief Reset IRDA handle state\r
 348   * @param  __HANDLE__: specifies the IRDA Handle.\r
 349   *         The Handle Instance which can be USART1 or USART2.\r
 350   * @retval None\r
 351   */\r
 352 #define __HAL_IRDA_RESET_HANDLE_STATE(__HANDLE__) ((__HANDLE__)->State = HAL_IRDA_STATE_RESET)\r
 353 \r
 354 /** @brief  Check whether the specified IRDA flag is set or not.\r
 355   * @param  __HANDLE__: specifies the IRDA Handle.\r
 356   *         The Handle Instance which can be USART1 or USART2.\r
 357   *         UART peripheral\r
 358   * @param  __FLAG__: specifies the flag to check.\r
 359   *        This parameter can be one of the following values:\r
 360   *            @arg IRDA_FLAG_REACK: Receive enable acknowledge flag\r
 361   *            @arg IRDA_FLAG_TEACK: Transmit enable acknowledge flag\r
 362   *            @arg IRDA_FLAG_BUSY:  Busy flag\r
 363   *            @arg IRDA_FLAG_ABRF:  Auto Baud rate detection flag\r
 364   *            @arg IRDA_FLAG_ABRE:  Auto Baud rate detection error flag\r
 365   *            @arg IRDA_FLAG_TXE:   Transmit data register empty flag\r
 366   *            @arg IRDA_FLAG_TC:    Transmission Complete flag\r
 367   *            @arg IRDA_FLAG_RXNE:  Receive data register not empty flag\r
 368   *            @arg IRDA_FLAG_IDLE:  Idle Line detection flag\r
 369   *            @arg IRDA_FLAG_ORE:   OverRun Error flag\r
 370   *            @arg IRDA_FLAG_NE:    Noise Error flag\r
 371   *            @arg IRDA_FLAG_FE:    Framing Error flag\r
 372   *            @arg IRDA_FLAG_PE:    Parity Error flag\r
 373   * @retval The new state of __FLAG__ (TRUE or FALSE).\r
 374   */\r
 375 #define __HAL_IRDA_GET_FLAG(__HANDLE__, __FLAG__) (((__HANDLE__)->Instance->ISR & (__FLAG__)) == (__FLAG__))   \r
 376 \r
 377 /** @brief  Enable the specified IRDA interrupt.\r
 378   * @param  __HANDLE__: specifies the IRDA Handle.\r
 379   *         The Handle Instance which can be USART1 or USART2.\r
 380   *         UART peripheral\r
 381   * @param  __INTERRUPT__: specifies the IRDA interrupt source to enable.\r
 382   *          This parameter can be one of the following values:\r
 383   *            @arg IRDA_IT_TXE:  Transmit Data Register empty interrupt\r
 384   *            @arg IRDA_IT_TC:   Transmission complete interrupt\r
 385   *            @arg IRDA_IT_RXNE: Receive Data register not empty interrupt\r
 386   *            @arg IRDA_IT_IDLE: Idle line detection interrupt\r
 387   *            @arg IRDA_IT_PE:   Parity Error interrupt\r
 388   *            @arg IRDA_IT_ERR:  Error interrupt(Frame error, noise error, overrun error)\r
 389   * @retval None\r
 390   */\r
 391 #define __HAL_IRDA_ENABLE_IT(__HANDLE__, __INTERRUPT__) (((((uint8_t)(__INTERRUPT__)) >> 5) == 1)? ((__HANDLE__)->Instance->CR1 |= (1 << ((__INTERRUPT__) & IRDA_IT_MASK))): \\r
 392                                                           ((((uint8_t)(__INTERRUPT__)) >> 5) == 2)? ((__HANDLE__)->Instance->CR2 |= (1 << ((__INTERRUPT__) & IRDA_IT_MASK))): \\r
 393                                                           ((__HANDLE__)->Instance->CR3 |= (1 << ((__INTERRUPT__) & IRDA_IT_MASK))))\r
 394 \r
 395 /** @brief  Disable the specified IRDA interrupt.\r
 396   * @param  __HANDLE__: specifies the IRDA Handle.\r
 397   *         The Handle Instance which can be USART1 or USART2.\r
 398   * @param  __INTERRUPT__: specifies the IRDA interrupt source to disable.\r
 399   *          This parameter can be one of the following values:\r
 400   *            @arg IRDA_IT_TXE:  Transmit Data Register empty interrupt\r
 401   *            @arg IRDA_IT_TC:   Transmission complete interrupt\r
 402   *            @arg IRDA_IT_RXNE: Receive Data register not empty interrupt\r
 403   *            @arg IRDA_IT_IDLE: Idle line detection interrupt\r
 404   *            @arg IRDA_IT_PE:   Parity Error interrupt\r
 405   *            @arg IRDA_IT_ERR:  Error interrupt(Frame error, noise error, overrun error)\r
 406   * @retval None\r
 407   */\r
 408 #define __HAL_IRDA_DISABLE_IT(__HANDLE__, __INTERRUPT__)  (((((uint8_t)(__INTERRUPT__)) >> 5) == 1)? ((__HANDLE__)->Instance->CR1 &= ~ ((uint32_t)1 << ((__INTERRUPT__) & IRDA_IT_MASK))): \\r
 409                                                            ((((uint8_t)(__INTERRUPT__)) >> 5) == 2)? ((__HANDLE__)->Instance->CR2 &= ~ ((uint32_t)1 << ((__INTERRUPT__) & IRDA_IT_MASK))): \\r
 410                                                            ((__HANDLE__)->Instance->CR3 &= ~ ((uint32_t)1 << ((__INTERRUPT__) & IRDA_IT_MASK))))\r
 411 \r
 412 /** @brief  Check whether the specified IRDA interrupt has occurred or not.\r
 413   * @param  __HANDLE__: specifies the IRDA Handle.\r
 414   *         The Handle Instance which can be USART1 or USART2.\r
 415   * @param  __IT__: specifies the IRDA interrupt source to check.\r
 416   *          This parameter can be one of the following values:\r
 417   *            @arg IRDA_IT_TXE: Transmit Data Register empty interrupt\r
 418   *            @arg IRDA_IT_TC:  Transmission complete interrupt\r
 419   *            @arg IRDA_IT_RXNE: Receive Data register not empty interrupt\r
 420   *            @arg IRDA_IT_IDLE: Idle line detection interrupt\r
 421   *            @arg IRDA_IT_ORE: OverRun Error interrupt\r
 422   *            @arg IRDA_IT_NE: Noise Error interrupt\r
 423   *            @arg IRDA_IT_FE: Framing Error interrupt\r
 424   *            @arg IRDA_IT_PE: Parity Error interrupt  \r
 425   * @retval The new state of __IT__ (TRUE or FALSE).\r
 426   */\r
 427 #define __HAL_IRDA_GET_IT(__HANDLE__, __IT__) ((__HANDLE__)->Instance->ISR & ((uint32_t)1 << ((__IT__)>> 0x08))) \r
 428 \r
 429 /** @brief  Check whether the specified IRDA interrupt source is enabled.\r
 430   * @param  __HANDLE__: specifies the IRDA Handle.\r
 431   *         The Handle Instance which can be USART1 or USART2.\r
 432   * @param  __IT__: specifies the IRDA interrupt source to check.\r
 433   *          This parameter can be one of the following values:\r
 434   *            @arg IRDA_IT_TXE: Transmit Data Register empty interrupt\r
 435   *            @arg IRDA_IT_TC:  Transmission complete interrupt\r
 436   *            @arg IRDA_IT_RXNE: Receive Data register not empty interrupt\r
 437   *            @arg IRDA_IT_IDLE: Idle line detection interrupt\r
 438   *            @arg IRDA_IT_ORE: OverRun Error interrupt\r
 439   *            @arg IRDA_IT_NE: Noise Error interrupt\r
 440   *            @arg IRDA_IT_FE: Framing Error interrupt\r
 441   *            @arg IRDA_IT_PE: Parity Error interrupt  \r
 442   * @retval The new state of __IT__ (TRUE or FALSE).\r
 443   */\r
 444 #define __HAL_IRDA_GET_IT_SOURCE(__HANDLE__, __IT__) ((((((uint8_t)(__IT__)) >> 5) == 1)? (__HANDLE__)->Instance->CR1:(((((uint8_t)(__IT__)) >> 5) == 2)? \\r
 445                                                           (__HANDLE__)->Instance->CR2 : (__HANDLE__)->Instance->CR3)) & ((uint32_t)1 << (((uint16_t)(__IT__)) & IRDA_IT_MASK)))\r
 446 \r
 447 /** @brief  Clear the specified IRDA ISR flag, in setting the proper ICR register flag.\r
 448   * @param  __HANDLE__: specifies the IRDA Handle.\r
 449   *         The Handle Instance which can be USART1 or USART2.\r
 450   * @param  __IT_CLEAR__: specifies the interrupt clear register flag that needs to be set\r
 451   *                       to clear the corresponding interrupt\r
 452   *          This parameter can be one of the following values:\r
 453   *            @arg IRDA_CLEAR_PEF: Parity Error Clear Flag\r
 454   *            @arg IRDA_CLEAR_FEF: Framing Error Clear Flag\r
 455   *            @arg IRDA_CLEAR_NEF: Noise detected Clear Flag\r
 456   *            @arg IRDA_CLEAR_OREF: OverRun Error Clear Flag\r
 457   *            @arg IRDA_CLEAR_TCF: Transmission Complete Clear Flag \r
 458   * @retval None\r
 459   */\r
 460 #define __HAL_IRDA_CLEAR_IT(__HANDLE__, __IT_CLEAR__) ((__HANDLE__)->Instance->ICR |= (uint32_t)(__IT_CLEAR__))\r
 461 \r
 462 /** @brief  Set a specific IRDA request flag.\r
 463   * @param  __HANDLE__: specifies the IRDA Handle.\r
 464   *         The Handle Instance which can be USART1 or USART2.\r
 465   * @param  __REQ__: specifies the request flag to set\r
 466   *          This parameter can be one of the following values:\r
 467   *            @arg IRDA_AUTOBAUD_REQUEST: Auto-Baud Rate Request     \r
 468   *            @arg IRDA_RXDATA_FLUSH_REQUEST: Receive Data flush Request \r
 469   *            @arg IRDA_TXDATA_FLUSH_REQUEST: Transmit data flush Request \r
 470   *\r
 471   * @retval None\r
 472   */\r
 473 #define __HAL_IRDA_SEND_REQ(__HANDLE__, __REQ__) ((__HANDLE__)->Instance->RQR |= (uint16_t)(__REQ__)) \r
 474 \r
 475 /** @brief  Enable UART/USART associated to IRDA Handle\r
 476   * @param  __HANDLE__: specifies the IRDA Handle.\r
 477   *         The Handle Instance which can be USART1 or USART2.\r
 478   * @retval None\r
 479   */\r
 480 #define __HAL_IRDA_ENABLE(__HANDLE__)                   ((__HANDLE__)->Instance->CR1 |=  USART_CR1_UE)\r
 481 \r
 482 /** @brief  Disable UART/USART associated to IRDA Handle\r
 483   * @param  __HANDLE__: specifies the IRDA Handle.\r
 484   *         The Handle Instance which can be USART1 or USART2.\r
 485   * @retval None\r
 486   */\r
 487 #define __HAL_IRDA_DISABLE(__HANDLE__)                  ((__HANDLE__)->Instance->CR1 &=  ~USART_CR1_UE)\r
 488 \r
 489 /**\r
 490   * @}\r
 491   */\r
 492 \r
 493 /* Include IRDA HAL Extension module */\r
 494 #include "stm32f7xx_hal_irda_ex.h"  \r
 495 \r
 496 /* Exported functions --------------------------------------------------------*/\r
 497 /** @addtogroup IRDA_Exported_Functions IRDA Exported Functions\r
 498   * @{\r
 499   */\r
 500 \r
 501 /** @addtogroup IRDA_Exported_Functions_Group1 Initialization and de-initialization functions\r
 502   * @{\r
 503   */\r
 504 \r
 505 /* Initialization and de-initialization functions  ****************************/\r
 506 HAL_StatusTypeDef HAL_IRDA_Init(IRDA_HandleTypeDef *hirda);\r
 507 HAL_StatusTypeDef HAL_IRDA_DeInit(IRDA_HandleTypeDef *hirda);\r
 508 void HAL_IRDA_MspInit(IRDA_HandleTypeDef *hirda);\r
 509 void HAL_IRDA_MspDeInit(IRDA_HandleTypeDef *hirda);\r
 510 /**\r
 511   * @}\r
 512   */\r
 513 \r
 514 /** @addtogroup IRDA_Exported_Functions_Group2 IO operation functions\r
 515   * @{\r
 516   */\r
 517 \r
 518 /* IO operation functions *****************************************************/\r
 519 HAL_StatusTypeDef HAL_IRDA_Transmit(IRDA_HandleTypeDef *hirda, uint8_t *pData, uint16_t Size, uint32_t Timeout);\r
 520 HAL_StatusTypeDef HAL_IRDA_Receive(IRDA_HandleTypeDef *hirda, uint8_t *pData, uint16_t Size, uint32_t Timeout);\r
 521 HAL_StatusTypeDef HAL_IRDA_Transmit_IT(IRDA_HandleTypeDef *hirda, uint8_t *pData, uint16_t Size);\r
 522 HAL_StatusTypeDef HAL_IRDA_Receive_IT(IRDA_HandleTypeDef *hirda, uint8_t *pData, uint16_t Size);\r
 523 HAL_StatusTypeDef HAL_IRDA_Transmit_DMA(IRDA_HandleTypeDef *hirda, uint8_t *pData, uint16_t Size);\r
 524 HAL_StatusTypeDef HAL_IRDA_Receive_DMA(IRDA_HandleTypeDef *hirda, uint8_t *pData, uint16_t Size);\r
 525 HAL_StatusTypeDef HAL_IRDA_DMAPause(IRDA_HandleTypeDef *hirda);\r
 526 HAL_StatusTypeDef HAL_IRDA_DMAResume(IRDA_HandleTypeDef *hirda);\r
 527 HAL_StatusTypeDef HAL_IRDA_DMAStop(IRDA_HandleTypeDef *hirda);\r
 528 void HAL_IRDA_IRQHandler(IRDA_HandleTypeDef *hirda);\r
 529 void HAL_IRDA_TxCpltCallback(IRDA_HandleTypeDef *hirda);\r
 530 void HAL_IRDA_RxCpltCallback(IRDA_HandleTypeDef *hirda);\r
 531 void HAL_IRDA_TxHalfCpltCallback(IRDA_HandleTypeDef *hirda);\r
 532 void HAL_IRDA_RxHalfCpltCallback(IRDA_HandleTypeDef *hirda);\r
 533 void HAL_IRDA_ErrorCallback(IRDA_HandleTypeDef *hirda);\r
 534 /**\r
 535  * @}\r
 536  */\r
 537 \r
 538 /** @addtogroup IRDA_Exported_Functions_Group3 Control functions\r
 539  * @{\r
 540  */\r
 541 /* Peripheral State methods  **************************************************/\r
 542 HAL_IRDA_StateTypeDef HAL_IRDA_GetState(IRDA_HandleTypeDef *hirda);\r
 543 uint32_t HAL_IRDA_GetError(IRDA_HandleTypeDef *hirda);\r
 544 /**\r
 545   * @}\r
 546   */\r
 547 \r
 548 /**\r
 549   * @}\r
 550   */\r
 551 \r
 552 /* Private types -------------------------------------------------------------*/\r
 553 /* Private variables ---------------------------------------------------------*/\r
 554 /* Private constants ---------------------------------------------------------*/\r
 555 /** @defgroup IRDA_Private_Constants IRDA Private Constants\r
 556   * @{\r
 557   */\r
 558 \r
 559 /** @defgroup IRDA_Interruption_Mask IRDA Interruption Mask\r
 560   * @{\r
 561   */ \r
 562 #define IRDA_IT_MASK  ((uint16_t)0x001F)  \r
 563 /**\r
 564   * @}\r
 565   */\r
 566 /**\r
 567   * @}\r
 568   */\r
 569 \r
 570 /* Private macros --------------------------------------------------------*/\r
 571 /** @defgroup IRDA_Private_Macros   IRDA Private Macros\r
 572   * @{\r
 573   */\r
 574 \r
 575 /** @brief  Ensure that IRDA Baud rate is less or equal to maximum value\r
 576   * @param  __BAUDRATE__: specifies the IRDA Baudrate set by the user.\r
 577   * @retval True or False\r
 578   */   \r
 579 #define IS_IRDA_BAUDRATE(__BAUDRATE__) ((__BAUDRATE__) < 115201)\r
 580 \r
 581 /** @brief  Ensure that IRDA prescaler value is strictly larger than 0\r
 582   * @param  __PRESCALER__: specifies the IRDA prescaler value set by the user.\r
 583   * @retval True or False\r
 584   */  \r
 585 #define IS_IRDA_PRESCALER(__PRESCALER__) ((__PRESCALER__) > 0)\r
 586 \r
 587 #define IS_IRDA_PARITY(__PARITY__) (((__PARITY__) == IRDA_PARITY_NONE) || \\r
 588                                     ((__PARITY__) == IRDA_PARITY_EVEN) || \\r
 589                                     ((__PARITY__) == IRDA_PARITY_ODD))\r
 590                                                                 \r
 591 #define IS_IRDA_TX_RX_MODE(__MODE__) ((((__MODE__) & (~((uint32_t)(IRDA_MODE_TX_RX)))) == (uint32_t)0x00) && ((__MODE__) != (uint32_t)0x00))\r
 592 \r
 593 #define IS_IRDA_POWERMODE(__MODE__) (((__MODE__) == IRDA_POWERMODE_LOWPOWER) || \\r
 594                                      ((__MODE__) == IRDA_POWERMODE_NORMAL))\r
 595                                                                          \r
 596 #define IS_IRDA_STATE(__STATE__) (((__STATE__) == IRDA_STATE_DISABLE) || \\r
 597                                   ((__STATE__) == IRDA_STATE_ENABLE))\r
 598                                                                   \r
 599 #define IS_IRDA_MODE(__STATE__)  (((__STATE__) == IRDA_MODE_DISABLE) || \\r
 600                                   ((__STATE__) == IRDA_MODE_ENABLE))\r
 601                                                                   \r
 602 #define IS_IRDA_ONE_BIT_SAMPLE(__ONEBIT__)     (((__ONEBIT__) == IRDA_ONE_BIT_SAMPLE_DISABLE) || \\r
 603                                                ((__ONEBIT__) == IRDA_ONE_BIT_SAMPLE_ENABLE))\r
 604 \r
 605 #define IS_IRDA_DMA_TX(__DMATX__)     (((__DMATX__) == IRDA_DMA_TX_DISABLE) || \\r
 606                                        ((__DMATX__) == IRDA_DMA_TX_ENABLE))             \r
 607 \r
 608 #define IS_IRDA_DMA_RX(__DMARX__)     (((__DMARX__) == IRDA_DMA_RX_DISABLE) || \\r
 609                                        ((__DMARX__) == IRDA_DMA_RX_ENABLE))\r
 610 \r
 611 #define IS_IRDA_REQUEST_PARAMETER(PARAM) (((PARAM) == IRDA_AUTOBAUD_REQUEST) || \\r
 612                                           ((PARAM) == IRDA_SENDBREAK_REQUEST) || \\r
 613                                           ((PARAM) == IRDA_MUTE_MODE_REQUEST) || \\r
 614                                           ((PARAM) == IRDA_RXDATA_FLUSH_REQUEST) || \\r
 615                                           ((PARAM) == IRDA_TXDATA_FLUSH_REQUEST))                                                                          \r
 616 /**\r
 617  * @}\r
 618  */\r
 619 \r
 620 /* Private functions ---------------------------------------------------------*/\r
 621 /** @defgroup IRDA_Private_Functions IRDA Private Functions\r
 622   * @{\r
 623   */\r
 624 \r
 625 /**\r
 626   * @}\r
 627   */\r
 628 \r
 629 /**\r
 630   * @}\r
 631   */ \r
 632 \r
 633 /**\r
 634   * @}\r
 635   */ \r
 636 \r
 637 #ifdef __cplusplus\r
 638 }\r
 639 #endif\r
 640 \r
 641 #endif /* __STM32F7xx_HAL_IRDA_H */\r
 642 \r
 643 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/\r