git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/CORTEX_M7_STM32F7_STM32756G-EVAL/ST_Library/include/stm32f7xx_hal_uart.h

   1 /**\r
   2   ******************************************************************************\r
   3   * @file    stm32f7xx_hal_uart.h\r
   4   * @author  MCD Application Team\r
   5   * @version V0.3.0\r
   6   * @date    06-March-2015\r
   7   * @brief   Header file of UART 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_UART_H\r
  40 #define __STM32F7xx_HAL_UART_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 UART\r
  54   * @{\r
  55   */\r
  56 \r
  57 /* Exported types ------------------------------------------------------------*/\r
  58 /** @defgroup UART_Exported_Types UART Exported Types\r
  59   * @{\r
  60   */\r
  61 \r
  62 /**\r
  63   * @brief UART Init Structure definition\r
  64   */\r
  65 typedef struct\r
  66 {\r
  67   uint32_t BaudRate;                  /*!< This member configures the UART communication baud rate.\r
  68                                            The baud rate register is computed using the following formula:\r
  69                                            - If oversampling is 16 or in LIN mode,\r
  70                                               Baud Rate Register = ((PCLKx) / ((huart->Init.BaudRate)))\r
  71                                            - If oversampling is 8,\r
  72                                               Baud Rate Register[15:4] = ((2 * PCLKx) / ((huart->Init.BaudRate)))[15:4]\r
  73                                               Baud Rate Register[3] =  0\r
  74                                               Baud Rate Register[2:0] =  (((2 * PCLKx) / ((huart->Init.BaudRate)))[3:0]) >> 1      */\r
  75 \r
  76   uint32_t WordLength;                /*!< Specifies the number of data bits transmitted or received in a frame.\r
  77                                            This parameter can be a value of @ref UARTEx_Word_Length */\r
  78 \r
  79   uint32_t StopBits;                  /*!< Specifies the number of stop bits transmitted.\r
  80                                            This parameter can be a value of @ref UART_Stop_Bits */\r
  81 \r
  82   uint32_t Parity;                    /*!< Specifies the parity mode.\r
  83                                            This parameter can be a value of @ref UART_Parity\r
  84                                            @note When parity is enabled, the computed parity is inserted\r
  85                                                  at the MSB position of the transmitted data (9th bit when\r
  86                                                  the word length is set to 9 data bits; 8th bit when the\r
  87                                                  word length is set to 8 data bits). */\r
  88 \r
  89   uint32_t Mode;                      /*!< Specifies whether the Receive or Transmit mode is enabled or disabled.\r
  90                                            This parameter can be a value of @ref UART_Mode */\r
  91 \r
  92   uint32_t HwFlowCtl;                 /*!< Specifies whether the hardware flow control mode is enabled\r
  93                                            or disabled.\r
  94                                            This parameter can be a value of @ref UART_Hardware_Flow_Control */\r
  95 \r
  96   uint32_t OverSampling;              /*!< Specifies whether the Over sampling 8 is enabled or disabled, to achieve higher speed (up to fPCLK/8).\r
  97                                            This parameter can be a value of @ref UART_Over_Sampling */\r
  98 \r
  99   uint32_t OneBitSampling;            /*!< Specifies whether a single sample or three samples' majority vote is selected.\r
 100                                            Selecting the single sample method increases the receiver tolerance to clock\r
 101                                            deviations. This parameter can be a value of @ref UART_OneBit_Sampling */\r
 102 }UART_InitTypeDef;\r
 103 \r
 104 /**\r
 105   * @brief  UART Advanced Features initalization structure definition\r
 106   */\r
 107 typedef struct\r
 108 {\r
 109   uint32_t AdvFeatureInit;        /*!< Specifies which advanced UART features is initialized. Several\r
 110                                        Advanced Features may be initialized at the same time .\r
 111                                        This parameter can be a value of @ref UART_Advanced_Features_Initialization_Type */\r
 112 \r
 113   uint32_t TxPinLevelInvert;      /*!< Specifies whether the TX pin active level is inverted.\r
 114                                        This parameter can be a value of @ref UART_Tx_Inv  */\r
 115 \r
 116   uint32_t RxPinLevelInvert;      /*!< Specifies whether the RX pin active level is inverted.\r
 117                                        This parameter can be a value of @ref UART_Rx_Inv  */\r
 118 \r
 119   uint32_t DataInvert;            /*!< Specifies whether data are inverted (positive/direct logic\r
 120                                        vs negative/inverted logic).\r
 121                                        This parameter can be a value of @ref UART_Data_Inv */\r
 122 \r
 123   uint32_t Swap;                  /*!< Specifies whether TX and RX pins are swapped.\r
 124                                        This parameter can be a value of @ref UART_Rx_Tx_Swap */\r
 125 \r
 126   uint32_t OverrunDisable;        /*!< Specifies whether the reception overrun detection is disabled.\r
 127                                        This parameter can be a value of @ref UART_Overrun_Disable */\r
 128 \r
 129   uint32_t DMADisableonRxError;   /*!< Specifies whether the DMA is disabled in case of reception error.\r
 130                                        This parameter can be a value of @ref UART_DMA_Disable_on_Rx_Error */\r
 131 \r
 132   uint32_t AutoBaudRateEnable;    /*!< Specifies whether auto Baud rate detection is enabled.\r
 133                                        This parameter can be a value of @ref UART_AutoBaudRate_Enable */\r
 134 \r
 135   uint32_t AutoBaudRateMode;      /*!< If auto Baud rate detection is enabled, specifies how the rate\r
 136                                        detection is carried out.\r
 137                                        This parameter can be a value of @ref UART_AutoBaud_Rate_Mode */\r
 138 \r
 139   uint32_t MSBFirst;              /*!< Specifies whether MSB is sent first on UART line.\r
 140                                        This parameter can be a value of @ref UART_MSB_First */\r
 141 } UART_AdvFeatureInitTypeDef;\r
 142 \r
 143 \r
 144 \r
 145 /**\r
 146   * @brief HAL UART State structures definition\r
 147   */\r
 148 typedef enum\r
 149 {\r
 150   HAL_UART_STATE_RESET             = 0x00,    /*!< Peripheral is not initialized                      */\r
 151   HAL_UART_STATE_READY             = 0x01,    /*!< Peripheral Initialized and ready for use           */\r
 152   HAL_UART_STATE_BUSY              = 0x02,    /*!< an internal process is ongoing                     */\r
 153   HAL_UART_STATE_BUSY_TX           = 0x12,    /*!< Data Transmission process is ongoing               */\r
 154   HAL_UART_STATE_BUSY_RX           = 0x22,    /*!< Data Reception process is ongoing                  */\r
 155   HAL_UART_STATE_BUSY_TX_RX        = 0x32,    /*!< Data Transmission and Reception process is ongoing */\r
 156   HAL_UART_STATE_TIMEOUT           = 0x03,    /*!< Timeout state                                      */\r
 157   HAL_UART_STATE_ERROR             = 0x04     /*!< Error                                              */\r
 158 }HAL_UART_StateTypeDef;\r
 159 \r
 160 /**\r
 161   * @brief UART clock sources definition\r
 162   */\r
 163 typedef enum\r
 164 {\r
 165   UART_CLOCKSOURCE_PCLK1      = 0x00,    /*!< PCLK1 clock source  */\r
 166   UART_CLOCKSOURCE_PCLK2      = 0x01,    /*!< PCLK2 clock source  */\r
 167   UART_CLOCKSOURCE_HSI        = 0x02,    /*!< HSI clock source    */\r
 168   UART_CLOCKSOURCE_SYSCLK     = 0x04,    /*!< SYSCLK clock source */\r
 169   UART_CLOCKSOURCE_LSE        = 0x08,    /*!< LSE clock source       */\r
 170   UART_CLOCKSOURCE_UNDEFINED  = 0x10     /*!< Undefined clock source */\r
 171 }UART_ClockSourceTypeDef;\r
 172 \r
 173 /**\r
 174   * @brief  UART handle Structure definition\r
 175   */\r
 176 typedef struct\r
 177 {\r
 178   USART_TypeDef            *Instance;        /*!< UART registers base address        */\r
 179 \r
 180   UART_InitTypeDef         Init;             /*!< UART communication parameters      */\r
 181 \r
 182   UART_AdvFeatureInitTypeDef AdvancedInit;   /*!< UART Advanced Features initialization parameters */\r
 183 \r
 184   uint8_t                  *pTxBuffPtr;      /*!< Pointer to UART Tx transfer Buffer */\r
 185 \r
 186   uint16_t                 TxXferSize;       /*!< UART Tx Transfer size              */\r
 187 \r
 188   uint16_t                 TxXferCount;      /*!< UART Tx Transfer Counter           */\r
 189 \r
 190   uint8_t                  *pRxBuffPtr;      /*!< Pointer to UART Rx transfer Buffer */\r
 191 \r
 192   uint16_t                 RxXferSize;       /*!< UART Rx Transfer size              */\r
 193 \r
 194   uint16_t                 RxXferCount;      /*!< UART Rx Transfer Counter           */\r
 195 \r
 196   uint16_t                 Mask;             /*!< UART Rx RDR register mask          */\r
 197 \r
 198   DMA_HandleTypeDef        *hdmatx;          /*!< UART Tx DMA Handle parameters      */\r
 199 \r
 200   DMA_HandleTypeDef        *hdmarx;          /*!< UART Rx DMA Handle parameters      */\r
 201 \r
 202   HAL_LockTypeDef           Lock;            /*!< Locking object                     */\r
 203 \r
 204   __IO HAL_UART_StateTypeDef    State;       /*!< UART communication state           */\r
 205 \r
 206   __IO uint32_t             ErrorCode;   /*!< UART Error code                    */\r
 207 \r
 208 }UART_HandleTypeDef;\r
 209 \r
 210 /**\r
 211   * @}\r
 212   */\r
 213 \r
 214 /* Exported constants --------------------------------------------------------*/\r
 215 /** @defgroup UART_Exported_Constants UART Exported Constants\r
 216   * @{\r
 217   */\r
 218 /** @defgroup UART_Error_Definition   UART Error Definition\r
 219   * @{\r
 220   */\r
 221 #define  HAL_UART_ERROR_NONE       ((uint32_t)0x00000000)    /*!< No error            */\r
 222 #define  HAL_UART_ERROR_PE         ((uint32_t)0x00000001)    /*!< Parity error        */\r
 223 #define  HAL_UART_ERROR_NE         ((uint32_t)0x00000002)    /*!< Noise error         */\r
 224 #define  HAL_UART_ERROR_FE         ((uint32_t)0x00000004)    /*!< frame error         */\r
 225 #define  HAL_UART_ERROR_ORE        ((uint32_t)0x00000008)    /*!< Overrun error       */\r
 226 #define  HAL_UART_ERROR_DMA        ((uint32_t)0x00000010)    /*!< DMA transfer error  */\r
 227 /**\r
 228   * @}\r
 229   */\r
 230 /** @defgroup UART_Stop_Bits   UART Number of Stop Bits\r
 231   * @{\r
 232   */\r
 233 #define UART_STOPBITS_1                     ((uint32_t)0x0000)\r
 234 #define UART_STOPBITS_2                     ((uint32_t)USART_CR2_STOP_1)\r
 235 /**\r
 236   * @}\r
 237   */\r
 238 \r
 239 /** @defgroup UART_Parity  UART Parity\r
 240   * @{\r
 241   */\r
 242 #define UART_PARITY_NONE                    ((uint32_t)0x00000000)\r
 243 #define UART_PARITY_EVEN                    ((uint32_t)USART_CR1_PCE)\r
 244 #define UART_PARITY_ODD                     ((uint32_t)(USART_CR1_PCE | USART_CR1_PS))\r
 245 /**\r
 246   * @}\r
 247   */\r
 248 \r
 249 /** @defgroup UART_Hardware_Flow_Control UART Hardware Flow Control\r
 250   * @{\r
 251   */\r
 252 #define UART_HWCONTROL_NONE                  ((uint32_t)0x00000000)\r
 253 #define UART_HWCONTROL_RTS                   ((uint32_t)USART_CR3_RTSE)\r
 254 #define UART_HWCONTROL_CTS                   ((uint32_t)USART_CR3_CTSE)\r
 255 #define UART_HWCONTROL_RTS_CTS               ((uint32_t)(USART_CR3_RTSE | USART_CR3_CTSE))\r
 256 /**\r
 257   * @}\r
 258   */\r
 259 \r
 260 /** @defgroup UART_Mode UART Transfer Mode\r
 261   * @{\r
 262   */\r
 263 #define UART_MODE_RX                        ((uint32_t)USART_CR1_RE)\r
 264 #define UART_MODE_TX                        ((uint32_t)USART_CR1_TE)\r
 265 #define UART_MODE_TX_RX                     ((uint32_t)(USART_CR1_TE |USART_CR1_RE))\r
 266 /**\r
 267   * @}\r
 268   */\r
 269 \r
 270  /** @defgroup UART_State  UART State\r
 271   * @{\r
 272   */\r
 273 #define UART_STATE_DISABLE                  ((uint32_t)0x00000000)\r
 274 #define UART_STATE_ENABLE                   ((uint32_t)USART_CR1_UE)\r
 275 /**\r
 276   * @}\r
 277   */\r
 278 \r
 279 /** @defgroup UART_Over_Sampling UART Over Sampling\r
 280   * @{\r
 281   */\r
 282 #define UART_OVERSAMPLING_16                ((uint32_t)0x00000000)\r
 283 #define UART_OVERSAMPLING_8                 ((uint32_t)USART_CR1_OVER8)\r
 284 /**\r
 285   * @}\r
 286   */\r
 287 \r
 288 /** @defgroup UART_OneBit_Sampling UART One Bit Sampling Method\r
 289   * @{\r
 290   */\r
 291 #define UART_ONE_BIT_SAMPLE_DISABLE         ((uint32_t)0x00000000)\r
 292 #define UART_ONE_BIT_SAMPLE_ENABLE          ((uint32_t)USART_CR3_ONEBIT)\r
 293 /**\r
 294   * @}\r
 295   */\r
 296 \r
 297 /** @defgroup UART_AutoBaud_Rate_Mode    UART Advanced Feature AutoBaud Rate Mode\r
 298   * @{\r
 299   */\r
 300 #define UART_ADVFEATURE_AUTOBAUDRATE_ONSTARTBIT    ((uint32_t)0x0000)\r
 301 #define UART_ADVFEATURE_AUTOBAUDRATE_ONFALLINGEDGE ((uint32_t)USART_CR2_ABRMODE_0)\r
 302 #define UART_ADVFEATURE_AUTOBAUDRATE_ON0X7FFRAME   ((uint32_t)USART_CR2_ABRMODE_1)\r
 303 #define UART_ADVFEATURE_AUTOBAUDRATE_ON0X55FRAME   ((uint32_t)USART_CR2_ABRMODE)\r
 304 /**\r
 305   * @}\r
 306   */\r
 307 \r
 308 /** @defgroup UART_Receiver_TimeOut UART Receiver TimeOut\r
 309   * @{\r
 310   */\r
 311 #define UART_RECEIVER_TIMEOUT_DISABLE       ((uint32_t)0x00000000)\r
 312 #define UART_RECEIVER_TIMEOUT_ENABLE        ((uint32_t)USART_CR2_RTOEN)\r
 313 /**\r
 314   * @}\r
 315   */\r
 316 \r
 317 /** @defgroup UART_LIN    UART Local Interconnection Network mode\r
 318   * @{\r
 319   */\r
 320 #define UART_LIN_DISABLE                    ((uint32_t)0x00000000)\r
 321 #define UART_LIN_ENABLE                     ((uint32_t)USART_CR2_LINEN)\r
 322 /**\r
 323   * @}\r
 324   */\r
 325 \r
 326 /** @defgroup UART_LIN_Break_Detection  UART LIN Break Detection\r
 327   * @{\r
 328   */\r
 329 #define UART_LINBREAKDETECTLENGTH_10B       ((uint32_t)0x00000000)\r
 330 #define UART_LINBREAKDETECTLENGTH_11B       ((uint32_t)USART_CR2_LBDL)\r
 331 /**\r
 332   * @}\r
 333   */\r
 334 \r
 335 /** @defgroup UART_DMA_Tx    UART DMA Tx\r
 336   * @{\r
 337   */\r
 338 #define UART_DMA_TX_DISABLE                 ((uint32_t)0x00000000)\r
 339 #define UART_DMA_TX_ENABLE                  ((uint32_t)USART_CR3_DMAT)\r
 340 /**\r
 341   * @}\r
 342   */\r
 343 \r
 344 /** @defgroup UART_DMA_Rx   UART DMA Rx\r
 345   * @{\r
 346   */\r
 347 #define UART_DMA_RX_DISABLE                 ((uint32_t)0x0000)\r
 348 #define UART_DMA_RX_ENABLE                  ((uint32_t)USART_CR3_DMAR)\r
 349 /**\r
 350   * @}\r
 351   */\r
 352 \r
 353 /** @defgroup UART_Half_Duplex_Selection  UART Half Duplex Selection\r
 354   * @{\r
 355   */\r
 356 #define UART_HALF_DUPLEX_DISABLE            ((uint32_t)0x0000)\r
 357 #define UART_HALF_DUPLEX_ENABLE             ((uint32_t)USART_CR3_HDSEL)\r
 358 /**\r
 359   * @}\r
 360   */\r
 361 \r
 362 /** @defgroup UART_WakeUp_Methods   UART WakeUp Methods\r
 363   * @{\r
 364   */\r
 365 #define UART_WAKEUPMETHOD_IDLELINE          ((uint32_t)0x00000000)\r
 366 #define UART_WAKEUPMETHOD_ADDRESSMARK       ((uint32_t)USART_CR1_WAKE)\r
 367 /**\r
 368   * @}\r
 369   */\r
 370 \r
 371 /** @defgroup UART_Request_Parameters UART Request Parameters\r
 372   * @{\r
 373   */\r
 374 #define UART_AUTOBAUD_REQUEST               ((uint32_t)USART_RQR_ABRRQ)        /*!< Auto-Baud Rate Request */\r
 375 #define UART_SENDBREAK_REQUEST              ((uint32_t)USART_RQR_SBKRQ)        /*!< Send Break Request */\r
 376 #define UART_MUTE_MODE_REQUEST              ((uint32_t)USART_RQR_MMRQ)         /*!< Mute Mode Request */\r
 377 #define UART_RXDATA_FLUSH_REQUEST           ((uint32_t)USART_RQR_RXFRQ)        /*!< Receive Data flush Request */\r
 378 #define UART_TXDATA_FLUSH_REQUEST           ((uint32_t)USART_RQR_TXFRQ)        /*!< Transmit data flush Request */\r
 379 /**\r
 380   * @}\r
 381   */\r
 382 \r
 383 /** @defgroup UART_Advanced_Features_Initialization_Type  UART Advanced Feature Initialization Type\r
 384   * @{\r
 385   */\r
 386 #define UART_ADVFEATURE_NO_INIT                 ((uint32_t)0x00000000)\r
 387 #define UART_ADVFEATURE_TXINVERT_INIT           ((uint32_t)0x00000001)\r
 388 #define UART_ADVFEATURE_RXINVERT_INIT           ((uint32_t)0x00000002)\r
 389 #define UART_ADVFEATURE_DATAINVERT_INIT         ((uint32_t)0x00000004)\r
 390 #define UART_ADVFEATURE_SWAP_INIT               ((uint32_t)0x00000008)\r
 391 #define UART_ADVFEATURE_RXOVERRUNDISABLE_INIT   ((uint32_t)0x00000010)\r
 392 #define UART_ADVFEATURE_DMADISABLEONERROR_INIT  ((uint32_t)0x00000020)\r
 393 #define UART_ADVFEATURE_AUTOBAUDRATE_INIT       ((uint32_t)0x00000040)\r
 394 #define UART_ADVFEATURE_MSBFIRST_INIT           ((uint32_t)0x00000080)\r
 395 /**\r
 396   * @}\r
 397   */\r
 398 \r
 399 /** @defgroup UART_Tx_Inv UART Advanced Feature TX Pin Active Level Inversion\r
 400   * @{\r
 401   */\r
 402 #define UART_ADVFEATURE_TXINV_DISABLE       ((uint32_t)0x00000000)\r
 403 #define UART_ADVFEATURE_TXINV_ENABLE        ((uint32_t)USART_CR2_TXINV)\r
 404 /**\r
 405   * @}\r
 406   */\r
 407 \r
 408 /** @defgroup UART_Rx_Inv UART Advanced Feature RX Pin Active Level Inversion\r
 409   * @{\r
 410   */\r
 411 #define UART_ADVFEATURE_RXINV_DISABLE       ((uint32_t)0x00000000)\r
 412 #define UART_ADVFEATURE_RXINV_ENABLE        ((uint32_t)USART_CR2_RXINV)\r
 413 /**\r
 414   * @}\r
 415   */\r
 416 \r
 417 /** @defgroup UART_Data_Inv  UART Advanced Feature Binary Data Inversion\r
 418   * @{\r
 419   */\r
 420 #define UART_ADVFEATURE_DATAINV_DISABLE     ((uint32_t)0x00000000)\r
 421 #define UART_ADVFEATURE_DATAINV_ENABLE      ((uint32_t)USART_CR2_DATAINV)\r
 422 /**\r
 423   * @}\r
 424   */\r
 425 \r
 426 /** @defgroup UART_Rx_Tx_Swap UART Advanced Feature RX TX Pins Swap\r
 427   * @{\r
 428   */\r
 429 #define UART_ADVFEATURE_SWAP_DISABLE        ((uint32_t)0x00000000)\r
 430 #define UART_ADVFEATURE_SWAP_ENABLE         ((uint32_t)USART_CR2_SWAP)\r
 431 /**\r
 432   * @}\r
 433   */\r
 434 \r
 435 /** @defgroup UART_Overrun_Disable  UART Advanced Feature Overrun Disable\r
 436   * @{\r
 437   */\r
 438 #define UART_ADVFEATURE_OVERRUN_ENABLE      ((uint32_t)0x00000000)\r
 439 #define UART_ADVFEATURE_OVERRUN_DISABLE     ((uint32_t)USART_CR3_OVRDIS)\r
 440 /**\r
 441   * @}\r
 442   */\r
 443 \r
 444 /** @defgroup UART_AutoBaudRate_Enable  UART Advanced Feature Auto BaudRate Enable\r
 445   * @{\r
 446   */\r
 447 #define UART_ADVFEATURE_AUTOBAUDRATE_DISABLE   ((uint32_t)0x00000000)\r
 448 #define UART_ADVFEATURE_AUTOBAUDRATE_ENABLE    ((uint32_t)USART_CR2_ABREN)\r
 449 /**\r
 450   * @}\r
 451   */\r
 452 \r
 453 /** @defgroup UART_DMA_Disable_on_Rx_Error   UART Advanced Feature DMA Disable On Rx Error\r
 454   * @{\r
 455   */\r
 456 #define UART_ADVFEATURE_DMA_ENABLEONRXERROR    ((uint32_t)0x00000000)\r
 457 #define UART_ADVFEATURE_DMA_DISABLEONRXERROR   ((uint32_t)USART_CR3_DDRE)\r
 458 /**\r
 459   * @}\r
 460   */\r
 461 \r
 462 /** @defgroup UART_MSB_First   UART Advanced Feature MSB First\r
 463   * @{\r
 464   */\r
 465 #define UART_ADVFEATURE_MSBFIRST_DISABLE    ((uint32_t)0x00000000)\r
 466 #define UART_ADVFEATURE_MSBFIRST_ENABLE     ((uint32_t)USART_CR2_MSBFIRST)\r
 467 /**\r
 468   * @}\r
 469   */\r
 470 \r
 471 /** @defgroup UART_Mute_Mode   UART Advanced Feature Mute Mode Enable\r
 472   * @{\r
 473   */\r
 474 #define UART_ADVFEATURE_MUTEMODE_DISABLE    ((uint32_t)0x00000000)\r
 475 #define UART_ADVFEATURE_MUTEMODE_ENABLE     ((uint32_t)USART_CR1_MME)\r
 476 /**\r
 477   * @}\r
 478   */\r
 479 \r
 480 /** @defgroup UART_CR2_ADDRESS_LSB_POS    UART Address-matching LSB Position In CR2 Register\r
 481   * @{\r
 482   */\r
 483 #define UART_CR2_ADDRESS_LSB_POS            ((uint32_t) 24)\r
 484 /**\r
 485   * @}\r
 486   */\r
 487 \r
 488 /** @defgroup UART_DriverEnable_Polarity      UART DriverEnable Polarity\r
 489   * @{\r
 490   */\r
 491 #define UART_DE_POLARITY_HIGH               ((uint32_t)0x00000000)\r
 492 #define UART_DE_POLARITY_LOW                ((uint32_t)USART_CR3_DEP)\r
 493 /**\r
 494   * @}\r
 495   */\r
 496 \r
 497 /** @defgroup UART_CR1_DEAT_ADDRESS_LSB_POS    UART Driver Enable Assertion Time LSB Position In CR1 Register\r
 498   * @{\r
 499   */\r
 500 #define UART_CR1_DEAT_ADDRESS_LSB_POS       ((uint32_t) 21)\r
 501 /**\r
 502   * @}\r
 503   */\r
 504 \r
 505 /** @defgroup UART_CR1_DEDT_ADDRESS_LSB_POS    UART Driver Enable DeAssertion Time LSB Position In CR1 Register\r
 506   * @{\r
 507   */\r
 508 #define UART_CR1_DEDT_ADDRESS_LSB_POS       ((uint32_t) 16)\r
 509 /**\r
 510   * @}\r
 511   */\r
 512 \r
 513 /** @defgroup UART_Interruption_Mask    UART Interruptions Flag Mask\r
 514   * @{\r
 515   */\r
 516 #define UART_IT_MASK                        ((uint32_t)0x001F)\r
 517 /**\r
 518   * @}\r
 519   */\r
 520 \r
 521 /** @defgroup UART_TimeOut_Value    UART polling-based communications time-out value\r
 522   * @{\r
 523   */\r
 524 #define HAL_UART_TIMEOUT_VALUE              0x1FFFFFF\r
 525 /**\r
 526   * @}\r
 527   */\r
 528 \r
 529 /** @defgroup UART_Flags     UART Status Flags\r
 530   *        Elements values convention: 0xXXXX\r
 531   *           - 0xXXXX  : Flag mask in the ISR register\r
 532   * @{\r
 533   */\r
 534 #define UART_FLAG_TEACK                     ((uint32_t)0x00200000)\r
 535 #define UART_FLAG_SBKF                      ((uint32_t)0x00040000\r
 536 #define UART_FLAG_CMF                       ((uint32_t)0x00020000)\r
 537 #define UART_FLAG_BUSY                      ((uint32_t)0x00010000)\r
 538 #define UART_FLAG_ABRF                      ((uint32_t)0x00008000)\r
 539 #define UART_FLAG_ABRE                      ((uint32_t)0x00004000)\r
 540 #define UART_FLAG_EOBF                      ((uint32_t)0x00001000)\r
 541 #define UART_FLAG_RTOF                      ((uint32_t)0x00000800)\r
 542 #define UART_FLAG_CTS                       ((uint32_t)0x00000400)\r
 543 #define UART_FLAG_CTSIF                     ((uint32_t)0x00000200)\r
 544 #define UART_FLAG_LBDF                      ((uint32_t)0x00000100)\r
 545 #define UART_FLAG_TXE                       ((uint32_t)0x00000080)\r
 546 #define UART_FLAG_TC                        ((uint32_t)0x00000040)\r
 547 #define UART_FLAG_RXNE                      ((uint32_t)0x00000020)\r
 548 #define UART_FLAG_IDLE                      ((uint32_t)0x00000010)\r
 549 #define UART_FLAG_ORE                       ((uint32_t)0x00000008)\r
 550 #define UART_FLAG_NE                        ((uint32_t)0x00000004)\r
 551 #define UART_FLAG_FE                        ((uint32_t)0x00000002)\r
 552 #define UART_FLAG_PE                        ((uint32_t)0x00000001)\r
 553 /**\r
 554   * @}\r
 555   */\r
 556 \r
 557 /** @defgroup UART_Interrupt_definition   UART Interrupts Definition\r
 558   *        Elements values convention: 0000ZZZZ0XXYYYYYb\r
 559   *           - YYYYY  : Interrupt source position in the XX register (5bits)\r
 560   *           - XX  : Interrupt source register (2bits)\r
 561   *                 - 01: CR1 register\r
 562   *                 - 10: CR2 register\r
 563   *                 - 11: CR3 register\r
 564   *           - ZZZZ  : Flag position in the ISR register(4bits)\r
 565   * @{\r
 566   */\r
 567 #define UART_IT_PE                          ((uint32_t)0x0028)\r
 568 #define UART_IT_TXE                         ((uint32_t)0x0727)\r
 569 #define UART_IT_TC                          ((uint32_t)0x0626)\r
 570 #define UART_IT_RXNE                        ((uint32_t)0x0525)\r
 571 #define UART_IT_IDLE                        ((uint32_t)0x0424)\r
 572 #define UART_IT_LBD                         ((uint32_t)0x0846)\r
 573 #define UART_IT_CTS                         ((uint32_t)0x096A)\r
 574 #define UART_IT_CM                          ((uint32_t)0x112E)\r
 575 \r
 576 /**       Elements values convention: 000000000XXYYYYYb\r
 577   *           - YYYYY  : Interrupt source position in the XX register (5bits)\r
 578   *           - XX  : Interrupt source register (2bits)\r
 579   *                 - 01: CR1 register\r
 580   *                 - 10: CR2 register\r
 581   *                 - 11: CR3 register\r
 582   */\r
 583 #define UART_IT_ERR                         ((uint32_t)0x0060)\r
 584 \r
 585 /**       Elements values convention: 0000ZZZZ00000000b\r
 586   *           - ZZZZ  : Flag position in the ISR register(4bits)\r
 587   */\r
 588 #define UART_IT_ORE                         ((uint32_t)0x0300)\r
 589 #define UART_IT_NE                          ((uint32_t)0x0200)\r
 590 #define UART_IT_FE                          ((uint32_t)0x0100)\r
 591 /**\r
 592   * @}\r
 593   */\r
 594 \r
 595 /** @defgroup UART_IT_CLEAR_Flags  UART Interruption Clear Flags\r
 596   * @{\r
 597   */\r
 598 #define UART_CLEAR_PEF                       USART_ICR_PECF            /*!< Parity Error Clear Flag */\r
 599 #define UART_CLEAR_FEF                       USART_ICR_FECF            /*!< Framing Error Clear Flag */\r
 600 #define UART_CLEAR_NEF                       USART_ICR_NCF             /*!< Noise detected Clear Flag */\r
 601 #define UART_CLEAR_OREF                      USART_ICR_ORECF           /*!< OverRun Error Clear Flag */\r
 602 #define UART_CLEAR_IDLEF                     USART_ICR_IDLECF          /*!< IDLE line detected Clear Flag */\r
 603 #define UART_CLEAR_TCF                       USART_ICR_TCCF            /*!< Transmission Complete Clear Flag */\r
 604 #define UART_CLEAR_LBDF                      USART_ICR_LBDCF           /*!< LIN Break Detection Clear Flag */\r
 605 #define UART_CLEAR_CTSF                      USART_ICR_CTSCF           /*!< CTS Interrupt Clear Flag */\r
 606 #define UART_CLEAR_RTOF                      USART_ICR_RTOCF           /*!< Receiver Time Out Clear Flag */\r
 607 #define UART_CLEAR_EOBF                      USART_ICR_EOBCF           /*!< End Of Block Clear Flag */\r
 608 #define UART_CLEAR_CMF                       USART_ICR_CMCF            /*!< Character Match Clear Flag */\r
 609 /**\r
 610   * @}\r
 611   */\r
 612 \r
 613 \r
 614 /**\r
 615   * @}\r
 616   */\r
 617 \r
 618 /* Exported macros -----------------------------------------------------------*/\r
 619 /** @defgroup UART_Exported_Macros UART Exported Macros\r
 620   * @{\r
 621   */\r
 622 \r
 623 /** @brief Reset UART handle state\r
 624   * @param  __HANDLE__: UART handle.\r
 625   * @retval None\r
 626   */\r
 627 #define __HAL_UART_RESET_HANDLE_STATE(__HANDLE__) ((__HANDLE__)->State = HAL_UART_STATE_RESET)\r
 628 \r
 629 /** @brief  Flush the UART Data registers\r
 630   * @param  __HANDLE__: specifies the UART Handle.\r
 631   */\r
 632 #define __HAL_UART_FLUSH_DRREGISTER(__HANDLE__)  \\r
 633   do{                \\r
 634       SET_BIT((__HANDLE__)->Instance->RQR, UART_RXDATA_FLUSH_REQUEST); \\r
 635       SET_BIT((__HANDLE__)->Instance->RQR, UART_TXDATA_FLUSH_REQUEST); \\r
 636     }  while(0)\r
 637 \r
 638 /** @brief  Clears the specified UART ISR flag, in setting the proper ICR register flag.\r
 639   * @param  __HANDLE__: specifies the UART Handle.\r
 640   * @param  __FLAG__: specifies the interrupt clear register flag that needs to be set\r
 641   *                       to clear the corresponding interrupt\r
 642   *          This parameter can be one of the following values:\r
 643   *            @arg UART_CLEAR_PEF: Parity Error Clear Flag\r
 644   *            @arg UART_CLEAR_FEF: Framing Error Clear Flag\r
 645   *            @arg UART_CLEAR_NEF: Noise detected Clear Flag\r
 646   *            @arg UART_CLEAR_OREF: OverRun Error Clear Flag\r
 647   *            @arg UART_CLEAR_IDLEF: IDLE line detected Clear Flag\r
 648   *            @arg UART_CLEAR_TCF: Transmission Complete Clear Flag\r
 649   *            @arg UART_CLEAR_LBDF: LIN Break Detection Clear Flag\r
 650   *            @arg UART_CLEAR_CTSF: CTS Interrupt Clear Flag\r
 651   *            @arg UART_CLEAR_RTOF: Receiver Time Out Clear Flag\r
 652   *            @arg UART_CLEAR_EOBF: End Of Block Clear Flag\r
 653   *            @arg UART_CLEAR_CMF: Character Match Clear Flag\r
 654   * @retval None\r
 655   */\r
 656 #define __HAL_UART_CLEAR_IT(__HANDLE__, __FLAG__) ((__HANDLE__)->Instance->ICR = ~(__FLAG__))\r
 657 \r
 658 /** @brief  Clear the UART PE pending flag.\r
 659   * @param  __HANDLE__: specifies the UART Handle.\r
 660   * @retval None\r
 661   */\r
 662 #define __HAL_UART_CLEAR_PEFLAG(__HANDLE__)   __HAL_UART_CLEAR_IT((__HANDLE__),UART_CLEAR_PEF)\r
 663 \r
 664 /** @brief  Clear the UART FE pending flag.\r
 665   * @param  __HANDLE__: specifies the UART Handle.\r
 666   * @retval None\r
 667   */\r
 668 #define __HAL_UART_CLEAR_FEFLAG(__HANDLE__)   __HAL_UART_CLEAR_IT((__HANDLE__),UART_CLEAR_FEF)\r
 669 \r
 670 /** @brief  Clear the UART NE pending flag.\r
 671   * @param  __HANDLE__: specifies the UART Handle.\r
 672   * @retval None\r
 673   */\r
 674 #define __HAL_UART_CLEAR_NEFLAG(__HANDLE__)  __HAL_UART_CLEAR_IT((__HANDLE__),UART_CLEAR_NEF)\r
 675 \r
 676 /** @brief  Clear the UART ORE pending flag.\r
 677   * @param  __HANDLE__: specifies the UART Handle.\r
 678   * @retval None\r
 679   */\r
 680 #define __HAL_UART_CLEAR_OREFLAG(__HANDLE__)   __HAL_UART_CLEAR_IT((__HANDLE__),UART_CLEAR_OREF)\r
 681 \r
 682 /** @brief  Clear the UART IDLE pending flag.\r
 683   * @param  __HANDLE__: specifies the UART Handle.\r
 684   * @retval None\r
 685   */\r
 686 #define __HAL_UART_CLEAR_IDLEFLAG(__HANDLE__)   __HAL_UART_CLEAR_IT((__HANDLE__),UART_CLEAR_IDLEF)\r
 687 \r
 688 /** @brief  Checks whether the specified UART flag is set or not.\r
 689   * @param  __HANDLE__: specifies the UART Handle.\r
 690   * @param  __FLAG__: specifies the flag to check.\r
 691   *        This parameter can be one of the following values:\r
 692   *            @arg UART_FLAG_REACK: Receive enable acknowledge flag\r
 693   *            @arg UART_FLAG_TEACK: Transmit enable acknowledge flag\r
 694   *            @arg UART_FLAG_WUF:   Wake up from stop mode flag\r
 695   *            @arg UART_FLAG_RWU:   Receiver wake up flag (is the UART in mute mode)\r
 696   *            @arg UART_FLAG_SBKF:  Send Break flag\r
 697   *            @arg UART_FLAG_CMF:   Character match flag\r
 698   *            @arg UART_FLAG_BUSY:  Busy flag\r
 699   *            @arg UART_FLAG_ABRF:  Auto Baud rate detection flag\r
 700   *            @arg UART_FLAG_ABRE:  Auto Baud rate detection error flag\r
 701   *            @arg UART_FLAG_EOBF:  End of block flag\r
 702   *            @arg UART_FLAG_RTOF:  Receiver timeout flag\r
 703   *            @arg UART_FLAG_CTS:   CTS Change flag (not available for UART4 and UART5)\r
 704   *            @arg UART_FLAG_LBD:   LIN Break detection flag\r
 705   *            @arg UART_FLAG_TXE:   Transmit data register empty flag\r
 706   *            @arg UART_FLAG_TC:    Transmission Complete flag\r
 707   *            @arg UART_FLAG_RXNE:  Receive data register not empty flag\r
 708   *            @arg UART_FLAG_IDLE:  Idle Line detection flag\r
 709   *            @arg UART_FLAG_ORE:   OverRun Error flag\r
 710   *            @arg UART_FLAG_NE:    Noise Error flag\r
 711   *            @arg UART_FLAG_FE:    Framing Error flag\r
 712   *            @arg UART_FLAG_PE:    Parity Error flag\r
 713   * @retval The new state of __FLAG__ (TRUE or FALSE).\r
 714   */\r
 715 #define __HAL_UART_GET_FLAG(__HANDLE__, __FLAG__) (((__HANDLE__)->Instance->ISR & (__FLAG__)) == (__FLAG__))\r
 716 \r
 717 /** @brief  Enables the specified UART interrupt.\r
 718   * @param  __HANDLE__: specifies the UART Handle.\r
 719   * @param  __INTERRUPT__: specifies the UART interrupt source to enable.\r
 720   *          This parameter can be one of the following values:\r
 721   *            @arg UART_IT_WUF:  Wakeup from stop mode interrupt\r
 722   *            @arg UART_IT_CM:   Character match interrupt\r
 723   *            @arg UART_IT_CTS:  CTS change interrupt\r
 724   *            @arg UART_IT_LBD:  LIN Break detection interrupt\r
 725   *            @arg UART_IT_TXE:  Transmit Data Register empty interrupt\r
 726   *            @arg UART_IT_TC:   Transmission complete interrupt\r
 727   *            @arg UART_IT_RXNE: Receive Data register not empty interrupt\r
 728   *            @arg UART_IT_IDLE: Idle line detection interrupt\r
 729   *            @arg UART_IT_PE:   Parity Error interrupt\r
 730   *            @arg UART_IT_ERR:  Error interrupt(Frame error, noise error, overrun error)\r
 731   * @retval None\r
 732   */\r
 733 #define __HAL_UART_ENABLE_IT(__HANDLE__, __INTERRUPT__)   (((((uint8_t)(__INTERRUPT__)) >> 5U) == 1)? ((__HANDLE__)->Instance->CR1 |= (1U << ((__INTERRUPT__) & UART_IT_MASK))): \\r
 734                                                            ((((uint8_t)(__INTERRUPT__)) >> 5U) == 2)? ((__HANDLE__)->Instance->CR2 |= (1U << ((__INTERRUPT__) & UART_IT_MASK))): \\r
 735                                                            ((__HANDLE__)->Instance->CR3 |= (1U << ((__INTERRUPT__) & UART_IT_MASK))))\r
 736 \r
 737 \r
 738 /** @brief  Disables the specified UART interrupt.\r
 739   * @param  __HANDLE__: specifies the UART Handle.\r
 740   * @param  __INTERRUPT__: specifies the UART interrupt source to disable.\r
 741   *          This parameter can be one of the following values:\r
 742   *            @arg UART_IT_CM:   Character match interrupt\r
 743   *            @arg UART_IT_CTS:  CTS change interrupt\r
 744   *            @arg UART_IT_LBD:  LIN Break detection interrupt\r
 745   *            @arg UART_IT_TXE:  Transmit Data Register empty interrupt\r
 746   *            @arg UART_IT_TC:   Transmission complete interrupt\r
 747   *            @arg UART_IT_RXNE: Receive Data register not empty interrupt\r
 748   *            @arg UART_IT_IDLE: Idle line detection interrupt\r
 749   *            @arg UART_IT_PE:   Parity Error interrupt\r
 750   *            @arg UART_IT_ERR:  Error interrupt(Frame error, noise error, overrun error)\r
 751   * @retval None\r
 752   */\r
 753 #define __HAL_UART_DISABLE_IT(__HANDLE__, __INTERRUPT__)  (((((uint8_t)(__INTERRUPT__)) >> 5U) == 1)? ((__HANDLE__)->Instance->CR1 &= ~ (1U << ((__INTERRUPT__) & UART_IT_MASK))): \\r
 754                                                            ((((uint8_t)(__INTERRUPT__)) >> 5U) == 2)? ((__HANDLE__)->Instance->CR2 &= ~ (1U << ((__INTERRUPT__) & UART_IT_MASK))): \\r
 755                                                            ((__HANDLE__)->Instance->CR3 &= ~ (1U << ((__INTERRUPT__) & UART_IT_MASK))))\r
 756 \r
 757 /** @brief  Checks whether the specified UART interrupt has occurred or not.\r
 758   * @param  __HANDLE__: specifies the UART Handle.\r
 759   * @param  __IT__: specifies the UART interrupt to check.\r
 760   *          This parameter can be one of the following values:\r
 761   *            @arg UART_IT_CM:   Character match interrupt\r
 762   *            @arg UART_IT_CTS:  CTS change interrupt (not available for UART4 and UART5)\r
 763   *            @arg UART_IT_LBD:  LIN Break detection interrupt\r
 764   *            @arg UART_IT_TXE:  Transmit Data Register empty interrupt\r
 765   *            @arg UART_IT_TC:   Transmission complete interrupt\r
 766   *            @arg UART_IT_RXNE: Receive Data register not empty interrupt\r
 767   *            @arg UART_IT_IDLE: Idle line detection interrupt\r
 768   *            @arg UART_IT_ORE:  OverRun Error interrupt\r
 769   *            @arg UART_IT_NE:   Noise Error interrupt\r
 770   *            @arg UART_IT_FE:   Framing Error interrupt\r
 771   *            @arg UART_IT_PE:   Parity Error interrupt\r
 772   * @retval The new state of __IT__ (TRUE or FALSE).\r
 773   */\r
 774 #define __HAL_UART_GET_IT(__HANDLE__, __IT__) ((__HANDLE__)->Instance->ISR & ((uint32_t)1 << ((__IT__)>> 0x08)))\r
 775 \r
 776 /** @brief  Checks whether the specified UART interrupt source is enabled.\r
 777   * @param  __HANDLE__: specifies the UART Handle.\r
 778   * @param  __IT__: specifies the UART interrupt source to check.\r
 779   *          This parameter can be one of the following values:\r
 780   *            @arg UART_IT_CTS: CTS change interrupt (not available for UART4 and UART5)\r
 781   *            @arg UART_IT_LBD: LIN Break detection interrupt\r
 782   *            @arg UART_IT_TXE: Transmit Data Register empty interrupt\r
 783   *            @arg UART_IT_TC:  Transmission complete interrupt\r
 784   *            @arg UART_IT_RXNE: Receive Data register not empty interrupt\r
 785   *            @arg UART_IT_IDLE: Idle line detection interrupt\r
 786   *            @arg UART_IT_ORE: OverRun Error interrupt\r
 787   *            @arg UART_IT_NE: Noise Error interrupt\r
 788   *            @arg UART_IT_FE: Framing Error interrupt\r
 789   *            @arg UART_IT_PE: Parity Error interrupt\r
 790   * @retval The new state of __IT__ (TRUE or FALSE).\r
 791   */\r
 792 #define __HAL_UART_GET_IT_SOURCE(__HANDLE__, __IT__) ((((((uint8_t)(__IT__)) >> 5U) == 1)? (__HANDLE__)->Instance->CR1:(((((uint8_t)(__IT__)) >> 5U) == 2)? \\r
 793                                                        (__HANDLE__)->Instance->CR2 : (__HANDLE__)->Instance->CR3)) & ((uint32_t)1 << (((uint16_t)(__IT__)) & UART_IT_MASK)))\r
 794 \r
 795 /** @brief  Set a specific UART request flag.\r
 796   * @param  __HANDLE__: specifies the UART Handle.\r
 797   * @param  __REQ__: specifies the request flag to set\r
 798   *          This parameter can be one of the following values:\r
 799   *            @arg UART_AUTOBAUD_REQUEST: Auto-Baud Rate Request\r
 800   *            @arg UART_SENDBREAK_REQUEST: Send Break Request\r
 801   *            @arg UART_MUTE_MODE_REQUEST: Mute Mode Request\r
 802   *            @arg UART_RXDATA_FLUSH_REQUEST: Receive Data flush Request\r
 803   *            @arg UART_TXDATA_FLUSH_REQUEST: Transmit data flush Request\r
 804   * @retval None\r
 805   */\r
 806 #define __HAL_UART_SEND_REQ(__HANDLE__, __REQ__) ((__HANDLE__)->Instance->RQR |= (uint32_t)(__REQ__))\r
 807 \r
 808 /** @brief  Enables the UART one bit sample method\r
 809   * @param  __HANDLE__: specifies the UART Handle.  \r
 810   * @retval None\r
 811   */     \r
 812 #define __HAL_UART_ONE_BIT_SAMPLE_ENABLE(__HANDLE__) ((__HANDLE__)->Instance->CR3|= USART_CR3_ONEBIT)\r
 813 \r
 814 /** @brief  Disables the UART one bit sample method\r
 815   * @param  __HANDLE__: specifies the UART Handle.  \r
 816   * @retval None\r
 817   */      \r
 818 #define __HAL_UART_ONE_BIT_SAMPLE_DISABLE(__HANDLE__) ((__HANDLE__)->Instance->CR3 &= (uint32_t)~((uint32_t)USART_CR3_ONEBIT))\r
 819 \r
 820 /** @brief  Enable UART\r
 821   * @param  __HANDLE__: specifies the UART Handle.\r
 822   * @retval None\r
 823   */\r
 824 #define __HAL_UART_ENABLE(__HANDLE__)                   ((__HANDLE__)->Instance->CR1 |=  USART_CR1_UE)\r
 825 \r
 826 /** @brief  Disable UART\r
 827   * @param  __HANDLE__: specifies the UART Handle.\r
 828   * @retval None\r
 829   */\r
 830 #define __HAL_UART_DISABLE(__HANDLE__)                  ((__HANDLE__)->Instance->CR1 &=  ~USART_CR1_UE)\r
 831 \r
 832 /** @brief  Enable CTS flow control \r
 833   *         This macro allows to enable CTS hardware flow control for a given UART instance, \r
 834   *         without need to call HAL_UART_Init() function.\r
 835   *         As involving direct access to UART registers, usage of this macro should be fully endorsed by user.\r
 836   * @note   As macro is expected to be used for modifying CTS Hw flow control feature activation, without need\r
 837   *         for USART instance Deinit/Init, following conditions for macro call should be fulfilled :\r
 838   *           - UART instance should have already been initialised (through call of HAL_UART_Init() )\r
 839   *           - macro could only be called when corresponding UART instance is disabled (i.e __HAL_UART_DISABLE(__HANDLE__))\r
 840   *             and should be followed by an Enable macro (i.e __HAL_UART_ENABLE(__HANDLE__)).                                                                                                                  \r
 841   * @param  __HANDLE__: specifies the UART Handle.\r
 842   *         The Handle Instance can be USART1, USART2 or LPUART.\r
 843   * @retval None\r
 844   */\r
 845 #define __HAL_UART_HWCONTROL_CTS_ENABLE(__HANDLE__)        \\r
 846   do{                                                      \\r
 847     SET_BIT((__HANDLE__)->Instance->CR3, USART_CR3_CTSE);  \\r
 848     (__HANDLE__)->Init.HwFlowCtl |= USART_CR3_CTSE;        \\r
 849   } while(0)\r
 850 \r
 851 /** @brief  Disable CTS flow control \r
 852   *         This macro allows to disable CTS hardware flow control for a given UART instance, \r
 853   *         without need to call HAL_UART_Init() function.\r
 854   *         As involving direct access to UART registers, usage of this macro should be fully endorsed by user.\r
 855   * @note   As macro is expected to be used for modifying CTS Hw flow control feature activation, without need\r
 856   *         for USART instance Deinit/Init, following conditions for macro call should be fulfilled :\r
 857   *           - UART instance should have already been initialised (through call of HAL_UART_Init() )\r
 858   *           - macro could only be called when corresponding UART instance is disabled (i.e __HAL_UART_DISABLE(__HANDLE__))\r
 859   *             and should be followed by an Enable macro (i.e __HAL_UART_ENABLE(__HANDLE__)). \r
 860   * @param  __HANDLE__: specifies the UART Handle.\r
 861   *         The Handle Instance can be USART1, USART2 or LPUART.\r
 862   * @retval None\r
 863   */\r
 864 #define __HAL_UART_HWCONTROL_CTS_DISABLE(__HANDLE__)        \\r
 865   do{                                                       \\r
 866     CLEAR_BIT((__HANDLE__)->Instance->CR3, USART_CR3_CTSE); \\r
 867     (__HANDLE__)->Init.HwFlowCtl &= ~(USART_CR3_CTSE);      \\r
 868   } while(0)\r
 869 \r
 870 /** @brief  Enable RTS flow control \r
 871   *         This macro allows to enable RTS hardware flow control for a given UART instance, \r
 872   *         without need to call HAL_UART_Init() function.\r
 873   *         As involving direct access to UART registers, usage of this macro should be fully endorsed by user.\r
 874   * @note   As macro is expected to be used for modifying RTS Hw flow control feature activation, without need\r
 875   *         for USART instance Deinit/Init, following conditions for macro call should be fulfilled :\r
 876   *           - UART instance should have already been initialised (through call of HAL_UART_Init() )\r
 877   *           - macro could only be called when corresponding UART instance is disabled (i.e __HAL_UART_DISABLE(__HANDLE__))\r
 878   *             and should be followed by an Enable macro (i.e __HAL_UART_ENABLE(__HANDLE__)). \r
 879   * @param  __HANDLE__: specifies the UART Handle.\r
 880   *         The Handle Instance can be USART1, USART2 or LPUART.\r
 881   * @retval None\r
 882   */\r
 883 #define __HAL_UART_HWCONTROL_RTS_ENABLE(__HANDLE__)       \\r
 884   do{                                                     \\r
 885     SET_BIT((__HANDLE__)->Instance->CR3, USART_CR3_RTSE); \\r
 886     (__HANDLE__)->Init.HwFlowCtl |= USART_CR3_RTSE;       \\r
 887   } while(0)\r
 888 \r
 889 /** @brief  Disable RTS flow control \r
 890   *         This macro allows to disable RTS hardware flow control for a given UART instance, \r
 891   *         without need to call HAL_UART_Init() function.\r
 892   *         As involving direct access to UART registers, usage of this macro should be fully endorsed by user.\r
 893   * @note   As macro is expected to be used for modifying RTS Hw flow control feature activation, without need\r
 894   *         for USART instance Deinit/Init, following conditions for macro call should be fulfilled :\r
 895   *           - UART instance should have already been initialised (through call of HAL_UART_Init() )\r
 896   *           - macro could only be called when corresponding UART instance is disabled (i.e __HAL_UART_DISABLE(__HANDLE__))\r
 897   *             and should be followed by an Enable macro (i.e __HAL_UART_ENABLE(__HANDLE__)). \r
 898   * @param  __HANDLE__: specifies the UART Handle.\r
 899   *         The Handle Instance can be USART1, USART2 or LPUART.\r
 900   * @retval None\r
 901   */\r
 902 #define __HAL_UART_HWCONTROL_RTS_DISABLE(__HANDLE__)       \\r
 903   do{                                                      \\r
 904     CLEAR_BIT((__HANDLE__)->Instance->CR3, USART_CR3_RTSE);\\r
 905     (__HANDLE__)->Init.HwFlowCtl &= ~(USART_CR3_RTSE);     \\r
 906   } while(0)\r
 907 \r
 908 /**\r
 909   * @}\r
 910   */\r
 911 \r
 912 /* Private macros --------------------------------------------------------*/\r
 913 /** @defgroup UART_Private_Macros   UART Private Macros\r
 914   * @{\r
 915   */\r
 916 /** @brief  BRR division operation to set BRR register with LPUART\r
 917   * @param  _PCLK_: LPUART clock\r
 918   * @param  _BAUD_: Baud rate set by the user\r
 919   * @retval Division result\r
 920   */\r
 921 #define UART_DIV_LPUART(_PCLK_, _BAUD_)                (((_PCLK_)*256)/((_BAUD_)))\r
 922 \r
 923 /** @brief  BRR division operation to set BRR register in 8-bit oversampling mode\r
 924   * @param  _PCLK_: UART clock\r
 925   * @param  _BAUD_: Baud rate set by the user\r
 926   * @retval Division result\r
 927   */\r
 928 #define UART_DIV_SAMPLING8(_PCLK_, _BAUD_)             (((_PCLK_)*2)/((_BAUD_)))\r
 929 \r
 930 /** @brief  BRR division operation to set BRR register in 16-bit oversampling mode\r
 931   * @param  _PCLK_: UART clock\r
 932   * @param  _BAUD_: Baud rate set by the user\r
 933   * @retval Division result\r
 934   */\r
 935 #define UART_DIV_SAMPLING16(_PCLK_, _BAUD_)             (((_PCLK_))/((_BAUD_)))\r
 936 \r
 937 /** @brief  Check UART Baud rate\r
 938   * @param  BAUDRATE: Baudrate specified by the user\r
 939   *         The maximum Baud Rate is derived from the maximum clock on F7 (i.e. 200 MHz)\r
 940   *         divided by the smallest oversampling used on the USART (i.e. 8)\r
 941   * @retval Test result (TRUE or FALSE).\r
 942   */\r
 943 #define IS_UART_BAUDRATE(BAUDRATE) ((BAUDRATE) < 9000001)\r
 944 \r
 945 /** @brief  Check UART assertion time\r
 946   * @param  TIME: 5-bit value assertion time\r
 947   * @retval Test result (TRUE or FALSE).\r
 948   */\r
 949 #define IS_UART_ASSERTIONTIME(TIME)    ((TIME) <= 0x1F)\r
 950 \r
 951 /** @brief  Check UART deassertion time\r
 952   * @param  TIME: 5-bit value deassertion time\r
 953   * @retval Test result (TRUE or FALSE).\r
 954   */\r
 955 #define IS_UART_DEASSERTIONTIME(TIME) ((TIME) <= 0x1F)\r
 956 \r
 957 #define IS_UART_STOPBITS(STOPBITS) (((STOPBITS) == UART_STOPBITS_1) || \\r
 958                                     ((STOPBITS) == UART_STOPBITS_2))\r
 959 \r
 960 #define IS_UART_PARITY(PARITY) (((PARITY) == UART_PARITY_NONE) || \\r
 961                                 ((PARITY) == UART_PARITY_EVEN) || \\r
 962                                 ((PARITY) == UART_PARITY_ODD))\r
 963 \r
 964 #define IS_UART_HARDWARE_FLOW_CONTROL(CONTROL)\\r
 965                               (((CONTROL) == UART_HWCONTROL_NONE) || \\r
 966                                ((CONTROL) == UART_HWCONTROL_RTS) || \\r
 967                                ((CONTROL) == UART_HWCONTROL_CTS) || \\r
 968                                ((CONTROL) == UART_HWCONTROL_RTS_CTS))\r
 969 \r
 970 #define IS_UART_MODE(MODE) ((((MODE) & (~((uint32_t)(UART_MODE_TX_RX)))) == (uint32_t)0x00) && ((MODE) != (uint32_t)0x00))\r
 971 \r
 972 #define IS_UART_STATE(STATE) (((STATE) == UART_STATE_DISABLE) || \\r
 973                               ((STATE) == UART_STATE_ENABLE))\r
 974 \r
 975 #define IS_UART_OVERSAMPLING(SAMPLING) (((SAMPLING) == UART_OVERSAMPLING_16) || \\r
 976                                         ((SAMPLING) == UART_OVERSAMPLING_8))\r
 977 \r
 978 #define IS_UART_ONE_BIT_SAMPLE(ONEBIT) (((ONEBIT) == UART_ONE_BIT_SAMPLE_DISABLE) || \\r
 979                                         ((ONEBIT) == UART_ONE_BIT_SAMPLE_ENABLE))\r
 980 \r
 981 #define IS_UART_ADVFEATURE_AUTOBAUDRATEMODE(MODE)  (((MODE) == UART_ADVFEATURE_AUTOBAUDRATE_ONSTARTBIT) || \\r
 982                                                     ((MODE) == UART_ADVFEATURE_AUTOBAUDRATE_ONFALLINGEDGE) || \\r
 983                                                     ((MODE) == UART_ADVFEATURE_AUTOBAUDRATE_ON0X7FFRAME) || \\r
 984                                                     ((MODE) == UART_ADVFEATURE_AUTOBAUDRATE_ON0X55FRAME))\r
 985 \r
 986 #define IS_UART_RECEIVER_TIMEOUT(TIMEOUT) (((TIMEOUT) == UART_RECEIVER_TIMEOUT_DISABLE) || \\r
 987                                            ((TIMEOUT) == UART_RECEIVER_TIMEOUT_ENABLE))\r
 988 \r
 989 #define IS_UART_LIN(LIN)            (((LIN) == UART_LIN_DISABLE) || \\r
 990                                      ((LIN) == UART_LIN_ENABLE))\r
 991 \r
 992 #define IS_UART_WAKEUPMETHOD(WAKEUP) (((WAKEUP) == UART_WAKEUPMETHOD_IDLELINE) || \\r
 993                                       ((WAKEUP) == UART_WAKEUPMETHOD_ADDRESSMARK))\r
 994 \r
 995 #define IS_UART_LIN_BREAK_DETECT_LENGTH(LENGTH) (((LENGTH) == UART_LINBREAKDETECTLENGTH_10B) || \\r
 996                                                  ((LENGTH) == UART_LINBREAKDETECTLENGTH_11B))\r
 997 \r
 998 #define IS_UART_DMA_TX(DMATX)         (((DMATX) == UART_DMA_TX_DISABLE) || \\r
 999                                        ((DMATX) == UART_DMA_TX_ENABLE))\r
