source: asp3_wo_tecs/trunk/arch/arm_m_gcc/stm32f4xx_stm32cube/STM32F4xx_HAL_Driver/Inc/stm32f4xx_hal_uart.h@ 303

Last change on this file since 303 was 303, checked in by ertl-honda, 7 years ago

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