WebSVN – DashDisplay – Blame – /branches/Dashboard_L152_v2/Drivers/STM32L1xx_HAL_Driver/Inc/stm32l1xx_hal_uart.h

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

Subversion Repositories DashDisplay

(root)/branches/Dashboard_L152_v2/Drivers/STM32L1xx_HAL_Driver/Inc/stm32l1xx_hal_uart.h – Rev 49