Mercurial > public > ostc4
comparison Common/Drivers/STM32F4xx_HAL_DRIVER_v120/Inc/stm32f4xx_hal_uart.h @ 38:5f11787b4f42
include in ostc4 repository
author | heinrichsweikamp |
---|---|
date | Sat, 28 Apr 2018 11:52:34 +0200 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
37:ccc45c0e1ea2 | 38:5f11787b4f42 |
---|---|
1 /** | |
2 ****************************************************************************** | |
3 * @file stm32f4xx_hal_uart.h | |
4 * @author MCD Application Team | |
5 * @version V1.2.0 | |
6 * @date 26-December-2014 | |
7 * @brief Header file of UART HAL module. | |
8 ****************************************************************************** | |
9 * @attention | |
10 * | |
11 * <h2><center>© COPYRIGHT(c) 2014 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 */ | |
65 typedef 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 */ | |
100 typedef 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 */ | |
115 typedef 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 **********************************/ | |
579 HAL_StatusTypeDef HAL_UART_Init(UART_HandleTypeDef *huart); | |
580 HAL_StatusTypeDef HAL_HalfDuplex_Init(UART_HandleTypeDef *huart); | |
581 HAL_StatusTypeDef HAL_LIN_Init(UART_HandleTypeDef *huart, uint32_t BreakDetectLength); | |
582 HAL_StatusTypeDef HAL_MultiProcessor_Init(UART_HandleTypeDef *huart, uint8_t Address, uint32_t WakeUpMethod); | |
583 HAL_StatusTypeDef HAL_UART_DeInit (UART_HandleTypeDef *huart); | |
584 void HAL_UART_MspInit(UART_HandleTypeDef *huart); | |
585 void HAL_UART_MspDeInit(UART_HandleTypeDef *huart); | |
586 /** | |
587 * @} | |
588 */ | |
589 | |
590 /** @addtogroup UART_Exported_Functions_Group2 | |
591 * @{ | |
592 */ | |
593 /* IO operation functions *******************************************************/ | |
594 HAL_StatusTypeDef HAL_UART_Transmit(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout); | |
595 HAL_StatusTypeDef HAL_UART_Receive(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout); | |
596 HAL_StatusTypeDef HAL_UART_Transmit_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size); | |
597 HAL_StatusTypeDef HAL_UART_Receive_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size); | |
598 HAL_StatusTypeDef HAL_UART_Transmit_DMA(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size); | |
599 HAL_StatusTypeDef HAL_UART_Receive_DMA(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size); | |
600 HAL_StatusTypeDef HAL_UART_DMAPause(UART_HandleTypeDef *huart); | |
601 HAL_StatusTypeDef HAL_UART_DMAResume(UART_HandleTypeDef *huart); | |
602 HAL_StatusTypeDef HAL_UART_DMAStop(UART_HandleTypeDef *huart); | |
603 void HAL_UART_IRQHandler(UART_HandleTypeDef *huart); | |
604 void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart); | |
605 void HAL_UART_TxHalfCpltCallback(UART_HandleTypeDef *huart); | |
606 void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart); | |
607 void HAL_UART_RxHalfCpltCallback(UART_HandleTypeDef *huart); | |
608 void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart); | |
609 /** | |
610 * @} | |
611 */ | |
612 | |
613 /** @addtogroup UART_Exported_Functions_Group3 | |
614 * @{ | |
615 */ | |
616 /* Peripheral Control functions ************************************************/ | |
617 HAL_StatusTypeDef HAL_LIN_SendBreak(UART_HandleTypeDef *huart); | |
618 HAL_StatusTypeDef HAL_MultiProcessor_EnterMuteMode(UART_HandleTypeDef *huart); | |
619 HAL_StatusTypeDef HAL_MultiProcessor_ExitMuteMode(UART_HandleTypeDef *huart); | |
620 HAL_StatusTypeDef HAL_HalfDuplex_EnableTransmitter(UART_HandleTypeDef *huart); | |
621 HAL_StatusTypeDef HAL_HalfDuplex_EnableReceiver(UART_HandleTypeDef *huart); | |
622 /** | |
623 * @} | |
624 */ | |
625 | |
626 /** @addtogroup UART_Exported_Functions_Group4 | |
627 * @{ | |
628 */ | |
629 /* Peripheral State functions **************************************************/ | |
630 HAL_UART_StateTypeDef HAL_UART_GetState(UART_HandleTypeDef *huart); | |
631 uint32_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****/ |