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_STM32L0/stm32l0xx_hal_uart.c@579:53297373a894, 2015-07-01 (annotated)

Committer:: mbed_official
Date:: Wed Jul 01 09:45:11 2015 +0100
Revision:: 579:53297373a894
Parent:: 489:119543c9f674

Synchronized with git revision d5b4d2ab9c47edb4dc5776e7177b0c2263459081

Full URL: https://github.com/mbedmicro/mbed/commit/d5b4d2ab9c47edb4dc5776e7177b0c2263459081/

Initial version of drivers for SAMR21

Who changed what in which revision?

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