mbed-src - mbed library sources

Users » zain_mbed » Code » mbed-src

zain aftab / mbed-src

mbed library sources

Fork of mbed-src by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32L0/stm32l0xx_hal_irda.c@636:a11c0372f0ba, 2015-09-30 (annotated)

Committer:: mbed_official
Date:: Wed Sep 30 17:00:09 2015 +0100
Revision:: 636:a11c0372f0ba
Parent:: 490:119543c9f674

Synchronized with git revision d29c98dae61be0946ddf3a3c641c7726056f9452

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

Added support for SAMW25

Who changed what in which revision?

User	Revision	Line number	New contents of line
mbed_official	376:cb4d9db17537	1	/**
mbed_official	376:cb4d9db17537	2	******************************************************************************
mbed_official	376:cb4d9db17537	3	* @file stm32l0xx_hal_irda.c
mbed_official	376:cb4d9db17537	4	* @author MCD Application Team
mbed_official	490:119543c9f674	5	* @version V1.2.0
mbed_official	490:119543c9f674	6	* @date 06-February-2015
mbed_official	376:cb4d9db17537	7	* @brief IRDA HAL module driver.
mbed_official	376:cb4d9db17537	8	*
mbed_official	376:cb4d9db17537	9	* This file provides firmware functions to manage the following
mbed_official	376:cb4d9db17537	10	* functionalities of the IrDA (Infrared Data Association) Peripheral
mbed_official	376:cb4d9db17537	11	* (IRDA)
mbed_official	376:cb4d9db17537	12	* + Initialization and de-initialization functions
mbed_official	376:cb4d9db17537	13	* + IO operation functions
mbed_official	376:cb4d9db17537	14	* + Peripheral Control functions
mbed_official	376:cb4d9db17537	15	*
mbed_official	376:cb4d9db17537	16	*
mbed_official	376:cb4d9db17537	17	@verbatim
mbed_official	376:cb4d9db17537	18	===============================================================================
mbed_official	376:cb4d9db17537	19	##### How to use this driver #####
mbed_official	376:cb4d9db17537	20	===============================================================================
mbed_official	376:cb4d9db17537	21	[..]
mbed_official	376:cb4d9db17537	22	The IRDA HAL driver can be used as follows:
mbed_official	376:cb4d9db17537	23
mbed_official	376:cb4d9db17537	24
mbed_official	376:cb4d9db17537	25	(#) Declare a IRDA_HandleTypeDef handle structure.
mbed_official	376:cb4d9db17537	26	(#) Initialize the IRDA low level resources by implementing the HAL_IRDA_MspInit() API:
mbed_official	376:cb4d9db17537	27	(##) Enable the USARTx interface clock.
mbed_official	376:cb4d9db17537	28	(##) IRDA pins configuration:
mbed_official	376:cb4d9db17537	29	(+) Enable the clock for the IRDA GPIOs.
mbed_official	376:cb4d9db17537	30	(+) Configure these IRDA pins as alternate function pull-up.
mbed_official	376:cb4d9db17537	31	(##) NVIC configuration if you need to use interrupt process (HAL_IRDA_Transmit_IT()
mbed_official	376:cb4d9db17537	32	and HAL_IRDA_Receive_IT() APIs):
mbed_official	376:cb4d9db17537	33	(+) Configure the USARTx interrupt priority.
mbed_official	376:cb4d9db17537	34	(+) Enable the NVIC USART IRQ handle.
mbed_official	376:cb4d9db17537	35	(##) DMA Configuration if you need to use DMA process (HAL_IRDA_Transmit_DMA()
mbed_official	376:cb4d9db17537	36	and HAL_IRDA_Receive_DMA() APIs):
mbed_official	376:cb4d9db17537	37	(+) Declare a DMA handle structure for the Tx/Rx channel.
mbed_official	376:cb4d9db17537	38	(+) Enable the DMAx interface clock.
mbed_official	376:cb4d9db17537	39	(+) Configure the declared DMA handle structure with the required Tx/Rx parameters.
mbed_official	376:cb4d9db17537	40	(+) Configure the DMA Tx/Rx channel.
mbed_official	376:cb4d9db17537	41	(+) Associate the initilalized DMA handle to the IRDA DMA Tx/Rx handle.
mbed_official	376:cb4d9db17537	42	(+) Configure the priority and enable the NVIC for the transfer complete interrupt on the DMA Tx/Rx channel.
mbed_official	376:cb4d9db17537	43
mbed_official	376:cb4d9db17537	44	(#) Program the Baud Rate, Word Length, Parity, IrDA Mode, Prescaler
mbed_official	376:cb4d9db17537	45	and Mode(Receiver/Transmitter) in the hirda Init structure.
mbed_official	376:cb4d9db17537	46
mbed_official	376:cb4d9db17537	47	(#) Initialize the IRDA registers by calling the HAL_IRDA_Init() API:
mbed_official	376:cb4d9db17537	48	(++) This API configures also the low level Hardware GPIO, CLOCK, CORTEX...etc)
mbed_official	376:cb4d9db17537	49	by calling the customed HAL_IRDA_MspInit() API.
mbed_official	376:cb4d9db17537	50	-@@- The specific IRDA interrupts (Transmission complete interrupt,
mbed_official	376:cb4d9db17537	51	RXNE interrupt and Error Interrupts) will be managed using the macros
mbed_official	376:cb4d9db17537	52	__HAL_IRDA_ENABLE_IT() and __HAL_IRDA_DISABLE_IT() inside the transmit and receive process.
mbed_official	376:cb4d9db17537	53
mbed_official	376:cb4d9db17537	54	(#) Three operation modes are available within this driver :
mbed_official	376:cb4d9db17537	55
mbed_official	376:cb4d9db17537	56	* Polling mode IO operation *
mbed_official	376:cb4d9db17537	57	=================================
mbed_official	376:cb4d9db17537	58	[..]
mbed_official	376:cb4d9db17537	59	(+) Send an amount of data in blocking mode using HAL_IRDA_Transmit()
mbed_official	376:cb4d9db17537	60	(+) Receive an amount of data in blocking mode using HAL_IRDA_Receive()
mbed_official	376:cb4d9db17537	61
mbed_official	376:cb4d9db17537	62	* Interrupt mode IO operation *
mbed_official	376:cb4d9db17537	63	===================================
mbed_official	376:cb4d9db17537	64	[..]
mbed_official	376:cb4d9db17537	65	(+) Send an amount of data in non blocking mode using HAL_IRDA_Transmit_IT()
mbed_official	376:cb4d9db17537	66	(+) At transmission end of transfer HAL_IRDA_TxCpltCallback is executed and user can
mbed_official	376:cb4d9db17537	67	add his own code by customization of function pointer HAL_IRDA_TxCpltCallback
mbed_official	376:cb4d9db17537	68	(+) Receive an amount of data in non blocking mode using HAL_IRDA_Receive_IT()
mbed_official	376:cb4d9db17537	69	(+) At reception end of transfer HAL_IRDA_RxCpltCallback is executed and user can
mbed_official	376:cb4d9db17537	70	add his own code by customization of function pointer HAL_IRDA_RxCpltCallback
mbed_official	376:cb4d9db17537	71	(+) In case of transfer Error, HAL_IRDA_ErrorCallback() function is executed and user can
mbed_official	376:cb4d9db17537	72	add his own code by customization of function pointer HAL_IRDA_ErrorCallback
mbed_official	376:cb4d9db17537	73
mbed_official	376:cb4d9db17537	74	* DMA mode IO operation *
mbed_official	376:cb4d9db17537	75	=============================
mbed_official	376:cb4d9db17537	76	[..]
mbed_official	376:cb4d9db17537	77	(+) Send an amount of data in non blocking mode (DMA) using HAL_IRDA_Transmit_DMA()
mbed_official	376:cb4d9db17537	78	(+) At transmission end of transfer HAL_IRDA_TxCpltCallback is executed and user can
mbed_official	376:cb4d9db17537	79	add his own code by customization of function pointer HAL_IRDA_TxCpltCallback
mbed_official	376:cb4d9db17537	80	(+) Receive an amount of data in non blocking mode (DMA) using HAL_IRDA_Receive_DMA()
mbed_official	376:cb4d9db17537	81	(+) At reception end of transfer HAL_IRDA_RxCpltCallback is executed and user can
mbed_official	376:cb4d9db17537	82	add his own code by customization of function pointer HAL_IRDA_RxCpltCallback
mbed_official	376:cb4d9db17537	83	(+) In case of transfer Error, HAL_IRDA_ErrorCallback() function is executed and user can
mbed_official	376:cb4d9db17537	84	add his own code by customization of function pointer HAL_IRDA_ErrorCallback
mbed_official	376:cb4d9db17537	85
mbed_official	376:cb4d9db17537	86	* IRDA HAL driver macros list *
mbed_official	376:cb4d9db17537	87	===================================
mbed_official	376:cb4d9db17537	88	[..]
mbed_official	376:cb4d9db17537	89	Below the list of most used macros in IRDA HAL driver.
mbed_official	376:cb4d9db17537	90
mbed_official	376:cb4d9db17537	91	(+) __HAL_IRDA_ENABLE: Enable the IRDA peripheral
mbed_official	376:cb4d9db17537	92	(+) __HAL_IRDA_DISABLE: Disable the IRDA peripheral
mbed_official	376:cb4d9db17537	93	(+) __HAL_IRDA_GET_FLAG : Checks whether the specified IRDA flag is set or not
mbed_official	376:cb4d9db17537	94	(+) __HAL_IRDA_CLEAR_FLAG : Clears the specified IRDA pending flag
mbed_official	376:cb4d9db17537	95	(+) __HAL_IRDA_ENABLE_IT: Enables the specified IRDA interrupt
mbed_official	376:cb4d9db17537	96	(+) __HAL_IRDA_DISABLE_IT: Disables the specified IRDA interrupt
mbed_official	376:cb4d9db17537	97
mbed_official	376:cb4d9db17537	98	(@) You can refer to the IRDA HAL driver header file for more useful macros
mbed_official	376:cb4d9db17537	99
mbed_official	376:cb4d9db17537	100	@endverbatim
mbed_official	376:cb4d9db17537	101	******************************************************************************
mbed_official	376:cb4d9db17537	102	* @attention
mbed_official	376:cb4d9db17537	103	*
mbed_official	490:119543c9f674	104	* <h2><center>© COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
mbed_official	376:cb4d9db17537	105	*
mbed_official	376:cb4d9db17537	106	* Redistribution and use in source and binary forms, with or without modification,
mbed_official	376:cb4d9db17537	107	* are permitted provided that the following conditions are met:
mbed_official	376:cb4d9db17537	108	* 1. Redistributions of source code must retain the above copyright notice,
mbed_official	376:cb4d9db17537	109	* this list of conditions and the following disclaimer.
mbed_official	376:cb4d9db17537	110	* 2. Redistributions in binary form must reproduce the above copyright notice,
mbed_official	376:cb4d9db17537	111	* this list of conditions and the following disclaimer in the documentation
mbed_official	376:cb4d9db17537	112	* and/or other materials provided with the distribution.
mbed_official	376:cb4d9db17537	113	* 3. Neither the name of STMicroelectronics nor the names of its contributors
mbed_official	376:cb4d9db17537	114	* may be used to endorse or promote products derived from this software
mbed_official	376:cb4d9db17537	115	* without specific prior written permission.
mbed_official	376:cb4d9db17537	116	*
mbed_official	376:cb4d9db17537	117	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
mbed_official	376:cb4d9db17537	118	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
mbed_official	376:cb4d9db17537	119	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
mbed_official	376:cb4d9db17537	120	* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
mbed_official	376:cb4d9db17537	121	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
mbed_official	376:cb4d9db17537	122	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
mbed_official	376:cb4d9db17537	123	* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
mbed_official	376:cb4d9db17537	124	* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
mbed_official	376:cb4d9db17537	125	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
mbed_official	376:cb4d9db17537	126	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
mbed_official	376:cb4d9db17537	127	*
mbed_official	376:cb4d9db17537	128	******************************************************************************
mbed_official	376:cb4d9db17537	129	*/
mbed_official	376:cb4d9db17537	130
mbed_official	376:cb4d9db17537	131	/* Includes ------------------------------------------------------------------*/
mbed_official	376:cb4d9db17537	132	#include "stm32l0xx_hal.h"
mbed_official	376:cb4d9db17537	133
mbed_official	376:cb4d9db17537	134	/** @addtogroup STM32L0xx_HAL_Driver
mbed_official	376:cb4d9db17537	135	* @{
mbed_official	376:cb4d9db17537	136	*/
mbed_official	376:cb4d9db17537	137
mbed_official	490:119543c9f674	138	/** @addtogroup IRDA
mbed_official	376:cb4d9db17537	139	* @brief IRDA HAL module driver
mbed_official	376:cb4d9db17537	140	* @{
mbed_official	376:cb4d9db17537	141	*/
mbed_official	376:cb4d9db17537	142	#ifdef HAL_IRDA_MODULE_ENABLED
mbed_official	376:cb4d9db17537	143
mbed_official	376:cb4d9db17537	144	/* Private typedef -----------------------------------------------------------*/
mbed_official	376:cb4d9db17537	145	/* Private define ------------------------------------------------------------*/
mbed_official	376:cb4d9db17537	146	#define TEACK_REACK_TIMEOUT 1000
mbed_official	376:cb4d9db17537	147	#define HAL_IRDA_TXDMA_TIMEOUTVALUE 22000
mbed_official	376:cb4d9db17537	148	#define IRDA_CR1_FIELDS ((uint32_t)(USART_CR1_M \| USART_CR1_PCE \
mbed_official	376:cb4d9db17537	149	\| USART_CR1_PS \| USART_CR1_TE \| USART_CR1_RE))
mbed_official	376:cb4d9db17537	150	/* Private macro -------------------------------------------------------------*/
mbed_official	376:cb4d9db17537	151	/* Private variables ---------------------------------------------------------*/
mbed_official	376:cb4d9db17537	152	/* Private function prototypes -----------------------------------------------*/
mbed_official	376:cb4d9db17537	153	static void IRDA_DMATransmitCplt(DMA_HandleTypeDef *hdma);
mbed_official	376:cb4d9db17537	154	static void IRDA_DMATransmitHalfCplt(DMA_HandleTypeDef *hdma);
mbed_official	376:cb4d9db17537	155	static void IRDA_DMAReceiveCplt(DMA_HandleTypeDef *hdma);
mbed_official	376:cb4d9db17537	156	static void IRDA_DMAReceiveHalfCplt(DMA_HandleTypeDef *hdma);
mbed_official	376:cb4d9db17537	157	static void IRDA_DMAError(DMA_HandleTypeDef *hdma);
mbed_official	376:cb4d9db17537	158	static void IRDA_SetConfig (IRDA_HandleTypeDef *hirda);
mbed_official	376:cb4d9db17537	159	static HAL_StatusTypeDef IRDA_CheckIdleState(IRDA_HandleTypeDef *hirda);
mbed_official	376:cb4d9db17537	160	static HAL_StatusTypeDef IRDA_WaitOnFlagUntilTimeout(IRDA_HandleTypeDef *hirda, uint32_t Flag, FlagStatus Status, uint32_t Timeout);
mbed_official	376:cb4d9db17537	161	static HAL_StatusTypeDef IRDA_Transmit_IT(IRDA_HandleTypeDef *hirda);
mbed_official	490:119543c9f674	162	static HAL_StatusTypeDef IRDA_EndTransmit_IT(IRDA_HandleTypeDef *hirda);
mbed_official	376:cb4d9db17537	163	static HAL_StatusTypeDef IRDA_Receive_IT(IRDA_HandleTypeDef *hirda);
mbed_official	376:cb4d9db17537	164	/* Private functions ---------------------------------------------------------*/
mbed_official	376:cb4d9db17537	165
mbed_official	490:119543c9f674	166	/** @addtogroup IRDA_Exported_Functions
mbed_official	376:cb4d9db17537	167	* @{
mbed_official	376:cb4d9db17537	168	*/
mbed_official	376:cb4d9db17537	169
mbed_official	490:119543c9f674	170	/** @addtogroup IRDA_Exported_Functions_Group1
mbed_official	376:cb4d9db17537	171	* @brief Initialization and Configuration functions
mbed_official	376:cb4d9db17537	172	*
mbed_official	376:cb4d9db17537	173	@verbatim
mbed_official	376:cb4d9db17537	174	===============================================================================
mbed_official	376:cb4d9db17537	175	##### Initialization and Configuration functions #####
mbed_official	376:cb4d9db17537	176	===============================================================================
mbed_official	376:cb4d9db17537	177	[..]
mbed_official	376:cb4d9db17537	178	This subsection provides a set of functions allowing to initialize the USARTx
mbed_official	376:cb4d9db17537	179	in asynchronous IRDA mode.
mbed_official	376:cb4d9db17537	180	(+) For the asynchronous mode only these parameters can be configured:
mbed_official	376:cb4d9db17537	181	(++) Baud Rate
mbed_official	376:cb4d9db17537	182	(++) Word Length
mbed_official	376:cb4d9db17537	183	(++) Parity: If the parity is enabled, then the MSB bit of the data written
mbed_official	376:cb4d9db17537	184	in the data register is transmitted but is changed by the parity bit.
mbed_official	376:cb4d9db17537	185	Depending on the frame length defined by the M bit (8-bits or 9-bits)
mbed_official	376:cb4d9db17537	186	or by the M1 and M0 bits (7-bit, 8-bit or 9-bit),
mbed_official	376:cb4d9db17537	187	the possible IRDA frame formats are as listed in the following table:
mbed_official	376:cb4d9db17537	188	+---------------------------------------------------------------+
mbed_official	376:cb4d9db17537	189	\| M1M0 bits \| PCE bit \| IRDA frame \|
mbed_official	376:cb4d9db17537	190	\|-----------\|-----------\|---------------------------------------\|
mbed_official	376:cb4d9db17537	191	\| 00 \| 0 \| \| SB \| 8-bit data \| STB \| \|
mbed_official	376:cb4d9db17537	192	\|-----------\|-----------\|---------------------------------------\|
mbed_official	376:cb4d9db17537	193	\| 00 \| 1 \| \| SB \| 7-bit data \| PB \| STB \| \|
mbed_official	376:cb4d9db17537	194	\|-----------\|-----------\|---------------------------------------\|
mbed_official	376:cb4d9db17537	195	\| 01 \| 0 \| \| SB \| 9-bit data \| STB \| \|
mbed_official	376:cb4d9db17537	196	\|-----------\|-----------\|---------------------------------------\|
mbed_official	376:cb4d9db17537	197	\| 01 \| 1 \| \| SB \| 8-bit data \| PB \| STB \| \|
mbed_official	376:cb4d9db17537	198	\|-----------------------\|---------------------------------------\|
mbed_official	376:cb4d9db17537	199	\| 10 \| 0 \| \| SB \| 7-bit data \| STB \| \|
mbed_official	376:cb4d9db17537	200	\|-----------\|-----------\|---------------------------------------\|
mbed_official	376:cb4d9db17537	201	\| 10 \| 1 \| \| SB \| 6-bit data \| PB \| STB \| \|
mbed_official	376:cb4d9db17537	202	+---------------------------------------------------------------+
mbed_official	376:cb4d9db17537	203
mbed_official	376:cb4d9db17537	204	(++) Power mode
mbed_official	376:cb4d9db17537	205	(++) Prescaler setting
mbed_official	376:cb4d9db17537	206	(++) Receiver/transmitter modes
mbed_official	376:cb4d9db17537	207
mbed_official	376:cb4d9db17537	208	[..]
mbed_official	376:cb4d9db17537	209	The HAL_IRDA_Init() API follows the USART asynchronous configuration procedures
mbed_official	376:cb4d9db17537	210	(details for the procedures are available in reference manual).
mbed_official	376:cb4d9db17537	211
mbed_official	376:cb4d9db17537	212	@endverbatim
mbed_official	376:cb4d9db17537	213	* @{
mbed_official	376:cb4d9db17537	214	*/
mbed_official	376:cb4d9db17537	215
mbed_official	376:cb4d9db17537	216	/**
mbed_official	376:cb4d9db17537	217	* @brief Initializes the IRDA mode according to the specified
mbed_official	376:cb4d9db17537	218	* parameters in the IRDA_InitTypeDef and creates the associated handle .
mbed_official	376:cb4d9db17537	219	* @param hirda: IRDA handle
mbed_official	376:cb4d9db17537	220	* @retval HAL status
mbed_official	376:cb4d9db17537	221	*/
mbed_official	376:cb4d9db17537	222	HAL_StatusTypeDef HAL_IRDA_Init(IRDA_HandleTypeDef *hirda)
mbed_official	376:cb4d9db17537	223	{
mbed_official	376:cb4d9db17537	224	/* Check the IRDA handle allocation */
mbed_official	490:119543c9f674	225	if(hirda == NULL)
mbed_official	376:cb4d9db17537	226	{
mbed_official	376:cb4d9db17537	227	return HAL_ERROR;
mbed_official	376:cb4d9db17537	228	}
mbed_official	376:cb4d9db17537	229
mbed_official	376:cb4d9db17537	230	/* Check the USART/UART associated to the IRDA handle */
mbed_official	376:cb4d9db17537	231	assert_param(IS_IRDA_INSTANCE(hirda->Instance));
mbed_official	376:cb4d9db17537	232
mbed_official	376:cb4d9db17537	233	if(hirda->State == HAL_IRDA_STATE_RESET)
mbed_official	376:cb4d9db17537	234	{
mbed_official	376:cb4d9db17537	235	/* Init the low level hardware : GPIO, CLOCK, CORTEX */
mbed_official	376:cb4d9db17537	236	HAL_IRDA_MspInit(hirda);
mbed_official	376:cb4d9db17537	237	}
mbed_official	376:cb4d9db17537	238
mbed_official	376:cb4d9db17537	239	hirda->State = HAL_IRDA_STATE_BUSY;
mbed_official	376:cb4d9db17537	240
mbed_official	376:cb4d9db17537	241	/* Disable the Peripheral to update the configuration registers */
mbed_official	376:cb4d9db17537	242	__HAL_IRDA_DISABLE(hirda);
mbed_official	376:cb4d9db17537	243
mbed_official	376:cb4d9db17537	244	/* Set the IRDA Communication parameters */
mbed_official	376:cb4d9db17537	245	IRDA_SetConfig(hirda);
mbed_official	376:cb4d9db17537	246
mbed_official	376:cb4d9db17537	247	/* In IRDA mode, the following bits must be kept cleared:
mbed_official	376:cb4d9db17537	248	- LINEN, STOP and CLKEN bits in the USART_CR2 register,
mbed_official	376:cb4d9db17537	249	- SCEN and HDSEL bits in the USART_CR3 register.*/
mbed_official	376:cb4d9db17537	250	hirda->Instance->CR2 &= ~(USART_CR2_LINEN \| USART_CR2_CLKEN \| USART_CR2_STOP);
mbed_official	376:cb4d9db17537	251	hirda->Instance->CR3 &= ~(USART_CR3_SCEN \| USART_CR3_HDSEL);
mbed_official	376:cb4d9db17537	252
mbed_official	376:cb4d9db17537	253	/* set the UART/USART in IRDA mode */
mbed_official	376:cb4d9db17537	254	hirda->Instance->CR3 \|= USART_CR3_IREN;
mbed_official	376:cb4d9db17537	255
mbed_official	376:cb4d9db17537	256	/* Enable the Peripheral */
mbed_official	376:cb4d9db17537	257	__HAL_IRDA_ENABLE(hirda);
mbed_official	376:cb4d9db17537	258
mbed_official	376:cb4d9db17537	259	/* TEACK and/or REACK to check before moving hirda->State to Ready */
mbed_official	376:cb4d9db17537	260	return (IRDA_CheckIdleState(hirda));
mbed_official	376:cb4d9db17537	261	}
mbed_official	376:cb4d9db17537	262
mbed_official	376:cb4d9db17537	263	/**
mbed_official	376:cb4d9db17537	264	* @brief DeInitializes the IRDA peripheral
mbed_official	376:cb4d9db17537	265	* @param hirda: IRDA handle
mbed_official	376:cb4d9db17537	266	* @retval HAL status
mbed_official	376:cb4d9db17537	267	*/
mbed_official	376:cb4d9db17537	268	HAL_StatusTypeDef HAL_IRDA_DeInit(IRDA_HandleTypeDef *hirda)
mbed_official	376:cb4d9db17537	269	{
mbed_official	376:cb4d9db17537	270	/* Check the IRDA handle allocation */
mbed_official	490:119543c9f674	271	if(hirda == NULL)
mbed_official	376:cb4d9db17537	272	{
mbed_official	376:cb4d9db17537	273	return HAL_ERROR;
mbed_official	376:cb4d9db17537	274	}
mbed_official	376:cb4d9db17537	275
mbed_official	376:cb4d9db17537	276	/* Check the USART/UART associated to the IRDA handle */
mbed_official	376:cb4d9db17537	277	assert_param(IS_IRDA_INSTANCE(hirda->Instance));
mbed_official	376:cb4d9db17537	278
mbed_official	376:cb4d9db17537	279	hirda->State = HAL_IRDA_STATE_BUSY;
mbed_official	376:cb4d9db17537	280
mbed_official	376:cb4d9db17537	281	/* DeInit the low level hardware */
mbed_official	376:cb4d9db17537	282	HAL_IRDA_MspDeInit(hirda);
mbed_official	376:cb4d9db17537	283	/* Disable the Peripheral */
mbed_official	376:cb4d9db17537	284	__HAL_IRDA_DISABLE(hirda);
mbed_official	376:cb4d9db17537	285
mbed_official	376:cb4d9db17537	286	hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
mbed_official	376:cb4d9db17537	287	hirda->State = HAL_IRDA_STATE_RESET;
mbed_official	376:cb4d9db17537	288
mbed_official	376:cb4d9db17537	289	/* Release Lock */
mbed_official	376:cb4d9db17537	290	__HAL_UNLOCK(hirda);
mbed_official	376:cb4d9db17537	291
mbed_official	376:cb4d9db17537	292	return HAL_OK;
mbed_official	376:cb4d9db17537	293	}
mbed_official	376:cb4d9db17537	294
mbed_official	376:cb4d9db17537	295	/**
mbed_official	376:cb4d9db17537	296	* @brief IRDA MSP Init
mbed_official	376:cb4d9db17537	297	* @param hirda: IRDA handle
mbed_official	376:cb4d9db17537	298	* @retval None
mbed_official	376:cb4d9db17537	299	*/
mbed_official	376:cb4d9db17537	300	__weak void HAL_IRDA_MspInit(IRDA_HandleTypeDef *hirda)
mbed_official	376:cb4d9db17537	301	{
mbed_official	376:cb4d9db17537	302	/* NOTE : This function Should not be modified, when the callback is needed,
mbed_official	376:cb4d9db17537	303	the HAL_IRDA_MspInit could be implented in the user file
mbed_official	376:cb4d9db17537	304	*/
mbed_official	376:cb4d9db17537	305	}
mbed_official	376:cb4d9db17537	306
mbed_official	376:cb4d9db17537	307	/**
mbed_official	376:cb4d9db17537	308	* @brief IRDA MSP DeInit
mbed_official	376:cb4d9db17537	309	* @param hirda: IRDA handle
mbed_official	376:cb4d9db17537	310	* @retval None
mbed_official	376:cb4d9db17537	311	*/
mbed_official	376:cb4d9db17537	312	__weak void HAL_IRDA_MspDeInit(IRDA_HandleTypeDef *hirda)
mbed_official	376:cb4d9db17537	313	{
mbed_official	376:cb4d9db17537	314	/* NOTE : This function Should not be modified, when the callback is needed,
mbed_official	376:cb4d9db17537	315	the HAL_IRDA_MspDeInit could be implented in the user file
mbed_official	376:cb4d9db17537	316	*/
mbed_official	376:cb4d9db17537	317	}
mbed_official	376:cb4d9db17537	318
mbed_official	376:cb4d9db17537	319	/**
mbed_official	376:cb4d9db17537	320	* @}
mbed_official	376:cb4d9db17537	321	*/
mbed_official	376:cb4d9db17537	322
mbed_official	490:119543c9f674	323	/** @addtogroup IRDA_Exported_Functions_Group2
mbed_official	376:cb4d9db17537	324	* @brief IRDA Transmit-Receive functions
mbed_official	376:cb4d9db17537	325	*
mbed_official	376:cb4d9db17537	326	@verbatim
mbed_official	376:cb4d9db17537	327	===============================================================================
mbed_official	376:cb4d9db17537	328	##### IO operation functions #####
mbed_official	376:cb4d9db17537	329	===============================================================================
mbed_official	376:cb4d9db17537	330	[..]
mbed_official	376:cb4d9db17537	331	This subsection provides a set of functions allowing to manage the IRDA asynchronous
mbed_official	376:cb4d9db17537	332	data transfers.
mbed_official	376:cb4d9db17537	333
mbed_official	376:cb4d9db17537	334	(#) There are two modes of transfer:
mbed_official	376:cb4d9db17537	335	(++) Blocking mode: the communication is performed in polling mode.
mbed_official	376:cb4d9db17537	336	The HAL status of all data processing is returned by the same function
mbed_official	376:cb4d9db17537	337	after finishing transfer.
mbed_official	376:cb4d9db17537	338	(++) No-Blocking mode: the communication is performed using Interrupts
mbed_official	376:cb4d9db17537	339	or DMA, these API's return the HAL status.
mbed_official	376:cb4d9db17537	340	The end of the data processing will be indicated through the
mbed_official	376:cb4d9db17537	341	dedicated IRDA IRQ when using Interrupt mode or the DMA IRQ when
mbed_official	376:cb4d9db17537	342	using DMA mode.
mbed_official	376:cb4d9db17537	343	The HAL_IRDA_TxCpltCallback(), HAL_IRDA_RxCpltCallback() user callbacks
mbed_official	376:cb4d9db17537	344	will be executed respectivelly at the end of the Transmit or Receive process
mbed_official	376:cb4d9db17537	345	The HAL_IRDA_ErrorCallback() user callback will be executed when a communication error is detected
mbed_official	376:cb4d9db17537	346
mbed_official	376:cb4d9db17537	347	(#) Blocking mode API's are :
mbed_official	376:cb4d9db17537	348	(++) HAL_IRDA_Transmit()
mbed_official	376:cb4d9db17537	349	(++) HAL_IRDA_Receive()
mbed_official	376:cb4d9db17537	350
mbed_official	376:cb4d9db17537	351	(#) Non-Blocking mode API's with Interrupt are :
mbed_official	376:cb4d9db17537	352	(++) HAL_IRDA_Transmit_IT()
mbed_official	376:cb4d9db17537	353	(++) HAL_IRDA_Receive_IT()
mbed_official	376:cb4d9db17537	354	(++) HAL_IRDA_IRQHandler()
mbed_official	376:cb4d9db17537	355	(++) IRDA_Transmit_IT()
mbed_official	376:cb4d9db17537	356	(++) IRDA_Receive_IT()
mbed_official	376:cb4d9db17537	357
mbed_official	376:cb4d9db17537	358	(#) Non-Blocking mode functions with DMA are :
mbed_official	376:cb4d9db17537	359	(++) HAL_IRDA_Transmit_DMA()
mbed_official	376:cb4d9db17537	360	(++) HAL_IRDA_Receive_DMA()
mbed_official	376:cb4d9db17537	361
mbed_official	376:cb4d9db17537	362	(#) A set of Transfer Complete Callbacks are provided in No_Blocking mode:
mbed_official	376:cb4d9db17537	363	(++) HAL_IRDA_TxCpltCallback()
mbed_official	376:cb4d9db17537	364	(++) HAL_IRDA_RxCpltCallback()
mbed_official	376:cb4d9db17537	365	(++) HAL_IRDA_ErrorCallback()
mbed_official	376:cb4d9db17537	366
mbed_official	376:cb4d9db17537	367	@endverbatim
mbed_official	376:cb4d9db17537	368	* @{
mbed_official	376:cb4d9db17537	369	*/
mbed_official	376:cb4d9db17537	370
mbed_official	376:cb4d9db17537	371	/**
mbed_official	376:cb4d9db17537	372	* @brief Send an amount of data in blocking mode
mbed_official	376:cb4d9db17537	373	* @param hirda: IRDA handle
mbed_official	376:cb4d9db17537	374	* @param pData: pointer to data buffer
mbed_official	376:cb4d9db17537	375	* @param Size: amount of data to be sent
mbed_official	376:cb4d9db17537	376	* @param Timeout: Duration of the timeout
mbed_official	376:cb4d9db17537	377	* @retval HAL status
mbed_official	376:cb4d9db17537	378	*/
mbed_official	376:cb4d9db17537	379	HAL_StatusTypeDef HAL_IRDA_Transmit(IRDA_HandleTypeDef hirda, uint8_t pData, uint16_t Size, uint32_t Timeout)
mbed_official	376:cb4d9db17537	380	{
mbed_official	376:cb4d9db17537	381	uint16_t* tmp;
mbed_official	376:cb4d9db17537	382
mbed_official	376:cb4d9db17537	383	if ((hirda->State == HAL_IRDA_STATE_READY) \|\| (hirda->State == HAL_IRDA_STATE_BUSY_RX))
mbed_official	376:cb4d9db17537	384	{
mbed_official	490:119543c9f674	385	if((pData == NULL) \|\| (Size == 0))
mbed_official	376:cb4d9db17537	386	{
mbed_official	376:cb4d9db17537	387	return HAL_ERROR;
mbed_official	376:cb4d9db17537	388	}
mbed_official	376:cb4d9db17537	389
mbed_official	376:cb4d9db17537	390	/* Process Locked */
mbed_official	376:cb4d9db17537	391	__HAL_LOCK(hirda);
mbed_official	376:cb4d9db17537	392	hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
mbed_official	376:cb4d9db17537	393
mbed_official	376:cb4d9db17537	394	if(hirda->State == HAL_IRDA_STATE_BUSY_RX)
mbed_official	376:cb4d9db17537	395	{
mbed_official	376:cb4d9db17537	396	hirda->State = HAL_IRDA_STATE_BUSY_TX_RX;
mbed_official	376:cb4d9db17537	397	}
mbed_official	376:cb4d9db17537	398	else
mbed_official	376:cb4d9db17537	399	{
mbed_official	376:cb4d9db17537	400	hirda->State = HAL_IRDA_STATE_BUSY_TX;
mbed_official	376:cb4d9db17537	401	}
mbed_official	376:cb4d9db17537	402
mbed_official	376:cb4d9db17537	403	hirda->TxXferSize = Size;
mbed_official	376:cb4d9db17537	404	hirda->TxXferCount = Size;
mbed_official	376:cb4d9db17537	405	while(hirda->TxXferCount > 0)
mbed_official	376:cb4d9db17537	406	{
mbed_official	376:cb4d9db17537	407	hirda->TxXferCount--;
mbed_official	376:cb4d9db17537	408
mbed_official	376:cb4d9db17537	409	if(IRDA_WaitOnFlagUntilTimeout(hirda, IRDA_FLAG_TXE, RESET, Timeout) != HAL_OK)
mbed_official	376:cb4d9db17537	410	{
mbed_official	376:cb4d9db17537	411	return HAL_TIMEOUT;
mbed_official	376:cb4d9db17537	412	}
mbed_official	376:cb4d9db17537	413	if ((hirda->Init.WordLength == IRDA_WORDLENGTH_9B) && (hirda->Init.Parity == IRDA_PARITY_NONE))
mbed_official	376:cb4d9db17537	414	{
mbed_official	376:cb4d9db17537	415	tmp = (uint16_t*) pData;
mbed_official	376:cb4d9db17537	416	hirda->Instance->TDR = (*tmp & (uint16_t)0x01FF);
mbed_official	376:cb4d9db17537	417	pData +=2;
mbed_official	376:cb4d9db17537	418	}
mbed_official	376:cb4d9db17537	419	else
mbed_official	376:cb4d9db17537	420	{
mbed_official	376:cb4d9db17537	421	hirda->Instance->TDR = (*pData++ & (uint8_t)0xFF);
mbed_official	376:cb4d9db17537	422	}
mbed_official	376:cb4d9db17537	423	}
mbed_official	376:cb4d9db17537	424
mbed_official	376:cb4d9db17537	425	if(IRDA_WaitOnFlagUntilTimeout(hirda, IRDA_FLAG_TC, RESET, Timeout) != HAL_OK)
mbed_official	376:cb4d9db17537	426	{
mbed_official	376:cb4d9db17537	427	return HAL_TIMEOUT;
mbed_official	376:cb4d9db17537	428	}
mbed_official	376:cb4d9db17537	429
mbed_official	376:cb4d9db17537	430	if(hirda->State == HAL_IRDA_STATE_BUSY_TX_RX)
mbed_official	376:cb4d9db17537	431	{
mbed_official	376:cb4d9db17537	432	hirda->State = HAL_IRDA_STATE_BUSY_RX;
mbed_official	376:cb4d9db17537	433	}
mbed_official	376:cb4d9db17537	434	else
mbed_official	376:cb4d9db17537	435	{
mbed_official	376:cb4d9db17537	436	hirda->State = HAL_IRDA_STATE_READY;
mbed_official	376:cb4d9db17537	437	}
mbed_official	376:cb4d9db17537	438
mbed_official	376:cb4d9db17537	439	/* Process Unlocked */
mbed_official	376:cb4d9db17537	440	__HAL_UNLOCK(hirda);
mbed_official	376:cb4d9db17537	441
mbed_official	376:cb4d9db17537	442	return HAL_OK;
mbed_official	376:cb4d9db17537	443	}
mbed_official	376:cb4d9db17537	444	else
mbed_official	376:cb4d9db17537	445	{
mbed_official	376:cb4d9db17537	446	return HAL_BUSY;
mbed_official	376:cb4d9db17537	447	}
mbed_official	376:cb4d9db17537	448	}
mbed_official	376:cb4d9db17537	449
mbed_official	376:cb4d9db17537	450	/**
mbed_official	376:cb4d9db17537	451	* @brief Receive an amount of data in blocking mode
mbed_official	376:cb4d9db17537	452	* @param hirda: IRDA handle
mbed_official	376:cb4d9db17537	453	* @param pData: pointer to data buffer
mbed_official	376:cb4d9db17537	454	* @param Size: amount of data to be received
mbed_official	376:cb4d9db17537	455	* @param Timeout: Duration of the timeout
mbed_official	376:cb4d9db17537	456	* @retval HAL status
mbed_official	376:cb4d9db17537	457	*/
mbed_official	376:cb4d9db17537	458	HAL_StatusTypeDef HAL_IRDA_Receive(IRDA_HandleTypeDef hirda, uint8_t pData, uint16_t Size, uint32_t Timeout)
mbed_official	376:cb4d9db17537	459	{
mbed_official	376:cb4d9db17537	460	uint16_t* tmp;
mbed_official	376:cb4d9db17537	461	uint16_t uhMask;
mbed_official	376:cb4d9db17537	462
mbed_official	376:cb4d9db17537	463	if ((hirda->State == HAL_IRDA_STATE_READY) \|\| (hirda->State == HAL_IRDA_STATE_BUSY_TX))
mbed_official	376:cb4d9db17537	464	{
mbed_official	490:119543c9f674	465	if((pData == NULL) \|\| (Size == 0))
mbed_official	376:cb4d9db17537	466	{
mbed_official	376:cb4d9db17537	467	return HAL_ERROR;
mbed_official	376:cb4d9db17537	468	}
mbed_official	376:cb4d9db17537	469
mbed_official	376:cb4d9db17537	470	/* Process Locked */
mbed_official	376:cb4d9db17537	471	__HAL_LOCK(hirda);
mbed_official	376:cb4d9db17537	472	hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
mbed_official	376:cb4d9db17537	473
mbed_official	376:cb4d9db17537	474	if(hirda->State == HAL_IRDA_STATE_BUSY_TX)
mbed_official	376:cb4d9db17537	475	{
mbed_official	376:cb4d9db17537	476	hirda->State = HAL_IRDA_STATE_BUSY_TX_RX;
mbed_official	376:cb4d9db17537	477	}
mbed_official	376:cb4d9db17537	478	else
mbed_official	376:cb4d9db17537	479	{
mbed_official	376:cb4d9db17537	480	hirda->State = HAL_IRDA_STATE_BUSY_RX;
mbed_official	376:cb4d9db17537	481	}
mbed_official	376:cb4d9db17537	482
mbed_official	376:cb4d9db17537	483	hirda->RxXferSize = Size;
mbed_official	376:cb4d9db17537	484	hirda->RxXferCount = Size;
mbed_official	376:cb4d9db17537	485
mbed_official	376:cb4d9db17537	486	/* Computation of the mask to apply to the RDR register
mbed_official	376:cb4d9db17537	487	of the UART associated to the IRDA */
mbed_official	490:119543c9f674	488	IRDA_MASK_COMPUTATION(hirda);
mbed_official	376:cb4d9db17537	489	uhMask = hirda->Mask;
mbed_official	376:cb4d9db17537	490
mbed_official	376:cb4d9db17537	491	/* Check data remaining to be received */
mbed_official	376:cb4d9db17537	492	while(hirda->RxXferCount > 0)
mbed_official	376:cb4d9db17537	493	{
mbed_official	376:cb4d9db17537	494	hirda->RxXferCount--;
mbed_official	376:cb4d9db17537	495
mbed_official	376:cb4d9db17537	496	if(IRDA_WaitOnFlagUntilTimeout(hirda, IRDA_FLAG_RXNE, RESET, Timeout) != HAL_OK)
mbed_official	376:cb4d9db17537	497	{
mbed_official	376:cb4d9db17537	498	return HAL_TIMEOUT;
mbed_official	376:cb4d9db17537	499	}
mbed_official	376:cb4d9db17537	500	if ((hirda->Init.WordLength == IRDA_WORDLENGTH_9B) && (hirda->Init.Parity == IRDA_PARITY_NONE))
mbed_official	376:cb4d9db17537	501	{
mbed_official	376:cb4d9db17537	502	tmp = (uint16_t*) pData ;
mbed_official	376:cb4d9db17537	503	*tmp = (uint16_t)(hirda->Instance->RDR & uhMask);
mbed_official	376:cb4d9db17537	504	pData +=2;
mbed_official	376:cb4d9db17537	505	}
mbed_official	376:cb4d9db17537	506	else
mbed_official	376:cb4d9db17537	507	{
mbed_official	376:cb4d9db17537	508	*pData++ = (uint8_t)(hirda->Instance->RDR & (uint8_t)uhMask);
mbed_official	376:cb4d9db17537	509	}
mbed_official	376:cb4d9db17537	510	}
mbed_official	376:cb4d9db17537	511
mbed_official	376:cb4d9db17537	512	if(hirda->State == HAL_IRDA_STATE_BUSY_TX_RX)
mbed_official	376:cb4d9db17537	513	{
mbed_official	376:cb4d9db17537	514	hirda->State = HAL_IRDA_STATE_BUSY_TX;
mbed_official	376:cb4d9db17537	515	}
mbed_official	376:cb4d9db17537	516	else
mbed_official	376:cb4d9db17537	517	{
mbed_official	376:cb4d9db17537	518	hirda->State = HAL_IRDA_STATE_READY;
mbed_official	376:cb4d9db17537	519	}
mbed_official	376:cb4d9db17537	520
mbed_official	376:cb4d9db17537	521	/* Process Unlocked */
mbed_official	376:cb4d9db17537	522	__HAL_UNLOCK(hirda);
mbed_official	376:cb4d9db17537	523
mbed_official	376:cb4d9db17537	524	return HAL_OK;
mbed_official	376:cb4d9db17537	525	}
mbed_official	376:cb4d9db17537	526	else
mbed_official	376:cb4d9db17537	527	{
mbed_official	376:cb4d9db17537	528	return HAL_BUSY;
mbed_official	376:cb4d9db17537	529	}
mbed_official	376:cb4d9db17537	530	}
mbed_official	376:cb4d9db17537	531
mbed_official	376:cb4d9db17537	532	/**
mbed_official	376:cb4d9db17537	533	* @brief Send an amount of data in interrupt mode
mbed_official	376:cb4d9db17537	534	* @param hirda: IRDA handle
mbed_official	376:cb4d9db17537	535	* @param pData: pointer to data buffer
mbed_official	376:cb4d9db17537	536	* @param Size: amount of data to be sent
mbed_official	376:cb4d9db17537	537	* @retval HAL status
mbed_official	376:cb4d9db17537	538	*/
mbed_official	376:cb4d9db17537	539	HAL_StatusTypeDef HAL_IRDA_Transmit_IT(IRDA_HandleTypeDef hirda, uint8_t pData, uint16_t Size)
mbed_official	376:cb4d9db17537	540	{
mbed_official	376:cb4d9db17537	541	if ((hirda->State == HAL_IRDA_STATE_READY) \|\| (hirda->State == HAL_IRDA_STATE_BUSY_RX))
mbed_official	376:cb4d9db17537	542	{
mbed_official	490:119543c9f674	543	if((pData == NULL) \|\| (Size == 0))
mbed_official	376:cb4d9db17537	544	{
mbed_official	376:cb4d9db17537	545	return HAL_ERROR;
mbed_official	376:cb4d9db17537	546	}
mbed_official	376:cb4d9db17537	547
mbed_official	376:cb4d9db17537	548	/* Process Locked */
mbed_official	376:cb4d9db17537	549	__HAL_LOCK(hirda);
mbed_official	376:cb4d9db17537	550
mbed_official	376:cb4d9db17537	551	hirda->pTxBuffPtr = pData;
mbed_official	376:cb4d9db17537	552	hirda->TxXferSize = Size;
mbed_official	376:cb4d9db17537	553	hirda->TxXferCount = Size;
mbed_official	376:cb4d9db17537	554
mbed_official	376:cb4d9db17537	555	hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
mbed_official	376:cb4d9db17537	556	if(hirda->State == HAL_IRDA_STATE_BUSY_RX)
mbed_official	376:cb4d9db17537	557	{
mbed_official	376:cb4d9db17537	558	hirda->State = HAL_IRDA_STATE_BUSY_TX_RX;
mbed_official	376:cb4d9db17537	559	}
mbed_official	376:cb4d9db17537	560	else
mbed_official	376:cb4d9db17537	561	{
mbed_official	376:cb4d9db17537	562	hirda->State = HAL_IRDA_STATE_BUSY_TX;
mbed_official	376:cb4d9db17537	563	}
mbed_official	376:cb4d9db17537	564
mbed_official	376:cb4d9db17537	565	/* Enable the IRDA Error Interrupt: (Frame error, noise error, overrun error) */
mbed_official	376:cb4d9db17537	566	__HAL_IRDA_ENABLE_IT(hirda, IRDA_IT_ERR);
mbed_official	376:cb4d9db17537	567
mbed_official	376:cb4d9db17537	568	/* Process Unlocked */
mbed_official	376:cb4d9db17537	569	__HAL_UNLOCK(hirda);
mbed_official	376:cb4d9db17537	570
mbed_official	490:119543c9f674	571	/* Enable the IRDA Transmit Data Register Empty Interrupt */
mbed_official	490:119543c9f674	572	__HAL_IRDA_ENABLE_IT(hirda, IRDA_IT_TXE);
mbed_official	376:cb4d9db17537	573
mbed_official	376:cb4d9db17537	574	return HAL_OK;
mbed_official	376:cb4d9db17537	575	}
mbed_official	376:cb4d9db17537	576	else
mbed_official	376:cb4d9db17537	577	{
mbed_official	376:cb4d9db17537	578	return HAL_BUSY;
mbed_official	376:cb4d9db17537	579	}
mbed_official	376:cb4d9db17537	580	}
mbed_official	376:cb4d9db17537	581
mbed_official	376:cb4d9db17537	582	/**
mbed_official	376:cb4d9db17537	583	* @brief Receive an amount of data in interrupt mode
mbed_official	376:cb4d9db17537	584	* @param hirda: IRDA handle
mbed_official	376:cb4d9db17537	585	* @param pData: pointer to data buffer
mbed_official	376:cb4d9db17537	586	* @param Size: amount of data to be received
mbed_official	376:cb4d9db17537	587	* @retval HAL status
mbed_official	376:cb4d9db17537	588	*/
mbed_official	376:cb4d9db17537	589	HAL_StatusTypeDef HAL_IRDA_Receive_IT(IRDA_HandleTypeDef hirda, uint8_t pData, uint16_t Size)
mbed_official	376:cb4d9db17537	590	{
mbed_official	376:cb4d9db17537	591	if ((hirda->State == HAL_IRDA_STATE_READY) \|\| (hirda->State == HAL_IRDA_STATE_BUSY_TX))
mbed_official	376:cb4d9db17537	592	{
mbed_official	490:119543c9f674	593	if((pData == NULL) \|\| (Size == 0))
mbed_official	376:cb4d9db17537	594	{
mbed_official	376:cb4d9db17537	595	return HAL_ERROR;
mbed_official	376:cb4d9db17537	596	}
mbed_official	376:cb4d9db17537	597
mbed_official	376:cb4d9db17537	598	/* Process Locked */
mbed_official	376:cb4d9db17537	599	__HAL_LOCK(hirda);
mbed_official	376:cb4d9db17537	600
mbed_official	376:cb4d9db17537	601	hirda->pRxBuffPtr = pData;
mbed_official	376:cb4d9db17537	602	hirda->RxXferSize = Size;
mbed_official	376:cb4d9db17537	603	hirda->RxXferCount = Size;
mbed_official	376:cb4d9db17537	604
mbed_official	376:cb4d9db17537	605	/* Computation of the mask to apply to the RDR register
mbed_official	376:cb4d9db17537	606	of the UART associated to the IRDA */
mbed_official	490:119543c9f674	607	IRDA_MASK_COMPUTATION(hirda);
mbed_official	376:cb4d9db17537	608
mbed_official	376:cb4d9db17537	609	hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
mbed_official	376:cb4d9db17537	610	if(hirda->State == HAL_IRDA_STATE_BUSY_TX)
mbed_official	376:cb4d9db17537	611	{
mbed_official	376:cb4d9db17537	612	hirda->State = HAL_IRDA_STATE_BUSY_TX_RX;
mbed_official	376:cb4d9db17537	613	}
mbed_official	376:cb4d9db17537	614	else
mbed_official	376:cb4d9db17537	615	{
mbed_official	376:cb4d9db17537	616	hirda->State = HAL_IRDA_STATE_BUSY_RX;
mbed_official	376:cb4d9db17537	617	}
mbed_official	376:cb4d9db17537	618
mbed_official	376:cb4d9db17537	619	/* Enable the IRDA Parity Error Interrupt */
mbed_official	376:cb4d9db17537	620	__HAL_IRDA_ENABLE_IT(hirda, IRDA_IT_PE);
mbed_official	376:cb4d9db17537	621
mbed_official	376:cb4d9db17537	622	/* Enable the IRDA Error Interrupt: (Frame error, noise error, overrun error) */
mbed_official	376:cb4d9db17537	623	__HAL_IRDA_ENABLE_IT(hirda, IRDA_IT_ERR);
mbed_official	376:cb4d9db17537	624
mbed_official	376:cb4d9db17537	625	/* Process Unlocked */
mbed_official	376:cb4d9db17537	626	__HAL_UNLOCK(hirda);
mbed_official	376:cb4d9db17537	627
mbed_official	376:cb4d9db17537	628	/* Enable the IRDA Data Register not empty Interrupt */
mbed_official	376:cb4d9db17537	629	__HAL_IRDA_ENABLE_IT(hirda, IRDA_IT_RXNE);
mbed_official	376:cb4d9db17537	630
mbed_official	376:cb4d9db17537	631	return HAL_OK;
mbed_official	376:cb4d9db17537	632	}
mbed_official	376:cb4d9db17537	633	else
mbed_official	376:cb4d9db17537	634	{
mbed_official	376:cb4d9db17537	635	return HAL_BUSY;
mbed_official	376:cb4d9db17537	636	}
mbed_official	376:cb4d9db17537	637	}
mbed_official	376:cb4d9db17537	638
mbed_official	376:cb4d9db17537	639	/**
mbed_official	376:cb4d9db17537	640	* @brief Send an amount of data in DMA mode
mbed_official	376:cb4d9db17537	641	* @param hirda: IRDA handle
mbed_official	376:cb4d9db17537	642	* @param pData: pointer to data buffer
mbed_official	376:cb4d9db17537	643	* @param Size: amount of data to be sent
mbed_official	376:cb4d9db17537	644	* @retval HAL status
mbed_official	376:cb4d9db17537	645	*/
mbed_official	376:cb4d9db17537	646	HAL_StatusTypeDef HAL_IRDA_Transmit_DMA(IRDA_HandleTypeDef hirda, uint8_t pData, uint16_t Size)
mbed_official	376:cb4d9db17537	647	{
mbed_official	376:cb4d9db17537	648	uint32_t *tmp;
mbed_official	376:cb4d9db17537	649
mbed_official	376:cb4d9db17537	650	if ((hirda->State == HAL_IRDA_STATE_READY) \|\| (hirda->State == HAL_IRDA_STATE_BUSY_RX))
mbed_official	376:cb4d9db17537	651	{
mbed_official	490:119543c9f674	652	if((pData == NULL) \|\| (Size == 0))
mbed_official	376:cb4d9db17537	653	{
mbed_official	376:cb4d9db17537	654	return HAL_ERROR;
mbed_official	376:cb4d9db17537	655	}
mbed_official	376:cb4d9db17537	656
mbed_official	376:cb4d9db17537	657	/* Process Locked */
mbed_official	376:cb4d9db17537	658	__HAL_LOCK(hirda);
mbed_official	376:cb4d9db17537	659
mbed_official	376:cb4d9db17537	660	hirda->pTxBuffPtr = pData;
mbed_official	376:cb4d9db17537	661	hirda->TxXferSize = Size;
mbed_official	376:cb4d9db17537	662	hirda->TxXferCount = Size;
mbed_official	376:cb4d9db17537	663
mbed_official	376:cb4d9db17537	664	hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
mbed_official	376:cb4d9db17537	665
mbed_official	376:cb4d9db17537	666	if(hirda->State == HAL_IRDA_STATE_BUSY_RX)
mbed_official	376:cb4d9db17537	667	{
mbed_official	376:cb4d9db17537	668	hirda->State = HAL_IRDA_STATE_BUSY_TX_RX;
mbed_official	376:cb4d9db17537	669	}
mbed_official	376:cb4d9db17537	670	else
mbed_official	376:cb4d9db17537	671	{
mbed_official	376:cb4d9db17537	672	hirda->State = HAL_IRDA_STATE_BUSY_TX;
mbed_official	376:cb4d9db17537	673	}
mbed_official	376:cb4d9db17537	674
mbed_official	376:cb4d9db17537	675	/* Set the IRDA DMA transfer complete callback */
mbed_official	376:cb4d9db17537	676	hirda->hdmatx->XferCpltCallback = IRDA_DMATransmitCplt;
mbed_official	376:cb4d9db17537	677
mbed_official	376:cb4d9db17537	678	/* Set the IRDA DMA half transfer complete callback */
mbed_official	376:cb4d9db17537	679	hirda->hdmatx->XferHalfCpltCallback = IRDA_DMATransmitHalfCplt;
mbed_official	376:cb4d9db17537	680
mbed_official	376:cb4d9db17537	681	/* Set the DMA error callback */
mbed_official	376:cb4d9db17537	682	hirda->hdmatx->XferErrorCallback = IRDA_DMAError;
mbed_official	376:cb4d9db17537	683
mbed_official	376:cb4d9db17537	684	/* Enable the IRDA transmit DMA channel */
mbed_official	376:cb4d9db17537	685	tmp = (uint32_t*)&pData;
mbed_official	376:cb4d9db17537	686	HAL_DMA_Start_IT(hirda->hdmatx, (uint32_t)tmp, (uint32_t)&hirda->Instance->TDR, Size);
mbed_official	376:cb4d9db17537	687
mbed_official	490:119543c9f674	688	/* Clear the TC flag in the SR register by writing 0 to it */
mbed_official	490:119543c9f674	689	__HAL_IRDA_CLEAR_FLAG(hirda, IRDA_FLAG_TC);
mbed_official	490:119543c9f674	690
mbed_official	376:cb4d9db17537	691	/* Enable the DMA transfer for transmit request by setting the DMAT bit
mbed_official	376:cb4d9db17537	692	in the IRDA CR3 register */
mbed_official	376:cb4d9db17537	693	hirda->Instance->CR3 \|= USART_CR3_DMAT;
mbed_official	376:cb4d9db17537	694
mbed_official	376:cb4d9db17537	695	/* Process Unlocked */
mbed_official	376:cb4d9db17537	696	__HAL_UNLOCK(hirda);
mbed_official	376:cb4d9db17537	697
mbed_official	376:cb4d9db17537	698	return HAL_OK;
mbed_official	376:cb4d9db17537	699	}
mbed_official	376:cb4d9db17537	700	else
mbed_official	376:cb4d9db17537	701	{
mbed_official	376:cb4d9db17537	702	return HAL_BUSY;
mbed_official	376:cb4d9db17537	703	}
mbed_official	376:cb4d9db17537	704	}
mbed_official	376:cb4d9db17537	705
mbed_official	376:cb4d9db17537	706	/**
mbed_official	376:cb4d9db17537	707	* @brief Receive an amount of data in DMA mode
mbed_official	376:cb4d9db17537	708	* @param hirda: IRDA handle
mbed_official	376:cb4d9db17537	709	* @param pData: pointer to data buffer
mbed_official	376:cb4d9db17537	710	* @param Size: amount of data to be received
mbed_official	376:cb4d9db17537	711	* @note When the IRDA parity is enabled (PCE = 1), the received data contain
mbed_official	376:cb4d9db17537	712	* the parity bit (MSB position)
mbed_official	376:cb4d9db17537	713	* @retval HAL status
mbed_official	376:cb4d9db17537	714	*/
mbed_official	376:cb4d9db17537	715	HAL_StatusTypeDef HAL_IRDA_Receive_DMA(IRDA_HandleTypeDef hirda, uint8_t pData, uint16_t Size)
mbed_official	376:cb4d9db17537	716	{
mbed_official	376:cb4d9db17537	717	uint32_t *tmp;
mbed_official	376:cb4d9db17537	718
mbed_official	376:cb4d9db17537	719	if ((hirda->State == HAL_IRDA_STATE_READY) \|\| (hirda->State == HAL_IRDA_STATE_BUSY_TX))
mbed_official	376:cb4d9db17537	720	{
mbed_official	490:119543c9f674	721	if((pData == NULL) \|\| (Size == 0))
mbed_official	376:cb4d9db17537	722	{
mbed_official	376:cb4d9db17537	723	return HAL_ERROR;
mbed_official	376:cb4d9db17537	724	}
mbed_official	376:cb4d9db17537	725
mbed_official	376:cb4d9db17537	726	/* Process Locked */
mbed_official	376:cb4d9db17537	727	__HAL_LOCK(hirda);
mbed_official	376:cb4d9db17537	728
mbed_official	376:cb4d9db17537	729	hirda->pRxBuffPtr = pData;
mbed_official	376:cb4d9db17537	730	hirda->RxXferSize = Size;
mbed_official	376:cb4d9db17537	731
mbed_official	376:cb4d9db17537	732	hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
mbed_official	376:cb4d9db17537	733	if(hirda->State == HAL_IRDA_STATE_BUSY_TX)
mbed_official	376:cb4d9db17537	734	{
mbed_official	376:cb4d9db17537	735	hirda->State = HAL_IRDA_STATE_BUSY_TX_RX;
mbed_official	376:cb4d9db17537	736	}
mbed_official	376:cb4d9db17537	737	else
mbed_official	376:cb4d9db17537	738	{
mbed_official	376:cb4d9db17537	739	hirda->State = HAL_IRDA_STATE_BUSY_RX;
mbed_official	376:cb4d9db17537	740	}
mbed_official	376:cb4d9db17537	741
mbed_official	376:cb4d9db17537	742	/* Set the IRDA DMA transfer complete callback */
mbed_official	376:cb4d9db17537	743	hirda->hdmarx->XferCpltCallback = IRDA_DMAReceiveCplt;
mbed_official	376:cb4d9db17537	744
mbed_official	376:cb4d9db17537	745	/* Set the IRDA DMA half transfer complete callback */
mbed_official	376:cb4d9db17537	746	hirda->hdmarx->XferHalfCpltCallback = IRDA_DMAReceiveHalfCplt;
mbed_official	376:cb4d9db17537	747
mbed_official	376:cb4d9db17537	748	/* Set the DMA error callback */
mbed_official	376:cb4d9db17537	749	hirda->hdmarx->XferErrorCallback = IRDA_DMAError;
mbed_official	376:cb4d9db17537	750
mbed_official	376:cb4d9db17537	751	/* Enable the DMA channel */
mbed_official	376:cb4d9db17537	752	tmp = (uint32_t*)&pData;
mbed_official	376:cb4d9db17537	753	HAL_DMA_Start_IT(hirda->hdmarx, (uint32_t)&hirda->Instance->RDR, (uint32_t)tmp, Size);
mbed_official	376:cb4d9db17537	754
mbed_official	376:cb4d9db17537	755	/* Enable the DMA transfer for the receiver request by setting the DMAR bit
mbed_official	376:cb4d9db17537	756	in the IRDA CR3 register */
mbed_official	376:cb4d9db17537	757	hirda->Instance->CR3 \|= USART_CR3_DMAR;
mbed_official	376:cb4d9db17537	758
mbed_official	376:cb4d9db17537	759	/* Process Unlocked */
mbed_official	376:cb4d9db17537	760	__HAL_UNLOCK(hirda);
mbed_official	376:cb4d9db17537	761
mbed_official	376:cb4d9db17537	762	return HAL_OK;
mbed_official	376:cb4d9db17537	763	}
mbed_official	376:cb4d9db17537	764	else
mbed_official	376:cb4d9db17537	765	{
mbed_official	376:cb4d9db17537	766	return HAL_BUSY;
mbed_official	376:cb4d9db17537	767	}
mbed_official	376:cb4d9db17537	768	}
mbed_official	376:cb4d9db17537	769
mbed_official	376:cb4d9db17537	770	/**
mbed_official	376:cb4d9db17537	771	* @brief Pauses the DMA Transfer.
mbed_official	376:cb4d9db17537	772	* @param hirda: pointer to a IRDA_HandleTypeDef structure that contains
mbed_official	376:cb4d9db17537	773	* the configuration information for the specified IRDA module.
mbed_official	376:cb4d9db17537	774	* @retval HAL status
mbed_official	376:cb4d9db17537	775	*/
mbed_official	376:cb4d9db17537	776	HAL_StatusTypeDef HAL_IRDA_DMAPause(IRDA_HandleTypeDef *hirda)
mbed_official	376:cb4d9db17537	777	{
mbed_official	376:cb4d9db17537	778	/* Process Locked */
mbed_official	376:cb4d9db17537	779	__HAL_LOCK(hirda);
mbed_official	376:cb4d9db17537	780
mbed_official	376:cb4d9db17537	781	if(hirda->State == HAL_IRDA_STATE_BUSY_TX)
mbed_official	376:cb4d9db17537	782	{
mbed_official	376:cb4d9db17537	783	/* Disable the UART DMA Tx request */
mbed_official	376:cb4d9db17537	784	hirda->Instance->CR3 &= (uint32_t)(~USART_CR3_DMAT);
mbed_official	376:cb4d9db17537	785	}
mbed_official	376:cb4d9db17537	786	else if(hirda->State == HAL_IRDA_STATE_BUSY_RX)
mbed_official	376:cb4d9db17537	787	{
mbed_official	376:cb4d9db17537	788	/* Disable the UART DMA Rx request */
mbed_official	376:cb4d9db17537	789	hirda->Instance->CR3 &= (uint32_t)(~USART_CR3_DMAR);
mbed_official	376:cb4d9db17537	790	}
mbed_official	376:cb4d9db17537	791	else if (hirda->State == HAL_IRDA_STATE_BUSY_TX_RX)
mbed_official	376:cb4d9db17537	792	{
mbed_official	376:cb4d9db17537	793	/* Disable the UART DMA Tx & Rx requests */
mbed_official	376:cb4d9db17537	794	hirda->Instance->CR3 &= (uint32_t)(~USART_CR3_DMAT);
mbed_official	376:cb4d9db17537	795	hirda->Instance->CR3 &= (uint32_t)(~USART_CR3_DMAR);
mbed_official	376:cb4d9db17537	796	}
mbed_official	376:cb4d9db17537	797
mbed_official	376:cb4d9db17537	798	/* Process Unlocked */
mbed_official	376:cb4d9db17537	799	__HAL_UNLOCK(hirda);
mbed_official	376:cb4d9db17537	800
mbed_official	376:cb4d9db17537	801	return HAL_OK;
mbed_official	376:cb4d9db17537	802	}
mbed_official	376:cb4d9db17537	803
mbed_official	376:cb4d9db17537	804	/**
mbed_official	376:cb4d9db17537	805	* @brief Resumes the DMA Transfer.
mbed_official	376:cb4d9db17537	806	* @param hirda: pointer to a IRDA_HandleTypeDef structure that contains
mbed_official	376:cb4d9db17537	807	* the configuration information for the specified UART module.
mbed_official	376:cb4d9db17537	808	* @retval HAL status
mbed_official	376:cb4d9db17537	809	*/
mbed_official	376:cb4d9db17537	810	HAL_StatusTypeDef HAL_IRDA_DMAResume(IRDA_HandleTypeDef *hirda)
mbed_official	376:cb4d9db17537	811	{
mbed_official	376:cb4d9db17537	812	/* Process Locked */
mbed_official	376:cb4d9db17537	813	__HAL_LOCK(hirda);
mbed_official	376:cb4d9db17537	814
mbed_official	376:cb4d9db17537	815	if(hirda->State == HAL_IRDA_STATE_BUSY_TX)
mbed_official	376:cb4d9db17537	816	{
mbed_official	376:cb4d9db17537	817	/* Enable the UART DMA Tx request */
mbed_official	376:cb4d9db17537	818	hirda->Instance->CR3 \|= USART_CR3_DMAT;
mbed_official	376:cb4d9db17537	819	}
mbed_official	376:cb4d9db17537	820	else if(hirda->State == HAL_IRDA_STATE_BUSY_RX)
mbed_official	376:cb4d9db17537	821	{
mbed_official	376:cb4d9db17537	822	/* Clear the Overrun flag before resumming the Rx transfer*/
mbed_official	376:cb4d9db17537	823	__HAL_IRDA_CLEAR_IT(hirda, IRDA_CLEAR_OREF);
mbed_official	376:cb4d9db17537	824
mbed_official	376:cb4d9db17537	825	/* Enable the UART DMA Rx request */
mbed_official	376:cb4d9db17537	826	hirda->Instance->CR3 \|= USART_CR3_DMAR;
mbed_official	376:cb4d9db17537	827	}
mbed_official	376:cb4d9db17537	828	else if(hirda->State == HAL_IRDA_STATE_BUSY_TX_RX)
mbed_official	376:cb4d9db17537	829	{
mbed_official	376:cb4d9db17537	830	/* Clear the Overrun flag before resumming the Rx transfer*/
mbed_official	376:cb4d9db17537	831	__HAL_IRDA_CLEAR_IT(hirda, IRDA_CLEAR_OREF);
mbed_official	376:cb4d9db17537	832
mbed_official	376:cb4d9db17537	833	/* Enable the UART DMA Tx & Rx request */
mbed_official	376:cb4d9db17537	834	hirda->Instance->CR3 \|= USART_CR3_DMAT;
mbed_official	376:cb4d9db17537	835	hirda->Instance->CR3 \|= USART_CR3_DMAR;
mbed_official	376:cb4d9db17537	836	}
mbed_official	376:cb4d9db17537	837
mbed_official	376:cb4d9db17537	838	/* Process Unlocked */
mbed_official	376:cb4d9db17537	839	__HAL_UNLOCK(hirda);
mbed_official	376:cb4d9db17537	840
mbed_official	376:cb4d9db17537	841	return HAL_OK;
mbed_official	376:cb4d9db17537	842	}
mbed_official	376:cb4d9db17537	843
mbed_official	376:cb4d9db17537	844	/**
mbed_official	376:cb4d9db17537	845	* @brief Stops the DMA Transfer.
mbed_official	376:cb4d9db17537	846	* @param hirda: pointer to a IRDA_HandleTypeDef structure that contains
mbed_official	376:cb4d9db17537	847	* the configuration information for the specified UART module.
mbed_official	376:cb4d9db17537	848	* @retval HAL status
mbed_official	376:cb4d9db17537	849	*/
mbed_official	376:cb4d9db17537	850	HAL_StatusTypeDef HAL_IRDA_DMAStop(IRDA_HandleTypeDef *hirda)
mbed_official	376:cb4d9db17537	851	{
mbed_official	376:cb4d9db17537	852	/* The Lock is not implemented on this API to allow the user application
mbed_official	376:cb4d9db17537	853	to call the HAL UART API under callbacks HAL_UART_TxCpltCallback() / HAL_UART_RxCpltCallback():
mbed_official	376:cb4d9db17537	854	when calling HAL_DMA_Abort() API the DMA TX/RX Transfer complete interrupt is generated
mbed_official	376:cb4d9db17537	855	and the correspond call back is executed HAL_UART_TxCpltCallback() / HAL_UART_RxCpltCallback()
mbed_official	376:cb4d9db17537	856	*/
mbed_official	376:cb4d9db17537	857
mbed_official	376:cb4d9db17537	858	/* Disable the UART Tx/Rx DMA requests */
mbed_official	376:cb4d9db17537	859	hirda->Instance->CR3 &= ~USART_CR3_DMAT;
mbed_official	376:cb4d9db17537	860	hirda->Instance->CR3 &= ~USART_CR3_DMAR;
mbed_official	376:cb4d9db17537	861
mbed_official	376:cb4d9db17537	862	/* Abort the UART DMA tx channel */
mbed_official	490:119543c9f674	863	if(hirda->hdmatx != NULL)
mbed_official	376:cb4d9db17537	864	{
mbed_official	376:cb4d9db17537	865	HAL_DMA_Abort(hirda->hdmatx);
mbed_official	376:cb4d9db17537	866	}
mbed_official	376:cb4d9db17537	867	/* Abort the UART DMA rx channel */
mbed_official	490:119543c9f674	868	if(hirda->hdmarx != NULL)
mbed_official	376:cb4d9db17537	869	{
mbed_official	376:cb4d9db17537	870	HAL_DMA_Abort(hirda->hdmarx);
mbed_official	376:cb4d9db17537	871	}
mbed_official	376:cb4d9db17537	872
mbed_official	376:cb4d9db17537	873	hirda->State = HAL_IRDA_STATE_READY;
mbed_official	376:cb4d9db17537	874
mbed_official	376:cb4d9db17537	875	return HAL_OK;
mbed_official	376:cb4d9db17537	876	}
mbed_official	376:cb4d9db17537	877
mbed_official	376:cb4d9db17537	878	/**
mbed_official	376:cb4d9db17537	879	* @brief This function handles IRDA interrupt request.
mbed_official	376:cb4d9db17537	880	* @param hirda: IRDA handle
mbed_official	376:cb4d9db17537	881	* @retval None
mbed_official	376:cb4d9db17537	882	*/
mbed_official	376:cb4d9db17537	883	void HAL_IRDA_IRQHandler(IRDA_HandleTypeDef *hirda)
mbed_official	376:cb4d9db17537	884	{
mbed_official	376:cb4d9db17537	885	/* IRDA parity error interrupt occurred -------------------------------------*/
mbed_official	376:cb4d9db17537	886	if((__HAL_IRDA_GET_IT(hirda, IRDA_IT_PE) != RESET) && (__HAL_IRDA_GET_IT_SOURCE(hirda, IRDA_IT_PE) != RESET))
mbed_official	376:cb4d9db17537	887	{
mbed_official	490:119543c9f674	888	__HAL_IRDA_CLEAR_PEFLAG(hirda);
mbed_official	376:cb4d9db17537	889
mbed_official	376:cb4d9db17537	890	hirda->ErrorCode \|= HAL_IRDA_ERROR_PE;
mbed_official	376:cb4d9db17537	891	/* Set the IRDA state ready to be able to start again the process */
mbed_official	376:cb4d9db17537	892	hirda->State = HAL_IRDA_STATE_READY;
mbed_official	376:cb4d9db17537	893	}
mbed_official	376:cb4d9db17537	894
mbed_official	376:cb4d9db17537	895	/* IRDA frame error interrupt occured --------------------------------------*/
mbed_official	376:cb4d9db17537	896	if((__HAL_IRDA_GET_IT(hirda, IRDA_IT_FE) != RESET) && (__HAL_IRDA_GET_IT_SOURCE(hirda, IRDA_IT_ERR) != RESET))
mbed_official	376:cb4d9db17537	897	{
mbed_official	490:119543c9f674	898	__HAL_IRDA_CLEAR_FEFLAG(hirda);
mbed_official	376:cb4d9db17537	899
mbed_official	376:cb4d9db17537	900	hirda->ErrorCode \|= HAL_IRDA_ERROR_FE;
mbed_official	376:cb4d9db17537	901	/* Set the IRDA state ready to be able to start again the process */
mbed_official	376:cb4d9db17537	902	hirda->State = HAL_IRDA_STATE_READY;
mbed_official	376:cb4d9db17537	903	}
mbed_official	376:cb4d9db17537	904
mbed_official	376:cb4d9db17537	905	/* IRDA noise error interrupt occured --------------------------------------*/
mbed_official	376:cb4d9db17537	906	if((__HAL_IRDA_GET_IT(hirda, IRDA_IT_NE) != RESET) && (__HAL_IRDA_GET_IT_SOURCE(hirda, IRDA_IT_ERR) != RESET))
mbed_official	376:cb4d9db17537	907	{
mbed_official	490:119543c9f674	908	__HAL_IRDA_CLEAR_NEFLAG(hirda);
mbed_official	376:cb4d9db17537	909
mbed_official	376:cb4d9db17537	910	hirda->ErrorCode \|= HAL_IRDA_ERROR_NE;
mbed_official	376:cb4d9db17537	911	/* Set the IRDA state ready to be able to start again the process */
mbed_official	376:cb4d9db17537	912	hirda->State = HAL_IRDA_STATE_READY;
mbed_official	376:cb4d9db17537	913	}
mbed_official	376:cb4d9db17537	914
mbed_official	376:cb4d9db17537	915	/* IRDA Over-Run interrupt occured -----------------------------------------*/
mbed_official	376:cb4d9db17537	916	if((__HAL_IRDA_GET_IT(hirda, IRDA_IT_ORE) != RESET) && (__HAL_IRDA_GET_IT_SOURCE(hirda, IRDA_IT_ERR) != RESET))
mbed_official	376:cb4d9db17537	917	{
mbed_official	490:119543c9f674	918	__HAL_IRDA_CLEAR_OREFLAG(hirda);
mbed_official	376:cb4d9db17537	919
mbed_official	376:cb4d9db17537	920	hirda->ErrorCode \|= HAL_IRDA_ERROR_ORE;
mbed_official	376:cb4d9db17537	921	/* Set the IRDA state ready to be able to start again the process */
mbed_official	376:cb4d9db17537	922	hirda->State = HAL_IRDA_STATE_READY;
mbed_official	376:cb4d9db17537	923	}
mbed_official	376:cb4d9db17537	924
mbed_official	376:cb4d9db17537	925	/* Call IRDA Error Call back function if need be --------------------------*/
mbed_official	376:cb4d9db17537	926	if(hirda->ErrorCode != HAL_IRDA_ERROR_NONE)
mbed_official	376:cb4d9db17537	927	{
mbed_official	376:cb4d9db17537	928	HAL_IRDA_ErrorCallback(hirda);
mbed_official	376:cb4d9db17537	929	}
mbed_official	376:cb4d9db17537	930
mbed_official	376:cb4d9db17537	931	/* IRDA in mode Receiver ---------------------------------------------------*/
mbed_official	376:cb4d9db17537	932	if((__HAL_IRDA_GET_IT(hirda, IRDA_IT_RXNE) != RESET) && (__HAL_IRDA_GET_IT_SOURCE(hirda, IRDA_IT_RXNE) != RESET))
mbed_official	376:cb4d9db17537	933	{
mbed_official	376:cb4d9db17537	934	IRDA_Receive_IT(hirda);
mbed_official	376:cb4d9db17537	935	/* Clear RXNE interrupt flag */
mbed_official	376:cb4d9db17537	936	__HAL_IRDA_SEND_REQ(hirda, IRDA_RXDATA_FLUSH_REQUEST);
mbed_official	376:cb4d9db17537	937	}
mbed_official	376:cb4d9db17537	938
mbed_official	376:cb4d9db17537	939	/* IRDA in mode Transmitter ------------------------------------------------*/
mbed_official	376:cb4d9db17537	940	if((__HAL_IRDA_GET_IT(hirda, IRDA_IT_TXE) != RESET) &&(__HAL_IRDA_GET_IT_SOURCE(hirda, IRDA_IT_TXE) != RESET))
mbed_official	376:cb4d9db17537	941	{
mbed_official	376:cb4d9db17537	942	IRDA_Transmit_IT(hirda);
mbed_official	376:cb4d9db17537	943	}
mbed_official	490:119543c9f674	944
mbed_official	490:119543c9f674	945	/* IRDA in mode Transmitter (transmission end) -----------------------------*/
mbed_official	490:119543c9f674	946	if((__HAL_IRDA_GET_IT(hirda, IRDA_IT_TC) != RESET) &&(__HAL_IRDA_GET_IT_SOURCE(hirda, IRDA_IT_TC) != RESET))
mbed_official	490:119543c9f674	947	{
mbed_official	490:119543c9f674	948	IRDA_EndTransmit_IT(hirda);
mbed_official	490:119543c9f674	949	}
mbed_official	490:119543c9f674	950
mbed_official	376:cb4d9db17537	951	}
mbed_official	376:cb4d9db17537	952
mbed_official	376:cb4d9db17537	953	/**
mbed_official	376:cb4d9db17537	954	* @brief Tx Half Transfer completed callback
mbed_official	376:cb4d9db17537	955	* @param hirda: irda handle
mbed_official	376:cb4d9db17537	956	* @retval None
mbed_official	376:cb4d9db17537	957	*/
mbed_official	376:cb4d9db17537	958	__weak void HAL_IRDA_TxHalfCpltCallback(IRDA_HandleTypeDef *hirda)
mbed_official	376:cb4d9db17537	959	{
mbed_official	376:cb4d9db17537	960	/* NOTE : This function should not be modified, when the callback is needed,
mbed_official	376:cb4d9db17537	961	the HAL_IRDA_TxHalfCpltCallback can be implemented in the user file
mbed_official	376:cb4d9db17537	962	*/
mbed_official	376:cb4d9db17537	963	}
mbed_official	376:cb4d9db17537	964
mbed_official	376:cb4d9db17537	965	/**
mbed_official	376:cb4d9db17537	966	* @brief Tx Transfer completed callback
mbed_official	376:cb4d9db17537	967	* @param hirda: irda handle
mbed_official	376:cb4d9db17537	968	* @retval None
mbed_official	376:cb4d9db17537	969	*/
mbed_official	376:cb4d9db17537	970	__weak void HAL_IRDA_TxCpltCallback(IRDA_HandleTypeDef *hirda)
mbed_official	376:cb4d9db17537	971	{
mbed_official	376:cb4d9db17537	972	/* NOTE : This function should not be modified, when the callback is needed,
mbed_official	376:cb4d9db17537	973	the HAL_IRDA_TxCpltCallback can be implemented in the user file
mbed_official	376:cb4d9db17537	974	*/
mbed_official	376:cb4d9db17537	975	}
mbed_official	376:cb4d9db17537	976
mbed_official	376:cb4d9db17537	977	/**
mbed_official	376:cb4d9db17537	978	* @brief Rx Half Transfer completed callback
mbed_official	376:cb4d9db17537	979	* @param hirda: irda handle
mbed_official	376:cb4d9db17537	980	* @retval None
mbed_official	376:cb4d9db17537	981	*/
mbed_official	376:cb4d9db17537	982	__weak void HAL_IRDA_RxHalfCpltCallback(IRDA_HandleTypeDef *hirda)
mbed_official	376:cb4d9db17537	983	{
mbed_official	376:cb4d9db17537	984	/* NOTE : This function should not be modified, when the callback is needed,
mbed_official	376:cb4d9db17537	985	the HAL_IRDA_RxHalfCpltCallback can be implemented in the user file
mbed_official	376:cb4d9db17537	986	*/
mbed_official	376:cb4d9db17537	987	}
mbed_official	376:cb4d9db17537	988
mbed_official	376:cb4d9db17537	989	/**
mbed_official	376:cb4d9db17537	990	* @brief Rx Transfer completed callback
mbed_official	376:cb4d9db17537	991	* @param hirda: irda handle
mbed_official	376:cb4d9db17537	992	* @retval None
mbed_official	376:cb4d9db17537	993	*/
mbed_official	376:cb4d9db17537	994	__weak void HAL_IRDA_RxCpltCallback(IRDA_HandleTypeDef *hirda)
mbed_official	376:cb4d9db17537	995	{
mbed_official	376:cb4d9db17537	996	/* NOTE : This function should not be modified, when the callback is needed,
mbed_official	376:cb4d9db17537	997	the HAL_IRDA_RxCpltCallback can be implemented in the user file
mbed_official	376:cb4d9db17537	998	*/
mbed_official	376:cb4d9db17537	999	}
mbed_official	376:cb4d9db17537	1000
mbed_official	376:cb4d9db17537	1001	/**
mbed_official	376:cb4d9db17537	1002	* @brief IRDA error callback
mbed_official	376:cb4d9db17537	1003	* @param hirda: IRDA handle
mbed_official	376:cb4d9db17537	1004	* @retval None
mbed_official	376:cb4d9db17537	1005	*/
mbed_official	376:cb4d9db17537	1006	__weak void HAL_IRDA_ErrorCallback(IRDA_HandleTypeDef *hirda)
mbed_official	376:cb4d9db17537	1007	{
mbed_official	376:cb4d9db17537	1008	/* NOTE : This function should not be modified, when the callback is needed,
mbed_official	376:cb4d9db17537	1009	the HAL_IRDA_ErrorCallback can be implemented in the user file
mbed_official	376:cb4d9db17537	1010	*/
mbed_official	376:cb4d9db17537	1011	}
mbed_official	376:cb4d9db17537	1012
mbed_official	376:cb4d9db17537	1013	/**
mbed_official	376:cb4d9db17537	1014	* @}
mbed_official	376:cb4d9db17537	1015	*/
mbed_official	376:cb4d9db17537	1016
mbed_official	490:119543c9f674	1017	/** @addtogroup IRDA_Exported_Functions_Group3
mbed_official	376:cb4d9db17537	1018	* @brief IRDA control functions
mbed_official	376:cb4d9db17537	1019	*
mbed_official	376:cb4d9db17537	1020	@verbatim
mbed_official	376:cb4d9db17537	1021	===============================================================================
mbed_official	376:cb4d9db17537	1022	##### Peripheral Control functions #####
mbed_official	376:cb4d9db17537	1023	===============================================================================
mbed_official	376:cb4d9db17537	1024	[..]
mbed_official	376:cb4d9db17537	1025	This subsection provides a set of functions allowing to control the IRDA.
mbed_official	376:cb4d9db17537	1026	(+) HAL_IRDA_GetState() API can be helpful to check in run-time the state of the IRDA peripheral.
mbed_official	376:cb4d9db17537	1027	(+) IRDA_SetConfig() API is used to configure the IRDA communications parameters.
mbed_official	376:cb4d9db17537	1028	@endverbatim
mbed_official	376:cb4d9db17537	1029	* @{
mbed_official	376:cb4d9db17537	1030	*/
mbed_official	376:cb4d9db17537	1031
mbed_official	376:cb4d9db17537	1032	/**
mbed_official	376:cb4d9db17537	1033	* @brief return the IRDA state
mbed_official	376:cb4d9db17537	1034	* @param hirda: irda handle
mbed_official	376:cb4d9db17537	1035	* @retval HAL state
mbed_official	376:cb4d9db17537	1036	*/
mbed_official	376:cb4d9db17537	1037	HAL_IRDA_StateTypeDef HAL_IRDA_GetState(IRDA_HandleTypeDef *hirda)
mbed_official	376:cb4d9db17537	1038	{
mbed_official	376:cb4d9db17537	1039	return hirda->State;
mbed_official	376:cb4d9db17537	1040	}
mbed_official	376:cb4d9db17537	1041
mbed_official	376:cb4d9db17537	1042	/**
mbed_official	376:cb4d9db17537	1043	* @brief Return the IRDA error code
mbed_official	376:cb4d9db17537	1044	* @param hirda : pointer to a IRDA_HandleTypeDef structure that contains
mbed_official	376:cb4d9db17537	1045	* the configuration information for the specified IRDA.
mbed_official	376:cb4d9db17537	1046	* @retval IRDA Error Code
mbed_official	376:cb4d9db17537	1047	*/
mbed_official	376:cb4d9db17537	1048	uint32_t HAL_IRDA_GetError(IRDA_HandleTypeDef *hirda)
mbed_official	376:cb4d9db17537	1049	{
mbed_official	376:cb4d9db17537	1050	return hirda->ErrorCode;
mbed_official	376:cb4d9db17537	1051	}
mbed_official	376:cb4d9db17537	1052
mbed_official	376:cb4d9db17537	1053	/**
mbed_official	376:cb4d9db17537	1054	* @}
mbed_official	376:cb4d9db17537	1055	*/
mbed_official	376:cb4d9db17537	1056
mbed_official	376:cb4d9db17537	1057	/**
mbed_official	376:cb4d9db17537	1058	* @brief Configure the IRDA peripheral
mbed_official	376:cb4d9db17537	1059	* @param hirda: irda handle
mbed_official	376:cb4d9db17537	1060	* @retval None
mbed_official	376:cb4d9db17537	1061	*/
mbed_official	376:cb4d9db17537	1062	static void IRDA_SetConfig(IRDA_HandleTypeDef *hirda)
mbed_official	376:cb4d9db17537	1063	{
mbed_official	376:cb4d9db17537	1064	uint32_t tmpreg = 0x00000000;
mbed_official	376:cb4d9db17537	1065	uint32_t clocksource = 0x00000000;
mbed_official	376:cb4d9db17537	1066
mbed_official	376:cb4d9db17537	1067	/* Check the communication parameters */
mbed_official	376:cb4d9db17537	1068	assert_param(IS_IRDA_BAUDRATE(hirda->Init.BaudRate));
mbed_official	376:cb4d9db17537	1069	assert_param(IS_IRDA_WORD_LENGTH(hirda->Init.WordLength));
mbed_official	376:cb4d9db17537	1070	assert_param(IS_IRDA_PARITY(hirda->Init.Parity));
mbed_official	376:cb4d9db17537	1071	assert_param(IS_IRDA_TX_RX_MODE(hirda->Init.Mode));
mbed_official	376:cb4d9db17537	1072	assert_param(IS_IRDA_PRESCALER(hirda->Init.Prescaler));
mbed_official	376:cb4d9db17537	1073	assert_param(IS_IRDA_POWERMODE(hirda->Init.PowerMode));
mbed_official	376:cb4d9db17537	1074	/-------------------------- USART CR1 Configuration -----------------------/
mbed_official	376:cb4d9db17537	1075	/* Configure the IRDA Word Length, Parity and transfer Mode:
mbed_official	376:cb4d9db17537	1076	Set the M bits according to hirda->Init.WordLength value
mbed_official	376:cb4d9db17537	1077	Set PCE and PS bits according to hirda->Init.Parity value
mbed_official	376:cb4d9db17537	1078	Set TE and RE bits according to hirda->Init.Mode value */
mbed_official	376:cb4d9db17537	1079	tmpreg = (uint32_t)hirda->Init.WordLength \| hirda->Init.Parity \| hirda->Init.Mode ;
mbed_official	376:cb4d9db17537	1080
mbed_official	376:cb4d9db17537	1081	MODIFY_REG(hirda->Instance->CR1, IRDA_CR1_FIELDS, tmpreg);
mbed_official	376:cb4d9db17537	1082
mbed_official	376:cb4d9db17537	1083	/-------------------------- USART CR3 Configuration -----------------------/
mbed_official	376:cb4d9db17537	1084	MODIFY_REG(hirda->Instance->CR3, USART_CR3_IRLP, hirda->Init.PowerMode);
mbed_official	376:cb4d9db17537	1085
mbed_official	376:cb4d9db17537	1086	/-------------------------- USART GTPR Configuration ----------------------/
mbed_official	376:cb4d9db17537	1087	MODIFY_REG(hirda->Instance->GTPR, (uint32_t)USART_GTPR_PSC, hirda->Init.Prescaler);
mbed_official	376:cb4d9db17537	1088
mbed_official	376:cb4d9db17537	1089	/-------------------------- USART BRR Configuration -----------------------/
mbed_official	490:119543c9f674	1090	IRDA_GETCLOCKSOURCE(hirda, clocksource);
mbed_official	376:cb4d9db17537	1091	switch (clocksource)
mbed_official	376:cb4d9db17537	1092	{
mbed_official	376:cb4d9db17537	1093	case IRDA_CLOCKSOURCE_PCLK1:
mbed_official	376:cb4d9db17537	1094	hirda->Instance->BRR = (uint16_t)(HAL_RCC_GetPCLK1Freq() / hirda->Init.BaudRate);
mbed_official	376:cb4d9db17537	1095	break;
mbed_official	376:cb4d9db17537	1096	case IRDA_CLOCKSOURCE_PCLK2:
mbed_official	376:cb4d9db17537	1097	hirda->Instance->BRR = (uint16_t)(HAL_RCC_GetPCLK2Freq() / hirda->Init.BaudRate);
mbed_official	376:cb4d9db17537	1098	break;
mbed_official	376:cb4d9db17537	1099	case IRDA_CLOCKSOURCE_HSI:
mbed_official	376:cb4d9db17537	1100	hirda->Instance->BRR = (uint16_t)(HSI_VALUE / hirda->Init.BaudRate);
mbed_official	376:cb4d9db17537	1101	break;
mbed_official	376:cb4d9db17537	1102	case IRDA_CLOCKSOURCE_SYSCLK:
mbed_official	376:cb4d9db17537	1103	hirda->Instance->BRR = (uint16_t)(HAL_RCC_GetSysClockFreq() / hirda->Init.BaudRate);
mbed_official	376:cb4d9db17537	1104	break;
mbed_official	376:cb4d9db17537	1105	case IRDA_CLOCKSOURCE_LSE:
mbed_official	376:cb4d9db17537	1106	hirda->Instance->BRR = (uint16_t)(LSE_VALUE / hirda->Init.BaudRate);
mbed_official	376:cb4d9db17537	1107	break;
mbed_official	376:cb4d9db17537	1108	default:
mbed_official	376:cb4d9db17537	1109	break;
mbed_official	376:cb4d9db17537	1110	}
mbed_official	376:cb4d9db17537	1111	}
mbed_official	376:cb4d9db17537	1112
mbed_official	376:cb4d9db17537	1113	/**
mbed_official	376:cb4d9db17537	1114	* @brief Check the IRDA Idle State
mbed_official	376:cb4d9db17537	1115	* @param hirda: IRDA handle
mbed_official	376:cb4d9db17537	1116	* @retval HAL status
mbed_official	376:cb4d9db17537	1117	*/
mbed_official	376:cb4d9db17537	1118	static HAL_StatusTypeDef IRDA_CheckIdleState(IRDA_HandleTypeDef *hirda)
mbed_official	376:cb4d9db17537	1119	{
mbed_official	376:cb4d9db17537	1120	/* Initialize the IRDA ErrorCode */
mbed_official	376:cb4d9db17537	1121	hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
mbed_official	376:cb4d9db17537	1122
mbed_official	376:cb4d9db17537	1123	/* Check if the Transmitter is enabled */
mbed_official	376:cb4d9db17537	1124	if((hirda->Instance->CR1 & USART_CR1_TE) == USART_CR1_TE)
mbed_official	376:cb4d9db17537	1125	{
mbed_official	376:cb4d9db17537	1126	/* Wait until TEACK flag is set */
mbed_official	376:cb4d9db17537	1127	if(IRDA_WaitOnFlagUntilTimeout(hirda, USART_ISR_TEACK, RESET, TEACK_REACK_TIMEOUT) != HAL_OK)
mbed_official	376:cb4d9db17537	1128	{
mbed_official	376:cb4d9db17537	1129	hirda->State= HAL_IRDA_STATE_TIMEOUT;
mbed_official	376:cb4d9db17537	1130	return HAL_TIMEOUT;
mbed_official	376:cb4d9db17537	1131	}
mbed_official	376:cb4d9db17537	1132	}
mbed_official	376:cb4d9db17537	1133	/* Check if the Receiver is enabled */
mbed_official	376:cb4d9db17537	1134	if((hirda->Instance->CR1 & USART_CR1_RE) == USART_CR1_RE)
mbed_official	376:cb4d9db17537	1135	{
mbed_official	376:cb4d9db17537	1136	if(IRDA_WaitOnFlagUntilTimeout(hirda, USART_ISR_REACK, RESET, TEACK_REACK_TIMEOUT) != HAL_OK)
mbed_official	376:cb4d9db17537	1137	{
mbed_official	376:cb4d9db17537	1138	hirda->State= HAL_IRDA_STATE_TIMEOUT;
mbed_official	376:cb4d9db17537	1139	return HAL_TIMEOUT;
mbed_official	376:cb4d9db17537	1140	}
mbed_official	376:cb4d9db17537	1141	}
mbed_official	376:cb4d9db17537	1142	/* Process Unlocked */
mbed_official	376:cb4d9db17537	1143	__HAL_UNLOCK(hirda);
mbed_official	376:cb4d9db17537	1144
mbed_official	376:cb4d9db17537	1145	/* Initialize the IRDA state*/
mbed_official	376:cb4d9db17537	1146	hirda->State= HAL_IRDA_STATE_READY;
mbed_official	376:cb4d9db17537	1147
mbed_official	376:cb4d9db17537	1148	return HAL_OK;
mbed_official	376:cb4d9db17537	1149	}
mbed_official	376:cb4d9db17537	1150
mbed_official	376:cb4d9db17537	1151	/**
mbed_official	376:cb4d9db17537	1152	* @brief Handle IRDA Communication Timeout.
mbed_official	376:cb4d9db17537	1153	* @param hirda: IRDA handle
mbed_official	376:cb4d9db17537	1154	* @param Flag: specifies the IRDA flag to check.
mbed_official	376:cb4d9db17537	1155	* @param Status: the flag status (SET or RESET). The function is locked in a while loop as long as the flag remains set to Status.
mbed_official	376:cb4d9db17537	1156	* @param Timeout: Timeout duration
mbed_official	376:cb4d9db17537	1157	* @retval HAL status
mbed_official	376:cb4d9db17537	1158	*/
mbed_official	376:cb4d9db17537	1159	static HAL_StatusTypeDef IRDA_WaitOnFlagUntilTimeout(IRDA_HandleTypeDef *hirda, uint32_t Flag, FlagStatus Status, uint32_t Timeout)
mbed_official	376:cb4d9db17537	1160	{
mbed_official	376:cb4d9db17537	1161	uint32_t tickstart = 0x00;
mbed_official	376:cb4d9db17537	1162	tickstart = HAL_GetTick();
mbed_official	376:cb4d9db17537	1163
mbed_official	376:cb4d9db17537	1164	/* Wait until flag is set */
mbed_official	376:cb4d9db17537	1165	if(Status == RESET)
mbed_official	376:cb4d9db17537	1166	{
mbed_official	376:cb4d9db17537	1167	while(__HAL_IRDA_GET_FLAG(hirda, Flag) == RESET)
mbed_official	376:cb4d9db17537	1168	{
mbed_official	376:cb4d9db17537	1169	/* Check for the Timeout */
mbed_official	376:cb4d9db17537	1170	if(Timeout != HAL_MAX_DELAY)
mbed_official	376:cb4d9db17537	1171	{
mbed_official	376:cb4d9db17537	1172	if((Timeout == 0)\|\|((HAL_GetTick() - tickstart ) > Timeout))
mbed_official	376:cb4d9db17537	1173	{
mbed_official	376:cb4d9db17537	1174	/* Disable TXE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts for the interrupt process */
mbed_official	376:cb4d9db17537	1175	__HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_TXE);
mbed_official	376:cb4d9db17537	1176	__HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_RXNE);
mbed_official	376:cb4d9db17537	1177	__HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_PE);
mbed_official	376:cb4d9db17537	1178	__HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_ERR);
mbed_official	376:cb4d9db17537	1179
mbed_official	490:119543c9f674	1180	hirda->State= HAL_IRDA_STATE_READY;
mbed_official	376:cb4d9db17537	1181
mbed_official	376:cb4d9db17537	1182	/* Process Unlocked */
mbed_official	376:cb4d9db17537	1183	__HAL_UNLOCK(hirda);
mbed_official	376:cb4d9db17537	1184
mbed_official	376:cb4d9db17537	1185	return HAL_TIMEOUT;
mbed_official	376:cb4d9db17537	1186	}
mbed_official	376:cb4d9db17537	1187	}
mbed_official	376:cb4d9db17537	1188	}
mbed_official	376:cb4d9db17537	1189	}
mbed_official	376:cb4d9db17537	1190	else
mbed_official	376:cb4d9db17537	1191	{
mbed_official	376:cb4d9db17537	1192	while(__HAL_IRDA_GET_FLAG(hirda, Flag) != RESET)
mbed_official	376:cb4d9db17537	1193	{
mbed_official	376:cb4d9db17537	1194	/* Check for the Timeout */
mbed_official	376:cb4d9db17537	1195	if(Timeout != HAL_MAX_DELAY)
mbed_official	376:cb4d9db17537	1196	{
mbed_official	376:cb4d9db17537	1197	if((Timeout == 0)\|\|((HAL_GetTick() - tickstart ) > Timeout))
mbed_official	376:cb4d9db17537	1198	{
mbed_official	376:cb4d9db17537	1199	/* Disable TXE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts for the interrupt process */
mbed_official	376:cb4d9db17537	1200	__HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_TXE);
mbed_official	376:cb4d9db17537	1201	__HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_RXNE);
mbed_official	376:cb4d9db17537	1202	__HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_PE);
mbed_official	376:cb4d9db17537	1203	__HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_ERR);
mbed_official	376:cb4d9db17537	1204
mbed_official	490:119543c9f674	1205	hirda->State= HAL_IRDA_STATE_READY;
mbed_official	376:cb4d9db17537	1206
mbed_official	376:cb4d9db17537	1207	/* Process Unlocked */
mbed_official	376:cb4d9db17537	1208	__HAL_UNLOCK(hirda);
mbed_official	376:cb4d9db17537	1209
mbed_official	376:cb4d9db17537	1210	return HAL_TIMEOUT;
mbed_official	376:cb4d9db17537	1211	}
mbed_official	376:cb4d9db17537	1212	}
mbed_official	376:cb4d9db17537	1213	}
mbed_official	376:cb4d9db17537	1214	}
mbed_official	376:cb4d9db17537	1215	return HAL_OK;
mbed_official	376:cb4d9db17537	1216	}
mbed_official	376:cb4d9db17537	1217
mbed_official	376:cb4d9db17537	1218	/**
mbed_official	376:cb4d9db17537	1219	* @brief Receive an amount of data in non blocking mode.
mbed_official	376:cb4d9db17537	1220	* Function called under interruption only, once
mbed_official	376:cb4d9db17537	1221	* interruptions have been enabled by HAL_IRDA_Transmit_IT()
mbed_official	376:cb4d9db17537	1222	* @param hirda: IRDA handle
mbed_official	376:cb4d9db17537	1223	* @retval HAL status
mbed_official	376:cb4d9db17537	1224	*/
mbed_official	376:cb4d9db17537	1225	static HAL_StatusTypeDef IRDA_Transmit_IT(IRDA_HandleTypeDef *hirda)
mbed_official	376:cb4d9db17537	1226	{
mbed_official	376:cb4d9db17537	1227	uint16_t* tmp;
mbed_official	376:cb4d9db17537	1228
mbed_official	376:cb4d9db17537	1229	if((hirda->State == HAL_IRDA_STATE_BUSY_TX) \|\| (hirda->State == HAL_IRDA_STATE_BUSY_TX_RX))
mbed_official	376:cb4d9db17537	1230	{
mbed_official	490:119543c9f674	1231
mbed_official	376:cb4d9db17537	1232	if(hirda->TxXferCount == 0)
mbed_official	376:cb4d9db17537	1233	{
mbed_official	490:119543c9f674	1234	/* Disable the IRDA Transmit Data Register Empty Interrupt */
mbed_official	376:cb4d9db17537	1235	__HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_TXE);
mbed_official	490:119543c9f674	1236
mbed_official	490:119543c9f674	1237	/* Enable the IRDA Transmit Complete Interrupt */
mbed_official	490:119543c9f674	1238	__HAL_IRDA_ENABLE_IT(hirda, IRDA_IT_TC);
mbed_official	376:cb4d9db17537	1239
mbed_official	376:cb4d9db17537	1240	return HAL_OK;
mbed_official	376:cb4d9db17537	1241	}
mbed_official	376:cb4d9db17537	1242	else
mbed_official	376:cb4d9db17537	1243	{
mbed_official	376:cb4d9db17537	1244	if ((hirda->Init.WordLength == IRDA_WORDLENGTH_9B) && (hirda->Init.Parity == IRDA_PARITY_NONE))
mbed_official	376:cb4d9db17537	1245	{
mbed_official	376:cb4d9db17537	1246	tmp = (uint16_t*) hirda->pTxBuffPtr;
mbed_official	376:cb4d9db17537	1247	hirda->Instance->TDR = (*tmp & (uint16_t)0x01FF);
mbed_official	376:cb4d9db17537	1248	hirda->pTxBuffPtr += 2;
mbed_official	376:cb4d9db17537	1249	}
mbed_official	376:cb4d9db17537	1250	else
mbed_official	376:cb4d9db17537	1251	{
mbed_official	376:cb4d9db17537	1252	hirda->Instance->TDR = (uint8_t)(*hirda->pTxBuffPtr++ & (uint8_t)0xFF);
mbed_official	376:cb4d9db17537	1253	}
mbed_official	376:cb4d9db17537	1254	hirda->TxXferCount--;
mbed_official	376:cb4d9db17537	1255	return HAL_OK;
mbed_official	376:cb4d9db17537	1256	}
mbed_official	376:cb4d9db17537	1257	}
mbed_official	376:cb4d9db17537	1258	else
mbed_official	376:cb4d9db17537	1259	{
mbed_official	376:cb4d9db17537	1260	return HAL_BUSY;
mbed_official	376:cb4d9db17537	1261	}
mbed_official	376:cb4d9db17537	1262	}
mbed_official	490:119543c9f674	1263	/**
mbed_official	490:119543c9f674	1264	* @brief Wraps up transmission in non blocking mode.
mbed_official	490:119543c9f674	1265	* @param hirda: pointer to a IRDA_HandleTypeDef structure that contains
mbed_official	490:119543c9f674	1266	* the configuration information for the specified IRDA module.
mbed_official	490:119543c9f674	1267	* @retval HAL status
mbed_official	490:119543c9f674	1268	*/
mbed_official	490:119543c9f674	1269	static HAL_StatusTypeDef IRDA_EndTransmit_IT(IRDA_HandleTypeDef *hirda)
mbed_official	490:119543c9f674	1270	{
mbed_official	490:119543c9f674	1271	/* Disable the IRDA Transmit Complete Interrupt */
mbed_official	490:119543c9f674	1272	__HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_TC);
mbed_official	490:119543c9f674	1273
mbed_official	490:119543c9f674	1274	/* Check if a receive process is ongoing or not */
mbed_official	490:119543c9f674	1275	if(hirda->State == HAL_IRDA_STATE_BUSY_TX_RX)
mbed_official	490:119543c9f674	1276	{
mbed_official	490:119543c9f674	1277	hirda->State = HAL_IRDA_STATE_BUSY_RX;
mbed_official	490:119543c9f674	1278	}
mbed_official	490:119543c9f674	1279	else
mbed_official	490:119543c9f674	1280	{
mbed_official	490:119543c9f674	1281	/* Disable the IRDA Error Interrupt: (Frame error, noise error, overrun error) */
mbed_official	490:119543c9f674	1282	__HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_ERR);
mbed_official	490:119543c9f674	1283
mbed_official	490:119543c9f674	1284	hirda->State = HAL_IRDA_STATE_READY;
mbed_official	490:119543c9f674	1285	}
mbed_official	490:119543c9f674	1286
mbed_official	490:119543c9f674	1287	HAL_IRDA_TxCpltCallback(hirda);
mbed_official	490:119543c9f674	1288
mbed_official	490:119543c9f674	1289	return HAL_OK;
mbed_official	490:119543c9f674	1290	}
mbed_official	376:cb4d9db17537	1291
mbed_official	376:cb4d9db17537	1292	/**
mbed_official	376:cb4d9db17537	1293	* @brief Receive an amount of data in non blocking mode.
mbed_official	376:cb4d9db17537	1294	* Function called under interruption only, once
mbed_official	376:cb4d9db17537	1295	* interruptions have been enabled by HAL_IRDA_Receive_IT()
mbed_official	376:cb4d9db17537	1296	* @param hirda: IRDA handle
mbed_official	376:cb4d9db17537	1297	* @retval HAL status
mbed_official	376:cb4d9db17537	1298	*/
mbed_official	376:cb4d9db17537	1299	static HAL_StatusTypeDef IRDA_Receive_IT(IRDA_HandleTypeDef *hirda)
mbed_official	376:cb4d9db17537	1300	{
mbed_official	376:cb4d9db17537	1301	uint16_t* tmp;
mbed_official	376:cb4d9db17537	1302	uint16_t uhMask = hirda->Mask;
mbed_official	376:cb4d9db17537	1303
mbed_official	376:cb4d9db17537	1304	if ((hirda->State == HAL_IRDA_STATE_BUSY_RX) \|\| (hirda->State == HAL_IRDA_STATE_BUSY_TX_RX))
mbed_official	376:cb4d9db17537	1305	{
mbed_official	376:cb4d9db17537	1306	if ((hirda->Init.WordLength == IRDA_WORDLENGTH_9B) && (hirda->Init.Parity == IRDA_PARITY_NONE))
mbed_official	376:cb4d9db17537	1307	{
mbed_official	376:cb4d9db17537	1308	tmp = (uint16_t*) hirda->pRxBuffPtr ;
mbed_official	376:cb4d9db17537	1309	*tmp = (uint16_t)(hirda->Instance->RDR & uhMask);
mbed_official	376:cb4d9db17537	1310	hirda->pRxBuffPtr +=2;
mbed_official	376:cb4d9db17537	1311	}
mbed_official	376:cb4d9db17537	1312	else
mbed_official	376:cb4d9db17537	1313	{
mbed_official	376:cb4d9db17537	1314	*hirda->pRxBuffPtr++ = (uint8_t)(hirda->Instance->RDR & (uint8_t)uhMask);
mbed_official	376:cb4d9db17537	1315	}
mbed_official	376:cb4d9db17537	1316
mbed_official	376:cb4d9db17537	1317	if(--hirda->RxXferCount == 0)
mbed_official	376:cb4d9db17537	1318	{
mbed_official	376:cb4d9db17537	1319	while(HAL_IS_BIT_SET(hirda->Instance->ISR, IRDA_FLAG_RXNE))
mbed_official	376:cb4d9db17537	1320	{
mbed_official	376:cb4d9db17537	1321	}
mbed_official	376:cb4d9db17537	1322	__HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_RXNE);
mbed_official	376:cb4d9db17537	1323
mbed_official	376:cb4d9db17537	1324	if(hirda->State == HAL_IRDA_STATE_BUSY_TX_RX)
mbed_official	376:cb4d9db17537	1325	{
mbed_official	376:cb4d9db17537	1326	hirda->State = HAL_IRDA_STATE_BUSY_TX;
mbed_official	376:cb4d9db17537	1327	}
mbed_official	376:cb4d9db17537	1328	else
mbed_official	376:cb4d9db17537	1329	{
mbed_official	376:cb4d9db17537	1330	/* Disable the IRDA Parity Error Interrupt */
mbed_official	376:cb4d9db17537	1331	__HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_PE);
mbed_official	376:cb4d9db17537	1332
mbed_official	376:cb4d9db17537	1333	/* Disable the IRDA Error Interrupt: (Frame error, noise error, overrun error) */
mbed_official	376:cb4d9db17537	1334	__HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_ERR);
mbed_official	376:cb4d9db17537	1335
mbed_official	376:cb4d9db17537	1336	hirda->State = HAL_IRDA_STATE_READY;
mbed_official	376:cb4d9db17537	1337	}
mbed_official	376:cb4d9db17537	1338
mbed_official	376:cb4d9db17537	1339	HAL_IRDA_RxCpltCallback(hirda);
mbed_official	376:cb4d9db17537	1340
mbed_official	376:cb4d9db17537	1341	return HAL_OK;
mbed_official	376:cb4d9db17537	1342	}
mbed_official	376:cb4d9db17537	1343
mbed_official	376:cb4d9db17537	1344	return HAL_OK;
mbed_official	376:cb4d9db17537	1345	}
mbed_official	376:cb4d9db17537	1346	else
mbed_official	376:cb4d9db17537	1347	{
mbed_official	376:cb4d9db17537	1348	return HAL_BUSY;
mbed_official	376:cb4d9db17537	1349	}
mbed_official	376:cb4d9db17537	1350	}
mbed_official	376:cb4d9db17537	1351
mbed_official	376:cb4d9db17537	1352	/**
mbed_official	376:cb4d9db17537	1353	* @brief DMA IRDA Tx transfer completed callback
mbed_official	376:cb4d9db17537	1354	* @param hdma: DMA handle
mbed_official	376:cb4d9db17537	1355	* @retval None
mbed_official	376:cb4d9db17537	1356	*/
mbed_official	376:cb4d9db17537	1357	static void IRDA_DMATransmitCplt(DMA_HandleTypeDef *hdma)
mbed_official	376:cb4d9db17537	1358	{
mbed_official	376:cb4d9db17537	1359	IRDA_HandleTypeDef* hirda = ( IRDA_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official	490:119543c9f674	1360
mbed_official	376:cb4d9db17537	1361	/* DMA Normal mode */
mbed_official	490:119543c9f674	1362	if ( HAL_IS_BIT_CLR(hdma->Instance->CCR, DMA_CCR_CIRC) )
mbed_official	376:cb4d9db17537	1363	{
mbed_official	376:cb4d9db17537	1364	hirda->TxXferCount = 0;
mbed_official	490:119543c9f674	1365
mbed_official	490:119543c9f674	1366	/* Disable the DMA transfer for transmit request by resetting the DMAT bit
mbed_official	490:119543c9f674	1367	in the IRDA CR3 register */
mbed_official	490:119543c9f674	1368	hirda->Instance->CR3 &= ~(USART_CR3_DMAT);
mbed_official	490:119543c9f674	1369
mbed_official	490:119543c9f674	1370	/* Enable the IRDA Transmit Complete Interrupt */
mbed_official	490:119543c9f674	1371	__HAL_IRDA_ENABLE_IT(hirda, IRDA_IT_TC);
mbed_official	376:cb4d9db17537	1372	}
mbed_official	376:cb4d9db17537	1373	/* DMA Circular mode */
mbed_official	376:cb4d9db17537	1374	else
mbed_official	376:cb4d9db17537	1375	{
mbed_official	376:cb4d9db17537	1376	HAL_IRDA_TxCpltCallback(hirda);
mbed_official	376:cb4d9db17537	1377	}
mbed_official	376:cb4d9db17537	1378	}
mbed_official	376:cb4d9db17537	1379
mbed_official	376:cb4d9db17537	1380	/**
mbed_official	376:cb4d9db17537	1381	* @brief DMA IRDA receive process half complete callback
mbed_official	376:cb4d9db17537	1382	* @param hdma: pointer to a DMA_HandleTypeDef structure that contains
mbed_official	376:cb4d9db17537	1383	* the configuration information for the specified DMA module.
mbed_official	376:cb4d9db17537	1384	* @retval None
mbed_official	376:cb4d9db17537	1385	*/
mbed_official	376:cb4d9db17537	1386	static void IRDA_DMATransmitHalfCplt(DMA_HandleTypeDef *hdma)
mbed_official	376:cb4d9db17537	1387	{
mbed_official	376:cb4d9db17537	1388	IRDA_HandleTypeDef* hirda = ( IRDA_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official	376:cb4d9db17537	1389
mbed_official	376:cb4d9db17537	1390	HAL_IRDA_TxHalfCpltCallback(hirda);
mbed_official	376:cb4d9db17537	1391	}
mbed_official	376:cb4d9db17537	1392
mbed_official	376:cb4d9db17537	1393	/**
mbed_official	376:cb4d9db17537	1394	* @brief DMA IRDA Rx Transfer completed callback
mbed_official	376:cb4d9db17537	1395	* @param hdma: DMA handle
mbed_official	376:cb4d9db17537	1396	* @retval None
mbed_official	376:cb4d9db17537	1397	*/
mbed_official	376:cb4d9db17537	1398	static void IRDA_DMAReceiveCplt(DMA_HandleTypeDef *hdma)
mbed_official	376:cb4d9db17537	1399	{
mbed_official	376:cb4d9db17537	1400	IRDA_HandleTypeDef* hirda = ( IRDA_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official	376:cb4d9db17537	1401	/* DMA Normal mode */
mbed_official	376:cb4d9db17537	1402	if((hdma->Instance->CCR & DMA_CCR_CIRC) == 0)
mbed_official	376:cb4d9db17537	1403	{
mbed_official	376:cb4d9db17537	1404	hirda->RxXferCount = 0;
mbed_official	376:cb4d9db17537	1405
mbed_official	376:cb4d9db17537	1406	/* Disable the DMA transfer for the receiver request by setting the DMAR bit
mbed_official	376:cb4d9db17537	1407	in the IRDA CR3 register */
mbed_official	376:cb4d9db17537	1408	hirda->Instance->CR3 &= (uint16_t)~((uint16_t)USART_CR3_DMAR);
mbed_official	376:cb4d9db17537	1409
mbed_official	376:cb4d9db17537	1410	if(hirda->State == HAL_IRDA_STATE_BUSY_TX_RX)
mbed_official	376:cb4d9db17537	1411	{
mbed_official	376:cb4d9db17537	1412	hirda->State = HAL_IRDA_STATE_BUSY_TX;
mbed_official	376:cb4d9db17537	1413	}
mbed_official	376:cb4d9db17537	1414	else
mbed_official	376:cb4d9db17537	1415	{
mbed_official	376:cb4d9db17537	1416	hirda->State = HAL_IRDA_STATE_READY;
mbed_official	376:cb4d9db17537	1417	}
mbed_official	376:cb4d9db17537	1418	}
mbed_official	376:cb4d9db17537	1419
mbed_official	376:cb4d9db17537	1420	HAL_IRDA_RxCpltCallback(hirda);
mbed_official	376:cb4d9db17537	1421	}
mbed_official	376:cb4d9db17537	1422
mbed_official	376:cb4d9db17537	1423	/**
mbed_official	376:cb4d9db17537	1424	* @brief DMA IRDA receive process half complete callback
mbed_official	376:cb4d9db17537	1425	* @param hdma: pointer to a DMA_HandleTypeDef structure that contains
mbed_official	376:cb4d9db17537	1426	* the configuration information for the specified DMA module.
mbed_official	376:cb4d9db17537	1427	* @retval None
mbed_official	376:cb4d9db17537	1428	*/
mbed_official	376:cb4d9db17537	1429	static void IRDA_DMAReceiveHalfCplt(DMA_HandleTypeDef *hdma)
mbed_official	376:cb4d9db17537	1430	{
mbed_official	376:cb4d9db17537	1431	IRDA_HandleTypeDef* hirda = ( IRDA_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official	376:cb4d9db17537	1432
mbed_official	376:cb4d9db17537	1433	HAL_IRDA_RxHalfCpltCallback(hirda);
mbed_official	376:cb4d9db17537	1434	}
mbed_official	376:cb4d9db17537	1435
mbed_official	376:cb4d9db17537	1436	/**
mbed_official	376:cb4d9db17537	1437	* @brief DMA IRDA communication error callback
mbed_official	376:cb4d9db17537	1438	* @param hdma: DMA handle
mbed_official	376:cb4d9db17537	1439	* @retval None
mbed_official	376:cb4d9db17537	1440	*/
mbed_official	376:cb4d9db17537	1441	static void IRDA_DMAError(DMA_HandleTypeDef *hdma)
mbed_official	376:cb4d9db17537	1442	{
mbed_official	376:cb4d9db17537	1443	IRDA_HandleTypeDef* hirda = ( IRDA_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official	376:cb4d9db17537	1444	hirda->RxXferCount = 0;
mbed_official	376:cb4d9db17537	1445	hirda->TxXferCount = 0;
mbed_official	376:cb4d9db17537	1446	hirda->State= HAL_IRDA_STATE_READY;
mbed_official	376:cb4d9db17537	1447	hirda->ErrorCode \|= HAL_IRDA_ERROR_DMA;
mbed_official	376:cb4d9db17537	1448	HAL_IRDA_ErrorCallback(hirda);
mbed_official	376:cb4d9db17537	1449	}
mbed_official	376:cb4d9db17537	1450
mbed_official	376:cb4d9db17537	1451	/**
mbed_official	376:cb4d9db17537	1452	* @}
mbed_official	376:cb4d9db17537	1453	*/
mbed_official	376:cb4d9db17537	1454
mbed_official	376:cb4d9db17537	1455	#endif /* HAL_IRDA_MODULE_ENABLED */
mbed_official	376:cb4d9db17537	1456	/**
mbed_official	376:cb4d9db17537	1457	* @}
mbed_official	376:cb4d9db17537	1458	*/
mbed_official	376:cb4d9db17537	1459
mbed_official	376:cb4d9db17537	1460	/**
mbed_official	376:cb4d9db17537	1461	* @}
mbed_official	376:cb4d9db17537	1462	*/
mbed_official	376:cb4d9db17537	1463
mbed_official	376:cb4d9db17537	1464	/********************** (C) COPYRIGHT STMicroelectronics *END OF FILE**/
mbed_official	490:119543c9f674	1465

Repository toolbox

Export to desktop IDE

Repository details

Type:	Library
Created:	23 Nov 2016
Imports:	0
Forks:	0
Commits:	637
Dependents:	0
Dependencies:	0
Followers:	1

targets/cmsis/TARGET_STM/TARGET_STM32L0/stm32l0xx_hal_irda.c@636:a11c0372f0ba, 2015-09-30 (annotated)

Who changed what in which revision?

Repository toolbox

Repository details

Important Information for this Arm website

Access Warning