Subversion Repositories DashDisplay

/**

/**

  ******************************************************************************

  ******************************************************************************

  * @file    stm32l1xx_hal_uart.c

  * @file    stm32l1xx_hal_uart.c

  * @author  MCD Application Team

  * @author  MCD Application Team

  * @brief   UART HAL module driver.

  * @brief   UART HAL module driver.

  *          This file provides firmware functions to manage the following

  *          This file provides firmware functions to manage the following

  *          functionalities of the Universal Asynchronous Receiver Transmitter Peripheral (UART).

  *          functionalities of the Universal Asynchronous Receiver Transmitter Peripheral (UART).

  *           + Initialization and de-initialization functions

  *           + Initialization and de-initialization functions

  *           + IO operation functions

  *           + IO operation functions

  *           + Peripheral Control functions

  *           + Peripheral Control functions

  *           + Peripheral State and Errors functions

  *           + Peripheral State and Errors functions

  @verbatim

  *

  ==============================================================================

  ******************************************************************************

                        ##### How to use this driver #####

  * @attention

  ==============================================================================

  *

  [..]

  * Copyright (c) 2016 STMicroelectronics.

    The UART HAL driver can be used as follows:

  * All rights reserved.

  *

    (#) Declare a UART_HandleTypeDef handle structure (eg. UART_HandleTypeDef huart).

  * This software is licensed under terms that can be found in the LICENSE file

    (#) Initialize the UART low level resources by implementing the HAL_UART_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.

        (##) UART pins configuration:

  *

            (+++) Enable the clock for the UART GPIOs.

  ******************************************************************************

            (+++) Configure the UART TX/RX pins as alternate function pull-up.

  @verbatim

        (##) NVIC configuration if you need to use interrupt process (HAL_UART_Transmit_IT()

  ==============================================================================

             and HAL_UART_Receive_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_UART_Transmit_DMA()

    The UART HAL driver can be used as follows:

             and HAL_UART_Receive_DMA() APIs):

            (+++) Declare a DMA handle structure for the Tx/Rx channel.

    (#) Declare a UART_HandleTypeDef handle structure (eg. UART_HandleTypeDef huart).

            (+++) Enable the DMAx interface clock.

    (#) Initialize the UART low level resources by implementing the HAL_UART_MspInit() API:

            (+++) Configure the declared DMA handle structure with the required

        (##) Enable the USARTx interface clock.

                  Tx/Rx parameters.

        (##) UART pins configuration:

            (+++) Configure the DMA Tx/Rx channel.

            (+++) Enable the clock for the UART GPIOs.

            (+++) Associate the initialized DMA handle to the UART DMA Tx/Rx handle.

            (+++) Configure the UART TX/RX pins as alternate function pull-up.

            (+++) Configure the priority and enable the NVIC for the transfer complete

        (##) NVIC configuration if you need to use interrupt process (HAL_UART_Transmit_IT()

                  interrupt on the DMA Tx/Rx channel.

             and HAL_UART_Receive_IT() APIs):

            (+++) Configure the USARTx interrupt priority and enable the NVIC USART IRQ handle

            (+++) Configure the USARTx interrupt priority.

                  (used for last byte sending completion detection in DMA non circular mode)

            (+++) Enable the NVIC USART IRQ handle.

        (##) DMA Configuration if you need to use DMA process (HAL_UART_Transmit_DMA()

    (#) Program the Baud Rate, Word Length, Stop Bit, Parity, Hardware

             and HAL_UART_Receive_DMA() APIs):

        flow control and Mode(Receiver/Transmitter) in the huart Init structure.

            (+++) Declare a DMA handle structure for the Tx/Rx channel.

            (+++) Enable the DMAx interface clock.

    (#) For the UART asynchronous mode, initialize the UART registers by calling

            (+++) Configure the declared DMA handle structure with the required

        the HAL_UART_Init() API.

                  Tx/Rx parameters.

            (+++) Configure the DMA Tx/Rx channel.

    (#) For the UART Half duplex mode, initialize the UART registers by calling

            (+++) Associate the initialized DMA handle to the UART DMA Tx/Rx handle.

        the HAL_HalfDuplex_Init() API.

            (+++) Configure the priority and enable the NVIC for the transfer complete

                  interrupt on the DMA Tx/Rx channel.

    (#) For the LIN mode, initialize the UART registers by calling the HAL_LIN_Init() API.

            (+++) Configure the USARTx interrupt priority and enable the NVIC USART IRQ handle

                  (used for last byte sending completion detection in DMA non circular mode)

    (#) For the Multi-Processor mode, initialize the UART registers by calling

        the HAL_MultiProcessor_Init() API.

    (#) Program the Baud Rate, Word Length, Stop Bit, Parity, Hardware

        flow control and Mode(Receiver/Transmitter) in the huart Init structure.

     [..]

       (@) The specific UART interrupts (Transmission complete interrupt,

    (#) For the UART asynchronous mode, initialize the UART registers by calling

            RXNE interrupt and Error Interrupts) will be managed using the macros

        the HAL_UART_Init() API.

            __HAL_UART_ENABLE_IT() and __HAL_UART_DISABLE_IT() inside the transmit

            and receive process.

    (#) For the UART Half duplex mode, initialize the UART registers by calling

        the HAL_HalfDuplex_Init() API.

     [..]

       (@) These APIs (HAL_UART_Init() and HAL_HalfDuplex_Init()) configure also the

    (#) For the LIN mode, initialize the UART registers by calling the HAL_LIN_Init() API.

            low level Hardware GPIO, CLOCK, CORTEX...etc) by calling the customized

            HAL_UART_MspInit() API.

    (#) For the Multi-Processor mode, initialize the UART registers by calling

        the HAL_MultiProcessor_Init() API.

    ##### Callback registration #####

    ==================================

     [..]

       (@) The specific UART interrupts (Transmission complete interrupt,

    [..]

            RXNE interrupt and Error Interrupts) will be managed using the macros

    The compilation define USE_HAL_UART_REGISTER_CALLBACKS when set to 1

            __HAL_UART_ENABLE_IT() and __HAL_UART_DISABLE_IT() inside the transmit

    allows the user to configure dynamically the driver callbacks.

            and receive process.

    [..]

     [..]

    Use Function @ref HAL_UART_RegisterCallback() to register a user callback.

       (@) These APIs (HAL_UART_Init() and HAL_HalfDuplex_Init()) configure also the

    Function @ref HAL_UART_RegisterCallback() allows to register following callbacks:

            low level Hardware GPIO, CLOCK, CORTEX...etc) by calling the customized

    (+) TxHalfCpltCallback        : Tx Half Complete Callback.

            HAL_UART_MspInit() API.

    (+) TxCpltCallback            : Tx Complete Callback.

    (+) RxHalfCpltCallback        : Rx Half Complete Callback.

    ##### Callback registration #####

    (+) RxCpltCallback            : Rx Complete Callback.

    ==================================

    (+) ErrorCallback             : Error Callback.

    (+) AbortCpltCallback         : Abort Complete Callback.

    [..]

    (+) AbortTransmitCpltCallback : Abort Transmit Complete Callback.

    The compilation define USE_HAL_UART_REGISTER_CALLBACKS when set to 1

    (+) AbortReceiveCpltCallback  : Abort Receive Complete Callback.

    allows the user to configure dynamically the driver callbacks.

    (+) MspInitCallback           : UART MspInit.

    (+) MspDeInitCallback         : UART MspDeInit.

    [..]

    This function takes as parameters the HAL peripheral handle, the Callback ID

    Use Function HAL_UART_RegisterCallback() to register a user callback.

    and a pointer to the user callback function.

    Function HAL_UART_RegisterCallback() allows to register following callbacks:

    (+) TxHalfCpltCallback        : Tx Half Complete Callback.

    [..]

    (+) TxCpltCallback            : Tx Complete Callback.

    Use function @ref HAL_UART_UnRegisterCallback() to reset a callback to the default

    (+) RxHalfCpltCallback        : Rx Half Complete Callback.

    weak (surcharged) function.

    (+) RxCpltCallback            : Rx Complete Callback.

    @ref HAL_UART_UnRegisterCallback() takes as parameters the HAL peripheral handle,

    (+) ErrorCallback             : Error Callback.

    and the Callback ID.

    (+) AbortCpltCallback         : Abort Complete Callback.

    This function allows to reset following callbacks:

    (+) AbortTransmitCpltCallback : Abort Transmit Complete Callback.

    (+) TxHalfCpltCallback        : Tx Half Complete Callback.

    (+) AbortReceiveCpltCallback  : Abort Receive Complete Callback.

    (+) TxCpltCallback            : Tx Complete Callback.

    (+) MspInitCallback           : UART MspInit.

    (+) RxHalfCpltCallback        : Rx Half Complete Callback.

    (+) MspDeInitCallback         : UART MspDeInit.

    (+) RxCpltCallback            : Rx Complete Callback.

    This function takes as parameters the HAL peripheral handle, the Callback ID

    (+) ErrorCallback             : Error Callback.

    and a pointer to the user callback function.

    (+) AbortCpltCallback         : Abort Complete Callback.

    (+) AbortTransmitCpltCallback : Abort Transmit Complete Callback.

    [..]

    (+) AbortReceiveCpltCallback  : Abort Receive Complete Callback.

    Use function HAL_UART_UnRegisterCallback() to reset a callback to the default

    (+) MspInitCallback           : UART MspInit.

    weak (surcharged) function.

    (+) MspDeInitCallback         : UART MspDeInit.

    HAL_UART_UnRegisterCallback() takes as parameters the HAL peripheral handle,

    and the Callback ID.

    [..]

    This function allows to reset following callbacks:

    For specific callback RxEventCallback, use dedicated registration/reset functions:

    (+) TxHalfCpltCallback        : Tx Half Complete Callback.

    respectively @ref HAL_UART_RegisterRxEventCallback() , @ref HAL_UART_UnRegisterRxEventCallback().

    (+) TxCpltCallback            : Tx Complete Callback.

    (+) RxHalfCpltCallback        : Rx Half Complete Callback.

    [..]

    (+) RxCpltCallback            : Rx Complete Callback.

    By default, after the @ref HAL_UART_Init() and when the state is HAL_UART_STATE_RESET

    (+) ErrorCallback             : Error Callback.

    all callbacks are set to the corresponding weak (surcharged) functions:

    (+) AbortCpltCallback         : Abort Complete Callback.

    examples @ref HAL_UART_TxCpltCallback(), @ref HAL_UART_RxHalfCpltCallback().

    (+) AbortTransmitCpltCallback : Abort Transmit Complete Callback.

    Exception done for MspInit and MspDeInit functions that are respectively

    (+) AbortReceiveCpltCallback  : Abort Receive Complete Callback.

    reset to the legacy weak (surcharged) functions in the @ref HAL_UART_Init()

    (+) MspInitCallback           : UART MspInit.

    and @ref HAL_UART_DeInit() only when these callbacks are null (not registered beforehand).

    (+) MspDeInitCallback         : UART MspDeInit.

    If not, MspInit or MspDeInit are not null, the @ref HAL_UART_Init() and @ref HAL_UART_DeInit()

    keep and use the user MspInit/MspDeInit callbacks (registered beforehand).

    [..]

    For specific callback RxEventCallback, use dedicated registration/reset functions:

    [..]

    respectively HAL_UART_RegisterRxEventCallback() , HAL_UART_UnRegisterRxEventCallback().

    Callbacks can be registered/unregistered in HAL_UART_STATE_READY state only.

    Exception done MspInit/MspDeInit that can be registered/unregistered

    [..]

    in HAL_UART_STATE_READY or HAL_UART_STATE_RESET state, thus registered (user)

    By default, after the HAL_UART_Init() and when the state is HAL_UART_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 HAL_UART_TxCpltCallback(), HAL_UART_RxHalfCpltCallback().

    using @ref HAL_UART_RegisterCallback() before calling @ref HAL_UART_DeInit()

    Exception done for MspInit and MspDeInit functions that are respectively

    or @ref HAL_UART_Init() function.

    reset to the legacy weak (surcharged) functions in the HAL_UART_Init()

    and HAL_UART_DeInit() only when these callbacks are null (not registered beforehand).

    [..]

    If not, MspInit or MspDeInit are not null, the HAL_UART_Init() and HAL_UART_DeInit()

    When The compilation define USE_HAL_UART_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_UART_STATE_READY state only.

     [..]

    Exception done MspInit/MspDeInit that can be registered/unregistered

        Three operation modes are available within this driver :

    in HAL_UART_STATE_READY or HAL_UART_STATE_RESET state, thus registered (user)

    MspInit/DeInit callbacks can be used during the Init/DeInit.

     *** Polling mode IO operation ***

    In that case first register the MspInit/MspDeInit user callbacks

     =================================

    using HAL_UART_RegisterCallback() before calling HAL_UART_DeInit()

     [..]

    or HAL_UART_Init() function.

       (+) Send an amount of data in blocking mode using HAL_UART_Transmit()

       (+) Receive an amount of data in blocking mode using HAL_UART_Receive()

    [..]

    When The compilation define USE_HAL_UART_REGISTER_CALLBACKS is set to 0 or

     *** Interrupt mode IO operation ***

    not defined, the callback registration feature is not available

     ===================================

    and weak (surcharged) callbacks are used.

     [..]

       (+) Send an amount of data in non blocking mode using HAL_UART_Transmit_IT()

     [..]

       (+) At transmission end of transfer HAL_UART_TxCpltCallback is executed and user can

        Three operation modes are available within this driver :

            add his own code by customization of function pointer HAL_UART_TxCpltCallback

       (+) Receive an amount of data in non blocking mode using HAL_UART_Receive_IT()

     *** Polling mode IO operation ***

       (+) At reception end of transfer HAL_UART_RxCpltCallback is executed and user can

     =================================

            add his own code by customization of function pointer HAL_UART_RxCpltCallback

     [..]

       (+) In case of transfer Error, HAL_UART_ErrorCallback() function is executed and user can

       (+) Send an amount of data in blocking mode using HAL_UART_Transmit()

            add his own code by customization of function pointer HAL_UART_ErrorCallback

       (+) Receive an amount of data in blocking mode using HAL_UART_Receive()

     *** DMA mode IO operation ***

     *** Interrupt mode IO operation ***

     ==============================

     ===================================

     [..]

     [..]

       (+) Send an amount of data in non blocking mode (DMA) using HAL_UART_Transmit_DMA()

       (+) Send an amount of data in non blocking mode using HAL_UART_Transmit_IT()

       (+) At transmission end of half transfer HAL_UART_TxHalfCpltCallback is executed and user can

       (+) At transmission end of transfer HAL_UART_TxCpltCallback is executed and user can

            add his own code by customization of function pointer HAL_UART_TxHalfCpltCallback

            add his own code by customization of function pointer HAL_UART_TxCpltCallback

       (+) At transmission end of transfer HAL_UART_TxCpltCallback is executed and user can

       (+) Receive an amount of data in non blocking mode using HAL_UART_Receive_IT()

            add his own code by customization of function pointer HAL_UART_TxCpltCallback

       (+) At reception end of transfer HAL_UART_RxCpltCallback is executed and user can

       (+) Receive an amount of data in non blocking mode (DMA) using HAL_UART_Receive_DMA()

            add his own code by customization of function pointer HAL_UART_RxCpltCallback

       (+) At reception end of half transfer HAL_UART_RxHalfCpltCallback is executed and user can

       (+) In case of transfer Error, HAL_UART_ErrorCallback() function is executed and user can

            add his own code by customization of function pointer HAL_UART_RxHalfCpltCallback

            add his own code by customization of function pointer HAL_UART_ErrorCallback

       (+) At reception end of transfer HAL_UART_RxCpltCallback is executed and user can

            add his own code by customization of function pointer HAL_UART_RxCpltCallback

     *** DMA mode IO operation ***

       (+) In case of transfer Error, HAL_UART_ErrorCallback() function is executed and user can

     ==============================

            add his own code by customization of function pointer HAL_UART_ErrorCallback

     [..]

       (+) Pause the DMA Transfer using HAL_UART_DMAPause()

       (+) Send an amount of data in non blocking mode (DMA) using HAL_UART_Transmit_DMA()

       (+) Resume the DMA Transfer using HAL_UART_DMAResume()

       (+) At transmission end of half transfer HAL_UART_TxHalfCpltCallback is executed and user can

       (+) Stop the DMA Transfer using HAL_UART_DMAStop()

            add his own code by customization of function pointer HAL_UART_TxHalfCpltCallback

       (+) At transmission end of transfer HAL_UART_TxCpltCallback is executed and user can

            add his own code by customization of function pointer HAL_UART_TxCpltCallback

    [..] This subsection also provides a set of additional functions providing enhanced reception

       (+) Receive an amount of data in non blocking mode (DMA) using HAL_UART_Receive_DMA()

    services to user. (For example, these functions allow application to handle use cases

       (+) At reception end of half transfer HAL_UART_RxHalfCpltCallback is executed and user can

    where number of data to be received is unknown).

            add his own code by customization of function pointer HAL_UART_RxHalfCpltCallback

       (+) At reception end of transfer HAL_UART_RxCpltCallback is executed and user can

    (#) Compared to standard reception services which only consider number of received

            add his own code by customization of function pointer HAL_UART_RxCpltCallback

        data elements as reception completion criteria, these functions also consider additional events

       (+) In case of transfer Error, HAL_UART_ErrorCallback() function is executed and user can

        as triggers for updating reception status to caller :

            add his own code by customization of function pointer HAL_UART_ErrorCallback

       (+) Detection of inactivity period (RX line has not been active for a given period).

       (+) Pause the DMA Transfer using HAL_UART_DMAPause()

          (++) RX inactivity detected by IDLE event, i.e. RX line has been in idle state (normally high state)

       (+) Resume the DMA Transfer using HAL_UART_DMAResume()

               for 1 frame time, after last received byte.

       (+) Stop the DMA Transfer using HAL_UART_DMAStop()

    (#) There are two mode of transfer:

       (+) Blocking mode: The reception is performed in polling mode, until either expected number of data is received,

    [..] This subsection also provides a set of additional functions providing enhanced reception

           or till IDLE event occurs. Reception is handled only during function execution.

    services to user. (For example, these functions allow application to handle use cases

           When function exits, no data reception could occur. HAL status and number of actually received data elements,

    where number of data to be received is unknown).

           are returned by function after finishing transfer.

       (+) Non-Blocking mode: The reception is performed using Interrupts or DMA.

    (#) Compared to standard reception services which only consider number of received

           These API's return the HAL status.

        data elements as reception completion criteria, these functions also consider additional events

           The end of the data processing will be indicated through the

        as triggers for updating reception status to caller :

           dedicated UART IRQ when using Interrupt mode or the DMA IRQ when using DMA mode.

       (+) Detection of inactivity period (RX line has not been active for a given period).

           The HAL_UARTEx_RxEventCallback() user callback will be executed during Receive process

          (++) RX inactivity detected by IDLE event, i.e. RX line has been in idle state (normally high state)

           The HAL_UART_ErrorCallback()user callback will be executed when a reception error is detected.

               for 1 frame time, after last received byte.

    (#) Blocking mode API:

    (#) There are two mode of transfer:

        (+) HAL_UARTEx_ReceiveToIdle()

       (+) Blocking mode: The reception is performed in polling mode, until either expected number of data is received,

           or till IDLE event occurs. Reception is handled only during function execution.

    (#) Non-Blocking mode API with Interrupt:

           When function exits, no data reception could occur. HAL status and number of actually received data elements,

        (+) HAL_UARTEx_ReceiveToIdle_IT()

           are returned by function after finishing transfer.

       (+) Non-Blocking mode: The reception is performed using Interrupts or DMA.

    (#) Non-Blocking mode API with DMA:

           These API's return the HAL status.

        (+) HAL_UARTEx_ReceiveToIdle_DMA()

           The end of the data processing will be indicated through the

           dedicated UART IRQ when using Interrupt mode or the DMA IRQ when using DMA mode.

           The HAL_UARTEx_RxEventCallback() user callback will be executed during Receive process

     *** UART HAL driver macros list ***

           The HAL_UART_ErrorCallback()user callback will be executed when a reception error is detected.

     =============================================

     [..]

    (#) Blocking mode API:

       Below the list of most used macros in UART HAL driver.

        (+) HAL_UARTEx_ReceiveToIdle()

      (+) __HAL_UART_ENABLE: Enable the UART peripheral

    (#) Non-Blocking mode API with Interrupt:

      (+) __HAL_UART_DISABLE: Disable the UART peripheral

        (+) HAL_UARTEx_ReceiveToIdle_IT()

      (+) __HAL_UART_GET_FLAG : Check whether the specified UART flag is set or not

      (+) __HAL_UART_CLEAR_FLAG : Clear the specified UART pending flag

    (#) Non-Blocking mode API with DMA:

      (+) __HAL_UART_ENABLE_IT: Enable the specified UART interrupt

        (+) HAL_UARTEx_ReceiveToIdle_DMA()

      (+) __HAL_UART_DISABLE_IT: Disable the specified UART interrupt

      (+) __HAL_UART_GET_IT_SOURCE: Check whether the specified UART interrupt has occurred or not

     *** UART HAL driver macros list ***

     [..]

     =============================================

       (@) You can refer to the UART HAL driver header file for more useful macros

     [..]

       Below the list of most used macros in UART HAL driver.

  @endverbatim

     [..]

      (+) __HAL_UART_ENABLE: Enable the UART peripheral

       (@) Additional remark: If the parity is enabled, then the MSB bit of the data written

      (+) __HAL_UART_DISABLE: Disable the UART peripheral

           in the data register is transmitted but is changed by the parity bit.

      (+) __HAL_UART_GET_FLAG : Check whether the specified UART flag is set or not

           Depending on the frame length defined by the M bit (8-bits or 9-bits),

      (+) __HAL_UART_CLEAR_FLAG : Clear the specified UART pending flag

           the possible UART frame formats are as listed in the following table:

      (+) __HAL_UART_ENABLE_IT: Enable the specified UART interrupt

    +-------------------------------------------------------------+

      (+) __HAL_UART_DISABLE_IT: Disable the specified UART interrupt

    |   M bit |  PCE bit  |            UART frame                 |

      (+) __HAL_UART_GET_IT_SOURCE: Check whether the specified UART interrupt has occurred or not

    |---------------------|---------------------------------------|

    |    0    |    0      |    | SB | 8 bit data | STB |          |

     [..]

    |---------|-----------|---------------------------------------|

       (@) You can refer to the UART HAL driver header file for more useful macros

    |    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 UART frame formats are as listed in the following table:

  * @attention

    +-------------------------------------------------------------+

  *

    |   M bit |  PCE bit  |            UART 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 "stm32l1xx_hal.h"

/* Includes ------------------------------------------------------------------*/

