WebSVN – LedShow – Blame – /trunk/Drivers/STM32F1xx_HAL_Driver/Inc/stm32f1xx_hal_irda.h

Rev	Author	Line No.	Line
2	mjames	1	/**
		2	******************************************************************************
		3	* @file stm32f1xx_hal_irda.h
		4	* @author MCD Application Team
		5	* @brief Header file of IRDA HAL module.
		6	******************************************************************************
		7	* @attention
		8	*
9	mjames	9	* <h2><center>© Copyright (c) 2016 STMicroelectronics.
		10	* All rights reserved.</center></h2>
2	mjames	11	*
9	mjames	12	* This software component is licensed by ST under BSD 3-Clause license,
		13	* the "License"; You may not use this file except in compliance with the
		14	* License. You may obtain a copy of the License at:
		15	* opensource.org/licenses/BSD-3-Clause
2	mjames	16	*
		17	******************************************************************************
		18	*/
		19
		20	/* Define to prevent recursive inclusion -------------------------------------*/
		21	#ifndef __STM32F1xx_HAL_IRDA_H
		22	#define __STM32F1xx_HAL_IRDA_H
		23
		24	#ifdef __cplusplus
9	mjames	25	extern "C" {
2	mjames	26	#endif
		27
		28	/* Includes ------------------------------------------------------------------*/
		29	#include "stm32f1xx_hal_def.h"
		30
		31	/** @addtogroup STM32F1xx_HAL_Driver
		32	* @{
		33	*/
		34
		35	/** @addtogroup IRDA
		36	* @{
		37	*/
		38
9	mjames	39	/* Exported types ------------------------------------------------------------*/
2	mjames	40	/** @defgroup IRDA_Exported_Types IRDA Exported Types
		41	* @{
		42	*/
		43	/**
		44	* @brief IRDA Init Structure definition
		45	*/
		46	typedef struct
		47	{
		48	uint32_t BaudRate; /*!< This member configures the IRDA communication baud rate.
		49	The baud rate is computed using the following formula:
		50	- IntegerDivider = ((PCLKx) / (16 * (hirda->Init.BaudRate)))
		51	- FractionalDivider = ((IntegerDivider - ((uint32_t) IntegerDivider)) * 16) + 0.5 */
		52
		53	uint32_t WordLength; /*!< Specifies the number of data bits transmitted or received in a frame.
		54	This parameter can be a value of @ref IRDA_Word_Length */
		55
		56	uint32_t Parity; /*!< Specifies the parity mode.
		57	This parameter can be a value of @ref IRDA_Parity
		58	@note When parity is enabled, the computed parity is inserted
		59	at the MSB position of the transmitted data (9th bit when
		60	the word length is set to 9 data bits; 8th bit when the
		61	word length is set to 8 data bits). */
		62
		63	uint32_t Mode; /*!< Specifies whether the Receive or Transmit mode is enabled or disabled.
9	mjames	64	This parameter can be a value of @ref IRDA_Mode */
		65
		66	uint8_t Prescaler; /*!< Specifies the Prescaler value to be programmed
2	mjames	67	in the IrDA low-power Baud Register, for defining pulse width on which
9	mjames	68	burst acceptance/rejection will be decided. This value is used as divisor
2	mjames	69	of system clock to achieve required pulse width. */
9	mjames	70
2	mjames	71	uint32_t IrDAMode; /*!< Specifies the IrDA mode
		72	This parameter can be a value of @ref IRDA_Low_Power */
9	mjames	73	} IRDA_InitTypeDef;
2	mjames	74
9	mjames	75	/**
2	mjames	76	* @brief HAL IRDA State structures definition
		77	* @note HAL IRDA State value is a combination of 2 different substates: gState and RxState.
9	mjames	78	* - gState contains IRDA state information related to global Handle management
2	mjames	79	* and also information related to Tx operations.
		80	* gState value coding follow below described bitmap :
9	mjames	81	* b7-b6 Error information
2	mjames	82	* 00 : No Error
		83	* 01 : (Not Used)
		84	* 10 : Timeout
		85	* 11 : Error
		86	* b5 IP initilisation status
		87	* 0 : Reset (IP not initialized)
		88	* 1 : Init done (IP not initialized. HAL IRDA Init function already called)
		89	* b4-b3 (not used)
		90	* xx : Should be set to 00
		91	* b2 Intrinsic process state
		92	* 0 : Ready
		93	* 1 : Busy (IP busy with some configuration or internal operations)
		94	* b1 (not used)
		95	* x : Should be set to 0
		96	* b0 Tx state
		97	* 0 : Ready (no Tx operation ongoing)
		98	* 1 : Busy (Tx operation ongoing)
		99	* - RxState contains information related to Rx operations.
		100	* RxState value coding follow below described bitmap :
		101	* b7-b6 (not used)
		102	* xx : Should be set to 00
		103	* b5 IP initilisation status
		104	* 0 : Reset (IP not initialized)
		105	* 1 : Init done (IP not initialized)
		106	* b4-b2 (not used)
		107	* xxx : Should be set to 000
		108	* b1 Rx state
		109	* 0 : Ready (no Rx operation ongoing)
		110	* 1 : Busy (Rx operation ongoing)
		111	* b0 (not used)
		112	* x : Should be set to 0.
9	mjames	113	*/
2	mjames	114	typedef enum
		115	{
9	mjames	116	HAL_IRDA_STATE_RESET = 0x00U, /*!< Peripheral is not yet Initialized
2	mjames	117	Value is allowed for gState and RxState */
9	mjames	118	HAL_IRDA_STATE_READY = 0x20U, /*!< Peripheral Initialized and ready for use
2	mjames	119	Value is allowed for gState and RxState */
9	mjames	120	HAL_IRDA_STATE_BUSY = 0x24U, /*!< An internal process is ongoing
2	mjames	121	Value is allowed for gState only */
9	mjames	122	HAL_IRDA_STATE_BUSY_TX = 0x21U, /*!< Data Transmission process is ongoing
2	mjames	123	Value is allowed for gState only */
9	mjames	124	HAL_IRDA_STATE_BUSY_RX = 0x22U, /*!< Data Reception process is ongoing
2	mjames	125	Value is allowed for RxState only */
9	mjames	126	HAL_IRDA_STATE_BUSY_TX_RX = 0x23U, /*!< Data Transmission and Reception process is ongoing
2	mjames	127	Not to be used for neither gState nor RxState.
		128	Value is result of combination (Or) between gState and RxState values */
9	mjames	129	HAL_IRDA_STATE_TIMEOUT = 0xA0U, /*!< Timeout state
2	mjames	130	Value is allowed for gState only */
9	mjames	131	HAL_IRDA_STATE_ERROR = 0xE0U /*!< Error
2	mjames	132	Value is allowed for gState only */
9	mjames	133	} HAL_IRDA_StateTypeDef;
2	mjames	134
9	mjames	135	/**
		136	* @brief IRDA handle Structure definition
		137	*/
		138	#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
		139	typedef struct __IRDA_HandleTypeDef
		140	#else
2	mjames	141	typedef struct
9	mjames	142	#endif /* USE_HAL_IRDA_REGISTER_CALLBACKS */
2	mjames	143	{
9	mjames	144	USART_TypeDef Instance; /!< USART registers base address */
2	mjames	145
9	mjames	146	IRDA_InitTypeDef Init; /!< IRDA communication parameters /
2	mjames	147
9	mjames	148	uint8_t pTxBuffPtr; /!< Pointer to IRDA Tx transfer Buffer */
2	mjames	149
9	mjames	150	uint16_t TxXferSize; /!< IRDA Tx Transfer size /
2	mjames	151
9	mjames	152	__IO uint16_t TxXferCount; /!< IRDA Tx Transfer Counter /
2	mjames	153
9	mjames	154	uint8_t pRxBuffPtr; /!< Pointer to IRDA Rx transfer Buffer */
2	mjames	155
9	mjames	156	uint16_t RxXferSize; /!< IRDA Rx Transfer size /
2	mjames	157
9	mjames	158	__IO uint16_t RxXferCount; /!< IRDA Rx Transfer Counter /
2	mjames	159
9	mjames	160	DMA_HandleTypeDef hdmatx; /!< IRDA Tx DMA Handle parameters */
2	mjames	161
9	mjames	162	DMA_HandleTypeDef hdmarx; /!< IRDA Rx DMA Handle parameters */
2	mjames	163
9	mjames	164	HAL_LockTypeDef Lock; /!< Locking object /
2	mjames	165
9	mjames	166	__IO HAL_IRDA_StateTypeDef gState; /*!< IRDA state information related to global Handle management
2	mjames	167	and also related to Tx operations.
		168	This parameter can be a value of @ref HAL_IRDA_StateTypeDef */
		169
9	mjames	170	__IO HAL_IRDA_StateTypeDef RxState; /*!< IRDA state information related to Rx operations.
2	mjames	171	This parameter can be a value of @ref HAL_IRDA_StateTypeDef */
		172
		173	__IO uint32_t ErrorCode; /!< IRDA Error code /
		174
9	mjames	175	#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
		176	void (* TxHalfCpltCallback)(struct __IRDA_HandleTypeDef hirda); /!< IRDA Tx Half Complete Callback */
		177
		178	void (* TxCpltCallback)(struct __IRDA_HandleTypeDef hirda); /!< IRDA Tx Complete Callback */
		179
		180	void (* RxHalfCpltCallback)(struct __IRDA_HandleTypeDef hirda); /!< IRDA Rx Half Complete Callback */
		181
		182	void (* RxCpltCallback)(struct __IRDA_HandleTypeDef hirda); /!< IRDA Rx Complete Callback */
		183
		184	void (* ErrorCallback)(struct __IRDA_HandleTypeDef hirda); /!< IRDA Error Callback */
		185
		186	void (* AbortCpltCallback)(struct __IRDA_HandleTypeDef hirda); /!< IRDA Abort Complete Callback */
		187
		188	void (* AbortTransmitCpltCallback)(struct __IRDA_HandleTypeDef hirda); /!< IRDA Abort Transmit Complete Callback */
		189
		190	void (* AbortReceiveCpltCallback)(struct __IRDA_HandleTypeDef hirda); /!< IRDA Abort Receive Complete Callback */
		191
		192
		193	void (* MspInitCallback)(struct __IRDA_HandleTypeDef hirda); /!< IRDA Msp Init callback */
		194
		195	void (* MspDeInitCallback)(struct __IRDA_HandleTypeDef hirda); /!< IRDA Msp DeInit callback */
		196	#endif /* USE_HAL_IRDA_REGISTER_CALLBACKS */
		197
		198	} IRDA_HandleTypeDef;
		199
		200	#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
2	mjames	201	/**
9	mjames	202	* @brief HAL IRDA Callback ID enumeration definition
		203	*/
		204	typedef enum
		205	{
		206	HAL_IRDA_TX_HALFCOMPLETE_CB_ID = 0x00U, /!< IRDA Tx Half Complete Callback ID /
		207	HAL_IRDA_TX_COMPLETE_CB_ID = 0x01U, /!< IRDA Tx Complete Callback ID /
		208	HAL_IRDA_RX_HALFCOMPLETE_CB_ID = 0x02U, /!< IRDA Rx Half Complete Callback ID /
		209	HAL_IRDA_RX_COMPLETE_CB_ID = 0x03U, /!< IRDA Rx Complete Callback ID /
		210	HAL_IRDA_ERROR_CB_ID = 0x04U, /!< IRDA Error Callback ID /
		211	HAL_IRDA_ABORT_COMPLETE_CB_ID = 0x05U, /!< IRDA Abort Complete Callback ID /
		212	HAL_IRDA_ABORT_TRANSMIT_COMPLETE_CB_ID = 0x06U, /!< IRDA Abort Transmit Complete Callback ID /
		213	HAL_IRDA_ABORT_RECEIVE_COMPLETE_CB_ID = 0x07U, /!< IRDA Abort Receive Complete Callback ID /
		214
		215	HAL_IRDA_MSPINIT_CB_ID = 0x08U, /!< IRDA MspInit callback ID /
		216	HAL_IRDA_MSPDEINIT_CB_ID = 0x09U /!< IRDA MspDeInit callback ID /
		217
		218	} HAL_IRDA_CallbackIDTypeDef;
		219
		220	/**
		221	* @brief HAL IRDA Callback pointer definition
		222	*/
		223	typedef void (pIRDA_CallbackTypeDef)(IRDA_HandleTypeDef hirda); /!< pointer to an IRDA callback function /
		224
		225	#endif /* USE_HAL_IRDA_REGISTER_CALLBACKS */
		226
		227	/**
2	mjames	228	* @}
		229	*/
		230
		231	/* Exported constants --------------------------------------------------------*/
		232	/** @defgroup IRDA_Exported_Constants IRDA Exported constants
		233	* @{
		234	*/
		235	/** @defgroup IRDA_Error_Code IRDA Error Code
		236	* @{
9	mjames	237	*/
		238	#define HAL_IRDA_ERROR_NONE 0x00000000U /!< No error /
		239	#define HAL_IRDA_ERROR_PE 0x00000001U /!< Parity error /
		240	#define HAL_IRDA_ERROR_NE 0x00000002U /!< Noise error /
		241	#define HAL_IRDA_ERROR_FE 0x00000004U /!< Frame error /
		242	#define HAL_IRDA_ERROR_ORE 0x00000008U /!< Overrun error /
		243	#define HAL_IRDA_ERROR_DMA 0x00000010U /!< DMA transfer error /
		244	#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
		245	#define HAL_IRDA_ERROR_INVALID_CALLBACK ((uint32_t)0x00000020U) /!< Invalid Callback error /
		246	#endif /* USE_HAL_IRDA_REGISTER_CALLBACKS */
2	mjames	247	/**
		248	* @}
		249	*/
		250
		251	/** @defgroup IRDA_Word_Length IRDA Word Length
		252	* @{
		253	*/
9	mjames	254	#define IRDA_WORDLENGTH_8B 0x00000000U
		255	#define IRDA_WORDLENGTH_9B ((uint32_t)USART_CR1_M)
2	mjames	256	/**
		257	* @}
		258	*/
		259
9	mjames	260	/** @defgroup IRDA_Parity IRDA Parity
2	mjames	261	* @{
9	mjames	262	*/
		263	#define IRDA_PARITY_NONE 0x00000000U
		264	#define IRDA_PARITY_EVEN ((uint32_t)USART_CR1_PCE)
		265	#define IRDA_PARITY_ODD ((uint32_t)(USART_CR1_PCE \| USART_CR1_PS))
2	mjames	266	/**
		267	* @}
9	mjames	268	*/
2	mjames	269
9	mjames	270	/** @defgroup IRDA_Mode IRDA Transfer Mode
2	mjames	271	* @{
9	mjames	272	*/
		273	#define IRDA_MODE_RX ((uint32_t)USART_CR1_RE)
		274	#define IRDA_MODE_TX ((uint32_t)USART_CR1_TE)
		275	#define IRDA_MODE_TX_RX ((uint32_t)(USART_CR1_TE \|USART_CR1_RE))
2	mjames	276	/**
		277	* @}
		278	*/
		279
		280	/** @defgroup IRDA_Low_Power IRDA Low Power
		281	* @{
		282	*/
9	mjames	283	#define IRDA_POWERMODE_LOWPOWER ((uint32_t)USART_CR3_IRLP)
		284	#define IRDA_POWERMODE_NORMAL 0x00000000U
2	mjames	285	/**
		286	* @}
		287	*/
		288
		289	/** @defgroup IRDA_Flags IRDA Flags
		290	* Elements values convention: 0xXXXX
		291	* - 0xXXXX : Flag mask in the SR register
		292	* @{
		293	*/
9	mjames	294	#define IRDA_FLAG_TXE ((uint32_t)USART_SR_TXE)
		295	#define IRDA_FLAG_TC ((uint32_t)USART_SR_TC)
		296	#define IRDA_FLAG_RXNE ((uint32_t)USART_SR_RXNE)
		297	#define IRDA_FLAG_IDLE ((uint32_t)USART_SR_IDLE)
		298	#define IRDA_FLAG_ORE ((uint32_t)USART_SR_ORE)
		299	#define IRDA_FLAG_NE ((uint32_t)USART_SR_NE)
		300	#define IRDA_FLAG_FE ((uint32_t)USART_SR_FE)
		301	#define IRDA_FLAG_PE ((uint32_t)USART_SR_PE)
2	mjames	302	/**
		303	* @}
		304	*/
		305
		306	/** @defgroup IRDA_Interrupt_definition IRDA Interrupt Definitions
		307	* Elements values convention: 0xY000XXXX
		308	* - XXXX : Interrupt mask in the XX register
		309	* - Y : Interrupt source register (2bits)
		310	* - 01: CR1 register
		311	* - 10: CR2 register
		312	* - 11: CR3 register
		313	* @{
		314	*/
9	mjames	315	#define IRDA_IT_PE ((uint32_t)(IRDA_CR1_REG_INDEX << 28U \| USART_CR1_PEIE))
		316	#define IRDA_IT_TXE ((uint32_t)(IRDA_CR1_REG_INDEX << 28U \| USART_CR1_TXEIE))
		317	#define IRDA_IT_TC ((uint32_t)(IRDA_CR1_REG_INDEX << 28U \| USART_CR1_TCIE))
		318	#define IRDA_IT_RXNE ((uint32_t)(IRDA_CR1_REG_INDEX << 28U \| USART_CR1_RXNEIE))
		319	#define IRDA_IT_IDLE ((uint32_t)(IRDA_CR1_REG_INDEX << 28U \| USART_CR1_IDLEIE))
2	mjames	320
9	mjames	321	#define IRDA_IT_LBD ((uint32_t)(IRDA_CR2_REG_INDEX << 28U \| USART_CR2_LBDIE))
2	mjames	322
9	mjames	323	#define IRDA_IT_CTS ((uint32_t)(IRDA_CR3_REG_INDEX << 28U \| USART_CR3_CTSIE))
		324	#define IRDA_IT_ERR ((uint32_t)(IRDA_CR3_REG_INDEX << 28U \| USART_CR3_EIE))
2	mjames	325	/**
		326	* @}
		327	*/
		328
		329	/**
		330	* @}
		331	*/
		332
		333	/* Exported macro ------------------------------------------------------------*/
		334	/** @defgroup IRDA_Exported_Macros IRDA Exported Macros
		335	* @{
		336	*/
		337
		338	/** @brief Reset IRDA handle gstate & RxState
9	mjames	339	* @param __HANDLE__ specifies the IRDA Handle.
		340	* IRDA Handle selects the USARTx or UARTy peripheral
2	mjames	341	* (USART,UART availability and x,y values depending on device).
9	mjames	342	* @retval None
2	mjames	343	*/
9	mjames	344	#if USE_HAL_IRDA_REGISTER_CALLBACKS == 1
2	mjames	345	#define __HAL_IRDA_RESET_HANDLE_STATE(__HANDLE__) do{ \
		346	(__HANDLE__)->gState = HAL_IRDA_STATE_RESET; \
		347	(__HANDLE__)->RxState = HAL_IRDA_STATE_RESET; \
9	mjames	348	(__HANDLE__)->MspInitCallback = NULL; \
		349	(__HANDLE__)->MspDeInitCallback = NULL; \
2	mjames	350	} while(0U)
9	mjames	351	#else
		352	#define __HAL_IRDA_RESET_HANDLE_STATE(__HANDLE__) do{ \
		353	(__HANDLE__)->gState = HAL_IRDA_STATE_RESET; \
		354	(__HANDLE__)->RxState = HAL_IRDA_STATE_RESET; \
		355	} while(0U)
		356	#endif /USE_HAL_IRDA_REGISTER_CALLBACKS /
