WebSVN – canSerial – Diff – /trunk/Drivers/STM32F1xx_HAL_Driver/Src/stm32f1xx_hal_usart.c

 /**
   ******************************************************************************
   * @file    stm32f1xx_hal_usart.c
   * @author  MCD Application Team
   * @brief   USART HAL module driver.
   *          This file provides firmware functions to manage the following
   *          functionalities of the Universal Synchronous/Asynchronous Receiver Transmitter
   *          Peripheral (USART).
   *           + Initialization and de-initialization functions
   *           + IO operation functions
   *           + Peripheral Control functions
-  @verbatim
+  *
-  ==============================================================================
+  ******************************************************************************
-                        ##### How to use this driver #####
+  * @attention
-  ==============================================================================
+  *
-  [..]
+  * Copyright (c) 2016 STMicroelectronics.
-    The USART HAL driver can be used as follows:
+  * All rights reserved.
+  *
-    (#) Declare a USART_HandleTypeDef handle structure (eg. USART_HandleTypeDef husart).
+  * This software is licensed under terms that can be found in the LICENSE file
-    (#) Initialize the USART low level resources by implementing the HAL_USART_MspInit() API:
+  * in the root directory of this software component.
-        (##) Enable the USARTx interface clock.
+  * If no LICENSE file comes with this software, it is provided AS-IS.
-        (##) USART pins configuration:
+  *
-             (+++) Enable the clock for the USART GPIOs.
+  ******************************************************************************
-             (+++) Configure the USART pins as alternate function pull-up.
+  @verbatim
-        (##) NVIC configuration if you need to use interrupt process (HAL_USART_Transmit_IT(),
+  ==============================================================================
-             HAL_USART_Receive_IT() and HAL_USART_TransmitReceive_IT() APIs):
+                        ##### How to use this driver #####
-             (+++) Configure the USARTx interrupt priority.
+  ==============================================================================
-             (+++) Enable the NVIC USART IRQ handle.
+  [..]
-        (##) DMA Configuration if you need to use DMA process (HAL_USART_Transmit_DMA()
+    The USART HAL driver can be used as follows:
-             HAL_USART_Receive_DMA() and HAL_USART_TransmitReceive_DMA() APIs):
-             (+++) Declare a DMA handle structure for the Tx/Rx channel.
+    (#) Declare a USART_HandleTypeDef handle structure (eg. USART_HandleTypeDef husart).
-             (+++) Enable the DMAx interface clock.
+    (#) Initialize the USART low level resources by implementing the HAL_USART_MspInit() API:
-             (+++) Configure the declared DMA handle structure with the required Tx/Rx parameters.
+        (##) Enable the USARTx interface clock.
-             (+++) Configure the DMA Tx/Rx channel.
+        (##) USART pins configuration:
-             (+++) Associate the initialized DMA handle to the USART DMA Tx/Rx handle.
+             (+++) Enable the clock for the USART GPIOs.
-             (+++) Configure the priority and enable the NVIC for the transfer complete interrupt on the DMA Tx/Rx channel.
+             (+++) Configure the USART pins as alternate function pull-up.
-             (+++) Configure the USARTx interrupt priority and enable the NVIC USART IRQ handle
+        (##) NVIC configuration if you need to use interrupt process (HAL_USART_Transmit_IT(),
-                   (used for last byte sending completion detection in DMA non circular mode)
+             HAL_USART_Receive_IT() and HAL_USART_TransmitReceive_IT() APIs):
+             (+++) Configure the USARTx interrupt priority.
-    (#) Program the Baud Rate, Word Length, Stop Bit, Parity, Hardware
+             (+++) Enable the NVIC USART IRQ handle.
-        flow control and Mode(Receiver/Transmitter) in the husart Init structure.
+        (##) DMA Configuration if you need to use DMA process (HAL_USART_Transmit_DMA()
+             HAL_USART_Receive_DMA() and HAL_USART_TransmitReceive_DMA() APIs):
-    (#) Initialize the USART registers by calling the HAL_USART_Init() API:
+             (+++) Declare a DMA handle structure for the Tx/Rx channel.
-        (++) These APIs configures also the low level Hardware GPIO, CLOCK, CORTEX...etc)
+             (+++) Enable the DMAx interface clock.
-             by calling the customized HAL_USART_MspInit(&husart) API.
+             (+++) Configure the declared DMA handle structure with the required Tx/Rx parameters.
+             (+++) Configure the DMA Tx/Rx channel.
-        -@@- The specific USART interrupts (Transmission complete interrupt,
+             (+++) Associate the initialized DMA handle to the USART DMA Tx/Rx handle.
-             RXNE interrupt and Error Interrupts) will be managed using the macros
+             (+++) Configure the priority and enable the NVIC for the transfer complete interrupt on the DMA Tx/Rx channel.
-             __HAL_USART_ENABLE_IT() and __HAL_USART_DISABLE_IT() inside the transmit and receive process.
+             (+++) Configure the USARTx interrupt priority and enable the NVIC USART IRQ handle
+                   (used for last byte sending completion detection in DMA non circular mode)
-    (#) Three operation modes are available within this driver :
+    (#) Program the Baud Rate, Word Length, Stop Bit, Parity, Hardware
-     *** Polling mode IO operation ***
+        flow control and Mode(Receiver/Transmitter) in the husart Init structure.
-     =================================
-     [..]
+    (#) Initialize the USART registers by calling the HAL_USART_Init() API:
-       (+) Send an amount of data in blocking mode using HAL_USART_Transmit()
+        (++) These APIs configures also the low level Hardware GPIO, CLOCK, CORTEX...etc)
-       (+) Receive an amount of data in blocking mode using HAL_USART_Receive()
+             by calling the customized HAL_USART_MspInit(&husart) API.
-     *** Interrupt mode IO operation ***
+        -@@- The specific USART interrupts (Transmission complete interrupt,
-     ===================================
+             RXNE interrupt and Error Interrupts) will be managed using the macros
-     [..]
+             __HAL_USART_ENABLE_IT() and __HAL_USART_DISABLE_IT() inside the transmit and receive process.
-       (+) Send an amount of data in non blocking mode using HAL_USART_Transmit_IT()
-       (+) At transmission end of transfer HAL_USART_TxHalfCpltCallback is executed and user can
+    (#) Three operation modes are available within this driver :
-            add his own code by customization of function pointer HAL_USART_TxCpltCallback
-       (+) Receive an amount of data in non blocking mode using HAL_USART_Receive_IT()
+     *** Polling mode IO operation ***
-       (+) At reception end of transfer HAL_USART_RxCpltCallback is executed and user can
+     =================================
-            add his own code by customization of function pointer HAL_USART_RxCpltCallback
+     [..]
-       (+) In case of transfer Error, HAL_USART_ErrorCallback() function is executed and user can
+       (+) Send an amount of data in blocking mode using HAL_USART_Transmit()
-            add his own code by customization of function pointer HAL_USART_ErrorCallback
+       (+) Receive an amount of data in blocking mode using HAL_USART_Receive()
-     *** DMA mode IO operation ***
+     *** Interrupt mode IO operation ***
-     ==============================
+     ===================================
      [..]
-       (+) Send an amount of data in non blocking mode (DMA) using HAL_USART_Transmit_DMA()
+       (+) Send an amount of data in non blocking mode using HAL_USART_Transmit_IT()
-       (+) At transmission end of half transfer HAL_USART_TxHalfCpltCallback is executed and user can
+       (+) At transmission end of transfer HAL_USART_TxHalfCpltCallback is executed and user can
-            add his own code by customization of function pointer HAL_USART_TxHalfCpltCallback
+            add his own code by customization of function pointer HAL_USART_TxCpltCallback
-       (+) At transmission end of transfer HAL_USART_TxCpltCallback is executed and user can
+       (+) Receive an amount of data in non blocking mode using HAL_USART_Receive_IT()
-            add his own code by customization of function pointer HAL_USART_TxCpltCallback
+       (+) At reception end of transfer HAL_USART_RxCpltCallback is executed and user can
-       (+) Receive an amount of data in non blocking mode (DMA) using HAL_USART_Receive_DMA()
+            add his own code by customization of function pointer HAL_USART_RxCpltCallback
-       (+) At reception end of half transfer HAL_USART_RxHalfCpltCallback is executed and user can
+       (+) In case of transfer Error, HAL_USART_ErrorCallback() function is executed and user can
-            add his own code by customization of function pointer HAL_USART_RxHalfCpltCallback
+            add his own code by customization of function pointer HAL_USART_ErrorCallback
-       (+) At reception end of transfer HAL_USART_RxCpltCallback is executed and user can
-            add his own code by customization of function pointer HAL_USART_RxCpltCallback
+     *** DMA mode IO operation ***
-       (+) In case of transfer Error, HAL_USART_ErrorCallback() function is executed and user can
+     ==============================
-            add his own code by customization of function pointer HAL_USART_ErrorCallback
+     [..]
-       (+) Pause the DMA Transfer using HAL_USART_DMAPause()
+       (+) Send an amount of data in non blocking mode (DMA) using HAL_USART_Transmit_DMA()
-       (+) Resume the DMA Transfer using HAL_USART_DMAResume()
+       (+) At transmission end of half transfer HAL_USART_TxHalfCpltCallback is executed and user can
-       (+) Stop the DMA Transfer using HAL_USART_DMAStop()
+            add his own code by customization of function pointer HAL_USART_TxHalfCpltCallback
+       (+) At transmission end of transfer HAL_USART_TxCpltCallback is executed and user can
-     *** USART HAL driver macros list ***
+            add his own code by customization of function pointer HAL_USART_TxCpltCallback
-     =============================================
+       (+) Receive an amount of data in non blocking mode (DMA) using HAL_USART_Receive_DMA()
-     [..]
+       (+) At reception end of half transfer HAL_USART_RxHalfCpltCallback is executed and user can
-       Below the list of most used macros in USART HAL driver.
+            add his own code by customization of function pointer HAL_USART_RxHalfCpltCallback
+       (+) At reception end of transfer HAL_USART_RxCpltCallback is executed and user can
-       (+) __HAL_USART_ENABLE: Enable the USART peripheral
+            add his own code by customization of function pointer HAL_USART_RxCpltCallback
-       (+) __HAL_USART_DISABLE: Disable the USART peripheral
+       (+) In case of transfer Error, HAL_USART_ErrorCallback() function is executed and user can
-       (+) __HAL_USART_GET_FLAG : Check whether the specified USART flag is set or not
+            add his own code by customization of function pointer HAL_USART_ErrorCallback
-       (+) __HAL_USART_CLEAR_FLAG : Clear the specified USART pending flag
+       (+) Pause the DMA Transfer using HAL_USART_DMAPause()
-       (+) __HAL_USART_ENABLE_IT: Enable the specified USART interrupt
+       (+) Resume the DMA Transfer using HAL_USART_DMAResume()
-       (+) __HAL_USART_DISABLE_IT: Disable the specified USART interrupt
+       (+) Stop the DMA Transfer using HAL_USART_DMAStop()
-     [..]
+     *** USART HAL driver macros list ***
-       (@) You can refer to the USART HAL driver header file for more useful macros
+     =============================================
+     [..]
-    ##### Callback registration #####
+       Below the list of most used macros in USART HAL driver.
-    ==================================
+       (+) __HAL_USART_ENABLE: Enable the USART peripheral
-    [..]
+       (+) __HAL_USART_DISABLE: Disable the USART peripheral
-    The compilation define USE_HAL_USART_REGISTER_CALLBACKS when set to 1
+       (+) __HAL_USART_GET_FLAG : Check whether the specified USART flag is set or not
-    allows the user to configure dynamically the driver callbacks.
+       (+) __HAL_USART_CLEAR_FLAG : Clear the specified USART pending flag
+       (+) __HAL_USART_ENABLE_IT: Enable the specified USART interrupt
-    [..]
+       (+) __HAL_USART_DISABLE_IT: Disable the specified USART interrupt
-    Use Function @ref HAL_USART_RegisterCallback() to register a user callback.
-    Function @ref HAL_USART_RegisterCallback() allows to register following callbacks:
+     [..]
-    (+) TxHalfCpltCallback        : Tx Half Complete Callback.
+       (@) You can refer to the USART HAL driver header file for more useful macros
-    (+) TxCpltCallback            : Tx Complete Callback.
-    (+) RxHalfCpltCallback        : Rx Half Complete Callback.
+    ##### Callback registration #####
-    (+) RxCpltCallback            : Rx Complete Callback.
+    ==================================
-    (+) TxRxCpltCallback          : Tx Rx Complete Callback.
-    (+) ErrorCallback             : Error Callback.
+    [..]
-    (+) AbortCpltCallback         : Abort Complete Callback.
+    The compilation define USE_HAL_USART_REGISTER_CALLBACKS when set to 1
-    (+) MspInitCallback           : USART MspInit.
+    allows the user to configure dynamically the driver callbacks.
-    (+) MspDeInitCallback         : USART MspDeInit.
-    This function takes as parameters the HAL peripheral handle, the Callback ID
+    [..]
-    and a pointer to the user callback function.
+    Use Function @ref HAL_USART_RegisterCallback() to register a user callback.
+    Function @ref HAL_USART_RegisterCallback() allows to register following callbacks:
-    [..]
+    (+) TxHalfCpltCallback        : Tx Half Complete Callback.
-    Use function @ref HAL_USART_UnRegisterCallback() to reset a callback to the default
+    (+) TxCpltCallback            : Tx Complete Callback.
-    weak (surcharged) function.
+    (+) RxHalfCpltCallback        : Rx Half Complete Callback.
-    @ref HAL_USART_UnRegisterCallback() takes as parameters the HAL peripheral handle,
+    (+) RxCpltCallback            : Rx Complete Callback.
-    and the Callback ID.
+    (+) TxRxCpltCallback          : Tx Rx Complete Callback.
-    This function allows to reset following callbacks:
+    (+) ErrorCallback             : Error Callback.
-    (+) TxHalfCpltCallback        : Tx Half Complete Callback.
+    (+) AbortCpltCallback         : Abort Complete Callback.
-    (+) TxCpltCallback            : Tx Complete Callback.
+    (+) MspInitCallback           : USART MspInit.
-    (+) RxHalfCpltCallback        : Rx Half Complete Callback.
+    (+) MspDeInitCallback         : USART MspDeInit.
-    (+) RxCpltCallback            : Rx Complete Callback.
+    This function takes as parameters the HAL peripheral handle, the Callback ID
-    (+) TxRxCpltCallback          : Tx Rx Complete Callback.
+    and a pointer to the user callback function.
-    (+) ErrorCallback             : Error Callback.
-    (+) AbortCpltCallback         : Abort Complete Callback.
+    [..]
-    (+) MspInitCallback           : USART MspInit.
+    Use function @ref HAL_USART_UnRegisterCallback() to reset a callback to the default
-    (+) MspDeInitCallback         : USART MspDeInit.
+    weak (surcharged) function.
+    @ref HAL_USART_UnRegisterCallback() takes as parameters the HAL peripheral handle,
-    [..]
+    and the Callback ID.
-    By default, after the @ref HAL_USART_Init() and when the state is HAL_USART_STATE_RESET
+    This function allows to reset following callbacks:
-    all callbacks are set to the corresponding weak (surcharged) functions:
+    (+) TxHalfCpltCallback        : Tx Half Complete Callback.
-    examples @ref HAL_USART_TxCpltCallback(), @ref HAL_USART_RxHalfCpltCallback().
+    (+) TxCpltCallback            : Tx Complete Callback.
-    Exception done for MspInit and MspDeInit functions that are respectively
+    (+) RxHalfCpltCallback        : Rx Half Complete Callback.
-    reset to the legacy weak (surcharged) functions in the @ref HAL_USART_Init()
+    (+) RxCpltCallback            : Rx Complete Callback.
-    and @ref HAL_USART_DeInit() only when these callbacks are null (not registered beforehand).
+    (+) TxRxCpltCallback          : Tx Rx Complete Callback.
-    If not, MspInit or MspDeInit are not null, the @ref HAL_USART_Init() and @ref HAL_USART_DeInit()
+    (+) ErrorCallback             : Error Callback.
-    keep and use the user MspInit/MspDeInit callbacks (registered beforehand).
+    (+) AbortCpltCallback         : Abort Complete Callback.
+    (+) MspInitCallback           : USART MspInit.
-    [..]
+    (+) MspDeInitCallback         : USART MspDeInit.
-    Callbacks can be registered/unregistered in HAL_USART_STATE_READY state only.
-    Exception done MspInit/MspDeInit that can be registered/unregistered
+    [..]
-    in HAL_USART_STATE_READY or HAL_USART_STATE_RESET state, thus registered (user)
+    By default, after the @ref HAL_USART_Init() and when the state is HAL_USART_STATE_RESET
-    MspInit/DeInit callbacks can be used during the Init/DeInit.
+    all callbacks are set to the corresponding weak (surcharged) functions:
-    In that case first register the MspInit/MspDeInit user callbacks
+    examples @ref HAL_USART_TxCpltCallback(), @ref HAL_USART_RxHalfCpltCallback().
-    using @ref HAL_USART_RegisterCallback() before calling @ref HAL_USART_DeInit()
+    Exception done for MspInit and MspDeInit functions that are respectively
-    or @ref HAL_USART_Init() function.
+    reset to the legacy weak (surcharged) functions in the @ref HAL_USART_Init()
+    and @ref HAL_USART_DeInit() only when these callbacks are null (not registered beforehand).
-    [..]
+    If not, MspInit or MspDeInit are not null, the @ref HAL_USART_Init() and @ref HAL_USART_DeInit()
-    When The compilation define USE_HAL_USART_REGISTER_CALLBACKS is set to 0 or
+    keep and use the user MspInit/MspDeInit callbacks (registered beforehand).
-    not defined, the callback registration feature is not available
-    and weak (surcharged) callbacks are used.
+    [..]
+    Callbacks can be registered/unregistered in HAL_USART_STATE_READY state only.
-  @endverbatim
+    Exception done MspInit/MspDeInit that can be registered/unregistered
-     [..]
+    in HAL_USART_STATE_READY or HAL_USART_STATE_RESET state, thus registered (user)
-       (@) Additional remark: If the parity is enabled, then the MSB bit of the data written
+    MspInit/DeInit callbacks can be used during the Init/DeInit.
-           in the data register is transmitted but is changed by the parity bit.
+    In that case first register the MspInit/MspDeInit user callbacks
-           Depending on the frame length defined by the M bit (8-bits or 9-bits),
+    using @ref HAL_USART_RegisterCallback() before calling @ref HAL_USART_DeInit()
-           the possible USART frame formats are as listed in the following table:
+    or @ref HAL_USART_Init() function.
-    +-------------------------------------------------------------+
-    |   M bit |  PCE bit  |            USART frame                 |
+    [..]
-    |---------------------|---------------------------------------|
+    When The compilation define USE_HAL_USART_REGISTER_CALLBACKS is set to 0 or
-    |    0    |    0      |    | SB | 8 bit data | STB |          |
+    not defined, the callback registration feature is not available
-    |---------|-----------|---------------------------------------|
+    and weak (surcharged) callbacks are used.
-    |    0    |    1      |    | SB | 7 bit data | PB | STB |     |
-    |---------|-----------|---------------------------------------|
+  @endverbatim
-    |    1    |    0      |    | SB | 9 bit data | STB |          |
+     [..]
-    |---------|-----------|---------------------------------------|
+       (@) Additional remark: If the parity is enabled, then the MSB bit of the data written
-    |    1    |    1      |    | SB | 8 bit data | PB | STB |     |
+           in the data register is transmitted but is changed by the parity bit.
-    +-------------------------------------------------------------+
+           Depending on the frame length defined by the M bit (8-bits or 9-bits),
-  ******************************************************************************
+           the possible USART frame formats are as listed in the following table:
-  * @attention
+    +-------------------------------------------------------------+
-  *
+    |   M bit |  PCE bit  |            USART frame                 |
-  * <h2><center>&copy; Copyright (c) 2016 STMicroelectronics.
+    |---------------------|---------------------------------------|
-  * All rights reserved.</center></h2>
+    |    0    |    0      |    | SB | 8 bit data | STB |          |
-  *
+    |---------|-----------|---------------------------------------|
-  * This software component is licensed by ST under BSD 3-Clause license,
+    |    0    |    1      |    | SB | 7 bit data | PB | STB |     |
-  * the "License"; You may not use this file except in compliance with the
+    |---------|-----------|---------------------------------------|
-  * License. You may obtain a copy of the License at:
+    |    1    |    0      |    | SB | 9 bit data | STB |          |
-  *                        opensource.org/licenses/BSD-3-Clause
+    |---------|-----------|---------------------------------------|
-  *
+    |    1    |    1      |    | SB | 8 bit data | PB | STB |     |
-  ******************************************************************************
+    +-------------------------------------------------------------+
-  */
+  ******************************************************************************
+  */
-/* Includes ------------------------------------------------------------------*/
-#include "stm32f1xx_hal.h"
+/* Includes ------------------------------------------------------------------*/
+#include "stm32f1xx_hal.h"
-/** @addtogroup STM32F1xx_HAL_Driver
-  * @{
+/** @addtogroup STM32F1xx_HAL_Driver
-  */
+  * @{
+  */
-/** @defgroup USART USART
-  * @brief HAL USART Synchronous module driver
+/** @defgroup USART USART
-  * @{
+  * @brief HAL USART Synchronous module driver
-  */
+  * @{
-#ifdef HAL_USART_MODULE_ENABLED
+  */
-/* Private typedef -----------------------------------------------------------*/
+#ifdef HAL_USART_MODULE_ENABLED
-/* Private define ------------------------------------------------------------*/
+/* Private typedef -----------------------------------------------------------*/
-/** @addtogroup USART_Private_Constants
+/* Private define ------------------------------------------------------------*/
-  * @{
+/** @addtogroup USART_Private_Constants
-  */
+  * @{
-#define DUMMY_DATA           0xFFFFU
+  */
-#define USART_TIMEOUT_VALUE  22000U
+#define DUMMY_DATA           0xFFFFU
-/**
+#define USART_TIMEOUT_VALUE  22000U
-  * @}
+/**
-  */
+  * @}
-/* Private macro -------------------------------------------------------------*/
+  */
-/* Private variables ---------------------------------------------------------*/
+/* Private macro -------------------------------------------------------------*/
-/* Private function prototypes -----------------------------------------------*/
+/* Private variables ---------------------------------------------------------*/
-/* Private functions ---------------------------------------------------------*/
+/* Private function prototypes -----------------------------------------------*/
-/** @addtogroup USART_Private_Functions
+/* Private functions ---------------------------------------------------------*/
-  * @{
+/** @addtogroup USART_Private_Functions
-  */
+  * @{
-#if (USE_HAL_USART_REGISTER_CALLBACKS == 1)
+  */
-void USART_InitCallbacksToDefault(USART_HandleTypeDef *husart);
+#if (USE_HAL_USART_REGISTER_CALLBACKS == 1)
-#endif /* USE_HAL_USART_REGISTER_CALLBACKS */
+void USART_InitCallbacksToDefault(USART_HandleTypeDef *husart);
-static void USART_EndTxTransfer(USART_HandleTypeDef *husart);
+#endif /* USE_HAL_USART_REGISTER_CALLBACKS */
-static void USART_EndRxTransfer(USART_HandleTypeDef *husart);
+static void USART_EndTxTransfer(USART_HandleTypeDef *husart);
-static HAL_StatusTypeDef USART_Transmit_IT(USART_HandleTypeDef *husart);
+static void USART_EndRxTransfer(USART_HandleTypeDef *husart);
-static HAL_StatusTypeDef USART_EndTransmit_IT(USART_HandleTypeDef *husart);
+static HAL_StatusTypeDef USART_Transmit_IT(USART_HandleTypeDef *husart);
-static HAL_StatusTypeDef USART_Receive_IT(USART_HandleTypeDef *husart);
+static HAL_StatusTypeDef USART_EndTransmit_IT(USART_HandleTypeDef *husart);
-static HAL_StatusTypeDef USART_TransmitReceive_IT(USART_HandleTypeDef *husart);
+static HAL_StatusTypeDef USART_Receive_IT(USART_HandleTypeDef *husart);
-static void USART_SetConfig(USART_HandleTypeDef *husart);
+static HAL_StatusTypeDef USART_TransmitReceive_IT(USART_HandleTypeDef *husart);
-static void USART_DMATransmitCplt(DMA_HandleTypeDef *hdma);
+static void USART_SetConfig(USART_HandleTypeDef *husart);
-static void USART_DMATxHalfCplt(DMA_HandleTypeDef *hdma);
+static void USART_DMATransmitCplt(DMA_HandleTypeDef *hdma);
-static void USART_DMAReceiveCplt(DMA_HandleTypeDef *hdma);
+static void USART_DMATxHalfCplt(DMA_HandleTypeDef *hdma);
-static void USART_DMARxHalfCplt(DMA_HandleTypeDef *hdma);
+static void USART_DMAReceiveCplt(DMA_HandleTypeDef *hdma);
-static void USART_DMAError(DMA_HandleTypeDef *hdma);
+static void USART_DMARxHalfCplt(DMA_HandleTypeDef *hdma);
-static void USART_DMAAbortOnError(DMA_HandleTypeDef *hdma);
+static void USART_DMAError(DMA_HandleTypeDef *hdma);
-static void USART_DMATxAbortCallback(DMA_HandleTypeDef *hdma);
+static void USART_DMAAbortOnError(DMA_HandleTypeDef *hdma);
-static void USART_DMARxAbortCallback(DMA_HandleTypeDef *hdma);
+static void USART_DMATxAbortCallback(DMA_HandleTypeDef *hdma);
+static void USART_DMARxAbortCallback(DMA_HandleTypeDef *hdma);
-static HAL_StatusTypeDef USART_WaitOnFlagUntilTimeout(USART_HandleTypeDef *husart, uint32_t Flag, FlagStatus Status, uint32_t Tickstart, uint32_t Timeout);
-/**
+static HAL_StatusTypeDef USART_WaitOnFlagUntilTimeout(USART_HandleTypeDef *husart, uint32_t Flag, FlagStatus Status,
-  * @}
+                                                      uint32_t Tickstart, uint32_t Timeout);
-  */
+/**
+  * @}
-/* Exported functions --------------------------------------------------------*/
+  */
-/** @defgroup USART_Exported_Functions USART Exported Functions
-  * @{
+/* Exported functions --------------------------------------------------------*/
-  */
+/** @defgroup USART_Exported_Functions USART Exported Functions
+  * @{
-/** @defgroup USART_Exported_Functions_Group1 USART Initialization and de-initialization functions
+  */
-  *  @brief    Initialization and Configuration functions
-  *
+/** @defgroup USART_Exported_Functions_Group1 USART Initialization and de-initialization functions
-@verbatim
+  *  @brief    Initialization and Configuration functions
-  ==============================================================================
+  *
-              ##### Initialization and Configuration functions #####
+@verbatim
   ==============================================================================
-  [..]
+              ##### Initialization and Configuration functions #####
-  This subsection provides a set of functions allowing to initialize the USART
+  ==============================================================================
-  in asynchronous and in synchronous modes.
+  [..]
-  (+) For the asynchronous mode only these parameters can be configured:
+  This subsection provides a set of functions allowing to initialize the USART
-      (++) Baud Rate
+  in asynchronous and in synchronous modes.
-      (++) Word Length
+  (+) For the asynchronous mode only these parameters can be configured:
-      (++) Stop Bit
+      (++) Baud Rate
-      (++) Parity: If the parity is enabled, then the MSB bit of the data written
+      (++) Word Length
-           in the data register is transmitted but is changed by the parity bit.
+      (++) Stop Bit
-           Depending on the frame length defined by the M bit (8-bits or 9-bits),
+      (++) Parity: If the parity is enabled, then the MSB bit of the data written
-           please refer to Reference manual for possible USART frame formats.
+           in the data register is transmitted but is changed by the parity bit.
-      (++) USART polarity
+           Depending on the frame length defined by the M bit (8-bits or 9-bits),
-      (++) USART phase
+           please refer to Reference manual for possible USART frame formats.
-      (++) USART LastBit
+      (++) USART polarity
-      (++) Receiver/transmitter modes
+      (++) USART phase
+      (++) USART LastBit
-  [..]
+      (++) Receiver/transmitter modes
-    The HAL_USART_Init() function follows the USART  synchronous configuration
-    procedures (details for the procedures are available in reference manuals
+  [..]
-    (RM0008 for STM32F10Xxx MCUs and RM0041 for STM32F100xx MCUs)).
+    The HAL_USART_Init() function follows the USART  synchronous configuration
+    procedures (details for the procedures are available in reference manuals
-@endverbatim
+    (RM0008 for STM32F10Xxx MCUs and RM0041 for STM32F100xx MCUs)).
-  * @{
-  */
+@endverbatim
+  * @{
-/**
+  */
-  * @brief  Initialize the USART mode according to the specified
-  *         parameters in the USART_InitTypeDef and initialize the associated handle.
+/**
-  * @param  husart Pointer to a USART_HandleTypeDef structure that contains
+  * @brief  Initialize the USART mode according to the specified
-  *                the configuration information for the specified USART module.
+  *         parameters in the USART_InitTypeDef and initialize the associated handle.
-  * @retval HAL status
+  * @param  husart Pointer to a USART_HandleTypeDef structure that contains
-  */
+  *                the configuration information for the specified USART module.
-HAL_StatusTypeDef HAL_USART_Init(USART_HandleTypeDef *husart)
+  * @retval HAL status
-{
+  */
-  /* Check the USART handle allocation */
+HAL_StatusTypeDef HAL_USART_Init(USART_HandleTypeDef *husart)
-  if (husart == NULL)
+{
-  {
+  /* Check the USART handle allocation */
-    return HAL_ERROR;
+  if (husart == NULL)
-  }
+  {
+    return HAL_ERROR;
-  /* Check the parameters */
+  }
-  assert_param(IS_USART_INSTANCE(husart->Instance));
+  /* Check the parameters */
-  if (husart->State == HAL_USART_STATE_RESET)
+  assert_param(IS_USART_INSTANCE(husart->Instance));
-  {
-    /* Allocate lock resource and initialize it */
+  if (husart->State == HAL_USART_STATE_RESET)
-    husart->Lock = HAL_UNLOCKED;
+  {
+    /* Allocate lock resource and initialize it */
-#if (USE_HAL_USART_REGISTER_CALLBACKS == 1)
+    husart->Lock = HAL_UNLOCKED;
-    USART_InitCallbacksToDefault(husart);
+#if (USE_HAL_USART_REGISTER_CALLBACKS == 1)
-    if (husart->MspInitCallback == NULL)
+    USART_InitCallbacksToDefault(husart);
-    {
-      husart->MspInitCallback = HAL_USART_MspInit;
+    if (husart->MspInitCallback == NULL)
-    }
+    {
+      husart->MspInitCallback = HAL_USART_MspInit;
-    /* Init the low level hardware */
+    }
-    husart->MspInitCallback(husart);
-#else
+    /* Init the low level hardware */
-    /* Init the low level hardware : GPIO, CLOCK */
+    husart->MspInitCallback(husart);
-    HAL_USART_MspInit(husart);
+#else
-#endif /* USE_HAL_USART_REGISTER_CALLBACKS */
+    /* Init the low level hardware : GPIO, CLOCK */
-  }
+    HAL_USART_MspInit(husart);
+#endif /* USE_HAL_USART_REGISTER_CALLBACKS */
-  husart->State = HAL_USART_STATE_BUSY;
+  }
-  /* Set the USART Communication parameters */
+  husart->State = HAL_USART_STATE_BUSY;
-  USART_SetConfig(husart);
+  /* Set the USART Communication parameters */
-  /* In USART mode, the following bits must be kept cleared:
+  USART_SetConfig(husart);
-     - LINEN bit in the USART_CR2 register
-     - HDSEL, SCEN and IREN bits in the USART_CR3 register */
+  /* In USART mode, the following bits must be kept cleared:
-  CLEAR_BIT(husart->Instance->CR2, USART_CR2_LINEN);
+     - LINEN bit in the USART_CR2 register
-  CLEAR_BIT(husart->Instance->CR3, (USART_CR3_SCEN | USART_CR3_HDSEL | USART_CR3_IREN));
+     - HDSEL, SCEN and IREN bits in the USART_CR3 register */
+  CLEAR_BIT(husart->Instance->CR2, USART_CR2_LINEN);
-  /* Enable the Peripheral */
+  CLEAR_BIT(husart->Instance->CR3, (USART_CR3_SCEN | USART_CR3_HDSEL | USART_CR3_IREN));
-  __HAL_USART_ENABLE(husart);
+  /* Enable the Peripheral */
-  /* Initialize the USART state */
+  __HAL_USART_ENABLE(husart);
-  husart->ErrorCode = HAL_USART_ERROR_NONE;
-  husart->State = HAL_USART_STATE_READY;
+  /* Initialize the USART state */
+  husart->ErrorCode = HAL_USART_ERROR_NONE;
-  return HAL_OK;
+  husart->State = HAL_USART_STATE_READY;
-}
+  return HAL_OK;
-/**
+}
-  * @brief  DeInitializes the USART peripheral.
-  * @param  husart Pointer to a USART_HandleTypeDef structure that contains
+/**
-  *                the configuration information for the specified USART module.
+  * @brief  DeInitializes the USART peripheral.
-  * @retval HAL status
+  * @param  husart Pointer to a USART_HandleTypeDef structure that contains
-  */
+  *                the configuration information for the specified USART module.
-HAL_StatusTypeDef HAL_USART_DeInit(USART_HandleTypeDef *husart)
+  * @retval HAL status
-{
+  */
-  /* Check the USART handle allocation */
+HAL_StatusTypeDef HAL_USART_DeInit(USART_HandleTypeDef *husart)
-  if (husart == NULL)
+{
-  {
+  /* Check the USART handle allocation */
-    return HAL_ERROR;
+  if (husart == NULL)
-  }
+  {
+    return HAL_ERROR;
-  /* Check the parameters */
+  }
-  assert_param(IS_USART_INSTANCE(husart->Instance));
+  /* Check the parameters */
-  husart->State = HAL_USART_STATE_BUSY;
+  assert_param(IS_USART_INSTANCE(husart->Instance));
-  /* Disable the Peripheral */
+  husart->State = HAL_USART_STATE_BUSY;
-  __HAL_USART_DISABLE(husart);
+  /* Disable the Peripheral */
-#if (USE_HAL_USART_REGISTER_CALLBACKS == 1)
+  __HAL_USART_DISABLE(husart);
-  if (husart->MspDeInitCallback == NULL)
-  {
+#if (USE_HAL_USART_REGISTER_CALLBACKS == 1)
-    husart->MspDeInitCallback = HAL_USART_MspDeInit;
+  if (husart->MspDeInitCallback == NULL)
-  }
+  {
-  /* DeInit the low level hardware */
+    husart->MspDeInitCallback = HAL_USART_MspDeInit;
-  husart->MspDeInitCallback(husart);
+  }
-#else
+  /* DeInit the low level hardware */
-  /* DeInit the low level hardware */
+  husart->MspDeInitCallback(husart);
-  HAL_USART_MspDeInit(husart);
+#else
-#endif /* USE_HAL_USART_REGISTER_CALLBACKS */
+  /* DeInit the low level hardware */
+  HAL_USART_MspDeInit(husart);
-  husart->ErrorCode = HAL_USART_ERROR_NONE;
+#endif /* USE_HAL_USART_REGISTER_CALLBACKS */
-  husart->State = HAL_USART_STATE_RESET;
+  husart->ErrorCode = HAL_USART_ERROR_NONE;
-  /* Release Lock */
+  husart->State = HAL_USART_STATE_RESET;
-  __HAL_UNLOCK(husart);
+  /* Release Lock */
-  return HAL_OK;
+  __HAL_UNLOCK(husart);
-}
+  return HAL_OK;
-/**
+}
-  * @brief  USART MSP Init.
-  * @param  husart Pointer to a USART_HandleTypeDef structure that contains
+/**
-  *                the configuration information for the specified USART module.
+  * @brief  USART MSP Init.
-  * @retval None
+  * @param  husart Pointer to a USART_HandleTypeDef structure that contains
-  */
+  *                the configuration information for the specified USART module.
-__weak void HAL_USART_MspInit(USART_HandleTypeDef *husart)
+  * @retval None
-{
+  */
-  /* Prevent unused argument(s) compilation warning */
+__weak void HAL_USART_MspInit(USART_HandleTypeDef *husart)
-  UNUSED(husart);
+{
-  /* NOTE: This function should not be modified, when the callback is needed,
+  /* Prevent unused argument(s) compilation warning */
-           the HAL_USART_MspInit could be implemented in the user file
+  UNUSED(husart);
-   */
+  /* NOTE: This function should not be modified, when the callback is needed,
-}
+           the HAL_USART_MspInit could be implemented in the user file
+   */
-/**
+}
-  * @brief  USART MSP DeInit.
-  * @param  husart Pointer to a USART_HandleTypeDef structure that contains
+/**
-  *                the configuration information for the specified USART module.
+  * @brief  USART MSP DeInit.
-  * @retval None
+  * @param  husart Pointer to a USART_HandleTypeDef structure that contains
-  */
+  *                the configuration information for the specified USART module.
-__weak void HAL_USART_MspDeInit(USART_HandleTypeDef *husart)
+  * @retval None
-{
+  */
-  /* Prevent unused argument(s) compilation warning */
+__weak void HAL_USART_MspDeInit(USART_HandleTypeDef *husart)
-  UNUSED(husart);
+{
-  /* NOTE: This function should not be modified, when the callback is needed,
+  /* Prevent unused argument(s) compilation warning */
-           the HAL_USART_MspDeInit could be implemented in the user file
+  UNUSED(husart);
-   */
+  /* NOTE: This function should not be modified, when the callback is needed,
-}
+           the HAL_USART_MspDeInit could be implemented in the user file
+   */
-#if (USE_HAL_USART_REGISTER_CALLBACKS == 1)
+}
-/**
-  * @brief  Register a User USART Callback
+#if (USE_HAL_USART_REGISTER_CALLBACKS == 1)
-  *         To be used instead of the weak predefined callback
+/**
-  * @param  husart usart handle
+  * @brief  Register a User USART Callback
-  * @param  CallbackID ID of the callback to be registered
+  *         To be used instead of the weak predefined callback
-  *         This parameter can be one of the following values:
+  * @note   The HAL_USART_RegisterCallback() may be called before HAL_USART_Init() in HAL_USART_STATE_RESET
-  *           @arg @ref HAL_USART_TX_HALFCOMPLETE_CB_ID Tx Half Complete Callback ID
+  *         to register callbacks for HAL_USART_MSPINIT_CB_ID and HAL_USART_MSPDEINIT_CB_ID
-  *           @arg @ref HAL_USART_TX_COMPLETE_CB_ID Tx Complete Callback ID
+  * @param  husart usart handle
-  *           @arg @ref HAL_USART_RX_HALFCOMPLETE_CB_ID Rx Half Complete Callback ID
+  * @param  CallbackID ID of the callback to be registered
-  *           @arg @ref HAL_USART_RX_COMPLETE_CB_ID Rx Complete Callback ID
+  *         This parameter can be one of the following values:
-  *           @arg @ref HAL_USART_TX_RX_COMPLETE_CB_ID Rx Complete Callback ID
+  *           @arg @ref HAL_USART_TX_HALFCOMPLETE_CB_ID Tx Half Complete Callback ID
-  *           @arg @ref HAL_USART_ERROR_CB_ID Error Callback ID
+  *           @arg @ref HAL_USART_TX_COMPLETE_CB_ID Tx Complete Callback ID
-  *           @arg @ref HAL_USART_ABORT_COMPLETE_CB_ID Abort Complete Callback ID
+  *           @arg @ref HAL_USART_RX_HALFCOMPLETE_CB_ID Rx Half Complete Callback ID
-  *           @arg @ref HAL_USART_MSPINIT_CB_ID MspInit Callback ID
+  *           @arg @ref HAL_USART_RX_COMPLETE_CB_ID Rx Complete Callback ID
-  *           @arg @ref HAL_USART_MSPDEINIT_CB_ID MspDeInit Callback ID
+  *           @arg @ref HAL_USART_TX_RX_COMPLETE_CB_ID Rx Complete Callback ID
-  * @param  pCallback pointer to the Callback function
+  *           @arg @ref HAL_USART_ERROR_CB_ID Error Callback ID
-  * @retval HAL status
+  *           @arg @ref HAL_USART_ABORT_COMPLETE_CB_ID Abort Complete Callback ID
-+  */
+  *           @arg @ref HAL_USART_MSPINIT_CB_ID MspInit Callback ID
-HAL_StatusTypeDef HAL_USART_RegisterCallback(USART_HandleTypeDef *husart, HAL_USART_CallbackIDTypeDef CallbackID, pUSART_CallbackTypeDef pCallback)
+  *           @arg @ref HAL_USART_MSPDEINIT_CB_ID MspDeInit Callback ID
-{
+  * @param  pCallback pointer to the Callback function
-  HAL_StatusTypeDef status = HAL_OK;
+  * @retval HAL status
++  */
-  if (pCallback == NULL)
+HAL_StatusTypeDef HAL_USART_RegisterCallback(USART_HandleTypeDef *husart, HAL_USART_CallbackIDTypeDef CallbackID,
-  {
+                                             pUSART_CallbackTypeDef pCallback)
-    /* Update the error code */
+{
-    husart->ErrorCode |= HAL_USART_ERROR_INVALID_CALLBACK;
+  HAL_StatusTypeDef status = HAL_OK;
-    return HAL_ERROR;
+  if (pCallback == NULL)
-  }
+  {
-  /* Process locked */
+    /* Update the error code */
-  __HAL_LOCK(husart);
+    husart->ErrorCode |= HAL_USART_ERROR_INVALID_CALLBACK;
-  if (husart->State == HAL_USART_STATE_READY)
+    return HAL_ERROR;
-  {
+  }
-    switch (CallbackID)
-    {
+  if (husart->State == HAL_USART_STATE_READY)
-      case HAL_USART_TX_HALFCOMPLETE_CB_ID :
+  {
-        husart->TxHalfCpltCallback = pCallback;
+    switch (CallbackID)
-        break;
+    {
+      case HAL_USART_TX_HALFCOMPLETE_CB_ID :
-      case HAL_USART_TX_COMPLETE_CB_ID :
+        husart->TxHalfCpltCallback = pCallback;
-        husart->TxCpltCallback = pCallback;
+        break;
-        break;
+      case HAL_USART_TX_COMPLETE_CB_ID :
-      case HAL_USART_RX_HALFCOMPLETE_CB_ID :
+        husart->TxCpltCallback = pCallback;
-        husart->RxHalfCpltCallback = pCallback;
+        break;
-        break;
+      case HAL_USART_RX_HALFCOMPLETE_CB_ID :
-      case HAL_USART_RX_COMPLETE_CB_ID :
+        husart->RxHalfCpltCallback = pCallback;
-        husart->RxCpltCallback = pCallback;
+        break;
-        break;
+      case HAL_USART_RX_COMPLETE_CB_ID :
-      case HAL_USART_TX_RX_COMPLETE_CB_ID :
+        husart->RxCpltCallback = pCallback;
-        husart->TxRxCpltCallback = pCallback;
+        break;
-        break;
+      case HAL_USART_TX_RX_COMPLETE_CB_ID :
-      case HAL_USART_ERROR_CB_ID :
+        husart->TxRxCpltCallback = pCallback;
-        husart->ErrorCallback = pCallback;
+        break;
-        break;
+      case HAL_USART_ERROR_CB_ID :
-      case HAL_USART_ABORT_COMPLETE_CB_ID :
+        husart->ErrorCallback = pCallback;
-        husart->AbortCpltCallback = pCallback;
+        break;
-        break;
+      case HAL_USART_ABORT_COMPLETE_CB_ID :
-      case HAL_USART_MSPINIT_CB_ID :
+        husart->AbortCpltCallback = pCallback;
-        husart->MspInitCallback = pCallback;
+        break;
-        break;
+      case HAL_USART_MSPINIT_CB_ID :
-      case HAL_USART_MSPDEINIT_CB_ID :
+        husart->MspInitCallback = pCallback;
-        husart->MspDeInitCallback = pCallback;
+        break;
-        break;
+      case HAL_USART_MSPDEINIT_CB_ID :
-      default :
+        husart->MspDeInitCallback = pCallback;
-        /* Update the error code */
+        break;
-        husart->ErrorCode |= HAL_USART_ERROR_INVALID_CALLBACK;
+      default :
-        /* Return error status */
+        /* Update the error code */
-        status =  HAL_ERROR;
+        husart->ErrorCode |= HAL_USART_ERROR_INVALID_CALLBACK;
-        break;
-    }
+        /* Return error status */
-  }
+        status =  HAL_ERROR;
-  else if (husart->State == HAL_USART_STATE_RESET)
+        break;
-  {
+    }
-    switch (CallbackID)
+  }
-    {
+  else if (husart->State == HAL_USART_STATE_RESET)
-      case HAL_USART_MSPINIT_CB_ID :
+  {
-        husart->MspInitCallback = pCallback;
+    switch (CallbackID)
-        break;
+    {
+      case HAL_USART_MSPINIT_CB_ID :
-      case HAL_USART_MSPDEINIT_CB_ID :
+        husart->MspInitCallback = pCallback;
-        husart->MspDeInitCallback = pCallback;
+        break;
-        break;
+      case HAL_USART_MSPDEINIT_CB_ID :
-      default :
+        husart->MspDeInitCallback = pCallback;
-        /* Update the error code */
+        break;
-        husart->ErrorCode |= HAL_USART_ERROR_INVALID_CALLBACK;
+      default :
-        /* Return error status */
+        /* Update the error code */
-        status =  HAL_ERROR;
+        husart->ErrorCode |= HAL_USART_ERROR_INVALID_CALLBACK;
-        break;
-    }
+        /* Return error status */
-  }
+        status =  HAL_ERROR;
-  else
+        break;
-  {
+    }
-    /* Update the error code */
+  }
-    husart->ErrorCode |= HAL_USART_ERROR_INVALID_CALLBACK;
+  else
+  {
-    /* Return error status */
+    /* Update the error code */
-    status =  HAL_ERROR;
+    husart->ErrorCode |= HAL_USART_ERROR_INVALID_CALLBACK;
-  }
+    /* Return error status */
-  /* Release Lock */
+    status =  HAL_ERROR;
-  __HAL_UNLOCK(husart);
+  }
   return status;
 }
 /**
   * @brief  Unregister an USART Callback
   *         USART callaback is redirected to the weak predefined callback
-  * @param  husart usart handle
+  * @note   The HAL_USART_UnRegisterCallback() may be called before HAL_USART_Init() in HAL_USART_STATE_RESET
-  * @param  CallbackID ID of the callback to be unregistered
+  *         to un-register callbacks for HAL_USART_MSPINIT_CB_ID and HAL_USART_MSPDEINIT_CB_ID
-  *         This parameter can be one of the following values:
+  * @param  husart usart handle
-  *           @arg @ref HAL_USART_TX_HALFCOMPLETE_CB_ID Tx Half Complete Callback ID
+  * @param  CallbackID ID of the callback to be unregistered
-  *           @arg @ref HAL_USART_TX_COMPLETE_CB_ID Tx Complete Callback ID
+  *         This parameter can be one of the following values:
-  *           @arg @ref HAL_USART_RX_HALFCOMPLETE_CB_ID Rx Half Complete Callback ID
+  *           @arg @ref HAL_USART_TX_HALFCOMPLETE_CB_ID Tx Half Complete Callback ID
-  *           @arg @ref HAL_USART_RX_COMPLETE_CB_ID Rx Complete Callback ID
+  *           @arg @ref HAL_USART_TX_COMPLETE_CB_ID Tx Complete Callback ID
-  *           @arg @ref HAL_USART_TX_RX_COMPLETE_CB_ID Rx Complete Callback ID
+  *           @arg @ref HAL_USART_RX_HALFCOMPLETE_CB_ID Rx Half Complete Callback ID
-  *           @arg @ref HAL_USART_ERROR_CB_ID Error Callback ID
+  *           @arg @ref HAL_USART_RX_COMPLETE_CB_ID Rx Complete Callback ID
-  *           @arg @ref HAL_USART_ABORT_COMPLETE_CB_ID Abort Complete Callback ID
+  *           @arg @ref HAL_USART_TX_RX_COMPLETE_CB_ID Rx Complete Callback ID
-  *           @arg @ref HAL_USART_MSPINIT_CB_ID MspInit Callback ID
+  *           @arg @ref HAL_USART_ERROR_CB_ID Error Callback ID
-  *           @arg @ref HAL_USART_MSPDEINIT_CB_ID MspDeInit Callback ID
+  *           @arg @ref HAL_USART_ABORT_COMPLETE_CB_ID Abort Complete Callback ID
-  * @retval HAL status
+  *           @arg @ref HAL_USART_MSPINIT_CB_ID MspInit Callback ID
-  */
+  *           @arg @ref HAL_USART_MSPDEINIT_CB_ID MspDeInit Callback ID
-HAL_StatusTypeDef HAL_USART_UnRegisterCallback(USART_HandleTypeDef *husart, HAL_USART_CallbackIDTypeDef CallbackID)
+  * @retval HAL status
-{
+  */
-  HAL_StatusTypeDef status = HAL_OK;
+HAL_StatusTypeDef HAL_USART_UnRegisterCallback(USART_HandleTypeDef *husart, HAL_USART_CallbackIDTypeDef CallbackID)
+{
-  /* Process locked */
+  HAL_StatusTypeDef status = HAL_OK;
-  __HAL_LOCK(husart);
+  if (husart->State == HAL_USART_STATE_READY)
-  if (husart->State == HAL_USART_STATE_READY)
+  {
-  {
+    switch (CallbackID)
-    switch (CallbackID)
+    {
-    {
+      case HAL_USART_TX_HALFCOMPLETE_CB_ID :
-      case HAL_USART_TX_HALFCOMPLETE_CB_ID :
+        husart->TxHalfCpltCallback = HAL_USART_TxHalfCpltCallback;               /* Legacy weak  TxHalfCpltCallback       */
-        husart->TxHalfCpltCallback = HAL_USART_TxHalfCpltCallback;               /* Legacy weak  TxHalfCpltCallback       */
+        break;
-        break;
+      case HAL_USART_TX_COMPLETE_CB_ID :
-      case HAL_USART_TX_COMPLETE_CB_ID :
+        husart->TxCpltCallback = HAL_USART_TxCpltCallback;                       /* Legacy weak TxCpltCallback            */
-        husart->TxCpltCallback = HAL_USART_TxCpltCallback;                       /* Legacy weak TxCpltCallback            */
+        break;
-        break;
+      case HAL_USART_RX_HALFCOMPLETE_CB_ID :
-      case HAL_USART_RX_HALFCOMPLETE_CB_ID :
+        husart->RxHalfCpltCallback = HAL_USART_RxHalfCpltCallback;               /* Legacy weak RxHalfCpltCallback        */
-        husart->RxHalfCpltCallback = HAL_USART_RxHalfCpltCallback;               /* Legacy weak RxHalfCpltCallback        */
+        break;
-        break;
+      case HAL_USART_RX_COMPLETE_CB_ID :
-      case HAL_USART_RX_COMPLETE_CB_ID :
+        husart->RxCpltCallback = HAL_USART_RxCpltCallback;                       /* Legacy weak RxCpltCallback            */
-        husart->RxCpltCallback = HAL_USART_RxCpltCallback;                       /* Legacy weak RxCpltCallback            */
+        break;
-        break;
+      case HAL_USART_TX_RX_COMPLETE_CB_ID :
-      case HAL_USART_TX_RX_COMPLETE_CB_ID :
+        husart->TxRxCpltCallback = HAL_USART_TxRxCpltCallback;                   /* Legacy weak TxRxCpltCallback            */
-        husart->TxRxCpltCallback = HAL_USART_TxRxCpltCallback;                   /* Legacy weak TxRxCpltCallback            */
+        break;
-        break;
+      case HAL_USART_ERROR_CB_ID :
-      case HAL_USART_ERROR_CB_ID :
+        husart->ErrorCallback = HAL_USART_ErrorCallback;                         /* Legacy weak ErrorCallback             */
-        husart->ErrorCallback = HAL_USART_ErrorCallback;                         /* Legacy weak ErrorCallback             */
+        break;
-        break;
+      case HAL_USART_ABORT_COMPLETE_CB_ID :
-      case HAL_USART_ABORT_COMPLETE_CB_ID :
+        husart->AbortCpltCallback = HAL_USART_AbortCpltCallback;                 /* Legacy weak AbortCpltCallback         */
-        husart->AbortCpltCallback = HAL_USART_AbortCpltCallback;                 /* Legacy weak AbortCpltCallback         */
+        break;
-        break;
+      case HAL_USART_MSPINIT_CB_ID :
-      case HAL_USART_MSPINIT_CB_ID :
+        husart->MspInitCallback = HAL_USART_MspInit;                             /* Legacy weak MspInitCallback           */
-        husart->MspInitCallback = HAL_USART_MspInit;                             /* Legacy weak MspInitCallback           */
+        break;
-        break;
+      case HAL_USART_MSPDEINIT_CB_ID :
-      case HAL_USART_MSPDEINIT_CB_ID :
+        husart->MspDeInitCallback = HAL_USART_MspDeInit;                         /* Legacy weak MspDeInitCallback         */
-        husart->MspDeInitCallback = HAL_USART_MspDeInit;                         /* Legacy weak MspDeInitCallback         */
+        break;
-        break;
+      default :
-      default :
+        /* Update the error code */
-        /* Update the error code */
+        husart->ErrorCode |= HAL_USART_ERROR_INVALID_CALLBACK;
-        husart->ErrorCode |= HAL_USART_ERROR_INVALID_CALLBACK;
+        /* Return error status */
-        /* Return error status */
+        status =  HAL_ERROR;
-        status =  HAL_ERROR;
+        break;
-        break;
+    }
-    }
+  }
-  }
+  else if (husart->State == HAL_USART_STATE_RESET)
-  else if (husart->State == HAL_USART_STATE_RESET)
+  {
-  {
+    switch (CallbackID)
-    switch (CallbackID)
+    {
-    {
+      case HAL_USART_MSPINIT_CB_ID :
-      case HAL_USART_MSPINIT_CB_ID :
+        husart->MspInitCallback = HAL_USART_MspInit;
-        husart->MspInitCallback = HAL_USART_MspInit;
+        break;
-        break;
+      case HAL_USART_MSPDEINIT_CB_ID :
-      case HAL_USART_MSPDEINIT_CB_ID :
+        husart->MspDeInitCallback = HAL_USART_MspDeInit;
-        husart->MspDeInitCallback = HAL_USART_MspDeInit;
+        break;
-        break;
+      default :
-      default :
+        /* Update the error code */
-        /* Update the error code */
+        husart->ErrorCode |= HAL_USART_ERROR_INVALID_CALLBACK;
-        husart->ErrorCode |= HAL_USART_ERROR_INVALID_CALLBACK;
+        /* Return error status */
-        /* Return error status */
+        status =  HAL_ERROR;
-        status =  HAL_ERROR;
+        break;
-        break;
+    }
-    }
+  }
-  }
+  else
-  else
+  {
-  {
+    /* Update the error code */
-    /* Update the error code */
+    husart->ErrorCode |= HAL_USART_ERROR_INVALID_CALLBACK;
-    husart->ErrorCode |= HAL_USART_ERROR_INVALID_CALLBACK;
+    /* Return error status */
-    /* Return error status */
+    status =  HAL_ERROR;
-    status =  HAL_ERROR;
+  }
-  }
+  return status;
-  /* Release Lock */
+}
-  __HAL_UNLOCK(husart);
+#endif /* USE_HAL_USART_REGISTER_CALLBACKS */
-  return status;
+/**
-}
+  * @}
-#endif /* USE_HAL_USART_REGISTER_CALLBACKS */
+  */
-/**
+/** @defgroup USART_Exported_Functions_Group2 IO operation functions
-  * @}
+  *  @brief   USART Transmit and Receive functions
-  */
+  *
+@verbatim
-/** @defgroup USART_Exported_Functions_Group2 IO operation functions
+  ==============================================================================
-  *  @brief   USART Transmit and Receive functions
+                         ##### IO operation functions #####
-  *
+  ==============================================================================
-@verbatim
+  [..]
-  ==============================================================================
+    This subsection provides a set of functions allowing to manage the USART synchronous
-                         ##### IO operation functions #####
+    data transfers.
-  ==============================================================================
   [..]
-    This subsection provides a set of functions allowing to manage the USART synchronous
+    The USART supports master mode only: it cannot receive or send data related to an input
-    data transfers.
+    clock (SCLK is always an output).
-  [..]
+    (#) There are two modes of transfer:
-    The USART supports master mode only: it cannot receive or send data related to an input
+        (++) Blocking mode: The communication is performed in polling mode.
-    clock (SCLK is always an output).
+             The HAL status of all data processing is returned by the same function
+             after finishing transfer.
-    (#) There are two modes of transfer:
+        (++) No-Blocking mode: The communication is performed using Interrupts
-        (++) Blocking mode: The communication is performed in polling mode.
+             or DMA, These API's return the HAL status.
-             The HAL status of all data processing is returned by the same function
+             The end of the data processing will be indicated through the
-             after finishing transfer.
+             dedicated USART IRQ when using Interrupt mode or the DMA IRQ when
-        (++) No-Blocking mode: The communication is performed using Interrupts
+             using DMA mode.
-             or DMA, These API's return the HAL status.
+             The HAL_USART_TxCpltCallback(), HAL_USART_RxCpltCallback() and HAL_USART_TxRxCpltCallback()
-             The end of the data processing will be indicated through the
+              user callbacks
-             dedicated USART IRQ when using Interrupt mode or the DMA IRQ when
+             will be executed respectively at the end of the transmit or Receive process
-             using DMA mode.
+             The HAL_USART_ErrorCallback() user callback will be executed when a communication
-             The HAL_USART_TxCpltCallback(), HAL_USART_RxCpltCallback() and HAL_USART_TxRxCpltCallback()
+             error is detected
-              user callbacks
-             will be executed respectively at the end of the transmit or Receive process
+    (#) Blocking mode APIs are :
-             The HAL_USART_ErrorCallback() user callback will be executed when a communication
+        (++) HAL_USART_Transmit() in simplex mode
-             error is detected
+        (++) HAL_USART_Receive() in full duplex receive only
+        (++) HAL_USART_TransmitReceive() in full duplex mode
-    (#) Blocking mode APIs are :
-        (++) HAL_USART_Transmit() in simplex mode
+    (#) Non Blocking mode APIs with Interrupt are :
-        (++) HAL_USART_Receive() in full duplex receive only
+        (++) HAL_USART_Transmit_IT()in simplex mode
-        (++) HAL_USART_TransmitReceive() in full duplex mode
+        (++) HAL_USART_Receive_IT() in full duplex receive only
+        (++) HAL_USART_TransmitReceive_IT() in full duplex mode
-    (#) Non Blocking mode APIs with Interrupt are :
+        (++) HAL_USART_IRQHandler()
-        (++) HAL_USART_Transmit_IT()in simplex mode
-        (++) HAL_USART_Receive_IT() in full duplex receive only
+    (#) Non Blocking mode functions with DMA are :
-        (++) HAL_USART_TransmitReceive_IT() in full duplex mode
+        (++) HAL_USART_Transmit_DMA()in simplex mode
-        (++) HAL_USART_IRQHandler()
+        (++) HAL_USART_Receive_DMA() in full duplex receive only
+        (++) HAL_USART_TransmitReceive_DMA() in full duplex mode
-    (#) Non Blocking mode functions with DMA are :
+        (++) HAL_USART_DMAPause()
-        (++) HAL_USART_Transmit_DMA()in simplex mode
+        (++) HAL_USART_DMAResume()
-        (++) HAL_USART_Receive_DMA() in full duplex receive only
+        (++) HAL_USART_DMAStop()
-        (++) HAL_USART_TransmitReceive_DMA() in full duplex mode
-        (++) HAL_USART_DMAPause()
+    (#) A set of Transfer Complete Callbacks are provided in non Blocking mode:
-        (++) HAL_USART_DMAResume()
+        (++) HAL_USART_TxHalfCpltCallback()
-        (++) HAL_USART_DMAStop()
+        (++) HAL_USART_TxCpltCallback()
+        (++) HAL_USART_RxHalfCpltCallback()
-    (#) A set of Transfer Complete Callbacks are provided in non Blocking mode:
+        (++) HAL_USART_RxCpltCallback()
-        (++) HAL_USART_TxHalfCpltCallback()
+        (++) HAL_USART_ErrorCallback()
-        (++) HAL_USART_TxCpltCallback()
+        (++) HAL_USART_TxRxCpltCallback()
-        (++) HAL_USART_RxHalfCpltCallback()
-        (++) HAL_USART_RxCpltCallback()
+    (#) Non-Blocking mode transfers could be aborted using Abort API's :
-        (++) HAL_USART_ErrorCallback()
+        (++) HAL_USART_Abort()
-        (++) HAL_USART_TxRxCpltCallback()
+        (++) HAL_USART_Abort_IT()
-    (#) Non-Blocking mode transfers could be aborted using Abort API's :
+    (#) For Abort services based on interrupts (HAL_USART_Abort_IT), a Abort Complete Callbacks is provided:
-        (++) HAL_USART_Abort()
+        (++) HAL_USART_AbortCpltCallback()
-        (++) HAL_USART_Abort_IT()
+    (#) In Non-Blocking mode transfers, possible errors are split into 2 categories.
-    (#) For Abort services based on interrupts (HAL_USART_Abort_IT), a Abort Complete Callbacks is provided:
+        Errors are handled as follows :
-        (++) HAL_USART_AbortCpltCallback()
+        (++) Error is considered as Recoverable and non blocking : Transfer could go till end, but error severity is
+             to be evaluated by user : this concerns Frame Error, Parity Error or Noise Error in Interrupt mode reception .
-    (#) In Non-Blocking mode transfers, possible errors are split into 2 categories.
+             Received character is then retrieved and stored in Rx buffer, Error code is set to allow user to identify error type,
-        Errors are handled as follows :
+             and HAL_USART_ErrorCallback() user callback is executed. Transfer is kept ongoing on USART side.
-        (++) Error is considered as Recoverable and non blocking : Transfer could go till end, but error severity is
+             If user wants to abort it, Abort services should be called by user.
-             to be evaluated by user : this concerns Frame Error, Parity Error or Noise Error in Interrupt mode reception .
+        (++) Error is considered as Blocking : Transfer could not be completed properly and is aborted.
-             Received character is then retrieved and stored in Rx buffer, Error code is set to allow user to identify error type,
+             This concerns Overrun Error In Interrupt mode reception and all errors in DMA mode.
-             and HAL_USART_ErrorCallback() user callback is executed. Transfer is kept ongoing on USART side.
+             Error code is set to allow user to identify error type, and HAL_USART_ErrorCallback() user callback is executed.
-             If user wants to abort it, Abort services should be called by user.
-        (++) Error is considered as Blocking : Transfer could not be completed properly and is aborted.
+@endverbatim
-             This concerns Overrun Error In Interrupt mode reception and all errors in DMA mode.
+  * @{
-             Error code is set to allow user to identify error type, and HAL_USART_ErrorCallback() user callback is executed.
+  */
-@endverbatim
+/**
-  * @{
+  * @brief  Simplex Send an amount of data in blocking mode.
-  */
+  * @note   When USART parity is not enabled (PCE = 0), and Word Length is configured to 9 bits (M1-M0 = 01),
+  *         the sent data is handled as a set of u16. In this case, Size must indicate the number
-/**
+  *         of u16 provided through pTxData.
-  * @brief  Simplex Send an amount of data in blocking mode.
+  * @param  husart  Pointer to a USART_HandleTypeDef structure that contains
-  * @note   When USART parity is not enabled (PCE = 0), and Word Length is configured to 9 bits (M1-M0 = 01),
+  *                 the configuration information for the specified USART module.
-  *         the sent data is handled as a set of u16. In this case, Size must indicate the number
+  * @param  pTxData Pointer to data buffer (u8 or u16 data elements).
-  *         of u16 provided through pTxData.
+  * @param  Size    Amount of data elements (u8 or u16) to be sent.
-  * @param  husart  Pointer to a USART_HandleTypeDef structure that contains
+  * @param  Timeout Timeout duration.
-  *                 the configuration information for the specified USART module.
+  * @retval HAL status
-  * @param  pTxData Pointer to data buffer (u8 or u16 data elements).
+  */
-  * @param  Size    Amount of data elements (u8 or u16) to be sent.
+HAL_StatusTypeDef HAL_USART_Transmit(USART_HandleTypeDef *husart, const uint8_t *pTxData, uint16_t Size, uint32_t Timeout)
-  * @param  Timeout Timeout duration.
+{
-  * @retval HAL status
+  const uint8_t  *ptxdata8bits;
-  */
+  const uint16_t *ptxdata16bits;
-HAL_StatusTypeDef HAL_USART_Transmit(USART_HandleTypeDef *husart, uint8_t *pTxData, uint16_t Size, uint32_t Timeout)
+  uint32_t tickstart;
-{
-  uint8_t  *ptxdata8bits;
+  if (husart->State == HAL_USART_STATE_READY)
-  uint16_t *ptxdata16bits;
+  {
-  uint32_t tickstart;
+    if ((pTxData == NULL) || (Size == 0))
+    {
-  if (husart->State == HAL_USART_STATE_READY)
+      return  HAL_ERROR;
-  {
+    }
-    if ((pTxData == NULL) || (Size == 0))
-    {
+    /* Process Locked */
-      return  HAL_ERROR;
+    __HAL_LOCK(husart);
-    }
+    husart->ErrorCode = HAL_USART_ERROR_NONE;
-    /* Process Locked */
+    husart->State = HAL_USART_STATE_BUSY_TX;
-    __HAL_LOCK(husart);
+    /* Init tickstart for timeout management */
-    husart->ErrorCode = HAL_USART_ERROR_NONE;
+    tickstart = HAL_GetTick();
-    husart->State = HAL_USART_STATE_BUSY_TX;
+    husart->TxXferSize = Size;
-    /* Init tickstart for timeout management */
+    husart->TxXferCount = Size;
-    tickstart = HAL_GetTick();
+    /* In case of 9bits/No Parity transfer, pTxData needs to be handled as a uint16_t pointer */
-    husart->TxXferSize = Size;
+    if ((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE))
-    husart->TxXferCount = Size;
+    {
+      ptxdata8bits  = NULL;
-    /* In case of 9bits/No Parity transfer, pTxData needs to be handled as a uint16_t pointer */
+      ptxdata16bits = (const uint16_t *) pTxData;
-    if ((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE))
+    }
-    {
+    else
-      ptxdata8bits  = NULL;
+    {
-      ptxdata16bits = (uint16_t *) pTxData;
+      ptxdata8bits  = pTxData;
-    }
+      ptxdata16bits = NULL;
-    else
+    }
-    {
-      ptxdata8bits  = pTxData;
+    while (husart->TxXferCount > 0U)
-      ptxdata16bits = NULL;
+    {
-    }
+      /* Wait for TXE flag in order to write data in DR */
+      if (USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_TXE, RESET, tickstart, Timeout) != HAL_OK)
-    while (husart->TxXferCount > 0U)
+      {
-    {
+        return HAL_TIMEOUT;
-      /* Wait for TXE flag in order to write data in DR */
+      }
-      if (USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_TXE, RESET, tickstart, Timeout) != HAL_OK)
+      if (ptxdata8bits == NULL)
       {
-        return HAL_TIMEOUT;
+        husart->Instance->DR = (uint16_t)(*ptxdata16bits & (uint16_t)0x01FF);
-      }
+        ptxdata16bits++;
-      if (ptxdata8bits == NULL)
+      }
-      {
+      else
-        husart->Instance->DR = (uint16_t)(*ptxdata16bits & (uint16_t)0x01FF);
+      {
-        ptxdata16bits++;
+        husart->Instance->DR = (uint8_t)(*ptxdata8bits & (uint8_t)0xFF);
-      }
+        ptxdata8bits++;
-      else
+      }
-      {
-        husart->Instance->DR = (uint8_t)(*ptxdata8bits & (uint8_t)0xFF);
+      husart->TxXferCount--;
-        ptxdata8bits++;
+    }
-      }
+    if (USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_TC, RESET, tickstart, Timeout) != HAL_OK)
-      husart->TxXferCount--;
+    {
-    }
+      return HAL_TIMEOUT;
+    }
-    if (USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_TC, RESET, tickstart, Timeout) != HAL_OK)
-    {
+    husart->State = HAL_USART_STATE_READY;
-      return HAL_TIMEOUT;
-    }
+    /* Process Unlocked */
+    __HAL_UNLOCK(husart);
-    husart->State = HAL_USART_STATE_READY;
+    return HAL_OK;
-    /* Process Unlocked */
+  }
-    __HAL_UNLOCK(husart);
+  else
+  {
-    return HAL_OK;
+    return HAL_BUSY;
   }
-  else
+}
-  {
-    return HAL_BUSY;
+/**
-  }
+  * @brief  Full-Duplex Receive an amount of data in blocking mode.
-}
+  * @note   To receive synchronous data, dummy data are simultaneously transmitted.
+  * @note   When USART parity is not enabled (PCE = 0), and Word Length is configured to 9 bits (M1-M0 = 01),
-/**
+  *         the received data is handled as a set of u16. In this case, Size must indicate the number
-  * @brief  Full-Duplex Receive an amount of data in blocking mode.
+  *         of u16 available through pRxData.
-  * @note   To receive synchronous data, dummy data are simultaneously transmitted.
+  * @param  husart  Pointer to a USART_HandleTypeDef structure that contains
-  * @note   When USART parity is not enabled (PCE = 0), and Word Length is configured to 9 bits (M1-M0 = 01),
+  *                 the configuration information for the specified USART module.
-  *         the received data is handled as a set of u16. In this case, Size must indicate the number
+  * @param  pRxData Pointer to data buffer (u8 or u16 data elements).
-  *         of u16 available through pRxData.
+  * @param  Size    Amount of data elements (u8 or u16) to be received.
-  * @param  husart  Pointer to a USART_HandleTypeDef structure that contains
+  * @param  Timeout Timeout duration.
-  *                 the configuration information for the specified USART module.
+  * @retval HAL status
-  * @param  pRxData Pointer to data buffer (u8 or u16 data elements).
+  */
-  * @param  Size    Amount of data elements (u8 or u16) to be received.
+HAL_StatusTypeDef HAL_USART_Receive(USART_HandleTypeDef *husart, uint8_t *pRxData, uint16_t Size, uint32_t Timeout)
-  * @param  Timeout Timeout duration.
+{
-  * @retval HAL status
+  uint8_t  *prxdata8bits;
-  */
+  uint16_t *prxdata16bits;
-HAL_StatusTypeDef HAL_USART_Receive(USART_HandleTypeDef *husart, uint8_t *pRxData, uint16_t Size, uint32_t Timeout)
+  uint32_t tickstart;
-{
-  uint8_t  *prxdata8bits;
+  if (husart->State == HAL_USART_STATE_READY)
-  uint16_t *prxdata16bits;
+  {
-  uint32_t tickstart;
+    if ((pRxData == NULL) || (Size == 0))
+    {
-  if (husart->State == HAL_USART_STATE_READY)
+      return  HAL_ERROR;
-  {
+    }
-    if ((pRxData == NULL) || (Size == 0))
+    /* Process Locked */
-    {
+    __HAL_LOCK(husart);
-      return  HAL_ERROR;
-    }
+    husart->ErrorCode = HAL_USART_ERROR_NONE;
-    /* Process Locked */
+    husart->State = HAL_USART_STATE_BUSY_RX;
-    __HAL_LOCK(husart);
+    /* Init tickstart for timeout management */
-    husart->ErrorCode = HAL_USART_ERROR_NONE;
+    tickstart = HAL_GetTick();
-    husart->State = HAL_USART_STATE_BUSY_RX;
+    husart->RxXferSize = Size;
-    /* Init tickstart for timeout management */
+    husart->RxXferCount = Size;
-    tickstart = HAL_GetTick();
+    /* In case of 9bits/No Parity transfer, pRxData needs to be handled as a uint16_t pointer */
-    husart->RxXferSize = Size;
+    if ((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE))
-    husart->RxXferCount = Size;
+    {
+      prxdata8bits  = NULL;
-    /* In case of 9bits/No Parity transfer, pRxData needs to be handled as a uint16_t pointer */
+      prxdata16bits = (uint16_t *) pRxData;
-    if ((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE))
+    }
-    {
+    else
-      prxdata8bits  = NULL;
+    {
-      prxdata16bits = (uint16_t *) pRxData;
+      prxdata8bits  = pRxData;
-    }
+      prxdata16bits = NULL;
-    else
+    }
-    {
-      prxdata8bits  = pRxData;
+    /* Check the remain data to be received */
-      prxdata16bits = NULL;
+    while (husart->RxXferCount > 0U)
-    }
+    {
+      /* Wait until TXE flag is set to send dummy byte in order to generate the
-    /* Check the remain data to be received */
+      * clock for the slave to send data.
-    while (husart->RxXferCount > 0U)
+      * Whatever the frame length (7, 8 or 9-bit long), the same dummy value
-    {
+      * can be written for all the cases. */
-      /* Wait until TXE flag is set to send dummy byte in order to generate the
+      if (USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_TXE, RESET, tickstart, Timeout) != HAL_OK)
-      * clock for the slave to send data.
+      {
-      * Whatever the frame length (7, 8 or 9-bit long), the same dummy value
+        return HAL_TIMEOUT;
-      * can be written for all the cases. */
+      }
-      if (USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_TXE, RESET, tickstart, Timeout) != HAL_OK)
+      husart->Instance->DR = (DUMMY_DATA & (uint16_t)0x0FF);
-      {
-        return HAL_TIMEOUT;
+      /* Wait until RXNE flag is set to receive the byte */
-      }
+      if (USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_RXNE, RESET, tickstart, Timeout) != HAL_OK)
-      husart->Instance->DR = (DUMMY_DATA & (uint16_t)0x0FF);
+      {
+        return HAL_TIMEOUT;
-      /* Wait until RXNE flag is set to receive the byte */
+      }
-      if (USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_RXNE, RESET, tickstart, Timeout) != HAL_OK)
-      {
+      if (prxdata8bits == NULL)
-        return HAL_TIMEOUT;
+      {
-      }
+        *prxdata16bits = (uint16_t)(husart->Instance->DR & (uint16_t)0x01FF);
+        prxdata16bits++;
-      if (prxdata8bits == NULL)
+      }
-      {
+      else
-        *prxdata16bits = (uint16_t)(husart->Instance->DR & (uint16_t)0x01FF);
+      {
-        prxdata16bits++;
+        if ((husart->Init.WordLength == USART_WORDLENGTH_9B) || ((husart->Init.WordLength == USART_WORDLENGTH_8B) && (husart->Init.Parity == USART_PARITY_NONE)))
-      }
+        {
-      else
+          *prxdata8bits = (uint8_t)(husart->Instance->DR & (uint8_t)0x0FF);
-      {
+        }
-        if ((husart->Init.WordLength == USART_WORDLENGTH_9B) || ((husart->Init.WordLength == USART_WORDLENGTH_8B) && (husart->Init.Parity == USART_PARITY_NONE)))
+        else
         {
-          *prxdata8bits = (uint8_t)(husart->Instance->DR & (uint8_t)0x0FF);
+          *prxdata8bits = (uint8_t)(husart->Instance->DR & (uint8_t)0x07F);
         }
-        else
+        prxdata8bits++;
-        {
+      }
-          *prxdata8bits = (uint8_t)(husart->Instance->DR & (uint8_t)0x07F);
+      husart->RxXferCount--;
-        }
+    }
-        prxdata8bits++;
-      }
+    husart->State = HAL_USART_STATE_READY;
-      husart->RxXferCount--;
-    }
+    /* Process Unlocked */
+    __HAL_UNLOCK(husart);
-    husart->State = HAL_USART_STATE_READY;
+    return HAL_OK;
-    /* Process Unlocked */
+  }
-    __HAL_UNLOCK(husart);
+  else
+  {
-    return HAL_OK;
+    return HAL_BUSY;
   }
-  else
+}
-  {
-    return HAL_BUSY;
+/**
-  }
+  * @brief  Full-Duplex Send and Receive an amount of data in full-duplex mode (blocking mode).
-}
+  * @note   When USART parity is not enabled (PCE = 0), and Word Length is configured to 9 bits (M1-M0 = 01),
+  *         the sent data and the received data are handled as sets of u16. In this case, Size must indicate the number
-/**
+  *         of u16 available through pTxData and through pRxData.
-  * @brief  Full-Duplex Send and Receive an amount of data in full-duplex mode (blocking mode).
+  * @param  husart  Pointer to a USART_HandleTypeDef structure that contains
-  * @note   When USART parity is not enabled (PCE = 0), and Word Length is configured to 9 bits (M1-M0 = 01),
+  *                 the configuration information for the specified USART module.
-  *         the sent data and the received data are handled as sets of u16. In this case, Size must indicate the number
+  * @param  pTxData Pointer to TX data buffer (u8 or u16 data elements).
-  *         of u16 available through pTxData and through pRxData.
+  * @param  pRxData Pointer to RX data buffer (u8 or u16 data elements).
-  * @param  husart  Pointer to a USART_HandleTypeDef structure that contains
+  * @param  Size    Amount of data elements (u8 or u16) to be sent (same amount to be received).
-  *                 the configuration information for the specified USART module.
+  * @param  Timeout Timeout duration
-  * @param  pTxData Pointer to TX data buffer (u8 or u16 data elements).
+  * @retval HAL status
-  * @param  pRxData Pointer to RX data buffer (u8 or u16 data elements).
+  */
-  * @param  Size    Amount of data elements (u8 or u16) to be sent (same amount to be received).
+HAL_StatusTypeDef HAL_USART_TransmitReceive(USART_HandleTypeDef *husart, const uint8_t *pTxData, uint8_t *pRxData,
-  * @param  Timeout Timeout duration
+                                            uint16_t Size, uint32_t Timeout)
-  * @retval HAL status
+{
-  */
+  uint8_t  *prxdata8bits;
-HAL_StatusTypeDef HAL_USART_TransmitReceive(USART_HandleTypeDef *husart, uint8_t *pTxData, uint8_t *pRxData, uint16_t Size, uint32_t Timeout)
+  uint16_t *prxdata16bits;
-{
+  const uint8_t  *ptxdata8bits;
-  uint8_t  *prxdata8bits;
+  const uint16_t *ptxdata16bits;
-  uint16_t *prxdata16bits;
+  uint16_t rxdatacount;
-  uint8_t  *ptxdata8bits;
+  uint32_t tickstart;
-  uint16_t *ptxdata16bits;
-  uint16_t rxdatacount;
+  if (husart->State == HAL_USART_STATE_READY)
-  uint32_t tickstart;
+  {
+    if ((pTxData == NULL) || (pRxData == NULL) || (Size == 0))
-  if (husart->State == HAL_USART_STATE_READY)
+    {
-  {
+      return  HAL_ERROR;
-    if ((pTxData == NULL) || (pRxData == NULL) || (Size == 0))
+    }
-    {
-      return  HAL_ERROR;
+    /* In case of 9bits/No Parity transfer, pTxData and pRxData buffers provided as input parameter
-    }
+       should be aligned on a u16 frontier, as data to be filled into TDR/retrieved from RDR will be
+       handled through a u16 cast. */
-    /* In case of 9bits/No Parity transfer, pTxData and pRxData buffers provided as input parameter
+    if ((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE))
-       should be aligned on a u16 frontier, as data to be filled into TDR/retrieved from RDR will be
+    {
-       handled through a u16 cast. */
+      if (((((uint32_t)pTxData) & 1U) != 0U) || ((((uint32_t)pRxData) & 1U) != 0U))
-    if ((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE))
+      {
-    {
+        return  HAL_ERROR;
-      if (((((uint32_t)pTxData) & 1U) != 0U) || ((((uint32_t)pRxData) & 1U) != 0U))
+      }
-      {
+    }
-        return  HAL_ERROR;
+    /* Process Locked */
-      }
+    __HAL_LOCK(husart);
-    }
-    /* Process Locked */
+    husart->ErrorCode = HAL_USART_ERROR_NONE;
-    __HAL_LOCK(husart);
+    husart->State = HAL_USART_STATE_BUSY_RX;
-    husart->ErrorCode = HAL_USART_ERROR_NONE;
+    /* Init tickstart for timeout management */
-    husart->State = HAL_USART_STATE_BUSY_RX;
+    tickstart = HAL_GetTick();
-    /* Init tickstart for timeout management */
+    husart->RxXferSize = Size;
-    tickstart = HAL_GetTick();
+    husart->TxXferSize = Size;
+    husart->TxXferCount = Size;
-    husart->RxXferSize = Size;
+    husart->RxXferCount = Size;
-    husart->TxXferSize = Size;
-    husart->TxXferCount = Size;
+    /* In case of 9bits/No Parity transfer, pRxData needs to be handled as a uint16_t pointer */
-    husart->RxXferCount = Size;
+    if ((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE))
+    {
-    /* In case of 9bits/No Parity transfer, pRxData needs to be handled as a uint16_t pointer */
+      prxdata8bits  = NULL;
-    if ((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE))
+      ptxdata8bits  = NULL;
-    {
+      ptxdata16bits = (const uint16_t *) pTxData;
-      prxdata8bits  = NULL;
+      prxdata16bits = (uint16_t *) pRxData;
-      ptxdata8bits  = NULL;
+    }
-      ptxdata16bits = (uint16_t *) pTxData;
+    else
-      prxdata16bits = (uint16_t *) pRxData;
+    {
-    }
+      prxdata8bits  = pRxData;
-    else
+      ptxdata8bits  = pTxData;
-    {
+      ptxdata16bits = NULL;
-      prxdata8bits  = pRxData;
+      prxdata16bits = NULL;
-      ptxdata8bits  = pTxData;
+    }
-      ptxdata16bits = NULL;
-      prxdata16bits = NULL;
+    /* Check the remain data to be received */
-    }
+    /* rxdatacount is a temporary variable for MISRAC2012-Rule-13.5 */
+    rxdatacount = husart->RxXferCount;
-    /* Check the remain data to be received */
+    while ((husart->TxXferCount > 0U) || (rxdatacount > 0U))
-    /* rxdatacount is a temporary variable for MISRAC2012-Rule-13.5 */
+    {
-    rxdatacount = husart->RxXferCount;
+      if (husart->TxXferCount > 0U)
-    while ((husart->TxXferCount > 0U) || (rxdatacount > 0U))
+      {
-    {
+        /* Wait for TXE flag in order to write data in DR */
-      if (husart->TxXferCount > 0U)
+        if (USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_TXE, RESET, tickstart, Timeout) != HAL_OK)
-      {
+        {
-        /* Wait for TXE flag in order to write data in DR */
+          return HAL_TIMEOUT;
-        if (USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_TXE, RESET, tickstart, Timeout) != HAL_OK)
+        }
-        {
-          return HAL_TIMEOUT;
+        if (ptxdata8bits == NULL)
-        }
+        {
+          husart->Instance->DR = (uint16_t)(*ptxdata16bits & (uint16_t)0x01FF);
-        if (ptxdata8bits == NULL)
+          ptxdata16bits++;
-        {
+        }
-          husart->Instance->DR = (uint16_t)(*ptxdata16bits & (uint16_t)0x01FF);
+        else
-          ptxdata16bits++;
+        {
-        }
+          husart->Instance->DR = (uint8_t)(*ptxdata8bits & (uint8_t)0xFF);
-        else
+          ptxdata8bits++;
-        {
+        }
-          husart->Instance->DR = (uint8_t)(*ptxdata8bits & (uint8_t)0xFF);
-          ptxdata8bits++;
+        husart->TxXferCount--;
-        }
+      }
-        husart->TxXferCount--;
+      if (husart->RxXferCount > 0U)
-      }
+      {
+        /* Wait for RXNE Flag */
-      if (husart->RxXferCount > 0U)
+        if (USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_RXNE, RESET, tickstart, Timeout) != HAL_OK)
-      {
+        {
-        /* Wait for RXNE Flag */
+          return HAL_TIMEOUT;
-        if (USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_RXNE, RESET, tickstart, Timeout) != HAL_OK)
+        }
-        {
+        if (prxdata8bits == NULL)
-          return HAL_TIMEOUT;
+        {
-        }
+          *prxdata16bits = (uint16_t)(husart->Instance->DR & (uint16_t)0x01FF);
-        if (prxdata8bits == NULL)
+          prxdata16bits++;
-        {
+        }
-          *prxdata16bits = (uint16_t)(husart->Instance->DR & (uint16_t)0x01FF);
+        else
-          prxdata16bits++;
+        {
-        }
+          if ((husart->Init.WordLength == USART_WORDLENGTH_9B) || ((husart->Init.WordLength == USART_WORDLENGTH_8B) && (husart->Init.Parity == USART_PARITY_NONE)))
-        else
+          {
-        {
+            *prxdata8bits = (uint8_t)(husart->Instance->DR & (uint8_t)0x0FF);
-          if ((husart->Init.WordLength == USART_WORDLENGTH_9B) || ((husart->Init.WordLength == USART_WORDLENGTH_8B) && (husart->Init.Parity == USART_PARITY_NONE)))
+          }
-          {
+          else
-            *prxdata8bits = (uint8_t)(husart->Instance->DR & (uint8_t)0x0FF);
+          {
-          }
+            *prxdata8bits = (uint8_t)(husart->Instance->DR & (uint8_t)0x07F);
-          else
+          }
-          {
-            *prxdata8bits = (uint8_t)(husart->Instance->DR & (uint8_t)0x07F);
+          prxdata8bits++;
-          }
+        }
-          prxdata8bits++;
+        husart->RxXferCount--;
-        }
+      }
+      rxdatacount = husart->RxXferCount;
-        husart->RxXferCount--;
+    }
-      }
-      rxdatacount = husart->RxXferCount;
+    husart->State = HAL_USART_STATE_READY;
-    }
+    /* Process Unlocked */
-    husart->State = HAL_USART_STATE_READY;
+    __HAL_UNLOCK(husart);
-    /* Process Unlocked */
+    return HAL_OK;
-    __HAL_UNLOCK(husart);
+  }
+  else
-    return HAL_OK;
+  {
-  }
+    return HAL_BUSY;
-  else
+  }
-  {
+}
-    return HAL_BUSY;
-  }
+/**
-}
+  * @brief  Simplex Send an amount of data in non-blocking mode.
+  * @note   When USART parity is not enabled (PCE = 0), and Word Length is configured to 9 bits (M1-M0 = 01),
-/**
+  *         the sent data is handled as a set of u16. In this case, Size must indicate the number
-  * @brief  Simplex Send an amount of data in non-blocking mode.
+  *         of u16 provided through pTxData.
-  * @note   When USART parity is not enabled (PCE = 0), and Word Length is configured to 9 bits (M1-M0 = 01),
+  * @param  husart  Pointer to a USART_HandleTypeDef structure that contains
-  *         the sent data is handled as a set of u16. In this case, Size must indicate the number
+  *                 the configuration information for the specified USART module.
-  *         of u16 provided through pTxData.
+  * @param  pTxData Pointer to data buffer (u8 or u16 data elements).
-  * @param  husart  Pointer to a USART_HandleTypeDef structure that contains
+  * @param  Size    Amount of data elements (u8 or u16) to be sent.
-  *                 the configuration information for the specified USART module.
+  * @retval HAL status
-  * @param  pTxData Pointer to data buffer (u8 or u16 data elements).
+  * @note   The USART errors are not managed to avoid the overrun error.
-  * @param  Size    Amount of data elements (u8 or u16) to be sent.
+  */
-  * @retval HAL status
+HAL_StatusTypeDef HAL_USART_Transmit_IT(USART_HandleTypeDef *husart, const uint8_t *pTxData, uint16_t Size)
-  * @note   The USART errors are not managed to avoid the overrun error.
+{
-  */
+  if (husart->State == HAL_USART_STATE_READY)
-HAL_StatusTypeDef HAL_USART_Transmit_IT(USART_HandleTypeDef *husart, uint8_t *pTxData, uint16_t Size)
+  {
-{
+    if ((pTxData == NULL) || (Size == 0))
-  if (husart->State == HAL_USART_STATE_READY)
+    {
-  {
+      return HAL_ERROR;
-    if ((pTxData == NULL) || (Size == 0))
+    }
-    {
-      return HAL_ERROR;
+    /* Process Locked */
-    }
+    __HAL_LOCK(husart);
-    /* Process Locked */
+    husart->pTxBuffPtr = pTxData;
-    __HAL_LOCK(husart);
+    husart->TxXferSize = Size;
+    husart->TxXferCount = Size;
-    husart->pTxBuffPtr = pTxData;
-    husart->TxXferSize = Size;
+    husart->ErrorCode = HAL_USART_ERROR_NONE;
-    husart->TxXferCount = Size;
+    husart->State = HAL_USART_STATE_BUSY_TX;
-    husart->ErrorCode = HAL_USART_ERROR_NONE;
+    /* The USART Error Interrupts: (Frame error, Noise error, Overrun error)
-    husart->State = HAL_USART_STATE_BUSY_TX;
+       are not managed by the USART transmit process to avoid the overrun interrupt
+       when the USART mode is configured for transmit and receive "USART_MODE_TX_RX"
-    /* The USART Error Interrupts: (Frame error, Noise error, Overrun error)
+       to benefit for the frame error and noise interrupts the USART mode should be
-       are not managed by the USART transmit process to avoid the overrun interrupt
+       configured only for transmit "USART_MODE_TX"
-       when the USART mode is configured for transmit and receive "USART_MODE_TX_RX"
+       The __HAL_USART_ENABLE_IT(husart, USART_IT_ERR) can be used to enable the Frame error,
-       to benefit for the frame error and noise interrupts the USART mode should be
+       Noise error interrupt */
-       configured only for transmit "USART_MODE_TX"
-       The __HAL_USART_ENABLE_IT(husart, USART_IT_ERR) can be used to enable the Frame error,
+    /* Process Unlocked */
-       Noise error interrupt */
+    __HAL_UNLOCK(husart);
-    /* Process Unlocked */
+    /* Enable the USART Transmit Data Register Empty Interrupt */
-    __HAL_UNLOCK(husart);
+    SET_BIT(husart->Instance->CR1, USART_CR1_TXEIE);
-    /* Enable the USART Transmit Data Register Empty Interrupt */
+    return HAL_OK;
-    SET_BIT(husart->Instance->CR1, USART_CR1_TXEIE);
+  }
+  else
-    return HAL_OK;
+  {
-  }
+    return HAL_BUSY;
-  else
+  }
-  {
+}
-    return HAL_BUSY;
-  }
+/**
-}
+  * @brief  Simplex Receive an amount of data in non-blocking mode.
+  * @note   To receive synchronous data, dummy data are simultaneously transmitted.
-/**
+  * @note   When USART parity is not enabled (PCE = 0), and Word Length is configured to 9 bits (M1-M0 = 01),
-  * @brief  Simplex Receive an amount of data in non-blocking mode.
+  *         the received data is handled as a set of u16. In this case, Size must indicate the number
-  * @note   To receive synchronous data, dummy data are simultaneously transmitted.
+  *         of u16 available through pRxData.
-  * @note   When USART parity is not enabled (PCE = 0), and Word Length is configured to 9 bits (M1-M0 = 01),
+  * @param  husart  Pointer to a USART_HandleTypeDef structure that contains
-  *         the received data is handled as a set of u16. In this case, Size must indicate the number
+  *                 the configuration information for the specified USART module.
-  *         of u16 available through pRxData.
+  * @param  pRxData Pointer to data buffer (u8 or u16 data elements).
-  * @param  husart  Pointer to a USART_HandleTypeDef structure that contains
+  * @param  Size    Amount of data elements (u8 or u16) to be received.
-  *                 the configuration information for the specified USART module.
+  * @retval HAL status
-  * @param  pRxData Pointer to data buffer (u8 or u16 data elements).
+  */
-  * @param  Size    Amount of data elements (u8 or u16) to be received.
+HAL_StatusTypeDef HAL_USART_Receive_IT(USART_HandleTypeDef *husart, uint8_t *pRxData, uint16_t Size)
-  * @retval HAL status
+{
-  */
+  if (husart->State == HAL_USART_STATE_READY)
-HAL_StatusTypeDef HAL_USART_Receive_IT(USART_HandleTypeDef *husart, uint8_t *pRxData, uint16_t Size)
+  {
-{
+    if ((pRxData == NULL) || (Size == 0))
-  if (husart->State == HAL_USART_STATE_READY)
+    {
-  {
+      return HAL_ERROR;
-    if ((pRxData == NULL) || (Size == 0))
+    }
-    {
+    /* Process Locked */
-      return HAL_ERROR;
+    __HAL_LOCK(husart);
-    }
-    /* Process Locked */
+    husart->pRxBuffPtr = pRxData;
-    __HAL_LOCK(husart);
+    husart->RxXferSize = Size;
+    husart->RxXferCount = Size;
-    husart->pRxBuffPtr = pRxData;
-    husart->RxXferSize = Size;
+    husart->ErrorCode = HAL_USART_ERROR_NONE;
-    husart->RxXferCount = Size;
+    husart->State = HAL_USART_STATE_BUSY_RX;
-    husart->ErrorCode = HAL_USART_ERROR_NONE;
+    /* Process Unlocked */
-    husart->State = HAL_USART_STATE_BUSY_RX;
+    __HAL_UNLOCK(husart);
-    /* Process Unlocked */
+    if (husart->Init.Parity != USART_PARITY_NONE)
-    __HAL_UNLOCK(husart);
+    {
+      /* Enable the USART Parity Error and Data Register not empty Interrupts */
-    /* Enable the USART Parity Error and Data Register not empty Interrupts */
+      SET_BIT(husart->Instance->CR1, USART_CR1_PEIE | USART_CR1_RXNEIE);
-    SET_BIT(husart->Instance->CR1, USART_CR1_PEIE | USART_CR1_RXNEIE);
+    }
+    else
-    /* Enable the USART Error Interrupt: (Frame error, noise error, overrun error) */
+    {
-    SET_BIT(husart->Instance->CR3, USART_CR3_EIE);
+      /* Enable the USART Data Register not empty Interrupts */
+      SET_BIT(husart->Instance->CR1, USART_CR1_RXNEIE);
-    /* Send dummy byte in order to generate the clock for the slave to send data */
+    }
-    husart->Instance->DR = (DUMMY_DATA & (uint16_t)0x01FF);
+    /* Enable the USART Error Interrupt: (Frame error, noise error, overrun error) */
-    return HAL_OK;
+    SET_BIT(husart->Instance->CR3, USART_CR3_EIE);
-  }
-  else
+    /* Send dummy byte in order to generate the clock for the slave to send data */
-  {
+    husart->Instance->DR = (DUMMY_DATA & (uint16_t)0x01FF);
-    return HAL_BUSY;
-  }
+    return HAL_OK;
-}
+  }
+  else
-/**
+  {
-  * @brief  Full-Duplex Send and Receive an amount of data in full-duplex mode (non-blocking).
+    return HAL_BUSY;
-  * @note   When USART parity is not enabled (PCE = 0), and Word Length is configured to 9 bits (M1-M0 = 01),
+  }
-  *         the sent data and the received data are handled as sets of u16. In this case, Size must indicate the number
+}
-  *         of u16 available through pTxData and through pRxData.
-  * @param  husart  Pointer to a USART_HandleTypeDef structure that contains
+/**
-  *                 the configuration information for the specified USART module.
+  * @brief  Full-Duplex Send and Receive an amount of data in full-duplex mode (non-blocking).
-  * @param  pTxData Pointer to TX data buffer (u8 or u16 data elements).
+  * @note   When USART parity is not enabled (PCE = 0), and Word Length is configured to 9 bits (M1-M0 = 01),
-  * @param  pRxData Pointer to RX data buffer (u8 or u16 data elements).
+  *         the sent data and the received data are handled as sets of u16. In this case, Size must indicate the number
-  * @param  Size    Amount of data elements (u8 or u16) to be sent (same amount to be received).
+  *         of u16 available through pTxData and through pRxData.
-  * @retval HAL status
+  * @param  husart  Pointer to a USART_HandleTypeDef structure that contains
-  */
+  *                 the configuration information for the specified USART module.
-HAL_StatusTypeDef HAL_USART_TransmitReceive_IT(USART_HandleTypeDef *husart, uint8_t *pTxData, uint8_t *pRxData,  uint16_t Size)
+  * @param  pTxData Pointer to TX data buffer (u8 or u16 data elements).
-{
+  * @param  pRxData Pointer to RX data buffer (u8 or u16 data elements).
-  if (husart->State == HAL_USART_STATE_READY)
+  * @param  Size    Amount of data elements (u8 or u16) to be sent (same amount to be received).
-  {
+  * @retval HAL status
-    if ((pTxData == NULL) || (pRxData == NULL) || (Size == 0))
+  */
-    {
+HAL_StatusTypeDef HAL_USART_TransmitReceive_IT(USART_HandleTypeDef *husart, const uint8_t *pTxData, uint8_t *pRxData,
-      return HAL_ERROR;
+                                               uint16_t Size)
-    }
+{
-    /* Process Locked */
+  if (husart->State == HAL_USART_STATE_READY)
-    __HAL_LOCK(husart);
+  {
+    if ((pTxData == NULL) || (pRxData == NULL) || (Size == 0))
-    husart->pRxBuffPtr = pRxData;
+    {
-    husart->RxXferSize = Size;
+      return HAL_ERROR;
-    husart->RxXferCount = Size;
+    }
-    husart->pTxBuffPtr = pTxData;
+    /* Process Locked */
-    husart->TxXferSize = Size;
+    __HAL_LOCK(husart);
-    husart->TxXferCount = Size;
+    husart->pRxBuffPtr = pRxData;
-    husart->ErrorCode = HAL_USART_ERROR_NONE;
+    husart->RxXferSize = Size;
-    husart->State = HAL_USART_STATE_BUSY_TX_RX;
+    husart->RxXferCount = Size;
+    husart->pTxBuffPtr = pTxData;
-    /* Process Unlocked */
+    husart->TxXferSize = Size;
-    __HAL_UNLOCK(husart);
+    husart->TxXferCount = Size;
-    /* Enable the USART Data Register not empty Interrupt */
+    husart->ErrorCode = HAL_USART_ERROR_NONE;
-    SET_BIT(husart->Instance->CR1, USART_CR1_RXNEIE);
+    husart->State = HAL_USART_STATE_BUSY_TX_RX;
-    /* Enable the USART Parity Error Interrupt */
+    /* Process Unlocked */
-    SET_BIT(husart->Instance->CR1, USART_CR1_PEIE);
+    __HAL_UNLOCK(husart);
-    /* Enable the USART Error Interrupt: (Frame error, noise error, overrun error) */
+    /* Enable the USART Data Register not empty Interrupt */
-    SET_BIT(husart->Instance->CR3, USART_CR3_EIE);
+    SET_BIT(husart->Instance->CR1, USART_CR1_RXNEIE);
-    /* Enable the USART Transmit Data Register Empty Interrupt */
+    if (husart->Init.Parity != USART_PARITY_NONE)
-    SET_BIT(husart->Instance->CR1, USART_CR1_TXEIE);
+    {
+      /* Enable the USART Parity Error Interrupt */
-    return HAL_OK;
+      SET_BIT(husart->Instance->CR1, USART_CR1_PEIE);
-  }
+    }
-  else
-  {
+    /* Enable the USART Error Interrupt: (Frame error, noise error, overrun error) */
-    return HAL_BUSY;
+    SET_BIT(husart->Instance->CR3, USART_CR3_EIE);
-  }
-}
+    /* Enable the USART Transmit Data Register Empty Interrupt */
+    SET_BIT(husart->Instance->CR1, USART_CR1_TXEIE);
-/**
-  * @brief  Simplex Send an amount of data in DMA mode.
+    return HAL_OK;
-  * @note   When USART parity is not enabled (PCE = 0), and Word Length is configured to 9 bits (M1-M0 = 01),
+  }
-  *         the sent data is handled as a set of u16. In this case, Size must indicate the number
+  else
-  *         of u16 provided through pTxData.
+  {
-  * @param  husart  Pointer to a USART_HandleTypeDef structure that contains
+    return HAL_BUSY;
-  *                 the configuration information for the specified USART module.
+  }
-  * @param  pTxData Pointer to data buffer (u8 or u16 data elements).
+}
-  * @param  Size    Amount of data elements (u8 or u16) to be sent.
-  * @retval HAL status
+/**
-  */
+  * @brief  Simplex Send an amount of data in DMA mode.
-HAL_StatusTypeDef HAL_USART_Transmit_DMA(USART_HandleTypeDef *husart, uint8_t *pTxData, uint16_t Size)
+  * @note   When USART parity is not enabled (PCE = 0), and Word Length is configured to 9 bits (M1-M0 = 01),
-{
+  *         the sent data is handled as a set of u16. In this case, Size must indicate the number
-  uint32_t *tmp;
+  *         of u16 provided through pTxData.
+  * @param  husart  Pointer to a USART_HandleTypeDef structure that contains
-  if (husart->State == HAL_USART_STATE_READY)
+  *                 the configuration information for the specified USART module.
-  {
+  * @param  pTxData Pointer to data buffer (u8 or u16 data elements).
-    if ((pTxData == NULL) || (Size == 0))
+  * @param  Size    Amount of data elements (u8 or u16) to be sent.
-    {
+  * @retval HAL status
-      return HAL_ERROR;
+  */
-    }
+HAL_StatusTypeDef HAL_USART_Transmit_DMA(USART_HandleTypeDef *husart, const uint8_t *pTxData, uint16_t Size)
-    /* Process Locked */
+{
-    __HAL_LOCK(husart);
+  const uint32_t *tmp;
-    husart->pTxBuffPtr = pTxData;
+  if (husart->State == HAL_USART_STATE_READY)
-    husart->TxXferSize = Size;
+  {
-    husart->TxXferCount = Size;
+    if ((pTxData == NULL) || (Size == 0))
+    {
-    husart->ErrorCode = HAL_USART_ERROR_NONE;
+      return HAL_ERROR;
-    husart->State = HAL_USART_STATE_BUSY_TX;
+    }
+    /* Process Locked */
-    /* Set the USART DMA transfer complete callback */
+    __HAL_LOCK(husart);
-    husart->hdmatx->XferCpltCallback = USART_DMATransmitCplt;
+    husart->pTxBuffPtr = pTxData;
-    /* Set the USART DMA Half transfer complete callback */
+    husart->TxXferSize = Size;
-    husart->hdmatx->XferHalfCpltCallback = USART_DMATxHalfCplt;
+    husart->TxXferCount = Size;
-    /* Set the DMA error callback */
+    husart->ErrorCode = HAL_USART_ERROR_NONE;
-    husart->hdmatx->XferErrorCallback = USART_DMAError;
+    husart->State = HAL_USART_STATE_BUSY_TX;
-    /* Set the DMA abort callback */
+    /* Set the USART DMA transfer complete callback */
-    husart->hdmatx->XferAbortCallback = NULL;
+    husart->hdmatx->XferCpltCallback = USART_DMATransmitCplt;
-    /* Enable the USART transmit DMA channel */
+    /* Set the USART DMA Half transfer complete callback */
-    tmp = (uint32_t *)&pTxData;
+    husart->hdmatx->XferHalfCpltCallback = USART_DMATxHalfCplt;
-    HAL_DMA_Start_IT(husart->hdmatx, *(uint32_t *)tmp, (uint32_t)&husart->Instance->DR, Size);
+    /* Set the DMA error callback */
-    /* Clear the TC flag in the SR register by writing 0 to it */
+    husart->hdmatx->XferErrorCallback = USART_DMAError;
-    __HAL_USART_CLEAR_FLAG(husart, USART_FLAG_TC);
+    /* Set the DMA abort callback */
-    /* Process Unlocked */
+    husart->hdmatx->XferAbortCallback = NULL;
-    __HAL_UNLOCK(husart);
+    /* Enable the USART transmit DMA channel */
-    /* Enable the DMA transfer for transmit request by setting the DMAT bit
+    tmp = (const uint32_t *)&pTxData;
-    in the USART CR3 register */
+    HAL_DMA_Start_IT(husart->hdmatx, *(const uint32_t *)tmp, (uint32_t)&husart->Instance->DR, Size);
-    SET_BIT(husart->Instance->CR3, USART_CR3_DMAT);
+    /* Clear the TC flag in the SR register by writing 0 to it */
-    return HAL_OK;
+    __HAL_USART_CLEAR_FLAG(husart, USART_FLAG_TC);
-  }
-  else
+    /* Process Unlocked */
-  {
+    __HAL_UNLOCK(husart);
-    return HAL_BUSY;
-  }
+    /* Enable the DMA transfer for transmit request by setting the DMAT bit
-}
+    in the USART CR3 register */
+    SET_BIT(husart->Instance->CR3, USART_CR3_DMAT);
-/**
-  * @brief  Full-Duplex Receive an amount of data in DMA mode.
+    return HAL_OK;
-  * @note   When USART parity is not enabled (PCE = 0), and Word Length is configured to 9 bits (M1-M0 = 01),
+  }
-  *         the received data is handled as a set of u16. In this case, Size must indicate the number
+  else
-  *         of u16 available through pRxData.
+  {
-  * @param  husart  Pointer to a USART_HandleTypeDef structure that contains
+    return HAL_BUSY;
-  *                 the configuration information for the specified USART module.
+  }
-  * @param  pRxData Pointer to data buffer (u8 or u16 data elements).
+}
-  * @param  Size    Amount of data elements (u8 or u16) to be received.
-  * @retval HAL status
+/**
-  * @note   The USART DMA transmit channel must be configured in order to generate the clock for the slave.
+  * @brief  Full-Duplex Receive an amount of data in DMA mode.
-  * @note   When the USART parity is enabled (PCE = 1) the data received contain the parity bit.
+  * @note   When USART parity is not enabled (PCE = 0), and Word Length is configured to 9 bits (M1-M0 = 01),
-  */
+  *         the received data is handled as a set of u16. In this case, Size must indicate the number
-HAL_StatusTypeDef HAL_USART_Receive_DMA(USART_HandleTypeDef *husart, uint8_t *pRxData, uint16_t Size)
+  *         of u16 available through pRxData.
-{
+  * @param  husart  Pointer to a USART_HandleTypeDef structure that contains
-  uint32_t *tmp;
+  *                 the configuration information for the specified USART module.
+  * @param  pRxData Pointer to data buffer (u8 or u16 data elements).
-  if (husart->State == HAL_USART_STATE_READY)
+  * @param  Size    Amount of data elements (u8 or u16) to be received.
-  {
+  * @retval HAL status
-    if ((pRxData == NULL) || (Size == 0))
+  * @note   The USART DMA transmit channel must be configured in order to generate the clock for the slave.
-    {
+  * @note   When the USART parity is enabled (PCE = 1) the data received contain the parity bit.
-      return HAL_ERROR;
+  */
-    }
+HAL_StatusTypeDef HAL_USART_Receive_DMA(USART_HandleTypeDef *husart, uint8_t *pRxData, uint16_t Size)
+{
-    /* Process Locked */
+  uint32_t *tmp;
-    __HAL_LOCK(husart);
+  if (husart->State == HAL_USART_STATE_READY)
-    husart->pRxBuffPtr = pRxData;
+  {
-    husart->RxXferSize = Size;
+    if ((pRxData == NULL) || (Size == 0))
-    husart->pTxBuffPtr = pRxData;
+    {
-    husart->TxXferSize = Size;
+      return HAL_ERROR;
+    }
-    husart->ErrorCode = HAL_USART_ERROR_NONE;
-    husart->State = HAL_USART_STATE_BUSY_RX;
+    /* Process Locked */
+    __HAL_LOCK(husart);
-    /* Set the USART DMA Rx transfer complete callback */
-    husart->hdmarx->XferCpltCallback = USART_DMAReceiveCplt;
+    husart->pRxBuffPtr = pRxData;
+    husart->RxXferSize = Size;
-    /* Set the USART DMA Half transfer complete callback */
+    husart->pTxBuffPtr = pRxData;
-    husart->hdmarx->XferHalfCpltCallback = USART_DMARxHalfCplt;
+    husart->TxXferSize = Size;
-    /* Set the USART DMA Rx transfer error callback */
+    husart->ErrorCode = HAL_USART_ERROR_NONE;
-    husart->hdmarx->XferErrorCallback = USART_DMAError;
+    husart->State = HAL_USART_STATE_BUSY_RX;
-    /* Set the DMA abort callback */
+    /* Set the USART DMA Rx transfer complete callback */
-    husart->hdmarx->XferAbortCallback = NULL;
+    husart->hdmarx->XferCpltCallback = USART_DMAReceiveCplt;
-    /* Set the USART Tx DMA transfer complete callback as NULL because the communication closing
+    /* Set the USART DMA Half transfer complete callback */
-    is performed in DMA reception complete callback  */
+    husart->hdmarx->XferHalfCpltCallback = USART_DMARxHalfCplt;
-    husart->hdmatx->XferHalfCpltCallback = NULL;
-    husart->hdmatx->XferCpltCallback = NULL;
+    /* Set the USART DMA Rx transfer error callback */
+    husart->hdmarx->XferErrorCallback = USART_DMAError;
-    /* Set the DMA error callback */
-    husart->hdmatx->XferErrorCallback = USART_DMAError;
+    /* Set the DMA abort callback */
+    husart->hdmarx->XferAbortCallback = NULL;
-    /* Set the DMA AbortCpltCallback */
-    husart->hdmatx->XferAbortCallback = NULL;
+    /* Set the USART Tx DMA transfer complete callback as NULL because the communication closing
+    is performed in DMA reception complete callback  */
-    /* Enable the USART receive DMA channel */
+    husart->hdmatx->XferHalfCpltCallback = NULL;
-    tmp = (uint32_t *)&pRxData;
+    husart->hdmatx->XferCpltCallback = NULL;
-    HAL_DMA_Start_IT(husart->hdmarx, (uint32_t)&husart->Instance->DR, *(uint32_t *)tmp, Size);
+    /* Set the DMA error callback */
-    /* Enable the USART transmit DMA channel: the transmit channel is used in order
+    husart->hdmatx->XferErrorCallback = USART_DMAError;
-       to generate in the non-blocking mode the clock to the slave device,
-       this mode isn't a simplex receive mode but a full-duplex receive one */
+    /* Set the DMA AbortCpltCallback */
-    HAL_DMA_Start_IT(husart->hdmatx, *(uint32_t *)tmp, (uint32_t)&husart->Instance->DR, Size);
+    husart->hdmatx->XferAbortCallback = NULL;
-    /* Clear the Overrun flag just before enabling the DMA Rx request: mandatory for the second transfer */
+    /* Enable the USART receive DMA channel */
-    __HAL_USART_CLEAR_OREFLAG(husart);
+    tmp = (uint32_t *)&pRxData;
+    HAL_DMA_Start_IT(husart->hdmarx, (uint32_t)&husart->Instance->DR, *(uint32_t *)tmp, Size);
-    /* Process Unlocked */
-    __HAL_UNLOCK(husart);
+    /* Enable the USART transmit DMA channel: the transmit channel is used in order
+       to generate in the non-blocking mode the clock to the slave device,
-    /* Enable the USART Parity Error Interrupt */
+       this mode isn't a simplex receive mode but a full-duplex receive one */
-    SET_BIT(husart->Instance->CR1, USART_CR1_PEIE);
+    HAL_DMA_Start_IT(husart->hdmatx, *(uint32_t *)tmp, (uint32_t)&husart->Instance->DR, Size);
-    /* Enable the USART Error Interrupt: (Frame error, noise error, overrun error) */
+    /* Clear the Overrun flag just before enabling the DMA Rx request: mandatory for the second transfer */
-    SET_BIT(husart->Instance->CR3, USART_CR3_EIE);
+    __HAL_USART_CLEAR_OREFLAG(husart);
-    /* Enable the DMA transfer for the receiver request by setting the DMAR bit
+    /* Process Unlocked */
-       in the USART CR3 register */
+    __HAL_UNLOCK(husart);
-    SET_BIT(husart->Instance->CR3, USART_CR3_DMAR);
+    if (husart->Init.Parity != USART_PARITY_NONE)
-    /* Enable the DMA transfer for transmit request by setting the DMAT bit
+    {
-       in the USART CR3 register */
+      /* Enable the USART Parity Error Interrupt */
-    SET_BIT(husart->Instance->CR3, USART_CR3_DMAT);
+      SET_BIT(husart->Instance->CR1, USART_CR1_PEIE);
+    }
-    return HAL_OK;
-  }
+    /* Enable the USART Error Interrupt: (Frame error, noise error, overrun error) */
-  else
+    SET_BIT(husart->Instance->CR3, USART_CR3_EIE);
-  {
-    return HAL_BUSY;
+    /* Enable the DMA transfer for the receiver request by setting the DMAR bit
-  }
+       in the USART CR3 register */
-}
+    SET_BIT(husart->Instance->CR3, USART_CR3_DMAR);
-/**
+    /* Enable the DMA transfer for transmit request by setting the DMAT bit
-  * @brief  Full-Duplex Transmit Receive an amount of data in DMA mode.
+       in the USART CR3 register */
-  * @note   When USART parity is not enabled (PCE = 0), and Word Length is configured to 9 bits (M1-M0 = 01),
+    SET_BIT(husart->Instance->CR3, USART_CR3_DMAT);
-  *         the sent data and the received data are handled as sets of u16. In this case, Size must indicate the number
-  *         of u16 available through pTxData and through pRxData.
+    return HAL_OK;
-  * @param  husart  Pointer to a USART_HandleTypeDef structure that contains
+  }
-  *                 the configuration information for the specified USART module.
+  else
-  * @param  pTxData Pointer to TX data buffer (u8 or u16 data elements).
+  {
-  * @param  pRxData Pointer to RX data buffer (u8 or u16 data elements).
+    return HAL_BUSY;
-  * @param  Size    Amount of data elements (u8 or u16) to be received/sent.
+  }
-  * @note   When the USART parity is enabled (PCE = 1) the data received contain the parity bit.
+}
-  * @retval HAL status
-  */
+/**
-HAL_StatusTypeDef HAL_USART_TransmitReceive_DMA(USART_HandleTypeDef *husart, uint8_t *pTxData, uint8_t *pRxData, uint16_t Size)
+  * @brief  Full-Duplex Transmit Receive an amount of data in DMA mode.
-{
+  * @note   When USART parity is not enabled (PCE = 0), and Word Length is configured to 9 bits (M1-M0 = 01),
-  uint32_t *tmp;
+  *         the sent data and the received data are handled as sets of u16. In this case, Size must indicate the number
+  *         of u16 available through pTxData and through pRxData.
-  if (husart->State == HAL_USART_STATE_READY)
+  * @param  husart  Pointer to a USART_HandleTypeDef structure that contains
-  {
+  *                 the configuration information for the specified USART module.
-    if ((pTxData == NULL) || (pRxData == NULL) || (Size == 0))
+  * @param  pTxData Pointer to TX data buffer (u8 or u16 data elements).
-    {
+  * @param  pRxData Pointer to RX data buffer (u8 or u16 data elements).
-      return HAL_ERROR;
+  * @param  Size    Amount of data elements (u8 or u16) to be received/sent.
-    }
+  * @note   When the USART parity is enabled (PCE = 1) the data received contain the parity bit.
-    /* Process Locked */
+  * @retval HAL status
-    __HAL_LOCK(husart);
+  */
+HAL_StatusTypeDef HAL_USART_TransmitReceive_DMA(USART_HandleTypeDef *husart, const uint8_t *pTxData, uint8_t *pRxData,
-    husart->pRxBuffPtr = pRxData;
+                                                uint16_t Size)
-    husart->RxXferSize = Size;
+{
-    husart->pTxBuffPtr = pTxData;
+  const uint32_t *tmp;
-    husart->TxXferSize = Size;
+  if (husart->State == HAL_USART_STATE_READY)
-    husart->ErrorCode = HAL_USART_ERROR_NONE;
+  {
-    husart->State = HAL_USART_STATE_BUSY_TX_RX;
+    if ((pTxData == NULL) || (pRxData == NULL) || (Size == 0))
+    {
-    /* Set the USART DMA Rx transfer complete callback */
+      return HAL_ERROR;
-    husart->hdmarx->XferCpltCallback = USART_DMAReceiveCplt;
+    }
+    /* Process Locked */
-    /* Set the USART DMA Half transfer complete callback */
+    __HAL_LOCK(husart);
-    husart->hdmarx->XferHalfCpltCallback = USART_DMARxHalfCplt;
+    husart->pRxBuffPtr = pRxData;
-    /* Set the USART DMA Tx transfer complete callback */
+    husart->RxXferSize = Size;
-    husart->hdmatx->XferCpltCallback = USART_DMATransmitCplt;
+    husart->pTxBuffPtr = pTxData;
+    husart->TxXferSize = Size;
-    /* Set the USART DMA Half transfer complete callback */
-    husart->hdmatx->XferHalfCpltCallback = USART_DMATxHalfCplt;
+    husart->ErrorCode = HAL_USART_ERROR_NONE;
+    husart->State = HAL_USART_STATE_BUSY_TX_RX;
-    /* Set the USART DMA Tx transfer error callback */
-    husart->hdmatx->XferErrorCallback = USART_DMAError;
+    /* Set the USART DMA Rx transfer complete callback */
+    husart->hdmarx->XferCpltCallback = USART_DMAReceiveCplt;
-    /* Set the USART DMA Rx transfer error callback */
-    husart->hdmarx->XferErrorCallback = USART_DMAError;
+    /* Set the USART DMA Half transfer complete callback */
+    husart->hdmarx->XferHalfCpltCallback = USART_DMARxHalfCplt;
-    /* Set the DMA abort callback */
-    husart->hdmarx->XferAbortCallback = NULL;
+    /* Set the USART DMA Tx transfer complete callback */
+    husart->hdmatx->XferCpltCallback = USART_DMATransmitCplt;
-    /* Enable the USART receive DMA channel */
-    tmp = (uint32_t *)&pRxData;
+    /* Set the USART DMA Half transfer complete callback */
-    HAL_DMA_Start_IT(husart->hdmarx, (uint32_t)&husart->Instance->DR, *(uint32_t *)tmp, Size);
+    husart->hdmatx->XferHalfCpltCallback = USART_DMATxHalfCplt;
-    /* Enable the USART transmit DMA channel */
+    /* Set the USART DMA Tx transfer error callback */
-    tmp = (uint32_t *)&pTxData;
+    husart->hdmatx->XferErrorCallback = USART_DMAError;
-    HAL_DMA_Start_IT(husart->hdmatx, *(uint32_t *)tmp, (uint32_t)&husart->Instance->DR, Size);
+    /* Set the USART DMA Rx transfer error callback */
-    /* Clear the TC flag in the SR register by writing 0 to it */
+    husart->hdmarx->XferErrorCallback = USART_DMAError;
-    __HAL_USART_CLEAR_FLAG(husart, USART_FLAG_TC);
+    /* Set the DMA abort callback */
-    /* Clear the Overrun flag: mandatory for the second transfer in circular mode */
+    husart->hdmarx->XferAbortCallback = NULL;
-    __HAL_USART_CLEAR_OREFLAG(husart);
+    /* Enable the USART receive DMA channel */
-    /* Process Unlocked */
+    tmp = (uint32_t *)&pRxData;
-    __HAL_UNLOCK(husart);
+    HAL_DMA_Start_IT(husart->hdmarx, (uint32_t)&husart->Instance->DR, *(const uint32_t *)tmp, Size);
-    /* Enable the USART Parity Error Interrupt */
+    /* Enable the USART transmit DMA channel */
-    SET_BIT(husart->Instance->CR1, USART_CR1_PEIE);
+    tmp = (const uint32_t *)&pTxData;
+    HAL_DMA_Start_IT(husart->hdmatx, *(const uint32_t *)tmp, (uint32_t)&husart->Instance->DR, Size);
-    /* Enable the USART Error Interrupt: (Frame error, noise error, overrun error) */
-    SET_BIT(husart->Instance->CR3, USART_CR3_EIE);
+    /* Clear the TC flag in the SR register by writing 0 to it */
+    __HAL_USART_CLEAR_FLAG(husart, USART_FLAG_TC);
-    /* Enable the DMA transfer for the receiver request by setting the DMAR bit
-       in the USART CR3 register */
+    /* Clear the Overrun flag: mandatory for the second transfer in circular mode */
-    SET_BIT(husart->Instance->CR3, USART_CR3_DMAR);
+    __HAL_USART_CLEAR_OREFLAG(husart);
-    /* Enable the DMA transfer for transmit request by setting the DMAT bit
+    /* Process Unlocked */
-       in the USART CR3 register */
+    __HAL_UNLOCK(husart);
-    SET_BIT(husart->Instance->CR3, USART_CR3_DMAT);
+    if (husart->Init.Parity != USART_PARITY_NONE)
-    return HAL_OK;
+    {
-  }
+      /* Enable the USART Parity Error Interrupt */
-  else
+      SET_BIT(husart->Instance->CR1, USART_CR1_PEIE);
-  {
+    }
-    return HAL_BUSY;
-  }
+    /* Enable the USART Error Interrupt: (Frame error, noise error, overrun error) */
-}
+    SET_BIT(husart->Instance->CR3, USART_CR3_EIE);
-/**
+    /* Enable the DMA transfer for the receiver request by setting the DMAR bit
-  * @brief  Pauses the DMA Transfer.
+       in the USART CR3 register */
-  * @param  husart Pointer to a USART_HandleTypeDef structure that contains
+    SET_BIT(husart->Instance->CR3, USART_CR3_DMAR);
-  *                the configuration information for the specified USART module.
-  * @retval HAL status
+    /* Enable the DMA transfer for transmit request by setting the DMAT bit
-  */
+       in the USART CR3 register */
-HAL_StatusTypeDef HAL_USART_DMAPause(USART_HandleTypeDef *husart)
+    SET_BIT(husart->Instance->CR3, USART_CR3_DMAT);
-{
-  /* Process Locked */
+    return HAL_OK;
-  __HAL_LOCK(husart);
+  }
+  else
-  /* Disable the USART DMA Tx request */
+  {
-  CLEAR_BIT(husart->Instance->CR3, USART_CR3_DMAT);
+    return HAL_BUSY;
+  }
-  /* Process Unlocked */
+}
-  __HAL_UNLOCK(husart);
+/**
-  return HAL_OK;
+  * @brief  Pauses the DMA Transfer.
-}
+  * @param  husart Pointer to a USART_HandleTypeDef structure that contains
+  *                the configuration information for the specified USART module.
-/**
+  * @retval HAL status
-  * @brief  Resumes the DMA Transfer.
+  */
-  * @param  husart Pointer to a USART_HandleTypeDef structure that contains
+HAL_StatusTypeDef HAL_USART_DMAPause(USART_HandleTypeDef *husart)
-  *                the configuration information for the specified USART module.
+{
-  * @retval HAL status
+  /* Process Locked */
-  */
+  __HAL_LOCK(husart);
-HAL_StatusTypeDef HAL_USART_DMAResume(USART_HandleTypeDef *husart)
-{
+  /* Disable the USART DMA Tx request */
-  /* Process Locked */
+  CLEAR_BIT(husart->Instance->CR3, USART_CR3_DMAT);
-  __HAL_LOCK(husart);
+  /* Process Unlocked */
-  /* Enable the USART DMA Tx request */
+  __HAL_UNLOCK(husart);
-  SET_BIT(husart->Instance->CR3, USART_CR3_DMAT);
+  return HAL_OK;
-  /* Process Unlocked */
+}
-  __HAL_UNLOCK(husart);
+/**
-  return HAL_OK;
+  * @brief  Resumes the DMA Transfer.
-}
+  * @param  husart Pointer to a USART_HandleTypeDef structure that contains
+  *                the configuration information for the specified USART module.
-/**
+  * @retval HAL status
-  * @brief  Stops the DMA Transfer.
+  */
-  * @param  husart Pointer to a USART_HandleTypeDef structure that contains
+HAL_StatusTypeDef HAL_USART_DMAResume(USART_HandleTypeDef *husart)
-  *                the configuration information for the specified USART module.
+{
-  * @retval HAL status
+  /* Process Locked */
-  */
+  __HAL_LOCK(husart);
-HAL_StatusTypeDef HAL_USART_DMAStop(USART_HandleTypeDef *husart)
-{
+  /* Enable the USART DMA Tx request */
-  uint32_t dmarequest = 0x00U;
+  SET_BIT(husart->Instance->CR3, USART_CR3_DMAT);
-  /* The Lock is not implemented on this API to allow the user application
-     to call the HAL USART API under callbacks HAL_USART_TxCpltCallback() / HAL_USART_RxCpltCallback():
+  /* Process Unlocked */
-     when calling HAL_DMA_Abort() API the DMA TX/RX Transfer complete interrupt is generated
+  __HAL_UNLOCK(husart);
-     and the correspond call back is executed HAL_USART_TxCpltCallback() / HAL_USART_RxCpltCallback()
-     */
+  return HAL_OK;
+}
-  /* Stop USART DMA Tx request if ongoing */
-  dmarequest = HAL_IS_BIT_SET(husart->Instance->CR3, USART_CR3_DMAT);
+/**
-  if ((husart->State == HAL_USART_STATE_BUSY_TX) && dmarequest)
+  * @brief  Stops the DMA Transfer.
-  {
+  * @param  husart Pointer to a USART_HandleTypeDef structure that contains
-    USART_EndTxTransfer(husart);
+  *                the configuration information for the specified USART module.
+  * @retval HAL status
-    /* Abort the USART DMA Tx channel */
+  */
-    if (husart->hdmatx != NULL)
+HAL_StatusTypeDef HAL_USART_DMAStop(USART_HandleTypeDef *husart)
-    {
+{
-      HAL_DMA_Abort(husart->hdmatx);
+  uint32_t dmarequest = 0x00U;
-    }
+  /* The Lock is not implemented on this API to allow the user application
+     to call the HAL USART API under callbacks HAL_USART_TxCpltCallback() / HAL_USART_RxCpltCallback():
-    /* Disable the USART Tx DMA request */
+     when calling HAL_DMA_Abort() API the DMA TX/RX Transfer complete interrupt is generated
-    CLEAR_BIT(husart->Instance->CR3, USART_CR3_DMAT);
+     and the correspond call back is executed HAL_USART_TxCpltCallback() / HAL_USART_RxCpltCallback()
-  }
+     */
-  /* Stop USART DMA Rx request if ongoing */
+  /* Stop USART DMA Tx request if ongoing */
-  dmarequest = HAL_IS_BIT_SET(husart->Instance->CR3, USART_CR3_DMAR);
+  dmarequest = HAL_IS_BIT_SET(husart->Instance->CR3, USART_CR3_DMAT);
-  if ((husart->State == HAL_USART_STATE_BUSY_RX) && dmarequest)
+  if ((husart->State == HAL_USART_STATE_BUSY_TX) && dmarequest)
   {
-    USART_EndRxTransfer(husart);
+    USART_EndTxTransfer(husart);
-    /* Abort the USART DMA Rx channel */
+    /* Abort the USART DMA Tx channel */
-    if (husart->hdmarx != NULL)
+    if (husart->hdmatx != NULL)
     {
-      HAL_DMA_Abort(husart->hdmarx);
+      HAL_DMA_Abort(husart->hdmatx);
     }
-    /* Disable the USART Rx DMA request */
+    /* Disable the USART Tx DMA request */
-    CLEAR_BIT(husart->Instance->CR3, USART_CR3_DMAR);
+    CLEAR_BIT(husart->Instance->CR3, USART_CR3_DMAT);
   }
-  return HAL_OK;
+  /* Stop USART DMA Rx request if ongoing */
-}
+  dmarequest = HAL_IS_BIT_SET(husart->Instance->CR3, USART_CR3_DMAR);
+  if ((husart->State == HAL_USART_STATE_BUSY_RX) && dmarequest)
-/**
+  {
-  * @brief  Abort ongoing transfer (blocking mode).
+    USART_EndRxTransfer(husart);
-  * @param  husart USART handle.
-  * @note   This procedure could be used for aborting any ongoing transfer (either Tx or Rx,
+    /* Abort the USART DMA Rx channel */
-  *         as described by TransferType parameter) started in Interrupt or DMA mode.
+    if (husart->hdmarx != NULL)
-  *         This procedure performs following operations :
+    {
-  *           - Disable PPP Interrupts (depending of transfer direction)
+      HAL_DMA_Abort(husart->hdmarx);
-  *           - Disable the DMA transfer in the peripheral register (if enabled)
+    }
-  *           - Abort DMA transfer by calling HAL_DMA_Abort (in case of transfer in DMA mode)
-  *           - Set handle State to READY
+    /* Disable the USART Rx DMA request */
-  * @note   This procedure is executed in blocking mode : when exiting function, Abort is considered as completed.
+    CLEAR_BIT(husart->Instance->CR3, USART_CR3_DMAR);
-  * @retval HAL status
+  }
-*/
-HAL_StatusTypeDef HAL_USART_Abort(USART_HandleTypeDef *husart)
+  return HAL_OK;
-{
+}
-  /* Disable TXEIE, TCIE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts */
-  CLEAR_BIT(husart->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE | USART_CR1_TXEIE | USART_CR1_TCIE));
+/**
-  CLEAR_BIT(husart->Instance->CR3, USART_CR3_EIE);
+  * @brief  Abort ongoing transfer (blocking mode).
+  * @param  husart USART handle.
-  /* Disable the USART DMA Tx request if enabled */
+  * @note   This procedure could be used for aborting any ongoing transfer (either Tx or Rx,
-  if (HAL_IS_BIT_SET(husart->Instance->CR3, USART_CR3_DMAT))
+  *         as described by TransferType parameter) started in Interrupt or DMA mode.
-  {
+  *         This procedure performs following operations :
-    CLEAR_BIT(husart->Instance->CR3, USART_CR3_DMAT);
+  *           - Disable PPP Interrupts (depending of transfer direction)
+  *           - Disable the DMA transfer in the peripheral register (if enabled)
-    /* Abort the USART DMA Tx channel : use blocking DMA Abort API (no callback) */
+  *           - Abort DMA transfer by calling HAL_DMA_Abort (in case of transfer in DMA mode)
-    if (husart->hdmatx != NULL)
+  *           - Set handle State to READY
-    {
+  * @note   This procedure is executed in blocking mode : when exiting function, Abort is considered as completed.
-      /* Set the USART DMA Abort callback to Null.
+  * @retval HAL status
-         No call back execution at end of DMA abort procedure */
+  */
-      husart->hdmatx->XferAbortCallback = NULL;
+HAL_StatusTypeDef HAL_USART_Abort(USART_HandleTypeDef *husart)
+{
-      HAL_DMA_Abort(husart->hdmatx);
+  /* Disable TXEIE, TCIE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts */
-    }
+  CLEAR_BIT(husart->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE | USART_CR1_TXEIE | USART_CR1_TCIE));
-  }
+  CLEAR_BIT(husart->Instance->CR3, USART_CR3_EIE);
-  /* Disable the USART DMA Rx request if enabled */
+  /* Disable the USART DMA Tx request if enabled */
-  if (HAL_IS_BIT_SET(husart->Instance->CR3, USART_CR3_DMAR))
+  if (HAL_IS_BIT_SET(husart->Instance->CR3, USART_CR3_DMAT))
   {
-    CLEAR_BIT(husart->Instance->CR3, USART_CR3_DMAR);
+    CLEAR_BIT(husart->Instance->CR3, USART_CR3_DMAT);
-    /* Abort the USART DMA Rx channel : use blocking DMA Abort API (no callback) */
+    /* Abort the USART DMA Tx channel : use blocking DMA Abort API (no callback) */
-    if (husart->hdmarx != NULL)
+    if (husart->hdmatx != NULL)
     {
       /* Set the USART DMA Abort callback to Null.
          No call back execution at end of DMA abort procedure */
-      husart->hdmarx->XferAbortCallback = NULL;
+      husart->hdmatx->XferAbortCallback = NULL;
-      HAL_DMA_Abort(husart->hdmarx);
+      HAL_DMA_Abort(husart->hdmatx);
     }
   }
-  /* Reset Tx and Rx transfer counters */
+  /* Disable the USART DMA Rx request if enabled */
-  husart->TxXferCount = 0x00U;
+  if (HAL_IS_BIT_SET(husart->Instance->CR3, USART_CR3_DMAR))
-  husart->RxXferCount = 0x00U;
+  {
+    CLEAR_BIT(husart->Instance->CR3, USART_CR3_DMAR);
-  /* Restore husart->State to Ready */
-  husart->State  = HAL_USART_STATE_READY;
+    /* Abort the USART DMA Rx channel : use blocking DMA Abort API (no callback) */
+    if (husart->hdmarx != NULL)
-  /* Reset Handle ErrorCode to No Error */
+    {
-  husart->ErrorCode = HAL_USART_ERROR_NONE;
+      /* Set the USART DMA Abort callback to Null.
+         No call back execution at end of DMA abort procedure */
-  return HAL_OK;
+      husart->hdmarx->XferAbortCallback = NULL;
-}
+      HAL_DMA_Abort(husart->hdmarx);
-/**
+    }
-  * @brief  Abort ongoing transfer (Interrupt mode).
+  }
-  * @param  husart USART handle.
-  * @note   This procedure could be used for aborting any ongoing transfer (either Tx or Rx,
+  /* Reset Tx and Rx transfer counters */
-  *         as described by TransferType parameter) started in Interrupt or DMA mode.
+  husart->TxXferCount = 0x00U;
-  *         This procedure performs following operations :
+  husart->RxXferCount = 0x00U;
-  *           - Disable PPP Interrupts (depending of transfer direction)
-  *           - Disable the DMA transfer in the peripheral register (if enabled)
+  /* Restore husart->State to Ready */
-  *           - Abort DMA transfer by calling HAL_DMA_Abort_IT (in case of transfer in DMA mode)
+  husart->State  = HAL_USART_STATE_READY;
-  *           - Set handle State to READY
-  *           - At abort completion, call user abort complete callback
+  /* Reset Handle ErrorCode to No Error */
-  * @note   This procedure is executed in Interrupt mode, meaning that abort procedure could be
+  husart->ErrorCode = HAL_USART_ERROR_NONE;
-  *         considered as completed only when user abort complete callback is executed (not when exiting function).
-  * @retval HAL status
+  return HAL_OK;
-*/
+}
-HAL_StatusTypeDef HAL_USART_Abort_IT(USART_HandleTypeDef *husart)
-{
+/**
-  uint32_t AbortCplt = 0x01U;
+  * @brief  Abort ongoing transfer (Interrupt mode).
+  * @param  husart USART handle.
-  /* Disable TXEIE, TCIE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts */
+  * @note   This procedure could be used for aborting any ongoing transfer (either Tx or Rx,
-  CLEAR_BIT(husart->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE | USART_CR1_TXEIE | USART_CR1_TCIE));
+  *         as described by TransferType parameter) started in Interrupt or DMA mode.
-  CLEAR_BIT(husart->Instance->CR3, USART_CR3_EIE);
+  *         This procedure performs following operations :
+  *           - Disable PPP Interrupts (depending of transfer direction)
-  /* If DMA Tx and/or DMA Rx Handles are associated to USART Handle, DMA Abort complete callbacks should be initialised
+  *           - Disable the DMA transfer in the peripheral register (if enabled)
-     before any call to DMA Abort functions */
+  *           - Abort DMA transfer by calling HAL_DMA_Abort_IT (in case of transfer in DMA mode)
-  /* DMA Tx Handle is valid */
+  *           - Set handle State to READY
-  if (husart->hdmatx != NULL)
+  *           - At abort completion, call user abort complete callback
-  {
+  * @note   This procedure is executed in Interrupt mode, meaning that abort procedure could be
-    /* Set DMA Abort Complete callback if USART DMA Tx request if enabled.
+  *         considered as completed only when user abort complete callback is executed (not when exiting function).
-       Otherwise, set it to NULL */
+  * @retval HAL status
-    if (HAL_IS_BIT_SET(husart->Instance->CR3, USART_CR3_DMAT))
+  */
-    {
+HAL_StatusTypeDef HAL_USART_Abort_IT(USART_HandleTypeDef *husart)
-      husart->hdmatx->XferAbortCallback = USART_DMATxAbortCallback;
+{
-    }
+  uint32_t AbortCplt = 0x01U;
-    else
-    {
+  /* Disable TXEIE, TCIE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts */
-      husart->hdmatx->XferAbortCallback = NULL;
+  CLEAR_BIT(husart->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE | USART_CR1_TXEIE | USART_CR1_TCIE));
-    }
+  CLEAR_BIT(husart->Instance->CR3, USART_CR3_EIE);
-  }
-  /* DMA Rx Handle is valid */
+  /* If DMA Tx and/or DMA Rx Handles are associated to USART Handle, DMA Abort complete callbacks should be initialised
-  if (husart->hdmarx != NULL)
+     before any call to DMA Abort functions */
-  {
+  /* DMA Tx Handle is valid */
-    /* Set DMA Abort Complete callback if USART DMA Rx request if enabled.
+  if (husart->hdmatx != NULL)
-       Otherwise, set it to NULL */
+  {
-    if (HAL_IS_BIT_SET(husart->Instance->CR3, USART_CR3_DMAR))
+    /* Set DMA Abort Complete callback if USART DMA Tx request if enabled.
-    {
+       Otherwise, set it to NULL */
-      husart->hdmarx->XferAbortCallback = USART_DMARxAbortCallback;
+    if (HAL_IS_BIT_SET(husart->Instance->CR3, USART_CR3_DMAT))
-    }
+    {
-    else
+      husart->hdmatx->XferAbortCallback = USART_DMATxAbortCallback;
-    {
+    }
-      husart->hdmarx->XferAbortCallback = NULL;
+    else
-    }
+    {
-  }
+      husart->hdmatx->XferAbortCallback = NULL;
+    }
-  /* Disable the USART DMA Tx request if enabled */
+  }
-  if (HAL_IS_BIT_SET(husart->Instance->CR3, USART_CR3_DMAT))
+  /* DMA Rx Handle is valid */
-  {
+  if (husart->hdmarx != NULL)
-    /* Disable DMA Tx at USART level */
+  {
-    CLEAR_BIT(husart->Instance->CR3, USART_CR3_DMAT);
+    /* Set DMA Abort Complete callback if USART DMA Rx request if enabled.
+       Otherwise, set it to NULL */
-    /* Abort the USART DMA Tx channel : use non blocking DMA Abort API (callback) */
+    if (HAL_IS_BIT_SET(husart->Instance->CR3, USART_CR3_DMAR))
-    if (husart->hdmatx != NULL)
+    {
-    {
+      husart->hdmarx->XferAbortCallback = USART_DMARxAbortCallback;
-      /* USART Tx DMA Abort callback has already been initialised :
+    }
-         will lead to call HAL_USART_AbortCpltCallback() at end of DMA abort procedure */
+    else
+    {
-      /* Abort DMA TX */
+      husart->hdmarx->XferAbortCallback = NULL;
-      if (HAL_DMA_Abort_IT(husart->hdmatx) != HAL_OK)
+    }
-      {
+  }
-        husart->hdmatx->XferAbortCallback = NULL;
-      }
+  /* Disable the USART DMA Tx request if enabled */
-      else
+  if (HAL_IS_BIT_SET(husart->Instance->CR3, USART_CR3_DMAT))
-      {
+  {
-        AbortCplt = 0x00U;
+    /* Disable DMA Tx at USART level */
-      }
+    CLEAR_BIT(husart->Instance->CR3, USART_CR3_DMAT);
-    }
-  }
+    /* Abort the USART DMA Tx channel : use non blocking DMA Abort API (callback) */
+    if (husart->hdmatx != NULL)
-  /* Disable the USART DMA Rx request if enabled */
+    {
-  if (HAL_IS_BIT_SET(husart->Instance->CR3, USART_CR3_DMAR))
+      /* USART Tx DMA Abort callback has already been initialised :
-  {
+         will lead to call HAL_USART_AbortCpltCallback() at end of DMA abort procedure */
-    CLEAR_BIT(husart->Instance->CR3, USART_CR3_DMAR);
+      /* Abort DMA TX */
-    /* Abort the USART DMA Rx channel : use non blocking DMA Abort API (callback) */
+      if (HAL_DMA_Abort_IT(husart->hdmatx) != HAL_OK)
-    if (husart->hdmarx != NULL)
+      {
-    {
+        husart->hdmatx->XferAbortCallback = NULL;
-      /* USART Rx DMA Abort callback has already been initialised :
+      }
-         will lead to call HAL_USART_AbortCpltCallback() at end of DMA abort procedure */
+      else
+      {
-      /* Abort DMA RX */
+        AbortCplt = 0x00U;
-      if (HAL_DMA_Abort_IT(husart->hdmarx) != HAL_OK)
+      }
-      {
+    }
-        husart->hdmarx->XferAbortCallback = NULL;
+  }
-        AbortCplt = 0x01U;
-      }
+  /* Disable the USART DMA Rx request if enabled */
-      else
+  if (HAL_IS_BIT_SET(husart->Instance->CR3, USART_CR3_DMAR))
-      {
+  {
-        AbortCplt = 0x00U;
+    CLEAR_BIT(husart->Instance->CR3, USART_CR3_DMAR);
-      }
-    }
+    /* Abort the USART DMA Rx channel : use non blocking DMA Abort API (callback) */
-  }
+    if (husart->hdmarx != NULL)
+    {
-  /* if no DMA abort complete callback execution is required => call user Abort Complete callback */
+      /* USART Rx DMA Abort callback has already been initialised :
-  if (AbortCplt  == 0x01U)
+         will lead to call HAL_USART_AbortCpltCallback() at end of DMA abort procedure */
-  {
-    /* Reset Tx and Rx transfer counters */
+      /* Abort DMA RX */
-    husart->TxXferCount = 0x00U;
+      if (HAL_DMA_Abort_IT(husart->hdmarx) != HAL_OK)
-    husart->RxXferCount = 0x00U;
+      {
+        husart->hdmarx->XferAbortCallback = NULL;
-    /* Reset errorCode */
+        AbortCplt = 0x01U;
-    husart->ErrorCode = HAL_USART_ERROR_NONE;
+      }
+      else
-    /* Restore husart->State to Ready */
+      {
-    husart->State  = HAL_USART_STATE_READY;
+        AbortCplt = 0x00U;
+      }
-    /* As no DMA to be aborted, call directly user Abort complete callback */
+    }
-#if (USE_HAL_USART_REGISTER_CALLBACKS == 1)
+  }
-    /* Call registered Abort Complete Callback */
-    husart->AbortCpltCallback(husart);
+  /* if no DMA abort complete callback execution is required => call user Abort Complete callback */
-#else
+  if (AbortCplt  == 0x01U)
-    /* Call legacy weak Abort Complete Callback */
+  {
-    HAL_USART_AbortCpltCallback(husart);
+    /* Reset Tx and Rx transfer counters */
-#endif /* USE_HAL_USART_REGISTER_CALLBACKS */
+    husart->TxXferCount = 0x00U;
-  }
+    husart->RxXferCount = 0x00U;
-  return HAL_OK;
+    /* Reset errorCode */
-}
+    husart->ErrorCode = HAL_USART_ERROR_NONE;
-/**
+    /* Restore husart->State to Ready */
-  * @brief  This function handles USART interrupt request.
+    husart->State  = HAL_USART_STATE_READY;
-  * @param  husart Pointer to a USART_HandleTypeDef structure that contains
-  *                the configuration information for the specified USART module.
+    /* As no DMA to be aborted, call directly user Abort complete callback */
-  * @retval None
+#if (USE_HAL_USART_REGISTER_CALLBACKS == 1)
-  */
+    /* Call registered Abort Complete Callback */
-void HAL_USART_IRQHandler(USART_HandleTypeDef *husart)
+    husart->AbortCpltCallback(husart);
-{
+#else
-  uint32_t isrflags = READ_REG(husart->Instance->SR);
+    /* Call legacy weak Abort Complete Callback */
-  uint32_t cr1its   = READ_REG(husart->Instance->CR1);
+    HAL_USART_AbortCpltCallback(husart);
-  uint32_t cr3its   = READ_REG(husart->Instance->CR3);
+#endif /* USE_HAL_USART_REGISTER_CALLBACKS */
-  uint32_t errorflags = 0x00U;
+  }
-  uint32_t dmarequest = 0x00U;
+  return HAL_OK;
-  /* If no error occurs */
+}
-  errorflags = (isrflags & (uint32_t)(USART_SR_PE | USART_SR_FE | USART_SR_ORE | USART_SR_NE));
-  if (errorflags == RESET)
+/**
-  {
+  * @brief  This function handles USART interrupt request.
-    /* USART in mode Receiver -------------------------------------------------*/
+  * @param  husart Pointer to a USART_HandleTypeDef structure that contains
-    if (((isrflags & USART_SR_RXNE) != RESET) && ((cr1its & USART_CR1_RXNEIE) != RESET))
+  *                the configuration information for the specified USART module.
-    {
+  * @retval None
-      if (husart->State == HAL_USART_STATE_BUSY_RX)
+  */
-      {
+void HAL_USART_IRQHandler(USART_HandleTypeDef *husart)
-        USART_Receive_IT(husart);
+{
-      }
+  uint32_t isrflags = READ_REG(husart->Instance->SR);
-      else
+  uint32_t cr1its   = READ_REG(husart->Instance->CR1);
-      {
+  uint32_t cr3its   = READ_REG(husart->Instance->CR3);
-        USART_TransmitReceive_IT(husart);
+  uint32_t errorflags = 0x00U;
-      }
+  uint32_t dmarequest = 0x00U;
-      return;
-    }
+  /* If no error occurs */
-  }
+  errorflags = (isrflags & (uint32_t)(USART_SR_PE | USART_SR_FE | USART_SR_ORE | USART_SR_NE));
-  /* If some errors occur */
+  if (errorflags == RESET)
-  if ((errorflags != RESET) && (((cr3its & USART_CR3_EIE) != RESET) || ((cr1its & (USART_CR1_RXNEIE | USART_CR1_PEIE)) != RESET)))
+  {
-  {
+    /* USART in mode Receiver -------------------------------------------------*/
-    /* USART parity error interrupt occurred ----------------------------------*/
+    if (((isrflags & USART_SR_RXNE) != RESET) && ((cr1its & USART_CR1_RXNEIE) != RESET))
-    if (((isrflags & USART_SR_PE) != RESET) && ((cr1its & USART_CR1_PEIE) != RESET))
+    {
-    {
+      if (husart->State == HAL_USART_STATE_BUSY_RX)
-      husart->ErrorCode |= HAL_USART_ERROR_PE;
+      {
-    }
+        USART_Receive_IT(husart);
+      }
-    /* USART noise error interrupt occurred --------------------------------*/
+      else
-    if (((isrflags & USART_SR_NE) != RESET) && ((cr3its & USART_CR3_EIE) != RESET))
+      {
-    {
+        USART_TransmitReceive_IT(husart);
-      husart->ErrorCode |= HAL_USART_ERROR_NE;
+      }
-    }
+      return;
+    }
-    /* USART frame error interrupt occurred --------------------------------*/
+  }
-    if (((isrflags & USART_SR_FE) != RESET) && ((cr3its & USART_CR3_EIE) != RESET))
+  /* If some errors occur */
-    {
+  if ((errorflags != RESET) && (((cr3its & USART_CR3_EIE) != RESET) || ((cr1its & (USART_CR1_RXNEIE | USART_CR1_PEIE)) != RESET)))
-      husart->ErrorCode |= HAL_USART_ERROR_FE;
+  {
-    }
+    /* USART parity error interrupt occurred ----------------------------------*/
+    if (((isrflags & USART_SR_PE) != RESET) && ((cr1its & USART_CR1_PEIE) != RESET))
-    /* USART Over-Run interrupt occurred -----------------------------------*/
+    {
-    if (((isrflags & USART_SR_ORE) != RESET) && (((cr1its & USART_CR1_RXNEIE) != RESET) || ((cr3its & USART_CR3_EIE) != RESET)))
+      husart->ErrorCode |= HAL_USART_ERROR_PE;
-    {
+    }
-      husart->ErrorCode |= HAL_USART_ERROR_ORE;
-    }
+    /* USART noise error interrupt occurred --------------------------------*/
+    if (((isrflags & USART_SR_NE) != RESET) && ((cr3its & USART_CR3_EIE) != RESET))
-    if (husart->ErrorCode != HAL_USART_ERROR_NONE)
+    {
-    {
+      husart->ErrorCode |= HAL_USART_ERROR_NE;
-      /* USART in mode Receiver -----------------------------------------------*/
+    }
-      if (((isrflags & USART_SR_RXNE) != RESET) && ((cr1its & USART_CR1_RXNEIE) != RESET))
-      {
+    /* USART frame error interrupt occurred --------------------------------*/
-        if (husart->State == HAL_USART_STATE_BUSY_RX)
+    if (((isrflags & USART_SR_FE) != RESET) && ((cr3its & USART_CR3_EIE) != RESET))
-        {
+    {
-          USART_Receive_IT(husart);
+      husart->ErrorCode |= HAL_USART_ERROR_FE;
-        }
+    }
-        else
-        {
+    /* USART Over-Run interrupt occurred -----------------------------------*/
-          USART_TransmitReceive_IT(husart);
+    if (((isrflags & USART_SR_ORE) != RESET) && (((cr1its & USART_CR1_RXNEIE) != RESET) || ((cr3its & USART_CR3_EIE) != RESET)))
-        }
+    {
-      }
+      husart->ErrorCode |= HAL_USART_ERROR_ORE;
-      /* If Overrun error occurs, or if any error occurs in DMA mode reception,
+    }
-      consider error as blocking */
-      dmarequest = HAL_IS_BIT_SET(husart->Instance->CR3, USART_CR3_DMAR);
+    if (husart->ErrorCode != HAL_USART_ERROR_NONE)
-      if (((husart->ErrorCode & HAL_USART_ERROR_ORE) != RESET) || dmarequest)
+    {
-      {
+      /* USART in mode Receiver -----------------------------------------------*/
-        /* Set the USART state ready to be able to start again the process,
+      if (((isrflags & USART_SR_RXNE) != RESET) && ((cr1its & USART_CR1_RXNEIE) != RESET))
-        Disable Rx Interrupts, and disable Rx DMA request, if ongoing */
+      {
-        USART_EndRxTransfer(husart);
+        if (husart->State == HAL_USART_STATE_BUSY_RX)
+        {
-        /* Disable the USART DMA Rx request if enabled */
+          USART_Receive_IT(husart);
-        if (HAL_IS_BIT_SET(husart->Instance->CR3, USART_CR3_DMAR))
+        }
-        {
+        else
-          CLEAR_BIT(husart->Instance->CR3, USART_CR3_DMAR);
+        {
+          USART_TransmitReceive_IT(husart);
-          /* Abort the USART DMA Rx channel */
+        }
-          if (husart->hdmarx != NULL)
+      }
-          {
+      /* If Overrun error occurs, or if any error occurs in DMA mode reception,
-            /* Set the USART DMA Abort callback :
+      consider error as blocking */
-            will lead to call HAL_USART_ErrorCallback() at end of DMA abort procedure */
+      dmarequest = HAL_IS_BIT_SET(husart->Instance->CR3, USART_CR3_DMAR);
-            husart->hdmarx->XferAbortCallback = USART_DMAAbortOnError;
+      if (((husart->ErrorCode & HAL_USART_ERROR_ORE) != RESET) || dmarequest)
+      {
-            if (HAL_DMA_Abort_IT(husart->hdmarx) != HAL_OK)
+        /* Set the USART state ready to be able to start again the process,
-            {
+        Disable Rx Interrupts, and disable Rx DMA request, if ongoing */
-              /* Call Directly XferAbortCallback function in case of error */
+        USART_EndRxTransfer(husart);
-              husart->hdmarx->XferAbortCallback(husart->hdmarx);
-            }
+        /* Disable the USART DMA Rx request if enabled */
-          }
+        if (HAL_IS_BIT_SET(husart->Instance->CR3, USART_CR3_DMAR))
-          else
+        {
-          {
+          CLEAR_BIT(husart->Instance->CR3, USART_CR3_DMAR);
-            /* Call user error callback */
-#if (USE_HAL_USART_REGISTER_CALLBACKS == 1)
+          /* Abort the USART DMA Rx channel */
-            /* Call registered Error Callback */
+          if (husart->hdmarx != NULL)
-            husart->ErrorCallback(husart);
+          {
-#else
+            /* Set the USART DMA Abort callback :
-            /* Call legacy weak Error Callback */
+            will lead to call HAL_USART_ErrorCallback() at end of DMA abort procedure */
-            HAL_USART_ErrorCallback(husart);
+            husart->hdmarx->XferAbortCallback = USART_DMAAbortOnError;
-#endif /* USE_HAL_USART_REGISTER_CALLBACKS */
-          }
+            if (HAL_DMA_Abort_IT(husart->hdmarx) != HAL_OK)
-        }
+            {
-        else
+              /* Call Directly XferAbortCallback function in case of error */
-        {
+              husart->hdmarx->XferAbortCallback(husart->hdmarx);
-          /* Call user error callback */
+            }
-#if (USE_HAL_USART_REGISTER_CALLBACKS == 1)
+          }
-          /* Call registered Error Callback */
+          else
-          husart->ErrorCallback(husart);
+          {
-#else
+            /* Call user error callback */
-          /* Call legacy weak Error Callback */
+#if (USE_HAL_USART_REGISTER_CALLBACKS == 1)
-          HAL_USART_ErrorCallback(husart);
+            /* Call registered Error Callback */
-#endif /* USE_HAL_USART_REGISTER_CALLBACKS */
+            husart->ErrorCallback(husart);
-        }
+#else
-      }
+            /* Call legacy weak Error Callback */
-      else
+            HAL_USART_ErrorCallback(husart);
-      {
+#endif /* USE_HAL_USART_REGISTER_CALLBACKS */
-        /* Call user error callback */
+          }
-#if (USE_HAL_USART_REGISTER_CALLBACKS == 1)
+        }
-        /* Call registered Error Callback */
+        else
-        husart->ErrorCallback(husart);
+        {
-#else
+          /* Call user error callback */
-        /* Call legacy weak Error Callback */
+#if (USE_HAL_USART_REGISTER_CALLBACKS == 1)
-        HAL_USART_ErrorCallback(husart);
+          /* Call registered Error Callback */
-#endif /* USE_HAL_USART_REGISTER_CALLBACKS */
+          husart->ErrorCallback(husart);
-        husart->ErrorCode = HAL_USART_ERROR_NONE;
+#else
-      }
+          /* Call legacy weak Error Callback */
-    }
+          HAL_USART_ErrorCallback(husart);
-    return;
+#endif /* USE_HAL_USART_REGISTER_CALLBACKS */
-  }
+        }
+      }
-  /* USART in mode Transmitter -----------------------------------------------*/
+      else
-  if (((isrflags & USART_SR_TXE) != RESET) && ((cr1its & USART_CR1_TXEIE) != RESET))
+      {
-  {
+        /* Call user error callback */
-    if (husart->State == HAL_USART_STATE_BUSY_TX)
+#if (USE_HAL_USART_REGISTER_CALLBACKS == 1)
-    {
+        /* Call registered Error Callback */
-      USART_Transmit_IT(husart);
+        husart->ErrorCallback(husart);
-    }
+#else
-    else
+        /* Call legacy weak Error Callback */
-    {
+        HAL_USART_ErrorCallback(husart);
-      USART_TransmitReceive_IT(husart);
+#endif /* USE_HAL_USART_REGISTER_CALLBACKS */
-    }
+        husart->ErrorCode = HAL_USART_ERROR_NONE;
-    return;
+      }
-  }
+    }
+    return;
-  /* USART in mode Transmitter (transmission end) ----------------------------*/
+  }
-  if (((isrflags & USART_SR_TC) != RESET) && ((cr1its & USART_CR1_TCIE) != RESET))
-  {
+  /* USART in mode Transmitter -----------------------------------------------*/
-    USART_EndTransmit_IT(husart);
+  if (((isrflags & USART_SR_TXE) != RESET) && ((cr1its & USART_CR1_TXEIE) != RESET))
-    return;
+  {
-  }
+    if (husart->State == HAL_USART_STATE_BUSY_TX)
-}
+    {
+      USART_Transmit_IT(husart);
-/**
+    }
-  * @brief  Tx Transfer completed callbacks.
+    else
-  * @param  husart Pointer to a USART_HandleTypeDef structure that contains
+    {
-  *                the configuration information for the specified USART module.
+      USART_TransmitReceive_IT(husart);
-  * @retval None
+    }
-  */
+    return;
-__weak void HAL_USART_TxCpltCallback(USART_HandleTypeDef *husart)
+  }
-{
-  /* Prevent unused argument(s) compilation warning */
+  /* USART in mode Transmitter (transmission end) ----------------------------*/
-  UNUSED(husart);
+  if (((isrflags & USART_SR_TC) != RESET) && ((cr1its & USART_CR1_TCIE) != RESET))
-  /* NOTE: This function should not be modified, when the callback is needed,
+  {
-           the HAL_USART_TxCpltCallback could be implemented in the user file
+    USART_EndTransmit_IT(husart);
-   */
+    return;
-}
+  }
+}
-/**
-  * @brief  Tx Half Transfer completed callbacks.
+/**
-  * @param  husart Pointer to a USART_HandleTypeDef structure that contains
+  * @brief  Tx Transfer completed callbacks.
-  *                the configuration information for the specified USART module.
+  * @param  husart Pointer to a USART_HandleTypeDef structure that contains
-  * @retval None
+  *                the configuration information for the specified USART module.
-  */
+  * @retval None
-__weak void HAL_USART_TxHalfCpltCallback(USART_HandleTypeDef *husart)
+  */
-{
+__weak void HAL_USART_TxCpltCallback(USART_HandleTypeDef *husart)
-  /* Prevent unused argument(s) compilation warning */
+{
-  UNUSED(husart);
+  /* Prevent unused argument(s) compilation warning */
-  /* NOTE: This function should not be modified, when the callback is needed,
+  UNUSED(husart);
-           the HAL_USART_TxHalfCpltCallback could be implemented in the user file
+  /* NOTE: This function should not be modified, when the callback is needed,
-   */
+           the HAL_USART_TxCpltCallback could be implemented in the user file
-}
+   */
+}
-/**
-  * @brief  Rx Transfer completed callbacks.
+/**
-  * @param  husart Pointer to a USART_HandleTypeDef structure that contains
+  * @brief  Tx Half Transfer completed callbacks.
-  *                the configuration information for the specified USART module.
+  * @param  husart Pointer to a USART_HandleTypeDef structure that contains
-  * @retval None
+  *                the configuration information for the specified USART module.
-  */
+  * @retval None
-__weak void HAL_USART_RxCpltCallback(USART_HandleTypeDef *husart)
+  */
-{
+__weak void HAL_USART_TxHalfCpltCallback(USART_HandleTypeDef *husart)
-  /* Prevent unused argument(s) compilation warning */
+{
-  UNUSED(husart);
+  /* Prevent unused argument(s) compilation warning */
-  /* NOTE: This function should not be modified, when the callback is needed,
+  UNUSED(husart);
-           the HAL_USART_RxCpltCallback could be implemented in the user file
+  /* NOTE: This function should not be modified, when the callback is needed,
-   */
+           the HAL_USART_TxHalfCpltCallback could be implemented in the user file
-}
+   */
+}
-/**
-  * @brief  Rx Half Transfer completed callbacks.
+/**
-  * @param  husart Pointer to a USART_HandleTypeDef structure that contains
+  * @brief  Rx Transfer completed callbacks.
-  *                the configuration information for the specified USART module.
+  * @param  husart Pointer to a USART_HandleTypeDef structure that contains
-  * @retval None
+  *                the configuration information for the specified USART module.
-  */
+  * @retval None
-__weak void HAL_USART_RxHalfCpltCallback(USART_HandleTypeDef *husart)
+  */
-{
+__weak void HAL_USART_RxCpltCallback(USART_HandleTypeDef *husart)
-  /* Prevent unused argument(s) compilation warning */
+{
-  UNUSED(husart);
+  /* Prevent unused argument(s) compilation warning */
-  /* NOTE: This function should not be modified, when the callback is needed,
+  UNUSED(husart);
-           the HAL_USART_RxHalfCpltCallback could be implemented in the user file
+  /* NOTE: This function should not be modified, when the callback is needed,
-   */
+           the HAL_USART_RxCpltCallback could be implemented in the user file
-}
+   */
+}
-/**
-  * @brief  Tx/Rx Transfers completed callback for the non-blocking process.
+/**
-  * @param  husart Pointer to a USART_HandleTypeDef structure that contains
+  * @brief  Rx Half Transfer completed callbacks.
-  *                the configuration information for the specified USART module.
+  * @param  husart Pointer to a USART_HandleTypeDef structure that contains
-  * @retval None
+  *                the configuration information for the specified USART module.
-  */
+  * @retval None
-__weak void HAL_USART_TxRxCpltCallback(USART_HandleTypeDef *husart)
+  */
-{
+__weak void HAL_USART_RxHalfCpltCallback(USART_HandleTypeDef *husart)
-  /* Prevent unused argument(s) compilation warning */
+{
-  UNUSED(husart);
+  /* Prevent unused argument(s) compilation warning */
-  /* NOTE: This function should not be modified, when the callback is needed,
+  UNUSED(husart);
-           the HAL_USART_TxRxCpltCallback could be implemented in the user file
+  /* NOTE: This function should not be modified, when the callback is needed,
-   */
+           the HAL_USART_RxHalfCpltCallback could be implemented in the user file
-}
+   */
+}
-/**
-  * @brief  USART error callbacks.
+/**
-  * @param  husart Pointer to a USART_HandleTypeDef structure that contains
+  * @brief  Tx/Rx Transfers completed callback for the non-blocking process.
-  *                the configuration information for the specified USART module.
+  * @param  husart Pointer to a USART_HandleTypeDef structure that contains
-  * @retval None
+  *                the configuration information for the specified USART module.
-  */
+  * @retval None
-__weak void HAL_USART_ErrorCallback(USART_HandleTypeDef *husart)
+  */
-{
+__weak void HAL_USART_TxRxCpltCallback(USART_HandleTypeDef *husart)
-  /* Prevent unused argument(s) compilation warning */
+{
-  UNUSED(husart);
+  /* Prevent unused argument(s) compilation warning */
-  /* NOTE: This function should not be modified, when the callback is needed,
+  UNUSED(husart);
-           the HAL_USART_ErrorCallback could be implemented in the user file
+  /* NOTE: This function should not be modified, when the callback is needed,
-   */
+           the HAL_USART_TxRxCpltCallback could be implemented in the user file
-}
+   */
+}
-/**
-  * @brief  USART Abort Complete callback.
+/**
-  * @param  husart USART handle.
+  * @brief  USART error callbacks.
-  * @retval None
+  * @param  husart Pointer to a USART_HandleTypeDef structure that contains
-  */
+  *                the configuration information for the specified USART module.
-__weak void HAL_USART_AbortCpltCallback(USART_HandleTypeDef *husart)
+  * @retval None
-{
+  */
-  /* Prevent unused argument(s) compilation warning */
+__weak void HAL_USART_ErrorCallback(USART_HandleTypeDef *husart)
-  UNUSED(husart);
+{
+  /* Prevent unused argument(s) compilation warning */
-  /* NOTE : This function should not be modified, when the callback is needed,
+  UNUSED(husart);
-            the HAL_USART_AbortCpltCallback can be implemented in the user file.
+  /* NOTE: This function should not be modified, when the callback is needed,
-   */
+           the HAL_USART_ErrorCallback could be implemented in the user file
-}
+   */
+}
-/**
-  * @}
+/**
-  */
+  * @brief  USART Abort Complete callback.
+  * @param  husart USART handle.
-/** @defgroup USART_Exported_Functions_Group3 Peripheral State and Errors functions
+  * @retval None
-  *  @brief   USART State and Errors functions
+  */
-  *
+__weak void HAL_USART_AbortCpltCallback(USART_HandleTypeDef *husart)
-@verbatim
+{
-  ==============================================================================
+  /* Prevent unused argument(s) compilation warning */
-                  ##### Peripheral State and Errors functions #####
+  UNUSED(husart);
-  ==============================================================================
-  [..]
+  /* NOTE : This function should not be modified, when the callback is needed,
-    This subsection provides a set of functions allowing to return the State of
+            the HAL_USART_AbortCpltCallback can be implemented in the user file.
-    USART communication
+   */
-    process, return Peripheral Errors occurred during communication process
+}
-     (+) HAL_USART_GetState() API can be helpful to check in run-time the state
-         of the USART peripheral.
+/**
-     (+) HAL_USART_GetError() check in run-time errors that could be occurred during
+  * @}
-         communication.
+  */
-@endverbatim
-  * @{
+/** @defgroup USART_Exported_Functions_Group3 Peripheral State and Errors functions
-  */
+  *  @brief   USART State and Errors functions
+  *
-/**
+@verbatim
-  * @brief  Returns the USART state.
+  ==============================================================================
-  * @param  husart Pointer to a USART_HandleTypeDef structure that contains
+                  ##### Peripheral State and Errors functions #####
-  *                the configuration information for the specified USART module.
+  ==============================================================================
-  * @retval HAL state
+  [..]
-  */
+    This subsection provides a set of functions allowing to return the State of
-HAL_USART_StateTypeDef HAL_USART_GetState(USART_HandleTypeDef *husart)
+    USART communication
-{
+    process, return Peripheral Errors occurred during communication process
-  return husart->State;
+     (+) HAL_USART_GetState() API can be helpful to check in run-time the state
-}
+         of the USART peripheral.
+     (+) HAL_USART_GetError() check in run-time errors that could be occurred during
-/**
+         communication.
-  * @brief  Return the USART error code
+@endverbatim
-  * @param  husart Pointer to a USART_HandleTypeDef structure that contains
+  * @{
-  *                the configuration information for the specified USART.
+  */
-  * @retval USART Error Code
-  */
+/**
-uint32_t HAL_USART_GetError(USART_HandleTypeDef *husart)
+  * @brief  Returns the USART state.
-{
+  * @param  husart Pointer to a USART_HandleTypeDef structure that contains
-  return husart->ErrorCode;
+  *                the configuration information for the specified USART module.
-}
+  * @retval HAL state
+  */
-/**
+HAL_USART_StateTypeDef HAL_USART_GetState(const USART_HandleTypeDef *husart)
-  * @}
+{
-  */
+  return husart->State;
+}
-/** @defgroup USART_Private_Functions USART Private Functions
- * @{
+/**
- */
+  * @brief  Return the USART error code
+  * @param  husart Pointer to a USART_HandleTypeDef structure that contains
-/**
+  *                the configuration information for the specified USART.
-  * @brief  Initialize the callbacks to their default values.
+  * @retval USART Error Code
-  * @param  husart USART handle.
+  */
-  * @retval none
+uint32_t HAL_USART_GetError(const USART_HandleTypeDef *husart)
-  */
+{
-#if (USE_HAL_USART_REGISTER_CALLBACKS == 1)
+  return husart->ErrorCode;
-void USART_InitCallbacksToDefault(USART_HandleTypeDef *husart)
+}
-{
-  /* Init the USART Callback settings */
+/**
-  husart->TxHalfCpltCallback        = HAL_USART_TxHalfCpltCallback;        /* Legacy weak TxHalfCpltCallback        */
+  * @}
-  husart->TxCpltCallback            = HAL_USART_TxCpltCallback;            /* Legacy weak TxCpltCallback            */
+  */
-  husart->RxHalfCpltCallback        = HAL_USART_RxHalfCpltCallback;        /* Legacy weak RxHalfCpltCallback        */
-  husart->RxCpltCallback            = HAL_USART_RxCpltCallback;            /* Legacy weak RxCpltCallback            */
+/** @defgroup USART_Private_Functions USART Private Functions
-  husart->TxRxCpltCallback          = HAL_USART_TxRxCpltCallback;          /* Legacy weak TxRxCpltCallback          */
+ * @{
-  husart->ErrorCallback             = HAL_USART_ErrorCallback;             /* Legacy weak ErrorCallback             */
+ */
-  husart->AbortCpltCallback         = HAL_USART_AbortCpltCallback;         /* Legacy weak AbortCpltCallback         */
-}
+/**
-#endif /* USE_HAL_USART_REGISTER_CALLBACKS */
+  * @brief  Initialize the callbacks to their default values.
+  * @param  husart USART handle.
-/**
+  * @retval none
-  * @brief  DMA USART transmit process complete callback.
+  */
-  * @param  hdma Pointer to a DMA_HandleTypeDef structure that contains
+#if (USE_HAL_USART_REGISTER_CALLBACKS == 1)
-  *              the configuration information for the specified DMA module.
+void USART_InitCallbacksToDefault(USART_HandleTypeDef *husart)
-  * @retval None
+{
-  */
+  /* Init the USART Callback settings */
-static void USART_DMATransmitCplt(DMA_HandleTypeDef *hdma)
+  husart->TxHalfCpltCallback        = HAL_USART_TxHalfCpltCallback;        /* Legacy weak TxHalfCpltCallback        */
-{
+  husart->TxCpltCallback            = HAL_USART_TxCpltCallback;            /* Legacy weak TxCpltCallback            */
-  USART_HandleTypeDef *husart = (USART_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
+  husart->RxHalfCpltCallback        = HAL_USART_RxHalfCpltCallback;        /* Legacy weak RxHalfCpltCallback        */
-  /* DMA Normal mode */
+  husart->RxCpltCallback            = HAL_USART_RxCpltCallback;            /* Legacy weak RxCpltCallback            */
-  if ((hdma->Instance->CCR & DMA_CCR_CIRC) == 0U)
+  husart->TxRxCpltCallback          = HAL_USART_TxRxCpltCallback;          /* Legacy weak TxRxCpltCallback          */
-  {
+  husart->ErrorCallback             = HAL_USART_ErrorCallback;             /* Legacy weak ErrorCallback             */
-    husart->TxXferCount = 0U;
+  husart->AbortCpltCallback         = HAL_USART_AbortCpltCallback;         /* Legacy weak AbortCpltCallback         */
-    if (husart->State == HAL_USART_STATE_BUSY_TX)
+}
-    {
+#endif /* USE_HAL_USART_REGISTER_CALLBACKS */
-      /* Disable the DMA transfer for transmit request by resetting the DMAT bit
-         in the USART CR3 register */
+/**
-      CLEAR_BIT(husart->Instance->CR3, USART_CR3_DMAT);
+  * @brief  DMA USART transmit process complete callback.
+  * @param  hdma Pointer to a DMA_HandleTypeDef structure that contains
-      /* Enable the USART Transmit Complete Interrupt */
+  *              the configuration information for the specified DMA module.
-      SET_BIT(husart->Instance->CR1, USART_CR1_TCIE);
+  * @retval None
-    }
+  */
-  }
+static void USART_DMATransmitCplt(DMA_HandleTypeDef *hdma)
-  /* DMA Circular mode */
+{
-  else
+  USART_HandleTypeDef *husart = (USART_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
-  {
+  /* DMA Normal mode */
-    if (husart->State == HAL_USART_STATE_BUSY_TX)
+  if ((hdma->Instance->CCR & DMA_CCR_CIRC) == 0U)
-    {
+  {
-#if (USE_HAL_USART_REGISTER_CALLBACKS == 1)
+    husart->TxXferCount = 0U;
-      /* Call registered Tx Complete Callback */
+    if (husart->State == HAL_USART_STATE_BUSY_TX)
-      husart->TxCpltCallback(husart);
+    {
-#else
+      /* Disable the DMA transfer for transmit request by resetting the DMAT bit
-      /* Call legacy weak Tx Complete Callback */
+         in the USART CR3 register */
-      HAL_USART_TxCpltCallback(husart);
+      CLEAR_BIT(husart->Instance->CR3, USART_CR3_DMAT);
-#endif /* USE_HAL_USART_REGISTER_CALLBACKS */
-    }
+      /* Enable the USART Transmit Complete Interrupt */
-  }
+      SET_BIT(husart->Instance->CR1, USART_CR1_TCIE);
-}
+    }
+  }
-/**
+  /* DMA Circular mode */
-  * @brief  DMA USART transmit process half complete callback
+  else
-  * @param  hdma Pointer to a DMA_HandleTypeDef structure that contains
+  {
-  *              the configuration information for the specified DMA module.
+    if (husart->State == HAL_USART_STATE_BUSY_TX)
-  * @retval None
+    {
-  */
+#if (USE_HAL_USART_REGISTER_CALLBACKS == 1)
-static void USART_DMATxHalfCplt(DMA_HandleTypeDef *hdma)
+      /* Call registered Tx Complete Callback */
-{
+      husart->TxCpltCallback(husart);
-  USART_HandleTypeDef *husart = (USART_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
+#else
+      /* Call legacy weak Tx Complete Callback */
-#if (USE_HAL_USART_REGISTER_CALLBACKS == 1)
+      HAL_USART_TxCpltCallback(husart);
-  /* Call registered Tx Half Complete Callback */
+#endif /* USE_HAL_USART_REGISTER_CALLBACKS */
-  husart->TxHalfCpltCallback(husart);
+    }
-#else
+  }
-  /* Call legacy weak Tx Half Complete Callback */
+}
-  HAL_USART_TxHalfCpltCallback(husart);
-#endif /* USE_HAL_USART_REGISTER_CALLBACKS */
+/**
-}
+  * @brief  DMA USART transmit process half complete callback
+  * @param  hdma Pointer to a DMA_HandleTypeDef structure that contains
-/**
+  *              the configuration information for the specified DMA module.
-  * @brief  DMA USART receive process complete callback.
+  * @retval None
-  * @param  hdma Pointer to a DMA_HandleTypeDef structure that contains
+  */
-  *              the configuration information for the specified DMA module.
+static void USART_DMATxHalfCplt(DMA_HandleTypeDef *hdma)
-  * @retval None
+{
-  */
+  USART_HandleTypeDef *husart = (USART_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
-static void USART_DMAReceiveCplt(DMA_HandleTypeDef *hdma)
-{
+#if (USE_HAL_USART_REGISTER_CALLBACKS == 1)
-  USART_HandleTypeDef *husart = (USART_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
+  /* Call registered Tx Half Complete Callback */
-  /* DMA Normal mode */
+  husart->TxHalfCpltCallback(husart);
-  if ((hdma->Instance->CCR & DMA_CCR_CIRC) == 0U)
+#else
-  {
+  /* Call legacy weak Tx Half Complete Callback */
-    husart->RxXferCount = 0x00U;
+  HAL_USART_TxHalfCpltCallback(husart);
+#endif /* USE_HAL_USART_REGISTER_CALLBACKS */
-    /* Disable RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts */
+}
-    CLEAR_BIT(husart->Instance->CR1, USART_CR1_PEIE);
-    CLEAR_BIT(husart->Instance->CR3, USART_CR3_EIE);
+/**
+  * @brief  DMA USART receive process complete callback.
-    /* Disable the DMA transfer for the Transmit/receiver request by clearing the DMAT/DMAR bit
+  * @param  hdma Pointer to a DMA_HandleTypeDef structure that contains
-         in the USART CR3 register */
+  *              the configuration information for the specified DMA module.
-    CLEAR_BIT(husart->Instance->CR3, USART_CR3_DMAR);
+  * @retval None
-    CLEAR_BIT(husart->Instance->CR3, USART_CR3_DMAT);
+  */
+static void USART_DMAReceiveCplt(DMA_HandleTypeDef *hdma)
-    /* The USART state is HAL_USART_STATE_BUSY_RX */
+{
-    if (husart->State == HAL_USART_STATE_BUSY_RX)
+  USART_HandleTypeDef *husart = (USART_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
-    {
+  /* DMA Normal mode */
-#if (USE_HAL_USART_REGISTER_CALLBACKS == 1)
+  if ((hdma->Instance->CCR & DMA_CCR_CIRC) == 0U)
-      /* Call registered Rx Complete Callback */
+  {
-      husart->RxCpltCallback(husart);
+    husart->RxXferCount = 0x00U;
-#else
-      /* Call legacy weak Rx Complete Callback */
+    /* Disable RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts */
-      HAL_USART_RxCpltCallback(husart);
+    CLEAR_BIT(husart->Instance->CR1, USART_CR1_PEIE);
-#endif /* USE_HAL_USART_REGISTER_CALLBACKS */
+    CLEAR_BIT(husart->Instance->CR3, USART_CR3_EIE);
-    }
-    /* The USART state is HAL_USART_STATE_BUSY_TX_RX */
+    /* Disable the DMA transfer for the Transmit/receiver request by clearing the DMAT/DMAR bit
-    else
+         in the USART CR3 register */
-    {
+    CLEAR_BIT(husart->Instance->CR3, USART_CR3_DMAR);
-#if (USE_HAL_USART_REGISTER_CALLBACKS == 1)
+    CLEAR_BIT(husart->Instance->CR3, USART_CR3_DMAT);
-      /* Call registered Tx Rx Complete Callback */
-      husart->TxRxCpltCallback(husart);
+    /* The USART state is HAL_USART_STATE_BUSY_RX */
-#else
+    if (husart->State == HAL_USART_STATE_BUSY_RX)
-      /* Call legacy weak Tx Rx Complete Callback */
+    {
-      HAL_USART_TxRxCpltCallback(husart);
+#if (USE_HAL_USART_REGISTER_CALLBACKS == 1)
-#endif /* USE_HAL_USART_REGISTER_CALLBACKS */
+      /* Call registered Rx Complete Callback */
-    }
+      husart->RxCpltCallback(husart);
-    husart->State = HAL_USART_STATE_READY;
+#else
-  }
+      /* Call legacy weak Rx Complete Callback */
-  /* DMA circular mode */
+      HAL_USART_RxCpltCallback(husart);
-  else
+#endif /* USE_HAL_USART_REGISTER_CALLBACKS */
-  {
+    }
-    if (husart->State == HAL_USART_STATE_BUSY_RX)
+    /* The USART state is HAL_USART_STATE_BUSY_TX_RX */
-    {
+    else
-#if (USE_HAL_USART_REGISTER_CALLBACKS == 1)
+    {
-      /* Call registered Rx Complete Callback */
+#if (USE_HAL_USART_REGISTER_CALLBACKS == 1)
-      husart->RxCpltCallback(husart);
+      /* Call registered Tx Rx Complete Callback */
-#else
+      husart->TxRxCpltCallback(husart);
-      /* Call legacy weak Rx Complete Callback */
+#else
-      HAL_USART_RxCpltCallback(husart);
+      /* Call legacy weak Tx Rx Complete Callback */
-#endif /* USE_HAL_USART_REGISTER_CALLBACKS */
+      HAL_USART_TxRxCpltCallback(husart);
-    }
+#endif /* USE_HAL_USART_REGISTER_CALLBACKS */
-    /* The USART state is HAL_USART_STATE_BUSY_TX_RX */
+    }
-    else
+    husart->State = HAL_USART_STATE_READY;
-    {
+  }
-#if (USE_HAL_USART_REGISTER_CALLBACKS == 1)
+  /* DMA circular mode */
-      /* Call registered Tx Rx Complete Callback */
+  else
-      husart->TxRxCpltCallback(husart);
+  {
-#else
+    if (husart->State == HAL_USART_STATE_BUSY_RX)
-      /* Call legacy weak Tx Rx Complete Callback */
+    {
-      HAL_USART_TxRxCpltCallback(husart);
+#if (USE_HAL_USART_REGISTER_CALLBACKS == 1)
-#endif /* USE_HAL_USART_REGISTER_CALLBACKS */
+      /* Call registered Rx Complete Callback */
-    }
+      husart->RxCpltCallback(husart);
-  }
+#else
-}
+      /* Call legacy weak Rx Complete Callback */
+      HAL_USART_RxCpltCallback(husart);
-/**
+#endif /* USE_HAL_USART_REGISTER_CALLBACKS */
-  * @brief  DMA USART receive process half complete callback
+    }
-  * @param  hdma Pointer to a DMA_HandleTypeDef structure that contains
+    /* The USART state is HAL_USART_STATE_BUSY_TX_RX */
-  *              the configuration information for the specified DMA module.
+    else
-  * @retval None
+    {
-  */
+#if (USE_HAL_USART_REGISTER_CALLBACKS == 1)
-static void USART_DMARxHalfCplt(DMA_HandleTypeDef *hdma)
+      /* Call registered Tx Rx Complete Callback */
-{
+      husart->TxRxCpltCallback(husart);
-  USART_HandleTypeDef *husart = (USART_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
+#else
+      /* Call legacy weak Tx Rx Complete Callback */
-#if (USE_HAL_USART_REGISTER_CALLBACKS == 1)
+      HAL_USART_TxRxCpltCallback(husart);
-  /* Call registered Rx Half Complete Callback */
+#endif /* USE_HAL_USART_REGISTER_CALLBACKS */
-  husart->RxHalfCpltCallback(husart);
+    }
-#else
+  }
-  /* Call legacy weak Rx Half Complete Callback */
+}
-  HAL_USART_RxHalfCpltCallback(husart);
-#endif /* USE_HAL_USART_REGISTER_CALLBACKS */
+/**
-}
+  * @brief  DMA USART receive process half complete callback
+  * @param  hdma Pointer to a DMA_HandleTypeDef structure that contains
-/**
+  *              the configuration information for the specified DMA module.
-  * @brief  DMA USART communication error callback.
+  * @retval None
-  * @param  hdma Pointer to a DMA_HandleTypeDef structure that contains
+  */
-  *              the configuration information for the specified DMA module.
+static void USART_DMARxHalfCplt(DMA_HandleTypeDef *hdma)
-  * @retval None
+{
-  */
+  USART_HandleTypeDef *husart = (USART_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
-static void USART_DMAError(DMA_HandleTypeDef *hdma)
-{
+#if (USE_HAL_USART_REGISTER_CALLBACKS == 1)
-  uint32_t dmarequest = 0x00U;
+  /* Call registered Rx Half Complete Callback */
-  USART_HandleTypeDef *husart = (USART_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
+  husart->RxHalfCpltCallback(husart);
-  husart->RxXferCount = 0x00U;
+#else
-  husart->TxXferCount = 0x00U;
+  /* Call legacy weak Rx Half Complete Callback */
+  HAL_USART_RxHalfCpltCallback(husart);
-  /* Stop USART DMA Tx request if ongoing */
+#endif /* USE_HAL_USART_REGISTER_CALLBACKS */
-  dmarequest = HAL_IS_BIT_SET(husart->Instance->CR3, USART_CR3_DMAT);
+}
-  if ((husart->State == HAL_USART_STATE_BUSY_TX) && dmarequest)
-  {
+/**
-    USART_EndTxTransfer(husart);
+  * @brief  DMA USART communication error callback.
-  }
+  * @param  hdma Pointer to a DMA_HandleTypeDef structure that contains
+  *              the configuration information for the specified DMA module.
-  /* Stop USART DMA Rx request if ongoing */
+  * @retval None
-  dmarequest = HAL_IS_BIT_SET(husart->Instance->CR3, USART_CR3_DMAR);
+  */
-  if ((husart->State == HAL_USART_STATE_BUSY_RX) && dmarequest)
+static void USART_DMAError(DMA_HandleTypeDef *hdma)
-  {
+{
-    USART_EndRxTransfer(husart);
+  uint32_t dmarequest = 0x00U;
-  }
+  USART_HandleTypeDef *husart = (USART_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
+  husart->RxXferCount = 0x00U;
-  husart->ErrorCode |= HAL_USART_ERROR_DMA;
+  husart->TxXferCount = 0x00U;
-  husart->State = HAL_USART_STATE_READY;
+  /* Stop USART DMA Tx request if ongoing */
-#if (USE_HAL_USART_REGISTER_CALLBACKS == 1)
+  dmarequest = HAL_IS_BIT_SET(husart->Instance->CR3, USART_CR3_DMAT);
-  /* Call registered Error Callback */
+  if ((husart->State == HAL_USART_STATE_BUSY_TX) && dmarequest)
-  husart->ErrorCallback(husart);
+  {
-#else
+    USART_EndTxTransfer(husart);
-  /* Call legacy weak Error Callback */
+  }
-  HAL_USART_ErrorCallback(husart);
-#endif /* USE_HAL_USART_REGISTER_CALLBACKS */
+  /* Stop USART DMA Rx request if ongoing */
-}
+  dmarequest = HAL_IS_BIT_SET(husart->Instance->CR3, USART_CR3_DMAR);
+  if ((husart->State == HAL_USART_STATE_BUSY_RX) && dmarequest)
-/**
+  {
-  * @brief  This function handles USART Communication Timeout.
+    USART_EndRxTransfer(husart);
-  * @param  husart Pointer to a USART_HandleTypeDef structure that contains
+  }
-  *                the configuration information for the specified USART module.
-  * @param  Flag specifies the USART flag to check.
+  husart->ErrorCode |= HAL_USART_ERROR_DMA;
-  * @param  Status The new Flag status (SET or RESET).
+  husart->State = HAL_USART_STATE_READY;
-  * @param  Tickstart Tick start value.
-  * @param  Timeout Timeout duration.
+#if (USE_HAL_USART_REGISTER_CALLBACKS == 1)
-  * @retval HAL status
+  /* Call registered Error Callback */
-  */
+  husart->ErrorCallback(husart);
-static HAL_StatusTypeDef USART_WaitOnFlagUntilTimeout(USART_HandleTypeDef *husart, uint32_t Flag, FlagStatus Status, uint32_t Tickstart, uint32_t Timeout)
+#else
-{
+  /* Call legacy weak Error Callback */
-  /* Wait until flag is set */
+  HAL_USART_ErrorCallback(husart);
-  while ((__HAL_USART_GET_FLAG(husart, Flag) ? SET : RESET) == Status)
+#endif /* USE_HAL_USART_REGISTER_CALLBACKS */
-  {
+}
-    /* Check for the Timeout */
-    if (Timeout != HAL_MAX_DELAY)
+/**
-    {
+  * @brief  This function handles USART Communication Timeout. It waits
-      if ((Timeout == 0U) || ((HAL_GetTick() - Tickstart) > Timeout))
+  *         until a flag is no longer in the specified status.
-      {
+  * @param  husart Pointer to a USART_HandleTypeDef structure that contains
-        /* Disable the USART Transmit Complete Interrupt */
+  *                the configuration information for the specified USART module.
-        CLEAR_BIT(husart->Instance->CR1, USART_CR1_TXEIE);
+  * @param  Flag specifies the USART flag to check.
+  * @param  Status The actual Flag status (SET or RESET).
-        /* Disable the USART RXNE Interrupt */
+  * @param  Tickstart Tick start value.
-        CLEAR_BIT(husart->Instance->CR1, USART_CR1_RXNEIE);
+  * @param  Timeout Timeout duration.
+  * @retval HAL status
-        /* Disable the USART Parity Error Interrupt */
+  */
-        CLEAR_BIT(husart->Instance->CR1, USART_CR1_PEIE);
+static HAL_StatusTypeDef USART_WaitOnFlagUntilTimeout(USART_HandleTypeDef *husart, uint32_t Flag, FlagStatus Status,
+                                                      uint32_t Tickstart, uint32_t Timeout)
-        /* Disable the USART Error Interrupt: (Frame error, noise error, overrun error) */
+{
-        CLEAR_BIT(husart->Instance->CR3, USART_CR3_EIE);
+  /* Wait until flag is set */
+  while ((__HAL_USART_GET_FLAG(husart, Flag) ? SET : RESET) == Status)
-        husart->State = HAL_USART_STATE_READY;
+  {
+    /* Check for the Timeout */
-        /* Process Unlocked */
+    if (Timeout != HAL_MAX_DELAY)
-        __HAL_UNLOCK(husart);
+    {
+      if ((Timeout == 0U) || ((HAL_GetTick() - Tickstart) > Timeout))
-        return HAL_TIMEOUT;
+      {
-      }
+        /* Disable the USART Transmit Complete Interrupt */
-    }
+        CLEAR_BIT(husart->Instance->CR1, USART_CR1_TXEIE);
-  }
-  return HAL_OK;
+        /* Disable the USART RXNE Interrupt */
-}
+        CLEAR_BIT(husart->Instance->CR1, USART_CR1_RXNEIE);
-/**
+        /* Disable the USART Parity Error Interrupt */
-  * @brief  End ongoing Tx transfer on USART peripheral (following error detection or Transmit completion).
+        CLEAR_BIT(husart->Instance->CR1, USART_CR1_PEIE);
-  * @param  husart USART handle.
-  * @retval None
+        /* Disable the USART Error Interrupt: (Frame error, noise error, overrun error) */
-  */
+        CLEAR_BIT(husart->Instance->CR3, USART_CR3_EIE);
-static void USART_EndTxTransfer(USART_HandleTypeDef *husart)
-{
+        husart->State = HAL_USART_STATE_READY;
-  /* Disable TXEIE and TCIE interrupts */
-  CLEAR_BIT(husart->Instance->CR1, (USART_CR1_TXEIE | USART_CR1_TCIE));
+        /* Process Unlocked */
+        __HAL_UNLOCK(husart);
-  /* At end of Tx process, restore husart->State to Ready */
-  husart->State = HAL_USART_STATE_READY;
+        return HAL_TIMEOUT;
-}
+      }
+    }
-/**
+  }
-  * @brief  End ongoing Rx transfer on USART peripheral (following error detection or Reception completion).
+  return HAL_OK;
-  * @param  husart USART handle.
+}
-  * @retval None
-  */
+/**
-static void USART_EndRxTransfer(USART_HandleTypeDef *husart)
+  * @brief  End ongoing Tx transfer on USART peripheral (following error detection or Transmit completion).
-{
+  * @param  husart USART handle.
-  /* Disable RXNE, PE and ERR interrupts */
+  * @retval None
-  CLEAR_BIT(husart->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE));
+  */
-  CLEAR_BIT(husart->Instance->CR3, USART_CR3_EIE);
+static void USART_EndTxTransfer(USART_HandleTypeDef *husart)
+{
-  /* At end of Rx process, restore husart->State to Ready */
+  /* Disable TXEIE and TCIE interrupts */
-  husart->State = HAL_USART_STATE_READY;
+  CLEAR_BIT(husart->Instance->CR1, (USART_CR1_TXEIE | USART_CR1_TCIE));
-}
+  /* At end of Tx process, restore husart->State to Ready */
-/**
+  husart->State = HAL_USART_STATE_READY;
-  * @brief  DMA USART communication abort callback, when initiated by HAL services on Error
+}
-  *         (To be called at end of DMA Abort procedure following error occurrence).
-  * @param  hdma DMA handle.
+/**
-  * @retval None
+  * @brief  End ongoing Rx transfer on USART peripheral (following error detection or Reception completion).
-  */
+  * @param  husart USART handle.
-static void USART_DMAAbortOnError(DMA_HandleTypeDef *hdma)
+  * @retval None
-{
+  */
-  USART_HandleTypeDef *husart = (USART_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
+static void USART_EndRxTransfer(USART_HandleTypeDef *husart)
-  husart->RxXferCount = 0x00U;
+{
-  husart->TxXferCount = 0x00U;
+  /* Disable RXNE, PE and ERR interrupts */
+  CLEAR_BIT(husart->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE));
-#if (USE_HAL_USART_REGISTER_CALLBACKS == 1)
+  CLEAR_BIT(husart->Instance->CR3, USART_CR3_EIE);
-  /* Call registered Error Callback */
-  husart->ErrorCallback(husart);
+  /* At end of Rx process, restore husart->State to Ready */
-#else
+  husart->State = HAL_USART_STATE_READY;
-  /* Call legacy weak Error Callback */
+}
-  HAL_USART_ErrorCallback(husart);
-#endif /* USE_HAL_USART_REGISTER_CALLBACKS */
+/**
-}
+  * @brief  DMA USART communication abort callback, when initiated by HAL services on Error
+  *         (To be called at end of DMA Abort procedure following error occurrence).
-/**
+  * @param  hdma DMA handle.
-  * @brief  DMA USART Tx communication abort callback, when initiated by user
+  * @retval None
-  *         (To be called at end of DMA Tx Abort procedure following user abort request).
+  */
-  * @note   When this callback is executed, User Abort complete call back is called only if no
+static void USART_DMAAbortOnError(DMA_HandleTypeDef *hdma)
-  *         Abort still ongoing for Rx DMA Handle.
+{
-  * @param  hdma DMA handle.
+  USART_HandleTypeDef *husart = (USART_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
-  * @retval None
+  husart->RxXferCount = 0x00U;
-  */
+  husart->TxXferCount = 0x00U;
-static void USART_DMATxAbortCallback(DMA_HandleTypeDef *hdma)
-{
+#if (USE_HAL_USART_REGISTER_CALLBACKS == 1)
-  USART_HandleTypeDef *husart = (USART_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
+  /* Call registered Error Callback */
+  husart->ErrorCallback(husart);
-  husart->hdmatx->XferAbortCallback = NULL;
+#else
+  /* Call legacy weak Error Callback */
-  /* Check if an Abort process is still ongoing */
+  HAL_USART_ErrorCallback(husart);
-  if (husart->hdmarx != NULL)
+#endif /* USE_HAL_USART_REGISTER_CALLBACKS */
-  {
+}
-    if (husart->hdmarx->XferAbortCallback != NULL)
-    {
+/**
-      return;
+  * @brief  DMA USART Tx communication abort callback, when initiated by user
-    }
+  *         (To be called at end of DMA Tx Abort procedure following user abort request).
-  }
+  * @note   When this callback is executed, User Abort complete call back is called only if no
+  *         Abort still ongoing for Rx DMA Handle.
-  /* No Abort process still ongoing : All DMA channels are aborted, call user Abort Complete callback */
+  * @param  hdma DMA handle.
-  husart->TxXferCount = 0x00U;
+  * @retval None
-  husart->RxXferCount = 0x00U;
+  */
+static void USART_DMATxAbortCallback(DMA_HandleTypeDef *hdma)
-  /* Reset errorCode */
+{
-  husart->ErrorCode = HAL_USART_ERROR_NONE;
+  USART_HandleTypeDef *husart = (USART_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
-  /* Restore husart->State to Ready */
+  husart->hdmatx->XferAbortCallback = NULL;
-  husart->State  = HAL_USART_STATE_READY;
+  /* Check if an Abort process is still ongoing */
-  /* Call user Abort complete callback */
+  if (husart->hdmarx != NULL)
-#if (USE_HAL_USART_REGISTER_CALLBACKS == 1)
+  {
-  /* Call registered Abort Complete Callback */
+    if (husart->hdmarx->XferAbortCallback != NULL)
-  husart->AbortCpltCallback(husart);
+    {
-#else
+      return;
-  /* Call legacy weak Abort Complete Callback */
+    }
-  HAL_USART_AbortCpltCallback(husart);
+  }
-#endif /* USE_HAL_USART_REGISTER_CALLBACKS */
-}
+  /* No Abort process still ongoing : All DMA channels are aborted, call user Abort Complete callback */
+  husart->TxXferCount = 0x00U;
-/**
+  husart->RxXferCount = 0x00U;
-  * @brief  DMA USART Rx communication abort callback, when initiated by user
-  *         (To be called at end of DMA Rx Abort procedure following user abort request).
+  /* Reset errorCode */
-  * @note   When this callback is executed, User Abort complete call back is called only if no
+  husart->ErrorCode = HAL_USART_ERROR_NONE;
-  *         Abort still ongoing for Tx DMA Handle.
-  * @param  hdma DMA handle.
+  /* Restore husart->State to Ready */
-  * @retval None
+  husart->State  = HAL_USART_STATE_READY;
-  */
-static void USART_DMARxAbortCallback(DMA_HandleTypeDef *hdma)
+  /* Call user Abort complete callback */
-{
+#if (USE_HAL_USART_REGISTER_CALLBACKS == 1)
-  USART_HandleTypeDef *husart = (USART_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
+  /* Call registered Abort Complete Callback */
+  husart->AbortCpltCallback(husart);
-  husart->hdmarx->XferAbortCallback = NULL;
+#else
+  /* Call legacy weak Abort Complete Callback */
-  /* Check if an Abort process is still ongoing */
+  HAL_USART_AbortCpltCallback(husart);
-  if (husart->hdmatx != NULL)
+#endif /* USE_HAL_USART_REGISTER_CALLBACKS */
-  {
+}
-    if (husart->hdmatx->XferAbortCallback != NULL)
-    {
+/**
-      return;
+  * @brief  DMA USART Rx communication abort callback, when initiated by user
-    }
+  *         (To be called at end of DMA Rx Abort procedure following user abort request).
-  }
+  * @note   When this callback is executed, User Abort complete call back is called only if no
+  *         Abort still ongoing for Tx DMA Handle.
-  /* No Abort process still ongoing : All DMA channels are aborted, call user Abort Complete callback */
+  * @param  hdma DMA handle.
-  husart->TxXferCount = 0x00U;
+  * @retval None
-  husart->RxXferCount = 0x00U;
+  */
+static void USART_DMARxAbortCallback(DMA_HandleTypeDef *hdma)
-  /* Reset errorCode */
+{
-  husart->ErrorCode = HAL_USART_ERROR_NONE;
+  USART_HandleTypeDef *husart = (USART_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
-  /* Restore husart->State to Ready */
+  husart->hdmarx->XferAbortCallback = NULL;
-  husart->State  = HAL_USART_STATE_READY;
+  /* Check if an Abort process is still ongoing */
-  /* Call user Abort complete callback */
+  if (husart->hdmatx != NULL)
-#if (USE_HAL_USART_REGISTER_CALLBACKS == 1)
+  {
-  /* Call registered Abort Complete Callback */
+    if (husart->hdmatx->XferAbortCallback != NULL)
-  husart->AbortCpltCallback(husart);
+    {
-#else
+      return;
-  /* Call legacy weak Abort Complete Callback */
+    }
-  HAL_USART_AbortCpltCallback(husart);
+  }
-#endif /* USE_HAL_USART_REGISTER_CALLBACKS */
-}
+  /* No Abort process still ongoing : All DMA channels are aborted, call user Abort Complete callback */
+  husart->TxXferCount = 0x00U;
-/**
+  husart->RxXferCount = 0x00U;
-  * @brief  Simplex Send an amount of data in non-blocking mode.
-  * @param  husart Pointer to a USART_HandleTypeDef structure that contains
+  /* Reset errorCode */
-  *                the configuration information for the specified USART module.
+  husart->ErrorCode = HAL_USART_ERROR_NONE;
-  * @retval HAL status
-  * @note   The USART errors are not managed to avoid the overrun error.
+  /* Restore husart->State to Ready */
-  */
+  husart->State  = HAL_USART_STATE_READY;
-static HAL_StatusTypeDef USART_Transmit_IT(USART_HandleTypeDef *husart)
-{
+  /* Call user Abort complete callback */
-  uint16_t *tmp;
+#if (USE_HAL_USART_REGISTER_CALLBACKS == 1)
+  /* Call registered Abort Complete Callback */
-  if (husart->State == HAL_USART_STATE_BUSY_TX)
+  husart->AbortCpltCallback(husart);
-  {
+#else
-    if ((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE))
+  /* Call legacy weak Abort Complete Callback */
-    {
+  HAL_USART_AbortCpltCallback(husart);
-      tmp = (uint16_t *) husart->pTxBuffPtr;
+#endif /* USE_HAL_USART_REGISTER_CALLBACKS */
-      husart->Instance->DR = (uint16_t)(*tmp & (uint16_t)0x01FF);
+}
-      husart->pTxBuffPtr += 2U;
-    }
+/**
-    else
+  * @brief  Simplex Send an amount of data in non-blocking mode.
-    {
+  * @param  husart Pointer to a USART_HandleTypeDef structure that contains
-      husart->Instance->DR = (uint8_t)(*husart->pTxBuffPtr++ & (uint8_t)0x00FF);
+  *                the configuration information for the specified USART module.
-    }
+  * @retval HAL status
+  * @note   The USART errors are not managed to avoid the overrun error.
-    if (--husart->TxXferCount == 0U)
+  */
-    {
+static HAL_StatusTypeDef USART_Transmit_IT(USART_HandleTypeDef *husart)
-      /* Disable the USART Transmit data register empty Interrupt */
+{
-      CLEAR_BIT(husart->Instance->CR1, USART_CR1_TXEIE);
+  const uint16_t *tmp;
-      /* Enable the USART Transmit Complete Interrupt */
+  if (husart->State == HAL_USART_STATE_BUSY_TX)
-      SET_BIT(husart->Instance->CR1, USART_CR1_TCIE);
+  {
-    }
+    if ((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE))
-    return HAL_OK;
+    {
-  }
+      tmp = (const uint16_t *) husart->pTxBuffPtr;
-  else
+      husart->Instance->DR = (uint16_t)(*tmp & (uint16_t)0x01FF);
-  {
+      husart->pTxBuffPtr += 2U;
-    return HAL_BUSY;
+    }
-  }
+    else
-}
+    {
+      husart->Instance->DR = (uint8_t)(*husart->pTxBuffPtr++ & (uint8_t)0x00FF);
-/**
+    }
-  * @brief  Wraps up transmission in non blocking mode.
-  * @param  husart Pointer to a USART_HandleTypeDef structure that contains
+    if (--husart->TxXferCount == 0U)
-  *                the configuration information for the specified USART module.
+    {
-  * @retval HAL status
+      /* Disable the USART Transmit data register empty Interrupt */
-  */
+      CLEAR_BIT(husart->Instance->CR1, USART_CR1_TXEIE);
-static HAL_StatusTypeDef USART_EndTransmit_IT(USART_HandleTypeDef *husart)
-{
+      /* Enable the USART Transmit Complete Interrupt */
-  /* Disable the USART Transmit Complete Interrupt */
+      SET_BIT(husart->Instance->CR1, USART_CR1_TCIE);
-  CLEAR_BIT(husart->Instance->CR1, USART_CR1_TCIE);
+    }
+    return HAL_OK;
-  /* Disable the USART Error Interrupt: (Frame error, noise error, overrun error) */
+  }
-  CLEAR_BIT(husart->Instance->CR3, USART_CR3_EIE);
+  else
+  {
-  husart->State = HAL_USART_STATE_READY;
+    return HAL_BUSY;
+  }
-#if (USE_HAL_USART_REGISTER_CALLBACKS == 1)
+}
-  /* Call registered Tx Complete Callback */
-  husart->TxCpltCallback(husart);
+/**
-#else
+  * @brief  Wraps up transmission in non blocking mode.
-  /* Call legacy weak Tx Complete Callback */
+  * @param  husart Pointer to a USART_HandleTypeDef structure that contains
-  HAL_USART_TxCpltCallback(husart);
+  *                the configuration information for the specified USART module.
-#endif /* USE_HAL_USART_REGISTER_CALLBACKS */
+  * @retval HAL status
+  */
-  return HAL_OK;
+static HAL_StatusTypeDef USART_EndTransmit_IT(USART_HandleTypeDef *husart)
-}
+{
+  /* Disable the USART Transmit Complete Interrupt */
-/**
+  CLEAR_BIT(husart->Instance->CR1, USART_CR1_TCIE);
-  * @brief  Simplex Receive an amount of data in non-blocking mode.
-  * @param  husart Pointer to a USART_HandleTypeDef structure that contains
+  /* Disable the USART Error Interrupt: (Frame error, noise error, overrun error) */
-  *                the configuration information for the specified USART module.
+  CLEAR_BIT(husart->Instance->CR3, USART_CR3_EIE);
-  * @retval HAL status
-  */
+  husart->State = HAL_USART_STATE_READY;
-static HAL_StatusTypeDef USART_Receive_IT(USART_HandleTypeDef *husart)
-{
+#if (USE_HAL_USART_REGISTER_CALLBACKS == 1)
-  uint8_t  *pdata8bits;
+  /* Call registered Tx Complete Callback */
-  uint16_t *pdata16bits;
+  husart->TxCpltCallback(husart);
+#else
-  if (husart->State == HAL_USART_STATE_BUSY_RX)
+  /* Call legacy weak Tx Complete Callback */
-  {
+  HAL_USART_TxCpltCallback(husart);
-    if ((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE))
+#endif /* USE_HAL_USART_REGISTER_CALLBACKS */
-    {
-      pdata8bits  = NULL;
+  return HAL_OK;
-      pdata16bits = (uint16_t *) husart->pRxBuffPtr;
+}
-      *pdata16bits = (uint16_t)(husart->Instance->DR & (uint16_t)0x01FF);
-      husart->pRxBuffPtr += 2U;
+/**
-    }
+  * @brief  Simplex Receive an amount of data in non-blocking mode.
-    else
+  * @param  husart Pointer to a USART_HandleTypeDef structure that contains
-    {
+  *                the configuration information for the specified USART module.
-      pdata8bits = (uint8_t *) husart->pRxBuffPtr;
+  * @retval HAL status
-      pdata16bits  = NULL;
+  */
+static HAL_StatusTypeDef USART_Receive_IT(USART_HandleTypeDef *husart)
-      if ((husart->Init.WordLength == USART_WORDLENGTH_9B) || ((husart->Init.WordLength == USART_WORDLENGTH_8B) && (husart->Init.Parity == USART_PARITY_NONE)))
+{
-      {
+  uint8_t  *pdata8bits;
-        *pdata8bits = (uint8_t)(husart->Instance->DR & (uint8_t)0x00FF);
+  uint16_t *pdata16bits;
-      }
-      else
+  if (husart->State == HAL_USART_STATE_BUSY_RX)
-      {
+  {
-        *pdata8bits = (uint8_t)(husart->Instance->DR & (uint8_t)0x007F);
+    if ((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE))
-      }
+    {
+      pdata8bits  = NULL;
-      husart->pRxBuffPtr += 1U;
+      pdata16bits = (uint16_t *) husart->pRxBuffPtr;
-    }
+      *pdata16bits = (uint16_t)(husart->Instance->DR & (uint16_t)0x01FF);
+      husart->pRxBuffPtr += 2U;
-    husart->RxXferCount--;
+    }
+    else
-    if (husart->RxXferCount == 0U)
+    {
-    {
+      pdata8bits = (uint8_t *) husart->pRxBuffPtr;
-      /* Disable the USART RXNE Interrupt */
+      pdata16bits  = NULL;
-      CLEAR_BIT(husart->Instance->CR1, USART_CR1_RXNEIE);
+      if ((husart->Init.WordLength == USART_WORDLENGTH_9B) || ((husart->Init.WordLength == USART_WORDLENGTH_8B) && (husart->Init.Parity == USART_PARITY_NONE)))
-      /* Disable the USART Parity Error Interrupt */
+      {
-      CLEAR_BIT(husart->Instance->CR1, USART_CR1_PEIE);
+        *pdata8bits = (uint8_t)(husart->Instance->DR & (uint8_t)0x00FF);
+      }
-      /* Disable the USART Error Interrupt: (Frame error, noise error, overrun error) */
+      else
-      CLEAR_BIT(husart->Instance->CR3, USART_CR3_EIE);
+      {
+        *pdata8bits = (uint8_t)(husart->Instance->DR & (uint8_t)0x007F);
-      husart->State = HAL_USART_STATE_READY;
+      }
-#if (USE_HAL_USART_REGISTER_CALLBACKS == 1)
-      /* Call registered Rx Complete Callback */
+      husart->pRxBuffPtr += 1U;
-      husart->RxCpltCallback(husart);
+    }
-#else
-      /* Call legacy weak Rx Complete Callback */
+    husart->RxXferCount--;
-      HAL_USART_RxCpltCallback(husart);
-#endif /* USE_HAL_USART_REGISTER_CALLBACKS */
+    if (husart->RxXferCount == 0U)
+    {
-      return HAL_OK;
+      /* Disable the USART RXNE Interrupt */
-    }
+      CLEAR_BIT(husart->Instance->CR1, USART_CR1_RXNEIE);
-    else
-    {
+      /* Disable the USART Parity Error Interrupt */
-      /* Send dummy byte in order to generate the clock for the slave to send the next data.
+      CLEAR_BIT(husart->Instance->CR1, USART_CR1_PEIE);
-      * Whatever the frame length (7, 8 or 9-bit long), the same dummy value
-      * can be written for all the cases. */
+      /* Disable the USART Error Interrupt: (Frame error, noise error, overrun error) */
-      husart->Instance->DR = (DUMMY_DATA & (uint16_t)0x0FF);
+      CLEAR_BIT(husart->Instance->CR3, USART_CR3_EIE);
-    }
-    return HAL_OK;
+      husart->State = HAL_USART_STATE_READY;
-  }
+#if (USE_HAL_USART_REGISTER_CALLBACKS == 1)
-  else
+      /* Call registered Rx Complete Callback */
-  {
+      husart->RxCpltCallback(husart);
-    return HAL_BUSY;
+#else
-  }
+      /* Call legacy weak Rx Complete Callback */
-}
+      HAL_USART_RxCpltCallback(husart);
+#endif /* USE_HAL_USART_REGISTER_CALLBACKS */
-/**
-  * @brief  Full-Duplex Send receive an amount of data in full-duplex mode (non-blocking).
+      return HAL_OK;
-  * @param  husart Pointer to a USART_HandleTypeDef structure that contains
+    }
-  *                the configuration information for the specified USART module.
+    else
-  * @retval HAL status
+    {
-  */
+      /* Send dummy byte in order to generate the clock for the slave to send the next data.
-static HAL_StatusTypeDef USART_TransmitReceive_IT(USART_HandleTypeDef *husart)
+      * Whatever the frame length (7, 8 or 9-bit long), the same dummy value
-{
+      * can be written for all the cases. */
-  uint8_t  *pdata8bits;
+      husart->Instance->DR = (DUMMY_DATA & (uint16_t)0x0FF);
-  uint16_t *pdata16bits;
+    }
+    return HAL_OK;
-  if (husart->State == HAL_USART_STATE_BUSY_TX_RX)
+  }
-  {
+  else
-    if (husart->TxXferCount != 0x00U)
+  {
-    {
+    return HAL_BUSY;
-      if (__HAL_USART_GET_FLAG(husart, USART_FLAG_TXE) != RESET)
+  }
-      {
+}
-        if ((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE))
-        {
+/**
-          pdata8bits  = NULL;
+  * @brief  Full-Duplex Send receive an amount of data in full-duplex mode (non-blocking).
-          pdata16bits = (uint16_t *) husart->pTxBuffPtr;
+  * @param  husart Pointer to a USART_HandleTypeDef structure that contains
-          husart->Instance->DR = (uint16_t)(*pdata16bits & (uint16_t)0x01FF);
+  *                the configuration information for the specified USART module.
-          husart->pTxBuffPtr += 2U;
+  * @retval HAL status
-        }
+  */
-        else
+static HAL_StatusTypeDef USART_TransmitReceive_IT(USART_HandleTypeDef *husart)
-        {
+{
-          husart->Instance->DR = (uint8_t)(*husart->pTxBuffPtr++ & (uint8_t)0x00FF);
+  const uint16_t *pdatatx16bits;
-        }
+  uint16_t *pdatarx16bits;
-        husart->TxXferCount--;
+  if (husart->State == HAL_USART_STATE_BUSY_TX_RX)
+  {
-        /* Check the latest data transmitted */
+    if (husart->TxXferCount != 0x00U)
-        if (husart->TxXferCount == 0U)
+    {
-        {
+      if (__HAL_USART_GET_FLAG(husart, USART_FLAG_TXE) != RESET)
-          CLEAR_BIT(husart->Instance->CR1, USART_CR1_TXEIE);
+      {
-        }
+        if ((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE))
-      }
+        {
-    }
+          pdatatx16bits = (const uint16_t *) husart->pTxBuffPtr;
+          husart->Instance->DR = (uint16_t)(*pdatatx16bits & (uint16_t)0x01FF);
-    if (husart->RxXferCount != 0x00U)
+          husart->pTxBuffPtr += 2U;
-    {
+        }
-      if (__HAL_USART_GET_FLAG(husart, USART_FLAG_RXNE) != RESET)
+        else
-      {
+        {
-        if ((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE))
+          husart->Instance->DR = (uint8_t)(*husart->pTxBuffPtr++ & (uint8_t)0x00FF);
-        {
+        }
-           pdata8bits  = NULL;
-           pdata16bits = (uint16_t *) husart->pRxBuffPtr;
+        husart->TxXferCount--;
-           *pdata16bits = (uint16_t)(husart->Instance->DR & (uint16_t)0x01FF);
-           husart->pRxBuffPtr += 2U;
+        /* Check the latest data transmitted */
-        }
+        if (husart->TxXferCount == 0U)
-        else
+        {
-        {
+          CLEAR_BIT(husart->Instance->CR1, USART_CR1_TXEIE);
-          pdata8bits = (uint8_t *) husart->pRxBuffPtr;
+        }
-          pdata16bits  = NULL;
+      }
-          if ((husart->Init.WordLength == USART_WORDLENGTH_9B) || ((husart->Init.WordLength == USART_WORDLENGTH_8B) && (husart->Init.Parity == USART_PARITY_NONE)))
+    }
-          {
-            *pdata8bits = (uint8_t)(husart->Instance->DR & (uint8_t)0x00FF);
+    if (husart->RxXferCount != 0x00U)
-          }
+    {
-          else
+      if (__HAL_USART_GET_FLAG(husart, USART_FLAG_RXNE) != RESET)
-          {
+      {
-            *pdata8bits = (uint8_t)(husart->Instance->DR & (uint8_t)0x007F);
+        if ((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE))
-          }
+        {
-          husart->pRxBuffPtr += 1U;
+          pdatarx16bits = (uint16_t *) husart->pRxBuffPtr;
-        }
+          *pdatarx16bits = (uint16_t)(husart->Instance->DR & (uint16_t)0x01FF);
+          husart->pRxBuffPtr += 2U;
-        husart->RxXferCount--;
+        }
-      }
+        else
-    }
+        {
+          if ((husart->Init.WordLength == USART_WORDLENGTH_9B) || ((husart->Init.WordLength == USART_WORDLENGTH_8B) && (husart->Init.Parity == USART_PARITY_NONE)))
-    /* Check the latest data received */
+          {
-    if (husart->RxXferCount == 0U)
+            *husart->pRxBuffPtr = (uint8_t)(husart->Instance->DR & (uint8_t)0x00FF);
-    {
+          }
-      /* Disable the USART RXNE Interrupt */
+          else
-      CLEAR_BIT(husart->Instance->CR1, USART_CR1_RXNEIE);
+          {
+            *husart->pRxBuffPtr = (uint8_t)(husart->Instance->DR & (uint8_t)0x007F);
-      /* Disable the USART Parity Error Interrupt */
+          }
-      CLEAR_BIT(husart->Instance->CR1, USART_CR1_PEIE);
+          husart->pRxBuffPtr += 1U;
+        }
-      /* Disable the USART Error Interrupt: (Frame error, noise error, overrun error) */
-      CLEAR_BIT(husart->Instance->CR3, USART_CR3_EIE);
+        husart->RxXferCount--;
+      }
-      husart->State = HAL_USART_STATE_READY;
+    }
-#if (USE_HAL_USART_REGISTER_CALLBACKS == 1)
+    /* Check the latest data received */
-      /* Call registered Tx Rx Complete Callback */
+    if (husart->RxXferCount == 0U)
-      husart->TxRxCpltCallback(husart);
+    {
-#else
+      /* Disable the USART RXNE Interrupt */
-      /* Call legacy weak Tx Rx Complete Callback */
+      CLEAR_BIT(husart->Instance->CR1, USART_CR1_RXNEIE);
-      HAL_USART_TxRxCpltCallback(husart);
-#endif /* USE_HAL_USART_REGISTER_CALLBACKS */
+      /* Disable the USART Parity Error Interrupt */
+      CLEAR_BIT(husart->Instance->CR1, USART_CR1_PEIE);
-      return HAL_OK;
-    }
+      /* Disable the USART Error Interrupt: (Frame error, noise error, overrun error) */
+      CLEAR_BIT(husart->Instance->CR3, USART_CR3_EIE);
-    return HAL_OK;
-  }
+      husart->State = HAL_USART_STATE_READY;
-  else
-  {
+#if (USE_HAL_USART_REGISTER_CALLBACKS == 1)
-    return HAL_BUSY;
+      /* Call registered Tx Rx Complete Callback */
-  }
+      husart->TxRxCpltCallback(husart);
-}
+#else
+      /* Call legacy weak Tx Rx Complete Callback */
-/**
+      HAL_USART_TxRxCpltCallback(husart);
-  * @brief  Configures the USART peripheral.
+#endif /* USE_HAL_USART_REGISTER_CALLBACKS */
-  * @param  husart Pointer to a USART_HandleTypeDef structure that contains
-  *                the configuration information for the specified USART module.
+      return HAL_OK;
-  * @retval None
+    }
-  */
-static void USART_SetConfig(USART_HandleTypeDef *husart)
+    return HAL_OK;
-{
+  }
-  uint32_t tmpreg = 0x00U;
+  else
-  uint32_t pclk;
+  {
+    return HAL_BUSY;
-  /* Check the parameters */
+  }
-  assert_param(IS_USART_INSTANCE(husart->Instance));
+}
-  assert_param(IS_USART_POLARITY(husart->Init.CLKPolarity));
-  assert_param(IS_USART_PHASE(husart->Init.CLKPhase));
+/**
-  assert_param(IS_USART_LASTBIT(husart->Init.CLKLastBit));
+  * @brief  Configures the USART peripheral.
-  assert_param(IS_USART_BAUDRATE(husart->Init.BaudRate));
+  * @param  husart Pointer to a USART_HandleTypeDef structure that contains
-  assert_param(IS_USART_WORD_LENGTH(husart->Init.WordLength));
+  *                the configuration information for the specified USART module.
-  assert_param(IS_USART_STOPBITS(husart->Init.StopBits));
+  * @retval None
-  assert_param(IS_USART_PARITY(husart->Init.Parity));
+  */
-  assert_param(IS_USART_MODE(husart->Init.Mode));
+static void USART_SetConfig(USART_HandleTypeDef *husart)
+{
-  /* The LBCL, CPOL and CPHA bits have to be selected when both the transmitter and the
+  uint32_t tmpreg = 0x00U;
-     receiver are disabled (TE=RE=0) to ensure that the clock pulses function correctly. */
+  uint32_t pclk;
-  CLEAR_BIT(husart->Instance->CR1, (USART_CR1_TE | USART_CR1_RE));
+  /* Check the parameters */
-  /*---------------------------- USART CR2 Configuration ---------------------*/
+  assert_param(IS_USART_INSTANCE(husart->Instance));
-  tmpreg = husart->Instance->CR2;
+  assert_param(IS_USART_POLARITY(husart->Init.CLKPolarity));
-  /* Clear CLKEN, CPOL, CPHA and LBCL bits */
+  assert_param(IS_USART_PHASE(husart->Init.CLKPhase));
-  tmpreg &= (uint32_t)~((uint32_t)(USART_CR2_CPHA | USART_CR2_CPOL | USART_CR2_CLKEN | USART_CR2_LBCL | USART_CR2_STOP));
+  assert_param(IS_USART_LASTBIT(husart->Init.CLKLastBit));
-  /* Configure the USART Clock, CPOL, CPHA and LastBit -----------------------*/
+  assert_param(IS_USART_BAUDRATE(husart->Init.BaudRate));
-  /* Set CPOL bit according to husart->Init.CLKPolarity value */
+  assert_param(IS_USART_WORD_LENGTH(husart->Init.WordLength));
-  /* Set CPHA bit according to husart->Init.CLKPhase value */
+  assert_param(IS_USART_STOPBITS(husart->Init.StopBits));
-  /* Set LBCL bit according to husart->Init.CLKLastBit value */
+  assert_param(IS_USART_PARITY(husart->Init.Parity));
-  /* Set Stop Bits: Set STOP[13:12] bits according to husart->Init.StopBits value */
+  assert_param(IS_USART_MODE(husart->Init.Mode));
-  tmpreg |= (uint32_t)(USART_CLOCK_ENABLE | husart->Init.CLKPolarity |
-                       husart->Init.CLKPhase | husart->Init.CLKLastBit | husart->Init.StopBits);
+  /* The LBCL, CPOL and CPHA bits have to be selected when both the transmitter and the
-  /* Write to USART CR2 */
+     receiver are disabled (TE=RE=0) to ensure that the clock pulses function correctly. */
-  WRITE_REG(husart->Instance->CR2, (uint32_t)tmpreg);
+  CLEAR_BIT(husart->Instance->CR1, (USART_CR1_TE | USART_CR1_RE));
-  /*-------------------------- USART CR1 Configuration -----------------------*/
+  /*---------------------------- USART CR2 Configuration ---------------------*/
-  tmpreg = husart->Instance->CR1;
+  tmpreg = husart->Instance->CR2;
+  /* Clear CLKEN, CPOL, CPHA and LBCL bits */
-  /* Clear M, PCE, PS, TE and RE bits */
+  tmpreg &= (uint32_t)~((uint32_t)(USART_CR2_CPHA | USART_CR2_CPOL | USART_CR2_CLKEN | USART_CR2_LBCL | USART_CR2_STOP));
-  tmpreg &= (uint32_t)~((uint32_t)(USART_CR1_M | USART_CR1_PCE | USART_CR1_PS | USART_CR1_TE | USART_CR1_RE));
+  /* Configure the USART Clock, CPOL, CPHA and LastBit -----------------------*/
+  /* Set CPOL bit according to husart->Init.CLKPolarity value */
-  /* Configure the USART Word Length, Parity and mode:
+  /* Set CPHA bit according to husart->Init.CLKPhase value */
-     Set the M bits according to husart->Init.WordLength value
+  /* Set LBCL bit according to husart->Init.CLKLastBit value */
-     Set PCE and PS bits according to husart->Init.Parity value
+  /* Set Stop Bits: Set STOP[13:12] bits according to husart->Init.StopBits value */
-     Set TE and RE bits according to husart->Init.Mode value
+  tmpreg |= (uint32_t)(USART_CLOCK_ENABLE | husart->Init.CLKPolarity |
-   */
+                       husart->Init.CLKPhase | husart->Init.CLKLastBit | husart->Init.StopBits);
-  tmpreg |= (uint32_t)husart->Init.WordLength | husart->Init.Parity | husart->Init.Mode;
+  /* Write to USART CR2 */
+  WRITE_REG(husart->Instance->CR2, (uint32_t)tmpreg);
-  /* Write to USART CR1 */
-  WRITE_REG(husart->Instance->CR1, (uint32_t)tmpreg);
+  /*-------------------------- USART CR1 Configuration -----------------------*/
+  tmpreg = husart->Instance->CR1;
-  /*-------------------------- USART CR3 Configuration -----------------------*/
-  /* Clear CTSE and RTSE bits */
+  /* Clear M, PCE, PS, TE and RE bits */
-  CLEAR_BIT(husart->Instance->CR3, (USART_CR3_RTSE | USART_CR3_CTSE));
+  tmpreg &= (uint32_t)~((uint32_t)(USART_CR1_M | USART_CR1_PCE | USART_CR1_PS | USART_CR1_TE | USART_CR1_RE));
-  /*-------------------------- USART BRR Configuration -----------------------*/
+  /* Configure the USART Word Length, Parity and mode:
-  if((husart->Instance == USART1))
+     Set the M bits according to husart->Init.WordLength value
-  {
+     Set PCE and PS bits according to husart->Init.Parity value
-    pclk = HAL_RCC_GetPCLK2Freq();
+     Set TE and RE bits according to husart->Init.Mode value
-    husart->Instance->BRR = USART_BRR(pclk, husart->Init.BaudRate);
+   */
-  }
+  tmpreg |= (uint32_t)husart->Init.WordLength | husart->Init.Parity | husart->Init.Mode;
-  else
-  {
+  /* Write to USART CR1 */
-    pclk = HAL_RCC_GetPCLK1Freq();
+  WRITE_REG(husart->Instance->CR1, (uint32_t)tmpreg);
-    husart->Instance->BRR = USART_BRR(pclk, husart->Init.BaudRate);
-  }
+  /*-------------------------- USART CR3 Configuration -----------------------*/
-}
+  /* Clear CTSE and RTSE bits */
+  CLEAR_BIT(husart->Instance->CR3, (USART_CR3_RTSE | USART_CR3_CTSE));
-/**
-  * @}
+  /*-------------------------- USART BRR Configuration -----------------------*/
-  */
+  if((husart->Instance == USART1))
+  {
-/**
+    pclk = HAL_RCC_GetPCLK2Freq();
-  * @}
+    husart->Instance->BRR = USART_BRR(pclk, husart->Init.BaudRate);
-  */
+  }
+  else
-#endif /* HAL_USART_MODULE_ENABLED */
+  {
-/**
+    pclk = HAL_RCC_GetPCLK1Freq();
-  * @}
+    husart->Instance->BRR = USART_BRR(pclk, husart->Init.BaudRate);
-  */
+  }
+}
-/**
-  * @}
+/**
-  */
+  * @}
+  */
-/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
+/**
+  * @}
+  */
+#endif /* HAL_USART_MODULE_ENABLED */
+/**
+  * @}
+  */
+/**
+  * @}
+  */

Subversion Repositories canSerial

(root)/trunk/Drivers/STM32F1xx_HAL_Driver/Src/stm32f1xx_hal_usart.c – Rev 2 → 3