1000 \r
1001 #define IS_UART_DMA_RX(DMARX)         (((DMARX) == UART_DMA_RX_DISABLE) || \\r
1002                                        ((DMARX) == UART_DMA_RX_ENABLE))\r
1003 \r
1004 #define IS_UART_HALF_DUPLEX(HDSEL)         (((HDSEL) == UART_HALF_DUPLEX_DISABLE) || \\r
1005                                             ((HDSEL) == UART_HALF_DUPLEX_ENABLE))\r
1006 \r
1007 #define IS_UART_REQUEST_PARAMETER(PARAM) (((PARAM) == UART_AUTOBAUD_REQUEST) || \\r
1008                                           ((PARAM) == UART_SENDBREAK_REQUEST) || \\r
1009                                           ((PARAM) == UART_MUTE_MODE_REQUEST) || \\r
1010                                           ((PARAM) == UART_RXDATA_FLUSH_REQUEST) || \\r
1011                                           ((PARAM) == UART_TXDATA_FLUSH_REQUEST))\r
1012 \r
1013 #define IS_UART_ADVFEATURE_INIT(INIT)           ((INIT) <= (UART_ADVFEATURE_NO_INIT | \\r
1014                                                             UART_ADVFEATURE_TXINVERT_INIT | \\r
1015                                                             UART_ADVFEATURE_RXINVERT_INIT | \\r
1016                                                             UART_ADVFEATURE_DATAINVERT_INIT | \\r
1017                                                             UART_ADVFEATURE_SWAP_INIT | \\r
1018                                                             UART_ADVFEATURE_RXOVERRUNDISABLE_INIT | \\r
1019                                                             UART_ADVFEATURE_DMADISABLEONERROR_INIT   | \\r
1020                                                             UART_ADVFEATURE_AUTOBAUDRATE_INIT | \\r
1021                                                             UART_ADVFEATURE_MSBFIRST_INIT))\r
1022 \r
1023 #define IS_UART_ADVFEATURE_TXINV(TXINV) (((TXINV) == UART_ADVFEATURE_TXINV_DISABLE) || \\r
1024                                          ((TXINV) == UART_ADVFEATURE_TXINV_ENABLE))\r
1025 \r
1026 #define IS_UART_ADVFEATURE_RXINV(RXINV) (((RXINV) == UART_ADVFEATURE_RXINV_DISABLE) || \\r
1027                                          ((RXINV) == UART_ADVFEATURE_RXINV_ENABLE))\r
1028 \r
1029 #define IS_UART_ADVFEATURE_DATAINV(DATAINV) (((DATAINV) == UART_ADVFEATURE_DATAINV_DISABLE) || \\r
1030                                              ((DATAINV) == UART_ADVFEATURE_DATAINV_ENABLE))\r
1031 \r
1032 #define IS_UART_ADVFEATURE_SWAP(SWAP) (((SWAP) == UART_ADVFEATURE_SWAP_DISABLE) || \\r
1033                                        ((SWAP) == UART_ADVFEATURE_SWAP_ENABLE))\r
1034 \r
1035 #define IS_UART_OVERRUN(OVERRUN)         (((OVERRUN) == UART_ADVFEATURE_OVERRUN_ENABLE) || \\r
1036                                           ((OVERRUN) == UART_ADVFEATURE_OVERRUN_DISABLE))\r
1037 \r
1038 #define IS_UART_ADVFEATURE_AUTOBAUDRATE(AUTOBAUDRATE)  (((AUTOBAUDRATE) == UART_ADVFEATURE_AUTOBAUDRATE_DISABLE) || \\r
1039                                                         ((AUTOBAUDRATE) == UART_ADVFEATURE_AUTOBAUDRATE_ENABLE))\r
1040 \r
1041 #define IS_UART_ADVFEATURE_DMAONRXERROR(DMA)      (((DMA) == UART_ADVFEATURE_DMA_ENABLEONRXERROR) || \\r
1042                                                    ((DMA) == UART_ADVFEATURE_DMA_DISABLEONRXERROR))\r
1043 \r
1044 #define IS_UART_ADVFEATURE_MSBFIRST(MSBFIRST) (((MSBFIRST) == UART_ADVFEATURE_MSBFIRST_DISABLE) || \\r
1045                                                ((MSBFIRST) == UART_ADVFEATURE_MSBFIRST_ENABLE))\r
1046 \r
1047 #define IS_UART_MUTE_MODE(MUTE)           (((MUTE) == UART_ADVFEATURE_MUTEMODE_DISABLE) || \\r
1048                                            ((MUTE) == UART_ADVFEATURE_MUTEMODE_ENABLE))\r
1049 \r
1050 #define IS_UART_DE_POLARITY(POLARITY)    (((POLARITY) == UART_DE_POLARITY_HIGH) || \\r
1051                                           ((POLARITY) == UART_DE_POLARITY_LOW))\r
1052 \r
1053 /**\r
1054   * @}\r
1055   */\r
1056 /* Include UART HAL Extension module */\r
1057 #include "stm32f7xx_hal_uart_ex.h"\r
1058 /* Exported functions --------------------------------------------------------*/\r
1059 /** @addtogroup UART_Exported_Functions UART Exported Functions\r
1060   * @{\r
1061   */\r
1062 \r
1063 /** @addtogroup UART_Exported_Functions_Group1 Initialization and de-initialization functions\r
1064   * @{\r
1065   */\r
1066 \r
1067 /* Initialization and de-initialization functions  ****************************/\r
1068 HAL_StatusTypeDef HAL_UART_Init(UART_HandleTypeDef *huart);\r
1069 HAL_StatusTypeDef HAL_HalfDuplex_Init(UART_HandleTypeDef *huart);\r
1070 HAL_StatusTypeDef HAL_LIN_Init(UART_HandleTypeDef *huart, uint32_t BreakDetectLength);\r
1071 HAL_StatusTypeDef HAL_MultiProcessor_Init(UART_HandleTypeDef *huart, uint8_t Address, uint32_t WakeUpMethod);\r
1072 HAL_StatusTypeDef HAL_UART_DeInit (UART_HandleTypeDef *huart);\r
1073 void HAL_UART_MspInit(UART_HandleTypeDef *huart);\r
1074 void HAL_UART_MspDeInit(UART_HandleTypeDef *huart);\r
1075 \r
1076 /**\r
1077   * @}\r
1078   */\r
1079 \r
1080 /** @addtogroup UART_Exported_Functions_Group2 IO operation functions\r
1081   * @{\r
1082   */\r
1083 \r
1084 /* IO operation functions *****************************************************/\r
1085 HAL_StatusTypeDef HAL_UART_Transmit(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout);\r
1086 HAL_StatusTypeDef HAL_UART_Receive(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout);\r
1087 HAL_StatusTypeDef HAL_UART_Transmit_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size);\r
1088 HAL_StatusTypeDef HAL_UART_Receive_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size);\r
1089 HAL_StatusTypeDef HAL_UART_Transmit_DMA(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size);\r
1090 HAL_StatusTypeDef HAL_UART_Receive_DMA(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size);\r
1091 HAL_StatusTypeDef HAL_UART_DMAPause(UART_HandleTypeDef *huart);\r
1092 HAL_StatusTypeDef HAL_UART_DMAResume(UART_HandleTypeDef *huart);\r
1093 HAL_StatusTypeDef HAL_UART_DMAStop(UART_HandleTypeDef *huart);\r
1094 void HAL_UART_IRQHandler(UART_HandleTypeDef *huart);\r
1095 void HAL_UART_TxHalfCpltCallback(UART_HandleTypeDef *huart);\r
1096 void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart);\r
1097 void HAL_UART_RxHalfCpltCallback(UART_HandleTypeDef *huart);\r
1098 void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart);\r
1099 void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart);\r
1100 \r
1101 /**\r
1102   * @}\r
1103   */\r
1104 \r
1105 /** @addtogroup UART_Exported_Functions_Group3 Peripheral Control functions\r
1106   * @{\r
1107   */\r
1108 \r
1109 /* Peripheral Control functions  ************************************************/\r
1110 HAL_StatusTypeDef HAL_LIN_SendBreak(UART_HandleTypeDef *huart);\r
1111 HAL_StatusTypeDef HAL_MultiProcessor_EnableMuteMode(UART_HandleTypeDef *huart);\r
1112 HAL_StatusTypeDef HAL_MultiProcessor_DisableMuteMode(UART_HandleTypeDef *huart);\r
1113 void HAL_MultiProcessor_EnterMuteMode(UART_HandleTypeDef *huart);\r
1114 HAL_StatusTypeDef HAL_HalfDuplex_EnableTransmitter(UART_HandleTypeDef *huart);\r
1115 HAL_StatusTypeDef HAL_HalfDuplex_EnableReceiver(UART_HandleTypeDef *huart);\r
1116 \r
1117 /**\r
1118   * @}\r
1119   */\r
1120 \r
1121 /** @addtogroup UART_Exported_Functions_Group4 Peripheral State and Error functions\r
1122   * @{\r
1123   */\r
1124 \r
1125 /* Peripheral State and Errors functions  **************************************************/\r
1126 HAL_UART_StateTypeDef HAL_UART_GetState(UART_HandleTypeDef *huart);\r
1127 uint32_t HAL_UART_GetError(UART_HandleTypeDef *huart);\r
1128 \r
1129 /**\r
1130   * @}\r
1131   */\r
1132 \r
1133 /**\r
1134   * @}\r
1135   */\r
1136 \r
1137 /* Private functions -----------------------------------------------------------*/\r
1138 /** @addtogroup UART_Private_Functions UART Private Functions\r
1139   * @{\r
1140   */\r
1141 \r
1142 HAL_StatusTypeDef UART_SetConfig(UART_HandleTypeDef *huart);\r
1143 HAL_StatusTypeDef UART_CheckIdleState(UART_HandleTypeDef *huart);\r
1144 HAL_StatusTypeDef UART_WaitOnFlagUntilTimeout(UART_HandleTypeDef *huart, uint32_t Flag, FlagStatus Status, uint32_t Timeout);\r
1145 void UART_AdvFeatureConfig(UART_HandleTypeDef *huart);\r
1146 \r
1147 /**\r
1148   * @}\r
1149   */\r
1150 \r
1151 /**\r
1152   * @}\r
1153   */\r
1154 \r
1155 /**\r
1156   * @}\r
1157   */\r
1158 \r
1159 #ifdef __cplusplus\r
1160 }\r
1161 #endif\r
1162 \r
1163 #endif /* __STM32F7xx_HAL_UART_H */\r
1164 \r
1165 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/\r