mbed-src - mbed library sources

Users » mbed_official » Code » mbed-src

mbed library sources

Dependents: Encrypted my_mbed lklk CyaSSL_DTLS_Cellular ... more

Superseded

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

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

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

Import library mbed

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

targets/cmsis/TARGET_STM/TARGET_STM32L0/stm32l0xx_hal_usart.c@579:53297373a894, 2015-07-01 (annotated)

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

Synchronized with git revision d5b4d2ab9c47edb4dc5776e7177b0c2263459081

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

Initial version of drivers for SAMR21

Who changed what in which revision?

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