2	mjames	357
9	mjames	358	/** @brief Flush the IRDA DR register
		359	* @param __HANDLE__ specifies the IRDA Handle.
		360	* IRDA Handle selects the USARTx or UARTy peripheral
2	mjames	361	* (USART,UART availability and x,y values depending on device).
9	mjames	362	* @retval None
2	mjames	363	*/
		364	#define __HAL_IRDA_FLUSH_DRREGISTER(__HANDLE__) ((__HANDLE__)->Instance->DR)
		365
		366	/** @brief Check whether the specified IRDA flag is set or not.
9	mjames	367	* @param __HANDLE__ specifies the IRDA Handle.
		368	* IRDA Handle selects the USARTx or UARTy peripheral
2	mjames	369	* (USART,UART availability and x,y values depending on device).
9	mjames	370	* @param __FLAG__ specifies the flag to check.
2	mjames	371	* This parameter can be one of the following values:
		372	* @arg IRDA_FLAG_TXE: Transmit data register empty flag
		373	* @arg IRDA_FLAG_TC: Transmission Complete flag
		374	* @arg IRDA_FLAG_RXNE: Receive data register not empty flag
		375	* @arg IRDA_FLAG_IDLE: Idle Line detection flag
		376	* @arg IRDA_FLAG_ORE: OverRun Error flag
		377	* @arg IRDA_FLAG_NE: Noise Error flag
		378	* @arg IRDA_FLAG_FE: Framing Error flag
		379	* @arg IRDA_FLAG_PE: Parity Error flag
		380	* @retval The new state of __FLAG__ (TRUE or FALSE).
		381	*/
		382	#define __HAL_IRDA_GET_FLAG(__HANDLE__, __FLAG__) (((__HANDLE__)->Instance->SR & (__FLAG__)) == (__FLAG__))
		383
		384	/** @brief Clear the specified IRDA pending flag.
9	mjames	385	* @param __HANDLE__ specifies the IRDA Handle.
		386	* IRDA Handle selects the USARTx or UARTy peripheral
2	mjames	387	* (USART,UART availability and x,y values depending on device).
9	mjames	388	* @param __FLAG__ specifies the flag to check.
2	mjames	389	* This parameter can be any combination of the following values:
		390	* @arg IRDA_FLAG_TC: Transmission Complete flag.
		391	* @arg IRDA_FLAG_RXNE: Receive data register not empty flag.
9	mjames	392	*
		393	* @note PE (Parity error), FE (Framing error), NE (Noise error), ORE (OverRun
		394	* error) and IDLE (Idle line detected) flags are cleared by software
2	mjames	395	* sequence: a read operation to USART_SR register followed by a read
		396	* operation to USART_DR register.
		397	* @note RXNE flag can be also cleared by a read to the USART_DR register.
9	mjames	398	* @note TC flag can be also cleared by software sequence: a read operation to
2	mjames	399	* USART_SR register followed by a write operation to USART_DR register.
		400	* @note TXE flag is cleared only by a write to the USART_DR register.
9	mjames	401	* @retval None
2	mjames	402	*/
		403	#define __HAL_IRDA_CLEAR_FLAG(__HANDLE__, __FLAG__) ((__HANDLE__)->Instance->SR = ~(__FLAG__))
		404
		405	/** @brief Clear the IRDA PE pending flag.
9	mjames	406	* @param __HANDLE__ specifies the IRDA Handle.
		407	* IRDA Handle selects the USARTx or UARTy peripheral
2	mjames	408	* (USART,UART availability and x,y values depending on device).
9	mjames	409	* @retval None
2	mjames	410	*/
		411	#define __HAL_IRDA_CLEAR_PEFLAG(__HANDLE__) \
