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

Rev	Author	Line No.	Line
2	mjames	1	/**
		2	******************************************************************************
		3	* @file stm32f1xx_hal_uart.h
		4	* @author MCD Application Team
		5	* @brief Header file of UART HAL module.
		6	******************************************************************************
		7	* @attention
		8	*
		9	* <h2><center>© COPYRIGHT(c) 2016 STMicroelectronics</center></h2>
		10	*
		11	* Redistribution and use in source and binary forms, with or without modification,
		12	* are permitted provided that the following conditions are met:
		13	* 1. Redistributions of source code must retain the above copyright notice,
		14	* this list of conditions and the following disclaimer.
		15	* 2. Redistributions in binary form must reproduce the above copyright notice,
		16	* this list of conditions and the following disclaimer in the documentation
		17	* and/or other materials provided with the distribution.
		18	* 3. Neither the name of STMicroelectronics nor the names of its contributors
		19	* may be used to endorse or promote products derived from this software
		20	* without specific prior written permission.
		21	*
		22	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
		23	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
		24	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
		25	* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
		26	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
		27	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
		28	* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
		29	* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
		30	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
		31	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		32	*
		33	******************************************************************************
		34	*/
		35
		36	/* Define to prevent recursive inclusion -------------------------------------*/
		37	#ifndef __STM32F1xx_HAL_UART_H
		38	#define __STM32F1xx_HAL_UART_H
		39
		40	#ifdef __cplusplus
		41	extern "C" {
		42	#endif
		43
		44	/* Includes ------------------------------------------------------------------*/
		45	#include "stm32f1xx_hal_def.h"
		46
		47	/** @addtogroup STM32F1xx_HAL_Driver
		48	* @{
		49	*/
		50
		51	/** @addtogroup UART
		52	* @{
		53	*/
		54
		55	/* Exported types ------------------------------------------------------------*/
		56	/** @defgroup UART_Exported_Types UART Exported Types
		57	* @{
		58	*/
		59
		60	/**
		61	* @brief UART Init Structure definition
		62	*/
		63	typedef struct
		64	{
		65	uint32_t BaudRate; /*!< This member configures the UART communication baud rate.
		66	The baud rate is computed using the following formula:
		67	- IntegerDivider = ((PCLKx) / (16 * (huart->Init.BaudRate)))
		68	- FractionalDivider = ((IntegerDivider - ((uint32_t) IntegerDivider)) * 16) + 0.5 */
		69
		70	uint32_t WordLength; /*!< Specifies the number of data bits transmitted or received in a frame.
		71	This parameter can be a value of @ref UART_Word_Length */
		72
		73	uint32_t StopBits; /*!< Specifies the number of stop bits transmitted.
		74	This parameter can be a value of @ref UART_Stop_Bits */
		75
		76	uint32_t Parity; /*!< Specifies the parity mode.
		77	This parameter can be a value of @ref UART_Parity
		78	@note When parity is enabled, the computed parity is inserted
		79	at the MSB position of the transmitted data (9th bit when
		80	the word length is set to 9 data bits; 8th bit when the
		81	word length is set to 8 data bits). */
		82
		83	uint32_t Mode; /*!< Specifies whether the Receive or Transmit mode is enabled or disabled.
		84	This parameter can be a value of @ref UART_Mode */
		85
		86	uint32_t HwFlowCtl; /*!< Specifies whether the hardware flow control mode is enabled or disabled.
		87	This parameter can be a value of @ref UART_Hardware_Flow_Control */
		88
		89	uint32_t OverSampling; /*!< Specifies whether the Over sampling 8 is enabled or disabled, to achieve higher speed (up to fPCLK/8).
		90	This parameter can be a value of @ref UART_Over_Sampling. This feature is only available
		91	on STM32F100xx family, so OverSampling parameter should always be set to 16. */
		92	}UART_InitTypeDef;
		93
		94	/**
		95	* @brief HAL UART State structures definition
		96	* @note HAL UART State value is a combination of 2 different substates: gState and RxState.
		97	* - gState contains UART state information related to global Handle management
		98	* and also information related to Tx operations.
		99	* gState value coding follow below described bitmap :
		100	* b7-b6 Error information
		101	* 00 : No Error
		102	* 01 : (Not Used)
		103	* 10 : Timeout
		104	* 11 : Error
		105	* b5 IP initilisation status
		106	* 0 : Reset (IP not initialized)
		107	* 1 : Init done (IP not initialized. HAL UART Init function already called)
		108	* b4-b3 (not used)
		109	* xx : Should be set to 00
		110	* b2 Intrinsic process state
		111	* 0 : Ready
		112	* 1 : Busy (IP busy with some configuration or internal operations)
		113	* b1 (not used)
		114	* x : Should be set to 0
		115	* b0 Tx state
		116	* 0 : Ready (no Tx operation ongoing)
		117	* 1 : Busy (Tx operation ongoing)
		118	* - RxState contains information related to Rx operations.
		119	* RxState value coding follow below described bitmap :
		120	* b7-b6 (not used)
		121	* xx : Should be set to 00
		122	* b5 IP initilisation status
		123	* 0 : Reset (IP not initialized)
		124	* 1 : Init done (IP not initialized)
		125	* b4-b2 (not used)
		126	* xxx : Should be set to 000
		127	* b1 Rx state
		128	* 0 : Ready (no Rx operation ongoing)
		129	* 1 : Busy (Rx operation ongoing)
		130	* b0 (not used)
		131	* x : Should be set to 0.
		132	*/
		133	typedef enum
		134	{
		135	HAL_UART_STATE_RESET = 0x00U, /*!< Peripheral is not yet Initialized
		136	Value is allowed for gState and RxState */
		137	HAL_UART_STATE_READY = 0x20U, /*!< Peripheral Initialized and ready for use
		138	Value is allowed for gState and RxState */
		139	HAL_UART_STATE_BUSY = 0x24U, /*!< an internal process is ongoing
		140	Value is allowed for gState only */
		141	HAL_UART_STATE_BUSY_TX = 0x21U, /*!< Data Transmission process is ongoing
		142	Value is allowed for gState only */
		143	HAL_UART_STATE_BUSY_RX = 0x22U, /*!< Data Reception process is ongoing
		144	Value is allowed for RxState only */
		145	HAL_UART_STATE_BUSY_TX_RX = 0x23U, /*!< Data Transmission and Reception process is ongoing
		146	Not to be used for neither gState nor RxState.
		147	Value is result of combination (Or) between gState and RxState values */
		148	HAL_UART_STATE_TIMEOUT = 0xA0U, /*!< Timeout state
		149	Value is allowed for gState only */
		150	HAL_UART_STATE_ERROR = 0xE0U /*!< Error
		151	Value is allowed for gState only */
		152	}HAL_UART_StateTypeDef;
		153
		154	/**
		155	* @brief UART handle Structure definition
		156	*/
		157	typedef struct
		158	{
		159	USART_TypeDef Instance; /!< UART registers base address */
		160
		161	UART_InitTypeDef Init; /!< UART communication parameters /
		162
		163	uint8_t pTxBuffPtr; /!< Pointer to UART Tx transfer Buffer */
		164
		165	uint16_t TxXferSize; /!< UART Tx Transfer size /
		166
		167	__IO uint16_t TxXferCount; /!< UART Tx Transfer Counter /
		168
		169	uint8_t pRxBuffPtr; /!< Pointer to UART Rx transfer Buffer */
		170
		171	uint16_t RxXferSize; /!< UART Rx Transfer size /
		172
		173	__IO uint16_t RxXferCount; /!< UART Rx Transfer Counter /
		174
		175	DMA_HandleTypeDef hdmatx; /!< UART Tx DMA Handle parameters */
		176
		177	DMA_HandleTypeDef hdmarx; /!< UART Rx DMA Handle parameters */
		178
		179	HAL_LockTypeDef Lock; /!< Locking object /
		180
		181	__IO HAL_UART_StateTypeDef gState; /*!< UART state information related to global Handle management
		182	and also related to Tx operations.
		183	This parameter can be a value of @ref HAL_UART_StateTypeDef */
		184
		185	__IO HAL_UART_StateTypeDef RxState; /*!< UART state information related to Rx operations.
		186	This parameter can be a value of @ref HAL_UART_StateTypeDef */
		187
		188	__IO uint32_t ErrorCode; /!< UART Error code /
		189	}UART_HandleTypeDef;
		190
		191	/**
		192	* @}
		193	*/
		194
		195	/* Exported constants --------------------------------------------------------*/
		196	/** @defgroup UART_Exported_Constants UART Exported constants
		197	* @{
		198	*/
		199
		200	/** @defgroup UART_Error_Code UART Error Code
		201	* @{
		202	*/
		203	#define HAL_UART_ERROR_NONE 0x00000000U /!< No error /
		204	#define HAL_UART_ERROR_PE 0x00000001U /!< Parity error /
		205	#define HAL_UART_ERROR_NE 0x00000002U /!< Noise error /
		206	#define HAL_UART_ERROR_FE 0x00000004U /!< Frame error /
		207	#define HAL_UART_ERROR_ORE 0x00000008U /!< Overrun error /
		208	#define HAL_UART_ERROR_DMA 0x00000010U /!< DMA transfer error /
		209	/**
		210	* @}
		211	*/
		212
		213	/** @defgroup UART_Word_Length UART Word Length
		214	* @{
		215	*/
		216	#define UART_WORDLENGTH_8B 0x00000000U
		217	#define UART_WORDLENGTH_9B ((uint32_t)USART_CR1_M)
		218	/**
		219	* @}
		220	*/
		221
		222	/** @defgroup UART_Stop_Bits UART Number of Stop Bits
		223	* @{
		224	*/
		225	#define UART_STOPBITS_1 0x00000000U
		226	#define UART_STOPBITS_2 ((uint32_t)USART_CR2_STOP_1)
		227	/**
		228	* @}
		229	*/
		230
		231	/** @defgroup UART_Parity UART Parity
		232	* @{
		233	*/
		234	#define UART_PARITY_NONE 0x00000000U
		235	#define UART_PARITY_EVEN ((uint32_t)USART_CR1_PCE)
		236	#define UART_PARITY_ODD ((uint32_t)(USART_CR1_PCE \| USART_CR1_PS))
		237	/**
		238	* @}
		239	*/
		240
		241	/** @defgroup UART_Hardware_Flow_Control UART Hardware Flow Control
		242	* @{
		243	*/
		244	#define UART_HWCONTROL_NONE 0x00000000U
		245	#define UART_HWCONTROL_RTS ((uint32_t)USART_CR3_RTSE)
		246	#define UART_HWCONTROL_CTS ((uint32_t)USART_CR3_CTSE)
		247	#define UART_HWCONTROL_RTS_CTS ((uint32_t)(USART_CR3_RTSE \| USART_CR3_CTSE))
		248	/**
		249	* @}
		250	*/
		251
		252	/** @defgroup UART_Mode UART Transfer Mode
		253	* @{
		254	*/
		255	#define UART_MODE_RX ((uint32_t)USART_CR1_RE)
		256	#define UART_MODE_TX ((uint32_t)USART_CR1_TE)
		257	#define UART_MODE_TX_RX ((uint32_t)(USART_CR1_TE \|USART_CR1_RE))
		258	/**
		259	* @}
		260	*/
		261
		262	/** @defgroup UART_State UART State
		263	* @{
		264	*/
		265	#define UART_STATE_DISABLE 0x00000000U
		266	#define UART_STATE_ENABLE ((uint32_t)USART_CR1_UE)
		267	/**
		268	* @}
		269	*/
		270
		271
		272	/** @defgroup UART_Over_Sampling UART Over Sampling
		273	* @{
		274	*/
		275	#define UART_OVERSAMPLING_16 0x00000000U
		276	#if defined(USART_CR1_OVER8)
		277	#define UART_OVERSAMPLING_8 ((uint32_t)USART_CR1_OVER8)
		278	#endif /* USART_CR1_OVER8 */
		279	/**
		280	* @}
		281	*/
		282
		283
		284	/** @defgroup UART_LIN_Break_Detection_Length UART LIN Break Detection Length
		285	* @{
		286	*/
		287	#define UART_LINBREAKDETECTLENGTH_10B 0x00000000U
		288	#define UART_LINBREAKDETECTLENGTH_11B ((uint32_t)USART_CR2_LBDL)
		289	/**
		290	* @}
		291	*/
		292	/** @defgroup UART_WakeUp_functions UART Wakeup Functions
		293	* @{
		294	*/
		295	#define UART_WAKEUPMETHOD_IDLELINE 0x00000000U
		296	#define UART_WAKEUPMETHOD_ADDRESSMARK ((uint32_t)USART_CR1_WAKE)
		297	/**
		298	* @}
		299	*/
		300
		301	/** @defgroup UART_Flags UART FLags
		302	* Elements values convention: 0xXXXX
		303	* - 0xXXXX : Flag mask in the SR register
		304	* @{
		305	*/
		306	#define UART_FLAG_CTS ((uint32_t)USART_SR_CTS)
		307	#define UART_FLAG_LBD ((uint32_t)USART_SR_LBD)
		308	#define UART_FLAG_TXE ((uint32_t)USART_SR_TXE)
		309	#define UART_FLAG_TC ((uint32_t)USART_SR_TC)
		310	#define UART_FLAG_RXNE ((uint32_t)USART_SR_RXNE)
		311	#define UART_FLAG_IDLE ((uint32_t)USART_SR_IDLE)
		312	#define UART_FLAG_ORE ((uint32_t)USART_SR_ORE)
		313	#define UART_FLAG_NE ((uint32_t)USART_SR_NE)
		314	#define UART_FLAG_FE ((uint32_t)USART_SR_FE)
		315	#define UART_FLAG_PE ((uint32_t)USART_SR_PE)
		316	/**
		317	* @}
		318	*/
		319
		320	/** @defgroup UART_Interrupt_definition UART Interrupt Definitions
		321	* Elements values convention: 0xY000XXXX
		322	* - XXXX : Interrupt mask (16 bits) in the Y register
		323	* - Y : Interrupt source register (2bits)
		324	* - 01: CR1 register
		325	* - 10: CR2 register
		326	* - 11: CR3 register
		327	* @{
		328	*/
		329
		330	#define UART_IT_PE ((uint32_t)(UART_CR1_REG_INDEX << 28U \| USART_CR1_PEIE))
		331	#define UART_IT_TXE ((uint32_t)(UART_CR1_REG_INDEX << 28U \| USART_CR1_TXEIE))
		332	#define UART_IT_TC ((uint32_t)(UART_CR1_REG_INDEX << 28U \| USART_CR1_TCIE))
		333	#define UART_IT_RXNE ((uint32_t)(UART_CR1_REG_INDEX << 28U \| USART_CR1_RXNEIE))
		334	#define UART_IT_IDLE ((uint32_t)(UART_CR1_REG_INDEX << 28U \| USART_CR1_IDLEIE))
		335
		336	#define UART_IT_LBD ((uint32_t)(UART_CR2_REG_INDEX << 28U \| USART_CR2_LBDIE))
		337
		338	#define UART_IT_CTS ((uint32_t)(UART_CR3_REG_INDEX << 28U \| USART_CR3_CTSIE))
		339	#define UART_IT_ERR ((uint32_t)(UART_CR3_REG_INDEX << 28U \| USART_CR3_EIE))
		340	/**
		341	* @}
		342	*/
		343
		344	/**
		345	* @}
		346	*/
		347
		348	/* Exported macro ------------------------------------------------------------*/
		349	/** @defgroup UART_Exported_Macros UART Exported Macros
		350	* @{
		351	*/
		352
		353	/** @brief Reset UART handle gstate & RxState
		354	* @param __HANDLE__: specifies the UART Handle.
		355	* UART Handle selects the USARTx or UARTy peripheral
		356	* (USART,UART availability and x,y values depending on device).
		357	*/
		358	#define __HAL_UART_RESET_HANDLE_STATE(__HANDLE__) do{ \
		359	(__HANDLE__)->gState = HAL_UART_STATE_RESET; \
		360	(__HANDLE__)->RxState = HAL_UART_STATE_RESET; \
		361	} while(0U)
		362
		363	/** @brief Flushs the UART DR register
		364	* @param __HANDLE__: specifies the UART Handle.
		365	* UART Handle selects the USARTx or UARTy peripheral
		366	* (USART,UART availability and x,y values depending on device).
		367	*/
		368	#define __HAL_UART_FLUSH_DRREGISTER(__HANDLE__) ((__HANDLE__)->Instance->DR)
		369
		370	/** @brief Checks whether the specified UART flag is set or not.
		371	* @param __HANDLE__: specifies the UART Handle.
		372	* This parameter can be UARTx where x: 1, 2, 3, 4 or 5 to select the USART or
		373	* UART peripheral.
		374	* @param __FLAG__: specifies the flag to check.
		375	* This parameter can be one of the following values:
		376	* @arg UART_FLAG_CTS: CTS Change flag (not available for UART4 and UART5)
		377	* @arg UART_FLAG_LBD: LIN Break detection flag
		378	* @arg UART_FLAG_TXE: Transmit data register empty flag
		379	* @arg UART_FLAG_TC: Transmission Complete flag
		380	* @arg UART_FLAG_RXNE: Receive data register not empty flag
		381	* @arg UART_FLAG_IDLE: Idle Line detection flag
		382	* @arg UART_FLAG_ORE: OverRun Error flag
		383	* @arg UART_FLAG_NE: Noise Error flag
		384	* @arg UART_FLAG_FE: Framing Error flag
		385	* @arg UART_FLAG_PE: Parity Error flag
		386	* @retval The new state of __FLAG__ (TRUE or FALSE).
		387	*/
		388	#define __HAL_UART_GET_FLAG(__HANDLE__, __FLAG__) (((__HANDLE__)->Instance->SR & (__FLAG__)) == (__FLAG__))
		389
		390	/** @brief Clears the specified UART pending flag.
		391	* @param __HANDLE__: specifies the UART Handle.
		392	* UART Handle selects the USARTx or UARTy peripheral
		393	* (USART,UART availability and x,y values depending on device).
		394	* @param __FLAG__: specifies the flag to check.
		395	* This parameter can be any combination of the following values:
		396	* @arg UART_FLAG_CTS: CTS Change flag (not available for UART4 and UART5).
		397	* @arg UART_FLAG_LBD: LIN Break detection flag.
		398	* @arg UART_FLAG_TC: Transmission Complete flag.
		399	* @arg UART_FLAG_RXNE: Receive data register not empty flag.
		400	*
		401	* @note PE (Parity error), FE (Framing error), NE (Noise error), ORE (OverRun
		402	* error) and IDLE (Idle line detected) flags are cleared by software
		403	* sequence: a read operation to USART_SR register followed by a read
		404	* operation to USART_DR register.
		405	* @note RXNE flag can be also cleared by a read to the USART_DR register.
		406	* @note TC flag can be also cleared by software sequence: a read operation to
		407	* USART_SR register followed by a write operation to USART_DR register.
		408	* @note TXE flag is cleared only by a write to the USART_DR register.
		409	*
		410	*/
		411	#define __HAL_UART_CLEAR_FLAG(__HANDLE__, __FLAG__) ((__HANDLE__)->Instance->SR = ~(__FLAG__))
		412
		413	/** @brief Clears the UART PE pending flag.
		414	* @param __HANDLE__: specifies the UART Handle.
		415	* UART Handle selects the USARTx or UARTy peripheral
		416	* (USART,UART availability and x,y values depending on device).
		417	*/
		418	#define __HAL_UART_CLEAR_PEFLAG(__HANDLE__) \
		419	do{ \
		420	__IO uint32_t tmpreg = 0x00U; \
		421	tmpreg = (__HANDLE__)->Instance->SR; \
		422	tmpreg = (__HANDLE__)->Instance->DR; \
		423	UNUSED(tmpreg); \
		424	} while(0U)
		425
		426	/** @brief Clears the UART FE pending flag.
		427	* @param __HANDLE__: specifies the UART Handle.
		428	* UART Handle selects the USARTx or UARTy peripheral
		429	* (USART,UART availability and x,y values depending on device).
		430	*/
		431	#define __HAL_UART_CLEAR_FEFLAG(__HANDLE__) __HAL_UART_CLEAR_PEFLAG(__HANDLE__)
		432
		433	/** @brief Clears the UART NE pending flag.
		434	* @param __HANDLE__: specifies the UART Handle.
		435	* UART Handle selects the USARTx or UARTy peripheral
		436	* (USART,UART availability and x,y values depending on device).
		437	*/
		438	#define __HAL_UART_CLEAR_NEFLAG(__HANDLE__) __HAL_UART_CLEAR_PEFLAG(__HANDLE__)
		439
		440	/** @brief Clears the UART ORE pending flag.
		441	* @param __HANDLE__: specifies the UART Handle.
		442	* UART Handle selects the USARTx or UARTy peripheral
		443	* (USART,UART availability and x,y values depending on device).
		444	*/
		445	#define __HAL_UART_CLEAR_OREFLAG(__HANDLE__) __HAL_UART_CLEAR_PEFLAG(__HANDLE__)
		446
		447	/** @brief Clears the UART IDLE pending flag.
		448	* @param __HANDLE__: specifies the UART Handle.
		449	* UART Handle selects the USARTx or UARTy peripheral
		450	* (USART,UART availability and x,y values depending on device).
		451	*/
		452	#define __HAL_UART_CLEAR_IDLEFLAG(__HANDLE__) __HAL_UART_CLEAR_PEFLAG(__HANDLE__)
		453
		454	/** @brief Enable the specified UART interrupt.
		455	* @param __HANDLE__: specifies the UART Handle.
		456	* UART Handle selects the USARTx or UARTy peripheral
		457	* (USART,UART availability and x,y values depending on device).
		458	* @param __INTERRUPT__: specifies the UART interrupt source to enable.
		459	* This parameter can be one of the following values:
		460	* @arg UART_IT_CTS: CTS change interrupt
		461	* @arg UART_IT_LBD: LIN Break detection interrupt
		462	* @arg UART_IT_TXE: Transmit Data Register empty interrupt
		463	* @arg UART_IT_TC: Transmission complete interrupt
		464	* @arg UART_IT_RXNE: Receive Data register not empty interrupt
		465	* @arg UART_IT_IDLE: Idle line detection interrupt
		466	* @arg UART_IT_PE: Parity Error interrupt
		467	* @arg UART_IT_ERR: Error interrupt(Frame error, noise error, overrun error)
		468	*/
		469	#define __HAL_UART_ENABLE_IT(__HANDLE__, __INTERRUPT__) ((((__INTERRUPT__) >> 28U) == UART_CR1_REG_INDEX)? ((__HANDLE__)->Instance->CR1 \|= ((__INTERRUPT__) & UART_IT_MASK)): \
		470	(((__INTERRUPT__) >> 28U) == UART_CR2_REG_INDEX)? ((__HANDLE__)->Instance->CR2 \|= ((__INTERRUPT__) & UART_IT_MASK)): \
		471	((__HANDLE__)->Instance->CR3 \|= ((__INTERRUPT__) & UART_IT_MASK)))
		472
		473	/** @brief Disable the specified UART interrupt.
		474	* @param __HANDLE__: specifies the UART Handle.
		475	* UART Handle selects the USARTx or UARTy peripheral
		476	* (USART,UART availability and x,y values depending on device).
		477	* @param __INTERRUPT__: specifies the UART interrupt source to disable.
		478	* This parameter can be one of the following values:
		479	* @arg UART_IT_CTS: CTS change interrupt
		480	* @arg UART_IT_LBD: LIN Break detection interrupt
		481	* @arg UART_IT_TXE: Transmit Data Register empty interrupt
		482	* @arg UART_IT_TC: Transmission complete interrupt
		483	* @arg UART_IT_RXNE: Receive Data register not empty interrupt
		484	* @arg UART_IT_IDLE: Idle line detection interrupt
		485	* @arg UART_IT_PE: Parity Error interrupt
		486	* @arg UART_IT_ERR: Error interrupt(Frame error, noise error, overrun error)
		487	*/
		488	#define __HAL_UART_DISABLE_IT(__HANDLE__, __INTERRUPT__) ((((__INTERRUPT__) >> 28U) == UART_CR1_REG_INDEX)? ((__HANDLE__)->Instance->CR1 &= ~((__INTERRUPT__) & UART_IT_MASK)): \
		489	(((__INTERRUPT__) >> 28U) == UART_CR2_REG_INDEX)? ((__HANDLE__)->Instance->CR2 &= ~((__INTERRUPT__) & UART_IT_MASK)): \
		490	((__HANDLE__)->Instance->CR3 &= ~ ((__INTERRUPT__) & UART_IT_MASK)))
		491
		492	/** @brief Checks whether the specified UART interrupt has occurred or not.
		493	* @param __HANDLE__: specifies the UART Handle.
		494	* UART Handle selects the USARTx or UARTy peripheral
		495	* (USART,UART availability and x,y values depending on device).
		496	* @param __IT__: specifies the UART interrupt source to check.
		497	* This parameter can be one of the following values:
		498	* @arg UART_IT_CTS: CTS change interrupt (not available for UART4 and UART5)
		499	* @arg UART_IT_LBD: LIN Break detection interrupt
		500	* @arg UART_IT_TXE: Transmit Data Register empty interrupt
		501	* @arg UART_IT_TC: Transmission complete interrupt
		502	* @arg UART_IT_RXNE: Receive Data register not empty interrupt
		503	* @arg UART_IT_IDLE: Idle line detection interrupt
		504	* @arg UART_IT_ERR: Error interrupt
		505	* @retval The new state of __IT__ (TRUE or FALSE).
		506	*/
		507	#define __HAL_UART_GET_IT_SOURCE(__HANDLE__, __IT__) (((((__IT__) >> 28U) == UART_CR1_REG_INDEX)? (__HANDLE__)->Instance->CR1:(((((uint32_t)(__IT__)) >> 28U) == UART_CR2_REG_INDEX)? \
		508	(__HANDLE__)->Instance->CR2 : (__HANDLE__)->Instance->CR3)) & (((uint32_t)(__IT__)) & UART_IT_MASK))
		509
		510	/** @brief Enable CTS flow control
		511	* This macro allows to enable CTS hardware flow control for a given UART instance,
		512	* without need to call HAL_UART_Init() function.
		513	* As involving direct access to UART registers, usage of this macro should be fully endorsed by user.
		514	* @note As macro is expected to be used for modifying CTS Hw flow control feature activation, without need
		515	* for USART instance Deinit/Init, following conditions for macro call should be fulfilled :
		516	* - UART instance should have already been initialised (through call of HAL_UART_Init() )
		517	* - macro could only be called when corresponding UART instance is disabled (i.e __HAL_UART_DISABLE(__HANDLE__))
		518	* and should be followed by an Enable macro (i.e __HAL_UART_ENABLE(__HANDLE__)).
		519	* @param __HANDLE__: specifies the UART Handle.
		520	* The Handle Instance can be any USARTx (supporting the HW Flow control feature).
		521	* It is used to select the USART peripheral (USART availability and x value depending on device).
		522	*/
		523	#define __HAL_UART_HWCONTROL_CTS_ENABLE(__HANDLE__) \
		524	do{ \
		525	SET_BIT((__HANDLE__)->Instance->CR3, USART_CR3_CTSE); \
		526	(__HANDLE__)->Init.HwFlowCtl \|= USART_CR3_CTSE; \
		527	} while(0U)
		528
		529	/** @brief Disable CTS flow control
		530	* This macro allows to disable CTS hardware flow control for a given UART instance,
		531	* without need to call HAL_UART_Init() function.
		532	* As involving direct access to UART registers, usage of this macro should be fully endorsed by user.
		533	* @note As macro is expected to be used for modifying CTS Hw flow control feature activation, without need
		534	* for USART instance Deinit/Init, following conditions for macro call should be fulfilled :
		535	* - UART instance should have already been initialised (through call of HAL_UART_Init() )
		536	* - macro could only be called when corresponding UART instance is disabled (i.e __HAL_UART_DISABLE(__HANDLE__))
		537	* and should be followed by an Enable macro (i.e __HAL_UART_ENABLE(__HANDLE__)).
		538	* @param __HANDLE__: specifies the UART Handle.
		539	* The Handle Instance can be any USARTx (supporting the HW Flow control feature).
		540	* It is used to select the USART peripheral (USART availability and x value depending on device).
		541	*/
		542	#define __HAL_UART_HWCONTROL_CTS_DISABLE(__HANDLE__) \
		543	do{ \
		544	CLEAR_BIT((__HANDLE__)->Instance->CR3, USART_CR3_CTSE); \
		545	(__HANDLE__)->Init.HwFlowCtl &= ~(USART_CR3_CTSE); \
		546	} while(0U)
		547
		548	/** @brief Enable RTS flow control
		549	* This macro allows to enable RTS hardware flow control for a given UART instance,
		550	* without need to call HAL_UART_Init() function.
		551	* As involving direct access to UART registers, usage of this macro should be fully endorsed by user.
		552	* @note As macro is expected to be used for modifying RTS Hw flow control feature activation, without need
		553	* for USART instance Deinit/Init, following conditions for macro call should be fulfilled :
		554	* - UART instance should have already been initialised (through call of HAL_UART_Init() )
		555	* - macro could only be called when corresponding UART instance is disabled (i.e __HAL_UART_DISABLE(__HANDLE__))
		556	* and should be followed by an Enable macro (i.e __HAL_UART_ENABLE(__HANDLE__)).
		557	* @param __HANDLE__: specifies the UART Handle.
		558	* The Handle Instance can be any USARTx (supporting the HW Flow control feature).
		559	* It is used to select the USART peripheral (USART availability and x value depending on device).
		560	*/
		561	#define __HAL_UART_HWCONTROL_RTS_ENABLE(__HANDLE__) \
		562	do{ \
		563	SET_BIT((__HANDLE__)->Instance->CR3, USART_CR3_RTSE); \
		564	(__HANDLE__)->Init.HwFlowCtl \|= USART_CR3_RTSE; \
		565	} while(0U)
		566
		567	/** @brief Disable RTS flow control
		568	* This macro allows to disable RTS hardware flow control for a given UART instance,
		569	* without need to call HAL_UART_Init() function.
		570	* As involving direct access to UART registers, usage of this macro should be fully endorsed by user.
		571	* @note As macro is expected to be used for modifying RTS Hw flow control feature activation, without need
		572	* for USART instance Deinit/Init, following conditions for macro call should be fulfilled :
		573	* - UART instance should have already been initialised (through call of HAL_UART_Init() )
		574	* - macro could only be called when corresponding UART instance is disabled (i.e __HAL_UART_DISABLE(__HANDLE__))
		575	* and should be followed by an Enable macro (i.e __HAL_UART_ENABLE(__HANDLE__)).
		576	* @param __HANDLE__: specifies the UART Handle.
		577	* The Handle Instance can be any USARTx (supporting the HW Flow control feature).
		578	* It is used to select the USART peripheral (USART availability and x value depending on device).
		579	*/
		580	#define __HAL_UART_HWCONTROL_RTS_DISABLE(__HANDLE__) \
		581	do{ \
		582	CLEAR_BIT((__HANDLE__)->Instance->CR3, USART_CR3_RTSE);\
		583	(__HANDLE__)->Init.HwFlowCtl &= ~(USART_CR3_RTSE); \
		584	} while(0U)
		585
		586	#if defined(USART_CR3_ONEBIT)
		587	/** @brief macros to enables the UART's one bit sample method
		588	* @param __HANDLE__: specifies the UART Handle.
		589	*/
		590	#define __HAL_UART_ONE_BIT_SAMPLE_ENABLE(__HANDLE__) ((__HANDLE__)->Instance->CR3\|= USART_CR3_ONEBIT)
		591
		592	/** @brief macros to disables the UART's one bit sample method
		593	* @param __HANDLE__: specifies the UART Handle.
		594	* @retval None
		595	*/
		596	#define __HAL_UART_ONE_BIT_SAMPLE_DISABLE(__HANDLE__) ((__HANDLE__)->Instance->CR3 &= (uint16_t)~((uint16_t)USART_CR3_ONEBIT))
		597	#endif /* USART_CR3_ONEBIT */
		598
		599	/** @brief Enable UART
		600	* @param __HANDLE__: specifies the UART Handle.
		601	*/
		602	#define __HAL_UART_ENABLE(__HANDLE__) ((__HANDLE__)->Instance->CR1 \|= USART_CR1_UE)
		603
		604	/** @brief Disable UART
		605	* @param __HANDLE__: specifies the UART Handle.
		606	*/
		607	#define __HAL_UART_DISABLE(__HANDLE__) ((__HANDLE__)->Instance->CR1 &= ~USART_CR1_UE)
		608	/**
		609	* @}
		610	*/
		611	/* Exported functions --------------------------------------------------------*/
		612	/** @addtogroup UART_Exported_Functions
		613	* @{
		614	*/
		615
		616	/** @addtogroup UART_Exported_Functions_Group1
		617	* @{
		618	*/
		619	/* Initialization/de-initialization functions **********************************/
		620	HAL_StatusTypeDef HAL_UART_Init(UART_HandleTypeDef *huart);
		621	HAL_StatusTypeDef HAL_HalfDuplex_Init(UART_HandleTypeDef *huart);
		622	HAL_StatusTypeDef HAL_LIN_Init(UART_HandleTypeDef *huart, uint32_t BreakDetectLength);
		623	HAL_StatusTypeDef HAL_MultiProcessor_Init(UART_HandleTypeDef *huart, uint8_t Address, uint32_t WakeUpMethod);
		624	HAL_StatusTypeDef HAL_UART_DeInit (UART_HandleTypeDef *huart);
		625	void HAL_UART_MspInit(UART_HandleTypeDef *huart);
		626	void HAL_UART_MspDeInit(UART_HandleTypeDef *huart);
		627	/**
		628	* @}
		629	*/
		630
		631	/** @addtogroup UART_Exported_Functions_Group2
		632	* @{
		633	*/
		634	/* IO operation functions *******************************************************/
		635	HAL_StatusTypeDef HAL_UART_Transmit(UART_HandleTypeDef huart, uint8_t pData, uint16_t Size, uint32_t Timeout);
		636	HAL_StatusTypeDef HAL_UART_Receive(UART_HandleTypeDef huart, uint8_t pData, uint16_t Size, uint32_t Timeout);
		637	HAL_StatusTypeDef HAL_UART_Transmit_IT(UART_HandleTypeDef huart, uint8_t pData, uint16_t Size);
		638	HAL_StatusTypeDef HAL_UART_Receive_IT(UART_HandleTypeDef huart, uint8_t pData, uint16_t Size);
		639	HAL_StatusTypeDef HAL_UART_Transmit_DMA(UART_HandleTypeDef huart, uint8_t pData, uint16_t Size);
		640	HAL_StatusTypeDef HAL_UART_Receive_DMA(UART_HandleTypeDef huart, uint8_t pData, uint16_t Size);
		641	HAL_StatusTypeDef HAL_UART_DMAPause(UART_HandleTypeDef *huart);
		642	HAL_StatusTypeDef HAL_UART_DMAResume(UART_HandleTypeDef *huart);
		643	HAL_StatusTypeDef HAL_UART_DMAStop(UART_HandleTypeDef *huart);
		644	/* Transfer Abort functions */
		645	HAL_StatusTypeDef HAL_UART_Abort(UART_HandleTypeDef *huart);
		646	HAL_StatusTypeDef HAL_UART_AbortTransmit(UART_HandleTypeDef *huart);
		647	HAL_StatusTypeDef HAL_UART_AbortReceive(UART_HandleTypeDef *huart);
		648	HAL_StatusTypeDef HAL_UART_Abort_IT(UART_HandleTypeDef *huart);
		649	HAL_StatusTypeDef HAL_UART_AbortTransmit_IT(UART_HandleTypeDef *huart);
		650	HAL_StatusTypeDef HAL_UART_AbortReceive_IT(UART_HandleTypeDef *huart);
		651
		652	void HAL_UART_IRQHandler(UART_HandleTypeDef *huart);
		653	void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart);
		654	void HAL_UART_TxHalfCpltCallback(UART_HandleTypeDef *huart);
		655	void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart);
		656	void HAL_UART_RxHalfCpltCallback(UART_HandleTypeDef *huart);
		657	void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart);
		658	void HAL_UART_AbortCpltCallback (UART_HandleTypeDef *huart);
		659	void HAL_UART_AbortTransmitCpltCallback (UART_HandleTypeDef *huart);
		660	void HAL_UART_AbortReceiveCpltCallback (UART_HandleTypeDef *huart);
		661	/**
		662	* @}
		663	*/
		664
		665	/** @addtogroup UART_Exported_Functions_Group3
		666	* @{
		667	*/
		668	/* Peripheral Control functions ************************************************/
		669	HAL_StatusTypeDef HAL_LIN_SendBreak(UART_HandleTypeDef *huart);
		670	HAL_StatusTypeDef HAL_MultiProcessor_EnterMuteMode(UART_HandleTypeDef *huart);
		671	HAL_StatusTypeDef HAL_MultiProcessor_ExitMuteMode(UART_HandleTypeDef *huart);
		672	HAL_StatusTypeDef HAL_HalfDuplex_EnableTransmitter(UART_HandleTypeDef *huart);
		673	HAL_StatusTypeDef HAL_HalfDuplex_EnableReceiver(UART_HandleTypeDef *huart);
		674	/**
		675	* @}
		676	*/
		677
		678	/** @addtogroup UART_Exported_Functions_Group4
		679	* @{
		680	*/
		681	/* Peripheral State functions **************************************************/
		682	HAL_UART_StateTypeDef HAL_UART_GetState(UART_HandleTypeDef *huart);
		683	uint32_t HAL_UART_GetError(UART_HandleTypeDef *huart);
		684	/**
		685	* @}
		686	*/
		687
		688	/**
		689	* @}
		690	*/
		691	/* Private types -------------------------------------------------------------*/
		692	/* Private variables ---------------------------------------------------------*/
		693	/* Private constants ---------------------------------------------------------*/
		694	/** @defgroup UART_Private_Constants UART Private Constants
		695	* @{
		696	*/
		697	/** @brief UART interruptions flag mask
		698	*
		699	*/
		700	#define UART_IT_MASK 0x0000FFFFU
		701
		702	#define UART_CR1_REG_INDEX 1U
		703	#define UART_CR2_REG_INDEX 2U
		704	#define UART_CR3_REG_INDEX 3U
		705	/**
		706	* @}
		707	*/
		708
		709	/* Private macros ------------------------------------------------------------*/
		710	/** @defgroup UART_Private_Macros UART Private Macros
		711	* @{
		712	*/
		713	#define IS_UART_WORD_LENGTH(LENGTH) (((LENGTH) == UART_WORDLENGTH_8B) \|\| \
		714	((LENGTH) == UART_WORDLENGTH_9B))
		715	#define IS_UART_LIN_WORD_LENGTH(LENGTH) (((LENGTH) == UART_WORDLENGTH_8B))
		716	#define IS_UART_STOPBITS(STOPBITS) (((STOPBITS) == UART_STOPBITS_1) \|\| \
		717	((STOPBITS) == UART_STOPBITS_2))
		718	#define IS_UART_PARITY(PARITY) (((PARITY) == UART_PARITY_NONE) \|\| \
		719	((PARITY) == UART_PARITY_EVEN) \|\| \
		720	((PARITY) == UART_PARITY_ODD))
		721	#define IS_UART_HARDWARE_FLOW_CONTROL(CONTROL)\
		722	(((CONTROL) == UART_HWCONTROL_NONE) \|\| \
		723	((CONTROL) == UART_HWCONTROL_RTS) \|\| \
		724	((CONTROL) == UART_HWCONTROL_CTS) \|\| \
		725	((CONTROL) == UART_HWCONTROL_RTS_CTS))
		726	#define IS_UART_MODE(MODE) ((((MODE) & 0x0000FFF3U) == 0x00U) && ((MODE) != 0x00U))
		727	#define IS_UART_STATE(STATE) (((STATE) == UART_STATE_DISABLE) \|\| \
		728	((STATE) == UART_STATE_ENABLE))
		729	#if defined(USART_CR1_OVER8)
		730	#define IS_UART_OVERSAMPLING(SAMPLING) (((SAMPLING) == UART_OVERSAMPLING_16) \|\| \
		731	((SAMPLING) == UART_OVERSAMPLING_8))
		732	#endif /* USART_CR1_OVER8 */
		733	#define IS_UART_LIN_OVERSAMPLING(SAMPLING) (((SAMPLING) == UART_OVERSAMPLING_16))
		734	#define IS_UART_LIN_BREAK_DETECT_LENGTH(LENGTH) (((LENGTH) == UART_LINBREAKDETECTLENGTH_10B) \|\| \
		735	((LENGTH) == UART_LINBREAKDETECTLENGTH_11B))
		736	#define IS_UART_WAKEUPMETHOD(WAKEUP) (((WAKEUP) == UART_WAKEUPMETHOD_IDLELINE) \|\| \
		737	((WAKEUP) == UART_WAKEUPMETHOD_ADDRESSMARK))
		738	#define IS_UART_BAUDRATE(BAUDRATE) ((BAUDRATE) < 4500001U)
		739	#define IS_UART_ADDRESS(ADDRESS) ((ADDRESS) <= 0x0FU)
		740
		741	#define UART_DIV_SAMPLING16(_PCLK_, _BAUD_) (((_PCLK_)25U)/(4U(_BAUD_)))
		742	#define UART_DIVMANT_SAMPLING16(_PCLK_, _BAUD_) (UART_DIV_SAMPLING16((_PCLK_), (_BAUD_))/100U)
		743	#define UART_DIVFRAQ_SAMPLING16(_PCLK_, _BAUD_) (((UART_DIV_SAMPLING16((_PCLK_), (_BAUD_)) - (UART_DIVMANT_SAMPLING16((_PCLK_), (_BAUD_)) * 100U)) * 16U + 50U) / 100U)
		744	/* UART BRR = mantissa + overflow + fraction
		745	= (UART DIVMANT << 4) + (UART DIVFRAQ & 0xF0) + (UART DIVFRAQ & 0x0FU) */
		746	#define UART_BRR_SAMPLING16(_PCLK_, _BAUD_) (((UART_DIVMANT_SAMPLING16((_PCLK_), (_BAUD_)) << 4U) + \
		747	(UART_DIVFRAQ_SAMPLING16((_PCLK_), (_BAUD_)) & 0xF0U)) + \
		748	(UART_DIVFRAQ_SAMPLING16((_PCLK_), (_BAUD_)) & 0x0FU))
		749
		750	#define UART_DIV_SAMPLING8(_PCLK_, _BAUD_) (((_PCLK_)25U)/(2U(_BAUD_)))
		751	#define UART_DIVMANT_SAMPLING8(_PCLK_, _BAUD_) (UART_DIV_SAMPLING8((_PCLK_), (_BAUD_))/100U)
		752	#define UART_DIVFRAQ_SAMPLING8(_PCLK_, _BAUD_) (((UART_DIV_SAMPLING8((_PCLK_), (_BAUD_)) - (UART_DIVMANT_SAMPLING8((_PCLK_), (_BAUD_)) * 100U)) * 8U + 50U) / 100U)
		753	/* UART BRR = mantissa + overflow + fraction
		754	= (UART DIVMANT << 4) + ((UART DIVFRAQ & 0xF8) << 1) + (UART DIVFRAQ & 0x07U) */
		755	#define UART_BRR_SAMPLING8(_PCLK_, _BAUD_) (((UART_DIVMANT_SAMPLING8((_PCLK_), (_BAUD_)) << 4U) + \
		756	((UART_DIVFRAQ_SAMPLING8((_PCLK_), (_BAUD_)) & 0xF8U) << 1U)) + \
		757	(UART_DIVFRAQ_SAMPLING8((_PCLK_), (_BAUD_)) & 0x07U))
		758	/**
		759	* @}
		760	*/
		761
		762	/* Private functions ---------------------------------------------------------*/
		763	/** @defgroup UART_Private_Functions UART Private Functions
		764	* @{
		765	*/
		766
		767	/**
		768	* @}
		769	*/
		770
		771	/**
		772	* @}
		773	*/
		774
		775	/**
		776	* @}
		777	*/
		778
		779	#ifdef __cplusplus
		780	}
		781	#endif
		782
		783	#endif /* __STM32F1xx_HAL_UART_H */
		784
		785	/********************** (C) COPYRIGHT STMicroelectronics *END OF FILE**/

Subversion Repositories LedShow

(root)/trunk/Drivers/STM32F1xx_HAL_Driver/Inc/stm32f1xx_hal_uart.h – Rev 2