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_STM32F3/stm32f3xx_hal_usart.c@632:7687fb9c4f91, 2015-09-28 (annotated)

Committer:: mbed_official
Date:: Mon Sep 28 14:00:11 2015 +0100
Revision:: 632:7687fb9c4f91
Parent:: 385:be64abf45658
Child:: 634:ac7d6880524d

Synchronized with git revision f7ce4ed029cc611121464252ff28d5e8beb895b0

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

NUCLEO_F303K8 - add support of the STM32F303K8

Who changed what in which revision?

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