9	mjames	412	do{ \
2	mjames	413	__IO uint32_t tmpreg = 0x00U; \
		414	tmpreg = (__HANDLE__)->Instance->SR; \
		415	tmpreg = (__HANDLE__)->Instance->DR; \
		416	UNUSED(tmpreg); \
		417	} while(0U)
9	mjames	418
2	mjames	419	/** @brief Clear the IRDA FE pending flag.
9	mjames	420	* @param __HANDLE__ specifies the IRDA Handle.
		421	* IRDA Handle selects the USARTx or UARTy peripheral
2	mjames	422	* (USART,UART availability and x,y values depending on device).
9	mjames	423	* @retval None
2	mjames	424	*/
		425	#define __HAL_IRDA_CLEAR_FEFLAG(__HANDLE__) __HAL_IRDA_CLEAR_PEFLAG(__HANDLE__)
		426
		427	/** @brief Clear the IRDA NE pending flag.
9	mjames	428	* @param __HANDLE__ specifies the IRDA Handle.
		429	* IRDA Handle selects the USARTx or UARTy peripheral
2	mjames	430	* (USART,UART availability and x,y values depending on device).
9	mjames	431	* @retval None
2	mjames	432	*/
		433	#define __HAL_IRDA_CLEAR_NEFLAG(__HANDLE__) __HAL_IRDA_CLEAR_PEFLAG(__HANDLE__)
		434
		435	/** @brief Clear the IRDA ORE pending flag.
9	mjames	436	* @param __HANDLE__ specifies the IRDA Handle.
		437	* IRDA Handle selects the USARTx or UARTy peripheral
2	mjames	438	* (USART,UART availability and x,y values depending on device).
9	mjames	439	* @retval None
2	mjames	440	*/
		441	#define __HAL_IRDA_CLEAR_OREFLAG(__HANDLE__) __HAL_IRDA_CLEAR_PEFLAG(__HANDLE__)
		442
		443	/** @brief Clear the IRDA IDLE pending flag.
9	mjames	444	* @param __HANDLE__ specifies the IRDA Handle.
		445	* IRDA Handle selects the USARTx or UARTy peripheral
2	mjames	446	* (USART,UART availability and x,y values depending on device).
9	mjames	447	* @retval None
2	mjames	448	*/
		449	#define __HAL_IRDA_CLEAR_IDLEFLAG(__HANDLE__) __HAL_IRDA_CLEAR_PEFLAG(__HANDLE__)
		450
		451	/** @brief Enable the specified IRDA interrupt.
9	mjames	452	* @param __HANDLE__ specifies the IRDA Handle.
		453	* IRDA Handle selects the USARTx or UARTy peripheral
2	mjames	454	* (USART,UART availability and x,y values depending on device).
9	mjames	455	* @param __INTERRUPT__ specifies the IRDA interrupt source to enable.
2	mjames	456	* This parameter can be one of the following values:
		457	* @arg IRDA_IT_TXE: Transmit Data Register empty interrupt
		458	* @arg IRDA_IT_TC: Transmission complete interrupt
		459	* @arg IRDA_IT_RXNE: Receive Data register not empty interrupt
		460	* @arg IRDA_IT_IDLE: Idle line detection interrupt
		461	* @arg IRDA_IT_PE: Parity Error interrupt
		462	* @arg IRDA_IT_ERR: Error interrupt(Frame error, noise error, overrun error)
9	mjames	463	* @retval None
2	mjames	464	*/
		465	#define __HAL_IRDA_ENABLE_IT(__HANDLE__, __INTERRUPT__) ((((__INTERRUPT__) >> 28U) == IRDA_CR1_REG_INDEX)? ((__HANDLE__)->Instance->CR1 \|= ((__INTERRUPT__) & IRDA_IT_MASK)): \
		466	(((__INTERRUPT__) >> 28U) == IRDA_CR2_REG_INDEX)? ((__HANDLE__)->Instance->CR2 \|= ((__INTERRUPT__) & IRDA_IT_MASK)): \