#include "stm32l1xx_hal.h"

/** @addtogroup STM32L1xx_HAL_Driver

  * @{

/** @addtogroup STM32L1xx_HAL_Driver

  */

  * @{

  */

/** @defgroup UART UART

  * @brief HAL UART module driver

/** @defgroup UART UART

  * @{

  * @brief HAL UART module driver

  */

  * @{

#ifdef HAL_UART_MODULE_ENABLED

  */

#ifdef HAL_UART_MODULE_ENABLED

/* Private typedef -----------------------------------------------------------*/

/* Private define ------------------------------------------------------------*/

/* Private typedef -----------------------------------------------------------*/

/** @addtogroup UART_Private_Constants

/* Private define ------------------------------------------------------------*/

  * @{

/** @addtogroup UART_Private_Constants

  */

  * @{

/**

  */

  * @}

/**

  */

  * @}

/* Private macro -------------------------------------------------------------*/

  */

/* Private variables ---------------------------------------------------------*/

/* Private macro -------------------------------------------------------------*/

/* Private function prototypes -----------------------------------------------*/

/* Private variables ---------------------------------------------------------*/

/** @addtogroup UART_Private_Functions  UART Private Functions

/* Private function prototypes -----------------------------------------------*/

  * @{

/** @addtogroup UART_Private_Functions  UART Private Functions

  */

  * @{

  */

#if (USE_HAL_UART_REGISTER_CALLBACKS == 1)

void UART_InitCallbacksToDefault(UART_HandleTypeDef *huart);

#if (USE_HAL_UART_REGISTER_CALLBACKS == 1)

#endif /* USE_HAL_UART_REGISTER_CALLBACKS */

void UART_InitCallbacksToDefault(UART_HandleTypeDef *huart);

static void UART_EndTxTransfer(UART_HandleTypeDef *huart);

#endif /* USE_HAL_UART_REGISTER_CALLBACKS */

static void UART_EndRxTransfer(UART_HandleTypeDef *huart);

static void UART_EndTxTransfer(UART_HandleTypeDef *huart);

static void UART_DMATransmitCplt(DMA_HandleTypeDef *hdma);

static void UART_EndRxTransfer(UART_HandleTypeDef *huart);

static void UART_DMAReceiveCplt(DMA_HandleTypeDef *hdma);

static void UART_DMATransmitCplt(DMA_HandleTypeDef *hdma);

static void UART_DMATxHalfCplt(DMA_HandleTypeDef *hdma);

static void UART_DMAReceiveCplt(DMA_HandleTypeDef *hdma);

static void UART_DMARxHalfCplt(DMA_HandleTypeDef *hdma);

static void UART_DMATxHalfCplt(DMA_HandleTypeDef *hdma);

static void UART_DMAError(DMA_HandleTypeDef *hdma);

static void UART_DMARxHalfCplt(DMA_HandleTypeDef *hdma);

static void UART_DMAAbortOnError(DMA_HandleTypeDef *hdma);

static void UART_DMAError(DMA_HandleTypeDef *hdma);

static void UART_DMATxAbortCallback(DMA_HandleTypeDef *hdma);

static void UART_DMAAbortOnError(DMA_HandleTypeDef *hdma);

static void UART_DMARxAbortCallback(DMA_HandleTypeDef *hdma);

static void UART_DMATxAbortCallback(DMA_HandleTypeDef *hdma);

static void UART_DMATxOnlyAbortCallback(DMA_HandleTypeDef *hdma);

static void UART_DMARxAbortCallback(DMA_HandleTypeDef *hdma);

static void UART_DMARxOnlyAbortCallback(DMA_HandleTypeDef *hdma);

static void UART_DMATxOnlyAbortCallback(DMA_HandleTypeDef *hdma);

static HAL_StatusTypeDef UART_Transmit_IT(UART_HandleTypeDef *huart);

static void UART_DMARxOnlyAbortCallback(DMA_HandleTypeDef *hdma);

static HAL_StatusTypeDef UART_EndTransmit_IT(UART_HandleTypeDef *huart);

static HAL_StatusTypeDef UART_Transmit_IT(UART_HandleTypeDef *huart);

static HAL_StatusTypeDef UART_Receive_IT(UART_HandleTypeDef *huart);

static HAL_StatusTypeDef UART_EndTransmit_IT(UART_HandleTypeDef *huart);

static HAL_StatusTypeDef UART_WaitOnFlagUntilTimeout(UART_HandleTypeDef *huart, uint32_t Flag, FlagStatus Status, uint32_t Tickstart, uint32_t Timeout);

static HAL_StatusTypeDef UART_Receive_IT(UART_HandleTypeDef *huart);

static void UART_SetConfig(UART_HandleTypeDef *huart);

static HAL_StatusTypeDef UART_WaitOnFlagUntilTimeout(UART_HandleTypeDef *huart, uint32_t Flag, FlagStatus Status,

                                                     uint32_t Tickstart, uint32_t Timeout);

/**

static void UART_SetConfig(UART_HandleTypeDef *huart);

  * @}

  */

/**

  * @}

/* Exported functions ---------------------------------------------------------*/

  */

/** @defgroup UART_Exported_Functions UART Exported Functions

  * @{

/* Exported functions ---------------------------------------------------------*/

  */

/** @defgroup UART_Exported_Functions UART Exported Functions

  * @{

/** @defgroup UART_Exported_Functions_Group1 Initialization and de-initialization functions

  */

  *  @brief    Initialization and Configuration functions

  *

/** @defgroup UART_Exported_Functions_Group1 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 USARTx or the UARTy

 ===============================================================================

    in asynchronous mode.

    [..]

      (+) For the asynchronous mode only these parameters can be configured:

    This subsection provides a set of functions allowing to initialize the USARTx or the UARTy

        (++) Baud Rate

    in asynchronous mode.

        (++) 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 UART frame formats.

             in the data register is transmitted but is changed by the parity bit.

        (++) Hardware flow control

             Depending on the frame length defined by the M bit (8-bits or 9-bits),

        (++) Receiver/transmitter modes

             please refer to Reference manual for possible UART frame formats.

        (++) Over Sampling Method

        (++) Hardware flow control

    [..]

        (++) Receiver/transmitter modes

    The HAL_UART_Init(), HAL_HalfDuplex_Init(), HAL_LIN_Init() and HAL_MultiProcessor_Init() APIs

        (++) Over Sampling Method

    follow respectively the UART asynchronous, UART Half duplex, LIN and Multi-Processor configuration

    [..]

    procedures (details for the procedures are available in reference manual (RM0038)).

    The HAL_UART_Init(), HAL_HalfDuplex_Init(), HAL_LIN_Init() and HAL_MultiProcessor_Init() APIs

    follow respectively the UART asynchronous, UART Half duplex, LIN and Multi-Processor configuration

@endverbatim

    procedures (details for the procedures are available in reference manual (RM0038)).

  * @{

  */

@endverbatim

  * @{

/**

  */

  * @brief  Initializes the UART mode according to the specified parameters in

  *         the UART_InitTypeDef and create the associated handle.

/**

  * @param  huart  Pointer to a UART_HandleTypeDef structure that contains

  * @brief  Initializes the UART mode according to the specified parameters in

  *                the configuration information for the specified UART module.

  *         the UART_InitTypeDef and create the associated handle.

  * @retval HAL status

  * @param  huart  Pointer to a UART_HandleTypeDef structure that contains

  */

  *                the configuration information for the specified UART module.

HAL_StatusTypeDef HAL_UART_Init(UART_HandleTypeDef *huart)

  * @retval HAL status

{

  */

  /* Check the UART handle allocation */

HAL_StatusTypeDef HAL_UART_Init(UART_HandleTypeDef *huart)

  if (huart == NULL)

{

  {

  /* Check the UART handle allocation */

    return HAL_ERROR;

  if (huart == NULL)

  }

  {

    return HAL_ERROR;

  /* Check the parameters */

  }

  if (huart->Init.HwFlowCtl != UART_HWCONTROL_NONE)

  {

  /* Check the parameters */

    /* The hardware flow control is available only for USART1, USART2 and USART3 */

  if (huart->Init.HwFlowCtl != UART_HWCONTROL_NONE)

    assert_param(IS_UART_HWFLOW_INSTANCE(huart->Instance));

  {

    assert_param(IS_UART_HARDWARE_FLOW_CONTROL(huart->Init.HwFlowCtl));

    /* The hardware flow control is available only for USART1, USART2 and USART3 */

  }

    assert_param(IS_UART_HWFLOW_INSTANCE(huart->Instance));

  else

    assert_param(IS_UART_HARDWARE_FLOW_CONTROL(huart->Init.HwFlowCtl));

  {

  }

    assert_param(IS_UART_INSTANCE(huart->Instance));

  else

  }

  {

  assert_param(IS_UART_WORD_LENGTH(huart->Init.WordLength));

    assert_param(IS_UART_INSTANCE(huart->Instance));

  assert_param(IS_UART_OVERSAMPLING(huart->Init.OverSampling));

  }

  assert_param(IS_UART_WORD_LENGTH(huart->Init.WordLength));

  if (huart->gState == HAL_UART_STATE_RESET)

  assert_param(IS_UART_OVERSAMPLING(huart->Init.OverSampling));

  {

    /* Allocate lock resource and initialize it */

  if (huart->gState == HAL_UART_STATE_RESET)

    huart->Lock = HAL_UNLOCKED;

  {

    /* Allocate lock resource and initialize it */

#if (USE_HAL_UART_REGISTER_CALLBACKS == 1)

    huart->Lock = HAL_UNLOCKED;

    UART_InitCallbacksToDefault(huart);

#if (USE_HAL_UART_REGISTER_CALLBACKS == 1)

    if (huart->MspInitCallback == NULL)

    UART_InitCallbacksToDefault(huart);

    {

      huart->MspInitCallback = HAL_UART_MspInit;

    if (huart->MspInitCallback == NULL)

    }

    {

      huart->MspInitCallback = HAL_UART_MspInit;

    /* Init the low level hardware */

    }

    huart->MspInitCallback(huart);

#else

    /* Init the low level hardware */

    /* Init the low level hardware : GPIO, CLOCK */

    huart->MspInitCallback(huart);

    HAL_UART_MspInit(huart);

#else

#endif /* (USE_HAL_UART_REGISTER_CALLBACKS) */

    /* Init the low level hardware : GPIO, CLOCK */

  }

    HAL_UART_MspInit(huart);

#endif /* (USE_HAL_UART_REGISTER_CALLBACKS) */

  huart->gState = HAL_UART_STATE_BUSY;

  }

  /* Disable the peripheral */

  huart->gState = HAL_UART_STATE_BUSY;

  __HAL_UART_DISABLE(huart);

  /* Disable the peripheral */

  /* Set the UART Communication parameters */

  __HAL_UART_DISABLE(huart);

  UART_SetConfig(huart);

  /* Set the UART Communication parameters */

  /* In asynchronous mode, the following bits must be kept cleared:

  UART_SetConfig(huart);

     - LINEN and CLKEN bits in the USART_CR2 register,

     - SCEN, HDSEL and IREN  bits in the USART_CR3 register.*/

  /* In asynchronous mode, the following bits must be kept cleared:

  CLEAR_BIT(huart->Instance->CR2, (USART_CR2_LINEN | USART_CR2_CLKEN));

     - LINEN and CLKEN bits in the USART_CR2 register,

  CLEAR_BIT(huart->Instance->CR3, (USART_CR3_SCEN | USART_CR3_HDSEL | USART_CR3_IREN));

     - SCEN, HDSEL and IREN  bits in the USART_CR3 register.*/

  CLEAR_BIT(huart->Instance->CR2, (USART_CR2_LINEN | USART_CR2_CLKEN));

  /* Enable the peripheral */

  CLEAR_BIT(huart->Instance->CR3, (USART_CR3_SCEN | USART_CR3_HDSEL | USART_CR3_IREN));

  __HAL_UART_ENABLE(huart);

  /* Enable the peripheral */

  /* Initialize the UART state */

  __HAL_UART_ENABLE(huart);

  huart->ErrorCode = HAL_UART_ERROR_NONE;

  huart->gState = HAL_UART_STATE_READY;

  /* Initialize the UART state */

  huart->RxState = HAL_UART_STATE_READY;

  huart->ErrorCode = HAL_UART_ERROR_NONE;

  huart->gState = HAL_UART_STATE_READY;

  return HAL_OK;

  huart->RxState = HAL_UART_STATE_READY;

}

  huart->RxEventType = HAL_UART_RXEVENT_TC;

/**

  return HAL_OK;

  * @brief  Initializes the half-duplex mode according to the specified

}

  *         parameters in the UART_InitTypeDef and create the associated handle.

  * @param  huart  Pointer to a UART_HandleTypeDef structure that contains

/**

  *                the configuration information for the specified UART module.

  * @brief  Initializes the half-duplex mode according to the specified

  * @retval HAL status

  *         parameters in the UART_InitTypeDef and create the associated handle.

  */

  * @param  huart  Pointer to a UART_HandleTypeDef structure that contains

HAL_StatusTypeDef HAL_HalfDuplex_Init(UART_HandleTypeDef *huart)

  *                the configuration information for the specified UART module.

{

  * @retval HAL status

  /* Check the UART handle allocation */

  */

  if (huart == NULL)

HAL_StatusTypeDef HAL_HalfDuplex_Init(UART_HandleTypeDef *huart)

  {

{

    return HAL_ERROR;

  /* Check the UART handle allocation */

  }

  if (huart == NULL)

  {

  /* Check the parameters */

    return HAL_ERROR;

  assert_param(IS_UART_HALFDUPLEX_INSTANCE(huart->Instance));

  }

  assert_param(IS_UART_WORD_LENGTH(huart->Init.WordLength));

  assert_param(IS_UART_OVERSAMPLING(huart->Init.OverSampling));

  /* Check the parameters */

  assert_param(IS_UART_HALFDUPLEX_INSTANCE(huart->Instance));

  if (huart->gState == HAL_UART_STATE_RESET)

  assert_param(IS_UART_WORD_LENGTH(huart->Init.WordLength));

  {

  assert_param(IS_UART_OVERSAMPLING(huart->Init.OverSampling));

    /* Allocate lock resource and initialize it */

    huart->Lock = HAL_UNLOCKED;

  if (huart->gState == HAL_UART_STATE_RESET)

  {

#if (USE_HAL_UART_REGISTER_CALLBACKS == 1)

    /* Allocate lock resource and initialize it */

    UART_InitCallbacksToDefault(huart);

    huart->Lock = HAL_UNLOCKED;

    if (huart->MspInitCallback == NULL)

#if (USE_HAL_UART_REGISTER_CALLBACKS == 1)

    {

    UART_InitCallbacksToDefault(huart);

      huart->MspInitCallback = HAL_UART_MspInit;

    }

    if (huart->MspInitCallback == NULL)

    {

    /* Init the low level hardware */

      huart->MspInitCallback = HAL_UART_MspInit;

    huart->MspInitCallback(huart);

    }

#else

    /* Init the low level hardware : GPIO, CLOCK */

    /* Init the low level hardware */

    HAL_UART_MspInit(huart);

    huart->MspInitCallback(huart);

#endif /* (USE_HAL_UART_REGISTER_CALLBACKS) */

#else

  }

    /* Init the low level hardware : GPIO, CLOCK */

    HAL_UART_MspInit(huart);

  huart->gState = HAL_UART_STATE_BUSY;

#endif /* (USE_HAL_UART_REGISTER_CALLBACKS) */

  }

  /* Disable the peripheral */

  __HAL_UART_DISABLE(huart);

  huart->gState = HAL_UART_STATE_BUSY;

  /* Set the UART Communication parameters */

  /* Disable the peripheral */

  UART_SetConfig(huart);

  __HAL_UART_DISABLE(huart);

  /* In half-duplex mode, the following bits must be kept cleared:

  /* Set the UART Communication parameters */

     - LINEN and CLKEN bits in the USART_CR2 register,

  UART_SetConfig(huart);

     - SCEN and IREN bits in the USART_CR3 register.*/

  CLEAR_BIT(huart->Instance->CR2, (USART_CR2_LINEN | USART_CR2_CLKEN));

  /* In half-duplex mode, the following bits must be kept cleared:

  CLEAR_BIT(huart->Instance->CR3, (USART_CR3_IREN | USART_CR3_SCEN));

     - LINEN and CLKEN bits in the USART_CR2 register,

     - SCEN and IREN bits in the USART_CR3 register.*/

  /* Enable the Half-Duplex mode by setting the HDSEL bit in the CR3 register */

  CLEAR_BIT(huart->Instance->CR2, (USART_CR2_LINEN | USART_CR2_CLKEN));

  SET_BIT(huart->Instance->CR3, USART_CR3_HDSEL);

  CLEAR_BIT(huart->Instance->CR3, (USART_CR3_IREN | USART_CR3_SCEN));

  /* Enable the peripheral */

  /* Enable the Half-Duplex mode by setting the HDSEL bit in the CR3 register */

  __HAL_UART_ENABLE(huart);

  SET_BIT(huart->Instance->CR3, USART_CR3_HDSEL);

  /* Initialize the UART state*/

  /* Enable the peripheral */

  huart->ErrorCode = HAL_UART_ERROR_NONE;

  __HAL_UART_ENABLE(huart);

  huart->gState = HAL_UART_STATE_READY;

  huart->RxState = HAL_UART_STATE_READY;

  /* Initialize the UART state*/

  huart->ErrorCode = HAL_UART_ERROR_NONE;

  return HAL_OK;

  huart->gState = HAL_UART_STATE_READY;

}

  huart->RxState = HAL_UART_STATE_READY;

  huart->RxEventType = HAL_UART_RXEVENT_TC;

/**

  * @brief  Initializes the LIN mode according to the specified

  return HAL_OK;

  *         parameters in the UART_InitTypeDef and create the associated handle.

}

  * @param  huart  Pointer to a UART_HandleTypeDef structure that contains

  *                the configuration information for the specified UART module.

/**

  * @param  BreakDetectLength Specifies the LIN break detection length.

  * @brief  Initializes the LIN mode according to the specified

  *         This parameter can be one of the following values:

  *         parameters in the UART_InitTypeDef and create the associated handle.

  *            @arg UART_LINBREAKDETECTLENGTH_10B: 10-bit break detection

  * @param  huart  Pointer to a UART_HandleTypeDef structure that contains

  *            @arg UART_LINBREAKDETECTLENGTH_11B: 11-bit break detection

  *                the configuration information for the specified UART module.

  * @retval HAL status

  * @param  BreakDetectLength Specifies the LIN break detection length.

  */

  *         This parameter can be one of the following values:

HAL_StatusTypeDef HAL_LIN_Init(UART_HandleTypeDef *huart, uint32_t BreakDetectLength)

  *            @arg UART_LINBREAKDETECTLENGTH_10B: 10-bit break detection

{

  *            @arg UART_LINBREAKDETECTLENGTH_11B: 11-bit break detection

  /* Check the UART handle allocation */

  * @retval HAL status

  if (huart == NULL)

  */

  {

HAL_StatusTypeDef HAL_LIN_Init(UART_HandleTypeDef *huart, uint32_t BreakDetectLength)

    return HAL_ERROR;

{

  }

  /* Check the UART handle allocation */

  if (huart == NULL)

  /* Check the LIN UART instance */

  {

  assert_param(IS_UART_LIN_INSTANCE(huart->Instance));

    return HAL_ERROR;

  }

  /* Check the Break detection length parameter */

  assert_param(IS_UART_LIN_BREAK_DETECT_LENGTH(BreakDetectLength));

  /* Check the LIN UART instance */

  assert_param(IS_UART_LIN_WORD_LENGTH(huart->Init.WordLength));

  assert_param(IS_UART_LIN_INSTANCE(huart->Instance));

  assert_param(IS_UART_LIN_OVERSAMPLING(huart->Init.OverSampling));

  /* Check the Break detection length parameter */

  if (huart->gState == HAL_UART_STATE_RESET)

  assert_param(IS_UART_LIN_BREAK_DETECT_LENGTH(BreakDetectLength));

  {

  assert_param(IS_UART_LIN_WORD_LENGTH(huart->Init.WordLength));

    /* Allocate lock resource and initialize it */

  assert_param(IS_UART_LIN_OVERSAMPLING(huart->Init.OverSampling));

    huart->Lock = HAL_UNLOCKED;

  if (huart->gState == HAL_UART_STATE_RESET)

#if (USE_HAL_UART_REGISTER_CALLBACKS == 1)

  {

    UART_InitCallbacksToDefault(huart);

    /* Allocate lock resource and initialize it */

    huart->Lock = HAL_UNLOCKED;

    if (huart->MspInitCallback == NULL)

    {

#if (USE_HAL_UART_REGISTER_CALLBACKS == 1)

      huart->MspInitCallback = HAL_UART_MspInit;

    UART_InitCallbacksToDefault(huart);

    }

    if (huart->MspInitCallback == NULL)

    /* Init the low level hardware */

    {

    huart->MspInitCallback(huart);

      huart->MspInitCallback = HAL_UART_MspInit;

#else

    }

    /* Init the low level hardware : GPIO, CLOCK */

    HAL_UART_MspInit(huart);

    /* Init the low level hardware */

#endif /* (USE_HAL_UART_REGISTER_CALLBACKS) */

    huart->MspInitCallback(huart);

  }

#else

    /* Init the low level hardware : GPIO, CLOCK */

  huart->gState = HAL_UART_STATE_BUSY;

    HAL_UART_MspInit(huart);

#endif /* (USE_HAL_UART_REGISTER_CALLBACKS) */

  /* Disable the peripheral */

  }

  __HAL_UART_DISABLE(huart);

  huart->gState = HAL_UART_STATE_BUSY;

  /* Set the UART Communication parameters */

  UART_SetConfig(huart);

  /* Disable the peripheral */

  __HAL_UART_DISABLE(huart);

  /* In LIN mode, the following bits must be kept cleared:

     - CLKEN bits in the USART_CR2 register,

  /* Set the UART Communication parameters */

     - SCEN, HDSEL and IREN bits in the USART_CR3 register.*/

  UART_SetConfig(huart);

  CLEAR_BIT(huart->Instance->CR2, (USART_CR2_CLKEN));

  CLEAR_BIT(huart->Instance->CR3, (USART_CR3_HDSEL | USART_CR3_IREN | USART_CR3_SCEN));

  /* In LIN mode, the following bits must be kept cleared:

     - CLKEN bits in the USART_CR2 register,

  /* Enable the LIN mode by setting the LINEN bit in the CR2 register */

     - SCEN, HDSEL and IREN bits in the USART_CR3 register.*/

  SET_BIT(huart->Instance->CR2, USART_CR2_LINEN);

  CLEAR_BIT(huart->Instance->CR2, (USART_CR2_CLKEN));

  CLEAR_BIT(huart->Instance->CR3, (USART_CR3_HDSEL | USART_CR3_IREN | USART_CR3_SCEN));

  /* Set the USART LIN Break detection length. */

  CLEAR_BIT(huart->Instance->CR2, USART_CR2_LBDL);

  /* Enable the LIN mode by setting the LINEN bit in the CR2 register */

  SET_BIT(huart->Instance->CR2, BreakDetectLength);

  SET_BIT(huart->Instance->CR2, USART_CR2_LINEN);

  /* Enable the peripheral */

  /* Set the USART LIN Break detection length. */

  __HAL_UART_ENABLE(huart);

  CLEAR_BIT(huart->Instance->CR2, USART_CR2_LBDL);

  SET_BIT(huart->Instance->CR2, BreakDetectLength);

  /* Initialize the UART state*/

  huart->ErrorCode = HAL_UART_ERROR_NONE;

  /* Enable the peripheral */

  huart->gState = HAL_UART_STATE_READY;

  __HAL_UART_ENABLE(huart);

  huart->RxState = HAL_UART_STATE_READY;

  /* Initialize the UART state*/

  return HAL_OK;

  huart->ErrorCode = HAL_UART_ERROR_NONE;

}

  huart->gState = HAL_UART_STATE_READY;

  huart->RxState = HAL_UART_STATE_READY;

/**

  huart->RxEventType = HAL_UART_RXEVENT_TC;

  * @brief  Initializes the Multi-Processor mode according to the specified

  *         parameters in the UART_InitTypeDef and create the associated handle.

  return HAL_OK;

  * @param  huart  Pointer to a UART_HandleTypeDef structure that contains

}

  *                the configuration information for the specified UART module.

  * @param  Address USART address

/**

  * @param  WakeUpMethod specifies the USART wake-up method.

  * @brief  Initializes the Multi-Processor mode according to the specified

  *         This parameter can be one of the following values:

  *         parameters in the UART_InitTypeDef and create the associated handle.

  *            @arg UART_WAKEUPMETHOD_IDLELINE: Wake-up by an idle line detection

  * @param  huart  Pointer to a UART_HandleTypeDef structure that contains

  *            @arg UART_WAKEUPMETHOD_ADDRESSMARK: Wake-up by an address mark

  *                the configuration information for the specified UART module.

  * @retval HAL status

  * @param  Address USART address

  */

  * @param  WakeUpMethod specifies the USART wake-up method.

HAL_StatusTypeDef HAL_MultiProcessor_Init(UART_HandleTypeDef *huart, uint8_t Address, uint32_t WakeUpMethod)

  *         This parameter can be one of the following values:

{

  *            @arg UART_WAKEUPMETHOD_IDLELINE: Wake-up by an idle line detection

  /* Check the UART handle allocation */

  *            @arg UART_WAKEUPMETHOD_ADDRESSMARK: Wake-up by an address mark

  if (huart == NULL)

  * @retval HAL status

  {

  */

    return HAL_ERROR;

HAL_StatusTypeDef HAL_MultiProcessor_Init(UART_HandleTypeDef *huart, uint8_t Address, uint32_t WakeUpMethod)

  }

{

  /* Check the UART handle allocation */

  /* Check the parameters */

  if (huart == NULL)

  assert_param(IS_UART_MULTIPROCESSOR_INSTANCE(huart->Instance));

  {

    return HAL_ERROR;

  /* Check the Address & wake up method parameters */

  }

  assert_param(IS_UART_WAKEUPMETHOD(WakeUpMethod));

  assert_param(IS_UART_ADDRESS(Address));

  /* Check the parameters */

  assert_param(IS_UART_WORD_LENGTH(huart->Init.WordLength));

  assert_param(IS_UART_MULTIPROCESSOR_INSTANCE(huart->Instance));

  assert_param(IS_UART_OVERSAMPLING(huart->Init.OverSampling));

  /* Check the Address & wake up method parameters */

  if (huart->gState == HAL_UART_STATE_RESET)

  assert_param(IS_UART_WAKEUPMETHOD(WakeUpMethod));

  {

  assert_param(IS_UART_ADDRESS(Address));

    /* Allocate lock resource and initialize it */

  assert_param(IS_UART_WORD_LENGTH(huart->Init.WordLength));

    huart->Lock = HAL_UNLOCKED;

  assert_param(IS_UART_OVERSAMPLING(huart->Init.OverSampling));

#if (USE_HAL_UART_REGISTER_CALLBACKS == 1)

  if (huart->gState == HAL_UART_STATE_RESET)

    UART_InitCallbacksToDefault(huart);

  {

    /* Allocate lock resource and initialize it */

    if (huart->MspInitCallback == NULL)

    huart->Lock = HAL_UNLOCKED;

    {

      huart->MspInitCallback = HAL_UART_MspInit;

#if (USE_HAL_UART_REGISTER_CALLBACKS == 1)

    }

    UART_InitCallbacksToDefault(huart);

    /* Init the low level hardware */

    if (huart->MspInitCallback == NULL)

    huart->MspInitCallback(huart);

    {

#else

      huart->MspInitCallback = HAL_UART_MspInit;

    /* Init the low level hardware : GPIO, CLOCK */

    }

    HAL_UART_MspInit(huart);

#endif /* (USE_HAL_UART_REGISTER_CALLBACKS) */

    /* Init the low level hardware */

  }

    huart->MspInitCallback(huart);

#else

  huart->gState = HAL_UART_STATE_BUSY;

    /* Init the low level hardware : GPIO, CLOCK */

    HAL_UART_MspInit(huart);

  /* Disable the peripheral */

#endif /* (USE_HAL_UART_REGISTER_CALLBACKS) */

  __HAL_UART_DISABLE(huart);

  }

  /* Set the UART Communication parameters */

  huart->gState = HAL_UART_STATE_BUSY;

  UART_SetConfig(huart);

  /* Disable the peripheral */

  /* In Multi-Processor mode, the following bits must be kept cleared:

  __HAL_UART_DISABLE(huart);

     - LINEN and CLKEN bits in the USART_CR2 register,

     - SCEN, HDSEL and IREN  bits in the USART_CR3 register */

  /* Set the UART Communication parameters */

  CLEAR_BIT(huart->Instance->CR2, (USART_CR2_LINEN | USART_CR2_CLKEN));

  UART_SetConfig(huart);

  CLEAR_BIT(huart->Instance->CR3, (USART_CR3_SCEN | USART_CR3_HDSEL | USART_CR3_IREN));

  /* In Multi-Processor mode, the following bits must be kept cleared:

  /* Set the USART address node */

     - LINEN and CLKEN bits in the USART_CR2 register,

  CLEAR_BIT(huart->Instance->CR2, USART_CR2_ADD);

     - SCEN, HDSEL and IREN  bits in the USART_CR3 register */

  SET_BIT(huart->Instance->CR2, Address);

  CLEAR_BIT(huart->Instance->CR2, (USART_CR2_LINEN | USART_CR2_CLKEN));

  CLEAR_BIT(huart->Instance->CR3, (USART_CR3_SCEN | USART_CR3_HDSEL | USART_CR3_IREN));

  /* Set the wake up method by setting the WAKE bit in the CR1 register */

  CLEAR_BIT(huart->Instance->CR1, USART_CR1_WAKE);

  /* Set the USART address node */

  SET_BIT(huart->Instance->CR1, WakeUpMethod);

  CLEAR_BIT(huart->Instance->CR2, USART_CR2_ADD);

  SET_BIT(huart->Instance->CR2, Address);

  /* Enable the peripheral */

  __HAL_UART_ENABLE(huart);

  /* Set the wake up method by setting the WAKE bit in the CR1 register */

  CLEAR_BIT(huart->Instance->CR1, USART_CR1_WAKE);

  /* Initialize the UART state */

  SET_BIT(huart->Instance->CR1, WakeUpMethod);

  huart->ErrorCode = HAL_UART_ERROR_NONE;

  huart->gState = HAL_UART_STATE_READY;

  /* Enable the peripheral */

  huart->RxState = HAL_UART_STATE_READY;

  __HAL_UART_ENABLE(huart);

  return HAL_OK;

  /* Initialize the UART state */

}

  huart->ErrorCode = HAL_UART_ERROR_NONE;

  huart->gState = HAL_UART_STATE_READY;

/**

  huart->RxState = HAL_UART_STATE_READY;

  * @brief  DeInitializes the UART peripheral.

  huart->RxEventType = HAL_UART_RXEVENT_TC;

  * @param  huart  Pointer to a UART_HandleTypeDef structure that contains

  *                the configuration information for the specified UART module.

  return HAL_OK;

  * @retval HAL status

}

  */

HAL_StatusTypeDef HAL_UART_DeInit(UART_HandleTypeDef *huart)

/**

{

  * @brief  DeInitializes the UART peripheral.

  /* Check the UART handle allocation */

  * @param  huart  Pointer to a UART_HandleTypeDef structure that contains

  if (huart == NULL)

  *                the configuration information for the specified UART module.

  {

  * @retval HAL status

    return HAL_ERROR;

  */

  }

HAL_StatusTypeDef HAL_UART_DeInit(UART_HandleTypeDef *huart)

{

  /* Check the parameters */

  /* Check the UART handle allocation */

  assert_param(IS_UART_INSTANCE(huart->Instance));

  if (huart == NULL)

  {

  huart->gState = HAL_UART_STATE_BUSY;

    return HAL_ERROR;

  }

  /* Disable the Peripheral */

  __HAL_UART_DISABLE(huart);

  /* Check the parameters */

  assert_param(IS_UART_INSTANCE(huart->Instance));

#if (USE_HAL_UART_REGISTER_CALLBACKS == 1)

  if (huart->MspDeInitCallback == NULL)

  huart->gState = HAL_UART_STATE_BUSY;

  {

    huart->MspDeInitCallback = HAL_UART_MspDeInit;

  /* Disable the Peripheral */

  }

  __HAL_UART_DISABLE(huart);

  /* DeInit the low level hardware */

  huart->MspDeInitCallback(huart);

#if (USE_HAL_UART_REGISTER_CALLBACKS == 1)

#else

  if (huart->MspDeInitCallback == NULL)

  /* DeInit the low level hardware */

  {

  HAL_UART_MspDeInit(huart);

    huart->MspDeInitCallback = HAL_UART_MspDeInit;

#endif /* (USE_HAL_UART_REGISTER_CALLBACKS) */

  }

  /* DeInit the low level hardware */

  huart->ErrorCode = HAL_UART_ERROR_NONE;

  huart->MspDeInitCallback(huart);

  huart->gState = HAL_UART_STATE_RESET;

#else

  huart->RxState = HAL_UART_STATE_RESET;

  /* DeInit the low level hardware */

  huart->ReceptionType = HAL_UART_RECEPTION_STANDARD;

  HAL_UART_MspDeInit(huart);

#endif /* (USE_HAL_UART_REGISTER_CALLBACKS) */

  /* Process Unlock */

  __HAL_UNLOCK(huart);

  huart->ErrorCode = HAL_UART_ERROR_NONE;

  huart->gState = HAL_UART_STATE_RESET;

  return HAL_OK;

  huart->RxState = HAL_UART_STATE_RESET;

}

  huart->ReceptionType = HAL_UART_RECEPTION_STANDARD;

  huart->RxEventType = HAL_UART_RXEVENT_TC;

/**

  * @brief  UART MSP Init.

  /* Process Unlock */

  * @param  huart  Pointer to a UART_HandleTypeDef structure that contains

  __HAL_UNLOCK(huart);

  *                the configuration information for the specified UART module.

  * @retval None

  return HAL_OK;

  */

}

__weak void HAL_UART_MspInit(UART_HandleTypeDef *huart)

{

/**

  /* Prevent unused argument(s) compilation warning */

  * @brief  UART MSP Init.

  UNUSED(huart);

  * @param  huart  Pointer to a UART_HandleTypeDef structure that contains

  /* NOTE: This function should not be modified, when the callback is needed,

  *                the configuration information for the specified UART module.

           the HAL_UART_MspInit could be implemented in the user file

  * @retval None

   */

  */

}

__weak void HAL_UART_MspInit(UART_HandleTypeDef *huart)

{

/**

  /* Prevent unused argument(s) compilation warning */

  * @brief  UART MSP DeInit.

  UNUSED(huart);

  * @param  huart  Pointer to a UART_HandleTypeDef structure that contains

  /* NOTE: This function should not be modified, when the callback is needed,

  *                the configuration information for the specified UART module.

           the HAL_UART_MspInit could be implemented in the user file

  * @retval None

   */

  */

}

__weak void HAL_UART_MspDeInit(UART_HandleTypeDef *huart)

{

/**

  /* Prevent unused argument(s) compilation warning */

  * @brief  UART MSP DeInit.

  UNUSED(huart);

  * @param  huart  Pointer to a UART_HandleTypeDef structure that contains

  /* NOTE: This function should not be modified, when the callback is needed,

  *                the configuration information for the specified UART module.

           the HAL_UART_MspDeInit could be implemented in the user file

  * @retval None

   */

  */

}

__weak void HAL_UART_MspDeInit(UART_HandleTypeDef *huart)

{

#if (USE_HAL_UART_REGISTER_CALLBACKS == 1)

  /* Prevent unused argument(s) compilation warning */

/**

  UNUSED(huart);

  * @brief  Register a User UART Callback

  /* NOTE: This function should not be modified, when the callback is needed,

  *         To be used instead of the weak predefined callback

           the HAL_UART_MspDeInit could be implemented in the user file

  * @param  huart uart handle

   */

  * @param  CallbackID ID of the callback to be registered

}

  *         This parameter can be one of the following values:

  *           @arg @ref HAL_UART_TX_HALFCOMPLETE_CB_ID Tx Half Complete Callback ID

#if (USE_HAL_UART_REGISTER_CALLBACKS == 1)

  *           @arg @ref HAL_UART_TX_COMPLETE_CB_ID Tx Complete Callback ID

/**

  *           @arg @ref HAL_UART_RX_HALFCOMPLETE_CB_ID Rx Half Complete Callback ID

  * @brief  Register a User UART Callback

  *           @arg @ref HAL_UART_RX_COMPLETE_CB_ID Rx Complete Callback ID

  *         To be used instead of the weak predefined callback

  *           @arg @ref HAL_UART_ERROR_CB_ID Error Callback ID

  * @note   The HAL_UART_RegisterCallback() may be called before HAL_UART_Init(), HAL_HalfDuplex_Init(), HAL_LIN_Init(),

  *           @arg @ref HAL_UART_ABORT_COMPLETE_CB_ID Abort Complete Callback ID

  *         HAL_MultiProcessor_Init() to register callbacks for HAL_UART_MSPINIT_CB_ID and HAL_UART_MSPDEINIT_CB_ID

  *           @arg @ref HAL_UART_ABORT_TRANSMIT_COMPLETE_CB_ID Abort Transmit Complete Callback ID

  * @param  huart uart handle

  *           @arg @ref HAL_UART_ABORT_RECEIVE_COMPLETE_CB_ID Abort Receive Complete Callback ID

  * @param  CallbackID ID of the callback to be registered

  *           @arg @ref HAL_UART_MSPINIT_CB_ID MspInit Callback ID

  *         This parameter can be one of the following values:

  *           @arg @ref HAL_UART_MSPDEINIT_CB_ID MspDeInit Callback ID

  *           @arg @ref HAL_UART_TX_HALFCOMPLETE_CB_ID Tx Half Complete Callback ID

  * @param  pCallback pointer to the Callback function

  *           @arg @ref HAL_UART_TX_COMPLETE_CB_ID Tx Complete Callback ID

  * @retval HAL status

  *           @arg @ref HAL_UART_RX_HALFCOMPLETE_CB_ID Rx Half Complete Callback ID

  */

  *           @arg @ref HAL_UART_RX_COMPLETE_CB_ID Rx Complete Callback ID

HAL_StatusTypeDef HAL_UART_RegisterCallback(UART_HandleTypeDef *huart, HAL_UART_CallbackIDTypeDef CallbackID, pUART_CallbackTypeDef pCallback)

  *           @arg @ref HAL_UART_ERROR_CB_ID Error Callback ID

{

  *           @arg @ref HAL_UART_ABORT_COMPLETE_CB_ID Abort Complete Callback ID

  HAL_StatusTypeDef status = HAL_OK;

  *           @arg @ref HAL_UART_ABORT_TRANSMIT_COMPLETE_CB_ID Abort Transmit Complete Callback ID

  *           @arg @ref HAL_UART_ABORT_RECEIVE_COMPLETE_CB_ID Abort Receive Complete Callback ID

  if (pCallback == NULL)

  *           @arg @ref HAL_UART_MSPINIT_CB_ID MspInit Callback ID

  {

  *           @arg @ref HAL_UART_MSPDEINIT_CB_ID MspDeInit Callback ID

    /* Update the error code */

  * @param  pCallback pointer to the Callback function

    huart->ErrorCode |= HAL_UART_ERROR_INVALID_CALLBACK;

  * @retval HAL status

  */

    return HAL_ERROR;

HAL_StatusTypeDef HAL_UART_RegisterCallback(UART_HandleTypeDef *huart, HAL_UART_CallbackIDTypeDef CallbackID,

  }

                                            pUART_CallbackTypeDef pCallback)

  /* Process locked */

{

  __HAL_LOCK(huart);

  HAL_StatusTypeDef status = HAL_OK;

  if (huart->gState == HAL_UART_STATE_READY)

  if (pCallback == NULL)

  {

  {

    switch (CallbackID)

    /* Update the error code */

    {

    huart->ErrorCode |= HAL_UART_ERROR_INVALID_CALLBACK;

      case HAL_UART_TX_HALFCOMPLETE_CB_ID :

        huart->TxHalfCpltCallback = pCallback;

    return HAL_ERROR;

        break;

  }

      case HAL_UART_TX_COMPLETE_CB_ID :

  if (huart->gState == HAL_UART_STATE_READY)

        huart->TxCpltCallback = pCallback;

  {

        break;

    switch (CallbackID)

    {

      case HAL_UART_RX_HALFCOMPLETE_CB_ID :

      case HAL_UART_TX_HALFCOMPLETE_CB_ID :

        huart->RxHalfCpltCallback = pCallback;

        huart->TxHalfCpltCallback = pCallback;

        break;

        break;

      case HAL_UART_RX_COMPLETE_CB_ID :

      case HAL_UART_TX_COMPLETE_CB_ID :

        huart->RxCpltCallback = pCallback;

        huart->TxCpltCallback = pCallback;

        break;

        break;

      case HAL_UART_ERROR_CB_ID :

      case HAL_UART_RX_HALFCOMPLETE_CB_ID :

        huart->ErrorCallback = pCallback;