git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/CORTEX_M7_STM32F7_STM32756G-EVAL_IAR_Keil/ST_Library/stm32f7xx_hal_usart.c

   1 /**\r
   2   ******************************************************************************\r
   3   * @file    stm32f7xx_hal_usart.c\r
   4   * @author  MCD Application Team\r
   5   * @version V1.0.0RC1\r
   6   * @date    24-March-2015\r
   7   * @brief   USART HAL module driver.\r
   8   *\r
   9   *          This file provides firmware functions to manage the following \r
  10   *          functionalities of the Universal Synchronous/Asynchronous Receiver Transmitter\r
  11   *          Peripheral (USART).\r
  12   *           + Initialization and de-initialization functions\r
  13   *           + IO operation functions\r
  14   *           + Peripheral Control functions\r
  15   *\r
  16   @verbatim\r
  17   ===============================================================================\r
  18                         ##### How to use this driver #####\r
  19  ===============================================================================\r
  20     [..]\r
  21       The USART HAL driver can be used as follows:\r
  22 \r
  23       (#) Declare a USART_HandleTypeDef handle structure.\r
  24       (#) Initialize the USART low level resources by implement the HAL_USART_MspInit ()API:\r
  25           (##) Enable the USARTx interface clock.\r
  26           (##) USART pins configuration:\r
  27             (+) Enable the clock for the USART GPIOs.\r
  28             (+) Configure these USART pins as alternate function pull-up.\r
  29           (##) NVIC configuration if you need to use interrupt process (HAL_USART_Transmit_IT(),\r
  30                 HAL_USART_Receive_IT() and HAL_USART_TransmitReceive_IT() APIs):\r
  31             (+) Configure the USARTx interrupt priority.\r
  32             (+) Enable the NVIC USART IRQ handle.\r
  33               (@) The specific USART interrupts (Transmission complete interrupt, \r
  34                   RXNE interrupt and Error Interrupts) will be managed using the macros\r
  35                   __HAL_USART_ENABLE_IT() and __HAL_USART_DISABLE_IT() inside the transmit and receive process.\r
  36           (##) DMA Configuration if you need to use DMA process (HAL_USART_Transmit_DMA()\r
  37                HAL_USART_Receive_IT() and HAL_USART_TransmitReceive_IT() APIs):\r
  38             (+) Declare a DMA handle structure for the Tx/Rx stream.\r
  39             (+) Enable the DMAx interface clock.\r
  40             (+) Configure the declared DMA handle structure with the required Tx/Rx parameters.                \r
  41             (+) Configure the DMA Tx/Rx Stream.\r
  42             (+) Associate the initialized DMA handle to the USART DMA Tx/Rx handle.\r
  43             (+) Configure the priority and enable the NVIC for the transfer complete interrupt on the DMA Tx/Rx Stream.\r
  44 \r
  45       (#) Program the Baud Rate, Word Length, Stop Bit, Parity, Hardware \r
  46           flow control and Mode(Receiver/Transmitter) in the husart Init structure.\r
  47 \r
  48       (#) Initialize the USART registers by calling the HAL_USART_Init() API:\r
  49           (+) These API's configures also the low level Hardware GPIO, CLOCK, CORTEX...etc)\r
  50               by calling the customed HAL_USART_MspInit(&husart) API.\r
  51 \r
  52   @endverbatim\r
  53   ******************************************************************************\r
  54   * @attention\r
  55   *\r
  56   * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>\r
  57   *\r
  58   * Redistribution and use in source and binary forms, with or without modification,\r
  59   * are permitted provided that the following conditions are met:\r
  60   *   1. Redistributions of source code must retain the above copyright notice,\r
  61   *      this list of conditions and the following disclaimer.\r
  62   *   2. Redistributions in binary form must reproduce the above copyright notice,\r
  63   *      this list of conditions and the following disclaimer in the documentation\r
  64   *      and/or other materials provided with the distribution.\r
  65   *   3. Neither the name of STMicroelectronics nor the names of its contributors\r
  66   *      may be used to endorse or promote products derived from this software\r
  67   *      without specific prior written permission.\r
  68   *\r
  69   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"\r
  70   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
  71   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\r
  72   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\r
  73   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\r
  74   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\r
  75   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\r
  76   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\r
  77   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\r
  78   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
  79   *\r
  80   ******************************************************************************\r
  81   */\r
  82 \r
  83 /* Includes ------------------------------------------------------------------*/\r
  84 #include "stm32f7xx_hal.h"\r
  85 \r
  86 /** @addtogroup STM32F7xx_HAL_Driver\r
  87   * @{\r
  88   */\r
  89 \r
  90 /** @defgroup USART USART\r
  91   * @brief HAL USART Synchronous module driver\r
  92   * @{\r
  93   */\r
  94 \r
  95 #ifdef HAL_USART_MODULE_ENABLED\r
  96 \r
  97 /* Private typedef -----------------------------------------------------------*/\r
  98 /* Private define ------------------------------------------------------------*/\r
  99 /** @addtogroup USART_Private_Constants\r
 100   * @{\r
 101   */\r
 102 #define DUMMY_DATA                             ((uint16_t) 0xFFFF)\r
 103 #define TEACK_REACK_TIMEOUT                    ((uint32_t) 1000)\r
 104 #define USART_TXDMA_TIMEOUTVALUE            22000\r
 105 #define USART_TIMEOUT_VALUE                 22000\r
 106 #define USART_CR1_FIELDS  ((uint32_t)(USART_CR1_M | USART_CR1_PCE | USART_CR1_PS | \\r
 107                                      USART_CR1_TE | USART_CR1_RE  | USART_CR1_OVER8))\r
 108 #define USART_CR2_FIELDS       ((uint32_t)(USART_CR2_CPHA | USART_CR2_CPOL | \\r
 109                             USART_CR2_CLKEN | USART_CR2_LBCL | USART_CR2_STOP))\r
 110 /**\r
 111   * @}\r
 112   */\r
 113 /* Private macro -------------------------------------------------------------*/\r
 114 /* Private variables ---------------------------------------------------------*/\r
 115 /* Private function prototypes -----------------------------------------------*/\r
 116 /* Private functions ---------------------------------------------------------*/\r
 117 /** @addtogroup USART_Private_Functions\r
 118   * @{\r
 119   */\r
 120 static void USART_DMATransmitCplt(DMA_HandleTypeDef *hdma);\r
 121 static void USART_DMAReceiveCplt(DMA_HandleTypeDef *hdma);\r
 122 static void USART_DMATxHalfCplt(DMA_HandleTypeDef *hdma);\r
 123 static void USART_DMARxHalfCplt(DMA_HandleTypeDef *hdma);\r
 124 static void USART_DMAError(DMA_HandleTypeDef *hdma);\r
 125 static HAL_StatusTypeDef USART_WaitOnFlagUntilTimeout(USART_HandleTypeDef *husart, uint32_t Flag, FlagStatus Status, uint32_t Timeout);\r
 126 static HAL_StatusTypeDef USART_SetConfig(USART_HandleTypeDef *husart);\r
 127 static HAL_StatusTypeDef USART_CheckIdleState(USART_HandleTypeDef *husart);\r
 128 static HAL_StatusTypeDef USART_Transmit_IT(USART_HandleTypeDef *husart);\r
 129 static HAL_StatusTypeDef USART_Receive_IT(USART_HandleTypeDef *husart);\r
 130 static HAL_StatusTypeDef USART_TransmitReceive_IT(USART_HandleTypeDef *husart);\r
 131 /**\r
 132   * @}\r
 133   */\r
 134 \r
 135 /* Exported functions --------------------------------------------------------*/\r
 136 \r
 137 /** @defgroup USART_Exported_Functions USART Exported Functions\r
 138   * @{\r
 139   */\r
 140 \r
 141 /** @defgroup USART_Exported_Functions_Group1 USART Initialization and de-initialization functions\r
 142   *  @brief    Initialization and Configuration functions\r
 143   *\r
 144 @verbatim\r
 145  ===============================================================================\r
 146             ##### Initialization and Configuration functions #####\r
 147  ===============================================================================\r
 148     [..]\r
 149     This subsection provides a set of functions allowing to initialize the USART\r
 150     in asynchronous and in synchronous modes.\r
 151       (+) For the asynchronous mode only these parameters can be configured:\r
 152         (++) Baud Rate\r
 153         (++) Word Length\r
 154         (++) Stop Bit\r
 155         (++) Parity: If the parity is enabled, then the MSB bit of the data written\r
 156              in the data register is transmitted but is changed by the parity bit.\r
 157              Depending on the frame length defined by the M1 and M0 bits (7-bit,\r
 158              8-bit or 9-bit), the possible USART frame formats are as listed in the\r
 159              following table:\r
 160 \r
 161    +---------------------------------------------------------------+\r
 162    | M1M0 bits |  PCE bit  |            USART frame                |\r
 163    |-----------------------|---------------------------------------|\r
 164    |     10    |     0     |    | SB | 7-bit data | STB |          |\r
 165    |-----------|-----------|---------------------------------------|\r
 166    |     10    |     1     |    | SB | 6-bit data | PB | STB |     |\r
 167    +---------------------------------------------------------------+\r
 168         (++) USART polarity\r
 169         (++) USART phase\r
 170         (++) USART LastBit\r
 171         (++) Receiver/transmitter modes\r
 172 \r
 173     [..]\r
 174     The HAL_USART_Init() function follows the USART  synchronous configuration\r
 175     procedure (details for the procedure are available in reference manual).\r
 176 \r
 177 @endverbatim\r
 178   * @{\r
 179   */\r
 180 \r
 181 /**\r
 182   * @brief  Initializes the USART mode according to the specified\r
 183   *         parameters in the USART_InitTypeDef and create the associated handle.\r
 184   * @param husart: USART handle\r
 185   * @retval HAL status\r
 186   */\r
 187 HAL_StatusTypeDef HAL_USART_Init(USART_HandleTypeDef *husart)\r
 188 {\r
 189   /* Check the USART handle allocation */\r
 190   if(husart == NULL)\r
 191   {\r
 192     return HAL_ERROR;\r
 193   }\r
 194 \r
 195   /* Check the parameters */\r
 196   assert_param(IS_USART_INSTANCE(husart->Instance));\r
 197 \r
 198   if(husart->State == HAL_USART_STATE_RESET)\r
 199   {\r
 200     /* Init the low level hardware : GPIO, CLOCK */\r
 201     HAL_USART_MspInit(husart);\r
 202   }\r
 203 \r
 204   husart->State = HAL_USART_STATE_BUSY;\r
 205 \r
 206   /* Disable the Peripheral */\r
 207   __HAL_USART_DISABLE(husart);\r
 208 \r
 209   /* Set the Usart Communication parameters */\r
 210   if (USART_SetConfig(husart) == HAL_ERROR)\r
 211   {\r
 212     return HAL_ERROR;\r
 213   }\r
 214 \r
 215   /* In Synchronous mode, the following bits must be kept cleared:\r
 216   - LINEN bit in the USART_CR2 register\r
 217   - HDSEL, SCEN and IREN bits in the USART_CR3 register.*/\r
 218   husart->Instance->CR2 &= ~USART_CR2_LINEN;\r
 219   husart->Instance->CR3 &= ~(USART_CR3_SCEN | USART_CR3_HDSEL | USART_CR3_IREN);\r
 220 \r
 221   /* Enable the Peripheral */\r
 222   __HAL_USART_ENABLE(husart);\r
 223 \r
 224   /* TEACK and/or REACK to check before moving husart->State to Ready */\r
 225   return (USART_CheckIdleState(husart));\r
 226 }\r
 227 \r
 228 /**\r
 229   * @brief DeInitializes the USART peripheral\r
 230   * @param husart: USART handle\r
 231   * @retval HAL status\r
 232   */\r
 233 HAL_StatusTypeDef HAL_USART_DeInit(USART_HandleTypeDef *husart)\r
 234 {\r
 235    /* Check the USART handle allocation */\r
 236   if(husart == NULL)\r
 237   {\r
 238     return HAL_ERROR;\r
 239   }\r
 240 \r
 241   /* Check the parameters */\r
 242   assert_param(IS_USART_INSTANCE(husart->Instance));\r
 243 \r
 244   husart->State = HAL_USART_STATE_BUSY;\r
 245 \r
 246   husart->Instance->CR1 = 0x0;\r
 247   husart->Instance->CR2 = 0x0;\r
 248   husart->Instance->CR3 = 0x0;\r
 249 \r
 250   /* DeInit the low level hardware */\r
 251   HAL_USART_MspDeInit(husart);\r
 252 \r
 253   husart->ErrorCode = HAL_USART_ERROR_NONE;\r
 254   husart->State = HAL_USART_STATE_RESET;\r
 255 \r
 256   /* Process Unlock */\r
 257   __HAL_UNLOCK(husart);\r
 258 \r
 259   return HAL_OK;\r
 260 }\r
 261 \r
 262 /**\r
 263   * @brief USART MSP Init\r
 264   * @param husart: USART handle\r
 265   * @retval None\r
 266   */\r
 267  __weak void HAL_USART_MspInit(USART_HandleTypeDef *husart)\r
 268 {\r
 269   /* NOTE : This function should not be modified, when the callback is needed,\r
 270             the HAL_USART_MspInit can be implemented in the user file\r
 271    */\r
 272 }\r
 273 \r
 274 /**\r
 275   * @brief USART MSP DeInit\r
 276   * @param husart: USART handle\r
 277   * @retval None\r
 278   */\r
 279  __weak void HAL_USART_MspDeInit(USART_HandleTypeDef *husart)\r
 280 {\r
 281   /* NOTE : This function should not be modified, when the callback is needed,\r
 282             the HAL_USART_MspDeInit can be implemented in the user file\r
 283    */\r
 284 }\r
 285 \r
 286 /**\r
 287   * @}\r
 288   */\r
 289 \r
 290 /** @defgroup USART_Exported_Functions_Group2 IO operation functions \r
 291   *  @brief   USART Transmit and Receive functions \r
 292   *\r
 293 @verbatim\r
 294  ===============================================================================\r
 295                       ##### IO operation functions #####\r
 296  ===============================================================================\r
 297     This subsection provides a set of functions allowing to manage the USART synchronous\r
 298     data transfers.\r
 299 \r
 300     [..] The USART supports master mode only: it cannot receive or send data related to an input\r
 301          clock (SCLK is always an output).\r
 302 \r
 303     (#) There are two mode of transfer:\r
 304        (+) Blocking mode: The communication is performed in polling mode.\r
 305             The HAL status of all data processing is returned by the same function\r
 306             after finishing transfer.\r
 307        (+) No-Blocking mode: The communication is performed using Interrupts\r
 308            or DMA, These API's return the HAL status.\r
 309            The end of the data processing will be indicated through the\r
 310            dedicated USART IRQ when using Interrupt mode or the DMA IRQ when\r
 311            using DMA mode.\r
 312            The HAL_USART_TxCpltCallback(), HAL_USART_RxCpltCallback() and HAL_USART_TxRxCpltCallback() user callbacks\r
 313            will be executed respectively at the end of the transmit or Receive process\r
 314            The HAL_USART_ErrorCallback()user callback will be executed when a communication error is detected\r
 315 \r
 316     (#) Blocking mode API's are :\r
 317         (+) HAL_USART_Transmit()in simplex mode\r
 318         (+) HAL_USART_Receive() in full duplex receive only\r
 319         (+) HAL_USART_TransmitReceive() in full duplex mode\r
 320 \r
 321     (#) Non-Blocking mode API's with Interrupt are :\r
 322         (+) HAL_USART_Transmit_IT()in simplex mode\r
 323         (+) HAL_USART_Receive_IT() in full duplex receive only\r
 324         (+) HAL_USART_TransmitReceive_IT()in full duplex mode\r
 325         (+) HAL_USART_IRQHandler()\r
 326 \r
 327     (#) No-Blocking mode functions with DMA are :\r
 328         (+) HAL_USART_Transmit_DMA()in simplex mode\r
 329         (+) HAL_USART_Receive_DMA() in full duplex receive only\r
 330         (+) HAL_USART_TransmitReceive_DMA() in full duplex mode\r
 331         (+) HAL_USART_DMAPause()\r
 332         (+) HAL_USART_DMAResume()\r
 333         (+) HAL_USART_DMAStop()\r
 334 \r
 335     (#) A set of Transfer Complete Callbacks are provided in No_Blocking mode:\r
 336         (+) HAL_USART_TxCpltCallback()\r
 337         (+) HAL_USART_RxCpltCallback()\r
 338         (+) HAL_USART_TxHalfCpltCallback()\r
 339         (+) HAL_USART_RxHalfCpltCallback()\r
 340         (+) HAL_USART_ErrorCallback()\r
 341         (+) HAL_USART_TxRxCpltCallback()\r
 342 \r
 343 @endverbatim\r
 344   * @{\r
 345   */\r
 346 \r
 347 /**\r
 348   * @brief  Simplex Send an amount of data in blocking mode\r
 349   * @param  husart: USART handle\r
 350   * @param pTxData: pointer to data buffer\r
 351   * @param Size: amount of data to be sent\r
 352   * @param Timeout : Timeout duration\r
 353   * @retval HAL status\r
 354   */\r
 355 HAL_StatusTypeDef HAL_USART_Transmit(USART_HandleTypeDef *husart, uint8_t *pTxData, uint16_t Size, uint32_t Timeout)\r
 356 {\r
 357   uint16_t* tmp;\r
 358 \r
 359   if(husart->State == HAL_USART_STATE_READY)\r
 360   {\r
 361     if((pTxData == NULL) || (Size == 0))\r
 362     {\r
 363       return  HAL_ERROR;\r
 364     }\r
 365 \r
 366     /* Process Locked */\r
 367     __HAL_LOCK(husart);\r
 368 \r
 369     husart->ErrorCode = HAL_USART_ERROR_NONE;\r
 370     husart->State = HAL_USART_STATE_BUSY_TX;\r
 371 \r
 372     husart->TxXferSize = Size;\r
 373     husart->TxXferCount = Size;\r
 374 \r
 375     /* Check the remaining data to be sent */\r
 376     while(husart->TxXferCount > 0)\r
 377     {\r
 378       husart->TxXferCount--;\r
 379       if(USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_TC, RESET, Timeout) != HAL_OK)\r
 380         {\r
 381           return HAL_TIMEOUT;\r
 382         }\r
 383       if((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE))\r
 384       {\r
 385         tmp = (uint16_t*) pTxData;\r
 386         husart->Instance->TDR = (*tmp & (uint16_t)0x01FF);\r
 387         pTxData += 2;\r
 388       }\r
 389       else\r
 390       {\r
 391         husart->Instance->TDR = (*pTxData++ & (uint8_t)0xFF);\r
 392       }\r
 393     }\r
 394 \r
 395     if(USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_TC, RESET, Timeout) != HAL_OK)\r
 396     {\r
 397       return HAL_TIMEOUT;\r
 398     }\r
 399 \r
 400     husart->State = HAL_USART_STATE_READY;\r
 401 \r
 402     /* Process Unlocked */\r
 403     __HAL_UNLOCK(husart);\r
 404 \r
 405     return HAL_OK;\r
 406   }\r
 407   else\r
 408   {\r
 409     return HAL_BUSY;\r
 410   }\r
 411 }\r
 412 \r
 413 /**\r
 414   * @brief Receive an amount of data in blocking mode\r
 415   * @note To receive synchronous data, dummy data are simultaneously transmitted\r
 416   * @param husart: USART handle\r
 417   * @param pRxData: pointer to data buffer\r
 418   * @param Size: amount of data to be received\r
 419   * @param Timeout : Timeout duration\r
 420   * @retval HAL status\r
 421   */\r
 422 HAL_StatusTypeDef HAL_USART_Receive(USART_HandleTypeDef *husart, uint8_t *pRxData, uint16_t Size, uint32_t Timeout)\r
 423 {\r
 424   uint16_t* tmp;\r
 425   uint16_t uhMask;\r
 426 \r
 427   if(husart->State == HAL_USART_STATE_READY)\r
 428   {\r
 429     if((pRxData == NULL) || (Size == 0))\r
 430     {\r
 431       return  HAL_ERROR;\r
 432     }\r
 433     /* Process Locked */\r
 434     __HAL_LOCK(husart);\r
 435 \r
 436     husart->ErrorCode = HAL_USART_ERROR_NONE;\r
 437     husart->State = HAL_USART_STATE_BUSY_RX;\r
 438 \r
 439     husart->RxXferSize = Size;\r
 440     husart->RxXferCount = Size;\r
 441 \r
 442     /* Computation of USART mask to apply to RDR register */\r
 443     __HAL_USART_MASK_COMPUTATION(husart);\r
 444     uhMask = husart->Mask;\r
 445 \r
 446     /* as long as data have to be received */\r
 447     while(husart->RxXferCount > 0)\r
 448     {\r
 449       husart->RxXferCount--;\r
 450 \r
 451       /* Wait until TC flag is set to send dummy byte in order to generate the\r
 452       * clock for the slave to send data.\r
 453        * Whatever the frame length (7, 8 or 9-bit long), the same dummy value\r
 454        * can be written for all the cases. */\r
 455       if(USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_TC, RESET, Timeout) != HAL_OK)\r
 456       {\r
 457         return HAL_TIMEOUT;\r
 458       }\r
 459       husart->Instance->TDR = (DUMMY_DATA & (uint16_t)0x0FF);\r
 460 \r
 461       /* Wait for RXNE Flag */\r
 462       if(USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_RXNE, RESET, Timeout) != HAL_OK)\r
 463       {\r
 464         return HAL_TIMEOUT;\r
 465       }\r
 466 \r
 467       if((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE))\r
 468       {\r
 469         tmp = (uint16_t*) pRxData ;\r
 470         *tmp = (uint16_t)(husart->Instance->RDR & uhMask);\r
 471         pRxData +=2;\r
 472       }\r
 473       else\r
 474       {\r
 475         *pRxData++ = (uint8_t)(husart->Instance->RDR & (uint8_t)uhMask);\r
 476       }\r
 477     }\r
 478 \r
 479     husart->State = HAL_USART_STATE_READY;\r
 480 \r
 481     /* Process Unlocked */\r
 482     __HAL_UNLOCK(husart);\r
 483 \r
 484     return HAL_OK;\r
 485   }\r
 486   else\r
 487   {\r
 488     return HAL_BUSY;\r
 489   }\r
 490 }\r
 491 \r
 492 /**\r
 493   * @brief Full-Duplex Send and Receive an amount of data in blocking mode\r
 494   * @param husart: USART handle\r
 495   * @param pTxData: pointer to TX data buffer\r
 496   * @param pRxData: pointer to RX data buffer\r
 497   * @param Size: amount of data to be sent (same amount to be received)\r
 498   * @param Timeout : Timeout duration\r
 499   * @retval HAL status\r
 500   */\r
 501 HAL_StatusTypeDef HAL_USART_TransmitReceive(USART_HandleTypeDef *husart, uint8_t *pTxData, uint8_t *pRxData, uint16_t Size, uint32_t Timeout)\r
 502 {\r
 503   uint16_t* tmp;\r
 504   uint16_t uhMask;\r
 505 \r
 506   if(husart->State == HAL_USART_STATE_READY)\r
 507   {\r
 508     if((pTxData == NULL) || (pRxData == NULL) || (Size == 0))\r
 509     {\r
 510       return  HAL_ERROR;\r
 511     }\r
 512     /* Process Locked */\r
 513     __HAL_LOCK(husart);\r
 514 \r
 515     husart->ErrorCode = HAL_USART_ERROR_NONE;\r
 516     husart->State = HAL_USART_STATE_BUSY_RX;\r
 517 \r
 518     husart->RxXferSize = Size;\r
 519     husart->TxXferSize = Size;\r
 520     husart->TxXferCount = Size;\r
 521     husart->RxXferCount = Size;\r
 522 \r
 523     /* Computation of USART mask to apply to RDR register */\r
 524     __HAL_USART_MASK_COMPUTATION(husart);\r
 525     uhMask = husart->Mask;\r
 526 \r
 527     /* Check the remain data to be sent */\r
 528     while(husart->TxXferCount > 0)\r
 529     {\r
 530       husart->TxXferCount--;\r
 531       husart->RxXferCount--;\r
 532 \r
 533       /* Wait until TC flag is set to send data */\r
 534       if(USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_TC, RESET, Timeout) != HAL_OK)\r
 535       {\r
 536         return HAL_TIMEOUT;\r
 537       }\r
 538       if((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE))\r
 539       {\r
 540         tmp = (uint16_t*) pTxData;\r
 541         husart->Instance->TDR = (*tmp & uhMask);\r
 542         pTxData += 2;\r
 543       }\r
 544       else\r
 545       {\r
 546         husart->Instance->TDR = (*pTxData++ & (uint8_t)uhMask);\r
 547       }\r
 548 \r
 549       /* Wait for RXNE Flag */\r
 550       if(USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_RXNE, RESET, Timeout) != HAL_OK)\r
 551       {\r
 552         return HAL_TIMEOUT;\r
 553       }\r
 554 \r
 555       if((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE))\r
 556       {\r
 557         tmp = (uint16_t*) pRxData ;\r
 558         *tmp = (uint16_t)(husart->Instance->RDR & uhMask);\r
 559         pRxData +=2;\r
 560       }\r
 561       else\r
 562       {\r
 563         *pRxData++ = (uint8_t)(husart->Instance->RDR & (uint8_t)uhMask);\r
 564       }\r
 565     }\r
 566 \r
 567     husart->State = HAL_USART_STATE_READY;\r
 568 \r
 569     /* Process Unlocked */\r
 570     __HAL_UNLOCK(husart);\r
 571 \r
 572     return HAL_OK;\r
 573   }\r
 574   else\r
 575   {\r
 576     return HAL_BUSY;\r
 577   }\r
 578 }\r
 579 \r
 580 /**\r
 581   * @brief  Send an amount of data in interrupt mode\r
 582   * @param  husart: USART handle\r
 583   * @param pTxData: pointer to data buffer\r
 584   * @param Size: amount of data to be sent\r
 585   * @retval HAL status\r
 586   */\r
 587 HAL_StatusTypeDef HAL_USART_Transmit_IT(USART_HandleTypeDef *husart, uint8_t *pTxData, uint16_t Size)\r
 588 {\r
 589   if(husart->State == HAL_USART_STATE_READY)\r
 590   {\r
 591     if((pTxData == NULL ) || (Size == 0))\r
 592     {\r
 593       return HAL_ERROR;\r
 594     }\r
 595 \r
 596     /* Process Locked */\r
 597     __HAL_LOCK(husart);\r
 598 \r
 599     husart->pTxBuffPtr = pTxData;\r
 600     husart->TxXferSize = Size;\r
 601     husart->TxXferCount = Size;\r
 602 \r
 603     husart->ErrorCode = HAL_USART_ERROR_NONE;\r
 604     husart->State = HAL_USART_STATE_BUSY_TX;\r
 605 \r
 606     /* The USART Error Interrupts: (Frame error, noise error, overrun error)\r
 607     are not managed by the USART Transmit Process to avoid the overrun interrupt\r
 608     when the usart mode is configured for transmit and receive "USART_MODE_TX_RX"\r
 609     to benefit for the frame error and noise interrupts the usart mode should be\r
 610     configured only for transmit "USART_MODE_TX" */\r
 611 \r
 612     /* Process Unlocked */\r
 613     __HAL_UNLOCK(husart);\r
 614 \r
 615     /* Enable the USART Transmit Data Register Empty Interrupt */\r
 616     __HAL_USART_ENABLE_IT(husart, USART_IT_TXE);\r
 617 \r
 618     return HAL_OK;\r
 619   }\r
 620   else\r
 621   {\r
 622     return HAL_BUSY;\r
 623   }\r
 624 }\r
 625 \r
 626 /**\r
 627   * @brief Receive an amount of data in blocking mode\r
 628   *        To receive synchronous data, dummy data are simultaneously transmitted\r
 629   * @param husart: USART handle\r
 630   * @param pRxData: pointer to data buffer\r
 631   * @param Size: amount of data to be received\r
 632   * @retval HAL status\r
 633   */\r
 634 HAL_StatusTypeDef HAL_USART_Receive_IT(USART_HandleTypeDef *husart, uint8_t *pRxData, uint16_t Size)\r
 635 {\r
 636   if(husart->State == HAL_USART_STATE_READY)\r
 637   {\r
 638     if((pRxData == NULL ) || (Size == 0))\r
 639     {\r
 640       return HAL_ERROR;\r
 641     }\r
 642     /* Process Locked */\r
 643     __HAL_LOCK(husart);\r
 644 \r
 645     husart->pRxBuffPtr = pRxData;\r
 646     husart->RxXferSize = Size;\r
 647     husart->RxXferCount = Size;\r
 648 \r
 649     __HAL_USART_MASK_COMPUTATION(husart);\r
 650 \r
 651     husart->ErrorCode = HAL_USART_ERROR_NONE;\r
 652     husart->State = HAL_USART_STATE_BUSY_RX;\r
 653 \r
 654     /* Enable the USART Parity Error Interrupt */\r
 655     __HAL_USART_ENABLE_IT(husart, USART_IT_PE);\r
 656 \r
 657     /* Enable the USART Error Interrupt: (Frame error, noise error, overrun error) */\r
 658     __HAL_USART_ENABLE_IT(husart, USART_IT_ERR);\r
 659 \r
 660     /* Enable the USART Data Register not empty Interrupt */\r
 661     __HAL_USART_ENABLE_IT(husart, USART_IT_RXNE);\r
 662 \r
 663     /* Process Unlocked */\r
 664     __HAL_UNLOCK(husart);\r
 665 \r
 666 \r
 667     /* Send dummy byte in order to generate the clock for the Slave to send the next data */\r
 668     if(husart->Init.WordLength == USART_WORDLENGTH_9B)\r
 669     {\r
 670       husart->Instance->TDR = (DUMMY_DATA & (uint16_t)0x01FF); \r
 671     }\r
 672     else\r
 673     {\r
 674       husart->Instance->TDR = (DUMMY_DATA & (uint16_t)0x00FF);\r
 675     }\r
 676 \r
 677     return HAL_OK;\r
 678   }\r
 679   else\r
 680   {\r
 681     return HAL_BUSY;\r
 682   }\r
 683 }\r
 684 \r
 685 /**\r
 686   * @brief Full-Duplex Send and Receive an amount of data in interrupt mode\r
 687   * @param husart: USART handle\r
 688   * @param pTxData: pointer to TX data buffer\r
 689   * @param pRxData: pointer to RX data buffer\r
 690   * @param Size: amount of data to be sent (same amount to be received)\r
 691   * @retval HAL status\r
 692   */\r
 693 HAL_StatusTypeDef HAL_USART_TransmitReceive_IT(USART_HandleTypeDef *husart, uint8_t *pTxData, uint8_t *pRxData,  uint16_t Size)\r
 694 {\r
 695 \r
 696   if(husart->State == HAL_USART_STATE_READY)\r
 697   {\r
 698     if((pTxData == NULL) || (pRxData == NULL) || (Size == 0))\r
 699     {\r
 700       return HAL_ERROR;\r
 701     }\r
 702     /* Process Locked */\r
 703     __HAL_LOCK(husart);\r
 704 \r
 705     husart->pRxBuffPtr = pRxData;\r
 706     husart->RxXferSize = Size;\r
 707     husart->RxXferCount = Size;\r
 708     husart->pTxBuffPtr = pTxData;\r
 709     husart->TxXferSize = Size;\r
 710     husart->TxXferCount = Size;\r
 711 \r
 712     /* Computation of USART mask to apply to RDR register */\r
 713     __HAL_USART_MASK_COMPUTATION(husart);\r
 714 \r
 715     husart->ErrorCode = HAL_USART_ERROR_NONE;\r
 716     husart->State = HAL_USART_STATE_BUSY_TX_RX;\r
 717 \r
 718     /* Enable the USART Data Register not empty Interrupt */\r
 719     __HAL_USART_ENABLE_IT(husart, USART_IT_RXNE);\r
 720 \r
 721     /* Enable the USART Parity Error Interrupt */\r
 722     __HAL_USART_ENABLE_IT(husart, USART_IT_PE);\r
 723 \r
 724     /* Enable the USART Error Interrupt: (Frame error, noise error, overrun error) */\r
 725     __HAL_USART_ENABLE_IT(husart, USART_IT_ERR);\r
 726 \r
 727     /* Process Unlocked */\r
 728     __HAL_UNLOCK(husart);\r
 729 \r
 730     /* Enable the USART Transmit Data Register Empty Interrupt */\r
 731     __HAL_USART_ENABLE_IT(husart, USART_IT_TXE);\r
 732 \r
 733     return HAL_OK;\r
 734   }\r
 735   else\r
 736   {\r
 737     return HAL_BUSY;\r
 738   }\r
 739 \r
 740 }\r
 741 \r
 742 /**\r
 743   * @brief Send an amount of data in DMA mode\r
 744   * @param husart: USART handle\r
 745   * @param pTxData: pointer to data buffer\r
 746   * @param Size: amount of data to be sent\r
 747   * @retval HAL status\r
 748   */\r
 749 HAL_StatusTypeDef HAL_USART_Transmit_DMA(USART_HandleTypeDef *husart, uint8_t *pTxData, uint16_t Size)\r
 750 {\r
 751   uint32_t *tmp;\r
 752 \r
 753   if(husart->State == HAL_USART_STATE_READY)\r
 754   {\r
 755     if((pTxData == NULL ) || (Size == 0))\r
 756     {\r
 757       return HAL_ERROR;\r
 758     }\r
 759     /* Process Locked */\r
 760     __HAL_LOCK(husart);\r
 761 \r
 762     husart->pTxBuffPtr = pTxData;\r
 763     husart->TxXferSize = Size;\r
 764     husart->TxXferCount = Size;\r
 765 \r
 766     husart->ErrorCode = HAL_USART_ERROR_NONE;\r
 767     husart->State = HAL_USART_STATE_BUSY_TX;\r
 768 \r
 769     /* Set the USART DMA transfer complete callback */\r
 770     husart->hdmatx->XferCpltCallback = USART_DMATransmitCplt;\r
 771 \r
 772     /* Set the USART DMA Half transfer complete callback */\r
 773     husart->hdmatx->XferHalfCpltCallback = USART_DMATxHalfCplt;\r
 774 \r
 775     /* Set the DMA error callback */\r
 776     husart->hdmatx->XferErrorCallback = USART_DMAError;\r
 777 \r
 778     /* Enable the USART transmit DMA channel */\r
 779     tmp = (uint32_t*)&pTxData;\r
 780     HAL_DMA_Start_IT(husart->hdmatx, *(uint32_t*)tmp, (uint32_t)&husart->Instance->TDR, Size);\r
 781 \r
 782 \r
 783     /* Clear the TC flag in the SR register by writing 0 to it */\r
 784     __HAL_USART_CLEAR_IT(husart, USART_FLAG_TC);\r
 785 \r
 786     /* Enable the DMA transfer for transmit request by setting the DMAT bit\r
 787        in the USART CR3 register */\r
 788     husart->Instance->CR3 |= USART_CR3_DMAT;\r
 789 \r
 790     /* Process Unlocked */\r
 791     __HAL_UNLOCK(husart);\r
 792 \r
 793     return HAL_OK;\r
 794   }\r
 795   else\r
 796   {\r
 797     return HAL_BUSY;\r
 798   }\r
 799 }\r
 800 \r
 801 /**\r
 802   * @brief Receive an amount of data in DMA mode\r
 803   * @param husart: USART handle\r
 804   * @param pRxData: pointer to data buffer\r
 805   * @param Size: amount of data to be received\r
 806   * @note   When the USART parity is enabled (PCE = 1), the received data contain\r
 807   *         the parity bit (MSB position)\r
 808   * @retval HAL status\r
 809   * @note The USART DMA transmit stream must be configured in order to generate the clock for the slave.\r
 810   */\r
 811 HAL_StatusTypeDef HAL_USART_Receive_DMA(USART_HandleTypeDef *husart, uint8_t *pRxData, uint16_t Size)\r
 812 {\r
 813   uint32_t *tmp;\r
 814 \r
 815   if(husart->State == HAL_USART_STATE_READY)\r
 816   {\r
 817     if((pRxData == NULL ) || (Size == 0))\r
 818     {\r
 819       return HAL_ERROR;\r
 820     }\r
 821 \r
 822     /* Process Locked */\r
 823     __HAL_LOCK(husart);\r
 824 \r
 825     husart->pRxBuffPtr = pRxData;\r
 826     husart->RxXferSize = Size;\r
 827     husart->pTxBuffPtr = pRxData;\r
 828     husart->TxXferSize = Size;\r
 829 \r
 830     husart->ErrorCode = HAL_USART_ERROR_NONE;\r
 831     husart->State = HAL_USART_STATE_BUSY_RX;\r
 832 \r
 833     /* Set the USART DMA Rx transfer complete callback */\r
 834     husart->hdmarx->XferCpltCallback = USART_DMAReceiveCplt;\r
 835 \r
 836     /* Set the USART DMA Half transfer complete callback */\r
 837     husart->hdmarx->XferHalfCpltCallback = USART_DMARxHalfCplt;\r
 838 \r
 839     /* Set the USART DMA Rx transfer error callback */\r
 840     husart->hdmarx->XferErrorCallback = USART_DMAError;\r
 841 \r
 842     /* Enable the USART receive DMA channel */\r
 843     tmp = (uint32_t*)&pRxData;\r
 844     HAL_DMA_Start_IT(husart->hdmarx, (uint32_t)&husart->Instance->RDR, *(uint32_t*)tmp, Size);\r
 845 \r
 846     /* Enable the USART transmit DMA channel: the transmit stream is used in order\r
 847        to generate in the non-blocking mode the clock to the slave device,\r
 848        this mode isn't a simplex receive mode but a full-duplex receive mode */\r
 849     tmp = (uint32_t*)&pRxData;\r
 850     HAL_DMA_Start_IT(husart->hdmatx, *(uint32_t*)tmp, (uint32_t)&husart->Instance->TDR, Size);\r
 851 \r
 852     /* Enable the DMA transfer for the receiver request by setting the DMAR bit\r
 853        in the USART CR3 register */\r
 854     husart->Instance->CR3 |= USART_CR3_DMAR;\r
 855 \r
 856     /* Enable the DMA transfer for transmit request by setting the DMAT bit\r
 857        in the USART CR3 register */\r
 858     husart->Instance->CR3 |= USART_CR3_DMAT;\r
 859 \r
 860     /* Process Unlocked */\r
 861     __HAL_UNLOCK(husart);\r
 862 \r
 863     return HAL_OK;\r
 864   }\r
 865   else\r
 866   {\r
 867     return HAL_BUSY;\r
 868   }\r
 869 }\r
 870 \r
 871 /**\r
 872   * @brief Full-Duplex Transmit Receive an amount of data in non blocking mode \r
 873   * @param husart: USART handle\r
 874   * @param pTxData: pointer to TX data buffer\r
 875   * @param pRxData: pointer to RX data buffer\r
 876   * @param Size: amount of data to be received/sent\r
 877   * @note   When the USART parity is enabled (PCE = 1) the data received contain the parity bit.\r
 878   * @retval HAL status\r
 879   */\r
 880 HAL_StatusTypeDef HAL_USART_TransmitReceive_DMA(USART_HandleTypeDef *husart, uint8_t *pTxData, uint8_t *pRxData, uint16_t Size)\r
 881 {\r
 882   uint32_t *tmp;\r
 883 \r
 884   if(husart->State == HAL_USART_STATE_READY)\r
 885   {\r
 886     if((pTxData == NULL) || (pRxData == NULL) || (Size == 0))\r
 887     {\r
 888       return HAL_ERROR;\r
 889     }\r
 890     /* Process Locked */\r
 891     __HAL_LOCK(husart);\r
 892 \r
 893     husart->pRxBuffPtr = pRxData;\r
 894     husart->RxXferSize = Size;\r
 895     husart->pTxBuffPtr = pTxData;\r
 896     husart->TxXferSize = Size;\r
 897 \r
 898     husart->ErrorCode = HAL_USART_ERROR_NONE;\r
 899     husart->State = HAL_USART_STATE_BUSY_TX_RX;\r
 900 \r
 901     /* Set the USART DMA Rx transfer complete callback */\r
 902     husart->hdmarx->XferCpltCallback = USART_DMAReceiveCplt;\r
 903 \r
 904     /* Set the USART DMA Half transfer complete callback */\r
 905     husart->hdmarx->XferHalfCpltCallback = USART_DMARxHalfCplt;\r
 906 \r
 907     /* Set the USART DMA Tx transfer complete callback */\r
 908     husart->hdmatx->XferCpltCallback = USART_DMATransmitCplt;\r
 909 \r
 910     /* Set the USART DMA Half transfer complete callback */\r
 911     husart->hdmatx->XferHalfCpltCallback = USART_DMATxHalfCplt;\r
 912 \r
 913     /* Set the USART DMA Tx transfer error callback */\r
 914     husart->hdmatx->XferErrorCallback = USART_DMAError;\r
 915 \r
 916     /* Set the USART DMA Rx transfer error callback */\r
 917     husart->hdmarx->XferErrorCallback = USART_DMAError;\r
 918 \r
 919     /* Enable the USART receive DMA channel */\r
 920     tmp = (uint32_t*)&pRxData;\r
 921     HAL_DMA_Start_IT(husart->hdmarx, (uint32_t)&husart->Instance->RDR, *(uint32_t*)tmp, Size);\r
 922 \r
 923     /* Enable the USART transmit DMA channel */\r
 924     tmp = (uint32_t*)&pTxData;\r
 925     HAL_DMA_Start_IT(husart->hdmatx, *(uint32_t*)tmp, (uint32_t)&husart->Instance->TDR, Size);\r
 926 \r
 927     /* Clear the TC flag in the SR register by writing 0 to it */\r
 928     __HAL_USART_CLEAR_IT(husart, USART_FLAG_TC);\r
 929 \r
 930     /* Enable the DMA transfer for the receiver request by setting the DMAR bit\r
 931        in the USART CR3 register */\r
 932     husart->Instance->CR3 |= USART_CR3_DMAR;\r
 933 \r
 934     /* Enable the DMA transfer for transmit request by setting the DMAT bit\r
 935        in the USART CR3 register */\r
 936     husart->Instance->CR3 |= USART_CR3_DMAT;\r
 937 \r
 938     /* Process Unlocked */\r
 939     __HAL_UNLOCK(husart);\r
 940 \r
 941     return HAL_OK;\r
 942   }\r
 943   else\r
 944   {\r
 945     return HAL_BUSY;\r
 946   }\r
 947 }\r
 948 \r
 949 /**\r
 950   * @brief Pauses the DMA Transfer.\r
 951   * @param husart: USART handle\r
 952   * @retval None\r
 953   */\r
 954 HAL_StatusTypeDef HAL_USART_DMAPause(USART_HandleTypeDef *husart)\r
 955 {\r
 956   /* Process Locked */\r
 957   __HAL_LOCK(husart);\r
 958 \r
 959   if(husart->State == HAL_USART_STATE_BUSY_TX)\r
 960   {\r
 961     /* Disable the USART DMA Tx request */\r
 962     husart->Instance->CR3 &= (uint32_t)(~USART_CR3_DMAT);\r
 963   }\r
 964   else if(husart->State == HAL_USART_STATE_BUSY_RX)\r
 965   {\r
 966     /* Disable the USART DMA Rx request */\r
 967     husart->Instance->CR3 &= (uint32_t)(~USART_CR3_DMAR);\r
 968   }\r
 969   else if(husart->State == HAL_USART_STATE_BUSY_TX_RX)\r
 970   {\r
 971     /* Disable the USART DMA Tx request */\r
 972     husart->Instance->CR3 &= (uint32_t)(~USART_CR3_DMAT);\r
 973     /* Disable the USART DMA Rx request */\r
 974     husart->Instance->CR3 &= (uint32_t)(~USART_CR3_DMAR);\r
 975   }\r
 976 \r
 977   /* Process Unlocked */\r
 978   __HAL_UNLOCK(husart);\r
 979 \r
 980   return HAL_OK;\r
 981 }\r
 982 \r
 983 /**\r
 984   * @brief Resumes the DMA Transfer.\r
 985   * @param husart: USART handle\r
 986   * @retval None\r
 987   */\r
 988 HAL_StatusTypeDef HAL_USART_DMAResume(USART_HandleTypeDef *husart)\r
 989 {\r
 990   /* Process Locked */\r
 991   __HAL_LOCK(husart);\r
 992 \r
 993   if(husart->State == HAL_USART_STATE_BUSY_TX)\r
 994   {\r
 995     /* Enable the USART DMA Tx request */\r
 996     husart->Instance->CR3 |= USART_CR3_DMAT;\r
 997   }\r
 998   else if(husart->State == HAL_USART_STATE_BUSY_RX)\r
 999   {\r
1000     /* Enable the USART DMA Rx request */\r
1001     husart->Instance->CR3 |= USART_CR3_DMAR;\r
1002   }\r
1003   else if(husart->State == HAL_USART_STATE_BUSY_TX_RX)\r
1004   {\r
1005     /* Enable the USART DMA Rx request  before the DMA Tx request */\r
1006     husart->Instance->CR3 |= USART_CR3_DMAR;\r
1007     /* Enable the USART DMA Tx request */\r
1008     husart->Instance->CR3 |= USART_CR3_DMAT;\r
1009   }\r
1010 \r
1011   /* If the USART peripheral is still not enabled, enable it */\r
1012   if((husart->Instance->CR1 & USART_CR1_UE) == 0)\r
1013   {\r
1014     /* Enable USART peripheral */\r
1015     __HAL_USART_ENABLE(husart);\r
1016   }\r
1017 \r
1018   /* Process Unlocked */\r
1019   __HAL_UNLOCK(husart);\r
1020 \r
1021   return HAL_OK;\r
1022 }\r
1023 \r
1024 /**\r
1025   * @brief Stops the DMA Transfer.\r
1026   * @param husart: USART handle\r
1027   * @retval None\r
1028   */\r
1029 HAL_StatusTypeDef HAL_USART_DMAStop(USART_HandleTypeDef *husart)\r
1030 {\r
1031   /* Process Locked */\r
1032   __HAL_LOCK(husart);\r
1033 \r
1034   /* Disable the USART Tx/Rx DMA requests */\r
1035   husart->Instance->CR3 &= ~USART_CR3_DMAT;\r
1036   husart->Instance->CR3 &= ~USART_CR3_DMAR;\r
1037 \r
1038   /* Abort the USART DMA tx Stream */\r
1039   if(husart->hdmatx != NULL)\r
1040   {\r
1041     HAL_DMA_Abort(husart->hdmatx);\r
1042   }\r
1043   /* Abort the USART DMA rx Stream */\r
1044   if(husart->hdmarx != NULL)\r
1045   {\r
1046     HAL_DMA_Abort(husart->hdmarx);\r
1047   }\r
1048 \r
1049   /* Disable USART peripheral */\r
1050   __HAL_USART_DISABLE(husart);\r
1051 \r
1052   husart->State = HAL_USART_STATE_READY;\r
1053 \r
1054   /* Process Unlocked */\r
1055   __HAL_UNLOCK(husart);\r
1056 \r
1057   return HAL_OK;\r
1058 }\r
1059 \r
1060 /**\r
1061   * @brief  This function handles USART interrupt request.\r
1062   * @param  husart: USART handle\r
1063   * @retval None\r
1064   */\r
1065 void HAL_USART_IRQHandler(USART_HandleTypeDef *husart)\r
1066 {\r
1067 \r
1068   /* USART parity error interrupt occurred ------------------------------------*/\r
1069   if((__HAL_USART_GET_IT(husart, USART_IT_PE) != RESET) && (__HAL_USART_GET_IT_SOURCE(husart, USART_IT_PE) != RESET))\r
1070   {\r
1071     __HAL_USART_CLEAR_IT(husart, USART_CLEAR_PEF);\r
1072     husart->ErrorCode |= HAL_USART_ERROR_PE;\r
1073     /* Set the USART state ready to be able to start again the process */\r
1074     husart->State = HAL_USART_STATE_READY;\r
1075   }\r
1076 \r
1077   /* USART frame error interrupt occurred -------------------------------------*/\r
1078   if((__HAL_USART_GET_IT(husart, USART_IT_FE) != RESET) && (__HAL_USART_GET_IT_SOURCE(husart, USART_IT_ERR) != RESET))\r
1079   {\r
1080     __HAL_USART_CLEAR_IT(husart, USART_CLEAR_FEF);\r
1081     husart->ErrorCode |= HAL_USART_ERROR_FE;\r
1082     /* Set the USART state ready to be able to start again the process */\r
1083     husart->State = HAL_USART_STATE_READY;\r
1084   }\r
1085 \r
1086   /* USART noise error interrupt occurred -------------------------------------*/\r
1087   if((__HAL_USART_GET_IT(husart, USART_IT_NE) != RESET) && (__HAL_USART_GET_IT_SOURCE(husart, USART_IT_ERR) != RESET))\r
1088   {\r
1089     __HAL_USART_CLEAR_IT(husart, USART_CLEAR_NEF);\r
1090     husart->ErrorCode |= HAL_USART_ERROR_NE;\r
1091     /* Set the USART state ready to be able to start again the process */\r
1092     husart->State = HAL_USART_STATE_READY;\r
1093   }\r
1094 \r
1095   /* USART Over-Run interrupt occurred ----------------------------------------*/\r
1096   if((__HAL_USART_GET_IT(husart, USART_IT_ORE) != RESET) && (__HAL_USART_GET_IT_SOURCE(husart, USART_IT_ERR) != RESET))\r
1097   {\r
1098     __HAL_USART_CLEAR_IT(husart, USART_CLEAR_OREF);\r
1099     husart->ErrorCode |= HAL_USART_ERROR_ORE;\r
1100     /* Set the USART state ready to be able to start again the process */\r
1101     husart->State = HAL_USART_STATE_READY;\r
1102   }\r
1103 \r
1104    /* Call USART Error Call back function if need be --------------------------*/\r
1105   if(husart->ErrorCode != HAL_USART_ERROR_NONE)\r
1106   {\r
1107     HAL_USART_ErrorCallback(husart);\r
1108   }\r
1109 \r
1110   /* USART in mode Receiver --------------------------------------------------*/\r
1111   if((__HAL_USART_GET_IT(husart, USART_IT_RXNE) != RESET) && (__HAL_USART_GET_IT_SOURCE(husart, USART_IT_RXNE) != RESET))\r
1112   {\r
1113     if(husart->State == HAL_USART_STATE_BUSY_RX)\r
1114     {\r
1115       USART_Receive_IT(husart);\r
1116     }\r
1117     else\r
1118     {\r
1119       USART_TransmitReceive_IT(husart);\r
1120     }\r
1121   }\r
1122 \r
1123   /* USART in mode Transmitter -----------------------------------------------*/\r
1124   if((__HAL_USART_GET_IT(husart, USART_IT_TXE) != RESET) &&(__HAL_USART_GET_IT_SOURCE(husart, USART_IT_TXE) != RESET))\r
1125   {\r
1126     if(husart->State == HAL_USART_STATE_BUSY_TX)\r
1127     {\r
1128       USART_Transmit_IT(husart);\r
1129     }\r
1130     else\r
1131     {\r
1132       USART_TransmitReceive_IT(husart);\r
1133     }\r
1134   }\r
1135 \r
1136 }\r
1137 \r
1138 /**\r
1139   * @brief Tx Transfer completed callbacks\r
1140   * @param husart: USART handle\r
1141   * @retval None\r
1142   */\r
1143 __weak void HAL_USART_TxCpltCallback(USART_HandleTypeDef *husart)\r
1144 {\r
1145   /* NOTE : This function should not be modified, when the callback is needed,\r
1146             the HAL_USART_TxCpltCallback can be implemented in the user file\r
1147    */ \r
1148 }\r
1149 \r
1150 /**\r
1151   * @brief  Tx Half Transfer completed callbacks.\r
1152   * @param  husart: USART handle\r
1153   * @retval None\r
1154   */\r
1155  __weak void HAL_USART_TxHalfCpltCallback(USART_HandleTypeDef *husart)\r
1156 {\r
1157   /* NOTE: This function should not be modified, when the callback is needed,\r
1158            the HAL_USART_TxHalfCpltCallback can be implemented in the user file\r
1159    */\r
1160 }\r
1161 \r
1162 /**\r
1163   * @brief  Rx Transfer completed callbacks.\r
1164   * @param  husart: USART handle\r
1165   * @retval None\r
1166   */\r
1167 __weak void HAL_USART_RxCpltCallback(USART_HandleTypeDef *husart)\r
1168 {\r
1169   /* NOTE: This function should not be modified, when the callback is needed,\r
1170            the HAL_USART_RxCpltCallback can be implemented in the user file\r
1171    */\r
1172 }\r
1173 \r
1174 /**\r
1175   * @brief Rx Half Transfer completed callbacks\r
1176   * @param husart: usart handle\r
1177   * @retval None\r
1178   */\r
1179 __weak void HAL_USART_RxHalfCpltCallback(USART_HandleTypeDef *husart)\r
1180 {\r
1181   /* NOTE : This function should not be modified, when the callback is needed,\r
1182             the HAL_USART_RxHalfCpltCallback can be implemented in the user file\r
1183    */\r
1184 }\r
1185 \r
1186 /**\r
1187   * @brief Tx/Rx Transfers completed callback for the non-blocking process\r
1188   * @param husart: USART handle\r
1189   * @retval None\r
1190   */\r
1191 __weak void HAL_USART_TxRxCpltCallback(USART_HandleTypeDef *husart)\r
1192 {\r
1193   /* NOTE : This function should not be modified, when the callback is needed,\r
1194             the HAL_USART_TxRxCpltCallback can be implemented in the user file\r
1195    */\r
1196 }\r
1197 \r
1198 /**\r
1199   * @brief USART error callbacks\r
1200   * @param husart: USART handle\r
1201   * @retval None\r
1202   */\r
1203 __weak void HAL_USART_ErrorCallback(USART_HandleTypeDef *husart)\r
1204 {\r
1205   /* NOTE : This function should not be modified, when the callback is needed,\r
1206             the HAL_USART_ErrorCallback can be implemented in the user file\r
1207    */ \r
1208 }\r
1209 \r
1210 /**\r
1211   * @}\r
1212   */\r
1213 \r
1214 /** @defgroup USART_Exported_Functions_Group3 Peripheral State and Errors functions \r
1215   *  @brief   USART State and Errors functions \r
1216   *\r
1217 @verbatim   \r
1218   ==============================================================================\r
1219                   ##### Peripheral State and Errors functions #####\r
1220   ==============================================================================  \r
1221   [..]\r
1222     This subsection provides a set of functions allowing to return the State of \r
1223     USART communication\r
1224     process, return Peripheral Errors occurred during communication process\r
1225      (+) HAL_USART_GetState() API can be helpful to check in run-time the state \r
1226          of the USART peripheral.\r
1227      (+) HAL_USART_GetError() check in run-time errors that could be occurred during \r
1228          communication. \r
1229 @endverbatim\r
1230   * @{\r
1231   */\r
1232 \r
1233 /**\r
1234   * @brief return the USART state\r
1235   * @param husart: USART handle\r
1236   * @retval HAL state\r
1237   */\r
1238 HAL_USART_StateTypeDef HAL_USART_GetState(USART_HandleTypeDef *husart)\r
1239 {\r
1240   return husart->State;\r
1241 }\r
1242 \r
1243 /**\r
1244   * @brief  Return the USART error code\r
1245   * @param  husart : pointer to a USART_HandleTypeDef structure that contains\r
1246   *              the configuration information for the specified USART.\r
1247   * @retval USART Error Code\r
1248   */\r
1249 uint32_t HAL_USART_GetError(USART_HandleTypeDef *husart)\r
1250 {\r
1251   return husart->ErrorCode;\r
1252 }\r
1253 \r
1254 /**\r
1255   * @}\r
1256   */\r
1257   \r
1258 \r
1259 /**\r
1260   * @brief  Simplex Send an amount of data in non-blocking mode.\r
1261   * @note   Function called under interruption only, once\r
1262   *         interruptions have been enabled by HAL_USART_Transmit_IT().\r
1263   * @param  husart: USART handle\r
1264   * @retval HAL status\r
1265   * @note   The USART errors are not managed to avoid the overrun error.\r
1266   */\r
1267 static HAL_StatusTypeDef USART_Transmit_IT(USART_HandleTypeDef *husart)\r
1268 {\r
1269   uint16_t* tmp;\r
1270 \r
1271   if(husart->State == HAL_USART_STATE_BUSY_TX)\r
1272   {\r
1273 \r
1274     if(husart->TxXferCount == 0)\r
1275     {\r
1276       /* Disable the USART Transmit Complete Interrupt */\r
1277       __HAL_USART_DISABLE_IT(husart, USART_IT_TXE);\r
1278 \r
1279       /* Disable the USART Error Interrupt: (Frame error, noise error, overrun error) */\r
1280       __HAL_USART_DISABLE_IT(husart, USART_IT_ERR);\r
1281 \r
1282       if(USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_TC, RESET, USART_TIMEOUT_VALUE) != HAL_OK)\r
1283       {\r
1284         return HAL_TIMEOUT;\r
1285       }\r
1286       husart->State = HAL_USART_STATE_READY;\r
1287 \r
1288       HAL_USART_TxCpltCallback(husart);\r
1289 \r
1290       return HAL_OK;\r
1291     }\r
1292     else\r
1293     {\r
1294       if((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE))\r
1295       {\r
1296         tmp = (uint16_t*) husart->pTxBuffPtr;\r
1297         husart->Instance->TDR = (*tmp & (uint16_t)0x01FF);   \r
1298         husart->pTxBuffPtr += 2;\r
1299       }\r
1300       else\r
1301       {\r
1302         husart->Instance->TDR = (uint8_t)(*husart->pTxBuffPtr++ & (uint8_t)0xFF);       \r
1303       }\r
1304 \r
1305       husart->TxXferCount--;\r
1306 \r
1307       return HAL_OK;\r
1308     }\r
1309   }\r
1310   else\r
1311   {\r
1312     return HAL_BUSY;\r
1313   }\r
1314 }\r
1315 \r
1316 /**\r
1317   * @brief  Simplex Receive an amount of data in non-blocking mode.\r
1318   *         Function called under interruption only, once\r
1319   *         interruptions have been enabled by HAL_USART_Receive_IT()\r
1320   * @param  husart: USART handle\r
1321   * @retval HAL status\r
1322   */\r
1323 static HAL_StatusTypeDef USART_Receive_IT(USART_HandleTypeDef *husart)\r
1324 {\r
1325   uint16_t* tmp;\r
1326   uint16_t uhMask = husart->Mask;\r
1327 \r
1328   if(husart->State == HAL_USART_STATE_BUSY_RX)\r
1329   {\r
1330 \r
1331     if((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE))\r
1332     {\r
1333       tmp = (uint16_t*) husart->pRxBuffPtr;\r
1334       *tmp = (uint16_t)(husart->Instance->RDR & uhMask);\r
1335       husart->pRxBuffPtr += 2;\r
1336     }\r
1337     else\r
1338     {\r
1339       *husart->pRxBuffPtr++ = (uint8_t)(husart->Instance->RDR & (uint8_t)uhMask);\r
1340     }\r
1341       /* Send dummy byte in order to generate the clock for the Slave to Send the next data */\r
1342       husart->Instance->TDR = (DUMMY_DATA & (uint16_t)0x00FF);\r
1343 \r
1344     if(--husart->RxXferCount == 0)\r
1345     {\r
1346       __HAL_USART_DISABLE_IT(husart, USART_IT_RXNE);\r
1347 \r
1348       /* Disable the USART Parity Error Interrupt */\r
1349       __HAL_USART_DISABLE_IT(husart, USART_IT_PE);\r
1350 \r
1351       /* Disable the USART Error Interrupt: (Frame error, noise error, overrun error) */\r
1352       __HAL_USART_DISABLE_IT(husart, USART_IT_ERR);\r
1353 \r
1354       husart->State = HAL_USART_STATE_READY;\r
1355 \r
1356       HAL_USART_RxCpltCallback(husart);\r
1357 \r
1358       return HAL_OK;\r
1359     }\r
1360 \r
1361     return HAL_OK;\r
1362   }\r
1363   else\r
1364   {\r
1365     return HAL_BUSY;\r
1366   }\r
1367 }\r
1368 \r
1369 /**\r
1370   * @brief  Full-Duplex Send receive an amount of data in full-duplex mode (non-blocking).\r
1371   *         Function called under interruption only, once\r
1372   *         interruptions have been enabled by HAL_USART_TransmitReceive_IT()     \r
1373   * @param  husart: USART handle\r
1374   * @retval HAL status\r
1375   */\r
1376 static HAL_StatusTypeDef USART_TransmitReceive_IT(USART_HandleTypeDef *husart)\r
1377 {\r
1378   uint16_t* tmp;\r
1379   uint16_t uhMask = husart->Mask;\r
1380 \r
1381   if(husart->State == HAL_USART_STATE_BUSY_TX_RX)\r
1382   {\r
1383     if(husart->TxXferCount != 0x00)\r
1384     {\r
1385       if(__HAL_USART_GET_FLAG(husart, USART_FLAG_TXE) != RESET)\r
1386       {\r
1387         if((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE))\r
1388         {\r
1389           tmp = (uint16_t*) husart->pTxBuffPtr;\r
1390           husart->Instance->TDR = (uint16_t)(*tmp & uhMask);\r
1391           husart->pTxBuffPtr += 2;\r
1392         }\r
1393         else\r
1394         {\r
1395           husart->Instance->TDR = (uint8_t)(*husart->pTxBuffPtr++ & (uint8_t)uhMask);\r
1396         }\r
1397         husart->TxXferCount--;\r
1398 \r
1399         /* Check the latest data transmitted */\r
1400         if(husart->TxXferCount == 0)\r
1401         {\r
1402            __HAL_USART_DISABLE_IT(husart, USART_IT_TXE);\r
1403         }\r
1404       }\r
1405     }\r
1406 \r
1407     if(husart->RxXferCount != 0x00)\r
1408     {\r
1409       if(__HAL_USART_GET_FLAG(husart, USART_FLAG_RXNE) != RESET)\r
1410       {\r
1411         if((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE))\r
1412         {\r
1413           tmp = (uint16_t*) husart->pRxBuffPtr;\r
1414           *tmp = (uint16_t)(husart->Instance->RDR & uhMask);\r
1415           husart->pRxBuffPtr += 2;\r
1416         }\r
1417         else\r
1418         {\r
1419           *husart->pRxBuffPtr++ = (uint8_t)(husart->Instance->RDR & (uint8_t)uhMask);\r
1420         }\r
1421         husart->RxXferCount--;\r
1422       }\r
1423     }\r
1424 \r
1425     /* Check the latest data received */\r
1426     if(husart->RxXferCount == 0)\r
1427     {\r
1428       __HAL_USART_DISABLE_IT(husart, USART_IT_RXNE);\r
1429 \r
1430       /* Disable the USART Parity Error Interrupt */\r
1431       __HAL_USART_DISABLE_IT(husart, USART_IT_PE);\r
1432 \r
1433       /* Disable the USART Error Interrupt: (Frame error, noise error, overrun error) */\r
1434       __HAL_USART_DISABLE_IT(husart, USART_IT_ERR);\r
1435 \r
1436       husart->State = HAL_USART_STATE_READY;\r
1437 \r
1438       HAL_USART_TxRxCpltCallback(husart);\r
1439 \r
1440       return HAL_OK;\r
1441     }\r
1442 \r
1443     return HAL_OK;\r
1444   }\r
1445   else\r
1446   {\r
1447     return HAL_BUSY;\r
1448   }\r
1449 }\r
1450 \r
1451 /**\r
1452   * @brief  This function handles USART Communication Timeout.\r
1453   * @param  husart: USART handle\r
1454   * @param  Flag: specifies the USART flag to check.\r
1455   * @param  Status: The new Flag status (SET or RESET).\r
1456   * @param  Timeout: Timeout duration\r
1457   * @retval HAL status\r
1458   */\r
1459 static HAL_StatusTypeDef USART_WaitOnFlagUntilTimeout(USART_HandleTypeDef *husart, uint32_t Flag, FlagStatus Status, uint32_t Timeout)  \r
1460 {\r
1461   uint32_t tickstart = HAL_GetTick();\r
1462 \r
1463   /* Wait until flag is set */\r
1464   if(Status == RESET)\r
1465   {\r
1466     while(__HAL_USART_GET_FLAG(husart, Flag) == RESET)\r
1467     {\r
1468       /* Check for the Timeout */\r
1469       if(Timeout != HAL_MAX_DELAY)\r
1470       {\r
1471         if((Timeout == 0)||((HAL_GetTick()-tickstart) >=  Timeout))\r
1472         {\r
1473           /* Disable TXE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts for the interrupt process */\r
1474           __HAL_USART_DISABLE_IT(husart, USART_IT_TXE);\r
1475           __HAL_USART_DISABLE_IT(husart, USART_IT_RXNE);\r
1476           __HAL_USART_DISABLE_IT(husart, USART_IT_PE);\r
1477           __HAL_USART_DISABLE_IT(husart, USART_IT_ERR);\r
1478 \r
1479           husart->State= HAL_USART_STATE_TIMEOUT;\r
1480 \r
1481           /* Process Unlocked */\r
1482           __HAL_UNLOCK(husart);\r
1483 \r
1484           return HAL_TIMEOUT;\r
1485         }\r
1486       }\r
1487     }\r
1488   }\r
1489   else\r
1490   {\r
1491     while(__HAL_USART_GET_FLAG(husart, Flag) != RESET)\r
1492     {\r
1493       /* Check for the Timeout */\r
1494       if(Timeout != HAL_MAX_DELAY)\r
1495       {\r
1496         if((Timeout == 0)||((HAL_GetTick()-tickstart) >=  Timeout))\r
1497         {\r
1498           /* Disable TXE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts for the interrupt process */\r
1499           __HAL_USART_DISABLE_IT(husart, USART_IT_TXE);\r
1500           __HAL_USART_DISABLE_IT(husart, USART_IT_RXNE);\r
1501           __HAL_USART_DISABLE_IT(husart, USART_IT_PE);\r
1502           __HAL_USART_DISABLE_IT(husart, USART_IT_ERR);\r
1503 \r
1504           husart->State= HAL_USART_STATE_TIMEOUT;\r
1505 \r
1506           /* Process Unlocked */\r
1507           __HAL_UNLOCK(husart);\r
1508 \r
1509           return HAL_TIMEOUT;\r
1510         }\r
1511       }\r
1512     }\r
1513   }\r
1514   return HAL_OK;\r
1515 }\r
1516 \r
1517 \r
1518 /**\r
1519   * @brief DMA USART transmit process complete callback\r
1520   * @param  hdma: DMA handle\r
1521   * @retval None\r
1522   */\r
1523 static void USART_DMATransmitCplt(DMA_HandleTypeDef *hdma)\r
1524 {\r
1525   USART_HandleTypeDef* husart = ( USART_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;\r
1526 \r
1527   husart->TxXferCount = 0;\r
1528   \r
1529   if(husart->State == HAL_USART_STATE_BUSY_TX)\r
1530   {\r
1531     /* Wait for USART TC Flag */\r
1532     if(USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_TC, RESET, USART_TXDMA_TIMEOUTVALUE) != HAL_OK)\r
1533     {\r
1534       /* Timeout occurred */ \r
1535       husart->State = HAL_USART_STATE_TIMEOUT;\r
1536       HAL_USART_ErrorCallback(husart);\r
1537     }\r
1538     else\r
1539     {\r
1540       /* No Timeout */\r
1541       /* Disable the DMA transfer for transmit request by setting the DMAT bit\r
1542        in the USART CR3 register */\r
1543       husart->Instance->CR3 &= ~(USART_CR3_DMAT);\r
1544       husart->State= HAL_USART_STATE_READY;\r
1545     }\r
1546   }\r
1547   /* the usart state is HAL_USART_STATE_BUSY_TX_RX*/\r
1548   else\r
1549   {\r
1550     husart->State= HAL_USART_STATE_BUSY_RX;\r
1551     HAL_USART_TxCpltCallback(husart);\r
1552   }\r
1553 }\r
1554 \r
1555 \r
1556 /**\r
1557   * @brief DMA USART transmit process half complete callback\r
1558   * @param hdma : DMA handle\r
1559   * @retval None\r
1560   */\r
1561 static void USART_DMATxHalfCplt(DMA_HandleTypeDef *hdma)\r
1562 {\r
1563   USART_HandleTypeDef* husart = (USART_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;\r
1564 \r
1565   HAL_USART_TxHalfCpltCallback(husart);\r
1566 }\r
1567 \r
1568 /**\r
1569   * @brief DMA USART receive process complete callback\r
1570   * @param  hdma: DMA handle\r
1571   * @retval None\r
1572   */\r
1573 static void USART_DMAReceiveCplt(DMA_HandleTypeDef *hdma)\r
1574 {\r
1575   USART_HandleTypeDef* husart = ( USART_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;\r
1576 \r
1577   husart->RxXferCount = 0;\r
1578 \r
1579   /* Disable the DMA RX transfer for the receiver request by resetting the DMAR bit\r
1580   in USART CR3 register */\r
1581   husart->Instance->CR3 &= (uint32_t)~((uint32_t)USART_CR3_DMAR);\r
1582   /* similarly, disable the DMA TX transfer that was started to provide the\r
1583      clock to the slave device */\r
1584   husart->Instance->CR3 &= (uint32_t)~((uint32_t)USART_CR3_DMAT);\r
1585 \r
1586   husart->State= HAL_USART_STATE_READY;\r
1587 \r
1588   HAL_USART_RxCpltCallback(husart);\r
1589 }\r
1590 \r
1591 /**\r
1592   * @brief DMA USART receive process half complete callback\r
1593   * @param hdma : DMA handle\r
1594   * @retval None\r
1595   */\r
1596 static void USART_DMARxHalfCplt(DMA_HandleTypeDef *hdma)\r
1597 {\r
1598   USART_HandleTypeDef* husart = (USART_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;\r
1599 \r
1600   HAL_USART_RxHalfCpltCallback(husart);\r
1601 }\r
1602 \r
1603 /**\r
1604   * @brief DMA USART communication error callback\r
1605   * @param  hdma: DMA handle\r
1606   * @retval None\r
1607   */\r
1608 static void USART_DMAError(DMA_HandleTypeDef *hdma)\r
1609 {\r
1610   USART_HandleTypeDef* husart = ( USART_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;\r
1611 \r
1612   husart->RxXferCount = 0;\r
1613   husart->TxXferCount = 0;\r
1614   husart->ErrorCode |= HAL_USART_ERROR_DMA;\r
1615   husart->State= HAL_USART_STATE_READY;\r
1616 \r
1617   HAL_USART_ErrorCallback(husart);\r
1618 }\r
1619 \r
1620 /**\r
1621   * @brief Configure the USART peripheral \r
1622   * @param husart: USART handle\r
1623   * @retval None\r
1624   */\r
1625 static HAL_StatusTypeDef USART_SetConfig(USART_HandleTypeDef *husart)\r
1626 {\r
1627   uint32_t tmpreg      = 0x0;\r
1628   USART_ClockSourceTypeDef clocksource = USART_CLOCKSOURCE_UNDEFINED;\r
1629   HAL_StatusTypeDef ret                = HAL_OK;\r
1630   \r
1631   /* Check the parameters */\r
1632   assert_param(IS_USART_POLARITY(husart->Init.CLKPolarity));\r
1633   assert_param(IS_USART_PHASE(husart->Init.CLKPhase));\r
1634   assert_param(IS_USART_LASTBIT(husart->Init.CLKLastBit));\r
1635   assert_param(IS_USART_BAUDRATE(husart->Init.BaudRate));  \r
1636   assert_param(IS_USART_WORD_LENGTH(husart->Init.WordLength));\r
1637   assert_param(IS_USART_STOPBITS(husart->Init.StopBits));\r
1638   assert_param(IS_USART_PARITY(husart->Init.Parity));\r
1639   assert_param(IS_USART_MODE(husart->Init.Mode));\r
1640   assert_param(IS_USART_OVERSAMPLING(husart->Init.OverSampling));   \r
1641 \r
1642 \r
1643   /*-------------------------- USART CR1 Configuration -----------------------*/\r
1644    /* Clear M, PCE, PS, TE and RE bits and configure       \r
1645    *  the USART Word Length, Parity, Mode and OverSampling: \r
1646    *  set the M bits according to husart->Init.WordLength value \r
1647    *  set PCE and PS bits according to husart->Init.Parity value\r
1648    *  set TE and RE bits according to husart->Init.Mode value\r
1649    *  force OVER8 to 1 to allow to reach the maximum speed (Fclock/8) */\r
1650   tmpreg = (uint32_t)husart->Init.WordLength | husart->Init.Parity | husart->Init.Mode | USART_CR1_OVER8;\r
1651   MODIFY_REG(husart->Instance->CR1, USART_CR1_FIELDS, tmpreg);\r
1652   \r
1653   /*---------------------------- USART CR2 Configuration ---------------------*/\r
1654   /* Clear and configure the USART Clock, CPOL, CPHA, LBCL and STOP bits:\r
1655    * set CPOL bit according to husart->Init.CLKPolarity value\r
1656    * set CPHA bit according to husart->Init.CLKPhase value\r
1657    * set LBCL bit according to husart->Init.CLKLastBit value\r
1658    * set STOP[13:12] bits according to husart->Init.StopBits value */\r
1659   tmpreg = (uint32_t)(USART_CLOCK_ENABLE); \r
1660   tmpreg |= ((uint32_t)husart->Init.CLKPolarity | (uint32_t)husart->Init.CLKPhase);\r
1661   tmpreg |= ((uint32_t)husart->Init.CLKLastBit | (uint32_t)husart->Init.StopBits);\r
1662   MODIFY_REG(husart->Instance->CR2, USART_CR2_FIELDS, tmpreg);\r
1663 \r
1664   /*-------------------------- USART CR3 Configuration -----------------------*/\r
1665   /* no CR3 register configuration                                            */\r
1666 \r
1667   /*-------------------------- USART BRR Configuration -----------------------*/\r
1668   /* BRR is filled-up according to OVER8 bit setting which is forced to 1     */\r
1669   USART_GETCLOCKSOURCE(husart, clocksource);\r
1670   switch (clocksource)\r
1671   {\r
1672   case USART_CLOCKSOURCE_PCLK1: \r
1673     husart->Instance->BRR = (uint16_t)(2*HAL_RCC_GetPCLK1Freq() / husart->Init.BaudRate);\r
1674     break;\r
1675   case USART_CLOCKSOURCE_PCLK2: \r
1676     husart->Instance->BRR = (uint16_t)(2*HAL_RCC_GetPCLK2Freq() / husart->Init.BaudRate);\r
1677     break;\r
1678   case USART_CLOCKSOURCE_HSI: \r
1679     husart->Instance->BRR = (uint16_t)(2*HSI_VALUE / husart->Init.BaudRate); \r
1680     break; \r
1681   case USART_CLOCKSOURCE_SYSCLK:  \r
1682     husart->Instance->BRR = (uint16_t)(2*HAL_RCC_GetSysClockFreq() / husart->Init.BaudRate);\r
1683     break;  \r
1684   case USART_CLOCKSOURCE_LSE:                \r
1685     husart->Instance->BRR = (uint16_t)(2*LSE_VALUE / husart->Init.BaudRate); \r
1686     break;\r
1687     case USART_CLOCKSOURCE_UNDEFINED:                \r
1688   default:\r
1689       ret = HAL_ERROR; \r
1690     break;    \r
1691   } \r
1692   \r
1693   return ret; \r
1694 }\r
1695 \r
1696 /**\r
1697   * @brief Check the USART Idle State\r
1698   * @param husart: USART handle\r
1699   * @retval HAL status\r
1700   */\r
1701 static HAL_StatusTypeDef USART_CheckIdleState(USART_HandleTypeDef *husart)\r
1702 {\r
1703    /* Initialize the USART ErrorCode */\r
1704   husart->ErrorCode = HAL_USART_ERROR_NONE;\r
1705   \r
1706   /* Check if the Transmitter is enabled */\r
1707   if((husart->Instance->CR1 & USART_CR1_TE) == USART_CR1_TE)\r
1708   {\r
1709     /* Wait until TEACK flag is set */\r
1710     if(USART_WaitOnFlagUntilTimeout(husart, USART_ISR_TEACK, RESET, TEACK_REACK_TIMEOUT) != HAL_OK)  \r
1711     { \r
1712       husart->State= HAL_USART_STATE_TIMEOUT;      \r
1713       return HAL_TIMEOUT;\r
1714     } \r
1715   }\r
1716   /* Check if the Receiver is enabled */\r
1717   if((husart->Instance->CR1 & USART_CR1_RE) == USART_CR1_RE)\r
1718   {\r
1719     /* Wait until REACK flag is set */\r
1720     if(USART_WaitOnFlagUntilTimeout(husart, USART_ISR_REACK, RESET, TEACK_REACK_TIMEOUT) != HAL_OK)  \r
1721     { \r
1722       husart->State= HAL_USART_STATE_TIMEOUT;       \r
1723       return HAL_TIMEOUT;\r
1724     }\r
1725   }\r
1726   \r
1727   /* Initialize the USART state*/\r
1728   husart->State= HAL_USART_STATE_READY;\r
1729   \r
1730   /* Process Unlocked */\r
1731   __HAL_UNLOCK(husart);\r
1732   \r
1733   return HAL_OK;  \r
1734 }\r
1735 \r
1736 /**\r
1737   * @}\r
1738   */\r
1739 \r
1740 #endif /* HAL_USART_MODULE_ENABLED */\r
1741 /**\r
1742   * @}\r
1743   */\r
1744 \r
1745 /**\r
1746   * @}\r
1747   */\r
1748 \r
1749 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/\r