9	mjames	467	((__HANDLE__)->Instance->CR3 \|= ((__INTERRUPT__) & IRDA_IT_MASK)))
2	mjames	468	/** @brief Disable the specified IRDA interrupt.
9	mjames	469	* @param __HANDLE__ specifies the IRDA Handle.
		470	* IRDA Handle selects the USARTx or UARTy peripheral
2	mjames	471	* (USART,UART availability and x,y values depending on device).
9	mjames	472	* @param __INTERRUPT__ specifies the IRDA interrupt source to disable.
2	mjames	473	* This parameter can be one of the following values:
		474	* @arg IRDA_IT_TXE: Transmit Data Register empty interrupt
		475	* @arg IRDA_IT_TC: Transmission complete interrupt
		476	* @arg IRDA_IT_RXNE: Receive Data register not empty interrupt
		477	* @arg IRDA_IT_IDLE: Idle line detection interrupt
		478	* @arg IRDA_IT_PE: Parity Error interrupt
		479	* @arg IRDA_IT_ERR: Error interrupt(Frame error, noise error, overrun error)
9	mjames	480	* @retval None
2	mjames	481	*/
		482	#define __HAL_IRDA_DISABLE_IT(__HANDLE__, __INTERRUPT__) ((((__INTERRUPT__) >> 28U) == IRDA_CR1_REG_INDEX)? ((__HANDLE__)->Instance->CR1 &= ~((__INTERRUPT__) & IRDA_IT_MASK)): \
		483	(((__INTERRUPT__) >> 28U) == IRDA_CR2_REG_INDEX)? ((__HANDLE__)->Instance->CR2 &= ~((__INTERRUPT__) & IRDA_IT_MASK)): \
		484	((__HANDLE__)->Instance->CR3 &= ~ ((__INTERRUPT__) & IRDA_IT_MASK)))
