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@441:d2c15dda23c1, 2015-01-06 (annotated)

Committer:: mbed_official
Date:: Tue Jan 06 16:15:36 2015 +0000
Revision:: 441:d2c15dda23c1
Parent:: 392:2b59412bb664
Child:: 630:825f75ca301e

Synchronized with git revision 245a60b29caabb42eabdd19658eeac7c3f68313b

Full URL: https://github.com/mbedmicro/mbed/commit/245a60b29caabb42eabdd19658eeac7c3f68313b/

NUCLEO_F072RB/F091RC - adding target to rtos lib and exporter for coide and gcc_arm

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