git.leonardobizzoni.com Git - pioneer-stm32/blob

   1 /**\r
   2   ******************************************************************************\r
   3   * @file    stm32f7xx_hal_uart.h\r
   4   * @author  MCD Application Team\r
   5   * @brief   Header file of UART HAL module.\r
   6   ******************************************************************************\r
   7   * @attention\r
   8   *\r
   9   * <h2><center>&copy; Copyright (c) 2017 STMicroelectronics.\r
  10   * All rights reserved.</center></h2>\r
  11   *\r
  12   * This software component is licensed by ST under BSD 3-Clause license,\r
  13   * the "License"; You may not use this file except in compliance with the\r
  14   * License. You may obtain a copy of the License at:\r
  15   *                        opensource.org/licenses/BSD-3-Clause\r
  16   *\r
  17   ******************************************************************************\r
  18   */\r
  19 \r
  20 /* Define to prevent recursive inclusion -------------------------------------*/\r
  21 #ifndef STM32F7xx_HAL_UART_H\r
  22 #define STM32F7xx_HAL_UART_H\r
  23 \r
  24 #ifdef __cplusplus\r
  25 extern "C" {\r
  26 #endif\r
  27 \r
  28 /* Includes ------------------------------------------------------------------*/\r
  29 #include "stm32f7xx_hal_def.h"\r
  30 \r
  31 /** @addtogroup STM32F7xx_HAL_Driver\r
  32   * @{\r
  33   */\r
  34 \r
  35 /** @addtogroup UART\r
  36   * @{\r
  37   */\r
  38 \r
  39 /* Exported types ------------------------------------------------------------*/\r
  40 /** @defgroup UART_Exported_Types UART Exported Types\r
  41   * @{\r
  42   */\r
  43 \r
  44 /**\r
  45   * @brief UART Init Structure definition\r
  46   */\r
  47 typedef struct\r
  48 {\r
  49   uint32_t BaudRate;                  /*!< This member configures the UART communication baud rate.\r
  50                                            The baud rate register is computed using the following formula:\r
  51                                            - If oversampling is 16 or in LIN mode,\r
  52                                               Baud Rate Register = ((uart_ker_ck) / ((huart->Init.BaudRate)))\r
  53                                            - If oversampling is 8,\r
  54                                               Baud Rate Register[15:4] = ((2 * uart_ker_ck) / ((huart->Init.BaudRate)))[15:4]\r
  55                                               Baud Rate Register[3] =  0\r
  56                                               Baud Rate Register[2:0] =  (((2 * uart_ker_ck) / ((huart->Init.BaudRate)))[3:0]) >> 1\r
  57                                            where uart_ker_ck is the UART input clock */\r
  58 \r
  59   uint32_t WordLength;                /*!< Specifies the number of data bits transmitted or received in a frame.\r
  60                                            This parameter can be a value of @ref UARTEx_Word_Length. */\r
  61 \r
  62   uint32_t StopBits;                  /*!< Specifies the number of stop bits transmitted.\r
  63                                            This parameter can be a value of @ref UART_Stop_Bits. */\r
  64 \r
  65   uint32_t Parity;                    /*!< Specifies the parity mode.\r
  66                                            This parameter can be a value of @ref UART_Parity\r
  67                                            @note When parity is enabled, the computed parity is inserted\r
  68                                                  at the MSB position of the transmitted data (9th bit when\r
  69                                                  the word length is set to 9 data bits; 8th bit when the\r
  70                                                  word length is set to 8 data bits). */\r
  71 \r
  72   uint32_t Mode;                      /*!< Specifies whether the Receive or Transmit mode is enabled or disabled.\r
  73                                            This parameter can be a value of @ref UART_Mode. */\r
  74 \r
  75   uint32_t HwFlowCtl;                 /*!< Specifies whether the hardware flow control mode is enabled\r
  76                                            or disabled.\r
  77                                            This parameter can be a value of @ref UART_Hardware_Flow_Control. */\r
  78 \r
  79   uint32_t OverSampling;              /*!< Specifies whether the Over sampling 8 is enabled or disabled, to achieve higher speed (up to f_PCLK/8).\r
  80                                            This parameter can be a value of @ref UART_Over_Sampling. */\r
  81 \r
  82   uint32_t OneBitSampling;            /*!< Specifies whether a single sample or three samples' majority vote is selected.\r
  83                                            Selecting the single sample method increases the receiver tolerance to clock\r
  84                                            deviations. This parameter can be a value of @ref UART_OneBit_Sampling. */\r
  85 \r
  86 \r
  87 } UART_InitTypeDef;\r
  88 \r
  89 /**\r
  90   * @brief  UART Advanced Features initialization structure definition\r
  91   */\r
  92 typedef struct\r
  93 {\r
  94   uint32_t AdvFeatureInit;        /*!< Specifies which advanced UART features is initialized. Several\r
  95                                        Advanced Features may be initialized at the same time .\r
  96                                        This parameter can be a value of @ref UART_Advanced_Features_Initialization_Type. */\r
  97 \r
  98   uint32_t TxPinLevelInvert;      /*!< Specifies whether the TX pin active level is inverted.\r
  99                                        This parameter can be a value of @ref UART_Tx_Inv. */\r
 100 \r
 101   uint32_t RxPinLevelInvert;      /*!< Specifies whether the RX pin active level is inverted.\r
 102                                        This parameter can be a value of @ref UART_Rx_Inv. */\r
 103 \r
 104   uint32_t DataInvert;            /*!< Specifies whether data are inverted (positive/direct logic\r
 105                                        vs negative/inverted logic).\r
 106                                        This parameter can be a value of @ref UART_Data_Inv. */\r
 107 \r
 108   uint32_t Swap;                  /*!< Specifies whether TX and RX pins are swapped.\r
 109                                        This parameter can be a value of @ref UART_Rx_Tx_Swap. */\r
 110 \r
 111   uint32_t OverrunDisable;        /*!< Specifies whether the reception overrun detection is disabled.\r
 112                                        This parameter can be a value of @ref UART_Overrun_Disable. */\r
 113 \r
 114   uint32_t DMADisableonRxError;   /*!< Specifies whether the DMA is disabled in case of reception error.\r
 115                                        This parameter can be a value of @ref UART_DMA_Disable_on_Rx_Error. */\r
 116 \r
 117   uint32_t AutoBaudRateEnable;    /*!< Specifies whether auto Baud rate detection is enabled.\r
 118                                        This parameter can be a value of @ref UART_AutoBaudRate_Enable. */\r
 119 \r
 120   uint32_t AutoBaudRateMode;      /*!< If auto Baud rate detection is enabled, specifies how the rate\r
 121                                        detection is carried out.\r
 122                                        This parameter can be a value of @ref UART_AutoBaud_Rate_Mode. */\r
 123 \r
 124   uint32_t MSBFirst;              /*!< Specifies whether MSB is sent first on UART line.\r
 125                                        This parameter can be a value of @ref UART_MSB_First. */\r
 126 } UART_AdvFeatureInitTypeDef;\r
 127 \r
 128 \r
 129 \r
 130 /**\r
 131   * @brief HAL UART State definition\r
 132   * @note  HAL UART State value is a combination of 2 different substates: gState and RxState (see @ref UART_State_Definition).\r
 133   *        - gState contains UART state information related to global Handle management\r
 134   *          and also information related to Tx operations.\r
 135   *          gState value coding follow below described bitmap :\r
 136   *          b7-b6  Error information\r
 137   *             00 : No Error\r
 138   *             01 : (Not Used)\r
 139   *             10 : Timeout\r
 140   *             11 : Error\r
 141   *          b5     Peripheral initialization status\r
 142   *             0  : Reset (Peripheral not initialized)\r
 143   *             1  : Init done (Peripheral not initialized. HAL UART Init function already called)\r
 144   *          b4-b3  (not used)\r
 145   *             xx : Should be set to 00\r
 146   *          b2     Intrinsic process state\r
 147   *             0  : Ready\r
 148   *             1  : Busy (Peripheral busy with some configuration or internal operations)\r
 149   *          b1     (not used)\r
 150   *             x  : Should be set to 0\r
 151   *          b0     Tx state\r
 152   *             0  : Ready (no Tx operation ongoing)\r
 153   *             1  : Busy (Tx operation ongoing)\r
 154   *        - RxState contains information related to Rx operations.\r
 155   *          RxState value coding follow below described bitmap :\r
 156   *          b7-b6  (not used)\r
 157   *             xx : Should be set to 00\r
 158   *          b5     Peripheral initialization status\r
 159   *             0  : Reset (Peripheral not initialized)\r
 160   *             1  : Init done (Peripheral not initialized)\r
 161   *          b4-b2  (not used)\r
 162   *            xxx : Should be set to 000\r
 163   *          b1     Rx state\r
 164   *             0  : Ready (no Rx operation ongoing)\r
 165   *             1  : Busy (Rx operation ongoing)\r
 166   *          b0     (not used)\r
 167   *             x  : Should be set to 0.\r
 168   */\r
 169 typedef uint32_t HAL_UART_StateTypeDef;\r
 170 \r
 171 /**\r
 172   * @brief UART clock sources definition\r
 173   */\r
 174 typedef enum\r
 175 {\r
 176   UART_CLOCKSOURCE_PCLK1      = 0x00U,    /*!< PCLK1 clock source  */\r
 177   UART_CLOCKSOURCE_PCLK2      = 0x01U,    /*!< PCLK2 clock source  */\r
 178   UART_CLOCKSOURCE_HSI        = 0x02U,    /*!< HSI clock source    */\r
 179   UART_CLOCKSOURCE_SYSCLK     = 0x04U,    /*!< SYSCLK clock source */\r
 180   UART_CLOCKSOURCE_LSE        = 0x08U,    /*!< LSE clock source       */\r
 181   UART_CLOCKSOURCE_UNDEFINED  = 0x10U     /*!< Undefined clock source */\r
 182 } UART_ClockSourceTypeDef;\r
 183 \r
 184 /**\r
 185   * @brief  UART handle Structure definition\r
 186   */\r
 187 typedef struct __UART_HandleTypeDef\r
 188 {\r
 189   USART_TypeDef            *Instance;                /*!< UART registers base address        */\r
 190 \r
 191   UART_InitTypeDef         Init;                     /*!< UART communication parameters      */\r
 192 \r
 193   UART_AdvFeatureInitTypeDef AdvancedInit;           /*!< UART Advanced Features initialization parameters */\r
 194 \r
 195   uint8_t                  *pTxBuffPtr;              /*!< Pointer to UART Tx transfer Buffer */\r
 196 \r
 197   uint16_t                 TxXferSize;               /*!< UART Tx Transfer size              */\r
 198 \r
 199   __IO uint16_t            TxXferCount;              /*!< UART Tx Transfer Counter           */\r
 200 \r
 201   uint8_t                  *pRxBuffPtr;              /*!< Pointer to UART Rx transfer Buffer */\r
 202 \r
 203   uint16_t                 RxXferSize;               /*!< UART Rx Transfer size              */\r
 204 \r
 205   __IO uint16_t            RxXferCount;              /*!< UART Rx Transfer Counter           */\r
 206 \r
 207   uint16_t                 Mask;                     /*!< UART Rx RDR register mask          */\r
 208 \r
 209 \r
 210   void (*RxISR)(struct __UART_HandleTypeDef *huart); /*!< Function pointer on Rx IRQ handler   */\r
 211 \r
 212   void (*TxISR)(struct __UART_HandleTypeDef *huart); /*!< Function pointer on Tx IRQ handler   */\r
 213 \r
 214   DMA_HandleTypeDef        *hdmatx;                  /*!< UART Tx DMA Handle parameters      */\r
 215 \r
 216   DMA_HandleTypeDef        *hdmarx;                  /*!< UART Rx DMA Handle parameters      */\r
 217 \r
 218   HAL_LockTypeDef           Lock;                    /*!< Locking object                     */\r
 219 \r
 220   __IO HAL_UART_StateTypeDef    gState;              /*!< UART state information related to global Handle management\r
 221                                                           and also related to Tx operations.\r
 222                                                           This parameter can be a value of @ref HAL_UART_StateTypeDef */\r
 223 \r
 224   __IO HAL_UART_StateTypeDef    RxState;             /*!< UART state information related to Rx operations.\r
 225                                                           This parameter can be a value of @ref HAL_UART_StateTypeDef */\r
 226 \r
 227   __IO uint32_t                 ErrorCode;           /*!< UART Error code                    */\r
 228 \r
 229 #if (USE_HAL_UART_REGISTER_CALLBACKS == 1)\r
 230   void (* TxHalfCpltCallback)(struct __UART_HandleTypeDef *huart);        /*!< UART Tx Half Complete Callback        */\r
 231   void (* TxCpltCallback)(struct __UART_HandleTypeDef *huart);            /*!< UART Tx Complete Callback             */\r
 232   void (* RxHalfCpltCallback)(struct __UART_HandleTypeDef *huart);        /*!< UART Rx Half Complete Callback        */\r
 233   void (* RxCpltCallback)(struct __UART_HandleTypeDef *huart);            /*!< UART Rx Complete Callback             */\r
 234   void (* ErrorCallback)(struct __UART_HandleTypeDef *huart);             /*!< UART Error Callback                   */\r
 235   void (* AbortCpltCallback)(struct __UART_HandleTypeDef *huart);         /*!< UART Abort Complete Callback          */\r
 236   void (* AbortTransmitCpltCallback)(struct __UART_HandleTypeDef *huart); /*!< UART Abort Transmit Complete Callback */\r
 237   void (* AbortReceiveCpltCallback)(struct __UART_HandleTypeDef *huart);  /*!< UART Abort Receive Complete Callback  */\r
 238   void (* WakeupCallback)(struct __UART_HandleTypeDef *huart);            /*!< UART Wakeup Callback                  */\r
 239 \r
 240   void (* MspInitCallback)(struct __UART_HandleTypeDef *huart);           /*!< UART Msp Init callback                */\r
 241   void (* MspDeInitCallback)(struct __UART_HandleTypeDef *huart);         /*!< UART Msp DeInit callback              */\r
 242 #endif  /* USE_HAL_UART_REGISTER_CALLBACKS */\r
 243 \r
 244 } UART_HandleTypeDef;\r
 245 \r
 246 #if (USE_HAL_UART_REGISTER_CALLBACKS == 1)\r
 247 /**\r
 248   * @brief  HAL UART Callback ID enumeration definition\r
 249   */\r
 250 typedef enum\r
 251 {\r
 252   HAL_UART_TX_HALFCOMPLETE_CB_ID         = 0x00U,    /*!< UART Tx Half Complete Callback ID        */\r
 253   HAL_UART_TX_COMPLETE_CB_ID             = 0x01U,    /*!< UART Tx Complete Callback ID             */\r
 254   HAL_UART_RX_HALFCOMPLETE_CB_ID         = 0x02U,    /*!< UART Rx Half Complete Callback ID        */\r
 255   HAL_UART_RX_COMPLETE_CB_ID             = 0x03U,    /*!< UART Rx Complete Callback ID             */\r
 256   HAL_UART_ERROR_CB_ID                   = 0x04U,    /*!< UART Error Callback ID                   */\r
 257   HAL_UART_ABORT_COMPLETE_CB_ID          = 0x05U,    /*!< UART Abort Complete Callback ID          */\r
 258   HAL_UART_ABORT_TRANSMIT_COMPLETE_CB_ID = 0x06U,    /*!< UART Abort Transmit Complete Callback ID */\r
 259   HAL_UART_ABORT_RECEIVE_COMPLETE_CB_ID  = 0x07U,    /*!< UART Abort Receive Complete Callback ID  */\r
 260   HAL_UART_WAKEUP_CB_ID                  = 0x08U,    /*!< UART Wakeup Callback ID                  */\r
 261 \r
 262   HAL_UART_MSPINIT_CB_ID                 = 0x0BU,    /*!< UART MspInit callback ID                 */\r
 263   HAL_UART_MSPDEINIT_CB_ID               = 0x0CU     /*!< UART MspDeInit callback ID               */\r
 264 \r
 265 } HAL_UART_CallbackIDTypeDef;\r
 266 \r
 267 /**\r
 268   * @brief  HAL UART Callback pointer definition\r
 269   */\r
 270 typedef  void (*pUART_CallbackTypeDef)(UART_HandleTypeDef *huart);  /*!< pointer to an UART callback function */\r
 271 \r
 272 #endif /* USE_HAL_UART_REGISTER_CALLBACKS */\r
 273 \r
 274 /**\r
 275   * @}\r
 276   */\r
 277 \r
 278 /* Exported constants --------------------------------------------------------*/\r
 279 /** @defgroup UART_Exported_Constants UART Exported Constants\r
 280   * @{\r
 281   */\r
 282 \r
 283 /** @defgroup UART_State_Definition UART State Code Definition\r
 284   * @{\r
 285   */\r
 286 #define  HAL_UART_STATE_RESET         0x00000000U    /*!< Peripheral is not initialized\r
 287                                                           Value is allowed for gState and RxState */\r
 288 #define  HAL_UART_STATE_READY         0x00000020U    /*!< Peripheral Initialized and ready for use\r
 289                                                           Value is allowed for gState and RxState */\r
 290 #define  HAL_UART_STATE_BUSY          0x00000024U    /*!< an internal process is ongoing\r
 291                                                           Value is allowed for gState only */\r
 292 #define  HAL_UART_STATE_BUSY_TX       0x00000021U    /*!< Data Transmission process is ongoing\r
 293                                                           Value is allowed for gState only */\r
 294 #define  HAL_UART_STATE_BUSY_RX       0x00000022U    /*!< Data Reception process is ongoing\r
 295                                                           Value is allowed for RxState only */\r
 296 #define  HAL_UART_STATE_BUSY_TX_RX    0x00000023U    /*!< Data Transmission and Reception process is ongoing\r
 297                                                           Not to be used for neither gState nor RxState.\r
 298                                                           Value is result of combination (Or) between gState and RxState values */\r
 299 #define  HAL_UART_STATE_TIMEOUT       0x000000A0U    /*!< Timeout state\r
 300                                                           Value is allowed for gState only */\r
 301 #define  HAL_UART_STATE_ERROR         0x000000E0U    /*!< Error\r
 302                                                           Value is allowed for gState only */\r
 303 /**\r
 304   * @}\r
 305   */\r
 306 \r
 307 /** @defgroup UART_Error_Definition   UART Error Definition\r
 308   * @{\r
 309   */\r
 310 #define  HAL_UART_ERROR_NONE             ((uint32_t)0x00000000U)    /*!< No error                */\r
 311 #define  HAL_UART_ERROR_PE               ((uint32_t)0x00000001U)    /*!< Parity error            */\r
 312 #define  HAL_UART_ERROR_NE               ((uint32_t)0x00000002U)    /*!< Noise error             */\r
 313 #define  HAL_UART_ERROR_FE               ((uint32_t)0x00000004U)    /*!< Frame error             */\r
 314 #define  HAL_UART_ERROR_ORE              ((uint32_t)0x00000008U)    /*!< Overrun error           */\r
 315 #define  HAL_UART_ERROR_DMA              ((uint32_t)0x00000010U)    /*!< DMA transfer error      */\r
 316 #if (USE_HAL_UART_REGISTER_CALLBACKS == 1)\r
 317 #define  HAL_UART_ERROR_INVALID_CALLBACK ((uint32_t)0x00000020U)    /*!< Invalid Callback error  */\r
 318 #endif /* USE_HAL_UART_REGISTER_CALLBACKS */\r
 319 /**\r
 320   * @}\r
 321   */\r
 322 \r
 323 /** @defgroup UART_Stop_Bits   UART Number of Stop Bits\r
 324   * @{\r
 325   */\r
 326 #define UART_STOPBITS_0_5                    USART_CR2_STOP_0                     /*!< UART frame with 0.5 stop bit  */\r
 327 #define UART_STOPBITS_1                     0x00000000U                           /*!< UART frame with 1 stop bit    */\r
 328 #define UART_STOPBITS_1_5                   (USART_CR2_STOP_0 | USART_CR2_STOP_1) /*!< UART frame with 1.5 stop bits */\r
 329 #define UART_STOPBITS_2                      USART_CR2_STOP_1                     /*!< UART frame with 2 stop bits   */\r
 330 /**\r
 331   * @}\r
 332   */\r
 333 \r
 334 /** @defgroup UART_Parity  UART Parity\r
 335   * @{\r
 336   */\r
 337 #define UART_PARITY_NONE                    0x00000000U                        /*!< No parity   */\r
 338 #define UART_PARITY_EVEN                    USART_CR1_PCE                      /*!< Even parity */\r
 339 #define UART_PARITY_ODD                     (USART_CR1_PCE | USART_CR1_PS)     /*!< Odd parity  */\r
 340 /**\r
 341   * @}\r
 342   */\r
 343 \r
 344 /** @defgroup UART_Hardware_Flow_Control UART Hardware Flow Control\r
 345   * @{\r
 346   */\r
 347 #define UART_HWCONTROL_NONE                  0x00000000U                          /*!< No hardware control       */\r
 348 #define UART_HWCONTROL_RTS                   USART_CR3_RTSE                       /*!< Request To Send           */\r
 349 #define UART_HWCONTROL_CTS                   USART_CR3_CTSE                       /*!< Clear To Send             */\r
 350 #define UART_HWCONTROL_RTS_CTS               (USART_CR3_RTSE | USART_CR3_CTSE)    /*!< Request and Clear To Send */\r
 351 /**\r
 352   * @}\r
 353   */\r
 354 \r
 355 /** @defgroup UART_Mode UART Transfer Mode\r
 356   * @{\r
 357   */\r
 358 #define UART_MODE_RX                        USART_CR1_RE                    /*!< RX mode        */\r
 359 #define UART_MODE_TX                        USART_CR1_TE                    /*!< TX mode        */\r
 360 #define UART_MODE_TX_RX                     (USART_CR1_TE |USART_CR1_RE)    /*!< RX and TX mode */\r
 361 /**\r
 362   * @}\r
 363   */\r
 364 \r
 365 /** @defgroup UART_State  UART State\r
 366   * @{\r
 367   */\r
 368 #define UART_STATE_DISABLE                  0x00000000U         /*!< UART disabled  */\r
 369 #define UART_STATE_ENABLE                   USART_CR1_UE        /*!< UART enabled   */\r
 370 /**\r
 371   * @}\r
 372   */\r
 373 \r
 374 /** @defgroup UART_Over_Sampling UART Over Sampling\r
 375   * @{\r
 376   */\r
 377 #define UART_OVERSAMPLING_16                0x00000000U         /*!< Oversampling by 16 */\r
 378 #define UART_OVERSAMPLING_8                 USART_CR1_OVER8     /*!< Oversampling by 8  */\r
 379 /**\r
 380   * @}\r
 381   */\r
 382 \r
 383 /** @defgroup UART_OneBit_Sampling UART One Bit Sampling Method\r
 384   * @{\r
 385   */\r
 386 #define UART_ONE_BIT_SAMPLE_DISABLE         0x00000000U         /*!< One-bit sampling disable */\r
 387 #define UART_ONE_BIT_SAMPLE_ENABLE          USART_CR3_ONEBIT    /*!< One-bit sampling enable  */\r
 388 /**\r
 389   * @}\r
 390   */\r
 391 \r
 392 /** @defgroup UART_AutoBaud_Rate_Mode    UART Advanced Feature AutoBaud Rate Mode\r
 393   * @{\r
 394   */\r
 395 #define UART_ADVFEATURE_AUTOBAUDRATE_ONSTARTBIT    0x00000000U           /*!< Auto Baud rate detection on start bit            */\r
 396 #define UART_ADVFEATURE_AUTOBAUDRATE_ONFALLINGEDGE USART_CR2_ABRMODE_0   /*!< Auto Baud rate detection on falling edge         */\r
 397 #define UART_ADVFEATURE_AUTOBAUDRATE_ON0X7FFRAME   USART_CR2_ABRMODE_1   /*!< Auto Baud rate detection on 0x7F frame detection */\r
 398 #define UART_ADVFEATURE_AUTOBAUDRATE_ON0X55FRAME   USART_CR2_ABRMODE     /*!< Auto Baud rate detection on 0x55 frame detection */\r
 399 /**\r
 400   * @}\r
 401   */\r
 402 \r
 403 /** @defgroup UART_Receiver_TimeOut UART Receiver TimeOut\r
 404   * @{\r
 405   */\r
 406 #define UART_RECEIVER_TIMEOUT_DISABLE       0x00000000U                 /*!< UART receiver timeout disable */\r
 407 #define UART_RECEIVER_TIMEOUT_ENABLE        USART_CR2_RTOEN             /*!< UART receiver timeout enable  */\r
 408 /**\r
 409   * @}\r
 410   */\r
 411 \r
 412 /** @defgroup UART_LIN    UART Local Interconnection Network mode\r
 413   * @{\r
 414   */\r
 415 #define UART_LIN_DISABLE                    0x00000000U                /*!< Local Interconnect Network disable */\r
 416 #define UART_LIN_ENABLE                     USART_CR2_LINEN            /*!< Local Interconnect Network enable  */\r
 417 /**\r
 418   * @}\r
 419   */\r
 420 \r
 421 /** @defgroup UART_LIN_Break_Detection  UART LIN Break Detection\r
 422   * @{\r
 423   */\r
 424 #define UART_LINBREAKDETECTLENGTH_10B       0x00000000U                /*!< LIN 10-bit break detection length */\r
 425 #define UART_LINBREAKDETECTLENGTH_11B       USART_CR2_LBDL             /*!< LIN 11-bit break detection length  */\r
 426 /**\r
 427   * @}\r
 428   */\r
 429 \r
 430 /** @defgroup UART_DMA_Tx    UART DMA Tx\r
 431   * @{\r
 432   */\r
 433 #define UART_DMA_TX_DISABLE                 0x00000000U                /*!< UART DMA TX disabled */\r
 434 #define UART_DMA_TX_ENABLE                  USART_CR3_DMAT             /*!< UART DMA TX enabled  */\r
 435 /**\r
 436   * @}\r
 437   */\r
 438 \r
 439 /** @defgroup UART_DMA_Rx   UART DMA Rx\r
 440   * @{\r
 441   */\r
 442 #define UART_DMA_RX_DISABLE                 0x00000000U                 /*!< UART DMA RX disabled */\r
 443 #define UART_DMA_RX_ENABLE                  USART_CR3_DMAR              /*!< UART DMA RX enabled  */\r
 444 /**\r
 445   * @}\r
 446   */\r
 447 \r
 448 /** @defgroup UART_Half_Duplex_Selection  UART Half Duplex Selection\r
 449   * @{\r
 450   */\r
 451 #define UART_HALF_DUPLEX_DISABLE            0x00000000U                 /*!< UART half-duplex disabled */\r
 452 #define UART_HALF_DUPLEX_ENABLE             USART_CR3_HDSEL             /*!< UART half-duplex enabled  */\r
 453 /**\r
 454   * @}\r
 455   */\r
 456 \r
 457 /** @defgroup UART_WakeUp_Methods   UART WakeUp Methods\r
 458   * @{\r
 459   */\r
 460 #define UART_WAKEUPMETHOD_IDLELINE          0x00000000U                 /*!< UART wake-up on idle line    */\r
 461 #define UART_WAKEUPMETHOD_ADDRESSMARK       USART_CR1_WAKE              /*!< UART wake-up on address mark */\r
 462 /**\r
 463   * @}\r
 464   */\r
 465 \r
 466 /** @defgroup UART_Request_Parameters UART Request Parameters\r
 467   * @{\r
 468   */\r
 469 #define UART_AUTOBAUD_REQUEST               USART_RQR_ABRRQ        /*!< Auto-Baud Rate Request      */\r
 470 #define UART_SENDBREAK_REQUEST              USART_RQR_SBKRQ        /*!< Send Break Request          */\r
 471 #define UART_MUTE_MODE_REQUEST              USART_RQR_MMRQ         /*!< Mute Mode Request           */\r
 472 #define UART_RXDATA_FLUSH_REQUEST           USART_RQR_RXFRQ        /*!< Receive Data flush Request  */\r
 473 #define UART_TXDATA_FLUSH_REQUEST           USART_RQR_TXFRQ        /*!< Transmit data flush Request */\r
 474 /**\r
 475   * @}\r
 476   */\r
 477 \r
 478 /** @defgroup UART_Advanced_Features_Initialization_Type  UART Advanced Feature Initialization Type\r
 479   * @{\r
 480   */\r
 481 #define UART_ADVFEATURE_NO_INIT                 0x00000000U          /*!< No advanced feature initialization       */\r
 482 #define UART_ADVFEATURE_TXINVERT_INIT           0x00000001U          /*!< TX pin active level inversion            */\r
 483 #define UART_ADVFEATURE_RXINVERT_INIT           0x00000002U          /*!< RX pin active level inversion            */\r
 484 #define UART_ADVFEATURE_DATAINVERT_INIT         0x00000004U          /*!< Binary data inversion                    */\r
 485 #define UART_ADVFEATURE_SWAP_INIT               0x00000008U          /*!< TX/RX pins swap                          */\r
 486 #define UART_ADVFEATURE_RXOVERRUNDISABLE_INIT   0x00000010U          /*!< RX overrun disable                       */\r
 487 #define UART_ADVFEATURE_DMADISABLEONERROR_INIT  0x00000020U          /*!< DMA disable on Reception Error           */\r
 488 #define UART_ADVFEATURE_AUTOBAUDRATE_INIT       0x00000040U          /*!< Auto Baud rate detection initialization  */\r
 489 #define UART_ADVFEATURE_MSBFIRST_INIT           0x00000080U          /*!< Most significant bit sent/received first */\r
 490 /**\r
 491   * @}\r
 492   */\r
 493 \r
 494 /** @defgroup UART_Tx_Inv UART Advanced Feature TX Pin Active Level Inversion\r
 495   * @{\r
 496   */\r
 497 #define UART_ADVFEATURE_TXINV_DISABLE       0x00000000U             /*!< TX pin active level inversion disable */\r
 498 #define UART_ADVFEATURE_TXINV_ENABLE        USART_CR2_TXINV         /*!< TX pin active level inversion enable  */\r
 499 /**\r
 500   * @}\r
 501   */\r
 502 \r
 503 /** @defgroup UART_Rx_Inv UART Advanced Feature RX Pin Active Level Inversion\r
 504   * @{\r
 505   */\r
 506 #define UART_ADVFEATURE_RXINV_DISABLE       0x00000000U             /*!< RX pin active level inversion disable */\r
 507 #define UART_ADVFEATURE_RXINV_ENABLE        USART_CR2_RXINV         /*!< RX pin active level inversion enable  */\r
 508 /**\r
 509   * @}\r
 510   */\r
 511 \r
 512 /** @defgroup UART_Data_Inv  UART Advanced Feature Binary Data Inversion\r
 513   * @{\r
 514   */\r
 515 #define UART_ADVFEATURE_DATAINV_DISABLE     0x00000000U             /*!< Binary data inversion disable */\r
 516 #define UART_ADVFEATURE_DATAINV_ENABLE      USART_CR2_DATAINV       /*!< Binary data inversion enable  */\r
 517 /**\r
 518   * @}\r
 519   */\r
 520 \r
 521 /** @defgroup UART_Rx_Tx_Swap UART Advanced Feature RX TX Pins Swap\r
 522   * @{\r
 523   */\r
 524 #define UART_ADVFEATURE_SWAP_DISABLE        0x00000000U             /*!< TX/RX pins swap disable */\r
 525 #define UART_ADVFEATURE_SWAP_ENABLE         USART_CR2_SWAP          /*!< TX/RX pins swap enable  */\r
 526 /**\r
 527   * @}\r
 528   */\r
 529 \r
 530 /** @defgroup UART_Overrun_Disable  UART Advanced Feature Overrun Disable\r
 531   * @{\r
 532   */\r
 533 #define UART_ADVFEATURE_OVERRUN_ENABLE      0x00000000U             /*!< RX overrun enable  */\r
 534 #define UART_ADVFEATURE_OVERRUN_DISABLE     USART_CR3_OVRDIS        /*!< RX overrun disable */\r
 535 /**\r
 536   * @}\r
 537   */\r
 538 \r
 539 /** @defgroup UART_AutoBaudRate_Enable  UART Advanced Feature Auto BaudRate Enable\r
 540   * @{\r
 541   */\r
 542 #define UART_ADVFEATURE_AUTOBAUDRATE_DISABLE   0x00000000U          /*!< RX Auto Baud rate detection enable  */\r
 543 #define UART_ADVFEATURE_AUTOBAUDRATE_ENABLE    USART_CR2_ABREN      /*!< RX Auto Baud rate detection disable */\r
 544 /**\r
 545   * @}\r
 546   */\r
 547 \r
 548 /** @defgroup UART_DMA_Disable_on_Rx_Error   UART Advanced Feature DMA Disable On Rx Error\r
 549   * @{\r
 550   */\r
 551 #define UART_ADVFEATURE_DMA_ENABLEONRXERROR    0x00000000U          /*!< DMA enable on Reception Error  */\r
 552 #define UART_ADVFEATURE_DMA_DISABLEONRXERROR   USART_CR3_DDRE       /*!< DMA disable on Reception Error */\r
 553 /**\r
 554   * @}\r
 555   */\r
 556 \r
 557 /** @defgroup UART_MSB_First   UART Advanced Feature MSB First\r
 558   * @{\r
 559   */\r
 560 #define UART_ADVFEATURE_MSBFIRST_DISABLE    0x00000000U             /*!< Most significant bit sent/received first disable */\r
 561 #define UART_ADVFEATURE_MSBFIRST_ENABLE     USART_CR2_MSBFIRST      /*!< Most significant bit sent/received first enable  */\r
 562 /**\r
 563   * @}\r
 564   */\r
 565 \r
 566 /** @defgroup UART_Mute_Mode   UART Advanced Feature Mute Mode Enable\r
 567   * @{\r
 568   */\r
 569 #define UART_ADVFEATURE_MUTEMODE_DISABLE    0x00000000U             /*!< UART mute mode disable */\r
 570 #define UART_ADVFEATURE_MUTEMODE_ENABLE     USART_CR1_MME           /*!< UART mute mode enable  */\r
 571 /**\r
 572   * @}\r
 573   */\r
 574 \r
 575 /** @defgroup UART_CR2_ADDRESS_LSB_POS    UART Address-matching LSB Position In CR2 Register\r
 576   * @{\r
 577   */\r
 578 #define UART_CR2_ADDRESS_LSB_POS             24U                                /*!< UART address-matching LSB position in CR2 register */\r
 579 /**\r
 580   * @}\r
 581   */\r
 582 \r
 583 /** @defgroup UART_DriverEnable_Polarity      UART DriverEnable Polarity\r
 584   * @{\r
 585   */\r
 586 #define UART_DE_POLARITY_HIGH               0x00000000U             /*!< Driver enable signal is active high */\r
 587 #define UART_DE_POLARITY_LOW                USART_CR3_DEP           /*!< Driver enable signal is active low  */\r
 588 /**\r
 589   * @}\r
 590   */\r
 591 \r
 592 /** @defgroup UART_CR1_DEAT_ADDRESS_LSB_POS    UART Driver Enable Assertion Time LSB Position In CR1 Register\r
 593   * @{\r
 594   */\r
 595 #define UART_CR1_DEAT_ADDRESS_LSB_POS       21U      /*!< UART Driver Enable assertion time LSB position in CR1 register */\r
 596 /**\r
 597   * @}\r
 598   */\r
 599 \r
 600 /** @defgroup UART_CR1_DEDT_ADDRESS_LSB_POS    UART Driver Enable DeAssertion Time LSB Position In CR1 Register\r
 601   * @{\r
 602   */\r
 603 #define UART_CR1_DEDT_ADDRESS_LSB_POS       16U      /*!< UART Driver Enable de-assertion time LSB position in CR1 register */\r
 604 /**\r
 605   * @}\r
 606   */\r
 607 \r
 608 /** @defgroup UART_Interruption_Mask    UART Interruptions Flag Mask\r
 609   * @{\r
 610   */\r
 611 #define UART_IT_MASK                        0x001FU  /*!< UART interruptions flags mask */\r
 612 /**\r
 613   * @}\r
 614   */\r
 615 \r
 616 /** @defgroup UART_TimeOut_Value    UART polling-based communications time-out value\r
 617   * @{\r
 618   */\r
 619 #define HAL_UART_TIMEOUT_VALUE              0x1FFFFFFU  /*!< UART polling-based communications time-out value */\r
 620 /**\r
 621   * @}\r
 622   */\r
 623 \r
 624 /** @defgroup UART_Flags     UART Status Flags\r
 625   *        Elements values convention: 0xXXXX\r
 626   *           - 0xXXXX  : Flag mask in the ISR register\r
 627   * @{\r
 628   */\r
 629 #define UART_FLAG_TEACK                     USART_ISR_TEACK         /*!< UART transmit enable acknowledge flag     */\r
 630 #define UART_FLAG_RWU                       USART_ISR_RWU           /*!< UART receiver wake-up from mute mode flag */\r
 631 #define UART_FLAG_SBKF                      USART_ISR_SBKF          /*!< UART send break flag                      */\r
 632 #define UART_FLAG_CMF                       USART_ISR_CMF           /*!< UART character match flag                 */\r
 633 #define UART_FLAG_BUSY                      USART_ISR_BUSY          /*!< UART busy flag                            */\r
 634 #define UART_FLAG_ABRF                      USART_ISR_ABRF          /*!< UART auto Baud rate flag                  */\r
 635 #define UART_FLAG_ABRE                      USART_ISR_ABRE          /*!< UART auto Baud rate error                 */\r
 636 #define UART_FLAG_CTS                       USART_ISR_CTS           /*!< UART clear to send flag                   */\r
 637 #define UART_FLAG_CTSIF                     USART_ISR_CTSIF         /*!< UART clear to send interrupt flag         */\r
 638 #define UART_FLAG_LBDF                      USART_ISR_LBDF          /*!< UART LIN break detection flag             */\r
 639 #define UART_FLAG_TXE                       USART_ISR_TXE           /*!< UART transmit data register empty         */\r
 640 #define UART_FLAG_TC                        USART_ISR_TC            /*!< UART transmission complete                */\r
 641 #define UART_FLAG_RXNE                      USART_ISR_RXNE          /*!< UART read data register not empty         */\r
 642 #define UART_FLAG_IDLE                      USART_ISR_IDLE          /*!< UART idle flag                            */\r
 643 #define UART_FLAG_ORE                       USART_ISR_ORE           /*!< UART overrun error                        */\r
 644 #define UART_FLAG_NE                        USART_ISR_NE            /*!< UART noise error                          */\r
 645 #define UART_FLAG_FE                        USART_ISR_FE            /*!< UART frame error                          */\r
 646 #define UART_FLAG_PE                        USART_ISR_PE            /*!< UART parity error                         */\r
 647 /**\r
 648   * @}\r
 649   */\r
 650 \r
 651 /** @defgroup UART_Interrupt_definition   UART Interrupts Definition\r
 652   *        Elements values convention: 000ZZZZZ0XXYYYYYb\r
 653   *           - YYYYY  : Interrupt source position in the XX register (5bits)\r
 654   *           - XX  : Interrupt source register (2bits)\r
 655   *                 - 01: CR1 register\r
 656   *                 - 10: CR2 register\r
 657   *                 - 11: CR3 register\r
 658   *           - ZZZZZ  : Flag position in the ISR register(5bits)\r
 659   *        Elements values convention: 000000000XXYYYYYb\r
 660   *           - YYYYY  : Interrupt source position in the XX register (5bits)\r
 661   *           - XX  : Interrupt source register (2bits)\r
 662   *                 - 01: CR1 register\r
 663   *                 - 10: CR2 register\r
 664   *                 - 11: CR3 register\r
 665   *        Elements values convention: 0000ZZZZ00000000b\r
 666   *           - ZZZZ  : Flag position in the ISR register(4bits)\r
 667   * @{\r
 668   */\r
 669 #define UART_IT_PE                          0x0028U                  /*!< UART parity error interruption                 */\r
 670 #define UART_IT_TXE                         0x0727U                  /*!< UART transmit data register empty interruption */\r
 671 #define UART_IT_TC                          0x0626U                  /*!< UART transmission complete interruption        */\r
 672 #define UART_IT_RXNE                        0x0525U                  /*!< UART read data register not empty interruption */\r
 673 #define UART_IT_IDLE                        0x0424U                  /*!< UART idle interruption                         */\r
 674 #define UART_IT_LBD                         0x0846U                  /*!< UART LIN break detection interruption          */\r
 675 #define UART_IT_CTS                         0x096AU                  /*!< UART CTS interruption                          */\r
 676 #define UART_IT_CM                          0x112EU                  /*!< UART character match interruption              */\r
 677 \r
 678 #define UART_IT_ERR                         0x0060U                  /*!< UART error interruption         */\r
 679 \r
 680 #define UART_IT_ORE                         0x0300U                  /*!< UART overrun error interruption */\r
 681 #define UART_IT_NE                          0x0200U                  /*!< UART noise error interruption   */\r
 682 #define UART_IT_FE                          0x0100U                  /*!< UART frame error interruption   */\r
 683 /**\r
 684   * @}\r
 685   */\r
 686 \r
 687 /** @defgroup UART_IT_CLEAR_Flags  UART Interruption Clear Flags\r
 688   * @{\r
 689   */\r
 690 #define UART_CLEAR_PEF                       USART_ICR_PECF            /*!< Parity Error Clear Flag           */\r
 691 #define UART_CLEAR_FEF                       USART_ICR_FECF            /*!< Framing Error Clear Flag          */\r
 692 #define UART_CLEAR_NEF                       USART_ICR_NCF            /*!< Noise Error detected Clear Flag   */\r
 693 #define UART_CLEAR_OREF                      USART_ICR_ORECF           /*!< Overrun Error Clear Flag          */\r
 694 #define UART_CLEAR_IDLEF                     USART_ICR_IDLECF          /*!< IDLE line detected Clear Flag     */\r
 695 #define UART_CLEAR_TCF                       USART_ICR_TCCF            /*!< Transmission Complete Clear Flag  */\r
 696 #define UART_CLEAR_LBDF                      USART_ICR_LBDCF           /*!< LIN Break Detection Clear Flag    */\r
 697 #define UART_CLEAR_CTSF                      USART_ICR_CTSCF           /*!< CTS Interrupt Clear Flag          */\r
 698 #define UART_CLEAR_CMF                       USART_ICR_CMCF            /*!< Character Match Clear Flag        */\r
 699 /**\r
 700   * @}\r
 701   */\r
 702 \r
 703 \r
 704 /**\r
 705   * @}\r
 706   */\r
 707 \r
 708 /* Exported macros -----------------------------------------------------------*/\r
 709 /** @defgroup UART_Exported_Macros UART Exported Macros\r
 710   * @{\r
 711   */\r
 712 \r
 713 /** @brief  Reset UART handle states.\r
 714   * @param  __HANDLE__ UART handle.\r
 715   * @retval None\r
 716   */\r
 717 #if (USE_HAL_UART_REGISTER_CALLBACKS == 1)\r
 718 #define __HAL_UART_RESET_HANDLE_STATE(__HANDLE__)  do{                                                   \\r
 719                                                        (__HANDLE__)->gState = HAL_UART_STATE_RESET;      \\r
 720                                                        (__HANDLE__)->RxState = HAL_UART_STATE_RESET;     \\r
 721                                                        (__HANDLE__)->MspInitCallback = NULL;             \\r
 722                                                        (__HANDLE__)->MspDeInitCallback = NULL;           \\r
 723                                                      } while(0U)\r
 724 #else\r
 725 #define __HAL_UART_RESET_HANDLE_STATE(__HANDLE__)  do{                                                   \\r
 726                                                        (__HANDLE__)->gState = HAL_UART_STATE_RESET;      \\r
 727                                                        (__HANDLE__)->RxState = HAL_UART_STATE_RESET;     \\r
 728                                                      } while(0U)\r
 729 #endif /*USE_HAL_UART_REGISTER_CALLBACKS */\r
 730 \r
 731 /** @brief  Flush the UART Data registers.\r
 732   * @param  __HANDLE__ specifies the UART Handle.\r
 733   * @retval None\r
 734   */\r
 735 #define __HAL_UART_FLUSH_DRREGISTER(__HANDLE__)  \\r
 736   do{                \\r
 737       SET_BIT((__HANDLE__)->Instance->RQR, UART_RXDATA_FLUSH_REQUEST); \\r
 738       SET_BIT((__HANDLE__)->Instance->RQR, UART_TXDATA_FLUSH_REQUEST); \\r
 739     }  while(0U)\r
 740 \r
 741 /** @brief  Clear the specified UART pending flag.\r
 742   * @param  __HANDLE__ specifies the UART Handle.\r
 743   * @param  __FLAG__ specifies the flag to check.\r
 744   *          This parameter can be any combination of the following values:\r
 745   *            @arg @ref UART_CLEAR_PEF      Parity Error Clear Flag\r
 746   *            @arg @ref UART_CLEAR_FEF      Framing Error Clear Flag\r
 747   *            @arg @ref UART_CLEAR_NEF      Noise detected Clear Flag\r
 748   *            @arg @ref UART_CLEAR_OREF     Overrun Error Clear Flag\r
 749   *            @arg @ref UART_CLEAR_IDLEF    IDLE line detected Clear Flag\r
 750   *            @arg @ref UART_CLEAR_TCF      Transmission Complete Clear Flag\r
 751   *            @arg @ref UART_CLEAR_LBDF     LIN Break Detection Clear Flag\r
 752   *            @arg @ref UART_CLEAR_CTSF     CTS Interrupt Clear Flag\r
 753   *            @arg @ref UART_CLEAR_CMF      Character Match Clear Flag\r
 754   * @retval None\r
 755   */\r
 756 #define __HAL_UART_CLEAR_FLAG(__HANDLE__, __FLAG__) ((__HANDLE__)->Instance->ICR = (__FLAG__))\r
 757 \r
 758 /** @brief  Clear the UART PE pending flag.\r
 759   * @param  __HANDLE__ specifies the UART Handle.\r
 760   * @retval None\r
 761   */\r
 762 #define __HAL_UART_CLEAR_PEFLAG(__HANDLE__)   __HAL_UART_CLEAR_FLAG((__HANDLE__), UART_CLEAR_PEF)\r
 763 \r
 764 /** @brief  Clear the UART FE pending flag.\r
 765   * @param  __HANDLE__ specifies the UART Handle.\r
 766   * @retval None\r
 767   */\r
 768 #define __HAL_UART_CLEAR_FEFLAG(__HANDLE__)   __HAL_UART_CLEAR_FLAG((__HANDLE__), UART_CLEAR_FEF)\r
 769 \r
 770 /** @brief  Clear the UART NE pending flag.\r
 771   * @param  __HANDLE__ specifies the UART Handle.\r
 772   * @retval None\r
 773   */\r
 774 #define __HAL_UART_CLEAR_NEFLAG(__HANDLE__)  __HAL_UART_CLEAR_FLAG((__HANDLE__), UART_CLEAR_NEF)\r
 775 \r
 776 /** @brief  Clear the UART ORE pending flag.\r
 777   * @param  __HANDLE__ specifies the UART Handle.\r
 778   * @retval None\r
 779   */\r
 780 #define __HAL_UART_CLEAR_OREFLAG(__HANDLE__)   __HAL_UART_CLEAR_FLAG((__HANDLE__), UART_CLEAR_OREF)\r
 781 \r
 782 /** @brief  Clear the UART IDLE pending flag.\r
 783   * @param  __HANDLE__ specifies the UART Handle.\r
 784   * @retval None\r
 785   */\r
 786 #define __HAL_UART_CLEAR_IDLEFLAG(__HANDLE__)   __HAL_UART_CLEAR_FLAG((__HANDLE__), UART_CLEAR_IDLEF)\r
 787 \r
 788 \r
 789 /** @brief  Check whether the specified UART flag is set or not.\r
 790   * @param  __HANDLE__ specifies the UART Handle.\r
 791   * @param  __FLAG__ specifies the flag to check.\r
 792   *        This parameter can be one of the following values:\r
 793   *            @arg @ref UART_FLAG_TEACK Transmit enable acknowledge flag\r
 794   *            @arg @ref UART_FLAG_RWU   Receiver wake up flag (if the UART in mute mode)\r
 795   *            @arg @ref UART_FLAG_SBKF  Send Break flag\r
 796   *            @arg @ref UART_FLAG_CMF   Character match flag\r
 797   *            @arg @ref UART_FLAG_BUSY  Busy flag\r
 798   *            @arg @ref UART_FLAG_ABRF  Auto Baud rate detection flag\r
 799   *            @arg @ref UART_FLAG_ABRE  Auto Baud rate detection error flag\r
 800   *            @arg @ref UART_FLAG_CTS   CTS Change flag\r
 801   *            @arg @ref UART_FLAG_LBDF  LIN Break detection flag\r
 802   *            @arg @ref UART_FLAG_TXE   Transmit data register empty flag\r
 803   *            @arg @ref UART_FLAG_TC    Transmission Complete flag\r
 804   *            @arg @ref UART_FLAG_RXNE  Receive data register not empty flag\r
 805   *            @arg @ref UART_FLAG_IDLE  Idle Line detection flag\r
 806   *            @arg @ref UART_FLAG_ORE   Overrun Error flag\r
 807   *            @arg @ref UART_FLAG_NE    Noise Error flag\r
 808   *            @arg @ref UART_FLAG_FE    Framing Error flag\r
 809   *            @arg @ref UART_FLAG_PE    Parity Error flag\r
 810   * @retval The new state of __FLAG__ (TRUE or FALSE).\r
 811   */\r
 812 #define __HAL_UART_GET_FLAG(__HANDLE__, __FLAG__) (((__HANDLE__)->Instance->ISR & (__FLAG__)) == (__FLAG__))\r
 813 \r
 814 /** @brief  Enable the specified UART interrupt.\r
 815   * @param  __HANDLE__ specifies the UART Handle.\r
 816   * @param  __INTERRUPT__ specifies the UART interrupt source to enable.\r
 817   *          This parameter can be one of the following values:\r
 818   *            @arg @ref UART_IT_CM    Character match interrupt\r
 819   *            @arg @ref UART_IT_CTS   CTS change interrupt\r
 820   *            @arg @ref UART_IT_LBD   LIN Break detection interrupt\r
 821   *            @arg @ref UART_IT_TXE   Transmit Data Register empty interrupt\r
 822   *            @arg @ref UART_IT_TC    Transmission complete interrupt\r
 823   *            @arg @ref UART_IT_RXNE  Receive Data register not empty interrupt\r
 824   *            @arg @ref UART_IT_IDLE  Idle line detection interrupt\r
 825   *            @arg @ref UART_IT_PE    Parity Error interrupt\r
 826   *            @arg @ref UART_IT_ERR   Error interrupt (frame error, noise error, overrun error)\r
 827   * @retval None\r
 828   */\r
 829 #define __HAL_UART_ENABLE_IT(__HANDLE__, __INTERRUPT__)   (((((uint8_t)(__INTERRUPT__)) >> 5U) == 1U)? ((__HANDLE__)->Instance->CR1 |= (1U << ((__INTERRUPT__) & UART_IT_MASK))): \\r
 830                                                            ((((uint8_t)(__INTERRUPT__)) >> 5U) == 2U)? ((__HANDLE__)->Instance->CR2 |= (1U << ((__INTERRUPT__) & UART_IT_MASK))): \\r
 831                                                            ((__HANDLE__)->Instance->CR3 |= (1U << ((__INTERRUPT__) & UART_IT_MASK))))\r
 832 \r
 833 \r
 834 /** @brief  Disable the specified UART interrupt.\r
 835   * @param  __HANDLE__ specifies the UART Handle.\r
 836   * @param  __INTERRUPT__ specifies the UART interrupt source to disable.\r
 837   *          This parameter can be one of the following values:\r
 838   *            @arg @ref UART_IT_CM    Character match interrupt\r
 839   *            @arg @ref UART_IT_CTS   CTS change interrupt\r
 840   *            @arg @ref UART_IT_LBD   LIN Break detection interrupt\r
 841   *            @arg @ref UART_IT_TXE   Transmit Data Register empty interrupt\r
 842   *            @arg @ref UART_IT_TC    Transmission complete interrupt\r
 843   *            @arg @ref UART_IT_RXNE  Receive Data register not empty interrupt\r
 844   *            @arg @ref UART_IT_IDLE  Idle line detection interrupt\r
 845   *            @arg @ref UART_IT_PE    Parity Error interrupt\r
 846   *            @arg @ref UART_IT_ERR   Error interrupt (Frame error, noise error, overrun error)\r
 847   * @retval None\r
 848   */\r
 849 #define __HAL_UART_DISABLE_IT(__HANDLE__, __INTERRUPT__)  (((((uint8_t)(__INTERRUPT__)) >> 5U) == 1U)? ((__HANDLE__)->Instance->CR1 &= ~ (1U << ((__INTERRUPT__) & UART_IT_MASK))): \\r
 850                                                            ((((uint8_t)(__INTERRUPT__)) >> 5U) == 2U)? ((__HANDLE__)->Instance->CR2 &= ~ (1U << ((__INTERRUPT__) & UART_IT_MASK))): \\r
 851                                                            ((__HANDLE__)->Instance->CR3 &= ~ (1U << ((__INTERRUPT__) & UART_IT_MASK))))\r
 852 \r
 853 /** @brief  Check whether the specified UART interrupt has occurred or not.\r
 854   * @param  __HANDLE__ specifies the UART Handle.\r
 855   * @param  __INTERRUPT__ specifies the UART interrupt to check.\r
 856   *          This parameter can be one of the following values:\r
 857   *            @arg @ref UART_IT_CM    Character match interrupt\r
 858   *            @arg @ref UART_IT_CTS   CTS change interrupt\r
 859   *            @arg @ref UART_IT_LBD   LIN Break detection interrupt\r
 860   *            @arg @ref UART_IT_TXE   Transmit Data Register empty interrupt\r
 861   *            @arg @ref UART_IT_TC    Transmission complete interrupt\r
 862   *            @arg @ref UART_IT_RXNE  Receive Data register not empty interrupt\r
 863   *            @arg @ref UART_IT_IDLE  Idle line detection interrupt\r
 864   *            @arg @ref UART_IT_PE    Parity Error interrupt\r
 865   *            @arg @ref UART_IT_ERR   Error interrupt (Frame error, noise error, overrun error)\r
 866   * @retval The new state of __INTERRUPT__ (SET or RESET).\r
 867   */\r
 868 #define __HAL_UART_GET_IT(__HANDLE__, __INTERRUPT__) ((((__HANDLE__)->Instance->ISR & (1U << ((__INTERRUPT__)>> 8U))) != RESET) ? SET : RESET)\r
 869 \r
 870 /** @brief  Check whether the specified UART interrupt source is enabled or not.\r
 871   * @param  __HANDLE__ specifies the UART Handle.\r
 872   * @param  __INTERRUPT__ specifies the UART interrupt source to check.\r
 873   *          This parameter can be one of the following values:\r
 874   *            @arg @ref UART_IT_CM    Character match interrupt\r
 875   *            @arg @ref UART_IT_CTS   CTS change interrupt\r
 876   *            @arg @ref UART_IT_LBD   LIN Break detection interrupt\r
 877   *            @arg @ref UART_IT_TXE   Transmit Data Register empty interrupt\r
 878   *            @arg @ref UART_IT_TC    Transmission complete interrupt\r
 879   *            @arg @ref UART_IT_RXNE  Receive Data register not empty interrupt\r
 880   *            @arg @ref UART_IT_IDLE  Idle line detection interrupt\r
 881   *            @arg @ref UART_IT_PE    Parity Error interrupt\r
 882   *            @arg @ref UART_IT_ERR   Error interrupt (Frame error, noise error, overrun error)\r
 883   * @retval The new state of __INTERRUPT__ (SET or RESET).\r
 884   */\r
 885 #define __HAL_UART_GET_IT_SOURCE(__HANDLE__, __INTERRUPT__) ((((((((uint8_t)(__INTERRUPT__)) >> 5U) == 1U) ? (__HANDLE__)->Instance->CR1 : \\r
 886                                                                (((((uint8_t)(__INTERRUPT__)) >> 5U) == 2U) ? (__HANDLE__)->Instance->CR2 : \\r
 887                                                                (__HANDLE__)->Instance->CR3)) & (1U << (((uint16_t)(__INTERRUPT__)) & UART_IT_MASK)))  != RESET) ? SET : RESET)\r
 888 \r
 889 /** @brief  Clear the specified UART ISR flag, in setting the proper ICR register flag.\r
 890   * @param  __HANDLE__ specifies the UART Handle.\r
 891   * @param  __IT_CLEAR__ specifies the interrupt clear register flag that needs to be set\r
 892   *                       to clear the corresponding interrupt\r
 893   *          This parameter can be one of the following values:\r
 894   *            @arg @ref UART_CLEAR_PEF    Parity Error Clear Flag\r
 895   *            @arg @ref UART_CLEAR_FEF    Framing Error Clear Flag\r
 896   *            @arg @ref UART_CLEAR_NEF    Noise detected Clear Flag\r
 897   *            @arg @ref UART_CLEAR_OREF   Overrun Error Clear Flag\r
 898   *            @arg @ref UART_CLEAR_IDLEF  IDLE line detected Clear Flag\r
 899   *            @arg @ref UART_CLEAR_TCF    Transmission Complete Clear Flag\r
 900   *            @arg @ref UART_CLEAR_LBDF   LIN Break Detection Clear Flag\r
 901   *            @arg @ref UART_CLEAR_CTSF   CTS Interrupt Clear Flag\r
 902   *            @arg @ref UART_CLEAR_CMF    Character Match Clear Flag\r
 903   * @retval None\r
 904   */\r
 905 #define __HAL_UART_CLEAR_IT(__HANDLE__, __IT_CLEAR__) ((__HANDLE__)->Instance->ICR = (uint32_t)(__IT_CLEAR__))\r
 906 \r
 907 /** @brief  Set a specific UART request flag.\r
 908   * @param  __HANDLE__ specifies the UART Handle.\r
 909   * @param  __REQ__ specifies the request flag to set\r
 910   *          This parameter can be one of the following values:\r
 911   *            @arg @ref UART_AUTOBAUD_REQUEST Auto-Baud Rate Request\r
 912   *            @arg @ref UART_SENDBREAK_REQUEST Send Break Request\r
 913   *            @arg @ref UART_MUTE_MODE_REQUEST Mute Mode Request\r
 914   *            @arg @ref UART_RXDATA_FLUSH_REQUEST Receive Data flush Request\r
 915   *            @arg @ref UART_TXDATA_FLUSH_REQUEST Transmit data flush Request\r
 916   * @retval None\r
 917   */\r
 918 #define __HAL_UART_SEND_REQ(__HANDLE__, __REQ__) ((__HANDLE__)->Instance->RQR |= (uint16_t)(__REQ__))\r
 919 \r
 920 /** @brief  Enable the UART one bit sample method.\r
 921   * @param  __HANDLE__ specifies the UART Handle.\r
 922   * @retval None\r
 923   */\r
 924 #define __HAL_UART_ONE_BIT_SAMPLE_ENABLE(__HANDLE__) ((__HANDLE__)->Instance->CR3|= USART_CR3_ONEBIT)\r
 925 \r
 926 /** @brief  Disable the UART one bit sample method.\r
 927   * @param  __HANDLE__ specifies the UART Handle.\r
 928   * @retval None\r
 929   */\r
 930 #define __HAL_UART_ONE_BIT_SAMPLE_DISABLE(__HANDLE__) ((__HANDLE__)->Instance->CR3 &= ~USART_CR3_ONEBIT)\r
 931 \r
 932 /** @brief  Enable UART.\r
 933   * @param  __HANDLE__ specifies the UART Handle.\r
 934   * @retval None\r
 935   */\r
 936 #define __HAL_UART_ENABLE(__HANDLE__)                   ((__HANDLE__)->Instance->CR1 |= USART_CR1_UE)\r
 937 \r
 938 /** @brief  Disable UART.\r
 939   * @param  __HANDLE__ specifies the UART Handle.\r
 940   * @retval None\r
 941   */\r
 942 #define __HAL_UART_DISABLE(__HANDLE__)                  ((__HANDLE__)->Instance->CR1 &= ~USART_CR1_UE)\r
 943 \r
 944 /** @brief  Enable CTS flow control.\r
 945   * @note   This macro allows to enable CTS hardware flow control for a given UART instance,\r
 946   *         without need to call HAL_UART_Init() function.\r
 947   *         As involving direct access to UART registers, usage of this macro should be fully endorsed by user.\r
 948   * @note   As macro is expected to be used for modifying CTS Hw flow control feature activation, without need\r
 949   *         for USART instance Deinit/Init, following conditions for macro call should be fulfilled :\r
 950   *           - UART instance should have already been initialised (through call of HAL_UART_Init() )\r
 951   *           - macro could only be called when corresponding UART instance is disabled (i.e. __HAL_UART_DISABLE(__HANDLE__))\r
 952   *             and should be followed by an Enable macro (i.e. __HAL_UART_ENABLE(__HANDLE__)).\r
 953   * @param  __HANDLE__ specifies the UART Handle.\r
 954   * @retval None\r
 955   */\r
 956 #define __HAL_UART_HWCONTROL_CTS_ENABLE(__HANDLE__)        \\r
 957   do{                                                      \\r
 958     SET_BIT((__HANDLE__)->Instance->CR3, USART_CR3_CTSE);  \\r
 959     (__HANDLE__)->Init.HwFlowCtl |= USART_CR3_CTSE;        \\r
 960   } while(0U)\r
 961 \r
 962 /** @brief  Disable CTS flow control.\r
 963   * @note   This macro allows to disable CTS hardware flow control for a given UART instance,\r
 964   *         without need to call HAL_UART_Init() function.\r
 965   *         As involving direct access to UART registers, usage of this macro should be fully endorsed by user.\r
 966   * @note   As macro is expected to be used for modifying CTS Hw flow control feature activation, without need\r
 967   *         for USART instance Deinit/Init, following conditions for macro call should be fulfilled :\r
 968   *           - UART instance should have already been initialised (through call of HAL_UART_Init() )\r
 969   *           - macro could only be called when corresponding UART instance is disabled (i.e. __HAL_UART_DISABLE(__HANDLE__))\r
 970   *             and should be followed by an Enable macro (i.e. __HAL_UART_ENABLE(__HANDLE__)).\r
 971   * @param  __HANDLE__ specifies the UART Handle.\r
 972   * @retval None\r
 973   */\r
 974 #define __HAL_UART_HWCONTROL_CTS_DISABLE(__HANDLE__)        \\r
 975   do{                                                       \\r
 976     CLEAR_BIT((__HANDLE__)->Instance->CR3, USART_CR3_CTSE); \\r
 977     (__HANDLE__)->Init.HwFlowCtl &= ~(USART_CR3_CTSE);      \\r
 978   } while(0U)\r
 979 \r
 980 /** @brief  Enable RTS flow control.\r
 981   * @note   This macro allows to enable RTS hardware flow control for a given UART instance,\r
 982   *         without need to call HAL_UART_Init() function.\r
 983   *         As involving direct access to UART registers, usage of this macro should be fully endorsed by user.\r
 984   * @note   As macro is expected to be used for modifying RTS Hw flow control feature activation, without need\r
 985   *         for USART instance Deinit/Init, following conditions for macro call should be fulfilled :\r
 986   *           - UART instance should have already been initialised (through call of HAL_UART_Init() )\r
 987   *           - macro could only be called when corresponding UART instance is disabled (i.e. __HAL_UART_DISABLE(__HANDLE__))\r
 988   *             and should be followed by an Enable macro (i.e. __HAL_UART_ENABLE(__HANDLE__)).\r
 989   * @param  __HANDLE__ specifies the UART Handle.\r
 990   * @retval None\r
 991   */\r
 992 #define __HAL_UART_HWCONTROL_RTS_ENABLE(__HANDLE__)       \\r
 993   do{                                                     \\r
 994     SET_BIT((__HANDLE__)->Instance->CR3, USART_CR3_RTSE); \\r
 995     (__HANDLE__)->Init.HwFlowCtl |= USART_CR3_RTSE;       \\r
 996   } while(0U)\r
 997 \r
 998 /** @brief  Disable RTS flow control.\r
 999   * @note   This macro allows to disable RTS hardware flow control for a given UART instance,\r
1000   *         without need to call HAL_UART_Init() function.\r
1001   *         As involving direct access to UART registers, usage of this macro should be fully endorsed by user.\r
1002   * @note   As macro is expected to be used for modifying RTS Hw flow control feature activation, without need\r
1003   *         for USART instance Deinit/Init, following conditions for macro call should be fulfilled :\r
1004   *           - UART instance should have already been initialised (through call of HAL_UART_Init() )\r
1005   *           - macro could only be called when corresponding UART instance is disabled (i.e. __HAL_UART_DISABLE(__HANDLE__))\r
1006   *             and should be followed by an Enable macro (i.e. __HAL_UART_ENABLE(__HANDLE__)).\r
1007   * @param  __HANDLE__ specifies the UART Handle.\r
1008   * @retval None\r
1009   */\r
1010 #define __HAL_UART_HWCONTROL_RTS_DISABLE(__HANDLE__)       \\r
1011   do{                                                      \\r
1012     CLEAR_BIT((__HANDLE__)->Instance->CR3, USART_CR3_RTSE);\\r
1013     (__HANDLE__)->Init.HwFlowCtl &= ~(USART_CR3_RTSE);     \\r
1014   } while(0U)\r
1015 /**\r
1016   * @}\r
1017   */\r
1018 \r
1019 /* Private macros --------------------------------------------------------*/\r
1020 /** @defgroup UART_Private_Macros   UART Private Macros\r
1021   * @{\r
1022   */\r
1023 \r
1024 \r
1025 /** @brief  BRR division operation to set BRR register in 8-bit oversampling mode.\r
1026   * @param  __PCLK__ UART clock.\r
1027   * @param  __BAUD__ Baud rate set by the user.\r
1028   * @retval Division result\r
1029   */\r
1030 #define UART_DIV_SAMPLING8(__PCLK__, __BAUD__)   ((((__PCLK__)*2U) + ((__BAUD__)/2U)) / (__BAUD__))\r
1031 \r
1032 /** @brief  BRR division operation to set BRR register in 16-bit oversampling mode.\r
1033   * @param  __PCLK__ UART clock.\r
1034   * @param  __BAUD__ Baud rate set by the user.\r
1035   * @retval Division result\r
1036   */\r
1037 #define UART_DIV_SAMPLING16(__PCLK__, __BAUD__)  (((__PCLK__) + ((__BAUD__)/2U)) / (__BAUD__))\r
1038 \r
1039 \r
1040 /** @brief  Check UART Baud rate.\r
1041   * @param  __BAUDRATE__ Baudrate specified by the user.\r
1042   *         The maximum Baud Rate is derived from the maximum clock on F7 (i.e. 216 MHz)\r
1043   *         divided by the smallest oversampling used on the USART (i.e. 8)\r
1044   * @retval SET (__BAUDRATE__ is valid) or RESET (__BAUDRATE__ is invalid)\r
1045   */\r
1046 #define IS_UART_BAUDRATE(__BAUDRATE__) ((__BAUDRATE__) < 27000001U)\r
1047 \r
1048 /** @brief  Check UART assertion time.\r
1049   * @param  __TIME__ 5-bit value assertion time.\r
1050   * @retval Test result (TRUE or FALSE).\r
1051   */\r
1052 #define IS_UART_ASSERTIONTIME(__TIME__)    ((__TIME__) <= 0x1FU)\r
1053 \r
1054 /** @brief  Check UART deassertion time.\r
1055   * @param  __TIME__ 5-bit value deassertion time.\r
1056   * @retval Test result (TRUE or FALSE).\r
1057   */\r
1058 #define IS_UART_DEASSERTIONTIME(__TIME__) ((__TIME__) <= 0x1FU)\r
1059 \r
1060 /**\r
1061   * @brief Ensure that UART frame number of stop bits is valid.\r
1062   * @param __STOPBITS__ UART frame number of stop bits.\r
1063   * @retval SET (__STOPBITS__ is valid) or RESET (__STOPBITS__ is invalid)\r
1064   */\r
1065 #define IS_UART_STOPBITS(__STOPBITS__) (((__STOPBITS__) == UART_STOPBITS_0_5) || \\r
1066                                         ((__STOPBITS__) == UART_STOPBITS_1)   || \\r
1067                                         ((__STOPBITS__) == UART_STOPBITS_1_5) || \\r
1068                                         ((__STOPBITS__) == UART_STOPBITS_2))\r
1069 \r
1070 \r
1071 /**\r
1072   * @brief Ensure that UART frame parity is valid.\r
1073   * @param __PARITY__ UART frame parity.\r
1074   * @retval SET (__PARITY__ is valid) or RESET (__PARITY__ is invalid)\r
1075   */\r
1076 #define IS_UART_PARITY(__PARITY__) (((__PARITY__) == UART_PARITY_NONE) || \\r
1077                                     ((__PARITY__) == UART_PARITY_EVEN) || \\r
1078                                     ((__PARITY__) == UART_PARITY_ODD))\r
1079 \r
1080 /**\r
1081   * @brief Ensure that UART hardware flow control is valid.\r
1082   * @param __CONTROL__ UART hardware flow control.\r
1083   * @retval SET (__CONTROL__ is valid) or RESET (__CONTROL__ is invalid)\r
1084   */\r
1085 #define IS_UART_HARDWARE_FLOW_CONTROL(__CONTROL__)\\r
1086                                    (((__CONTROL__) == UART_HWCONTROL_NONE) || \\r
1087                                     ((__CONTROL__) == UART_HWCONTROL_RTS)  || \\r
1088                                     ((__CONTROL__) == UART_HWCONTROL_CTS)  || \\r
1089                                     ((__CONTROL__) == UART_HWCONTROL_RTS_CTS))\r
1090 \r
1091 /**\r
1092   * @brief Ensure that UART communication mode is valid.\r
1093   * @param __MODE__ UART communication mode.\r
1094   * @retval SET (__MODE__ is valid) or RESET (__MODE__ is invalid)\r
1095   */\r
1096 #define IS_UART_MODE(__MODE__) ((((__MODE__) & (~((uint32_t)(UART_MODE_TX_RX)))) == 0x00U) && ((__MODE__) != 0x00U))\r
1097 \r
1098 /**\r
1099   * @brief Ensure that UART state is valid.\r
1100   * @param __STATE__ UART state.\r
1101   * @retval SET (__STATE__ is valid) or RESET (__STATE__ is invalid)\r
1102   */\r
1103 #define IS_UART_STATE(__STATE__) (((__STATE__) == UART_STATE_DISABLE) || \\r
1104                                   ((__STATE__) == UART_STATE_ENABLE))\r
1105 \r
1106 /**\r
1107   * @brief Ensure that UART oversampling is valid.\r
1108   * @param __SAMPLING__ UART oversampling.\r
1109   * @retval SET (__SAMPLING__ is valid) or RESET (__SAMPLING__ is invalid)\r
1110   */\r
1111 #define IS_UART_OVERSAMPLING(__SAMPLING__) (((__SAMPLING__) == UART_OVERSAMPLING_16) || \\r
1112                                             ((__SAMPLING__) == UART_OVERSAMPLING_8))\r
1113 \r
1114 /**\r
1115   * @brief Ensure that UART frame sampling is valid.\r
1116   * @param __ONEBIT__ UART frame sampling.\r
1117   * @retval SET (__ONEBIT__ is valid) or RESET (__ONEBIT__ is invalid)\r
1118   */\r
1119 #define IS_UART_ONE_BIT_SAMPLE(__ONEBIT__) (((__ONEBIT__) == UART_ONE_BIT_SAMPLE_DISABLE) || \\r
1120                                             ((__ONEBIT__) == UART_ONE_BIT_SAMPLE_ENABLE))\r
1121 \r
1122 /**\r
1123   * @brief Ensure that UART auto Baud rate detection mode is valid.\r
1124   * @param __MODE__ UART auto Baud rate detection mode.\r
1125   * @retval SET (__MODE__ is valid) or RESET (__MODE__ is invalid)\r
1126   */\r
1127 #define IS_UART_ADVFEATURE_AUTOBAUDRATEMODE(__MODE__)  (((__MODE__) == UART_ADVFEATURE_AUTOBAUDRATE_ONSTARTBIT)    || \\r
1128                                                         ((__MODE__) == UART_ADVFEATURE_AUTOBAUDRATE_ONFALLINGEDGE) || \\r
1129                                                         ((__MODE__) == UART_ADVFEATURE_AUTOBAUDRATE_ON0X7FFRAME)   || \\r
1130                                                         ((__MODE__) == UART_ADVFEATURE_AUTOBAUDRATE_ON0X55FRAME))\r
1131 \r
1132 /**\r
1133   * @brief Ensure that UART receiver timeout setting is valid.\r
1134   * @param __TIMEOUT__ UART receiver timeout setting.\r
1135   * @retval SET (__TIMEOUT__ is valid) or RESET (__TIMEOUT__ is invalid)\r
1136   */\r
1137 #define IS_UART_RECEIVER_TIMEOUT(__TIMEOUT__) (((__TIMEOUT__) == UART_RECEIVER_TIMEOUT_DISABLE) || \\r
1138                                                ((__TIMEOUT__) == UART_RECEIVER_TIMEOUT_ENABLE))\r
1139 \r
1140 /**\r
1141   * @brief Ensure that UART LIN state is valid.\r
1142   * @param __LIN__ UART LIN state.\r
1143   * @retval SET (__LIN__ is valid) or RESET (__LIN__ is invalid)\r
1144   */\r
1145 #define IS_UART_LIN(__LIN__)        (((__LIN__) == UART_LIN_DISABLE) || \\r
1146                                      ((__LIN__) == UART_LIN_ENABLE))\r
1147 \r
1148 /**\r
1149   * @brief Ensure that UART LIN break detection length is valid.\r
1150   * @param __LENGTH__ UART LIN break detection length.\r
1151   * @retval SET (__LENGTH__ is valid) or RESET (__LENGTH__ is invalid)\r
1152   */\r
1153 #define IS_UART_LIN_BREAK_DETECT_LENGTH(__LENGTH__) (((__LENGTH__) == UART_LINBREAKDETECTLENGTH_10B) || \\r
1154                                                      ((__LENGTH__) == UART_LINBREAKDETECTLENGTH_11B))\r
1155 \r
1156 /**\r
1157   * @brief Ensure that UART DMA TX state is valid.\r
1158   * @param __DMATX__ UART DMA TX state.\r
1159   * @retval SET (__DMATX__ is valid) or RESET (__DMATX__ is invalid)\r
1160   */\r
1161 #define IS_UART_DMA_TX(__DMATX__)     (((__DMATX__) == UART_DMA_TX_DISABLE) || \\r
1162                                        ((__DMATX__) == UART_DMA_TX_ENABLE))\r
1163 \r
1164 /**\r
1165   * @brief Ensure that UART DMA RX state is valid.\r
1166   * @param __DMARX__ UART DMA RX state.\r
1167   * @retval SET (__DMARX__ is valid) or RESET (__DMARX__ is invalid)\r
1168   */\r
1169 #define IS_UART_DMA_RX(__DMARX__)     (((__DMARX__) == UART_DMA_RX_DISABLE) || \\r
1170                                        ((__DMARX__) == UART_DMA_RX_ENABLE))\r
1171 \r
1172 /**\r
1173   * @brief Ensure that UART half-duplex state is valid.\r
1174   * @param __HDSEL__ UART half-duplex state.\r
1175   * @retval SET (__HDSEL__ is valid) or RESET (__HDSEL__ is invalid)\r
1176   */\r
1177 #define IS_UART_HALF_DUPLEX(__HDSEL__)     (((__HDSEL__) == UART_HALF_DUPLEX_DISABLE) || \\r
1178                                             ((__HDSEL__) == UART_HALF_DUPLEX_ENABLE))\r
1179 \r
1180 /**\r
1181   * @brief Ensure that UART wake-up method is valid.\r
1182   * @param __WAKEUP__ UART wake-up method .\r
1183   * @retval SET (__WAKEUP__ is valid) or RESET (__WAKEUP__ is invalid)\r
1184   */\r
1185 #define IS_UART_WAKEUPMETHOD(__WAKEUP__) (((__WAKEUP__) == UART_WAKEUPMETHOD_IDLELINE) || \\r
1186                                           ((__WAKEUP__) == UART_WAKEUPMETHOD_ADDRESSMARK))\r
1187 \r
1188 /**\r
1189   * @brief Ensure that UART request parameter is valid.\r
1190   * @param __PARAM__ UART request parameter.\r
1191   * @retval SET (__PARAM__ is valid) or RESET (__PARAM__ is invalid)\r
1192   */\r
1193 #define IS_UART_REQUEST_PARAMETER(__PARAM__) (((__PARAM__) == UART_AUTOBAUD_REQUEST)     || \\r
1194                                               ((__PARAM__) == UART_SENDBREAK_REQUEST)    || \\r
1195                                               ((__PARAM__) == UART_MUTE_MODE_REQUEST)    || \\r
1196                                               ((__PARAM__) == UART_RXDATA_FLUSH_REQUEST) || \\r
1197                                               ((__PARAM__) == UART_TXDATA_FLUSH_REQUEST))\r
1198 \r
1199 /**\r
1200   * @brief Ensure that UART advanced features initialization is valid.\r
1201   * @param __INIT__ UART advanced features initialization.\r
1202   * @retval SET (__INIT__ is valid) or RESET (__INIT__ is invalid)\r
1203   */\r
1204 #define IS_UART_ADVFEATURE_INIT(__INIT__)   ((__INIT__) <= (UART_ADVFEATURE_NO_INIT                | \\r
1205                                                             UART_ADVFEATURE_TXINVERT_INIT          | \\r
1206                                                             UART_ADVFEATURE_RXINVERT_INIT          | \\r
1207                                                             UART_ADVFEATURE_DATAINVERT_INIT        | \\r
1208                                                             UART_ADVFEATURE_SWAP_INIT              | \\r
1209                                                             UART_ADVFEATURE_RXOVERRUNDISABLE_INIT  | \\r
1210                                                             UART_ADVFEATURE_DMADISABLEONERROR_INIT | \\r
1211                                                             UART_ADVFEATURE_AUTOBAUDRATE_INIT      | \\r
1212                                                             UART_ADVFEATURE_MSBFIRST_INIT))\r
1213 \r
1214 /**\r
1215   * @brief Ensure that UART frame TX inversion setting is valid.\r
1216   * @param __TXINV__ UART frame TX inversion setting.\r
1217   * @retval SET (__TXINV__ is valid) or RESET (__TXINV__ is invalid)\r
1218   */\r
1219 #define IS_UART_ADVFEATURE_TXINV(__TXINV__) (((__TXINV__) == UART_ADVFEATURE_TXINV_DISABLE) || \\r
1220                                              ((__TXINV__) == UART_ADVFEATURE_TXINV_ENABLE))\r
1221 \r
1222 /**\r
1223   * @brief Ensure that UART frame RX inversion setting is valid.\r
1224   * @param __RXINV__ UART frame RX inversion setting.\r
1225   * @retval SET (__RXINV__ is valid) or RESET (__RXINV__ is invalid)\r
1226   */\r
1227 #define IS_UART_ADVFEATURE_RXINV(__RXINV__) (((__RXINV__) == UART_ADVFEATURE_RXINV_DISABLE) || \\r
1228                                              ((__RXINV__) == UART_ADVFEATURE_RXINV_ENABLE))\r
1229 \r
1230 /**\r
1231   * @brief Ensure that UART frame data inversion setting is valid.\r
1232   * @param __DATAINV__ UART frame data inversion setting.\r
1233   * @retval SET (__DATAINV__ is valid) or RESET (__DATAINV__ is invalid)\r
1234   */\r
1235 #define IS_UART_ADVFEATURE_DATAINV(__DATAINV__) (((__DATAINV__) == UART_ADVFEATURE_DATAINV_DISABLE) || \\r
1236                                                  ((__DATAINV__) == UART_ADVFEATURE_DATAINV_ENABLE))\r
1237 \r
1238 /**\r
1239   * @brief Ensure that UART frame RX/TX pins swap setting is valid.\r
1240   * @param __SWAP__ UART frame RX/TX pins swap setting.\r
1241   * @retval SET (__SWAP__ is valid) or RESET (__SWAP__ is invalid)\r
1242   */\r
1243 #define IS_UART_ADVFEATURE_SWAP(__SWAP__) (((__SWAP__) == UART_ADVFEATURE_SWAP_DISABLE) || \\r
1244                                            ((__SWAP__) == UART_ADVFEATURE_SWAP_ENABLE))\r
1245 \r
1246 /**\r
1247   * @brief Ensure that UART frame overrun setting is valid.\r
1248   * @param __OVERRUN__ UART frame overrun setting.\r
1249   * @retval SET (__OVERRUN__ is valid) or RESET (__OVERRUN__ is invalid)\r
1250   */\r
1251 #define IS_UART_OVERRUN(__OVERRUN__)     (((__OVERRUN__) == UART_ADVFEATURE_OVERRUN_ENABLE) || \\r
1252                                           ((__OVERRUN__) == UART_ADVFEATURE_OVERRUN_DISABLE))\r
1253 \r
1254 /**\r
1255   * @brief Ensure that UART auto Baud rate state is valid.\r
1256   * @param __AUTOBAUDRATE__ UART auto Baud rate state.\r
1257   * @retval SET (__AUTOBAUDRATE__ is valid) or RESET (__AUTOBAUDRATE__ is invalid)\r
1258   */\r
1259 #define IS_UART_ADVFEATURE_AUTOBAUDRATE(__AUTOBAUDRATE__)  (((__AUTOBAUDRATE__) == UART_ADVFEATURE_AUTOBAUDRATE_DISABLE) || \\r
1260                                                             ((__AUTOBAUDRATE__) == UART_ADVFEATURE_AUTOBAUDRATE_ENABLE))\r
1261 \r
1262 /**\r
1263   * @brief Ensure that UART DMA enabling or disabling on error setting is valid.\r
1264   * @param __DMA__ UART DMA enabling or disabling on error setting.\r
1265   * @retval SET (__DMA__ is valid) or RESET (__DMA__ is invalid)\r
1266   */\r
1267 #define IS_UART_ADVFEATURE_DMAONRXERROR(__DMA__)  (((__DMA__) == UART_ADVFEATURE_DMA_ENABLEONRXERROR) || \\r
1268                                                    ((__DMA__) == UART_ADVFEATURE_DMA_DISABLEONRXERROR))\r
1269 \r
1270 /**\r
1271   * @brief Ensure that UART frame MSB first setting is valid.\r
1272   * @param __MSBFIRST__ UART frame MSB first setting.\r
1273   * @retval SET (__MSBFIRST__ is valid) or RESET (__MSBFIRST__ is invalid)\r
1274   */\r
1275 #define IS_UART_ADVFEATURE_MSBFIRST(__MSBFIRST__) (((__MSBFIRST__) == UART_ADVFEATURE_MSBFIRST_DISABLE) || \\r
1276                                                    ((__MSBFIRST__) == UART_ADVFEATURE_MSBFIRST_ENABLE))\r
1277 \r
1278 /**\r
1279   * @brief Ensure that UART mute mode state is valid.\r
1280   * @param __MUTE__ UART mute mode state.\r
1281   * @retval SET (__MUTE__ is valid) or RESET (__MUTE__ is invalid)\r
1282   */\r
1283 #define IS_UART_MUTE_MODE(__MUTE__)       (((__MUTE__) == UART_ADVFEATURE_MUTEMODE_DISABLE) || \\r
1284                                            ((__MUTE__) == UART_ADVFEATURE_MUTEMODE_ENABLE))\r
1285 \r
1286 /**\r
1287   * @brief Ensure that UART driver enable polarity is valid.\r
1288   * @param __POLARITY__ UART driver enable polarity.\r
1289   * @retval SET (__POLARITY__ is valid) or RESET (__POLARITY__ is invalid)\r
1290   */\r
1291 #define IS_UART_DE_POLARITY(__POLARITY__)    (((__POLARITY__) == UART_DE_POLARITY_HIGH) || \\r
1292                                               ((__POLARITY__) == UART_DE_POLARITY_LOW))\r
1293 \r
1294 \r
1295 /**\r
1296   * @}\r
1297   */\r
1298 \r
1299 /* Include UART HAL Extended module */\r
1300 #include "stm32f7xx_hal_uart_ex.h"\r
1301 \r
1302 \r
1303 /* Exported functions --------------------------------------------------------*/\r
1304 /** @addtogroup UART_Exported_Functions UART Exported Functions\r
1305   * @{\r
1306   */\r
1307 \r
1308 /** @addtogroup UART_Exported_Functions_Group1 Initialization and de-initialization functions\r
1309   * @{\r
1310   */\r
1311 \r
1312 /* Initialization and de-initialization functions  ****************************/\r
1313 HAL_StatusTypeDef HAL_UART_Init(UART_HandleTypeDef *huart);\r
1314 HAL_StatusTypeDef HAL_HalfDuplex_Init(UART_HandleTypeDef *huart);\r
1315 HAL_StatusTypeDef HAL_LIN_Init(UART_HandleTypeDef *huart, uint32_t BreakDetectLength);\r
1316 HAL_StatusTypeDef HAL_MultiProcessor_Init(UART_HandleTypeDef *huart, uint8_t Address, uint32_t WakeUpMethod);\r
1317 HAL_StatusTypeDef HAL_UART_DeInit(UART_HandleTypeDef *huart);\r
1318 void HAL_UART_MspInit(UART_HandleTypeDef *huart);\r
1319 void HAL_UART_MspDeInit(UART_HandleTypeDef *huart);\r
1320 \r
1321 /* Callbacks Register/UnRegister functions  ***********************************/\r
1322 #if (USE_HAL_UART_REGISTER_CALLBACKS == 1)\r
1323 HAL_StatusTypeDef HAL_UART_RegisterCallback(UART_HandleTypeDef *huart, HAL_UART_CallbackIDTypeDef CallbackID, pUART_CallbackTypeDef pCallback);\r
1324 HAL_StatusTypeDef HAL_UART_UnRegisterCallback(UART_HandleTypeDef *huart, HAL_UART_CallbackIDTypeDef CallbackID);\r
1325 #endif /* USE_HAL_UART_REGISTER_CALLBACKS */\r
1326 \r
1327 /**\r
1328   * @}\r
1329   */\r
1330 \r
1331 /** @addtogroup UART_Exported_Functions_Group2 IO operation functions\r
1332   * @{\r
1333   */\r
1334 \r
1335 /* IO operation functions *****************************************************/\r
1336 HAL_StatusTypeDef HAL_UART_Transmit(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout);\r
1337 HAL_StatusTypeDef HAL_UART_Receive(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout);\r
1338 HAL_StatusTypeDef HAL_UART_Transmit_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size);\r
1339 HAL_StatusTypeDef HAL_UART_Receive_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size);\r
1340 HAL_StatusTypeDef HAL_UART_Transmit_DMA(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size);\r
1341 HAL_StatusTypeDef HAL_UART_Receive_DMA(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size);\r
1342 HAL_StatusTypeDef HAL_UART_DMAPause(UART_HandleTypeDef *huart);\r
1343 HAL_StatusTypeDef HAL_UART_DMAResume(UART_HandleTypeDef *huart);\r
1344 HAL_StatusTypeDef HAL_UART_DMAStop(UART_HandleTypeDef *huart);\r
1345 /* Transfer Abort functions */\r
1346 HAL_StatusTypeDef HAL_UART_Abort(UART_HandleTypeDef *huart);\r
1347 HAL_StatusTypeDef HAL_UART_AbortTransmit(UART_HandleTypeDef *huart);\r
1348 HAL_StatusTypeDef HAL_UART_AbortReceive(UART_HandleTypeDef *huart);\r
1349 HAL_StatusTypeDef HAL_UART_Abort_IT(UART_HandleTypeDef *huart);\r
1350 HAL_StatusTypeDef HAL_UART_AbortTransmit_IT(UART_HandleTypeDef *huart);\r
1351 HAL_StatusTypeDef HAL_UART_AbortReceive_IT(UART_HandleTypeDef *huart);\r
1352 \r
1353 void HAL_UART_IRQHandler(UART_HandleTypeDef *huart);\r
1354 void HAL_UART_TxHalfCpltCallback(UART_HandleTypeDef *huart);\r
1355 void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart);\r
1356 void HAL_UART_RxHalfCpltCallback(UART_HandleTypeDef *huart);\r
1357 void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart);\r
1358 void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart);\r
1359 void HAL_UART_AbortCpltCallback(UART_HandleTypeDef *huart);\r
1360 void HAL_UART_AbortTransmitCpltCallback(UART_HandleTypeDef *huart);\r
1361 void HAL_UART_AbortReceiveCpltCallback(UART_HandleTypeDef *huart);\r
1362 \r
1363 /**\r
1364   * @}\r
1365   */\r
1366 \r
1367 /** @addtogroup UART_Exported_Functions_Group3 Peripheral Control functions\r
1368   * @{\r
1369   */\r
1370 \r
1371 /* Peripheral Control functions  ************************************************/\r
1372 HAL_StatusTypeDef HAL_LIN_SendBreak(UART_HandleTypeDef *huart);\r
1373 HAL_StatusTypeDef HAL_MultiProcessor_EnableMuteMode(UART_HandleTypeDef *huart);\r
1374 HAL_StatusTypeDef HAL_MultiProcessor_DisableMuteMode(UART_HandleTypeDef *huart);\r
1375 void HAL_MultiProcessor_EnterMuteMode(UART_HandleTypeDef *huart);\r
1376 HAL_StatusTypeDef HAL_HalfDuplex_EnableTransmitter(UART_HandleTypeDef *huart);\r
1377 HAL_StatusTypeDef HAL_HalfDuplex_EnableReceiver(UART_HandleTypeDef *huart);\r
1378 \r
1379 /**\r
1380   * @}\r
1381   */\r
1382 \r
1383 /** @addtogroup UART_Exported_Functions_Group4 Peripheral State and Error functions\r
1384   * @{\r
1385   */\r
1386 \r
1387 /* Peripheral State and Errors functions  **************************************************/\r
1388 HAL_UART_StateTypeDef HAL_UART_GetState(UART_HandleTypeDef *huart);\r
1389 uint32_t              HAL_UART_GetError(UART_HandleTypeDef *huart);\r
1390 \r
1391 /**\r
1392   * @}\r
1393   */\r
1394 \r
1395 /**\r
1396   * @}\r
1397   */\r
1398 \r
1399 /* Private functions -----------------------------------------------------------*/\r
1400 /** @addtogroup UART_Private_Functions UART Private Functions\r
1401   * @{\r
1402   */\r
1403 #if (USE_HAL_UART_REGISTER_CALLBACKS == 1)\r
1404 void UART_InitCallbacksToDefault(UART_HandleTypeDef *huart);\r
1405 #endif /* USE_HAL_UART_REGISTER_CALLBACKS */\r
1406 HAL_StatusTypeDef UART_SetConfig(UART_HandleTypeDef *huart);\r
1407 HAL_StatusTypeDef UART_CheckIdleState(UART_HandleTypeDef *huart);\r
1408 HAL_StatusTypeDef UART_WaitOnFlagUntilTimeout(UART_HandleTypeDef *huart, uint32_t Flag, FlagStatus Status, uint32_t Tickstart, uint32_t Timeout);\r
1409 void UART_AdvFeatureConfig(UART_HandleTypeDef *huart);\r
1410 \r
1411 /**\r
1412   * @}\r
1413   */\r
1414 \r
1415 /**\r
1416   * @}\r
1417   */\r
1418 \r
1419 /**\r
1420   * @}\r
1421   */\r
1422 \r
1423 #ifdef __cplusplus\r
1424 }\r
1425 #endif\r
1426 \r
1427 #endif /* STM32F7xx_HAL_UART_H */\r
1428 \r
1429 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/\r