9	mjames	485
2	mjames	486	/** @brief Check whether the specified IRDA interrupt has occurred or not.
9	mjames	487	* @param __HANDLE__ specifies the IRDA Handle.
		488	* IRDA Handle selects the USARTx or UARTy peripheral
2	mjames	489	* (USART,UART availability and x,y values depending on device).
9	mjames	490	* @param __IT__ specifies the IRDA interrupt source to check.
2	mjames	491	* This parameter can be one of the following values:
		492	* @arg IRDA_IT_TXE: Transmit Data Register empty interrupt
		493	* @arg IRDA_IT_TC: Transmission complete interrupt
		494	* @arg IRDA_IT_RXNE: Receive Data register not empty interrupt
		495	* @arg IRDA_IT_IDLE: Idle line detection interrupt
		496	* @arg IRDA_IT_ERR: Error interrupt
		497	* @arg IRDA_IT_PE: Parity Error interrupt
		498	* @retval The new state of __IT__ (TRUE or FALSE).
		499	*/
		500	#define __HAL_IRDA_GET_IT_SOURCE(__HANDLE__, __IT__) (((((__IT__) >> 28U) == IRDA_CR1_REG_INDEX)? (__HANDLE__)->Instance->CR1:(((((uint32_t)(__IT__)) >> 28U) == IRDA_CR2_REG_INDEX)? \
		501	(__HANDLE__)->Instance->CR2 : (__HANDLE__)->Instance->CR3)) & (((uint32_t)(__IT__)) & IRDA_IT_MASK))
		502
		503	/** @brief Enable UART/USART associated to IRDA Handle
9	mjames	504	* @param __HANDLE__ specifies the IRDA Handle.
		505	* IRDA Handle selects the USARTx or UARTy peripheral
2	mjames	506	* (USART,UART availability and x,y values depending on device).
9	mjames	507	* @retval None
2	mjames	508	*/
		509	#define __HAL_IRDA_ENABLE(__HANDLE__) (SET_BIT((__HANDLE__)->Instance->CR1, USART_CR1_UE))
		510
		511	/** @brief Disable UART/USART associated to IRDA Handle
9	mjames	512	* @param __HANDLE__ specifies the IRDA Handle.
		513	* IRDA Handle selects the USARTx or UARTy peripheral
2	mjames	514	* (USART,UART availability and x,y values depending on device).
9	mjames	515	* @retval None
2	mjames	516	*/
		517	#define __HAL_IRDA_DISABLE(__HANDLE__) (CLEAR_BIT((__HANDLE__)->Instance->CR1, USART_CR1_UE))
		518
		519	/**
		520	* @}
		521	*/
		522
		523	/* Exported functions --------------------------------------------------------*/
		524	/** @addtogroup IRDA_Exported_Functions
		525	* @{
		526	*/
