tool/mbed/mbed-sdk/libraries/mbed/targets/cmsis/TARGET_STM/TARGET_STM32F1/stm32f1xx_hal_usart.c

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