mbed-src - mbed library sources

Users » mbed_official » Code » mbed-src

mbed library sources

Dependents: Encrypted my_mbed lklk CyaSSL_DTLS_Cellular ... more

Superseded

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

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

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

Import library mbed

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

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

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

Synchronized with git revision 54fbe4144faf309c37205a5d39fa665daa919f10

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

NUCLEO_F031K6 : Add new target

Who changed what in which revision?

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