9	mjames	527
2	mjames	528	/** @addtogroup IRDA_Exported_Functions_Group1
		529	* @{
		530	*/
		531	/* Initialization/de-initialization functions **********************************/
		532	HAL_StatusTypeDef HAL_IRDA_Init(IRDA_HandleTypeDef *hirda);
		533	HAL_StatusTypeDef HAL_IRDA_DeInit(IRDA_HandleTypeDef *hirda);
		534	void HAL_IRDA_MspInit(IRDA_HandleTypeDef *hirda);
		535	void HAL_IRDA_MspDeInit(IRDA_HandleTypeDef *hirda);
9	mjames	536
		537	#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
		538	/* Callbacks Register/UnRegister functions ***********************************/
		539	HAL_StatusTypeDef HAL_IRDA_RegisterCallback(IRDA_HandleTypeDef *hirda, HAL_IRDA_CallbackIDTypeDef CallbackID, pIRDA_CallbackTypeDef pCallback);
		540	HAL_StatusTypeDef HAL_IRDA_UnRegisterCallback(IRDA_HandleTypeDef *hirda, HAL_IRDA_CallbackIDTypeDef CallbackID);
		541	#endif /* USE_HAL_IRDA_REGISTER_CALLBACKS */
		542
2	mjames	543	/**
		544	* @}
		545	*/
		546
		547	/** @addtogroup IRDA_Exported_Functions_Group2
		548	* @{
		549	*/
		550	/* IO operation functions *******************************************************/
		551	HAL_StatusTypeDef HAL_IRDA_Transmit(IRDA_HandleTypeDef hirda, uint8_t pData, uint16_t Size, uint32_t Timeout);
		552	HAL_StatusTypeDef HAL_IRDA_Receive(IRDA_HandleTypeDef hirda, uint8_t pData, uint16_t Size, uint32_t Timeout);
		553	HAL_StatusTypeDef HAL_IRDA_Transmit_IT(IRDA_HandleTypeDef hirda, uint8_t pData, uint16_t Size);
		554	HAL_StatusTypeDef HAL_IRDA_Receive_IT(IRDA_HandleTypeDef hirda, uint8_t pData, uint16_t Size);
		555	HAL_StatusTypeDef HAL_IRDA_Transmit_DMA(IRDA_HandleTypeDef hirda, uint8_t pData, uint16_t Size);
		556	HAL_StatusTypeDef HAL_IRDA_Receive_DMA(IRDA_HandleTypeDef hirda, uint8_t pData, uint16_t Size);
		557	HAL_StatusTypeDef HAL_IRDA_DMAPause(IRDA_HandleTypeDef *hirda);
		558	HAL_StatusTypeDef HAL_IRDA_DMAResume(IRDA_HandleTypeDef *hirda);
		559	HAL_StatusTypeDef HAL_IRDA_DMAStop(IRDA_HandleTypeDef *hirda);
		560	/* Transfer Abort functions */
		561	HAL_StatusTypeDef HAL_IRDA_Abort(IRDA_HandleTypeDef *hirda);
		562	HAL_StatusTypeDef HAL_IRDA_AbortTransmit(IRDA_HandleTypeDef *hirda);
		563	HAL_StatusTypeDef HAL_IRDA_AbortReceive(IRDA_HandleTypeDef *hirda);
		564	HAL_StatusTypeDef HAL_IRDA_Abort_IT(IRDA_HandleTypeDef *hirda);
		565	HAL_StatusTypeDef HAL_IRDA_AbortTransmit_IT(IRDA_HandleTypeDef *hirda);
		566	HAL_StatusTypeDef HAL_IRDA_AbortReceive_IT(IRDA_HandleTypeDef *hirda);
		567
		568	void HAL_IRDA_IRQHandler(IRDA_HandleTypeDef *hirda);
		569	void HAL_IRDA_TxCpltCallback(IRDA_HandleTypeDef *hirda);
		570	void HAL_IRDA_RxCpltCallback(IRDA_HandleTypeDef *hirda);
		571	void HAL_IRDA_TxHalfCpltCallback(IRDA_HandleTypeDef *hirda);
		572	void HAL_IRDA_RxHalfCpltCallback(IRDA_HandleTypeDef *hirda);
		573	void HAL_IRDA_ErrorCallback(IRDA_HandleTypeDef *hirda);
		574	void HAL_IRDA_AbortCpltCallback(IRDA_HandleTypeDef *hirda);
		575	void HAL_IRDA_AbortTransmitCpltCallback(IRDA_HandleTypeDef *hirda);
		576	void HAL_IRDA_AbortReceiveCpltCallback(IRDA_HandleTypeDef *hirda);
		577	/**
		578	* @}
		579	*/
		580
		581	/** @addtogroup IRDA_Exported_Functions_Group3
		582	* @{
		583	*/
		584	/* Peripheral State functions **************************************************/
		585	HAL_IRDA_StateTypeDef HAL_IRDA_GetState(IRDA_HandleTypeDef *hirda);
		586	uint32_t HAL_IRDA_GetError(IRDA_HandleTypeDef *hirda);
		587	/**
		588	* @}
9	mjames	589	*/
2	mjames	590
		591	/**
		592	* @}
		593	*/
		594
		595	/* Private types -------------------------------------------------------------*/
		596	/* Private variables ---------------------------------------------------------*/
		597	/* Private constants ---------------------------------------------------------*/
		598	/** @defgroup IRDA_Private_Constants IRDA Private Constants
		599	* @{
		600	*/
		601
		602	/** @brief IRDA interruptions flag mask
9	mjames	603	*
2	mjames	604	*/
9	mjames	605	#define IRDA_IT_MASK ((uint32_t) USART_CR1_PEIE \| USART_CR1_TXEIE \| USART_CR1_TCIE \| USART_CR1_RXNEIE \| \
		606	USART_CR1_IDLEIE \| USART_CR2_LBDIE \| USART_CR3_CTSIE \| USART_CR3_EIE )
