mbed-src - mbed library sources

Users » mbed_official » Code » mbed-src

mbed library sources

Dependents: Encrypted my_mbed lklk CyaSSL_DTLS_Cellular ... more

Superseded

This library was superseded by mbed-dev - https://os.mbed.com/users/mbed_official/code/mbed-dev/.

Development branch of the mbed library sources. This library is kept in synch with the latest changes from the mbed SDK and it is not guaranteed to work.

If you are looking for a stable and tested release, please import one of the official mbed library releases:

Import library mbed

The official Mbed 2 C/C++ SDK provides the software platform and libraries to build your applications.

targets/cmsis/TARGET_STM/TARGET_STM32F0/stm32f0xx_hal_uart.c@630:825f75ca301e, 2015-09-28 (annotated)

Committer:: mbed_official
Date:: Mon Sep 28 10:45:10 2015 +0100
Revision:: 630:825f75ca301e
Parent:: 441:d2c15dda23c1

Synchronized with git revision 54fbe4144faf309c37205a5d39fa665daa919f10

Full URL: https://github.com/mbedmicro/mbed/commit/54fbe4144faf309c37205a5d39fa665daa919f10/

NUCLEO_F031K6 : Add new target

Who changed what in which revision?

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