STM32L4xx_HAL_Driver - L4 HAL Drivers

Senior Design: Sound Monitor » Code » STM32L4xx_HAL_Driver

Senior Design: Sound Monitor / STM32L4xx_HAL_Driver

L4 HAL Drivers

Src/stm32l4xx_hal_irda.c@0:80ee8f3b695e, 2015-11-02 (annotated)

Committer:: EricLew
Date:: Mon Nov 02 19:37:23 2015 +0000
Revision:: 0:80ee8f3b695e

Errors are with definitions of LCD and QSPI functions. I believe all .h and .c files are  uploaded, but there may need to be certain functions called.

Who changed what in which revision?

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

Repository toolbox

Export to desktop IDE

Repository details

Type:	Library
Created:	02 Nov 2015
Imports:	1072
Forks:	1
Commits:	1
Dependents:	0
Dependencies:	0
Followers:	42

Src/stm32l4xx_hal_irda.c@0:80ee8f3b695e, 2015-11-02 (annotated)

Who changed what in which revision?

Repository toolbox

Repository details

Important Information for this Arm website

Access Warning