2	mjames	607
9	mjames	608	#define IRDA_CR1_REG_INDEX 1U
		609	#define IRDA_CR2_REG_INDEX 2U
		610	#define IRDA_CR3_REG_INDEX 3U
2	mjames	611	/**
		612	* @}
		613	*/
		614
		615	/* Private macros --------------------------------------------------------*/
		616	/** @defgroup IRDA_Private_Macros IRDA Private Macros
		617	* @{
		618	*/
9	mjames	619	#define IS_IRDA_WORD_LENGTH(LENGTH) (((LENGTH) == IRDA_WORDLENGTH_8B) \|\| \
		620	((LENGTH) == IRDA_WORDLENGTH_9B))
2	mjames	621
9	mjames	622	#define IS_IRDA_PARITY(PARITY) (((PARITY) == IRDA_PARITY_NONE) \|\| \
		623	((PARITY) == IRDA_PARITY_EVEN) \|\| \
		624	((PARITY) == IRDA_PARITY_ODD))
		625
		626	#define IS_IRDA_MODE(MODE) ((((MODE) & 0x0000FFF3U) == 0x00U) && ((MODE) != 0x00000000U))
		627
		628	#define IS_IRDA_POWERMODE(MODE) (((MODE) == IRDA_POWERMODE_LOWPOWER) \|\| \
		629	((MODE) == IRDA_POWERMODE_NORMAL))
		630
		631	#define IS_IRDA_BAUDRATE(BAUDRATE) ((BAUDRATE) < 115201U)
		632
		633	#define IRDA_DIV(_PCLK_, _BAUD_) (((_PCLK_)25U)/(4U(_BAUD_)))
		634
		635	#define IRDA_DIVMANT(_PCLK_, _BAUD_) (IRDA_DIV((_PCLK_), (_BAUD_))/100U)
		636
		637	#define IRDA_DIVFRAQ(_PCLK_, _BAUD_) (((IRDA_DIV((_PCLK_), (_BAUD_)) - (IRDA_DIVMANT((_PCLK_), (_BAUD_)) * 100U)) * 16U + 50U) / 100U)
		638
