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

   1 /**\r
   2   ******************************************************************************\r
   3   * @file    stm32f7xx_hal_uart.c\r
   4   * @author  MCD Application Team\r
   5   * @brief   UART HAL module driver.\r
   6   *          This file provides firmware functions to manage the following\r
   7   *          functionalities of the Universal Asynchronous Receiver Transmitter Peripheral (UART).\r
   8   *           + Initialization and de-initialization functions\r
   9   *           + IO operation functions\r
  10   *           + Peripheral Control functions\r
  11   *\r
  12   *\r
  13   @verbatim\r
  14  ===============================================================================\r
  15                         ##### How to use this driver #####\r
  16  ===============================================================================\r
  17   [..]\r
  18     The UART HAL driver can be used as follows:\r
  19 \r
  20     (#) Declare a UART_HandleTypeDef handle structure (eg. UART_HandleTypeDef huart).\r
  21     (#) Initialize the UART low level resources by implementing the HAL_UART_MspInit() API:\r
  22         (++) Enable the USARTx interface clock.\r
  23         (++) UART pins configuration:\r
  24             (+++) Enable the clock for the UART GPIOs.\r
  25             (+++) Configure these UART pins as alternate function pull-up.\r
  26         (++) NVIC configuration if you need to use interrupt process (HAL_UART_Transmit_IT()\r
  27              and HAL_UART_Receive_IT() APIs):\r
  28             (+++) Configure the USARTx interrupt priority.\r
  29             (+++) Enable the NVIC USART IRQ handle.\r
  30         (++) UART interrupts handling:\r
  31               -@@-  The specific UART interrupts (Transmission complete interrupt,\r
  32                 RXNE interrupt, RX/TX FIFOs related interrupts and Error Interrupts)\r
  33                 are managed using the macros __HAL_UART_ENABLE_IT() and __HAL_UART_DISABLE_IT()\r
  34                 inside the transmit and receive processes.\r
  35         (++) DMA Configuration if you need to use DMA process (HAL_UART_Transmit_DMA()\r
  36              and HAL_UART_Receive_DMA() APIs):\r
  37             (+++) Declare a DMA handle structure for the Tx/Rx channel.\r
  38             (+++) Enable the DMAx interface clock.\r
  39             (+++) Configure the declared DMA handle structure with the required Tx/Rx parameters.\r
  40             (+++) Configure the DMA Tx/Rx channel.\r
  41             (+++) Associate the initialized DMA handle to the UART DMA Tx/Rx handle.\r
  42             (+++) Configure the priority and enable the NVIC for the transfer complete interrupt on the DMA Tx/Rx channel.\r
  43 \r
  44     (#) Program the Baud Rate, Word Length, Stop Bit, Parity, Hardware\r
  45         flow control and Mode (Receiver/Transmitter) in the huart handle Init structure.\r
  46 \r
  47     (#) If required, program UART advanced features (TX/RX pins swap, auto Baud rate detection,...)\r
  48         in the huart handle AdvancedInit structure.\r
  49 \r
  50     (#) For the UART asynchronous mode, initialize the UART registers by calling\r
  51         the HAL_UART_Init() API.\r
  52 \r
  53     (#) For the UART Half duplex mode, initialize the UART registers by calling\r
  54         the HAL_HalfDuplex_Init() API.\r
  55 \r
  56     (#) For the UART LIN (Local Interconnection Network) mode, initialize the UART registers\r
  57         by calling the HAL_LIN_Init() API.\r
  58 \r
  59     (#) For the UART Multiprocessor mode, initialize the UART registers\r
  60         by calling the HAL_MultiProcessor_Init() API.\r
  61 \r
  62     (#) For the UART RS485 Driver Enabled mode, initialize the UART registers\r
  63         by calling the HAL_RS485Ex_Init() API.\r
  64 \r
  65     [..]\r
  66     (@) These API's (HAL_UART_Init(), HAL_HalfDuplex_Init(), HAL_LIN_Init(), HAL_MultiProcessor_Init(),\r
  67         also configure the low level Hardware GPIO, CLOCK, CORTEX...etc) by\r
  68         calling the customized HAL_UART_MspInit() API.\r
  69 \r
  70     ##### Callback registration #####\r
  71     ==================================\r
  72 \r
  73     [..]\r
  74     The compilation define USE_HAL_UART_REGISTER_CALLBACKS when set to 1\r
  75     allows the user to configure dynamically the driver callbacks.\r
  76 \r
  77     [..]\r
  78     Use Function @ref HAL_UART_RegisterCallback() to register a user callback.\r
  79     Function @ref HAL_UART_RegisterCallback() allows to register following callbacks:\r
  80     (+) TxHalfCpltCallback        : Tx Half Complete Callback.\r
  81     (+) TxCpltCallback            : Tx Complete Callback.\r
  82     (+) RxHalfCpltCallback        : Rx Half Complete Callback.\r
  83     (+) RxCpltCallback            : Rx Complete Callback.\r
  84     (+) ErrorCallback             : Error Callback.\r
  85     (+) AbortCpltCallback         : Abort Complete Callback.\r
  86     (+) AbortTransmitCpltCallback : Abort Transmit Complete Callback.\r
  87     (+) AbortReceiveCpltCallback  : Abort Receive Complete Callback.\r
  88     (+) WakeupCallback            : Wakeup Callback.\r
  89     (+) RxFifoFullCallback        : Rx Fifo Full Callback.\r
  90     (+) TxFifoEmptyCallback       : Tx Fifo Empty Callback.\r
  91     (+) MspInitCallback           : UART MspInit.\r
  92     (+) MspDeInitCallback         : UART MspDeInit.\r
  93     This function takes as parameters the HAL peripheral handle, the Callback ID\r
  94     and a pointer to the user callback function.\r
  95 \r
  96     [..]\r
  97     Use function @ref HAL_UART_UnRegisterCallback() to reset a callback to the default\r
  98     weak (surcharged) function.\r
  99     @ref HAL_UART_UnRegisterCallback() takes as parameters the HAL peripheral handle,\r
 100     and the Callback ID.\r
 101     This function allows to reset following callbacks:\r
 102     (+) TxHalfCpltCallback        : Tx Half Complete Callback.\r
 103     (+) TxCpltCallback            : Tx Complete Callback.\r
 104     (+) RxHalfCpltCallback        : Rx Half Complete Callback.\r
 105     (+) RxCpltCallback            : Rx Complete Callback.\r
 106     (+) ErrorCallback             : Error Callback.\r
 107     (+) AbortCpltCallback         : Abort Complete Callback.\r
 108     (+) AbortTransmitCpltCallback : Abort Transmit Complete Callback.\r
 109     (+) AbortReceiveCpltCallback  : Abort Receive Complete Callback.\r
 110     (+) WakeupCallback            : Wakeup Callback.\r
 111     (+) RxFifoFullCallback        : Rx Fifo Full Callback.\r
 112     (+) TxFifoEmptyCallback       : Tx Fifo Empty Callback.\r
 113     (+) MspInitCallback           : UART MspInit.\r
 114     (+) MspDeInitCallback         : UART MspDeInit.\r
 115 \r
 116     [..]\r
 117     By default, after the @ref HAL_UART_Init() and when the state is HAL_UART_STATE_RESET\r
 118     all callbacks are set to the corresponding weak (surcharged) functions:\r
 119     examples @ref HAL_UART_TxCpltCallback(), @ref HAL_UART_RxHalfCpltCallback().\r
 120     Exception done for MspInit and MspDeInit functions that are respectively\r
 121     reset to the legacy weak (surcharged) functions in the @ref HAL_UART_Init()\r
 122     and @ref HAL_UART_DeInit() only when these callbacks are null (not registered beforehand).\r
 123     If not, MspInit or MspDeInit are not null, the @ref HAL_UART_Init() and @ref HAL_UART_DeInit()\r
 124     keep and use the user MspInit/MspDeInit callbacks (registered beforehand).\r
 125 \r
 126     [..]\r
 127     Callbacks can be registered/unregistered in HAL_UART_STATE_READY state only.\r
 128     Exception done MspInit/MspDeInit that can be registered/unregistered\r
 129     in HAL_UART_STATE_READY or HAL_UART_STATE_RESET state, thus registered (user)\r
 130     MspInit/DeInit callbacks can be used during the Init/DeInit.\r
 131     In that case first register the MspInit/MspDeInit user callbacks\r
 132     using @ref HAL_UART_RegisterCallback() before calling @ref HAL_UART_DeInit()\r
 133     or @ref HAL_UART_Init() function.\r
 134 \r
 135     [..]\r
 136     When The compilation define USE_HAL_UART_REGISTER_CALLBACKS is set to 0 or\r
 137     not defined, the callback registration feature is not available\r
 138     and weak (surcharged) callbacks are used.\r
 139 \r
 140 \r
 141   @endverbatim\r
 142   ******************************************************************************\r
 143   * @attention\r
 144   *\r
 145   * <h2><center>&copy; Copyright (c) 2017 STMicroelectronics.\r
 146   * All rights reserved.</center></h2>\r
 147   *\r
 148   * This software component is licensed by ST under BSD 3-Clause license,\r
 149   * the "License"; You may not use this file except in compliance with the\r
 150   * License. You may obtain a copy of the License at:\r
 151   *                        opensource.org/licenses/BSD-3-Clause\r
 152   *\r
 153   ******************************************************************************\r
 154   */\r
 155 \r
 156 /* Includes ------------------------------------------------------------------*/\r
 157 #include "stm32f7xx_hal.h"\r
 158 \r
 159 /** @addtogroup STM32F7xx_HAL_Driver\r
 160   * @{\r
 161   */\r
 162 \r
 163 /** @defgroup UART UART\r
 164   * @brief HAL UART module driver\r
 165   * @{\r
 166   */\r
 167 \r
 168 #ifdef HAL_UART_MODULE_ENABLED\r
 169 \r
 170 /* Private typedef -----------------------------------------------------------*/\r
 171 /* Private define ------------------------------------------------------------*/\r
 172 /** @defgroup UART_Private_Constants UART Private Constants\r
 173   * @{\r
 174   */\r
 175 #define USART_CR1_FIELDS  ((uint32_t)(USART_CR1_M | USART_CR1_PCE | USART_CR1_PS | \\r
 176                                       USART_CR1_TE | USART_CR1_RE | USART_CR1_OVER8 )) /*!< UART or USART CR1 fields of parameters set by UART_SetConfig API */\r
 177 \r
 178 #define USART_CR3_FIELDS  ((uint32_t)(USART_CR3_RTSE | USART_CR3_CTSE | USART_CR3_ONEBIT))  /*!< UART or USART CR3 fields of parameters set by UART_SetConfig API */\r
 179 \r
 180 \r
 181 #define UART_BRR_MIN    0x10U        /* UART BRR minimum authorized value */\r
 182 #define UART_BRR_MAX    0x0000FFFFU  /* UART BRR maximum authorized value */\r
 183 \r
 184 /**\r
 185   * @}\r
 186   */\r
 187 \r
 188 /* Private macros ------------------------------------------------------------*/\r
 189 /* Private variables ---------------------------------------------------------*/\r
 190 /* Private function prototypes -----------------------------------------------*/\r
 191 /** @addtogroup UART_Private_Functions\r
 192   * @{\r
 193   */\r
 194 static void UART_EndTxTransfer(UART_HandleTypeDef *huart);\r
 195 static void UART_EndRxTransfer(UART_HandleTypeDef *huart);\r
 196 static void UART_DMATransmitCplt(DMA_HandleTypeDef *hdma);\r
 197 static void UART_DMAReceiveCplt(DMA_HandleTypeDef *hdma);\r
 198 static void UART_DMARxHalfCplt(DMA_HandleTypeDef *hdma);\r
 199 static void UART_DMATxHalfCplt(DMA_HandleTypeDef *hdma);\r
 200 static void UART_DMAError(DMA_HandleTypeDef *hdma);\r
 201 static void UART_DMAAbortOnError(DMA_HandleTypeDef *hdma);\r
 202 static void UART_DMATxAbortCallback(DMA_HandleTypeDef *hdma);\r
 203 static void UART_DMARxAbortCallback(DMA_HandleTypeDef *hdma);\r
 204 static void UART_DMATxOnlyAbortCallback(DMA_HandleTypeDef *hdma);\r
 205 static void UART_DMARxOnlyAbortCallback(DMA_HandleTypeDef *hdma);\r
 206 static void UART_TxISR_8BIT(UART_HandleTypeDef *huart);\r
 207 static void UART_TxISR_16BIT(UART_HandleTypeDef *huart);\r
 208 static void UART_EndTransmit_IT(UART_HandleTypeDef *huart);\r
 209 static void UART_RxISR_8BIT(UART_HandleTypeDef *huart);\r
 210 static void UART_RxISR_16BIT(UART_HandleTypeDef *huart);\r
 211 /**\r
 212   * @}\r
 213   */\r
 214 \r
 215 /* Exported functions --------------------------------------------------------*/\r
 216 \r
 217 /** @defgroup UART_Exported_Functions UART Exported Functions\r
 218   * @{\r
 219   */\r
 220 \r
 221 /** @defgroup UART_Exported_Functions_Group1 Initialization and de-initialization functions\r
 222   *  @brief    Initialization and Configuration functions\r
 223   *\r
 224 @verbatim\r
 225 ===============================================================================\r
 226             ##### Initialization and Configuration functions #####\r
 227  ===============================================================================\r
 228     [..]\r
 229     This subsection provides a set of functions allowing to initialize the USARTx or the UARTy\r
 230     in asynchronous mode.\r
 231       (+) For the asynchronous mode the parameters below can be configured:\r
 232         (++) Baud Rate\r
 233         (++) Word Length\r
 234         (++) Stop Bit\r
 235         (++) Parity: If the parity is enabled, then the MSB bit of the data written\r
 236              in the data register is transmitted but is changed by the parity bit.\r
 237         (++) Hardware flow control\r
 238         (++) Receiver/transmitter modes\r
 239         (++) Over Sampling Method\r
 240         (++) One-Bit Sampling Method\r
 241       (+) For the asynchronous mode, the following advanced features can be configured as well:\r
 242         (++) TX and/or RX pin level inversion\r
 243         (++) data logical level inversion\r
 244         (++) RX and TX pins swap\r
 245         (++) RX overrun detection disabling\r
 246         (++) DMA disabling on RX error\r
 247         (++) MSB first on communication line\r
 248         (++) auto Baud rate detection\r
 249     [..]\r
 250     The HAL_UART_Init(), HAL_HalfDuplex_Init(), HAL_LIN_Init()and HAL_MultiProcessor_Init()API\r
 251     follow respectively the UART asynchronous, UART Half duplex, UART LIN mode\r
 252     and UART multiprocessor mode configuration procedures (details for the procedures\r
 253     are available in reference manual).\r
 254 \r
 255 @endverbatim\r
 256 \r
 257   Depending on the frame length defined by the M1 and M0 bits (7-bit,\r
 258   8-bit or 9-bit), the possible UART formats are listed in the\r
 259   following table.\r
 260 \r
 261   Table 1. UART frame format.\r
 262     +-----------------------------------------------------------------------+\r
 263     |  M1 bit |  M0 bit |  PCE bit  |             UART frame                |\r
 264     |---------|---------|-----------|---------------------------------------|\r
 265     |    0    |    0    |    0      |    | SB |    8 bit data   | STB |     |\r
 266     |---------|---------|-----------|---------------------------------------|\r
 267     |    0    |    0    |    1      |    | SB | 7 bit data | PB | STB |     |\r
 268     |---------|---------|-----------|---------------------------------------|\r
 269     |    0    |    1    |    0      |    | SB |    9 bit data   | STB |     |\r
 270     |---------|---------|-----------|---------------------------------------|\r
 271     |    0    |    1    |    1      |    | SB | 8 bit data | PB | STB |     |\r
 272     |---------|---------|-----------|---------------------------------------|\r
 273     |    1    |    0    |    0      |    | SB |    7 bit data   | STB |     |\r
 274     |---------|---------|-----------|---------------------------------------|\r
 275     |    1    |    0    |    1      |    | SB | 6 bit data | PB | STB |     |\r
 276     +-----------------------------------------------------------------------+\r
 277 \r
 278   * @{\r
 279   */\r
 280 \r
 281 /**\r
 282   * @brief Initialize the UART mode according to the specified\r
 283   *        parameters in the UART_InitTypeDef and initialize the associated handle.\r
 284   * @param huart UART handle.\r
 285   * @retval HAL status\r
 286   */\r
 287 HAL_StatusTypeDef HAL_UART_Init(UART_HandleTypeDef *huart)\r
 288 {\r
 289   /* Check the UART handle allocation */\r
 290   if (huart == NULL)\r
 291   {\r
 292     return HAL_ERROR;\r
 293   }\r
 294 \r
 295   if (huart->Init.HwFlowCtl != UART_HWCONTROL_NONE)\r
 296   {\r
 297     /* Check the parameters */\r
 298     assert_param(IS_UART_HWFLOW_INSTANCE(huart->Instance));\r
 299   }\r
 300   else\r
 301   {\r
 302     /* Check the parameters */\r
 303     assert_param(IS_UART_INSTANCE(huart->Instance));\r
 304   }\r
 305 \r
 306   if (huart->gState == HAL_UART_STATE_RESET)\r
 307   {\r
 308     /* Allocate lock resource and initialize it */\r
 309     huart->Lock = HAL_UNLOCKED;\r
 310 \r
 311 #if (USE_HAL_UART_REGISTER_CALLBACKS == 1)\r
 312     UART_InitCallbacksToDefault(huart);\r
 313 \r
 314     if (huart->MspInitCallback == NULL)\r
 315     {\r
 316       huart->MspInitCallback = HAL_UART_MspInit;\r
 317     }\r
 318 \r
 319     /* Init the low level hardware */\r
 320     huart->MspInitCallback(huart);\r
 321 #else\r
 322     /* Init the low level hardware : GPIO, CLOCK */\r
 323     HAL_UART_MspInit(huart);\r
 324 #endif /* (USE_HAL_UART_REGISTER_CALLBACKS) */\r
 325   }\r
 326 \r
 327   huart->gState = HAL_UART_STATE_BUSY;\r
 328 \r
 329   /* Disable the Peripheral */\r
 330   __HAL_UART_DISABLE(huart);\r
 331 \r
 332   /* Set the UART Communication parameters */\r
 333   if (UART_SetConfig(huart) == HAL_ERROR)\r
 334   {\r
 335     return HAL_ERROR;\r
 336   }\r
 337 \r
 338   if (huart->AdvancedInit.AdvFeatureInit != UART_ADVFEATURE_NO_INIT)\r
 339   {\r
 340     UART_AdvFeatureConfig(huart);\r
 341   }\r
 342 \r
 343   /* In asynchronous mode, the following bits must be kept cleared:\r
 344   - LINEN and CLKEN bits in the USART_CR2 register,\r
 345   - SCEN, HDSEL and IREN  bits in the USART_CR3 register.*/\r
 346   CLEAR_BIT(huart->Instance->CR2, (USART_CR2_LINEN | USART_CR2_CLKEN));\r
 347   CLEAR_BIT(huart->Instance->CR3, (USART_CR3_SCEN | USART_CR3_HDSEL | USART_CR3_IREN));\r
 348 \r
 349   /* Enable the Peripheral */\r
 350   __HAL_UART_ENABLE(huart);\r
 351 \r
 352   /* TEACK and/or REACK to check before moving huart->gState and huart->RxState to Ready */\r
 353   return (UART_CheckIdleState(huart));\r
 354 }\r
 355 \r
 356 /**\r
 357   * @brief Initialize the half-duplex mode according to the specified\r
 358   *        parameters in the UART_InitTypeDef and creates the associated handle.\r
 359   * @param huart UART handle.\r
 360   * @retval HAL status\r
 361   */\r
 362 HAL_StatusTypeDef HAL_HalfDuplex_Init(UART_HandleTypeDef *huart)\r
 363 {\r
 364   /* Check the UART handle allocation */\r
 365   if (huart == NULL)\r
 366   {\r
 367     return HAL_ERROR;\r
 368   }\r
 369 \r
 370   /* Check UART instance */\r
 371   assert_param(IS_UART_HALFDUPLEX_INSTANCE(huart->Instance));\r
 372 \r
 373   if (huart->gState == HAL_UART_STATE_RESET)\r
 374   {\r
 375     /* Allocate lock resource and initialize it */\r
 376     huart->Lock = HAL_UNLOCKED;\r
 377 \r
 378 #if (USE_HAL_UART_REGISTER_CALLBACKS == 1)\r
 379     UART_InitCallbacksToDefault(huart);\r
 380 \r
 381     if (huart->MspInitCallback == NULL)\r
 382     {\r
 383       huart->MspInitCallback = HAL_UART_MspInit;\r
 384     }\r
 385 \r
 386     /* Init the low level hardware */\r
 387     huart->MspInitCallback(huart);\r
 388 #else\r
 389     /* Init the low level hardware : GPIO, CLOCK */\r
 390     HAL_UART_MspInit(huart);\r
 391 #endif /* (USE_HAL_UART_REGISTER_CALLBACKS) */\r
 392   }\r
 393 \r
 394   huart->gState = HAL_UART_STATE_BUSY;\r
 395 \r
 396   /* Disable the Peripheral */\r
 397   __HAL_UART_DISABLE(huart);\r
 398 \r
 399   /* Set the UART Communication parameters */\r
 400   if (UART_SetConfig(huart) == HAL_ERROR)\r
 401   {\r
 402     return HAL_ERROR;\r
 403   }\r
 404 \r
 405   if (huart->AdvancedInit.AdvFeatureInit != UART_ADVFEATURE_NO_INIT)\r
 406   {\r
 407     UART_AdvFeatureConfig(huart);\r
 408   }\r
 409 \r
 410   /* In half-duplex mode, the following bits must be kept cleared:\r
 411   - LINEN and CLKEN bits in the USART_CR2 register,\r
 412   - SCEN and IREN bits in the USART_CR3 register.*/\r
 413   CLEAR_BIT(huart->Instance->CR2, (USART_CR2_LINEN | USART_CR2_CLKEN));\r
 414   CLEAR_BIT(huart->Instance->CR3, (USART_CR3_IREN | USART_CR3_SCEN));\r
 415 \r
 416   /* Enable the Half-Duplex mode by setting the HDSEL bit in the CR3 register */\r
 417   SET_BIT(huart->Instance->CR3, USART_CR3_HDSEL);\r
 418 \r
 419   /* Enable the Peripheral */\r
 420   __HAL_UART_ENABLE(huart);\r
 421 \r
 422   /* TEACK and/or REACK to check before moving huart->gState and huart->RxState to Ready */\r
 423   return (UART_CheckIdleState(huart));\r
 424 }\r
 425 \r
 426 \r
 427 /**\r
 428   * @brief Initialize the LIN mode according to the specified\r
 429   *        parameters in the UART_InitTypeDef and creates the associated handle.\r
 430   * @param huart             UART handle.\r
 431   * @param BreakDetectLength Specifies the LIN break detection length.\r
 432   *        This parameter can be one of the following values:\r
 433   *          @arg @ref UART_LINBREAKDETECTLENGTH_10B 10-bit break detection\r
 434   *          @arg @ref UART_LINBREAKDETECTLENGTH_11B 11-bit break detection\r
 435   * @retval HAL status\r
 436   */\r
 437 HAL_StatusTypeDef HAL_LIN_Init(UART_HandleTypeDef *huart, uint32_t BreakDetectLength)\r
 438 {\r
 439   /* Check the UART handle allocation */\r
 440   if (huart == NULL)\r
 441   {\r
 442     return HAL_ERROR;\r
 443   }\r
 444 \r
 445   /* Check the LIN UART instance */\r
 446   assert_param(IS_UART_LIN_INSTANCE(huart->Instance));\r
 447   /* Check the Break detection length parameter */\r
 448   assert_param(IS_UART_LIN_BREAK_DETECT_LENGTH(BreakDetectLength));\r
 449 \r
 450   /* LIN mode limited to 16-bit oversampling only */\r
 451   if (huart->Init.OverSampling == UART_OVERSAMPLING_8)\r
 452   {\r
 453     return HAL_ERROR;\r
 454   }\r
 455   /* LIN mode limited to 8-bit data length */\r
 456   if (huart->Init.WordLength != UART_WORDLENGTH_8B)\r
 457   {\r
 458     return HAL_ERROR;\r
 459   }\r
 460 \r
 461   if (huart->gState == HAL_UART_STATE_RESET)\r
 462   {\r
 463     /* Allocate lock resource and initialize it */\r
 464     huart->Lock = HAL_UNLOCKED;\r
 465 \r
 466 #if (USE_HAL_UART_REGISTER_CALLBACKS == 1)\r
 467     UART_InitCallbacksToDefault(huart);\r
 468 \r
 469     if (huart->MspInitCallback == NULL)\r
 470     {\r
 471       huart->MspInitCallback = HAL_UART_MspInit;\r
 472     }\r
 473 \r
 474     /* Init the low level hardware */\r
 475     huart->MspInitCallback(huart);\r
 476 #else\r
 477     /* Init the low level hardware : GPIO, CLOCK */\r
 478     HAL_UART_MspInit(huart);\r
 479 #endif /* (USE_HAL_UART_REGISTER_CALLBACKS) */\r
 480   }\r
 481 \r
 482   huart->gState = HAL_UART_STATE_BUSY;\r
 483 \r
 484   /* Disable the Peripheral */\r
 485   __HAL_UART_DISABLE(huart);\r
 486 \r
 487   /* Set the UART Communication parameters */\r
 488   if (UART_SetConfig(huart) == HAL_ERROR)\r
 489   {\r
 490     return HAL_ERROR;\r
 491   }\r
 492 \r
 493   if (huart->AdvancedInit.AdvFeatureInit != UART_ADVFEATURE_NO_INIT)\r
 494   {\r
 495     UART_AdvFeatureConfig(huart);\r
 496   }\r
 497 \r
 498   /* In LIN mode, the following bits must be kept cleared:\r
 499   - LINEN and CLKEN bits in the USART_CR2 register,\r
 500   - SCEN and IREN bits in the USART_CR3 register.*/\r
 501   CLEAR_BIT(huart->Instance->CR2, USART_CR2_CLKEN);\r
 502   CLEAR_BIT(huart->Instance->CR3, (USART_CR3_HDSEL | USART_CR3_IREN | USART_CR3_SCEN));\r
 503 \r
 504   /* Enable the LIN mode by setting the LINEN bit in the CR2 register */\r
 505   SET_BIT(huart->Instance->CR2, USART_CR2_LINEN);\r
 506 \r
 507   /* Set the USART LIN Break detection length. */\r
 508   MODIFY_REG(huart->Instance->CR2, USART_CR2_LBDL, BreakDetectLength);\r
 509 \r
 510   /* Enable the Peripheral */\r
 511   __HAL_UART_ENABLE(huart);\r
 512 \r
 513   /* TEACK and/or REACK to check before moving huart->gState and huart->RxState to Ready */\r
 514   return (UART_CheckIdleState(huart));\r
 515 }\r
 516 \r
 517 \r
 518 /**\r
 519   * @brief Initialize the multiprocessor mode according to the specified\r
 520   *        parameters in the UART_InitTypeDef and initialize the associated handle.\r
 521   * @param huart        UART handle.\r
 522   * @param Address      UART node address (4-, 6-, 7- or 8-bit long).\r
 523   * @param WakeUpMethod Specifies the UART wakeup method.\r
 524   *        This parameter can be one of the following values:\r
 525   *          @arg @ref UART_WAKEUPMETHOD_IDLELINE WakeUp by an idle line detection\r
 526   *          @arg @ref UART_WAKEUPMETHOD_ADDRESSMARK WakeUp by an address mark\r
 527   * @note  If the user resorts to idle line detection wake up, the Address parameter\r
 528   *        is useless and ignored by the initialization function.\r
 529   * @note  If the user resorts to address mark wake up, the address length detection\r
 530   *        is configured by default to 4 bits only. For the UART to be able to\r
 531   *        manage 6-, 7- or 8-bit long addresses detection, the API\r
 532   *        HAL_MultiProcessorEx_AddressLength_Set() must be called after\r
 533   *        HAL_MultiProcessor_Init().\r
 534   * @retval HAL status\r
 535   */\r
 536 HAL_StatusTypeDef HAL_MultiProcessor_Init(UART_HandleTypeDef *huart, uint8_t Address, uint32_t WakeUpMethod)\r
 537 {\r
 538   /* Check the UART handle allocation */\r
 539   if (huart == NULL)\r
 540   {\r
 541     return HAL_ERROR;\r
 542   }\r
 543 \r
 544   /* Check the wake up method parameter */\r
 545   assert_param(IS_UART_WAKEUPMETHOD(WakeUpMethod));\r
 546 \r
 547   if (huart->gState == HAL_UART_STATE_RESET)\r
 548   {\r
 549     /* Allocate lock resource and initialize it */\r
 550     huart->Lock = HAL_UNLOCKED;\r
 551 \r
 552 #if (USE_HAL_UART_REGISTER_CALLBACKS == 1)\r
 553     UART_InitCallbacksToDefault(huart);\r
 554 \r
 555     if (huart->MspInitCallback == NULL)\r
 556     {\r
 557       huart->MspInitCallback = HAL_UART_MspInit;\r
 558     }\r
 559 \r
 560     /* Init the low level hardware */\r
 561     huart->MspInitCallback(huart);\r
 562 #else\r
 563     /* Init the low level hardware : GPIO, CLOCK */\r
 564     HAL_UART_MspInit(huart);\r
 565 #endif /* (USE_HAL_UART_REGISTER_CALLBACKS) */\r
 566   }\r
 567 \r
 568   huart->gState = HAL_UART_STATE_BUSY;\r
 569 \r
 570   /* Disable the Peripheral */\r
 571   __HAL_UART_DISABLE(huart);\r
 572 \r
 573   /* Set the UART Communication parameters */\r
 574   if (UART_SetConfig(huart) == HAL_ERROR)\r
 575   {\r
 576     return HAL_ERROR;\r
 577   }\r
 578 \r
 579   if (huart->AdvancedInit.AdvFeatureInit != UART_ADVFEATURE_NO_INIT)\r
 580   {\r
 581     UART_AdvFeatureConfig(huart);\r
 582   }\r
 583 \r
 584   /* In multiprocessor mode, the following bits must be kept cleared:\r
 585   - LINEN and CLKEN bits in the USART_CR2 register,\r
 586   - SCEN, HDSEL and IREN  bits in the USART_CR3 register. */\r
 587   CLEAR_BIT(huart->Instance->CR2, (USART_CR2_LINEN | USART_CR2_CLKEN));\r
 588   CLEAR_BIT(huart->Instance->CR3, (USART_CR3_SCEN | USART_CR3_HDSEL | USART_CR3_IREN));\r
 589 \r
 590   if (WakeUpMethod == UART_WAKEUPMETHOD_ADDRESSMARK)\r
 591   {\r
 592     /* If address mark wake up method is chosen, set the USART address node */\r
 593     MODIFY_REG(huart->Instance->CR2, USART_CR2_ADD, ((uint32_t)Address << UART_CR2_ADDRESS_LSB_POS));\r
 594   }\r
 595 \r
 596   /* Set the wake up method by setting the WAKE bit in the CR1 register */\r
 597   MODIFY_REG(huart->Instance->CR1, USART_CR1_WAKE, WakeUpMethod);\r
 598 \r
 599   /* Enable the Peripheral */\r
 600   __HAL_UART_ENABLE(huart);\r
 601 \r
 602   /* TEACK and/or REACK to check before moving huart->gState and huart->RxState to Ready */\r
 603   return (UART_CheckIdleState(huart));\r
 604 }\r
 605 \r
 606 \r
 607 /**\r
 608   * @brief DeInitialize the UART peripheral.\r
 609   * @param huart UART handle.\r
 610   * @retval HAL status\r
 611   */\r
 612 HAL_StatusTypeDef HAL_UART_DeInit(UART_HandleTypeDef *huart)\r
 613 {\r
 614   /* Check the UART handle allocation */\r
 615   if (huart == NULL)\r
 616   {\r
 617     return HAL_ERROR;\r
 618   }\r
 619 \r
 620   /* Check the parameters */\r
 621   assert_param(IS_UART_INSTANCE(huart->Instance));\r
 622 \r
 623   huart->gState = HAL_UART_STATE_BUSY;\r
 624 \r
 625   /* Disable the Peripheral */\r
 626   __HAL_UART_DISABLE(huart);\r
 627 \r
 628   huart->Instance->CR1 = 0x0U;\r
 629   huart->Instance->CR2 = 0x0U;\r
 630   huart->Instance->CR3 = 0x0U;\r
 631 \r
 632 #if (USE_HAL_UART_REGISTER_CALLBACKS == 1)\r
 633   if (huart->MspDeInitCallback == NULL)\r
 634   {\r
 635     huart->MspDeInitCallback = HAL_UART_MspDeInit;\r
 636   }\r
 637   /* DeInit the low level hardware */\r
 638   huart->MspDeInitCallback(huart);\r
 639 #else\r
 640   /* DeInit the low level hardware */\r
 641   HAL_UART_MspDeInit(huart);\r
 642 #endif /* (USE_HAL_UART_REGISTER_CALLBACKS) */\r
 643 \r
 644   huart->ErrorCode = HAL_UART_ERROR_NONE;\r
 645   huart->gState = HAL_UART_STATE_RESET;\r
 646   huart->RxState = HAL_UART_STATE_RESET;\r
 647 \r
 648   /* Process Unlock */\r
 649   __HAL_UNLOCK(huart);\r
 650 \r
 651   return HAL_OK;\r
 652 }\r
 653 \r
 654 /**\r
 655   * @brief Initialize the UART MSP.\r
 656   * @param huart UART handle.\r
 657   * @retval None\r
 658   */\r
 659 __weak void HAL_UART_MspInit(UART_HandleTypeDef *huart)\r
 660 {\r
 661   /* Prevent unused argument(s) compilation warning */\r
 662   UNUSED(huart);\r
 663 \r
 664   /* NOTE : This function should not be modified, when the callback is needed,\r
 665             the HAL_UART_MspInit can be implemented in the user file\r
 666    */\r
 667 }\r
 668 \r
 669 /**\r
 670   * @brief DeInitialize the UART MSP.\r
 671   * @param huart UART handle.\r
 672   * @retval None\r
 673   */\r
 674 __weak void HAL_UART_MspDeInit(UART_HandleTypeDef *huart)\r
 675 {\r
 676   /* Prevent unused argument(s) compilation warning */\r
 677   UNUSED(huart);\r
 678 \r
 679   /* NOTE : This function should not be modified, when the callback is needed,\r
 680             the HAL_UART_MspDeInit can be implemented in the user file\r
 681    */\r
 682 }\r
 683 \r
 684 #if (USE_HAL_UART_REGISTER_CALLBACKS == 1)\r
 685 /**\r
 686   * @brief  Register a User UART Callback\r
 687   *         To be used instead of the weak predefined callback\r
 688   * @param  huart uart handle\r
 689   * @param  CallbackID ID of the callback to be registered\r
 690   *         This parameter can be one of the following values:\r
 691   *           @arg @ref HAL_UART_TX_HALFCOMPLETE_CB_ID Tx Half Complete Callback ID\r
 692   *           @arg @ref HAL_UART_TX_COMPLETE_CB_ID Tx Complete Callback ID\r
 693   *           @arg @ref HAL_UART_RX_HALFCOMPLETE_CB_ID Rx Half Complete Callback ID\r
 694   *           @arg @ref HAL_UART_RX_COMPLETE_CB_ID Rx Complete Callback ID\r
 695   *           @arg @ref HAL_UART_ERROR_CB_ID Error Callback ID\r
 696   *           @arg @ref HAL_UART_ABORT_COMPLETE_CB_ID Abort Complete Callback ID\r
 697   *           @arg @ref HAL_UART_ABORT_TRANSMIT_COMPLETE_CB_ID Abort Transmit Complete Callback ID\r
 698   *           @arg @ref HAL_UART_ABORT_RECEIVE_COMPLETE_CB_ID Abort Receive Complete Callback ID\r
 699   *           @arg @ref HAL_UART_WAKEUP_CB_ID Wakeup Callback ID\r
 700   *           @arg @ref HAL_UART_RX_FIFO_FULL_CB_ID Rx Fifo Full Callback ID\r
 701   *           @arg @ref HAL_UART_TX_FIFO_EMPTY_CB_ID Tx Fifo Empty Callback ID\r
 702   *           @arg @ref HAL_UART_MSPINIT_CB_ID MspInit Callback ID\r
 703   *           @arg @ref HAL_UART_MSPDEINIT_CB_ID MspDeInit Callback ID\r
 704   * @param  pCallback pointer to the Callback function\r
 705   * @retval HAL status\r
 706   */\r
 707 HAL_StatusTypeDef HAL_UART_RegisterCallback(UART_HandleTypeDef *huart, HAL_UART_CallbackIDTypeDef CallbackID, pUART_CallbackTypeDef pCallback)\r
 708 {\r
 709   HAL_StatusTypeDef status = HAL_OK;\r
 710 \r
 711   if (pCallback == NULL)\r
 712   {\r
 713     /* Update the error code */\r
 714     huart->ErrorCode |= HAL_UART_ERROR_INVALID_CALLBACK;\r
 715 \r
 716     return HAL_ERROR;\r
 717   }\r
 718   /* Process locked */\r
 719   __HAL_LOCK(huart);\r
 720 \r
 721   if (huart->gState == HAL_UART_STATE_READY)\r
 722   {\r
 723     switch (CallbackID)\r
 724     {\r
 725       case HAL_UART_TX_HALFCOMPLETE_CB_ID :\r
 726         huart->TxHalfCpltCallback = pCallback;\r
 727         break;\r
 728 \r
 729       case HAL_UART_TX_COMPLETE_CB_ID :\r
 730         huart->TxCpltCallback = pCallback;\r
 731         break;\r
 732 \r
 733       case HAL_UART_RX_HALFCOMPLETE_CB_ID :\r
 734         huart->RxHalfCpltCallback = pCallback;\r
 735         break;\r
 736 \r
 737       case HAL_UART_RX_COMPLETE_CB_ID :\r
 738         huart->RxCpltCallback = pCallback;\r
 739         break;\r
 740 \r
 741       case HAL_UART_ERROR_CB_ID :\r
 742         huart->ErrorCallback = pCallback;\r
 743         break;\r
 744 \r
 745       case HAL_UART_ABORT_COMPLETE_CB_ID :\r
 746         huart->AbortCpltCallback = pCallback;\r
 747         break;\r
 748 \r
 749       case HAL_UART_ABORT_TRANSMIT_COMPLETE_CB_ID :\r
 750         huart->AbortTransmitCpltCallback = pCallback;\r
 751         break;\r
 752 \r
 753       case HAL_UART_ABORT_RECEIVE_COMPLETE_CB_ID :\r
 754         huart->AbortReceiveCpltCallback = pCallback;\r
 755         break;\r
 756 \r
 757       case HAL_UART_WAKEUP_CB_ID :\r
 758         huart->WakeupCallback = pCallback;\r
 759         break;\r
 760 \r
 761 \r
 762       case HAL_UART_MSPINIT_CB_ID :\r
 763         huart->MspInitCallback = pCallback;\r
 764         break;\r
 765 \r
 766       case HAL_UART_MSPDEINIT_CB_ID :\r
 767         huart->MspDeInitCallback = pCallback;\r
 768         break;\r
 769 \r
 770       default :\r
 771         /* Update the error code */\r
 772         huart->ErrorCode |= HAL_UART_ERROR_INVALID_CALLBACK;\r
 773 \r
 774         /* Return error status */\r
 775         status =  HAL_ERROR;\r
 776         break;\r
 777     }\r
 778   }\r
 779   else if (huart->gState == HAL_UART_STATE_RESET)\r
 780   {\r
 781     switch (CallbackID)\r
 782     {\r
 783       case HAL_UART_MSPINIT_CB_ID :\r
 784         huart->MspInitCallback = pCallback;\r
 785         break;\r
 786 \r
 787       case HAL_UART_MSPDEINIT_CB_ID :\r
 788         huart->MspDeInitCallback = pCallback;\r
 789         break;\r
 790 \r
 791       default :\r
 792         /* Update the error code */\r
 793         huart->ErrorCode |= HAL_UART_ERROR_INVALID_CALLBACK;\r
 794 \r
 795         /* Return error status */\r
 796         status =  HAL_ERROR;\r
 797         break;\r
 798     }\r
 799   }\r
 800   else\r
 801   {\r
 802     /* Update the error code */\r
 803     huart->ErrorCode |= HAL_UART_ERROR_INVALID_CALLBACK;\r
 804 \r
 805     /* Return error status */\r
 806     status =  HAL_ERROR;\r
 807   }\r
 808 \r
 809   /* Release Lock */\r
 810   __HAL_UNLOCK(huart);\r
 811 \r
 812   return status;\r
 813 }\r
 814 \r
 815 /**\r
 816   * @brief  Unregister an UART Callback\r
 817   *         UART callaback is redirected to the weak predefined callback\r
 818   * @param  huart uart handle\r
 819   * @param  CallbackID ID of the callback to be unregistered\r
 820   *         This parameter can be one of the following values:\r
 821   *           @arg @ref HAL_UART_TX_HALFCOMPLETE_CB_ID Tx Half Complete Callback ID\r
 822   *           @arg @ref HAL_UART_TX_COMPLETE_CB_ID Tx Complete Callback ID\r
 823   *           @arg @ref HAL_UART_RX_HALFCOMPLETE_CB_ID Rx Half Complete Callback ID\r
 824   *           @arg @ref HAL_UART_RX_COMPLETE_CB_ID Rx Complete Callback ID\r
 825   *           @arg @ref HAL_UART_ERROR_CB_ID Error Callback ID\r
 826   *           @arg @ref HAL_UART_ABORT_COMPLETE_CB_ID Abort Complete Callback ID\r
 827   *           @arg @ref HAL_UART_ABORT_TRANSMIT_COMPLETE_CB_ID Abort Transmit Complete Callback ID\r
 828   *           @arg @ref HAL_UART_ABORT_RECEIVE_COMPLETE_CB_ID Abort Receive Complete Callback ID\r
 829   *           @arg @ref HAL_UART_WAKEUP_CB_ID Wakeup Callback ID\r
 830   *           @arg @ref HAL_UART_RX_FIFO_FULL_CB_ID Rx Fifo Full Callback ID\r
 831   *           @arg @ref HAL_UART_TX_FIFO_EMPTY_CB_ID Tx Fifo Empty Callback ID\r
 832   *           @arg @ref HAL_UART_MSPINIT_CB_ID MspInit Callback ID\r
 833   *           @arg @ref HAL_UART_MSPDEINIT_CB_ID MspDeInit Callback ID\r
 834   * @retval HAL status\r
 835   */\r
 836 HAL_StatusTypeDef HAL_UART_UnRegisterCallback(UART_HandleTypeDef *huart, HAL_UART_CallbackIDTypeDef CallbackID)\r
 837 {\r
 838   HAL_StatusTypeDef status = HAL_OK;\r
 839 \r
 840   /* Process locked */\r
 841   __HAL_LOCK(huart);\r
 842 \r
 843   if (HAL_UART_STATE_READY == huart->gState)\r
 844   {\r
 845     switch (CallbackID)\r
 846     {\r
 847       case HAL_UART_TX_HALFCOMPLETE_CB_ID :\r
 848         huart->TxHalfCpltCallback = HAL_UART_TxHalfCpltCallback;               /* Legacy weak  TxHalfCpltCallback       */\r
 849         break;\r
 850 \r
 851       case HAL_UART_TX_COMPLETE_CB_ID :\r
 852         huart->TxCpltCallback = HAL_UART_TxCpltCallback;                       /* Legacy weak TxCpltCallback            */\r
 853         break;\r
 854 \r
 855       case HAL_UART_RX_HALFCOMPLETE_CB_ID :\r
 856         huart->RxHalfCpltCallback = HAL_UART_RxHalfCpltCallback;               /* Legacy weak RxHalfCpltCallback        */\r
 857         break;\r
 858 \r
 859       case HAL_UART_RX_COMPLETE_CB_ID :\r
 860         huart->RxCpltCallback = HAL_UART_RxCpltCallback;                       /* Legacy weak RxCpltCallback            */\r
 861         break;\r
 862 \r
 863       case HAL_UART_ERROR_CB_ID :\r
 864         huart->ErrorCallback = HAL_UART_ErrorCallback;                         /* Legacy weak ErrorCallback             */\r
 865         break;\r
 866 \r
 867       case HAL_UART_ABORT_COMPLETE_CB_ID :\r
 868         huart->AbortCpltCallback = HAL_UART_AbortCpltCallback;                 /* Legacy weak AbortCpltCallback         */\r
 869         break;\r
 870 \r
 871       case HAL_UART_ABORT_TRANSMIT_COMPLETE_CB_ID :\r
 872         huart->AbortTransmitCpltCallback = HAL_UART_AbortTransmitCpltCallback; /* Legacy weak AbortTransmitCpltCallback */\r
 873         break;\r
 874 \r
 875       case HAL_UART_ABORT_RECEIVE_COMPLETE_CB_ID :\r
 876         huart->AbortReceiveCpltCallback = HAL_UART_AbortReceiveCpltCallback;   /* Legacy weak AbortReceiveCpltCallback  */\r
 877         break;\r
 878 \r
 879       case HAL_UART_MSPINIT_CB_ID :\r
 880         huart->MspInitCallback = HAL_UART_MspInit;                             /* Legacy weak MspInitCallback           */\r
 881         break;\r
 882 \r
 883       case HAL_UART_MSPDEINIT_CB_ID :\r
 884         huart->MspDeInitCallback = HAL_UART_MspDeInit;                         /* Legacy weak MspDeInitCallback         */\r
 885         break;\r
 886 \r
 887       default :\r
 888         /* Update the error code */\r
 889         huart->ErrorCode |= HAL_UART_ERROR_INVALID_CALLBACK;\r
 890 \r
 891         /* Return error status */\r
 892         status =  HAL_ERROR;\r
 893         break;\r
 894     }\r
 895   }\r
 896   else if (HAL_UART_STATE_RESET == huart->gState)\r
 897   {\r
 898     switch (CallbackID)\r
 899     {\r
 900       case HAL_UART_MSPINIT_CB_ID :\r
 901         huart->MspInitCallback = HAL_UART_MspInit;\r
 902         break;\r
 903 \r
 904       case HAL_UART_MSPDEINIT_CB_ID :\r
 905         huart->MspDeInitCallback = HAL_UART_MspDeInit;\r
 906         break;\r
 907 \r
 908       default :\r
 909         /* Update the error code */\r
 910         huart->ErrorCode |= HAL_UART_ERROR_INVALID_CALLBACK;\r
 911 \r
 912         /* Return error status */\r
 913         status =  HAL_ERROR;\r
 914         break;\r
 915     }\r
 916   }\r
 917   else\r
 918   {\r
 919     /* Update the error code */\r
 920     huart->ErrorCode |= HAL_UART_ERROR_INVALID_CALLBACK;\r
 921 \r
 922     /* Return error status */\r
 923     status =  HAL_ERROR;\r
 924   }\r
 925 \r
 926   /* Release Lock */\r
 927   __HAL_UNLOCK(huart);\r
 928 \r
 929   return status;\r
 930 }\r
 931 #endif /* USE_HAL_UART_REGISTER_CALLBACKS */\r
 932 \r
 933 /**\r
 934   * @}\r
 935   */\r
 936 \r
 937 /** @defgroup UART_Exported_Functions_Group2 IO operation functions\r
 938   * @brief UART Transmit/Receive functions\r
 939   *\r
 940 @verbatim\r
 941  ===============================================================================\r
 942                       ##### IO operation functions #####\r
 943  ===============================================================================\r
 944     This subsection provides a set of functions allowing to manage the UART asynchronous\r
 945     and Half duplex data transfers.\r
 946 \r
 947     (#) There are two mode of transfer:\r
 948        (+) Blocking mode: The communication is performed in polling mode.\r
 949            The HAL status of all data processing is returned by the same function\r
 950            after finishing transfer.\r
 951        (+) Non-Blocking mode: The communication is performed using Interrupts\r
 952            or DMA, These API's return the HAL status.\r
 953            The end of the data processing will be indicated through the\r
 954            dedicated UART IRQ when using Interrupt mode or the DMA IRQ when\r
 955            using DMA mode.\r
 956            The HAL_UART_TxCpltCallback(), HAL_UART_RxCpltCallback() user callbacks\r
 957            will be executed respectively at the end of the transmit or Receive process\r
 958            The HAL_UART_ErrorCallback()user callback will be executed when a communication error is detected\r
 959 \r
 960     (#) Blocking mode API's are :\r
 961         (+) HAL_UART_Transmit()\r
 962         (+) HAL_UART_Receive()\r
 963 \r
 964     (#) Non-Blocking mode API's with Interrupt are :\r
 965         (+) HAL_UART_Transmit_IT()\r
 966         (+) HAL_UART_Receive_IT()\r
 967         (+) HAL_UART_IRQHandler()\r
 968 \r
 969     (#) Non-Blocking mode API's with DMA are :\r
 970         (+) HAL_UART_Transmit_DMA()\r
 971         (+) HAL_UART_Receive_DMA()\r
 972         (+) HAL_UART_DMAPause()\r
 973         (+) HAL_UART_DMAResume()\r
 974         (+) HAL_UART_DMAStop()\r
 975 \r
 976     (#) A set of Transfer Complete Callbacks are provided in Non_Blocking mode:\r
 977         (+) HAL_UART_TxHalfCpltCallback()\r
 978         (+) HAL_UART_TxCpltCallback()\r
 979         (+) HAL_UART_RxHalfCpltCallback()\r
 980         (+) HAL_UART_RxCpltCallback()\r
 981         (+) HAL_UART_ErrorCallback()\r
 982 \r
 983     (#) Non-Blocking mode transfers could be aborted using Abort API's :\r
 984         (+) HAL_UART_Abort()\r
 985         (+) HAL_UART_AbortTransmit()\r
 986         (+) HAL_UART_AbortReceive()\r
 987         (+) HAL_UART_Abort_IT()\r
 988         (+) HAL_UART_AbortTransmit_IT()\r
 989         (+) HAL_UART_AbortReceive_IT()\r
 990 \r
 991     (#) For Abort services based on interrupts (HAL_UART_Abortxxx_IT), a set of Abort Complete Callbacks are provided:\r
 992         (+) HAL_UART_AbortCpltCallback()\r
 993         (+) HAL_UART_AbortTransmitCpltCallback()\r
 994         (+) HAL_UART_AbortReceiveCpltCallback()\r
 995 \r
 996     (#) In Non-Blocking mode transfers, possible errors are split into 2 categories.\r
 997         Errors are handled as follows :\r
 998        (+) Error is considered as Recoverable and non blocking : Transfer could go till end, but error severity is\r
 999            to be evaluated by user : this concerns Frame Error, Parity Error or Noise Error in Interrupt mode reception .\r
1000            Received character is then retrieved and stored in Rx buffer, Error code is set to allow user to identify error type,\r
1001            and HAL_UART_ErrorCallback() user callback is executed. Transfer is kept ongoing on UART side.\r
1002            If user wants to abort it, Abort services should be called by user.\r
1003        (+) Error is considered as Blocking : Transfer could not be completed properly and is aborted.\r
1004            This concerns Overrun Error In Interrupt mode reception and all errors in DMA mode.\r
1005            Error code is set to allow user to identify error type, and HAL_UART_ErrorCallback() user callback is executed.\r
1006 \r
1007     -@- In the Half duplex communication, it is forbidden to run the transmit\r
1008         and receive process in parallel, the UART state HAL_UART_STATE_BUSY_TX_RX can't be useful.\r
1009 \r
1010 @endverbatim\r
1011   * @{\r
1012   */\r
1013 \r
1014 /**\r
1015   * @brief Send an amount of data in blocking mode.\r
1016   * @param huart   UART handle.\r
1017   * @param pData   Pointer to data buffer.\r
1018   * @param Size    Amount of data to be sent.\r
1019   * @param Timeout Timeout duration.\r
1020   * @retval HAL status\r
1021   */\r
1022 HAL_StatusTypeDef HAL_UART_Transmit(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout)\r
1023 {\r
1024   uint8_t  *pdata8bits;\r
1025   uint16_t *pdata16bits;\r
1026   uint32_t tickstart;\r
1027 \r
1028   /* Check that a Tx process is not already ongoing */\r
1029   if (huart->gState == HAL_UART_STATE_READY)\r
1030   {\r
1031     if ((pData == NULL) || (Size == 0U))\r
1032     {\r
1033       return  HAL_ERROR;\r
1034     }\r
1035 \r
1036     /* Process Locked */\r
1037     __HAL_LOCK(huart);\r
1038 \r
1039     huart->ErrorCode = HAL_UART_ERROR_NONE;\r
1040     huart->gState = HAL_UART_STATE_BUSY_TX;\r
1041 \r
1042     /* Init tickstart for timeout managment*/\r
1043     tickstart = HAL_GetTick();\r
1044 \r
1045     huart->TxXferSize  = Size;\r
1046     huart->TxXferCount = Size;\r
1047 \r
1048         /* In case of 9bits/No Parity transfer, pData needs to be handled as a uint16_t pointer */\r
1049     if ((huart->Init.WordLength == UART_WORDLENGTH_9B) && (huart->Init.Parity == UART_PARITY_NONE))\r
1050     {\r
1051       pdata8bits  = NULL;\r
1052       pdata16bits = (uint16_t *) pData;\r
1053     }\r
1054     else\r
1055     {\r
1056       pdata8bits  = pData;\r
1057       pdata16bits = NULL;\r
1058     }\r
1059 \r
1060     while (huart->TxXferCount > 0U)\r
1061     {\r
1062       if (UART_WaitOnFlagUntilTimeout(huart, UART_FLAG_TXE, RESET, tickstart, Timeout) != HAL_OK)\r
1063       {\r
1064         return HAL_TIMEOUT;\r
1065       }\r
1066       if (pdata8bits == NULL)\r
1067       {\r
1068         huart->Instance->TDR = (uint16_t)(*pdata16bits & 0x01FFU);\r
1069         pdata16bits++;\r
1070       }\r
1071       else\r
1072       {\r
1073         huart->Instance->TDR = (uint8_t)(*pdata8bits & 0xFFU);\r
1074         pdata8bits++;\r
1075       }\r
1076       huart->TxXferCount--;\r
1077     }\r
1078 \r
1079     if (UART_WaitOnFlagUntilTimeout(huart, UART_FLAG_TC, RESET, tickstart, Timeout) != HAL_OK)\r
1080     {\r
1081       return HAL_TIMEOUT;\r
1082     }\r
1083 \r
1084     /* At end of Tx process, restore huart->gState to Ready */\r
1085     huart->gState = HAL_UART_STATE_READY;\r
1086 \r
1087     /* Process Unlocked */\r
1088     __HAL_UNLOCK(huart);\r
1089 \r
1090     return HAL_OK;\r
1091   }\r
1092   else\r
1093   {\r
1094     return HAL_BUSY;\r
1095   }\r
1096 }\r
1097 \r
1098 /**\r
1099   * @brief Receive an amount of data in blocking mode.\r
1100   * @param huart   UART handle.\r
1101   * @param pData   Pointer to data buffer.\r
1102   * @param Size    Amount of data to be received.\r
1103   * @param Timeout Timeout duration.\r
1104   * @retval HAL status\r
1105   */\r
1106 HAL_StatusTypeDef HAL_UART_Receive(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout)\r
1107 {\r
1108   uint8_t  *pdata8bits;\r
1109   uint16_t *pdata16bits;\r
1110   uint16_t uhMask;\r
1111   uint32_t tickstart;\r
1112 \r
1113   /* Check that a Rx process is not already ongoing */\r
1114   if (huart->RxState == HAL_UART_STATE_READY)\r
1115   {\r
1116     if ((pData == NULL) || (Size == 0U))\r
1117     {\r
1118       return  HAL_ERROR;\r
1119     }\r
1120 \r
1121     /* Process Locked */\r
1122     __HAL_LOCK(huart);\r
1123 \r
1124     huart->ErrorCode = HAL_UART_ERROR_NONE;\r
1125     huart->RxState = HAL_UART_STATE_BUSY_RX;\r
1126 \r
1127     /* Init tickstart for timeout managment*/\r
1128     tickstart = HAL_GetTick();\r
1129 \r
1130     huart->RxXferSize  = Size;\r
1131     huart->RxXferCount = Size;\r
1132 \r
1133     /* Computation of UART mask to apply to RDR register */\r
1134     UART_MASK_COMPUTATION(huart);\r
1135     uhMask = huart->Mask;\r
1136 \r
1137     /* In case of 9bits/No Parity transfer, pRxData needs to be handled as a uint16_t pointer */\r
1138     if ((huart->Init.WordLength == UART_WORDLENGTH_9B) && (huart->Init.Parity == UART_PARITY_NONE))\r
1139     {\r
1140       pdata8bits  = NULL;\r
1141       pdata16bits = (uint16_t *) pData;\r
1142     }\r
1143     else\r
1144     {\r
1145       pdata8bits  = pData;\r
1146       pdata16bits = NULL;\r
1147     }\r
1148 \r
1149     /* as long as data have to be received */\r
1150     while (huart->RxXferCount > 0U)\r
1151     {\r
1152       if (UART_WaitOnFlagUntilTimeout(huart, UART_FLAG_RXNE, RESET, tickstart, Timeout) != HAL_OK)\r
1153       {\r
1154         return HAL_TIMEOUT;\r
1155       }\r
1156       if (pdata8bits == NULL)\r
1157       {\r
1158         *pdata16bits = (uint16_t)(huart->Instance->RDR & uhMask);\r
1159         pdata16bits++;\r
1160       }\r
1161       else\r
1162       {\r
1163         *pdata8bits = (uint8_t)(huart->Instance->RDR & (uint8_t)uhMask);\r
1164         pdata8bits++;\r
1165       }\r
1166       huart->RxXferCount--;\r
1167     }\r
1168 \r
1169     /* At end of Rx process, restore huart->RxState to Ready */\r
1170     huart->RxState = HAL_UART_STATE_READY;\r
1171 \r
1172     /* Process Unlocked */\r
1173     __HAL_UNLOCK(huart);\r
1174 \r
1175     return HAL_OK;\r
1176   }\r
1177   else\r
1178   {\r
1179     return HAL_BUSY;\r
1180   }\r
1181 }\r
1182 \r
1183 /**\r
1184   * @brief Send an amount of data in interrupt mode.\r
1185   * @param huart UART handle.\r
1186   * @param pData Pointer to data buffer.\r
1187   * @param Size  Amount of data to be sent.\r
1188   * @retval HAL status\r
1189   */\r
1190 HAL_StatusTypeDef HAL_UART_Transmit_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)\r
1191 {\r
1192   /* Check that a Tx process is not already ongoing */\r
1193   if (huart->gState == HAL_UART_STATE_READY)\r
1194   {\r
1195     if ((pData == NULL) || (Size == 0U))\r
1196     {\r
1197       return HAL_ERROR;\r
1198     }\r
1199 \r
1200     /* Process Locked */\r
1201     __HAL_LOCK(huart);\r
1202 \r
1203     huart->pTxBuffPtr  = pData;\r
1204     huart->TxXferSize  = Size;\r
1205     huart->TxXferCount = Size;\r
1206     huart->TxISR       = NULL;\r
1207 \r
1208     huart->ErrorCode = HAL_UART_ERROR_NONE;\r
1209     huart->gState = HAL_UART_STATE_BUSY_TX;\r
1210 \r
1211     /* Set the Tx ISR function pointer according to the data word length */\r
1212     if ((huart->Init.WordLength == UART_WORDLENGTH_9B) && (huart->Init.Parity == UART_PARITY_NONE))\r
1213     {\r
1214       huart->TxISR = UART_TxISR_16BIT;\r
1215     }\r
1216     else\r
1217     {\r
1218       huart->TxISR = UART_TxISR_8BIT;\r
1219     }\r
1220 \r
1221     /* Process Unlocked */\r
1222     __HAL_UNLOCK(huart);\r
1223 \r
1224     /* Enable the Transmit Data Register Empty interrupt */\r
1225     SET_BIT(huart->Instance->CR1, USART_CR1_TXEIE);\r
1226 \r
1227     return HAL_OK;\r
1228   }\r
1229   else\r
1230   {\r
1231     return HAL_BUSY;\r
1232   }\r
1233 }\r
1234 \r
1235 /**\r
1236   * @brief Receive an amount of data in interrupt mode.\r
1237   * @param huart UART handle.\r
1238   * @param pData Pointer to data buffer.\r
1239   * @param Size  Amount of data to be received.\r
1240   * @retval HAL status\r
1241   */\r
1242 HAL_StatusTypeDef HAL_UART_Receive_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)\r
1243 {\r
1244   /* Check that a Rx process is not already ongoing */\r
1245   if (huart->RxState == HAL_UART_STATE_READY)\r
1246   {\r
1247     if ((pData == NULL) || (Size == 0U))\r
1248     {\r
1249       return HAL_ERROR;\r
1250     }\r
1251 \r
1252     /* Process Locked */\r
1253     __HAL_LOCK(huart);\r
1254 \r
1255     huart->pRxBuffPtr  = pData;\r
1256     huart->RxXferSize  = Size;\r
1257     huart->RxXferCount = Size;\r
1258     huart->RxISR       = NULL;\r
1259 \r
1260     /* Computation of UART mask to apply to RDR register */\r
1261     UART_MASK_COMPUTATION(huart);\r
1262 \r
1263     huart->ErrorCode = HAL_UART_ERROR_NONE;\r
1264     huart->RxState = HAL_UART_STATE_BUSY_RX;\r
1265 \r
1266     /* Enable the UART Error Interrupt: (Frame error, noise error, overrun error) */\r
1267     SET_BIT(huart->Instance->CR3, USART_CR3_EIE);\r
1268 \r
1269     /* Set the Rx ISR function pointer according to the data word length */\r
1270     if ((huart->Init.WordLength == UART_WORDLENGTH_9B) && (huart->Init.Parity == UART_PARITY_NONE))\r
1271     {\r
1272       huart->RxISR = UART_RxISR_16BIT;\r
1273     }\r
1274     else\r
1275     {\r
1276       huart->RxISR = UART_RxISR_8BIT;\r
1277     }\r
1278 \r
1279     /* Process Unlocked */\r
1280     __HAL_UNLOCK(huart);\r
1281 \r
1282     /* Enable the UART Parity Error interrupt and Data Register Not Empty interrupt */\r
1283     SET_BIT(huart->Instance->CR1, USART_CR1_PEIE | USART_CR1_RXNEIE);\r
1284 \r
1285     return HAL_OK;\r
1286   }\r
1287   else\r
1288   {\r
1289     return HAL_BUSY;\r
1290   }\r
1291 }\r
1292 \r
1293 /**\r
1294   * @brief Send an amount of data in DMA mode.\r
1295   * @param huart UART handle.\r
1296   * @param pData Pointer to data buffer.\r
1297   * @param Size  Amount of data to be sent.\r
1298   * @retval HAL status\r
1299   */\r
1300 HAL_StatusTypeDef HAL_UART_Transmit_DMA(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)\r
1301 {\r
1302   /* Check that a Tx process is not already ongoing */\r
1303   if (huart->gState == HAL_UART_STATE_READY)\r
1304   {\r
1305     if ((pData == NULL) || (Size == 0U))\r
1306     {\r
1307       return HAL_ERROR;\r
1308     }\r
1309 \r
1310     /* Process Locked */\r
1311     __HAL_LOCK(huart);\r
1312 \r
1313     huart->pTxBuffPtr  = pData;\r
1314     huart->TxXferSize  = Size;\r
1315     huart->TxXferCount = Size;\r
1316 \r
1317     huart->ErrorCode = HAL_UART_ERROR_NONE;\r
1318     huart->gState = HAL_UART_STATE_BUSY_TX;\r
1319 \r
1320     if (huart->hdmatx != NULL)\r
1321     {\r
1322       /* Set the UART DMA transfer complete callback */\r
1323       huart->hdmatx->XferCpltCallback = UART_DMATransmitCplt;\r
1324 \r
1325       /* Set the UART DMA Half transfer complete callback */\r
1326       huart->hdmatx->XferHalfCpltCallback = UART_DMATxHalfCplt;\r
1327 \r
1328       /* Set the DMA error callback */\r
1329       huart->hdmatx->XferErrorCallback = UART_DMAError;\r
1330 \r
1331       /* Set the DMA abort callback */\r
1332       huart->hdmatx->XferAbortCallback = NULL;\r
1333 \r
1334       /* Enable the UART transmit DMA channel */\r
1335       if (HAL_DMA_Start_IT(huart->hdmatx, (uint32_t)huart->pTxBuffPtr, (uint32_t)&huart->Instance->TDR, Size) != HAL_OK)\r
1336       {\r
1337         /* Set error code to DMA */\r
1338         huart->ErrorCode = HAL_UART_ERROR_DMA;\r
1339 \r
1340         /* Process Unlocked */\r
1341         __HAL_UNLOCK(huart);\r
1342 \r
1343         /* Restore huart->gState to ready */\r
1344         huart->gState = HAL_UART_STATE_READY;\r
1345 \r
1346         return HAL_ERROR;\r
1347       }\r
1348     }\r
1349     /* Clear the TC flag in the ICR register */\r
1350     __HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_TCF);\r
1351 \r
1352     /* Process Unlocked */\r
1353     __HAL_UNLOCK(huart);\r
1354 \r
1355     /* Enable the DMA transfer for transmit request by setting the DMAT bit\r
1356     in the UART CR3 register */\r
1357     SET_BIT(huart->Instance->CR3, USART_CR3_DMAT);\r
1358 \r
1359     return HAL_OK;\r
1360   }\r
1361   else\r
1362   {\r
1363     return HAL_BUSY;\r
1364   }\r
1365 }\r
1366 \r
1367 /**\r
1368   * @brief Receive an amount of data in DMA mode.\r
1369   * @note   When the UART parity is enabled (PCE = 1), the received data contain\r
1370   *         the parity bit (MSB position).\r
1371   * @param huart UART handle.\r
1372   * @param pData Pointer to data buffer.\r
1373   * @param Size  Amount of data to be received.\r
1374   * @retval HAL status\r
1375   */\r
1376 HAL_StatusTypeDef HAL_UART_Receive_DMA(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)\r
1377 {\r
1378   /* Check that a Rx process is not already ongoing */\r
1379   if (huart->RxState == HAL_UART_STATE_READY)\r
1380   {\r
1381     if ((pData == NULL) || (Size == 0U))\r
1382     {\r
1383       return HAL_ERROR;\r
1384     }\r
1385 \r
1386     /* Process Locked */\r
1387     __HAL_LOCK(huart);\r
1388 \r
1389     huart->pRxBuffPtr = pData;\r
1390     huart->RxXferSize = Size;\r
1391 \r
1392     huart->ErrorCode = HAL_UART_ERROR_NONE;\r
1393     huart->RxState = HAL_UART_STATE_BUSY_RX;\r
1394 \r
1395     if (huart->hdmarx != NULL)\r
1396     {\r
1397       /* Set the UART DMA transfer complete callback */\r
1398       huart->hdmarx->XferCpltCallback = UART_DMAReceiveCplt;\r
1399 \r
1400       /* Set the UART DMA Half transfer complete callback */\r
1401       huart->hdmarx->XferHalfCpltCallback = UART_DMARxHalfCplt;\r
1402 \r
1403       /* Set the DMA error callback */\r
1404       huart->hdmarx->XferErrorCallback = UART_DMAError;\r
1405 \r
1406       /* Set the DMA abort callback */\r
1407       huart->hdmarx->XferAbortCallback = NULL;\r
1408 \r
1409       /* Enable the DMA channel */\r
1410       if (HAL_DMA_Start_IT(huart->hdmarx, (uint32_t)&huart->Instance->RDR, (uint32_t)huart->pRxBuffPtr, Size) != HAL_OK)\r
1411       {\r
1412         /* Set error code to DMA */\r
1413         huart->ErrorCode = HAL_UART_ERROR_DMA;\r
1414 \r
1415         /* Process Unlocked */\r
1416         __HAL_UNLOCK(huart);\r
1417 \r
1418         /* Restore huart->gState to ready */\r
1419         huart->gState = HAL_UART_STATE_READY;\r
1420 \r
1421         return HAL_ERROR;\r
1422       }\r
1423     }\r
1424     /* Process Unlocked */\r
1425     __HAL_UNLOCK(huart);\r
1426 \r
1427     /* Enable the UART Parity Error Interrupt */\r
1428     SET_BIT(huart->Instance->CR1, USART_CR1_PEIE);\r
1429 \r
1430     /* Enable the UART Error Interrupt: (Frame error, noise error, overrun error) */\r
1431     SET_BIT(huart->Instance->CR3, USART_CR3_EIE);\r
1432 \r
1433     /* Enable the DMA transfer for the receiver request by setting the DMAR bit\r
1434     in the UART CR3 register */\r
1435     SET_BIT(huart->Instance->CR3, USART_CR3_DMAR);\r
1436 \r
1437     return HAL_OK;\r
1438   }\r
1439   else\r
1440   {\r
1441     return HAL_BUSY;\r
1442   }\r
1443 }\r
1444 \r
1445 /**\r
1446   * @brief Pause the DMA Transfer.\r
1447   * @param huart UART handle.\r
1448   * @retval HAL status\r
1449   */\r
1450 HAL_StatusTypeDef HAL_UART_DMAPause(UART_HandleTypeDef *huart)\r
1451 {\r
1452   const HAL_UART_StateTypeDef gstate = huart->gState;\r
1453   const HAL_UART_StateTypeDef rxstate = huart->RxState;\r
1454 \r
1455   /* Process Locked */\r
1456   __HAL_LOCK(huart);\r
1457 \r
1458   if ((HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAT)) &&\r
1459       (gstate == HAL_UART_STATE_BUSY_TX))\r
1460   {\r
1461     /* Disable the UART DMA Tx request */\r
1462     CLEAR_BIT(huart->Instance->CR3, USART_CR3_DMAT);\r
1463   }\r
1464   if ((HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAR)) &&\r
1465       (rxstate == HAL_UART_STATE_BUSY_RX))\r
1466   {\r
1467     /* Disable PE and ERR (Frame error, noise error, overrun error) interrupts */\r
1468     CLEAR_BIT(huart->Instance->CR1, USART_CR1_PEIE);\r
1469     CLEAR_BIT(huart->Instance->CR3, USART_CR3_EIE);\r
1470 \r
1471     /* Disable the UART DMA Rx request */\r
1472     CLEAR_BIT(huart->Instance->CR3, USART_CR3_DMAR);\r
1473   }\r
1474 \r
1475   /* Process Unlocked */\r
1476   __HAL_UNLOCK(huart);\r
1477 \r
1478   return HAL_OK;\r
1479 }\r
1480 \r
1481 /**\r
1482   * @brief Resume the DMA Transfer.\r
1483   * @param huart UART handle.\r
1484   * @retval HAL status\r
1485   */\r
1486 HAL_StatusTypeDef HAL_UART_DMAResume(UART_HandleTypeDef *huart)\r
1487 {\r
1488   /* Process Locked */\r
1489   __HAL_LOCK(huart);\r
1490 \r
1491   if (huart->gState == HAL_UART_STATE_BUSY_TX)\r
1492   {\r
1493     /* Enable the UART DMA Tx request */\r
1494     SET_BIT(huart->Instance->CR3, USART_CR3_DMAT);\r
1495   }\r
1496   if (huart->RxState == HAL_UART_STATE_BUSY_RX)\r
1497   {\r
1498     /* Clear the Overrun flag before resuming the Rx transfer */\r
1499     __HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_OREF);\r
1500 \r
1501     /* Reenable PE and ERR (Frame error, noise error, overrun error) interrupts */\r
1502     SET_BIT(huart->Instance->CR1, USART_CR1_PEIE);\r
1503     SET_BIT(huart->Instance->CR3, USART_CR3_EIE);\r
1504 \r
1505     /* Enable the UART DMA Rx request */\r
1506     SET_BIT(huart->Instance->CR3, USART_CR3_DMAR);\r
1507   }\r
1508 \r
1509   /* Process Unlocked */\r
1510   __HAL_UNLOCK(huart);\r
1511 \r
1512   return HAL_OK;\r
1513 }\r
1514 \r
1515 /**\r
1516   * @brief Stop the DMA Transfer.\r
1517   * @param huart UART handle.\r
1518   * @retval HAL status\r
1519   */\r
1520 HAL_StatusTypeDef HAL_UART_DMAStop(UART_HandleTypeDef *huart)\r
1521 {\r
1522   /* The Lock is not implemented on this API to allow the user application\r
1523      to call the HAL UART API under callbacks HAL_UART_TxCpltCallback() / HAL_UART_RxCpltCallback() /\r
1524      HAL_UART_TxHalfCpltCallback / HAL_UART_RxHalfCpltCallback:\r
1525      indeed, when HAL_DMA_Abort() API is called, the DMA TX/RX Transfer or Half Transfer complete\r
1526      interrupt is generated if the DMA transfer interruption occurs at the middle or at the end of\r
1527      the stream and the corresponding call back is executed. */\r
1528 \r
1529   const HAL_UART_StateTypeDef gstate = huart->gState;\r
1530   const HAL_UART_StateTypeDef rxstate = huart->RxState;\r
1531 \r
1532   /* Stop UART DMA Tx request if ongoing */\r
1533   if ((HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAT)) &&\r
1534       (gstate == HAL_UART_STATE_BUSY_TX))\r
1535   {\r
1536     CLEAR_BIT(huart->Instance->CR3, USART_CR3_DMAT);\r
1537 \r
1538     /* Abort the UART DMA Tx channel */\r
1539     if (huart->hdmatx != NULL)\r
1540     {\r
1541       if (HAL_DMA_Abort(huart->hdmatx) != HAL_OK)\r
1542       {\r
1543         if (HAL_DMA_GetError(huart->hdmatx) == HAL_DMA_ERROR_TIMEOUT)\r
1544         {\r
1545           /* Set error code to DMA */\r
1546           huart->ErrorCode = HAL_UART_ERROR_DMA;\r
1547 \r
1548           return HAL_TIMEOUT;\r
1549         }\r
1550       }\r
1551     }\r
1552 \r
1553     UART_EndTxTransfer(huart);\r
1554   }\r
1555 \r
1556   /* Stop UART DMA Rx request if ongoing */\r
1557   if ((HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAR)) &&\r
1558       (rxstate == HAL_UART_STATE_BUSY_RX))\r
1559   {\r
1560     CLEAR_BIT(huart->Instance->CR3, USART_CR3_DMAR);\r
1561 \r
1562     /* Abort the UART DMA Rx channel */\r
1563     if (huart->hdmarx != NULL)\r
1564     {\r
1565       if (HAL_DMA_Abort(huart->hdmarx) != HAL_OK)\r
1566       {\r
1567         if (HAL_DMA_GetError(huart->hdmarx) == HAL_DMA_ERROR_TIMEOUT)\r
1568         {\r
1569           /* Set error code to DMA */\r
1570           huart->ErrorCode = HAL_UART_ERROR_DMA;\r
1571 \r
1572           return HAL_TIMEOUT;\r
1573         }\r
1574       }\r
1575     }\r
1576 \r
1577     UART_EndRxTransfer(huart);\r
1578   }\r
1579 \r
1580   return HAL_OK;\r
1581 }\r
1582 \r
1583 /**\r
1584   * @brief  Abort ongoing transfers (blocking mode).\r
1585   * @param  huart UART handle.\r
1586   * @note   This procedure could be used for aborting any ongoing transfer started in Interrupt or DMA mode.\r
1587   *         This procedure performs following operations :\r
1588   *           - Disable UART Interrupts (Tx and Rx)\r
1589   *           - Disable the DMA transfer in the peripheral register (if enabled)\r
1590   *           - Abort DMA transfer by calling HAL_DMA_Abort (in case of transfer in DMA mode)\r
1591   *           - Set handle State to READY\r
1592   * @note   This procedure is executed in blocking mode : when exiting function, Abort is considered as completed.\r
1593   * @retval HAL status\r
1594 */\r
1595 HAL_StatusTypeDef HAL_UART_Abort(UART_HandleTypeDef *huart)\r
1596 {\r
1597   /* Disable TXEIE, TCIE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts */\r
1598   CLEAR_BIT(huart->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE | USART_CR1_TXEIE | USART_CR1_TCIE));\r
1599   CLEAR_BIT(huart->Instance->CR3, USART_CR3_EIE);\r
1600 \r
1601   /* Disable the UART DMA Tx request if enabled */\r
1602   if (HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAT))\r
1603   {\r
1604     CLEAR_BIT(huart->Instance->CR3, USART_CR3_DMAT);\r
1605 \r
1606     /* Abort the UART DMA Tx channel : use blocking DMA Abort API (no callback) */\r
1607     if (huart->hdmatx != NULL)\r
1608     {\r
1609       /* Set the UART DMA Abort callback to Null.\r
1610          No call back execution at end of DMA abort procedure */\r
1611       huart->hdmatx->XferAbortCallback = NULL;\r
1612 \r
1613       if (HAL_DMA_Abort(huart->hdmatx) != HAL_OK)\r
1614       {\r
1615         if (HAL_DMA_GetError(huart->hdmatx) == HAL_DMA_ERROR_TIMEOUT)\r
1616         {\r
1617           /* Set error code to DMA */\r
1618           huart->ErrorCode = HAL_UART_ERROR_DMA;\r
1619 \r
1620           return HAL_TIMEOUT;\r
1621         }\r
1622       }\r
1623     }\r
1624   }\r
1625 \r
1626   /* Disable the UART DMA Rx request if enabled */\r
1627   if (HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAR))\r
1628   {\r
1629     CLEAR_BIT(huart->Instance->CR3, USART_CR3_DMAR);\r
1630 \r
1631     /* Abort the UART DMA Rx channel : use blocking DMA Abort API (no callback) */\r
1632     if (huart->hdmarx != NULL)\r
1633     {\r
1634       /* Set the UART DMA Abort callback to Null.\r
1635          No call back execution at end of DMA abort procedure */\r
1636       huart->hdmarx->XferAbortCallback = NULL;\r
1637 \r
1638       if (HAL_DMA_Abort(huart->hdmarx) != HAL_OK)\r
1639       {\r
1640         if (HAL_DMA_GetError(huart->hdmarx) == HAL_DMA_ERROR_TIMEOUT)\r
1641         {\r
1642           /* Set error code to DMA */\r
1643           huart->ErrorCode = HAL_UART_ERROR_DMA;\r
1644 \r
1645           return HAL_TIMEOUT;\r
1646         }\r
1647       }\r
1648     }\r
1649   }\r
1650 \r
1651   /* Reset Tx and Rx transfer counters */\r
1652   huart->TxXferCount = 0U;\r
1653   huart->RxXferCount = 0U;\r
1654 \r
1655   /* Clear the Error flags in the ICR register */\r
1656   __HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_OREF | UART_CLEAR_NEF | UART_CLEAR_PEF | UART_CLEAR_FEF);\r
1657 \r
1658 \r
1659   /* Discard the received data */\r
1660   __HAL_UART_SEND_REQ(huart, UART_RXDATA_FLUSH_REQUEST);\r
1661 \r
1662   /* Restore huart->gState and huart->RxState to Ready */\r
1663   huart->gState  = HAL_UART_STATE_READY;\r
1664   huart->RxState = HAL_UART_STATE_READY;\r
1665 \r
1666   /* Reset Handle ErrorCode to No Error */\r
1667   huart->ErrorCode = HAL_UART_ERROR_NONE;\r
1668 \r
1669   return HAL_OK;\r
1670 }\r
1671 \r
1672 /**\r
1673   * @brief  Abort ongoing Transmit transfer (blocking mode).\r
1674   * @param  huart UART handle.\r
1675   * @note   This procedure could be used for aborting any ongoing Tx transfer started in Interrupt or DMA mode.\r
1676   *         This procedure performs following operations :\r
1677   *           - Disable UART Interrupts (Tx)\r
1678   *           - Disable the DMA transfer in the peripheral register (if enabled)\r
1679   *           - Abort DMA transfer by calling HAL_DMA_Abort (in case of transfer in DMA mode)\r
1680   *           - Set handle State to READY\r
1681   * @note   This procedure is executed in blocking mode : when exiting function, Abort is considered as completed.\r
1682   * @retval HAL status\r
1683 */\r
1684 HAL_StatusTypeDef HAL_UART_AbortTransmit(UART_HandleTypeDef *huart)\r
1685 {\r
1686   /* Disable TXEIE and TCIE interrupts */\r
1687   CLEAR_BIT(huart->Instance->CR1, (USART_CR1_TXEIE | USART_CR1_TCIE));\r
1688 \r
1689   /* Disable the UART DMA Tx request if enabled */\r
1690   if (HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAT))\r
1691   {\r
1692     CLEAR_BIT(huart->Instance->CR3, USART_CR3_DMAT);\r
1693 \r
1694     /* Abort the UART DMA Tx channel : use blocking DMA Abort API (no callback) */\r
1695     if (huart->hdmatx != NULL)\r
1696     {\r
1697       /* Set the UART DMA Abort callback to Null.\r
1698          No call back execution at end of DMA abort procedure */\r
1699       huart->hdmatx->XferAbortCallback = NULL;\r
1700 \r
1701       if (HAL_DMA_Abort(huart->hdmatx) != HAL_OK)\r
1702       {\r
1703         if (HAL_DMA_GetError(huart->hdmatx) == HAL_DMA_ERROR_TIMEOUT)\r
1704         {\r
1705           /* Set error code to DMA */\r
1706           huart->ErrorCode = HAL_UART_ERROR_DMA;\r
1707 \r
1708           return HAL_TIMEOUT;\r
1709         }\r
1710       }\r
1711     }\r
1712   }\r
1713 \r
1714   /* Reset Tx transfer counter */\r
1715   huart->TxXferCount = 0U;\r
1716 \r
1717 \r
1718   /* Restore huart->gState to Ready */\r
1719   huart->gState = HAL_UART_STATE_READY;\r
1720 \r
1721   return HAL_OK;\r
1722 }\r
1723 \r
1724 /**\r
1725   * @brief  Abort ongoing Receive transfer (blocking mode).\r
1726   * @param  huart UART handle.\r
1727   * @note   This procedure could be used for aborting any ongoing Rx transfer started in Interrupt or DMA mode.\r
1728   *         This procedure performs following operations :\r
1729   *           - Disable UART Interrupts (Rx)\r
1730   *           - Disable the DMA transfer in the peripheral register (if enabled)\r
1731   *           - Abort DMA transfer by calling HAL_DMA_Abort (in case of transfer in DMA mode)\r
1732   *           - Set handle State to READY\r
1733   * @note   This procedure is executed in blocking mode : when exiting function, Abort is considered as completed.\r
1734   * @retval HAL status\r
1735 */\r
1736 HAL_StatusTypeDef HAL_UART_AbortReceive(UART_HandleTypeDef *huart)\r
1737 {\r
1738   /* Disable RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts */\r
1739   CLEAR_BIT(huart->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE));\r
1740   CLEAR_BIT(huart->Instance->CR3, USART_CR3_EIE);\r
1741 \r
1742   /* Disable the UART DMA Rx request if enabled */\r
1743   if (HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAR))\r
1744   {\r
1745     CLEAR_BIT(huart->Instance->CR3, USART_CR3_DMAR);\r
1746 \r
1747     /* Abort the UART DMA Rx channel : use blocking DMA Abort API (no callback) */\r
1748     if (huart->hdmarx != NULL)\r
1749     {\r
1750       /* Set the UART DMA Abort callback to Null.\r
1751          No call back execution at end of DMA abort procedure */\r
1752       huart->hdmarx->XferAbortCallback = NULL;\r
1753 \r
1754       if (HAL_DMA_Abort(huart->hdmarx) != HAL_OK)\r
1755       {\r
1756         if (HAL_DMA_GetError(huart->hdmarx) == HAL_DMA_ERROR_TIMEOUT)\r
1757         {\r
1758           /* Set error code to DMA */\r
1759           huart->ErrorCode = HAL_UART_ERROR_DMA;\r
1760 \r
1761           return HAL_TIMEOUT;\r
1762         }\r
1763       }\r
1764     }\r
1765   }\r
1766 \r
1767   /* Reset Rx transfer counter */\r
1768   huart->RxXferCount = 0U;\r
1769 \r
1770   /* Clear the Error flags in the ICR register */\r
1771   __HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_OREF | UART_CLEAR_NEF | UART_CLEAR_PEF | UART_CLEAR_FEF);\r
1772 \r
1773   /* Discard the received data */\r
1774   __HAL_UART_SEND_REQ(huart, UART_RXDATA_FLUSH_REQUEST);\r
1775 \r
1776   /* Restore huart->RxState to Ready */\r
1777   huart->RxState = HAL_UART_STATE_READY;\r
1778 \r
1779   return HAL_OK;\r
1780 }\r
1781 \r
1782 /**\r
1783   * @brief  Abort ongoing transfers (Interrupt mode).\r
1784   * @param  huart UART handle.\r
1785   * @note   This procedure could be used for aborting any ongoing transfer started in Interrupt or DMA mode.\r
1786   *         This procedure performs following operations :\r
1787   *           - Disable UART Interrupts (Tx and Rx)\r
1788   *           - Disable the DMA transfer in the peripheral register (if enabled)\r
1789   *           - Abort DMA transfer by calling HAL_DMA_Abort_IT (in case of transfer in DMA mode)\r
1790   *           - Set handle State to READY\r
1791   *           - At abort completion, call user abort complete callback\r
1792   * @note   This procedure is executed in Interrupt mode, meaning that abort procedure could be\r
1793   *         considered as completed only when user abort complete callback is executed (not when exiting function).\r
1794   * @retval HAL status\r
1795 */\r
1796 HAL_StatusTypeDef HAL_UART_Abort_IT(UART_HandleTypeDef *huart)\r
1797 {\r
1798   uint32_t abortcplt = 1U;\r
1799 \r
1800   /* Disable interrupts */\r
1801   CLEAR_BIT(huart->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE | USART_CR1_TXEIE | USART_CR1_TCIE));\r
1802   CLEAR_BIT(huart->Instance->CR3, USART_CR3_EIE);\r
1803 \r
1804   /* If DMA Tx and/or DMA Rx Handles are associated to UART Handle, DMA Abort complete callbacks should be initialised\r
1805      before any call to DMA Abort functions */\r
1806   /* DMA Tx Handle is valid */\r
1807   if (huart->hdmatx != NULL)\r
1808   {\r
1809     /* Set DMA Abort Complete callback if UART DMA Tx request if enabled.\r
1810        Otherwise, set it to NULL */\r
1811     if (HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAT))\r
1812     {\r
1813       huart->hdmatx->XferAbortCallback = UART_DMATxAbortCallback;\r
1814     }\r
1815     else\r
1816     {\r
1817       huart->hdmatx->XferAbortCallback = NULL;\r
1818     }\r
1819   }\r
1820   /* DMA Rx Handle is valid */\r
1821   if (huart->hdmarx != NULL)\r
1822   {\r
1823     /* Set DMA Abort Complete callback if UART DMA Rx request if enabled.\r
1824        Otherwise, set it to NULL */\r
1825     if (HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAR))\r
1826     {\r
1827       huart->hdmarx->XferAbortCallback = UART_DMARxAbortCallback;\r
1828     }\r
1829     else\r
1830     {\r
1831       huart->hdmarx->XferAbortCallback = NULL;\r
1832     }\r
1833   }\r
1834 \r
1835   /* Disable the UART DMA Tx request if enabled */\r
1836   if (HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAT))\r
1837   {\r
1838     /* Disable DMA Tx at UART level */\r
1839     CLEAR_BIT(huart->Instance->CR3, USART_CR3_DMAT);\r
1840 \r
1841     /* Abort the UART DMA Tx channel : use non blocking DMA Abort API (callback) */\r
1842     if (huart->hdmatx != NULL)\r
1843     {\r
1844       /* UART Tx DMA Abort callback has already been initialised :\r
1845          will lead to call HAL_UART_AbortCpltCallback() at end of DMA abort procedure */\r
1846 \r
1847       /* Abort DMA TX */\r
1848       if (HAL_DMA_Abort_IT(huart->hdmatx) != HAL_OK)\r
1849       {\r
1850         huart->hdmatx->XferAbortCallback = NULL;\r
1851       }\r
1852       else\r
1853       {\r
1854         abortcplt = 0U;\r
1855       }\r
1856     }\r
1857   }\r
1858 \r
1859   /* Disable the UART DMA Rx request if enabled */\r
1860   if (HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAR))\r
1861   {\r
1862     CLEAR_BIT(huart->Instance->CR3, USART_CR3_DMAR);\r
1863 \r
1864     /* Abort the UART DMA Rx channel : use non blocking DMA Abort API (callback) */\r
1865     if (huart->hdmarx != NULL)\r
1866     {\r
1867       /* UART Rx DMA Abort callback has already been initialised :\r
1868          will lead to call HAL_UART_AbortCpltCallback() at end of DMA abort procedure */\r
1869 \r
1870       /* Abort DMA RX */\r
1871       if (HAL_DMA_Abort_IT(huart->hdmarx) != HAL_OK)\r
1872       {\r
1873         huart->hdmarx->XferAbortCallback = NULL;\r
1874         abortcplt = 1U;\r
1875       }\r
1876       else\r
1877       {\r
1878         abortcplt = 0U;\r
1879       }\r
1880     }\r
1881   }\r
1882 \r
1883   /* if no DMA abort complete callback execution is required => call user Abort Complete callback */\r
1884   if (abortcplt == 1U)\r
1885   {\r
1886     /* Reset Tx and Rx transfer counters */\r
1887     huart->TxXferCount = 0U;\r
1888     huart->RxXferCount = 0U;\r
1889 \r
1890     /* Clear ISR function pointers */\r
1891     huart->RxISR = NULL;\r
1892     huart->TxISR = NULL;\r
1893 \r
1894     /* Reset errorCode */\r
1895     huart->ErrorCode = HAL_UART_ERROR_NONE;\r
1896 \r
1897     /* Clear the Error flags in the ICR register */\r
1898     __HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_OREF | UART_CLEAR_NEF | UART_CLEAR_PEF | UART_CLEAR_FEF);\r
1899 \r
1900 \r
1901     /* Discard the received data */\r
1902     __HAL_UART_SEND_REQ(huart, UART_RXDATA_FLUSH_REQUEST);\r
1903 \r
1904     /* Restore huart->gState and huart->RxState to Ready */\r
1905     huart->gState  = HAL_UART_STATE_READY;\r
1906     huart->RxState = HAL_UART_STATE_READY;\r
1907 \r
1908     /* As no DMA to be aborted, call directly user Abort complete callback */\r
1909 #if (USE_HAL_UART_REGISTER_CALLBACKS == 1)\r
1910     /* Call registered Abort complete callback */\r
1911     huart->AbortCpltCallback(huart);\r
1912 #else\r
1913     /* Call legacy weak Abort complete callback */\r
1914     HAL_UART_AbortCpltCallback(huart);\r
1915 #endif /* USE_HAL_UART_REGISTER_CALLBACKS */\r
1916   }\r
1917 \r
1918   return HAL_OK;\r
1919 }\r
1920 \r
1921 /**\r
1922   * @brief  Abort ongoing Transmit transfer (Interrupt mode).\r
1923   * @param  huart UART handle.\r
1924   * @note   This procedure could be used for aborting any ongoing Tx transfer started in Interrupt or DMA mode.\r
1925   *         This procedure performs following operations :\r
1926   *           - Disable UART Interrupts (Tx)\r
1927   *           - Disable the DMA transfer in the peripheral register (if enabled)\r
1928   *           - Abort DMA transfer by calling HAL_DMA_Abort_IT (in case of transfer in DMA mode)\r
1929   *           - Set handle State to READY\r
1930   *           - At abort completion, call user abort complete callback\r
1931   * @note   This procedure is executed in Interrupt mode, meaning that abort procedure could be\r
1932   *         considered as completed only when user abort complete callback is executed (not when exiting function).\r
1933   * @retval HAL status\r
1934 */\r
1935 HAL_StatusTypeDef HAL_UART_AbortTransmit_IT(UART_HandleTypeDef *huart)\r
1936 {\r
1937   /* Disable interrupts */\r
1938   CLEAR_BIT(huart->Instance->CR1, (USART_CR1_TXEIE | USART_CR1_TCIE));\r
1939 \r
1940   /* Disable the UART DMA Tx request if enabled */\r
1941   if (HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAT))\r
1942   {\r
1943     CLEAR_BIT(huart->Instance->CR3, USART_CR3_DMAT);\r
1944 \r
1945     /* Abort the UART DMA Tx channel : use non blocking DMA Abort API (callback) */\r
1946     if (huart->hdmatx != NULL)\r
1947     {\r
1948       /* Set the UART DMA Abort callback :\r
1949          will lead to call HAL_UART_AbortCpltCallback() at end of DMA abort procedure */\r
1950       huart->hdmatx->XferAbortCallback = UART_DMATxOnlyAbortCallback;\r
1951 \r
1952       /* Abort DMA TX */\r
1953       if (HAL_DMA_Abort_IT(huart->hdmatx) != HAL_OK)\r
1954       {\r
1955         /* Call Directly huart->hdmatx->XferAbortCallback function in case of error */\r
1956         huart->hdmatx->XferAbortCallback(huart->hdmatx);\r
1957       }\r
1958     }\r
1959     else\r
1960     {\r
1961       /* Reset Tx transfer counter */\r
1962       huart->TxXferCount = 0U;\r
1963 \r
1964       /* Clear TxISR function pointers */\r
1965       huart->TxISR = NULL;\r
1966 \r
1967       /* Restore huart->gState to Ready */\r
1968       huart->gState = HAL_UART_STATE_READY;\r
1969 \r
1970       /* As no DMA to be aborted, call directly user Abort complete callback */\r
1971 #if (USE_HAL_UART_REGISTER_CALLBACKS == 1)\r
1972       /* Call registered Abort Transmit Complete Callback */\r
1973       huart->AbortTransmitCpltCallback(huart);\r
1974 #else\r
1975       /* Call legacy weak Abort Transmit Complete Callback */\r
1976       HAL_UART_AbortTransmitCpltCallback(huart);\r
1977 #endif /* USE_HAL_UART_REGISTER_CALLBACKS */\r
1978     }\r
1979   }\r
1980   else\r
1981   {\r
1982     /* Reset Tx transfer counter */\r
1983     huart->TxXferCount = 0U;\r
1984 \r
1985     /* Clear TxISR function pointers */\r
1986     huart->TxISR = NULL;\r
1987 \r
1988 \r
1989     /* Restore huart->gState to Ready */\r
1990     huart->gState = HAL_UART_STATE_READY;\r
1991 \r
1992     /* As no DMA to be aborted, call directly user Abort complete callback */\r
1993 #if (USE_HAL_UART_REGISTER_CALLBACKS == 1)\r
1994     /* Call registered Abort Transmit Complete Callback */\r
1995     huart->AbortTransmitCpltCallback(huart);\r
1996 #else\r
1997     /* Call legacy weak Abort Transmit Complete Callback */\r
1998     HAL_UART_AbortTransmitCpltCallback(huart);\r
1999 #endif /* USE_HAL_UART_REGISTER_CALLBACKS */\r
2000   }\r
2001 \r
2002   return HAL_OK;\r
2003 }\r
2004 \r
2005 /**\r
2006   * @brief  Abort ongoing Receive transfer (Interrupt mode).\r
2007   * @param  huart UART handle.\r
2008   * @note   This procedure could be used for aborting any ongoing Rx transfer started in Interrupt or DMA mode.\r
2009   *         This procedure performs following operations :\r
2010   *           - Disable UART Interrupts (Rx)\r
2011   *           - Disable the DMA transfer in the peripheral register (if enabled)\r
2012   *           - Abort DMA transfer by calling HAL_DMA_Abort_IT (in case of transfer in DMA mode)\r
2013   *           - Set handle State to READY\r
2014   *           - At abort completion, call user abort complete callback\r
2015   * @note   This procedure is executed in Interrupt mode, meaning that abort procedure could be\r
2016   *         considered as completed only when user abort complete callback is executed (not when exiting function).\r
2017   * @retval HAL status\r
2018 */\r
2019 HAL_StatusTypeDef HAL_UART_AbortReceive_IT(UART_HandleTypeDef *huart)\r
2020 {\r
2021   /* Disable RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts */\r
2022   CLEAR_BIT(huart->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE));\r
2023   CLEAR_BIT(huart->Instance->CR3, USART_CR3_EIE);\r
2024 \r
2025   /* Disable the UART DMA Rx request if enabled */\r
2026   if (HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAR))\r
2027   {\r
2028     CLEAR_BIT(huart->Instance->CR3, USART_CR3_DMAR);\r
2029 \r
2030     /* Abort the UART DMA Rx channel : use non blocking DMA Abort API (callback) */\r
2031     if (huart->hdmarx != NULL)\r
2032     {\r
2033       /* Set the UART DMA Abort callback :\r
2034          will lead to call HAL_UART_AbortCpltCallback() at end of DMA abort procedure */\r
2035       huart->hdmarx->XferAbortCallback = UART_DMARxOnlyAbortCallback;\r
2036 \r
2037       /* Abort DMA RX */\r
2038       if (HAL_DMA_Abort_IT(huart->hdmarx) != HAL_OK)\r
2039       {\r
2040         /* Call Directly huart->hdmarx->XferAbortCallback function in case of error */\r
2041         huart->hdmarx->XferAbortCallback(huart->hdmarx);\r
2042       }\r
2043     }\r
2044     else\r
2045     {\r
2046       /* Reset Rx transfer counter */\r
2047       huart->RxXferCount = 0U;\r
2048 \r
2049       /* Clear RxISR function pointer */\r
2050       huart->pRxBuffPtr = NULL;\r
2051 \r
2052       /* Clear the Error flags in the ICR register */\r
2053       __HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_OREF | UART_CLEAR_NEF | UART_CLEAR_PEF | UART_CLEAR_FEF);\r
2054 \r
2055       /* Discard the received data */\r
2056       __HAL_UART_SEND_REQ(huart, UART_RXDATA_FLUSH_REQUEST);\r
2057 \r
2058       /* Restore huart->RxState to Ready */\r
2059       huart->RxState = HAL_UART_STATE_READY;\r
2060 \r
2061       /* As no DMA to be aborted, call directly user Abort complete callback */\r
2062 #if (USE_HAL_UART_REGISTER_CALLBACKS == 1)\r
2063       /* Call registered Abort Receive Complete Callback */\r
2064       huart->AbortReceiveCpltCallback(huart);\r
2065 #else\r
2066       /* Call legacy weak Abort Receive Complete Callback */\r
2067       HAL_UART_AbortReceiveCpltCallback(huart);\r
2068 #endif /* USE_HAL_UART_REGISTER_CALLBACKS */\r
2069     }\r
2070   }\r
2071   else\r
2072   {\r
2073     /* Reset Rx transfer counter */\r
2074     huart->RxXferCount = 0U;\r
2075 \r
2076     /* Clear RxISR function pointer */\r
2077     huart->pRxBuffPtr = NULL;\r
2078 \r
2079     /* Clear the Error flags in the ICR register */\r
2080     __HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_OREF | UART_CLEAR_NEF | UART_CLEAR_PEF | UART_CLEAR_FEF);\r
2081 \r
2082     /* Restore huart->RxState to Ready */\r
2083     huart->RxState = HAL_UART_STATE_READY;\r
2084 \r
2085     /* As no DMA to be aborted, call directly user Abort complete callback */\r
2086 #if (USE_HAL_UART_REGISTER_CALLBACKS == 1)\r
2087     /* Call registered Abort Receive Complete Callback */\r
2088     huart->AbortReceiveCpltCallback(huart);\r
2089 #else\r
2090     /* Call legacy weak Abort Receive Complete Callback */\r
2091     HAL_UART_AbortReceiveCpltCallback(huart);\r
2092 #endif /* USE_HAL_UART_REGISTER_CALLBACKS */\r
2093   }\r
2094 \r
2095   return HAL_OK;\r
2096 }\r
2097 \r
2098 /**\r
2099   * @brief Handle UART interrupt request.\r
2100   * @param huart UART handle.\r
2101   * @retval None\r
2102   */\r
2103 void HAL_UART_IRQHandler(UART_HandleTypeDef *huart)\r
2104 {\r
2105   uint32_t isrflags   = READ_REG(huart->Instance->ISR);\r
2106   uint32_t cr1its     = READ_REG(huart->Instance->CR1);\r
2107   uint32_t cr3its     = READ_REG(huart->Instance->CR3);\r
2108 \r
2109   uint32_t errorflags;\r
2110   uint32_t errorcode;\r
2111 \r
2112   /* If no error occurs */\r
2113   errorflags = (isrflags & (uint32_t)(USART_ISR_PE | USART_ISR_FE | USART_ISR_ORE | USART_ISR_NE));\r
2114   if (errorflags == 0U)\r
2115   {\r
2116     /* UART in mode Receiver ---------------------------------------------------*/\r
2117     if (((isrflags & USART_ISR_RXNE) != 0U)\r
2118         && ((cr1its & USART_CR1_RXNEIE) != 0U))\r
2119     {\r
2120       if (huart->RxISR != NULL)\r
2121       {\r
2122         huart->RxISR(huart);\r
2123       }\r
2124       return;\r
2125     }\r
2126   }\r
2127 \r
2128   /* If some errors occur */\r
2129   if ((errorflags != 0U)\r
2130       && (((cr3its & USART_CR3_EIE) != 0U)\r
2131           || ((cr1its & (USART_CR1_RXNEIE | USART_CR1_PEIE)) != 0U)))\r
2132   {\r
2133     /* UART parity error interrupt occurred -------------------------------------*/\r
2134     if (((isrflags & USART_ISR_PE) != 0U) && ((cr1its & USART_CR1_PEIE) != 0U))\r
2135     {\r
2136       __HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_PEF);\r
2137 \r
2138       huart->ErrorCode |= HAL_UART_ERROR_PE;\r
2139     }\r
2140 \r
2141     /* UART frame error interrupt occurred --------------------------------------*/\r
2142     if (((isrflags & USART_ISR_FE) != 0U) && ((cr3its & USART_CR3_EIE) != 0U))\r
2143     {\r
2144       __HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_FEF);\r
2145 \r
2146       huart->ErrorCode |= HAL_UART_ERROR_FE;\r
2147     }\r
2148 \r
2149     /* UART noise error interrupt occurred --------------------------------------*/\r
2150     if (((isrflags & USART_ISR_NE) != 0U) && ((cr3its & USART_CR3_EIE) != 0U))\r
2151     {\r
2152       __HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_NEF);\r
2153 \r
2154       huart->ErrorCode |= HAL_UART_ERROR_NE;\r
2155     }\r
2156 \r
2157     /* UART Over-Run interrupt occurred -----------------------------------------*/\r
2158     if (((isrflags & USART_ISR_ORE) != 0U)\r
2159         && (((cr1its & USART_CR1_RXNEIE) != 0U) ||\r
2160             ((cr3its & USART_CR3_EIE) != 0U)))\r
2161     {\r
2162       __HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_OREF);\r
2163 \r
2164       huart->ErrorCode |= HAL_UART_ERROR_ORE;\r
2165     }\r
2166 \r
2167     /* Call UART Error Call back function if need be --------------------------*/\r
2168     if (huart->ErrorCode != HAL_UART_ERROR_NONE)\r
2169     {\r
2170       /* UART in mode Receiver ---------------------------------------------------*/\r
2171       if (((isrflags & USART_ISR_RXNE) != 0U)\r
2172           && ((cr1its & USART_CR1_RXNEIE) != 0U))\r
2173       {\r
2174         if (huart->RxISR != NULL)\r
2175         {\r
2176           huart->RxISR(huart);\r
2177         }\r
2178       }\r
2179 \r
2180       /* If Overrun error occurs, or if any error occurs in DMA mode reception,\r
2181          consider error as blocking */\r
2182       errorcode = huart->ErrorCode;\r
2183       if ((HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAR)) ||\r
2184           ((errorcode & HAL_UART_ERROR_ORE) != 0U))\r
2185       {\r
2186         /* Blocking error : transfer is aborted\r
2187            Set the UART state ready to be able to start again the process,\r
2188            Disable Rx Interrupts, and disable Rx DMA request, if ongoing */\r
2189         UART_EndRxTransfer(huart);\r
2190 \r
2191         /* Disable the UART DMA Rx request if enabled */\r
2192         if (HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAR))\r
2193         {\r
2194           CLEAR_BIT(huart->Instance->CR3, USART_CR3_DMAR);\r
2195 \r
2196           /* Abort the UART DMA Rx channel */\r
2197           if (huart->hdmarx != NULL)\r
2198           {\r
2199             /* Set the UART DMA Abort callback :\r
2200                will lead to call HAL_UART_ErrorCallback() at end of DMA abort procedure */\r
2201             huart->hdmarx->XferAbortCallback = UART_DMAAbortOnError;\r
2202 \r
2203             /* Abort DMA RX */\r
2204             if (HAL_DMA_Abort_IT(huart->hdmarx) != HAL_OK)\r
2205             {\r
2206               /* Call Directly huart->hdmarx->XferAbortCallback function in case of error */\r
2207               huart->hdmarx->XferAbortCallback(huart->hdmarx);\r
2208             }\r
2209           }\r
2210           else\r
2211           {\r
2212             /* Call user error callback */\r
2213 #if (USE_HAL_UART_REGISTER_CALLBACKS == 1)\r
2214             /*Call registered error callback*/\r
2215             huart->ErrorCallback(huart);\r
2216 #else\r
2217             /*Call legacy weak error callback*/\r
2218             HAL_UART_ErrorCallback(huart);\r
2219 #endif /* USE_HAL_UART_REGISTER_CALLBACKS */\r
2220 \r
2221           }\r
2222         }\r
2223         else\r
2224         {\r
2225           /* Call user error callback */\r
2226 #if (USE_HAL_UART_REGISTER_CALLBACKS == 1)\r
2227           /*Call registered error callback*/\r
2228           huart->ErrorCallback(huart);\r
2229 #else\r
2230           /*Call legacy weak error callback*/\r
2231           HAL_UART_ErrorCallback(huart);\r
2232 #endif /* USE_HAL_UART_REGISTER_CALLBACKS */\r
2233         }\r
2234       }\r
2235       else\r
2236       {\r
2237         /* Non Blocking error : transfer could go on.\r
2238            Error is notified to user through user error callback */\r
2239 #if (USE_HAL_UART_REGISTER_CALLBACKS == 1)\r
2240         /*Call registered error callback*/\r
2241         huart->ErrorCallback(huart);\r
2242 #else\r
2243         /*Call legacy weak error callback*/\r
2244         HAL_UART_ErrorCallback(huart);\r
2245 #endif /* USE_HAL_UART_REGISTER_CALLBACKS */\r
2246         huart->ErrorCode = HAL_UART_ERROR_NONE;\r
2247       }\r
2248     }\r
2249     return;\r
2250 \r
2251   } /* End if some error occurs */\r
2252 \r
2253   /* UART in mode Transmitter ------------------------------------------------*/\r
2254   if (((isrflags & USART_ISR_TXE) != 0U)\r
2255       && ((cr1its & USART_CR1_TXEIE) != 0U))\r
2256   {\r
2257     if (huart->TxISR != NULL)\r
2258     {\r
2259       huart->TxISR(huart);\r
2260     }\r
2261     return;\r
2262   }\r
2263 \r
2264   /* UART in mode Transmitter (transmission end) -----------------------------*/\r
2265   if (((isrflags & USART_ISR_TC) != 0U) && ((cr1its & USART_CR1_TCIE) != 0U))\r
2266   {\r
2267     UART_EndTransmit_IT(huart);\r
2268     return;\r
2269   }\r
2270 \r
2271 }\r
2272 \r
2273 /**\r
2274   * @brief Tx Transfer completed callback.\r
2275   * @param huart UART handle.\r
2276   * @retval None\r
2277   */\r
2278 __weak void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)\r
2279 {\r
2280   /* Prevent unused argument(s) compilation warning */\r
2281   UNUSED(huart);\r
2282 \r
2283   /* NOTE : This function should not be modified, when the callback is needed,\r
2284             the HAL_UART_TxCpltCallback can be implemented in the user file.\r
2285    */\r
2286 }\r
2287 \r
2288 /**\r
2289   * @brief  Tx Half Transfer completed callback.\r
2290   * @param  huart UART handle.\r
2291   * @retval None\r
2292   */\r
2293 __weak void HAL_UART_TxHalfCpltCallback(UART_HandleTypeDef *huart)\r
2294 {\r
2295   /* Prevent unused argument(s) compilation warning */\r
2296   UNUSED(huart);\r
2297 \r
2298   /* NOTE: This function should not be modified, when the callback is needed,\r
2299            the HAL_UART_TxHalfCpltCallback can be implemented in the user file.\r
2300    */\r
2301 }\r
2302 \r
2303 /**\r
2304   * @brief  Rx Transfer completed callback.\r
2305   * @param  huart UART handle.\r
2306   * @retval None\r
2307   */\r
2308 __weak void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)\r
2309 {\r
2310   /* Prevent unused argument(s) compilation warning */\r
2311   UNUSED(huart);\r
2312 \r
2313   /* NOTE : This function should not be modified, when the callback is needed,\r
2314             the HAL_UART_RxCpltCallback can be implemented in the user file.\r
2315    */\r
2316 }\r
2317 \r
2318 /**\r
2319   * @brief  Rx Half Transfer completed callback.\r
2320   * @param  huart UART handle.\r
2321   * @retval None\r
2322   */\r
2323 __weak void HAL_UART_RxHalfCpltCallback(UART_HandleTypeDef *huart)\r
2324 {\r
2325   /* Prevent unused argument(s) compilation warning */\r
2326   UNUSED(huart);\r
2327 \r
2328   /* NOTE: This function should not be modified, when the callback is needed,\r
2329            the HAL_UART_RxHalfCpltCallback can be implemented in the user file.\r
2330    */\r
2331 }\r
2332 \r
2333 /**\r
2334   * @brief  UART error callback.\r
2335   * @param  huart UART handle.\r
2336   * @retval None\r
2337   */\r
2338 __weak void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart)\r
2339 {\r
2340   /* Prevent unused argument(s) compilation warning */\r
2341   UNUSED(huart);\r
2342 \r
2343   /* NOTE : This function should not be modified, when the callback is needed,\r
2344             the HAL_UART_ErrorCallback can be implemented in the user file.\r
2345    */\r
2346 }\r
2347 \r
2348 /**\r
2349   * @brief  UART Abort Complete callback.\r
2350   * @param  huart UART handle.\r
2351   * @retval None\r
2352   */\r
2353 __weak void HAL_UART_AbortCpltCallback(UART_HandleTypeDef *huart)\r
2354 {\r
2355   /* Prevent unused argument(s) compilation warning */\r
2356   UNUSED(huart);\r
2357 \r
2358   /* NOTE : This function should not be modified, when the callback is needed,\r
2359             the HAL_UART_AbortCpltCallback can be implemented in the user file.\r
2360    */\r
2361 }\r
2362 \r
2363 /**\r
2364   * @brief  UART Abort Complete callback.\r
2365   * @param  huart UART handle.\r
2366   * @retval None\r
2367   */\r
2368 __weak void HAL_UART_AbortTransmitCpltCallback(UART_HandleTypeDef *huart)\r
2369 {\r
2370   /* Prevent unused argument(s) compilation warning */\r
2371   UNUSED(huart);\r
2372 \r
2373   /* NOTE : This function should not be modified, when the callback is needed,\r
2374             the HAL_UART_AbortTransmitCpltCallback can be implemented in the user file.\r
2375    */\r
2376 }\r
2377 \r
2378 /**\r
2379   * @brief  UART Abort Receive Complete callback.\r
2380   * @param  huart UART handle.\r
2381   * @retval None\r
2382   */\r
2383 __weak void HAL_UART_AbortReceiveCpltCallback(UART_HandleTypeDef *huart)\r
2384 {\r
2385   /* Prevent unused argument(s) compilation warning */\r
2386   UNUSED(huart);\r
2387 \r
2388   /* NOTE : This function should not be modified, when the callback is needed,\r
2389             the HAL_UART_AbortReceiveCpltCallback can be implemented in the user file.\r
2390    */\r
2391 }\r
2392 \r
2393 /**\r
2394   * @}\r
2395   */\r
2396 \r
2397 /** @defgroup UART_Exported_Functions_Group3 Peripheral Control functions\r
2398   *  @brief   UART control functions\r
2399   *\r
2400 @verbatim\r
2401  ===============================================================================\r
2402                       ##### Peripheral Control functions #####\r
2403  ===============================================================================\r
2404     [..]\r
2405     This subsection provides a set of functions allowing to control the UART.\r
2406      (+) HAL_MultiProcessor_EnableMuteMode() API enables mute mode\r
2407      (+) HAL_MultiProcessor_DisableMuteMode() API disables mute mode\r
2408      (+) HAL_MultiProcessor_EnterMuteMode() API enters mute mode\r
2409      (+) UART_SetConfig() API configures the UART peripheral\r
2410      (+) UART_AdvFeatureConfig() API optionally configures the UART advanced features\r
2411      (+) UART_CheckIdleState() API ensures that TEACK and/or REACK are set after initialization\r
2412      (+) HAL_HalfDuplex_EnableTransmitter() API disables receiver and enables transmitter\r
2413      (+) HAL_HalfDuplex_EnableReceiver() API disables transmitter and enables receiver\r
2414      (+) HAL_LIN_SendBreak() API transmits the break characters\r
2415 @endverbatim\r
2416   * @{\r
2417   */\r
2418 \r
2419 /**\r
2420   * @brief  Enable UART in mute mode (does not mean UART enters mute mode;\r
2421   *         to enter mute mode, HAL_MultiProcessor_EnterMuteMode() API must be called).\r
2422   * @param  huart UART handle.\r
2423   * @retval HAL status\r
2424   */\r
2425 HAL_StatusTypeDef HAL_MultiProcessor_EnableMuteMode(UART_HandleTypeDef *huart)\r
2426 {\r
2427   /* Process Locked */\r
2428   __HAL_LOCK(huart);\r
2429 \r
2430   huart->gState = HAL_UART_STATE_BUSY;\r
2431 \r
2432   /* Enable USART mute mode by setting the MME bit in the CR1 register */\r
2433   SET_BIT(huart->Instance->CR1, USART_CR1_MME);\r
2434 \r
2435   huart->gState = HAL_UART_STATE_READY;\r
2436 \r
2437   return (UART_CheckIdleState(huart));\r
2438 }\r
2439 \r
2440 /**\r
2441   * @brief  Disable UART mute mode (does not mean the UART actually exits mute mode\r
2442   *         as it may not have been in mute mode at this very moment).\r
2443   * @param  huart UART handle.\r
2444   * @retval HAL status\r
2445   */\r
2446 HAL_StatusTypeDef HAL_MultiProcessor_DisableMuteMode(UART_HandleTypeDef *huart)\r
2447 {\r
2448   /* Process Locked */\r
2449   __HAL_LOCK(huart);\r
2450 \r
2451   huart->gState = HAL_UART_STATE_BUSY;\r
2452 \r
2453   /* Disable USART mute mode by clearing the MME bit in the CR1 register */\r
2454   CLEAR_BIT(huart->Instance->CR1, USART_CR1_MME);\r
2455 \r
2456   huart->gState = HAL_UART_STATE_READY;\r
2457 \r
2458   return (UART_CheckIdleState(huart));\r
2459 }\r
2460 \r
2461 /**\r
2462   * @brief Enter UART mute mode (means UART actually enters mute mode).\r
2463   * @note  To exit from mute mode, HAL_MultiProcessor_DisableMuteMode() API must be called.\r
2464   * @param huart UART handle.\r
2465   * @retval None\r
2466   */\r
2467 void HAL_MultiProcessor_EnterMuteMode(UART_HandleTypeDef *huart)\r
2468 {\r
2469   __HAL_UART_SEND_REQ(huart, UART_MUTE_MODE_REQUEST);\r
2470 }\r
2471 \r
2472 /**\r
2473   * @brief  Enable the UART transmitter and disable the UART receiver.\r
2474   * @param  huart UART handle.\r
2475   * @retval HAL status\r
2476   */\r
2477 HAL_StatusTypeDef HAL_HalfDuplex_EnableTransmitter(UART_HandleTypeDef *huart)\r
2478 {\r
2479   /* Process Locked */\r
2480   __HAL_LOCK(huart);\r
2481   huart->gState = HAL_UART_STATE_BUSY;\r
2482 \r
2483   /* Clear TE and RE bits */\r
2484   CLEAR_BIT(huart->Instance->CR1, (USART_CR1_TE | USART_CR1_RE));\r
2485 \r
2486   /* Enable the USART's transmit interface by setting the TE bit in the USART CR1 register */\r
2487   SET_BIT(huart->Instance->CR1, USART_CR1_TE);\r
2488 \r
2489   huart->gState = HAL_UART_STATE_READY;\r
2490 \r
2491   /* Process Unlocked */\r
2492   __HAL_UNLOCK(huart);\r
2493 \r
2494   return HAL_OK;\r
2495 }\r
2496 \r
2497 /**\r
2498   * @brief  Enable the UART receiver and disable the UART transmitter.\r
2499   * @param  huart UART handle.\r
2500   * @retval HAL status.\r
2501   */\r
2502 HAL_StatusTypeDef HAL_HalfDuplex_EnableReceiver(UART_HandleTypeDef *huart)\r
2503 {\r
2504   /* Process Locked */\r
2505   __HAL_LOCK(huart);\r
2506   huart->gState = HAL_UART_STATE_BUSY;\r
2507 \r
2508   /* Clear TE and RE bits */\r
2509   CLEAR_BIT(huart->Instance->CR1, (USART_CR1_TE | USART_CR1_RE));\r
2510 \r
2511   /* Enable the USART's receive interface by setting the RE bit in the USART CR1 register */\r
2512   SET_BIT(huart->Instance->CR1, USART_CR1_RE);\r
2513 \r
2514   huart->gState = HAL_UART_STATE_READY;\r
2515 \r
2516   /* Process Unlocked */\r
2517   __HAL_UNLOCK(huart);\r
2518 \r
2519   return HAL_OK;\r
2520 }\r
2521 \r
2522 \r
2523 /**\r
2524   * @brief  Transmit break characters.\r
2525   * @param  huart UART handle.\r
2526   * @retval HAL status\r
2527   */\r
2528 HAL_StatusTypeDef HAL_LIN_SendBreak(UART_HandleTypeDef *huart)\r
2529 {\r
2530   /* Check the parameters */\r
2531   assert_param(IS_UART_LIN_INSTANCE(huart->Instance));\r
2532 \r
2533   /* Process Locked */\r
2534   __HAL_LOCK(huart);\r
2535 \r
2536   huart->gState = HAL_UART_STATE_BUSY;\r
2537 \r
2538   /* Send break characters */\r
2539   __HAL_UART_SEND_REQ(huart, UART_SENDBREAK_REQUEST);\r
2540 \r
2541   huart->gState = HAL_UART_STATE_READY;\r
2542 \r
2543   /* Process Unlocked */\r
2544   __HAL_UNLOCK(huart);\r
2545 \r
2546   return HAL_OK;\r
2547 }\r
2548 \r
2549 /**\r
2550   * @}\r
2551   */\r
2552 \r
2553 /** @defgroup UART_Exported_Functions_Group4 Peripheral State and Error functions\r
2554  *  @brief   UART Peripheral State functions\r
2555  *\r
2556 @verbatim\r
2557   ==============================================================================\r
2558             ##### Peripheral State and Error functions #####\r
2559   ==============================================================================\r
2560     [..]\r
2561     This subsection provides functions allowing to :\r
2562       (+) Return the UART handle state.\r
2563       (+) Return the UART handle error code\r
2564 \r
2565 @endverbatim\r
2566   * @{\r
2567   */\r
2568 \r
2569 /**\r
2570   * @brief Return the UART handle state.\r
2571   * @param  huart Pointer to a UART_HandleTypeDef structure that contains\r
2572   *               the configuration information for the specified UART.\r
2573   * @retval HAL state\r
2574   */\r
2575 HAL_UART_StateTypeDef HAL_UART_GetState(UART_HandleTypeDef *huart)\r
2576 {\r
2577   uint32_t temp1, temp2;\r
2578   temp1 = huart->gState;\r
2579   temp2 = huart->RxState;\r
2580 \r
2581   return (HAL_UART_StateTypeDef)(temp1 | temp2);\r
2582 }\r
2583 \r
2584 /**\r
2585   * @brief  Return the UART handle error code.\r
2586   * @param  huart Pointer to a UART_HandleTypeDef structure that contains\r
2587   *               the configuration information for the specified UART.\r
2588   * @retval UART Error Code\r
2589 */\r
2590 uint32_t HAL_UART_GetError(UART_HandleTypeDef *huart)\r
2591 {\r
2592   return huart->ErrorCode;\r
2593 }\r
2594 /**\r
2595   * @}\r
2596   */\r
2597 \r
2598 /**\r
2599   * @}\r
2600   */\r
2601 \r
2602 /** @defgroup UART_Private_Functions UART Private Functions\r
2603   * @{\r
2604   */\r
2605 \r
2606 /**\r
2607   * @brief  Initialize the callbacks to their default values.\r
2608   * @param  huart UART handle.\r
2609   * @retval none\r
2610   */\r
2611 #if (USE_HAL_UART_REGISTER_CALLBACKS == 1)\r
2612 void UART_InitCallbacksToDefault(UART_HandleTypeDef *huart)\r
2613 {\r
2614   /* Init the UART Callback settings */\r
2615   huart->TxHalfCpltCallback        = HAL_UART_TxHalfCpltCallback;        /* Legacy weak TxHalfCpltCallback        */\r
2616   huart->TxCpltCallback            = HAL_UART_TxCpltCallback;            /* Legacy weak TxCpltCallback            */\r
2617   huart->RxHalfCpltCallback        = HAL_UART_RxHalfCpltCallback;        /* Legacy weak RxHalfCpltCallback        */\r
2618   huart->RxCpltCallback            = HAL_UART_RxCpltCallback;            /* Legacy weak RxCpltCallback            */\r
2619   huart->ErrorCallback             = HAL_UART_ErrorCallback;             /* Legacy weak ErrorCallback             */\r
2620   huart->AbortCpltCallback         = HAL_UART_AbortCpltCallback;         /* Legacy weak AbortCpltCallback         */\r
2621   huart->AbortTransmitCpltCallback = HAL_UART_AbortTransmitCpltCallback; /* Legacy weak AbortTransmitCpltCallback */\r
2622   huart->AbortReceiveCpltCallback  = HAL_UART_AbortReceiveCpltCallback;  /* Legacy weak AbortReceiveCpltCallback  */\r
2623 \r
2624 }\r
2625 #endif /* USE_HAL_UART_REGISTER_CALLBACKS */\r
2626 \r
2627 /**\r
2628   * @brief Configure the UART peripheral.\r
2629   * @param huart UART handle.\r
2630   * @retval HAL status\r
2631   */\r
2632 HAL_StatusTypeDef UART_SetConfig(UART_HandleTypeDef *huart)\r
2633 {\r
2634   uint32_t tmpreg;\r
2635   uint16_t brrtemp;\r
2636   UART_ClockSourceTypeDef clocksource;\r
2637   uint32_t usartdiv                   = 0x00000000U;\r
2638   HAL_StatusTypeDef ret               = HAL_OK;\r
2639 \r
2640   /* Check the parameters */\r
2641   assert_param(IS_UART_BAUDRATE(huart->Init.BaudRate));\r
2642   assert_param(IS_UART_WORD_LENGTH(huart->Init.WordLength));\r
2643   assert_param(IS_UART_STOPBITS(huart->Init.StopBits));\r
2644   assert_param(IS_UART_ONE_BIT_SAMPLE(huart->Init.OneBitSampling));\r
2645 \r
2646   assert_param(IS_UART_PARITY(huart->Init.Parity));\r
2647   assert_param(IS_UART_MODE(huart->Init.Mode));\r
2648   assert_param(IS_UART_HARDWARE_FLOW_CONTROL(huart->Init.HwFlowCtl));\r
2649   assert_param(IS_UART_OVERSAMPLING(huart->Init.OverSampling));\r
2650 \r
2651   /*-------------------------- USART CR1 Configuration -----------------------*/\r
2652   /* Clear M, PCE, PS, TE, RE and OVER8 bits and configure\r
2653   *  the UART Word Length, Parity, Mode and oversampling:\r
2654   *  set the M bits according to huart->Init.WordLength value\r
2655   *  set PCE and PS bits according to huart->Init.Parity value\r
2656   *  set TE and RE bits according to huart->Init.Mode value\r
2657   *  set OVER8 bit according to huart->Init.OverSampling value */\r
2658   tmpreg = (uint32_t)huart->Init.WordLength | huart->Init.Parity | huart->Init.Mode | huart->Init.OverSampling ;\r
2659   MODIFY_REG(huart->Instance->CR1, USART_CR1_FIELDS, tmpreg);\r
2660 \r
2661   /*-------------------------- USART CR2 Configuration -----------------------*/\r
2662   /* Configure the UART Stop Bits: Set STOP[13:12] bits according\r
2663   * to huart->Init.StopBits value */\r
2664   MODIFY_REG(huart->Instance->CR2, USART_CR2_STOP, huart->Init.StopBits);\r
2665 \r
2666   /*-------------------------- USART CR3 Configuration -----------------------*/\r
2667   /* Configure\r
2668   * - UART HardWare Flow Control: set CTSE and RTSE bits according\r
2669   *   to huart->Init.HwFlowCtl value\r
2670   * - one-bit sampling method versus three samples' majority rule according\r
2671   *   to huart->Init.OneBitSampling (not applicable to LPUART) */\r
2672   tmpreg = (uint32_t)huart->Init.HwFlowCtl;\r
2673 \r
2674   tmpreg |= huart->Init.OneBitSampling;\r
2675   MODIFY_REG(huart->Instance->CR3, USART_CR3_FIELDS, tmpreg);\r
2676 \r
2677 \r
2678   /*-------------------------- USART BRR Configuration -----------------------*/\r
2679   UART_GETCLOCKSOURCE(huart, clocksource);\r
2680 \r
2681   if (huart->Init.OverSampling == UART_OVERSAMPLING_8)\r
2682   {\r
2683     switch (clocksource)\r
2684     {\r
2685       case UART_CLOCKSOURCE_PCLK1:\r
2686         usartdiv = (uint16_t)(UART_DIV_SAMPLING8(HAL_RCC_GetPCLK1Freq(), huart->Init.BaudRate));\r
2687         break;\r
2688       case UART_CLOCKSOURCE_PCLK2:\r
2689         usartdiv = (uint16_t)(UART_DIV_SAMPLING8(HAL_RCC_GetPCLK2Freq(), huart->Init.BaudRate));\r
2690         break;\r
2691       case UART_CLOCKSOURCE_HSI:\r
2692         usartdiv = (uint16_t)(UART_DIV_SAMPLING8(HSI_VALUE, huart->Init.BaudRate));\r
2693         break;\r
2694       case UART_CLOCKSOURCE_SYSCLK:\r
2695         usartdiv = (uint16_t)(UART_DIV_SAMPLING8(HAL_RCC_GetSysClockFreq(), huart->Init.BaudRate));\r
2696         break;\r
2697       case UART_CLOCKSOURCE_LSE:\r
2698         usartdiv = (uint16_t)(UART_DIV_SAMPLING8(LSE_VALUE, huart->Init.BaudRate));\r
2699         break;\r
2700       case UART_CLOCKSOURCE_UNDEFINED:\r
2701       default:\r
2702         ret = HAL_ERROR;\r
2703         break;\r
2704     }\r
2705 \r
2706     /* USARTDIV must be greater than or equal to 0d16 */\r
2707     if ((usartdiv >= UART_BRR_MIN) && (usartdiv <= UART_BRR_MAX))\r
2708     {\r
2709       brrtemp = (uint16_t)(usartdiv & 0xFFF0U);\r
2710       brrtemp |= (uint16_t)((usartdiv & (uint16_t)0x000FU) >> 1U);\r
2711       huart->Instance->BRR = brrtemp;\r
2712     }\r
2713     else\r
2714     {\r
2715       ret = HAL_ERROR;\r
2716     }\r
2717   }\r
2718   else\r
2719   {\r
2720     switch (clocksource)\r
2721     {\r
2722       case UART_CLOCKSOURCE_PCLK1:\r
2723         usartdiv = (uint16_t)(UART_DIV_SAMPLING16(HAL_RCC_GetPCLK1Freq(), huart->Init.BaudRate));\r
2724         break;\r
2725       case UART_CLOCKSOURCE_PCLK2:\r
2726         usartdiv = (uint16_t)(UART_DIV_SAMPLING16(HAL_RCC_GetPCLK2Freq(), huart->Init.BaudRate));\r
2727         break;\r
2728       case UART_CLOCKSOURCE_HSI:\r
2729         usartdiv = (uint16_t)(UART_DIV_SAMPLING16(HSI_VALUE, huart->Init.BaudRate));\r
2730         break;\r
2731       case UART_CLOCKSOURCE_SYSCLK:\r
2732         usartdiv = (uint16_t)(UART_DIV_SAMPLING16(HAL_RCC_GetSysClockFreq(), huart->Init.BaudRate));\r
2733         break;\r
2734       case UART_CLOCKSOURCE_LSE:\r
2735         usartdiv = (uint16_t)(UART_DIV_SAMPLING16(LSE_VALUE, huart->Init.BaudRate));\r
2736         break;\r
2737       case UART_CLOCKSOURCE_UNDEFINED:\r
2738       default:\r
2739         ret = HAL_ERROR;\r
2740         break;\r
2741     }\r
2742 \r
2743     /* USARTDIV must be greater than or equal to 0d16 */\r
2744     if ((usartdiv >= UART_BRR_MIN) && (usartdiv <= UART_BRR_MAX))\r
2745     {\r
2746       huart->Instance->BRR = usartdiv;\r
2747     }\r
2748     else\r
2749     {\r
2750       ret = HAL_ERROR;\r
2751     }\r
2752   }\r
2753 \r
2754 \r
2755   /* Clear ISR function pointers */\r
2756   huart->RxISR = NULL;\r
2757   huart->TxISR = NULL;\r
2758 \r
2759   return ret;\r
2760 }\r
2761 \r
2762 /**\r
2763   * @brief Configure the UART peripheral advanced features.\r
2764   * @param huart UART handle.\r
2765   * @retval None\r
2766   */\r
2767 void UART_AdvFeatureConfig(UART_HandleTypeDef *huart)\r
2768 {\r
2769   /* Check whether the set of advanced features to configure is properly set */\r
2770   assert_param(IS_UART_ADVFEATURE_INIT(huart->AdvancedInit.AdvFeatureInit));\r
2771 \r
2772   /* if required, configure TX pin active level inversion */\r
2773   if (HAL_IS_BIT_SET(huart->AdvancedInit.AdvFeatureInit, UART_ADVFEATURE_TXINVERT_INIT))\r
2774   {\r
2775     assert_param(IS_UART_ADVFEATURE_TXINV(huart->AdvancedInit.TxPinLevelInvert));\r
2776     MODIFY_REG(huart->Instance->CR2, USART_CR2_TXINV, huart->AdvancedInit.TxPinLevelInvert);\r
2777   }\r
2778 \r
2779   /* if required, configure RX pin active level inversion */\r
2780   if (HAL_IS_BIT_SET(huart->AdvancedInit.AdvFeatureInit, UART_ADVFEATURE_RXINVERT_INIT))\r
2781   {\r
2782     assert_param(IS_UART_ADVFEATURE_RXINV(huart->AdvancedInit.RxPinLevelInvert));\r
2783     MODIFY_REG(huart->Instance->CR2, USART_CR2_RXINV, huart->AdvancedInit.RxPinLevelInvert);\r
2784   }\r
2785 \r
2786   /* if required, configure data inversion */\r
2787   if (HAL_IS_BIT_SET(huart->AdvancedInit.AdvFeatureInit, UART_ADVFEATURE_DATAINVERT_INIT))\r
2788   {\r
2789     assert_param(IS_UART_ADVFEATURE_DATAINV(huart->AdvancedInit.DataInvert));\r
2790     MODIFY_REG(huart->Instance->CR2, USART_CR2_DATAINV, huart->AdvancedInit.DataInvert);\r
2791   }\r
2792 \r
2793   /* if required, configure RX/TX pins swap */\r
2794   if (HAL_IS_BIT_SET(huart->AdvancedInit.AdvFeatureInit, UART_ADVFEATURE_SWAP_INIT))\r
2795   {\r
2796     assert_param(IS_UART_ADVFEATURE_SWAP(huart->AdvancedInit.Swap));\r
2797     MODIFY_REG(huart->Instance->CR2, USART_CR2_SWAP, huart->AdvancedInit.Swap);\r
2798   }\r
2799 \r
2800   /* if required, configure RX overrun detection disabling */\r
2801   if (HAL_IS_BIT_SET(huart->AdvancedInit.AdvFeatureInit, UART_ADVFEATURE_RXOVERRUNDISABLE_INIT))\r
2802   {\r
2803     assert_param(IS_UART_OVERRUN(huart->AdvancedInit.OverrunDisable));\r
2804     MODIFY_REG(huart->Instance->CR3, USART_CR3_OVRDIS, huart->AdvancedInit.OverrunDisable);\r
2805   }\r
2806 \r
2807   /* if required, configure DMA disabling on reception error */\r
2808   if (HAL_IS_BIT_SET(huart->AdvancedInit.AdvFeatureInit, UART_ADVFEATURE_DMADISABLEONERROR_INIT))\r
2809   {\r
2810     assert_param(IS_UART_ADVFEATURE_DMAONRXERROR(huart->AdvancedInit.DMADisableonRxError));\r
2811     MODIFY_REG(huart->Instance->CR3, USART_CR3_DDRE, huart->AdvancedInit.DMADisableonRxError);\r
2812   }\r
2813 \r
2814   /* if required, configure auto Baud rate detection scheme */\r
2815   if (HAL_IS_BIT_SET(huart->AdvancedInit.AdvFeatureInit, UART_ADVFEATURE_AUTOBAUDRATE_INIT))\r
2816   {\r
2817     assert_param(IS_USART_AUTOBAUDRATE_DETECTION_INSTANCE(huart->Instance));\r
2818     assert_param(IS_UART_ADVFEATURE_AUTOBAUDRATE(huart->AdvancedInit.AutoBaudRateEnable));\r
2819     MODIFY_REG(huart->Instance->CR2, USART_CR2_ABREN, huart->AdvancedInit.AutoBaudRateEnable);\r
2820     /* set auto Baudrate detection parameters if detection is enabled */\r
2821     if (huart->AdvancedInit.AutoBaudRateEnable == UART_ADVFEATURE_AUTOBAUDRATE_ENABLE)\r
2822     {\r
2823       assert_param(IS_UART_ADVFEATURE_AUTOBAUDRATEMODE(huart->AdvancedInit.AutoBaudRateMode));\r
2824       MODIFY_REG(huart->Instance->CR2, USART_CR2_ABRMODE, huart->AdvancedInit.AutoBaudRateMode);\r
2825     }\r
2826   }\r
2827 \r
2828   /* if required, configure MSB first on communication line */\r
2829   if (HAL_IS_BIT_SET(huart->AdvancedInit.AdvFeatureInit, UART_ADVFEATURE_MSBFIRST_INIT))\r
2830   {\r
2831     assert_param(IS_UART_ADVFEATURE_MSBFIRST(huart->AdvancedInit.MSBFirst));\r
2832     MODIFY_REG(huart->Instance->CR2, USART_CR2_MSBFIRST, huart->AdvancedInit.MSBFirst);\r
2833   }\r
2834 }\r
2835 \r
2836 /**\r
2837   * @brief Check the UART Idle State.\r
2838   * @param huart UART handle.\r
2839   * @retval HAL status\r
2840   */\r
2841 HAL_StatusTypeDef UART_CheckIdleState(UART_HandleTypeDef *huart)\r
2842 {\r
2843   uint32_t tickstart;\r
2844 \r
2845   /* Initialize the UART ErrorCode */\r
2846   huart->ErrorCode = HAL_UART_ERROR_NONE;\r
2847 \r
2848   /* Init tickstart for timeout managment*/\r
2849   tickstart = HAL_GetTick();\r
2850 \r
2851   /* Check if the Transmitter is enabled */\r
2852   if ((huart->Instance->CR1 & USART_CR1_TE) == USART_CR1_TE)\r
2853   {\r
2854     /* Wait until TEACK flag is set */\r
2855     if (UART_WaitOnFlagUntilTimeout(huart, USART_ISR_TEACK, RESET, tickstart, HAL_UART_TIMEOUT_VALUE) != HAL_OK)\r
2856     {\r
2857       /* Timeout occurred */\r
2858       return HAL_TIMEOUT;\r
2859     }\r
2860   }\r
2861 \r
2862   /* Initialize the UART State */\r
2863   huart->gState = HAL_UART_STATE_READY;\r
2864   huart->RxState = HAL_UART_STATE_READY;\r
2865 \r
2866   /* Process Unlocked */\r
2867   __HAL_UNLOCK(huart);\r
2868 \r
2869   return HAL_OK;\r
2870 }\r
2871 \r
2872 /**\r
2873   * @brief  Handle UART Communication Timeout.\r
2874   * @param huart     UART handle.\r
2875   * @param Flag      Specifies the UART flag to check\r
2876   * @param Status    Flag status (SET or RESET)\r
2877   * @param Tickstart Tick start value\r
2878   * @param Timeout   Timeout duration\r
2879   * @retval HAL status\r
2880   */\r
2881 HAL_StatusTypeDef UART_WaitOnFlagUntilTimeout(UART_HandleTypeDef *huart, uint32_t Flag, FlagStatus Status, uint32_t Tickstart, uint32_t Timeout)\r
2882 {\r
2883   /* Wait until flag is set */\r
2884   while ((__HAL_UART_GET_FLAG(huart, Flag) ? SET : RESET) == Status)\r
2885   {\r
2886     /* Check for the Timeout */\r
2887     if (Timeout != HAL_MAX_DELAY)\r
2888     {\r
2889       if (((HAL_GetTick() - Tickstart) > Timeout) || (Timeout == 0U))\r
2890       {\r
2891         /* Disable TXE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts for the interrupt process */\r
2892         CLEAR_BIT(huart->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE | USART_CR1_TXEIE));\r
2893         CLEAR_BIT(huart->Instance->CR3, USART_CR3_EIE);\r
2894 \r
2895         huart->gState = HAL_UART_STATE_READY;\r
2896         huart->RxState = HAL_UART_STATE_READY;\r
2897 \r
2898         /* Process Unlocked */\r
2899         __HAL_UNLOCK(huart);\r
2900 \r
2901         return HAL_TIMEOUT;\r
2902       }\r
2903     }\r
2904   }\r
2905   return HAL_OK;\r
2906 }\r
2907 \r
2908 \r
2909 /**\r
2910   * @brief  End ongoing Tx transfer on UART peripheral (following error detection or Transmit completion).\r
2911   * @param  huart UART handle.\r
2912   * @retval None\r
2913   */\r
2914 static void UART_EndTxTransfer(UART_HandleTypeDef *huart)\r
2915 {\r
2916   /* Disable TXEIE and TCIE interrupts */\r
2917   CLEAR_BIT(huart->Instance->CR1, (USART_CR1_TXEIE | USART_CR1_TCIE));\r
2918 \r
2919   /* At end of Tx process, restore huart->gState to Ready */\r
2920   huart->gState = HAL_UART_STATE_READY;\r
2921 }\r
2922 \r
2923 \r
2924 /**\r
2925   * @brief  End ongoing Rx transfer on UART peripheral (following error detection or Reception completion).\r
2926   * @param  huart UART handle.\r
2927   * @retval None\r
2928   */\r
2929 static void UART_EndRxTransfer(UART_HandleTypeDef *huart)\r
2930 {\r
2931   /* Disable RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts */\r
2932   CLEAR_BIT(huart->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE));\r
2933   CLEAR_BIT(huart->Instance->CR3, USART_CR3_EIE);\r
2934 \r
2935   /* At end of Rx process, restore huart->RxState to Ready */\r
2936   huart->RxState = HAL_UART_STATE_READY;\r
2937 \r
2938   /* Reset RxIsr function pointer */\r
2939   huart->RxISR = NULL;\r
2940 }\r
2941 \r
2942 \r
2943 /**\r
2944   * @brief DMA UART transmit process complete callback.\r
2945   * @param hdma DMA handle.\r
2946   * @retval None\r
2947   */\r
2948 static void UART_DMATransmitCplt(DMA_HandleTypeDef *hdma)\r
2949 {\r
2950   UART_HandleTypeDef *huart = (UART_HandleTypeDef *)(hdma->Parent);\r
2951 \r
2952   /* DMA Normal mode */\r
2953   if (hdma->Init.Mode != DMA_CIRCULAR)\r
2954   {\r
2955     huart->TxXferCount = 0U;\r
2956 \r
2957     /* Disable the DMA transfer for transmit request by resetting the DMAT bit\r
2958        in the UART CR3 register */\r
2959     CLEAR_BIT(huart->Instance->CR3, USART_CR3_DMAT);\r
2960 \r
2961     /* Enable the UART Transmit Complete Interrupt */\r
2962     SET_BIT(huart->Instance->CR1, USART_CR1_TCIE);\r
2963   }\r
2964   /* DMA Circular mode */\r
2965   else\r
2966   {\r
2967 #if (USE_HAL_UART_REGISTER_CALLBACKS == 1)\r
2968     /*Call registered Tx complete callback*/\r
2969     huart->TxCpltCallback(huart);\r
2970 #else\r
2971     /*Call legacy weak Tx complete callback*/\r
2972     HAL_UART_TxCpltCallback(huart);\r
2973 #endif /* USE_HAL_UART_REGISTER_CALLBACKS */\r
2974   }\r
2975 }\r
2976 \r
2977 /**\r
2978   * @brief DMA UART transmit process half complete callback.\r
2979   * @param hdma DMA handle.\r
2980   * @retval None\r
2981   */\r
2982 static void UART_DMATxHalfCplt(DMA_HandleTypeDef *hdma)\r
2983 {\r
2984   UART_HandleTypeDef *huart = (UART_HandleTypeDef *)(hdma->Parent);\r
2985 \r
2986 #if (USE_HAL_UART_REGISTER_CALLBACKS == 1)\r
2987   /*Call registered Tx Half complete callback*/\r
2988   huart->TxHalfCpltCallback(huart);\r
2989 #else\r
2990   /*Call legacy weak Tx Half complete callback*/\r
2991   HAL_UART_TxHalfCpltCallback(huart);\r
2992 #endif /* USE_HAL_UART_REGISTER_CALLBACKS */\r
2993 }\r
2994 \r
2995 /**\r
2996   * @brief DMA UART receive process complete callback.\r
2997   * @param hdma DMA handle.\r
2998   * @retval None\r
2999   */\r
3000 static void UART_DMAReceiveCplt(DMA_HandleTypeDef *hdma)\r
3001 {\r
3002   UART_HandleTypeDef *huart = (UART_HandleTypeDef *)(hdma->Parent);\r
3003 \r
3004   /* DMA Normal mode */\r
3005   if (hdma->Init.Mode != DMA_CIRCULAR)\r
3006   {\r
3007     huart->RxXferCount = 0U;\r
3008 \r
3009     /* Disable PE and ERR (Frame error, noise error, overrun error) interrupts */\r
3010     CLEAR_BIT(huart->Instance->CR1, USART_CR1_PEIE);\r
3011     CLEAR_BIT(huart->Instance->CR3, USART_CR3_EIE);\r
3012 \r
3013     /* Disable the DMA transfer for the receiver request by resetting the DMAR bit\r
3014        in the UART CR3 register */\r
3015     CLEAR_BIT(huart->Instance->CR3, USART_CR3_DMAR);\r
3016 \r
3017     /* At end of Rx process, restore huart->RxState to Ready */\r
3018     huart->RxState = HAL_UART_STATE_READY;\r
3019   }\r
3020 \r
3021 #if (USE_HAL_UART_REGISTER_CALLBACKS == 1)\r
3022   /*Call registered Rx complete callback*/\r
3023   huart->RxCpltCallback(huart);\r
3024 #else\r
3025   /*Call legacy weak Rx complete callback*/\r
3026   HAL_UART_RxCpltCallback(huart);\r
3027 #endif /* USE_HAL_UART_REGISTER_CALLBACKS */\r
3028 }\r
3029 \r
3030 /**\r
3031   * @brief DMA UART receive process half complete callback.\r
3032   * @param hdma DMA handle.\r
3033   * @retval None\r
3034   */\r
3035 static void UART_DMARxHalfCplt(DMA_HandleTypeDef *hdma)\r
3036 {\r
3037   UART_HandleTypeDef *huart = (UART_HandleTypeDef *)(hdma->Parent);\r
3038 \r
3039 #if (USE_HAL_UART_REGISTER_CALLBACKS == 1)\r
3040   /*Call registered Rx Half complete callback*/\r
3041   huart->RxHalfCpltCallback(huart);\r
3042 #else\r
3043   /*Call legacy weak Rx Half complete callback*/\r
3044   HAL_UART_RxHalfCpltCallback(huart);\r
3045 #endif /* USE_HAL_UART_REGISTER_CALLBACKS */\r
3046 }\r
3047 \r
3048 /**\r
3049   * @brief DMA UART communication error callback.\r
3050   * @param hdma DMA handle.\r
3051   * @retval None\r
3052   */\r
3053 static void UART_DMAError(DMA_HandleTypeDef *hdma)\r
3054 {\r
3055   UART_HandleTypeDef *huart = (UART_HandleTypeDef *)(hdma->Parent);\r
3056 \r
3057   const HAL_UART_StateTypeDef gstate = huart->gState;\r
3058   const HAL_UART_StateTypeDef rxstate = huart->RxState;\r
3059 \r
3060   /* Stop UART DMA Tx request if ongoing */\r
3061   if ((HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAT)) &&\r
3062       (gstate == HAL_UART_STATE_BUSY_TX))\r
3063   {\r
3064     huart->TxXferCount = 0U;\r
3065     UART_EndTxTransfer(huart);\r
3066   }\r
3067 \r
3068   /* Stop UART DMA Rx request if ongoing */\r
3069   if ((HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAR)) &&\r
3070       (rxstate == HAL_UART_STATE_BUSY_RX))\r
3071   {\r
3072     huart->RxXferCount = 0U;\r
3073     UART_EndRxTransfer(huart);\r
3074   }\r
3075 \r
3076   huart->ErrorCode |= HAL_UART_ERROR_DMA;\r
3077 \r
3078 #if (USE_HAL_UART_REGISTER_CALLBACKS == 1)\r
3079   /*Call registered error callback*/\r
3080   huart->ErrorCallback(huart);\r
3081 #else\r
3082   /*Call legacy weak error callback*/\r
3083   HAL_UART_ErrorCallback(huart);\r
3084 #endif /* USE_HAL_UART_REGISTER_CALLBACKS */\r
3085 }\r
3086 \r
3087 /**\r
3088   * @brief  DMA UART communication abort callback, when initiated by HAL services on Error\r
3089   *         (To be called at end of DMA Abort procedure following error occurrence).\r
3090   * @param  hdma DMA handle.\r
3091   * @retval None\r
3092   */\r
3093 static void UART_DMAAbortOnError(DMA_HandleTypeDef *hdma)\r
3094 {\r
3095   UART_HandleTypeDef *huart = (UART_HandleTypeDef *)(hdma->Parent);\r
3096   huart->RxXferCount = 0U;\r
3097   huart->TxXferCount = 0U;\r
3098 \r
3099 #if (USE_HAL_UART_REGISTER_CALLBACKS == 1)\r
3100   /*Call registered error callback*/\r
3101   huart->ErrorCallback(huart);\r
3102 #else\r
3103   /*Call legacy weak error callback*/\r
3104   HAL_UART_ErrorCallback(huart);\r
3105 #endif /* USE_HAL_UART_REGISTER_CALLBACKS */\r
3106 }\r
3107 \r
3108 /**\r
3109   * @brief  DMA UART Tx communication abort callback, when initiated by user\r
3110   *         (To be called at end of DMA Tx Abort procedure following user abort request).\r
3111   * @note   When this callback is executed, User Abort complete call back is called only if no\r
3112   *         Abort still ongoing for Rx DMA Handle.\r
3113   * @param  hdma DMA handle.\r
3114   * @retval None\r
3115   */\r
3116 static void UART_DMATxAbortCallback(DMA_HandleTypeDef *hdma)\r
3117 {\r
3118   UART_HandleTypeDef *huart = (UART_HandleTypeDef *)(hdma->Parent);\r
3119 \r
3120   huart->hdmatx->XferAbortCallback = NULL;\r
3121 \r
3122   /* Check if an Abort process is still ongoing */\r
3123   if (huart->hdmarx != NULL)\r
3124   {\r
3125     if (huart->hdmarx->XferAbortCallback != NULL)\r
3126     {\r
3127       return;\r
3128     }\r
3129   }\r
3130 \r
3131   /* No Abort process still ongoing : All DMA channels are aborted, call user Abort Complete callback */\r
3132   huart->TxXferCount = 0U;\r
3133   huart->RxXferCount = 0U;\r
3134 \r
3135   /* Reset errorCode */\r
3136   huart->ErrorCode = HAL_UART_ERROR_NONE;\r
3137 \r
3138   /* Clear the Error flags in the ICR register */\r
3139   __HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_OREF | UART_CLEAR_NEF | UART_CLEAR_PEF | UART_CLEAR_FEF);\r
3140 \r
3141 \r
3142   /* Restore huart->gState and huart->RxState to Ready */\r
3143   huart->gState  = HAL_UART_STATE_READY;\r
3144   huart->RxState = HAL_UART_STATE_READY;\r
3145 \r
3146   /* Call user Abort complete callback */\r
3147 #if (USE_HAL_UART_REGISTER_CALLBACKS == 1)\r
3148   /* Call registered Abort complete callback */\r
3149   huart->AbortCpltCallback(huart);\r
3150 #else\r
3151   /* Call legacy weak Abort complete callback */\r
3152   HAL_UART_AbortCpltCallback(huart);\r
3153 #endif /* USE_HAL_UART_REGISTER_CALLBACKS */\r
3154 }\r
3155 \r
3156 \r
3157 /**\r
3158   * @brief  DMA UART Rx communication abort callback, when initiated by user\r
3159   *         (To be called at end of DMA Rx Abort procedure following user abort request).\r
3160   * @note   When this callback is executed, User Abort complete call back is called only if no\r
3161   *         Abort still ongoing for Tx DMA Handle.\r
3162   * @param  hdma DMA handle.\r
3163   * @retval None\r
3164   */\r
3165 static void UART_DMARxAbortCallback(DMA_HandleTypeDef *hdma)\r
3166 {\r
3167   UART_HandleTypeDef *huart = (UART_HandleTypeDef *)(hdma->Parent);\r
3168 \r
3169   huart->hdmarx->XferAbortCallback = NULL;\r
3170 \r
3171   /* Check if an Abort process is still ongoing */\r
3172   if (huart->hdmatx != NULL)\r
3173   {\r
3174     if (huart->hdmatx->XferAbortCallback != NULL)\r
3175     {\r
3176       return;\r
3177     }\r
3178   }\r
3179 \r
3180   /* No Abort process still ongoing : All DMA channels are aborted, call user Abort Complete callback */\r
3181   huart->TxXferCount = 0U;\r
3182   huart->RxXferCount = 0U;\r
3183 \r
3184   /* Reset errorCode */\r
3185   huart->ErrorCode = HAL_UART_ERROR_NONE;\r
3186 \r
3187   /* Clear the Error flags in the ICR register */\r
3188   __HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_OREF | UART_CLEAR_NEF | UART_CLEAR_PEF | UART_CLEAR_FEF);\r
3189 \r
3190   /* Discard the received data */\r
3191   __HAL_UART_SEND_REQ(huart, UART_RXDATA_FLUSH_REQUEST);\r
3192 \r
3193   /* Restore huart->gState and huart->RxState to Ready */\r
3194   huart->gState  = HAL_UART_STATE_READY;\r
3195   huart->RxState = HAL_UART_STATE_READY;\r
3196 \r
3197   /* Call user Abort complete callback */\r
3198 #if (USE_HAL_UART_REGISTER_CALLBACKS == 1)\r
3199   /* Call registered Abort complete callback */\r
3200   huart->AbortCpltCallback(huart);\r
3201 #else\r
3202   /* Call legacy weak Abort complete callback */\r
3203   HAL_UART_AbortCpltCallback(huart);\r
3204 #endif /* USE_HAL_UART_REGISTER_CALLBACKS */\r
3205 }\r
3206 \r
3207 \r
3208 /**\r
3209   * @brief  DMA UART Tx communication abort callback, when initiated by user by a call to\r
3210   *         HAL_UART_AbortTransmit_IT API (Abort only Tx transfer)\r
3211   *         (This callback is executed at end of DMA Tx Abort procedure following user abort request,\r
3212   *         and leads to user Tx Abort Complete callback execution).\r
3213   * @param  hdma DMA handle.\r
3214   * @retval None\r
3215   */\r
3216 static void UART_DMATxOnlyAbortCallback(DMA_HandleTypeDef *hdma)\r
3217 {\r
3218   UART_HandleTypeDef *huart = (UART_HandleTypeDef *)(hdma->Parent);\r
3219 \r
3220   huart->TxXferCount = 0U;\r
3221 \r
3222 \r
3223   /* Restore huart->gState to Ready */\r
3224   huart->gState = HAL_UART_STATE_READY;\r
3225 \r
3226   /* Call user Abort complete callback */\r
3227 #if (USE_HAL_UART_REGISTER_CALLBACKS == 1)\r
3228   /* Call registered Abort Transmit Complete Callback */\r
3229   huart->AbortTransmitCpltCallback(huart);\r
3230 #else\r
3231   /* Call legacy weak Abort Transmit Complete Callback */\r
3232   HAL_UART_AbortTransmitCpltCallback(huart);\r
3233 #endif /* USE_HAL_UART_REGISTER_CALLBACKS */\r
3234 }\r
3235 \r
3236 /**\r
3237   * @brief  DMA UART Rx communication abort callback, when initiated by user by a call to\r
3238   *         HAL_UART_AbortReceive_IT API (Abort only Rx transfer)\r
3239   *         (This callback is executed at end of DMA Rx Abort procedure following user abort request,\r
3240   *         and leads to user Rx Abort Complete callback execution).\r
3241   * @param  hdma DMA handle.\r
3242   * @retval None\r
3243   */\r
3244 static void UART_DMARxOnlyAbortCallback(DMA_HandleTypeDef *hdma)\r
3245 {\r
3246   UART_HandleTypeDef *huart = (UART_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;\r
3247 \r
3248   huart->RxXferCount = 0U;\r
3249 \r
3250   /* Clear the Error flags in the ICR register */\r
3251   __HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_OREF | UART_CLEAR_NEF | UART_CLEAR_PEF | UART_CLEAR_FEF);\r
3252 \r
3253   /* Discard the received data */\r
3254   __HAL_UART_SEND_REQ(huart, UART_RXDATA_FLUSH_REQUEST);\r
3255 \r
3256   /* Restore huart->RxState to Ready */\r
3257   huart->RxState = HAL_UART_STATE_READY;\r
3258 \r
3259   /* Call user Abort complete callback */\r
3260 #if (USE_HAL_UART_REGISTER_CALLBACKS == 1)\r
3261   /* Call registered Abort Receive Complete Callback */\r
3262   huart->AbortReceiveCpltCallback(huart);\r
3263 #else\r
3264   /* Call legacy weak Abort Receive Complete Callback */\r
3265   HAL_UART_AbortReceiveCpltCallback(huart);\r
3266 #endif /* USE_HAL_UART_REGISTER_CALLBACKS */\r
3267 }\r
3268 \r
3269 /**\r
3270   * @brief TX interrrupt handler for 7 or 8 bits data word length .\r
3271   * @note   Function is called under interruption only, once\r
3272   *         interruptions have been enabled by HAL_UART_Transmit_IT().\r
3273   * @param huart UART handle.\r
3274   * @retval None\r
3275   */\r
3276 static void UART_TxISR_8BIT(UART_HandleTypeDef *huart)\r
3277 {\r
3278   /* Check that a Tx process is ongoing */\r
3279   if (huart->gState == HAL_UART_STATE_BUSY_TX)\r
3280   {\r
3281     if (huart->TxXferCount == 0U)\r
3282     {\r
3283       /* Disable the UART Transmit Data Register Empty Interrupt */\r
3284       CLEAR_BIT(huart->Instance->CR1, USART_CR1_TXEIE);\r
3285 \r
3286       /* Enable the UART Transmit Complete Interrupt */\r
3287       SET_BIT(huart->Instance->CR1, USART_CR1_TCIE);\r
3288     }\r
3289     else\r
3290     {\r
3291       huart->Instance->TDR = (uint8_t)(*huart->pTxBuffPtr & (uint8_t)0xFF);\r
3292       huart->pTxBuffPtr++;\r
3293       huart->TxXferCount--;\r
3294     }\r
3295   }\r
3296 }\r
3297 \r
3298 /**\r
3299   * @brief TX interrrupt handler for 9 bits data word length.\r
3300   * @note   Function is called under interruption only, once\r
3301   *         interruptions have been enabled by HAL_UART_Transmit_IT().\r
3302   * @param huart UART handle.\r
3303   * @retval None\r
3304   */\r
3305 static void UART_TxISR_16BIT(UART_HandleTypeDef *huart)\r
3306 {\r
3307   uint16_t *tmp;\r
3308 \r
3309   /* Check that a Tx process is ongoing */\r
3310   if (huart->gState == HAL_UART_STATE_BUSY_TX)\r
3311   {\r
3312     if (huart->TxXferCount == 0U)\r
3313     {\r
3314       /* Disable the UART Transmit Data Register Empty Interrupt */\r
3315       CLEAR_BIT(huart->Instance->CR1, USART_CR1_TXEIE);\r
3316 \r
3317       /* Enable the UART Transmit Complete Interrupt */\r
3318       SET_BIT(huart->Instance->CR1, USART_CR1_TCIE);\r
3319     }\r
3320     else\r
3321     {\r
3322       tmp = (uint16_t *) huart->pTxBuffPtr;\r
3323       huart->Instance->TDR = (((uint32_t)(*tmp)) & 0x01FFUL);\r
3324       huart->pTxBuffPtr += 2U;\r
3325       huart->TxXferCount--;\r
3326     }\r
3327   }\r
3328 }\r
3329 \r
3330 \r
3331 /**\r
3332   * @brief  Wrap up transmission in non-blocking mode.\r
3333   * @param  huart pointer to a UART_HandleTypeDef structure that contains\r
3334   *                the configuration information for the specified UART module.\r
3335   * @retval None\r
3336   */\r
3337 static void UART_EndTransmit_IT(UART_HandleTypeDef *huart)\r
3338 {\r
3339   /* Disable the UART Transmit Complete Interrupt */\r
3340   CLEAR_BIT(huart->Instance->CR1, USART_CR1_TCIE);\r
3341 \r
3342   /* Tx process is ended, restore huart->gState to Ready */\r
3343   huart->gState = HAL_UART_STATE_READY;\r
3344 \r
3345   /* Cleat TxISR function pointer */\r
3346   huart->TxISR = NULL;\r
3347 \r
3348 #if (USE_HAL_UART_REGISTER_CALLBACKS == 1)\r
3349   /*Call registered Tx complete callback*/\r
3350   huart->TxCpltCallback(huart);\r
3351 #else\r
3352   /*Call legacy weak Tx complete callback*/\r
3353   HAL_UART_TxCpltCallback(huart);\r
3354 #endif /* USE_HAL_UART_REGISTER_CALLBACKS */\r
3355 }\r
3356 \r
3357 /**\r
3358   * @brief RX interrrupt handler for 7 or 8 bits data word length .\r
3359   * @param huart UART handle.\r
3360   * @retval None\r
3361   */\r
3362 static void UART_RxISR_8BIT(UART_HandleTypeDef *huart)\r
3363 {\r
3364   uint16_t uhMask = huart->Mask;\r
3365   uint16_t  uhdata;\r
3366 \r
3367   /* Check that a Rx process is ongoing */\r
3368   if (huart->RxState == HAL_UART_STATE_BUSY_RX)\r
3369   {\r
3370     uhdata = (uint16_t) READ_REG(huart->Instance->RDR);\r
3371     *huart->pRxBuffPtr = (uint8_t)(uhdata & (uint8_t)uhMask);\r
3372     huart->pRxBuffPtr++;\r
3373     huart->RxXferCount--;\r
3374 \r
3375     if (huart->RxXferCount == 0U)\r
3376     {\r
3377       /* Disable the UART Parity Error Interrupt and RXNE interrupts */\r
3378       CLEAR_BIT(huart->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE));\r
3379 \r
3380       /* Disable the UART Error Interrupt: (Frame error, noise error, overrun error) */\r
3381       CLEAR_BIT(huart->Instance->CR3, USART_CR3_EIE);\r
3382 \r
3383       /* Rx process is completed, restore huart->RxState to Ready */\r
3384       huart->RxState = HAL_UART_STATE_READY;\r
3385 \r
3386       /* Clear RxISR function pointer */\r
3387       huart->RxISR = NULL;\r
3388 \r
3389 #if (USE_HAL_UART_REGISTER_CALLBACKS == 1)\r
3390       /*Call registered Rx complete callback*/\r
3391       huart->RxCpltCallback(huart);\r
3392 #else\r
3393       /*Call legacy weak Rx complete callback*/\r
3394       HAL_UART_RxCpltCallback(huart);\r
3395 #endif /* USE_HAL_UART_REGISTER_CALLBACKS */\r
3396     }\r
3397   }\r
3398   else\r
3399   {\r
3400     /* Clear RXNE interrupt flag */\r
3401     __HAL_UART_SEND_REQ(huart, UART_RXDATA_FLUSH_REQUEST);\r
3402   }\r
3403 }\r
3404 \r
3405 /**\r
3406   * @brief RX interrrupt handler for 9 bits data word length .\r
3407   * @note   Function is called under interruption only, once\r
3408   *         interruptions have been enabled by HAL_UART_Receive_IT()\r
3409   * @param huart UART handle.\r
3410   * @retval None\r
3411   */\r
3412 static void UART_RxISR_16BIT(UART_HandleTypeDef *huart)\r
3413 {\r
3414   uint16_t *tmp;\r
3415   uint16_t uhMask = huart->Mask;\r
3416   uint16_t  uhdata;\r
3417 \r
3418   /* Check that a Rx process is ongoing */\r
3419   if (huart->RxState == HAL_UART_STATE_BUSY_RX)\r
3420   {\r
3421     uhdata = (uint16_t) READ_REG(huart->Instance->RDR);\r
3422     tmp = (uint16_t *) huart->pRxBuffPtr ;\r
3423     *tmp = (uint16_t)(uhdata & uhMask);\r
3424     huart->pRxBuffPtr += 2U;\r
3425     huart->RxXferCount--;\r
3426 \r
3427     if (huart->RxXferCount == 0U)\r
3428     {\r
3429       /* Disable the UART Parity Error Interrupt and RXNE interrupt*/\r
3430       CLEAR_BIT(huart->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE));\r
3431 \r
3432       /* Disable the UART Error Interrupt: (Frame error, noise error, overrun error) */\r
3433       CLEAR_BIT(huart->Instance->CR3, USART_CR3_EIE);\r
3434 \r
3435       /* Rx process is completed, restore huart->RxState to Ready */\r
3436       huart->RxState = HAL_UART_STATE_READY;\r
3437 \r
3438       /* Clear RxISR function pointer */\r
3439       huart->RxISR = NULL;\r
3440 \r
3441 #if (USE_HAL_UART_REGISTER_CALLBACKS == 1)\r
3442       /*Call registered Rx complete callback*/\r
3443       huart->RxCpltCallback(huart);\r
3444 #else\r
3445       /*Call legacy weak Rx complete callback*/\r
3446       HAL_UART_RxCpltCallback(huart);\r
3447 #endif /* USE_HAL_UART_REGISTER_CALLBACKS */\r
3448     }\r
3449   }\r
3450   else\r
3451   {\r
3452     /* Clear RXNE interrupt flag */\r
3453     __HAL_UART_SEND_REQ(huart, UART_RXDATA_FLUSH_REQUEST);\r
3454   }\r
3455 }\r
3456 \r
3457 \r
3458 /**\r
3459   * @}\r
3460   */\r
3461 \r
3462 #endif /* HAL_UART_MODULE_ENABLED */\r
3463 /**\r
3464   * @}\r
3465   */\r
3466 \r
3467 /**\r
3468   * @}\r
3469   */\r
3470 \r
3471 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/\r