mbed-src - mbed library sources

Users » jaerts » Code » mbed-src

Joris Aerts / mbed-src

mbed library sources

Dependents: Marvino mbot

Fork of mbed-src by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32L4/stm32l4xx_hal_usart.c@610:813dcc80987e, 2015-08-14 (annotated)

Committer:: mbed_official
Date:: Fri Aug 14 13:15:17 2015 +0100
Revision:: 610:813dcc80987e

Synchronized with git revision 6d84db41c6833e0b9b024741eb0616a5f62d5599

Full URL: https://github.com/mbedmicro/mbed/commit/6d84db41c6833e0b9b024741eb0616a5f62d5599/

DISCO_F746NG - Improvements

Who changed what in which revision?

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

Repository toolbox

Export to desktop IDE

Repository details

Type:	Library
Created:	26 Nov 2015
Imports:	17
Forks:	0
Commits:	638
Dependents:	1
Dependencies:	0
Followers:	1

targets/cmsis/TARGET_STM/TARGET_STM32L4/stm32l4xx_hal_usart.c@610:813dcc80987e, 2015-08-14 (annotated)

Who changed what in which revision?

Repository toolbox

Repository details

Important Information for this Arm website

Access Warning