2	mjames	639	/* UART BRR = mantissa + overflow + fraction
		640	= (UART DIVMANT << 4) + (UART DIVFRAQ & 0xF0) + (UART DIVFRAQ & 0x0FU) */
9	mjames	641	#define IRDA_BRR(_PCLK_, _BAUD_) (((IRDA_DIVMANT((_PCLK_), (_BAUD_)) << 4U) + \
		642	(IRDA_DIVFRAQ((_PCLK_), (_BAUD_)) & 0xF0U)) + \
		643	(IRDA_DIVFRAQ((_PCLK_), (_BAUD_)) & 0x0FU))
2	mjames	644
		645	/**
		646	* @}
		647	*/
		648
		649	/* Private functions ---------------------------------------------------------*/
		650	/** @defgroup IRDA_Private_Functions IRDA Private Functions
		651	* @{
		652	*/
		653
		654	/**
		655	* @}
		656	*/
		657
		658	/**
		659	* @}
9	mjames	660	*/
2	mjames	661
		662	/**
		663	* @}
		664	*/
		665
		666	#ifdef __cplusplus
		667	}
		668	#endif
		669
		670	#endif /* __STM32F1xx_HAL_IRDA_H */
		671
		672	/********************** (C) COPYRIGHT STMicroelectronics *END OF FILE**/

Subversion Repositories LedShow

(root)/trunk/Drivers/STM32F1xx_HAL_Driver/Inc/stm32f1xx_hal_irda.h – Rev 9