mbed-dev - mbed library sources. Supersedes mbed-src.

Users » mbed_official » Code » mbed-dev

mbed official / mbed-dev

mbed library sources. Supersedes mbed-src.

Dependents: Nucleo_Hello_Encoder BLE_iBeaconScan AM1805_DEMO DISCO-F429ZI_ExportTemplate1 ... more

targets/TARGET_STM/TARGET_STM32L0/device/stm32l0xx_hal_usart.c@149:156823d33999, 2016-10-28 (annotated)

Committer:: <>
Date:: Fri Oct 28 11:17:30 2016 +0100
Revision:: 149:156823d33999
Parent:: targets/cmsis/TARGET_STM/TARGET_STM32L0/stm32l0xx_hal_usart.c@144:ef7eb2e8f9f7
Child:: 151:5eaa88a5bcc7

This updates the lib to the mbed lib v128

NOTE: This release includes a restructuring of the file and directory locations and thus some

include paths in your code may need updating accordingly.

Who changed what in which revision?

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