1 /**
2 ******************************************************************************
3 * @file stm32f1xx_ll_usart.h
4 * @author MCD Application Team
5 * @brief Header file of USART LL module.
6 ******************************************************************************
7 * @attention
8 *
9 * Copyright (c) 2016 STMicroelectronics.
10 * All rights reserved.
11 *
12 * This software is licensed under terms that can be found in the LICENSE file
13 * in the root directory of this software component.
14 * If no LICENSE file comes with this software, it is provided AS-IS.
15 *
16 ******************************************************************************
17 */
18
19 /* Define to prevent recursive inclusion -------------------------------------*/
20 #ifndef __STM32F1xx_LL_USART_H
21 #define __STM32F1xx_LL_USART_H
22
23 #ifdef __cplusplus
24 extern "C" {
25 #endif
26
27 /* Includes ------------------------------------------------------------------*/
28 #include "stm32f1xx.h"
29
30 /** @addtogroup STM32F1xx_LL_Driver
31 * @{
32 */
33
34 #if defined (USART1) || defined (USART2) || defined (USART3) || defined (UART4) || defined (UART5)
35
36 /** @defgroup USART_LL USART
37 * @{
38 */
39
40 /* Private types -------------------------------------------------------------*/
41 /* Private variables ---------------------------------------------------------*/
42
43 /* Private constants ---------------------------------------------------------*/
44 /** @defgroup USART_LL_Private_Constants USART Private Constants
45 * @{
46 */
47
48 /* Defines used for the bit position in the register and perform offsets*/
49 #define USART_POSITION_GTPR_GT USART_GTPR_GT_Pos
50 /**
51 * @}
52 */
53
54 /* Private macros ------------------------------------------------------------*/
55 #if defined(USE_FULL_LL_DRIVER)
56 /** @defgroup USART_LL_Private_Macros USART Private Macros
57 * @{
58 */
59 /**
60 * @}
61 */
62 #endif /*USE_FULL_LL_DRIVER*/
63
64 /* Exported types ------------------------------------------------------------*/
65 #if defined(USE_FULL_LL_DRIVER)
66 /** @defgroup USART_LL_ES_INIT USART Exported Init structures
67 * @{
68 */
69
70 /**
71 * @brief LL USART Init Structure definition
72 */
73 typedef struct
74 {
75 uint32_t BaudRate; /*!< This field defines expected Usart communication baud rate.
76
77 This feature can be modified afterwards using unitary function @ref LL_USART_SetBaudRate().*/
78
79 uint32_t DataWidth; /*!< Specifies the number of data bits transmitted or received in a frame.
80 This parameter can be a value of @ref USART_LL_EC_DATAWIDTH.
81
82 This feature can be modified afterwards using unitary function @ref LL_USART_SetDataWidth().*/
83
84 uint32_t StopBits; /*!< Specifies the number of stop bits transmitted.
85 This parameter can be a value of @ref USART_LL_EC_STOPBITS.
86
87 This feature can be modified afterwards using unitary function @ref LL_USART_SetStopBitsLength().*/
88
89 uint32_t Parity; /*!< Specifies the parity mode.
90 This parameter can be a value of @ref USART_LL_EC_PARITY.
91
92 This feature can be modified afterwards using unitary function @ref LL_USART_SetParity().*/
93
94 uint32_t TransferDirection; /*!< Specifies whether the Receive and/or Transmit mode is enabled or disabled.
95 This parameter can be a value of @ref USART_LL_EC_DIRECTION.
96
97 This feature can be modified afterwards using unitary function @ref LL_USART_SetTransferDirection().*/
98
99 uint32_t HardwareFlowControl; /*!< Specifies whether the hardware flow control mode is enabled or disabled.
100 This parameter can be a value of @ref USART_LL_EC_HWCONTROL.
101
102 This feature can be modified afterwards using unitary function @ref LL_USART_SetHWFlowCtrl().*/
103
104 uint32_t OverSampling; /*!< Specifies whether USART oversampling mode is 16 or 8.
105 This parameter can be a value of @ref USART_LL_EC_OVERSAMPLING.
106
107 This feature can be modified afterwards using unitary function @ref LL_USART_SetOverSampling().*/
108
109 } LL_USART_InitTypeDef;
110
111 /**
112 * @brief LL USART Clock Init Structure definition
113 */
114 typedef struct
115 {
116 uint32_t ClockOutput; /*!< Specifies whether the USART clock is enabled or disabled.
117 This parameter can be a value of @ref USART_LL_EC_CLOCK.
118
119 USART HW configuration can be modified afterwards using unitary functions
120 @ref LL_USART_EnableSCLKOutput() or @ref LL_USART_DisableSCLKOutput().
121 For more details, refer to description of this function. */
122
123 uint32_t ClockPolarity; /*!< Specifies the steady state of the serial clock.
124 This parameter can be a value of @ref USART_LL_EC_POLARITY.
125
126 USART HW configuration can be modified afterwards using unitary functions @ref LL_USART_SetClockPolarity().
127 For more details, refer to description of this function. */
128
129 uint32_t ClockPhase; /*!< Specifies the clock transition on which the bit capture is made.
130 This parameter can be a value of @ref USART_LL_EC_PHASE.
131
132 USART HW configuration can be modified afterwards using unitary functions @ref LL_USART_SetClockPhase().
133 For more details, refer to description of this function. */
134
135 uint32_t LastBitClockPulse; /*!< Specifies whether the clock pulse corresponding to the last transmitted
136 data bit (MSB) has to be output on the SCLK pin in synchronous mode.
137 This parameter can be a value of @ref USART_LL_EC_LASTCLKPULSE.
138
139 USART HW configuration can be modified afterwards using unitary functions @ref LL_USART_SetLastClkPulseOutput().
140 For more details, refer to description of this function. */
141
142 } LL_USART_ClockInitTypeDef;
143
144 /**
145 * @}
146 */
147 #endif /* USE_FULL_LL_DRIVER */
148
149 /* Exported constants --------------------------------------------------------*/
150 /** @defgroup USART_LL_Exported_Constants USART Exported Constants
151 * @{
152 */
153
154 /** @defgroup USART_LL_EC_GET_FLAG Get Flags Defines
155 * @brief Flags defines which can be used with LL_USART_ReadReg function
156 * @{
157 */
158 #define LL_USART_SR_PE USART_SR_PE /*!< Parity error flag */
159 #define LL_USART_SR_FE USART_SR_FE /*!< Framing error flag */
160 #define LL_USART_SR_NE USART_SR_NE /*!< Noise detected flag */
161 #define LL_USART_SR_ORE USART_SR_ORE /*!< Overrun error flag */
162 #define LL_USART_SR_IDLE USART_SR_IDLE /*!< Idle line detected flag */
163 #define LL_USART_SR_RXNE USART_SR_RXNE /*!< Read data register not empty flag */
164 #define LL_USART_SR_TC USART_SR_TC /*!< Transmission complete flag */
165 #define LL_USART_SR_TXE USART_SR_TXE /*!< Transmit data register empty flag */
166 #define LL_USART_SR_LBD USART_SR_LBD /*!< LIN break detection flag */
167 #define LL_USART_SR_CTS USART_SR_CTS /*!< CTS flag */
168 /**
169 * @}
170 */
171
172 /** @defgroup USART_LL_EC_IT IT Defines
173 * @brief IT defines which can be used with LL_USART_ReadReg and LL_USART_WriteReg functions
174 * @{
175 */
176 #define LL_USART_CR1_IDLEIE USART_CR1_IDLEIE /*!< IDLE interrupt enable */
177 #define LL_USART_CR1_RXNEIE USART_CR1_RXNEIE /*!< Read data register not empty interrupt enable */
178 #define LL_USART_CR1_TCIE USART_CR1_TCIE /*!< Transmission complete interrupt enable */
179 #define LL_USART_CR1_TXEIE USART_CR1_TXEIE /*!< Transmit data register empty interrupt enable */
180 #define LL_USART_CR1_PEIE USART_CR1_PEIE /*!< Parity error */
181 #define LL_USART_CR2_LBDIE USART_CR2_LBDIE /*!< LIN break detection interrupt enable */
182 #define LL_USART_CR3_EIE USART_CR3_EIE /*!< Error interrupt enable */
183 #define LL_USART_CR3_CTSIE USART_CR3_CTSIE /*!< CTS interrupt enable */
184 /**
185 * @}
186 */
187
188 /** @defgroup USART_LL_EC_DIRECTION Communication Direction
189 * @{
190 */
191 #define LL_USART_DIRECTION_NONE 0x00000000U /*!< Transmitter and Receiver are disabled */
192 #define LL_USART_DIRECTION_RX USART_CR1_RE /*!< Transmitter is disabled and Receiver is enabled */
193 #define LL_USART_DIRECTION_TX USART_CR1_TE /*!< Transmitter is enabled and Receiver is disabled */
194 #define LL_USART_DIRECTION_TX_RX (USART_CR1_TE |USART_CR1_RE) /*!< Transmitter and Receiver are enabled */
195 /**
196 * @}
197 */
198
199 /** @defgroup USART_LL_EC_PARITY Parity Control
200 * @{
201 */
202 #define LL_USART_PARITY_NONE 0x00000000U /*!< Parity control disabled */
203 #define LL_USART_PARITY_EVEN USART_CR1_PCE /*!< Parity control enabled and Even Parity is selected */
204 #define LL_USART_PARITY_ODD (USART_CR1_PCE | USART_CR1_PS) /*!< Parity control enabled and Odd Parity is selected */
205 /**
206 * @}
207 */
208
209 /** @defgroup USART_LL_EC_WAKEUP Wakeup
210 * @{
211 */
212 #define LL_USART_WAKEUP_IDLELINE 0x00000000U /*!< USART wake up from Mute mode on Idle Line */
213 #define LL_USART_WAKEUP_ADDRESSMARK USART_CR1_WAKE /*!< USART wake up from Mute mode on Address Mark */
214 /**
215 * @}
216 */
217
218 /** @defgroup USART_LL_EC_DATAWIDTH Datawidth
219 * @{
220 */
221 #define LL_USART_DATAWIDTH_8B 0x00000000U /*!< 8 bits word length : Start bit, 8 data bits, n stop bits */
222 #define LL_USART_DATAWIDTH_9B USART_CR1_M /*!< 9 bits word length : Start bit, 9 data bits, n stop bits */
223 /**
224 * @}
225 */
226
227 /** @defgroup USART_LL_EC_OVERSAMPLING Oversampling
228 * @{
229 */
230 #define LL_USART_OVERSAMPLING_16 0x00000000U /*!< Oversampling by 16 */
231 #if defined(USART_CR1_OVER8)
232 #define LL_USART_OVERSAMPLING_8 USART_CR1_OVER8 /*!< Oversampling by 8 */
233 #endif /* USART_OverSampling_Feature */
234 /**
235 * @}
236 */
237
238 #if defined(USE_FULL_LL_DRIVER)
239 /** @defgroup USART_LL_EC_CLOCK Clock Signal
240 * @{
241 */
242
243 #define LL_USART_CLOCK_DISABLE 0x00000000U /*!< Clock signal not provided */
244 #define LL_USART_CLOCK_ENABLE USART_CR2_CLKEN /*!< Clock signal provided */
245 /**
246 * @}
247 */
248 #endif /*USE_FULL_LL_DRIVER*/
249
250 /** @defgroup USART_LL_EC_LASTCLKPULSE Last Clock Pulse
251 * @{
252 */
253 #define LL_USART_LASTCLKPULSE_NO_OUTPUT 0x00000000U /*!< The clock pulse of the last data bit is not output to the SCLK pin */
254 #define LL_USART_LASTCLKPULSE_OUTPUT USART_CR2_LBCL /*!< The clock pulse of the last data bit is output to the SCLK pin */
255 /**
256 * @}
257 */
258
259 /** @defgroup USART_LL_EC_PHASE Clock Phase
260 * @{
261 */
262 #define LL_USART_PHASE_1EDGE 0x00000000U /*!< The first clock transition is the first data capture edge */
263 #define LL_USART_PHASE_2EDGE USART_CR2_CPHA /*!< The second clock transition is the first data capture edge */
264 /**
265 * @}
266 */
267
268 /** @defgroup USART_LL_EC_POLARITY Clock Polarity
269 * @{
270 */
271 #define LL_USART_POLARITY_LOW 0x00000000U /*!< Steady low value on SCLK pin outside transmission window*/
272 #define LL_USART_POLARITY_HIGH USART_CR2_CPOL /*!< Steady high value on SCLK pin outside transmission window */
273 /**
274 * @}
275 */
276
277 /** @defgroup USART_LL_EC_STOPBITS Stop Bits
278 * @{
279 */
280 #define LL_USART_STOPBITS_0_5 USART_CR2_STOP_0 /*!< 0.5 stop bit */
281 #define LL_USART_STOPBITS_1 0x00000000U /*!< 1 stop bit */
282 #define LL_USART_STOPBITS_1_5 (USART_CR2_STOP_0 | USART_CR2_STOP_1) /*!< 1.5 stop bits */
283 #define LL_USART_STOPBITS_2 USART_CR2_STOP_1 /*!< 2 stop bits */
284 /**
285 * @}
286 */
287
288 /** @defgroup USART_LL_EC_HWCONTROL Hardware Control
289 * @{
290 */
291 #define LL_USART_HWCONTROL_NONE 0x00000000U /*!< CTS and RTS hardware flow control disabled */
292 #define LL_USART_HWCONTROL_RTS USART_CR3_RTSE /*!< RTS output enabled, data is only requested when there is space in the receive buffer */
293 #define LL_USART_HWCONTROL_CTS USART_CR3_CTSE /*!< CTS mode enabled, data is only transmitted when the nCTS input is asserted (tied to 0) */
294 #define LL_USART_HWCONTROL_RTS_CTS (USART_CR3_RTSE | USART_CR3_CTSE) /*!< CTS and RTS hardware flow control enabled */
295 /**
296 * @}
297 */
298
299 /** @defgroup USART_LL_EC_IRDA_POWER IrDA Power
300 * @{
301 */
302 #define LL_USART_IRDA_POWER_NORMAL 0x00000000U /*!< IrDA normal power mode */
303 #define LL_USART_IRDA_POWER_LOW USART_CR3_IRLP /*!< IrDA low power mode */
304 /**
305 * @}
306 */
307
308 /** @defgroup USART_LL_EC_LINBREAK_DETECT LIN Break Detection Length
309 * @{
310 */
311 #define LL_USART_LINBREAK_DETECT_10B 0x00000000U /*!< 10-bit break detection method selected */
312 #define LL_USART_LINBREAK_DETECT_11B USART_CR2_LBDL /*!< 11-bit break detection method selected */
313 /**
314 * @}
315 */
316
317 /**
318 * @}
319 */
320
321 /* Exported macro ------------------------------------------------------------*/
322 /** @defgroup USART_LL_Exported_Macros USART Exported Macros
323 * @{
324 */
325
326 /** @defgroup USART_LL_EM_WRITE_READ Common Write and read registers Macros
327 * @{
328 */
329
330 /**
331 * @brief Write a value in USART register
332 * @param __INSTANCE__ USART Instance
333 * @param __REG__ Register to be written
334 * @param __VALUE__ Value to be written in the register
335 * @retval None
336 */
337 #define LL_USART_WriteReg(__INSTANCE__, __REG__, __VALUE__) WRITE_REG(__INSTANCE__->__REG__, (__VALUE__))
338
339 /**
340 * @brief Read a value in USART register
341 * @param __INSTANCE__ USART Instance
342 * @param __REG__ Register to be read
343 * @retval Register value
344 */
345 #define LL_USART_ReadReg(__INSTANCE__, __REG__) READ_REG(__INSTANCE__->__REG__)
346 /**
347 * @}
348 */
349
350 /** @defgroup USART_LL_EM_Exported_Macros_Helper Exported Macros Helper
351 * @{
352 */
353
354 /**
355 * @brief Compute USARTDIV value according to Peripheral Clock and
356 * expected Baud Rate in 8 bits sampling mode (32 bits value of USARTDIV is returned)
357 * @param __PERIPHCLK__ Peripheral Clock frequency used for USART instance
358 * @param __BAUDRATE__ Baud rate value to achieve
359 * @retval USARTDIV value to be used for BRR register filling in OverSampling_8 case
360 */
361 #define __LL_USART_DIV_SAMPLING8_100(__PERIPHCLK__, __BAUDRATE__) (((__PERIPHCLK__)*25)/(2*(__BAUDRATE__)))
362 #define __LL_USART_DIVMANT_SAMPLING8(__PERIPHCLK__, __BAUDRATE__) (__LL_USART_DIV_SAMPLING8_100((__PERIPHCLK__), (__BAUDRATE__))/100)
363 #define __LL_USART_DIVFRAQ_SAMPLING8(__PERIPHCLK__, __BAUDRATE__) (((__LL_USART_DIV_SAMPLING8_100((__PERIPHCLK__), (__BAUDRATE__)) - (__LL_USART_DIVMANT_SAMPLING8((__PERIPHCLK__), (__BAUDRATE__)) * 100)) * 8\
364 + 50) / 100)
365 /* UART BRR = mantissa + overflow + fraction
366 = (UART DIVMANT << 4) + ((UART DIVFRAQ & 0xF8) << 1) + (UART DIVFRAQ & 0x07) */
367 #define __LL_USART_DIV_SAMPLING8(__PERIPHCLK__, __BAUDRATE__) (((__LL_USART_DIVMANT_SAMPLING8((__PERIPHCLK__), (__BAUDRATE__)) << 4) + \
368 ((__LL_USART_DIVFRAQ_SAMPLING8((__PERIPHCLK__), (__BAUDRATE__)) & 0xF8) << 1)) + \
369 (__LL_USART_DIVFRAQ_SAMPLING8((__PERIPHCLK__), (__BAUDRATE__)) & 0x07))
370
371 /**
372 * @brief Compute USARTDIV value according to Peripheral Clock and
373 * expected Baud Rate in 16 bits sampling mode (32 bits value of USARTDIV is returned)
374 * @param __PERIPHCLK__ Peripheral Clock frequency used for USART instance
375 * @param __BAUDRATE__ Baud rate value to achieve
376 * @retval USARTDIV value to be used for BRR register filling in OverSampling_16 case
377 */
378 #define __LL_USART_DIV_SAMPLING16_100(__PERIPHCLK__, __BAUDRATE__) (((__PERIPHCLK__)*25)/(4*(__BAUDRATE__)))
379 #define __LL_USART_DIVMANT_SAMPLING16(__PERIPHCLK__, __BAUDRATE__) (__LL_USART_DIV_SAMPLING16_100((__PERIPHCLK__), (__BAUDRATE__))/100)
380 #define __LL_USART_DIVFRAQ_SAMPLING16(__PERIPHCLK__, __BAUDRATE__) ((((__LL_USART_DIV_SAMPLING16_100((__PERIPHCLK__), (__BAUDRATE__)) - (__LL_USART_DIVMANT_SAMPLING16((__PERIPHCLK__), (__BAUDRATE__)) * 100)) * 16)\
381 + 50) / 100)
382 /* USART BRR = mantissa + overflow + fraction
383 = (USART DIVMANT << 4) + (USART DIVFRAQ & 0xF0) + (USART DIVFRAQ & 0x0F) */
384 #define __LL_USART_DIV_SAMPLING16(__PERIPHCLK__, __BAUDRATE__) (((__LL_USART_DIVMANT_SAMPLING16((__PERIPHCLK__), (__BAUDRATE__)) << 4) + \
385 (__LL_USART_DIVFRAQ_SAMPLING16((__PERIPHCLK__), (__BAUDRATE__)) & 0xF0)) + \
386 (__LL_USART_DIVFRAQ_SAMPLING16((__PERIPHCLK__), (__BAUDRATE__)) & 0x0F))
387
388 /**
389 * @}
390 */
391
392 /**
393 * @}
394 */
395
396 /* Exported functions --------------------------------------------------------*/
397
398 /** @defgroup USART_LL_Exported_Functions USART Exported Functions
399 * @{
400 */
401
402 /** @defgroup USART_LL_EF_Configuration Configuration functions
403 * @{
404 */
405
406 /**
407 * @brief USART Enable
408 * @rmtoll CR1 UE LL_USART_Enable
409 * @param USARTx USART Instance
410 * @retval None
411 */
LL_USART_Enable(USART_TypeDef * USARTx)412 __STATIC_INLINE void LL_USART_Enable(USART_TypeDef *USARTx)
413 {
414 SET_BIT(USARTx->CR1, USART_CR1_UE);
415 }
416
417 /**
418 * @brief USART Disable (all USART prescalers and outputs are disabled)
419 * @note When USART is disabled, USART prescalers and outputs are stopped immediately,
420 * and current operations are discarded. The configuration of the USART is kept, but all the status
421 * flags, in the USARTx_SR are set to their default values.
422 * @rmtoll CR1 UE LL_USART_Disable
423 * @param USARTx USART Instance
424 * @retval None
425 */
LL_USART_Disable(USART_TypeDef * USARTx)426 __STATIC_INLINE void LL_USART_Disable(USART_TypeDef *USARTx)
427 {
428 CLEAR_BIT(USARTx->CR1, USART_CR1_UE);
429 }
430
431 /**
432 * @brief Indicate if USART is enabled
433 * @rmtoll CR1 UE LL_USART_IsEnabled
434 * @param USARTx USART Instance
435 * @retval State of bit (1 or 0).
436 */
LL_USART_IsEnabled(const USART_TypeDef * USARTx)437 __STATIC_INLINE uint32_t LL_USART_IsEnabled(const USART_TypeDef *USARTx)
438 {
439 return (READ_BIT(USARTx->CR1, USART_CR1_UE) == (USART_CR1_UE));
440 }
441
442 /**
443 * @brief Receiver Enable (Receiver is enabled and begins searching for a start bit)
444 * @rmtoll CR1 RE LL_USART_EnableDirectionRx
445 * @param USARTx USART Instance
446 * @retval None
447 */
LL_USART_EnableDirectionRx(USART_TypeDef * USARTx)448 __STATIC_INLINE void LL_USART_EnableDirectionRx(USART_TypeDef *USARTx)
449 {
450 ATOMIC_SET_BIT(USARTx->CR1, USART_CR1_RE);
451 }
452
453 /**
454 * @brief Receiver Disable
455 * @rmtoll CR1 RE LL_USART_DisableDirectionRx
456 * @param USARTx USART Instance
457 * @retval None
458 */
LL_USART_DisableDirectionRx(USART_TypeDef * USARTx)459 __STATIC_INLINE void LL_USART_DisableDirectionRx(USART_TypeDef *USARTx)
460 {
461 ATOMIC_CLEAR_BIT(USARTx->CR1, USART_CR1_RE);
462 }
463
464 /**
465 * @brief Transmitter Enable
466 * @rmtoll CR1 TE LL_USART_EnableDirectionTx
467 * @param USARTx USART Instance
468 * @retval None
469 */
LL_USART_EnableDirectionTx(USART_TypeDef * USARTx)470 __STATIC_INLINE void LL_USART_EnableDirectionTx(USART_TypeDef *USARTx)
471 {
472 ATOMIC_SET_BIT(USARTx->CR1, USART_CR1_TE);
473 }
474
475 /**
476 * @brief Transmitter Disable
477 * @rmtoll CR1 TE LL_USART_DisableDirectionTx
478 * @param USARTx USART Instance
479 * @retval None
480 */
LL_USART_DisableDirectionTx(USART_TypeDef * USARTx)481 __STATIC_INLINE void LL_USART_DisableDirectionTx(USART_TypeDef *USARTx)
482 {
483 ATOMIC_CLEAR_BIT(USARTx->CR1, USART_CR1_TE);
484 }
485
486 /**
487 * @brief Configure simultaneously enabled/disabled states
488 * of Transmitter and Receiver
489 * @rmtoll CR1 RE LL_USART_SetTransferDirection\n
490 * CR1 TE LL_USART_SetTransferDirection
491 * @param USARTx USART Instance
492 * @param TransferDirection This parameter can be one of the following values:
493 * @arg @ref LL_USART_DIRECTION_NONE
494 * @arg @ref LL_USART_DIRECTION_RX
495 * @arg @ref LL_USART_DIRECTION_TX
496 * @arg @ref LL_USART_DIRECTION_TX_RX
497 * @retval None
498 */
LL_USART_SetTransferDirection(USART_TypeDef * USARTx,uint32_t TransferDirection)499 __STATIC_INLINE void LL_USART_SetTransferDirection(USART_TypeDef *USARTx, uint32_t TransferDirection)
500 {
501 ATOMIC_MODIFY_REG(USARTx->CR1, USART_CR1_RE | USART_CR1_TE, TransferDirection);
502 }
503
504 /**
505 * @brief Return enabled/disabled states of Transmitter and Receiver
506 * @rmtoll CR1 RE LL_USART_GetTransferDirection\n
507 * CR1 TE LL_USART_GetTransferDirection
508 * @param USARTx USART Instance
509 * @retval Returned value can be one of the following values:
510 * @arg @ref LL_USART_DIRECTION_NONE
511 * @arg @ref LL_USART_DIRECTION_RX
512 * @arg @ref LL_USART_DIRECTION_TX
513 * @arg @ref LL_USART_DIRECTION_TX_RX
514 */
LL_USART_GetTransferDirection(const USART_TypeDef * USARTx)515 __STATIC_INLINE uint32_t LL_USART_GetTransferDirection(const USART_TypeDef *USARTx)
516 {
517 return (uint32_t)(READ_BIT(USARTx->CR1, USART_CR1_RE | USART_CR1_TE));
518 }
519
520 /**
521 * @brief Configure Parity (enabled/disabled and parity mode if enabled).
522 * @note This function selects if hardware parity control (generation and detection) is enabled or disabled.
523 * When the parity control is enabled (Odd or Even), computed parity bit is inserted at the MSB position
524 * (9th or 8th bit depending on data width) and parity is checked on the received data.
525 * @rmtoll CR1 PS LL_USART_SetParity\n
526 * CR1 PCE LL_USART_SetParity
527 * @param USARTx USART Instance
528 * @param Parity This parameter can be one of the following values:
529 * @arg @ref LL_USART_PARITY_NONE
530 * @arg @ref LL_USART_PARITY_EVEN
531 * @arg @ref LL_USART_PARITY_ODD
532 * @retval None
533 */
LL_USART_SetParity(USART_TypeDef * USARTx,uint32_t Parity)534 __STATIC_INLINE void LL_USART_SetParity(USART_TypeDef *USARTx, uint32_t Parity)
535 {
536 MODIFY_REG(USARTx->CR1, USART_CR1_PS | USART_CR1_PCE, Parity);
537 }
538
539 /**
540 * @brief Return Parity configuration (enabled/disabled and parity mode if enabled)
541 * @rmtoll CR1 PS LL_USART_GetParity\n
542 * CR1 PCE LL_USART_GetParity
543 * @param USARTx USART Instance
544 * @retval Returned value can be one of the following values:
545 * @arg @ref LL_USART_PARITY_NONE
546 * @arg @ref LL_USART_PARITY_EVEN
547 * @arg @ref LL_USART_PARITY_ODD
548 */
LL_USART_GetParity(const USART_TypeDef * USARTx)549 __STATIC_INLINE uint32_t LL_USART_GetParity(const USART_TypeDef *USARTx)
550 {
551 return (uint32_t)(READ_BIT(USARTx->CR1, USART_CR1_PS | USART_CR1_PCE));
552 }
553
554 /**
555 * @brief Set Receiver Wake Up method from Mute mode.
556 * @rmtoll CR1 WAKE LL_USART_SetWakeUpMethod
557 * @param USARTx USART Instance
558 * @param Method This parameter can be one of the following values:
559 * @arg @ref LL_USART_WAKEUP_IDLELINE
560 * @arg @ref LL_USART_WAKEUP_ADDRESSMARK
561 * @retval None
562 */
LL_USART_SetWakeUpMethod(USART_TypeDef * USARTx,uint32_t Method)563 __STATIC_INLINE void LL_USART_SetWakeUpMethod(USART_TypeDef *USARTx, uint32_t Method)
564 {
565 MODIFY_REG(USARTx->CR1, USART_CR1_WAKE, Method);
566 }
567
568 /**
569 * @brief Return Receiver Wake Up method from Mute mode
570 * @rmtoll CR1 WAKE LL_USART_GetWakeUpMethod
571 * @param USARTx USART Instance
572 * @retval Returned value can be one of the following values:
573 * @arg @ref LL_USART_WAKEUP_IDLELINE
574 * @arg @ref LL_USART_WAKEUP_ADDRESSMARK
575 */
LL_USART_GetWakeUpMethod(const USART_TypeDef * USARTx)576 __STATIC_INLINE uint32_t LL_USART_GetWakeUpMethod(const USART_TypeDef *USARTx)
577 {
578 return (uint32_t)(READ_BIT(USARTx->CR1, USART_CR1_WAKE));
579 }
580
581 /**
582 * @brief Set Word length (i.e. nb of data bits, excluding start and stop bits)
583 * @rmtoll CR1 M LL_USART_SetDataWidth
584 * @param USARTx USART Instance
585 * @param DataWidth This parameter can be one of the following values:
586 * @arg @ref LL_USART_DATAWIDTH_8B
587 * @arg @ref LL_USART_DATAWIDTH_9B
588 * @retval None
589 */
LL_USART_SetDataWidth(USART_TypeDef * USARTx,uint32_t DataWidth)590 __STATIC_INLINE void LL_USART_SetDataWidth(USART_TypeDef *USARTx, uint32_t DataWidth)
591 {
592 MODIFY_REG(USARTx->CR1, USART_CR1_M, DataWidth);
593 }
594
595 /**
596 * @brief Return Word length (i.e. nb of data bits, excluding start and stop bits)
597 * @rmtoll CR1 M LL_USART_GetDataWidth
598 * @param USARTx USART Instance
599 * @retval Returned value can be one of the following values:
600 * @arg @ref LL_USART_DATAWIDTH_8B
601 * @arg @ref LL_USART_DATAWIDTH_9B
602 */
LL_USART_GetDataWidth(const USART_TypeDef * USARTx)603 __STATIC_INLINE uint32_t LL_USART_GetDataWidth(const USART_TypeDef *USARTx)
604 {
605 return (uint32_t)(READ_BIT(USARTx->CR1, USART_CR1_M));
606 }
607
608 #if defined(USART_CR1_OVER8)
609 /**
610 * @brief Set Oversampling to 8-bit or 16-bit mode
611 * @rmtoll CR1 OVER8 LL_USART_SetOverSampling
612 * @param USARTx USART Instance
613 * @param OverSampling This parameter can be one of the following values:
614 * @arg @ref LL_USART_OVERSAMPLING_16
615 * @arg @ref LL_USART_OVERSAMPLING_8
616 * @retval None
617 */
LL_USART_SetOverSampling(USART_TypeDef * USARTx,uint32_t OverSampling)618 __STATIC_INLINE void LL_USART_SetOverSampling(USART_TypeDef *USARTx, uint32_t OverSampling)
619 {
620 MODIFY_REG(USARTx->CR1, USART_CR1_OVER8, OverSampling);
621 }
622
623 /**
624 * @brief Return Oversampling mode
625 * @rmtoll CR1 OVER8 LL_USART_GetOverSampling
626 * @param USARTx USART Instance
627 * @retval Returned value can be one of the following values:
628 * @arg @ref LL_USART_OVERSAMPLING_16
629 * @arg @ref LL_USART_OVERSAMPLING_8
630 */
LL_USART_GetOverSampling(const USART_TypeDef * USARTx)631 __STATIC_INLINE uint32_t LL_USART_GetOverSampling(const USART_TypeDef *USARTx)
632 {
633 return (uint32_t)(READ_BIT(USARTx->CR1, USART_CR1_OVER8));
634 }
635
636 #endif /* USART_OverSampling_Feature */
637 /**
638 * @brief Configure if Clock pulse of the last data bit is output to the SCLK pin or not
639 * @note Macro IS_USART_INSTANCE(USARTx) can be used to check whether or not
640 * Synchronous mode is supported by the USARTx instance.
641 * @rmtoll CR2 LBCL LL_USART_SetLastClkPulseOutput
642 * @param USARTx USART Instance
643 * @param LastBitClockPulse This parameter can be one of the following values:
644 * @arg @ref LL_USART_LASTCLKPULSE_NO_OUTPUT
645 * @arg @ref LL_USART_LASTCLKPULSE_OUTPUT
646 * @retval None
647 */
LL_USART_SetLastClkPulseOutput(USART_TypeDef * USARTx,uint32_t LastBitClockPulse)648 __STATIC_INLINE void LL_USART_SetLastClkPulseOutput(USART_TypeDef *USARTx, uint32_t LastBitClockPulse)
649 {
650 MODIFY_REG(USARTx->CR2, USART_CR2_LBCL, LastBitClockPulse);
651 }
652
653 /**
654 * @brief Retrieve Clock pulse of the last data bit output configuration
655 * (Last bit Clock pulse output to the SCLK pin or not)
656 * @note Macro IS_USART_INSTANCE(USARTx) can be used to check whether or not
657 * Synchronous mode is supported by the USARTx instance.
658 * @rmtoll CR2 LBCL LL_USART_GetLastClkPulseOutput
659 * @param USARTx USART Instance
660 * @retval Returned value can be one of the following values:
661 * @arg @ref LL_USART_LASTCLKPULSE_NO_OUTPUT
662 * @arg @ref LL_USART_LASTCLKPULSE_OUTPUT
663 */
LL_USART_GetLastClkPulseOutput(const USART_TypeDef * USARTx)664 __STATIC_INLINE uint32_t LL_USART_GetLastClkPulseOutput(const USART_TypeDef *USARTx)
665 {
666 return (uint32_t)(READ_BIT(USARTx->CR2, USART_CR2_LBCL));
667 }
668
669 /**
670 * @brief Select the phase of the clock output on the SCLK pin in synchronous mode
671 * @note Macro IS_USART_INSTANCE(USARTx) can be used to check whether or not
672 * Synchronous mode is supported by the USARTx instance.
673 * @rmtoll CR2 CPHA LL_USART_SetClockPhase
674 * @param USARTx USART Instance
675 * @param ClockPhase This parameter can be one of the following values:
676 * @arg @ref LL_USART_PHASE_1EDGE
677 * @arg @ref LL_USART_PHASE_2EDGE
678 * @retval None
679 */
LL_USART_SetClockPhase(USART_TypeDef * USARTx,uint32_t ClockPhase)680 __STATIC_INLINE void LL_USART_SetClockPhase(USART_TypeDef *USARTx, uint32_t ClockPhase)
681 {
682 MODIFY_REG(USARTx->CR2, USART_CR2_CPHA, ClockPhase);
683 }
684
685 /**
686 * @brief Return phase of the clock output on the SCLK pin in synchronous mode
687 * @note Macro IS_USART_INSTANCE(USARTx) can be used to check whether or not
688 * Synchronous mode is supported by the USARTx instance.
689 * @rmtoll CR2 CPHA LL_USART_GetClockPhase
690 * @param USARTx USART Instance
691 * @retval Returned value can be one of the following values:
692 * @arg @ref LL_USART_PHASE_1EDGE
693 * @arg @ref LL_USART_PHASE_2EDGE
694 */
LL_USART_GetClockPhase(const USART_TypeDef * USARTx)695 __STATIC_INLINE uint32_t LL_USART_GetClockPhase(const USART_TypeDef *USARTx)
696 {
697 return (uint32_t)(READ_BIT(USARTx->CR2, USART_CR2_CPHA));
698 }
699
700 /**
701 * @brief Select the polarity of the clock output on the SCLK pin in synchronous mode
702 * @note Macro IS_USART_INSTANCE(USARTx) can be used to check whether or not
703 * Synchronous mode is supported by the USARTx instance.
704 * @rmtoll CR2 CPOL LL_USART_SetClockPolarity
705 * @param USARTx USART Instance
706 * @param ClockPolarity This parameter can be one of the following values:
707 * @arg @ref LL_USART_POLARITY_LOW
708 * @arg @ref LL_USART_POLARITY_HIGH
709 * @retval None
710 */
LL_USART_SetClockPolarity(USART_TypeDef * USARTx,uint32_t ClockPolarity)711 __STATIC_INLINE void LL_USART_SetClockPolarity(USART_TypeDef *USARTx, uint32_t ClockPolarity)
712 {
713 MODIFY_REG(USARTx->CR2, USART_CR2_CPOL, ClockPolarity);
714 }
715
716 /**
717 * @brief Return polarity of the clock output on the SCLK pin in synchronous mode
718 * @note Macro IS_USART_INSTANCE(USARTx) can be used to check whether or not
719 * Synchronous mode is supported by the USARTx instance.
720 * @rmtoll CR2 CPOL LL_USART_GetClockPolarity
721 * @param USARTx USART Instance
722 * @retval Returned value can be one of the following values:
723 * @arg @ref LL_USART_POLARITY_LOW
724 * @arg @ref LL_USART_POLARITY_HIGH
725 */
LL_USART_GetClockPolarity(const USART_TypeDef * USARTx)726 __STATIC_INLINE uint32_t LL_USART_GetClockPolarity(const USART_TypeDef *USARTx)
727 {
728 return (uint32_t)(READ_BIT(USARTx->CR2, USART_CR2_CPOL));
729 }
730
731 /**
732 * @brief Configure Clock signal format (Phase Polarity and choice about output of last bit clock pulse)
733 * @note Macro IS_USART_INSTANCE(USARTx) can be used to check whether or not
734 * Synchronous mode is supported by the USARTx instance.
735 * @note Call of this function is equivalent to following function call sequence :
736 * - Clock Phase configuration using @ref LL_USART_SetClockPhase() function
737 * - Clock Polarity configuration using @ref LL_USART_SetClockPolarity() function
738 * - Output of Last bit Clock pulse configuration using @ref LL_USART_SetLastClkPulseOutput() function
739 * @rmtoll CR2 CPHA LL_USART_ConfigClock\n
740 * CR2 CPOL LL_USART_ConfigClock\n
741 * CR2 LBCL LL_USART_ConfigClock
742 * @param USARTx USART Instance
743 * @param Phase This parameter can be one of the following values:
744 * @arg @ref LL_USART_PHASE_1EDGE
745 * @arg @ref LL_USART_PHASE_2EDGE
746 * @param Polarity This parameter can be one of the following values:
747 * @arg @ref LL_USART_POLARITY_LOW
748 * @arg @ref LL_USART_POLARITY_HIGH
749 * @param LBCPOutput This parameter can be one of the following values:
750 * @arg @ref LL_USART_LASTCLKPULSE_NO_OUTPUT
751 * @arg @ref LL_USART_LASTCLKPULSE_OUTPUT
752 * @retval None
753 */
LL_USART_ConfigClock(USART_TypeDef * USARTx,uint32_t Phase,uint32_t Polarity,uint32_t LBCPOutput)754 __STATIC_INLINE void LL_USART_ConfigClock(USART_TypeDef *USARTx, uint32_t Phase, uint32_t Polarity, uint32_t LBCPOutput)
755 {
756 MODIFY_REG(USARTx->CR2, USART_CR2_CPHA | USART_CR2_CPOL | USART_CR2_LBCL, Phase | Polarity | LBCPOutput);
757 }
758
759 /**
760 * @brief Enable Clock output on SCLK pin
761 * @note Macro IS_USART_INSTANCE(USARTx) can be used to check whether or not
762 * Synchronous mode is supported by the USARTx instance.
763 * @rmtoll CR2 CLKEN LL_USART_EnableSCLKOutput
764 * @param USARTx USART Instance
765 * @retval None
766 */
LL_USART_EnableSCLKOutput(USART_TypeDef * USARTx)767 __STATIC_INLINE void LL_USART_EnableSCLKOutput(USART_TypeDef *USARTx)
768 {
769 SET_BIT(USARTx->CR2, USART_CR2_CLKEN);
770 }
771
772 /**
773 * @brief Disable Clock output on SCLK pin
774 * @note Macro IS_USART_INSTANCE(USARTx) can be used to check whether or not
775 * Synchronous mode is supported by the USARTx instance.
776 * @rmtoll CR2 CLKEN LL_USART_DisableSCLKOutput
777 * @param USARTx USART Instance
778 * @retval None
779 */
LL_USART_DisableSCLKOutput(USART_TypeDef * USARTx)780 __STATIC_INLINE void LL_USART_DisableSCLKOutput(USART_TypeDef *USARTx)
781 {
782 CLEAR_BIT(USARTx->CR2, USART_CR2_CLKEN);
783 }
784
785 /**
786 * @brief Indicate if Clock output on SCLK pin is enabled
787 * @note Macro IS_USART_INSTANCE(USARTx) can be used to check whether or not
788 * Synchronous mode is supported by the USARTx instance.
789 * @rmtoll CR2 CLKEN LL_USART_IsEnabledSCLKOutput
790 * @param USARTx USART Instance
791 * @retval State of bit (1 or 0).
792 */
LL_USART_IsEnabledSCLKOutput(const USART_TypeDef * USARTx)793 __STATIC_INLINE uint32_t LL_USART_IsEnabledSCLKOutput(const USART_TypeDef *USARTx)
794 {
795 return (READ_BIT(USARTx->CR2, USART_CR2_CLKEN) == (USART_CR2_CLKEN));
796 }
797
798 /**
799 * @brief Set the length of the stop bits
800 * @rmtoll CR2 STOP LL_USART_SetStopBitsLength
801 * @param USARTx USART Instance
802 * @param StopBits This parameter can be one of the following values:
803 * @arg @ref LL_USART_STOPBITS_0_5
804 * @arg @ref LL_USART_STOPBITS_1
805 * @arg @ref LL_USART_STOPBITS_1_5
806 * @arg @ref LL_USART_STOPBITS_2
807 * @retval None
808 */
LL_USART_SetStopBitsLength(USART_TypeDef * USARTx,uint32_t StopBits)809 __STATIC_INLINE void LL_USART_SetStopBitsLength(USART_TypeDef *USARTx, uint32_t StopBits)
810 {
811 MODIFY_REG(USARTx->CR2, USART_CR2_STOP, StopBits);
812 }
813
814 /**
815 * @brief Retrieve the length of the stop bits
816 * @rmtoll CR2 STOP LL_USART_GetStopBitsLength
817 * @param USARTx USART Instance
818 * @retval Returned value can be one of the following values:
819 * @arg @ref LL_USART_STOPBITS_0_5
820 * @arg @ref LL_USART_STOPBITS_1
821 * @arg @ref LL_USART_STOPBITS_1_5
822 * @arg @ref LL_USART_STOPBITS_2
823 */
LL_USART_GetStopBitsLength(const USART_TypeDef * USARTx)824 __STATIC_INLINE uint32_t LL_USART_GetStopBitsLength(const USART_TypeDef *USARTx)
825 {
826 return (uint32_t)(READ_BIT(USARTx->CR2, USART_CR2_STOP));
827 }
828
829 /**
830 * @brief Configure Character frame format (Datawidth, Parity control, Stop Bits)
831 * @note Call of this function is equivalent to following function call sequence :
832 * - Data Width configuration using @ref LL_USART_SetDataWidth() function
833 * - Parity Control and mode configuration using @ref LL_USART_SetParity() function
834 * - Stop bits configuration using @ref LL_USART_SetStopBitsLength() function
835 * @rmtoll CR1 PS LL_USART_ConfigCharacter\n
836 * CR1 PCE LL_USART_ConfigCharacter\n
837 * CR1 M LL_USART_ConfigCharacter\n
838 * CR2 STOP LL_USART_ConfigCharacter
839 * @param USARTx USART Instance
840 * @param DataWidth This parameter can be one of the following values:
841 * @arg @ref LL_USART_DATAWIDTH_8B
842 * @arg @ref LL_USART_DATAWIDTH_9B
843 * @param Parity This parameter can be one of the following values:
844 * @arg @ref LL_USART_PARITY_NONE
845 * @arg @ref LL_USART_PARITY_EVEN
846 * @arg @ref LL_USART_PARITY_ODD
847 * @param StopBits This parameter can be one of the following values:
848 * @arg @ref LL_USART_STOPBITS_0_5
849 * @arg @ref LL_USART_STOPBITS_1
850 * @arg @ref LL_USART_STOPBITS_1_5
851 * @arg @ref LL_USART_STOPBITS_2
852 * @retval None
853 */
LL_USART_ConfigCharacter(USART_TypeDef * USARTx,uint32_t DataWidth,uint32_t Parity,uint32_t StopBits)854 __STATIC_INLINE void LL_USART_ConfigCharacter(USART_TypeDef *USARTx, uint32_t DataWidth, uint32_t Parity,
855 uint32_t StopBits)
856 {
857 MODIFY_REG(USARTx->CR1, USART_CR1_PS | USART_CR1_PCE | USART_CR1_M, Parity | DataWidth);
858 MODIFY_REG(USARTx->CR2, USART_CR2_STOP, StopBits);
859 }
860
861 /**
862 * @brief Set Address of the USART node.
863 * @note This is used in multiprocessor communication during Mute mode or Stop mode,
864 * for wake up with address mark detection.
865 * @rmtoll CR2 ADD LL_USART_SetNodeAddress
866 * @param USARTx USART Instance
867 * @param NodeAddress 4 bit Address of the USART node.
868 * @retval None
869 */
LL_USART_SetNodeAddress(USART_TypeDef * USARTx,uint32_t NodeAddress)870 __STATIC_INLINE void LL_USART_SetNodeAddress(USART_TypeDef *USARTx, uint32_t NodeAddress)
871 {
872 MODIFY_REG(USARTx->CR2, USART_CR2_ADD, (NodeAddress & USART_CR2_ADD));
873 }
874
875 /**
876 * @brief Return 4 bit Address of the USART node as set in ADD field of CR2.
877 * @note only 4bits (b3-b0) of returned value are relevant (b31-b4 are not relevant)
878 * @rmtoll CR2 ADD LL_USART_GetNodeAddress
879 * @param USARTx USART Instance
880 * @retval Address of the USART node (Value between Min_Data=0 and Max_Data=255)
881 */
LL_USART_GetNodeAddress(const USART_TypeDef * USARTx)882 __STATIC_INLINE uint32_t LL_USART_GetNodeAddress(const USART_TypeDef *USARTx)
883 {
884 return (uint32_t)(READ_BIT(USARTx->CR2, USART_CR2_ADD));
885 }
886
887 /**
888 * @brief Enable RTS HW Flow Control
889 * @note Macro IS_UART_HWFLOW_INSTANCE(USARTx) can be used to check whether or not
890 * Hardware Flow control feature is supported by the USARTx instance.
891 * @rmtoll CR3 RTSE LL_USART_EnableRTSHWFlowCtrl
892 * @param USARTx USART Instance
893 * @retval None
894 */
LL_USART_EnableRTSHWFlowCtrl(USART_TypeDef * USARTx)895 __STATIC_INLINE void LL_USART_EnableRTSHWFlowCtrl(USART_TypeDef *USARTx)
896 {
897 SET_BIT(USARTx->CR3, USART_CR3_RTSE);
898 }
899
900 /**
901 * @brief Disable RTS HW Flow Control
902 * @note Macro IS_UART_HWFLOW_INSTANCE(USARTx) can be used to check whether or not
903 * Hardware Flow control feature is supported by the USARTx instance.
904 * @rmtoll CR3 RTSE LL_USART_DisableRTSHWFlowCtrl
905 * @param USARTx USART Instance
906 * @retval None
907 */
LL_USART_DisableRTSHWFlowCtrl(USART_TypeDef * USARTx)908 __STATIC_INLINE void LL_USART_DisableRTSHWFlowCtrl(USART_TypeDef *USARTx)
909 {
910 CLEAR_BIT(USARTx->CR3, USART_CR3_RTSE);
911 }
912
913 /**
914 * @brief Enable CTS HW Flow Control
915 * @note Macro IS_UART_HWFLOW_INSTANCE(USARTx) can be used to check whether or not
916 * Hardware Flow control feature is supported by the USARTx instance.
917 * @rmtoll CR3 CTSE LL_USART_EnableCTSHWFlowCtrl
918 * @param USARTx USART Instance
919 * @retval None
920 */
LL_USART_EnableCTSHWFlowCtrl(USART_TypeDef * USARTx)921 __STATIC_INLINE void LL_USART_EnableCTSHWFlowCtrl(USART_TypeDef *USARTx)
922 {
923 SET_BIT(USARTx->CR3, USART_CR3_CTSE);
924 }
925
926 /**
927 * @brief Disable CTS HW Flow Control
928 * @note Macro IS_UART_HWFLOW_INSTANCE(USARTx) can be used to check whether or not
929 * Hardware Flow control feature is supported by the USARTx instance.
930 * @rmtoll CR3 CTSE LL_USART_DisableCTSHWFlowCtrl
931 * @param USARTx USART Instance
932 * @retval None
933 */
LL_USART_DisableCTSHWFlowCtrl(USART_TypeDef * USARTx)934 __STATIC_INLINE void LL_USART_DisableCTSHWFlowCtrl(USART_TypeDef *USARTx)
935 {
936 CLEAR_BIT(USARTx->CR3, USART_CR3_CTSE);
937 }
938
939 /**
940 * @brief Configure HW Flow Control mode (both CTS and RTS)
941 * @note Macro IS_UART_HWFLOW_INSTANCE(USARTx) can be used to check whether or not
942 * Hardware Flow control feature is supported by the USARTx instance.
943 * @rmtoll CR3 RTSE LL_USART_SetHWFlowCtrl\n
944 * CR3 CTSE LL_USART_SetHWFlowCtrl
945 * @param USARTx USART Instance
946 * @param HardwareFlowControl This parameter can be one of the following values:
947 * @arg @ref LL_USART_HWCONTROL_NONE
948 * @arg @ref LL_USART_HWCONTROL_RTS
949 * @arg @ref LL_USART_HWCONTROL_CTS
950 * @arg @ref LL_USART_HWCONTROL_RTS_CTS
951 * @retval None
952 */
LL_USART_SetHWFlowCtrl(USART_TypeDef * USARTx,uint32_t HardwareFlowControl)953 __STATIC_INLINE void LL_USART_SetHWFlowCtrl(USART_TypeDef *USARTx, uint32_t HardwareFlowControl)
954 {
955 MODIFY_REG(USARTx->CR3, USART_CR3_RTSE | USART_CR3_CTSE, HardwareFlowControl);
956 }
957
958 /**
959 * @brief Return HW Flow Control configuration (both CTS and RTS)
960 * @note Macro IS_UART_HWFLOW_INSTANCE(USARTx) can be used to check whether or not
961 * Hardware Flow control feature is supported by the USARTx instance.
962 * @rmtoll CR3 RTSE LL_USART_GetHWFlowCtrl\n
963 * CR3 CTSE LL_USART_GetHWFlowCtrl
964 * @param USARTx USART Instance
965 * @retval Returned value can be one of the following values:
966 * @arg @ref LL_USART_HWCONTROL_NONE
967 * @arg @ref LL_USART_HWCONTROL_RTS
968 * @arg @ref LL_USART_HWCONTROL_CTS
969 * @arg @ref LL_USART_HWCONTROL_RTS_CTS
970 */
LL_USART_GetHWFlowCtrl(const USART_TypeDef * USARTx)971 __STATIC_INLINE uint32_t LL_USART_GetHWFlowCtrl(const USART_TypeDef *USARTx)
972 {
973 return (uint32_t)(READ_BIT(USARTx->CR3, USART_CR3_RTSE | USART_CR3_CTSE));
974 }
975
976 #if defined(USART_CR3_ONEBIT)
977 /**
978 * @brief Enable One bit sampling method
979 * @rmtoll CR3 ONEBIT LL_USART_EnableOneBitSamp
980 * @param USARTx USART Instance
981 * @retval None
982 */
LL_USART_EnableOneBitSamp(USART_TypeDef * USARTx)983 __STATIC_INLINE void LL_USART_EnableOneBitSamp(USART_TypeDef *USARTx)
984 {
985 SET_BIT(USARTx->CR3, USART_CR3_ONEBIT);
986 }
987
988 /**
989 * @brief Disable One bit sampling method
990 * @rmtoll CR3 ONEBIT LL_USART_DisableOneBitSamp
991 * @param USARTx USART Instance
992 * @retval None
993 */
LL_USART_DisableOneBitSamp(USART_TypeDef * USARTx)994 __STATIC_INLINE void LL_USART_DisableOneBitSamp(USART_TypeDef *USARTx)
995 {
996 CLEAR_BIT(USARTx->CR3, USART_CR3_ONEBIT);
997 }
998
999 /**
1000 * @brief Indicate if One bit sampling method is enabled
1001 * @rmtoll CR3 ONEBIT LL_USART_IsEnabledOneBitSamp
1002 * @param USARTx USART Instance
1003 * @retval State of bit (1 or 0).
1004 */
LL_USART_IsEnabledOneBitSamp(const USART_TypeDef * USARTx)1005 __STATIC_INLINE uint32_t LL_USART_IsEnabledOneBitSamp(const USART_TypeDef *USARTx)
1006 {
1007 return (READ_BIT(USARTx->CR3, USART_CR3_ONEBIT) == (USART_CR3_ONEBIT));
1008 }
1009 #endif /* USART_OneBitSampling_Feature */
1010
1011 #if defined(USART_CR1_OVER8)
1012 /**
1013 * @brief Configure USART BRR register for achieving expected Baud Rate value.
1014 * @note Compute and set USARTDIV value in BRR Register (full BRR content)
1015 * according to used Peripheral Clock, Oversampling mode, and expected Baud Rate values
1016 * @note Peripheral clock and Baud rate values provided as function parameters should be valid
1017 * (Baud rate value != 0)
1018 * @rmtoll BRR BRR LL_USART_SetBaudRate
1019 * @param USARTx USART Instance
1020 * @param PeriphClk Peripheral Clock
1021 * @param OverSampling This parameter can be one of the following values:
1022 * @arg @ref LL_USART_OVERSAMPLING_16
1023 * @arg @ref LL_USART_OVERSAMPLING_8
1024 * @param BaudRate Baud Rate
1025 * @retval None
1026 */
LL_USART_SetBaudRate(USART_TypeDef * USARTx,uint32_t PeriphClk,uint32_t OverSampling,uint32_t BaudRate)1027 __STATIC_INLINE void LL_USART_SetBaudRate(USART_TypeDef *USARTx, uint32_t PeriphClk, uint32_t OverSampling,
1028 uint32_t BaudRate)
1029 {
1030 if (OverSampling == LL_USART_OVERSAMPLING_8)
1031 {
1032 USARTx->BRR = (uint16_t)(__LL_USART_DIV_SAMPLING8(PeriphClk, BaudRate));
1033 }
1034 else
1035 {
1036 USARTx->BRR = (uint16_t)(__LL_USART_DIV_SAMPLING16(PeriphClk, BaudRate));
1037 }
1038 }
1039
1040 /**
1041 * @brief Return current Baud Rate value, according to USARTDIV present in BRR register
1042 * (full BRR content), and to used Peripheral Clock and Oversampling mode values
1043 * @note In case of non-initialized or invalid value stored in BRR register, value 0 will be returned.
1044 * @rmtoll BRR BRR LL_USART_GetBaudRate
1045 * @param USARTx USART Instance
1046 * @param PeriphClk Peripheral Clock
1047 * @param OverSampling This parameter can be one of the following values:
1048 * @arg @ref LL_USART_OVERSAMPLING_16
1049 * @arg @ref LL_USART_OVERSAMPLING_8
1050 * @retval Baud Rate
1051 */
LL_USART_GetBaudRate(const USART_TypeDef * USARTx,uint32_t PeriphClk,uint32_t OverSampling)1052 __STATIC_INLINE uint32_t LL_USART_GetBaudRate(const USART_TypeDef *USARTx, uint32_t PeriphClk, uint32_t OverSampling)
1053 {
1054 uint32_t usartdiv = 0x0U;
1055 uint32_t brrresult = 0x0U;
1056
1057 usartdiv = USARTx->BRR;
1058
1059 if (OverSampling == LL_USART_OVERSAMPLING_8)
1060 {
1061 if ((usartdiv & 0xFFF7U) != 0U)
1062 {
1063 usartdiv = (uint16_t)((usartdiv & 0xFFF0U) | ((usartdiv & 0x0007U) << 1U)) ;
1064 brrresult = (PeriphClk * 2U) / usartdiv;
1065 }
1066 }
1067 else
1068 {
1069 if ((usartdiv & 0xFFFFU) != 0U)
1070 {
1071 brrresult = PeriphClk / usartdiv;
1072 }
1073 }
1074 return (brrresult);
1075 }
1076 #else
1077 /**
1078 * @brief Configure USART BRR register for achieving expected Baud Rate value.
1079 * @note Compute and set USARTDIV value in BRR Register (full BRR content)
1080 * according to used Peripheral Clock, Oversampling mode, and expected Baud Rate values
1081 * @note Peripheral clock and Baud rate values provided as function parameters should be valid
1082 * (Baud rate value != 0)
1083 * @rmtoll BRR BRR LL_USART_SetBaudRate
1084 * @param USARTx USART Instance
1085 * @param PeriphClk Peripheral Clock
1086 * @param BaudRate Baud Rate
1087 * @retval None
1088 */
LL_USART_SetBaudRate(USART_TypeDef * USARTx,uint32_t PeriphClk,uint32_t BaudRate)1089 __STATIC_INLINE void LL_USART_SetBaudRate(USART_TypeDef *USARTx, uint32_t PeriphClk, uint32_t BaudRate)
1090 {
1091 USARTx->BRR = (uint16_t)(__LL_USART_DIV_SAMPLING16(PeriphClk, BaudRate));
1092 }
1093
1094 /**
1095 * @brief Return current Baud Rate value, according to USARTDIV present in BRR register
1096 * (full BRR content), and to used Peripheral Clock and Oversampling mode values
1097 * @note In case of non-initialized or invalid value stored in BRR register, value 0 will be returned.
1098 * @rmtoll BRR BRR LL_USART_GetBaudRate
1099 * @param USARTx USART Instance
1100 * @param PeriphClk Peripheral Clock
1101 * @retval Baud Rate
1102 */
LL_USART_GetBaudRate(const USART_TypeDef * USARTx,uint32_t PeriphClk)1103 __STATIC_INLINE uint32_t LL_USART_GetBaudRate(const USART_TypeDef *USARTx, uint32_t PeriphClk)
1104 {
1105 uint32_t usartdiv = 0x0U;
1106 uint32_t brrresult = 0x0U;
1107
1108 usartdiv = USARTx->BRR;
1109
1110 if ((usartdiv & 0xFFFFU) != 0U)
1111 {
1112 brrresult = PeriphClk / usartdiv;
1113 }
1114 return (brrresult);
1115 }
1116 #endif /* USART_OverSampling_Feature */
1117
1118 /**
1119 * @}
1120 */
1121
1122 /** @defgroup USART_LL_EF_Configuration_IRDA Configuration functions related to Irda feature
1123 * @{
1124 */
1125
1126 /**
1127 * @brief Enable IrDA mode
1128 * @note Macro IS_IRDA_INSTANCE(USARTx) can be used to check whether or not
1129 * IrDA feature is supported by the USARTx instance.
1130 * @rmtoll CR3 IREN LL_USART_EnableIrda
1131 * @param USARTx USART Instance
1132 * @retval None
1133 */
LL_USART_EnableIrda(USART_TypeDef * USARTx)1134 __STATIC_INLINE void LL_USART_EnableIrda(USART_TypeDef *USARTx)
1135 {
1136 SET_BIT(USARTx->CR3, USART_CR3_IREN);
1137 }
1138
1139 /**
1140 * @brief Disable IrDA mode
1141 * @note Macro IS_IRDA_INSTANCE(USARTx) can be used to check whether or not
1142 * IrDA feature is supported by the USARTx instance.
1143 * @rmtoll CR3 IREN LL_USART_DisableIrda
1144 * @param USARTx USART Instance
1145 * @retval None
1146 */
LL_USART_DisableIrda(USART_TypeDef * USARTx)1147 __STATIC_INLINE void LL_USART_DisableIrda(USART_TypeDef *USARTx)
1148 {
1149 CLEAR_BIT(USARTx->CR3, USART_CR3_IREN);
1150 }
1151
1152 /**
1153 * @brief Indicate if IrDA mode is enabled
1154 * @note Macro IS_IRDA_INSTANCE(USARTx) can be used to check whether or not
1155 * IrDA feature is supported by the USARTx instance.
1156 * @rmtoll CR3 IREN LL_USART_IsEnabledIrda
1157 * @param USARTx USART Instance
1158 * @retval State of bit (1 or 0).
1159 */
LL_USART_IsEnabledIrda(const USART_TypeDef * USARTx)1160 __STATIC_INLINE uint32_t LL_USART_IsEnabledIrda(const USART_TypeDef *USARTx)
1161 {
1162 return (READ_BIT(USARTx->CR3, USART_CR3_IREN) == (USART_CR3_IREN));
1163 }
1164
1165 /**
1166 * @brief Configure IrDA Power Mode (Normal or Low Power)
1167 * @note Macro IS_IRDA_INSTANCE(USARTx) can be used to check whether or not
1168 * IrDA feature is supported by the USARTx instance.
1169 * @rmtoll CR3 IRLP LL_USART_SetIrdaPowerMode
1170 * @param USARTx USART Instance
1171 * @param PowerMode This parameter can be one of the following values:
1172 * @arg @ref LL_USART_IRDA_POWER_NORMAL
1173 * @arg @ref LL_USART_IRDA_POWER_LOW
1174 * @retval None
1175 */
LL_USART_SetIrdaPowerMode(USART_TypeDef * USARTx,uint32_t PowerMode)1176 __STATIC_INLINE void LL_USART_SetIrdaPowerMode(USART_TypeDef *USARTx, uint32_t PowerMode)
1177 {
1178 MODIFY_REG(USARTx->CR3, USART_CR3_IRLP, PowerMode);
1179 }
1180
1181 /**
1182 * @brief Retrieve IrDA Power Mode configuration (Normal or Low Power)
1183 * @note Macro IS_IRDA_INSTANCE(USARTx) can be used to check whether or not
1184 * IrDA feature is supported by the USARTx instance.
1185 * @rmtoll CR3 IRLP LL_USART_GetIrdaPowerMode
1186 * @param USARTx USART Instance
1187 * @retval Returned value can be one of the following values:
1188 * @arg @ref LL_USART_IRDA_POWER_NORMAL
1189 * @arg @ref LL_USART_PHASE_2EDGE
1190 */
LL_USART_GetIrdaPowerMode(const USART_TypeDef * USARTx)1191 __STATIC_INLINE uint32_t LL_USART_GetIrdaPowerMode(const USART_TypeDef *USARTx)
1192 {
1193 return (uint32_t)(READ_BIT(USARTx->CR3, USART_CR3_IRLP));
1194 }
1195
1196 /**
1197 * @brief Set Irda prescaler value, used for dividing the USART clock source
1198 * to achieve the Irda Low Power frequency (8 bits value)
1199 * @note Macro IS_IRDA_INSTANCE(USARTx) can be used to check whether or not
1200 * IrDA feature is supported by the USARTx instance.
1201 * @rmtoll GTPR PSC LL_USART_SetIrdaPrescaler
1202 * @param USARTx USART Instance
1203 * @param PrescalerValue Value between Min_Data=0x00 and Max_Data=0xFF
1204 * @retval None
1205 */
LL_USART_SetIrdaPrescaler(USART_TypeDef * USARTx,uint32_t PrescalerValue)1206 __STATIC_INLINE void LL_USART_SetIrdaPrescaler(USART_TypeDef *USARTx, uint32_t PrescalerValue)
1207 {
1208 MODIFY_REG(USARTx->GTPR, USART_GTPR_PSC, PrescalerValue);
1209 }
1210
1211 /**
1212 * @brief Return Irda prescaler value, used for dividing the USART clock source
1213 * to achieve the Irda Low Power frequency (8 bits value)
1214 * @note Macro IS_IRDA_INSTANCE(USARTx) can be used to check whether or not
1215 * IrDA feature is supported by the USARTx instance.
1216 * @rmtoll GTPR PSC LL_USART_GetIrdaPrescaler
1217 * @param USARTx USART Instance
1218 * @retval Irda prescaler value (Value between Min_Data=0x00 and Max_Data=0xFF)
1219 */
LL_USART_GetIrdaPrescaler(const USART_TypeDef * USARTx)1220 __STATIC_INLINE uint32_t LL_USART_GetIrdaPrescaler(const USART_TypeDef *USARTx)
1221 {
1222 return (uint32_t)(READ_BIT(USARTx->GTPR, USART_GTPR_PSC));
1223 }
1224
1225 /**
1226 * @}
1227 */
1228
1229 /** @defgroup USART_LL_EF_Configuration_Smartcard Configuration functions related to Smartcard feature
1230 * @{
1231 */
1232
1233 /**
1234 * @brief Enable Smartcard NACK transmission
1235 * @note Macro IS_SMARTCARD_INSTANCE(USARTx) can be used to check whether or not
1236 * Smartcard feature is supported by the USARTx instance.
1237 * @rmtoll CR3 NACK LL_USART_EnableSmartcardNACK
1238 * @param USARTx USART Instance
1239 * @retval None
1240 */
LL_USART_EnableSmartcardNACK(USART_TypeDef * USARTx)1241 __STATIC_INLINE void LL_USART_EnableSmartcardNACK(USART_TypeDef *USARTx)
1242 {
1243 SET_BIT(USARTx->CR3, USART_CR3_NACK);
1244 }
1245
1246 /**
1247 * @brief Disable Smartcard NACK transmission
1248 * @note Macro IS_SMARTCARD_INSTANCE(USARTx) can be used to check whether or not
1249 * Smartcard feature is supported by the USARTx instance.
1250 * @rmtoll CR3 NACK LL_USART_DisableSmartcardNACK
1251 * @param USARTx USART Instance
1252 * @retval None
1253 */
LL_USART_DisableSmartcardNACK(USART_TypeDef * USARTx)1254 __STATIC_INLINE void LL_USART_DisableSmartcardNACK(USART_TypeDef *USARTx)
1255 {
1256 CLEAR_BIT(USARTx->CR3, USART_CR3_NACK);
1257 }
1258
1259 /**
1260 * @brief Indicate if Smartcard NACK transmission is enabled
1261 * @note Macro IS_SMARTCARD_INSTANCE(USARTx) can be used to check whether or not
1262 * Smartcard feature is supported by the USARTx instance.
1263 * @rmtoll CR3 NACK LL_USART_IsEnabledSmartcardNACK
1264 * @param USARTx USART Instance
1265 * @retval State of bit (1 or 0).
1266 */
LL_USART_IsEnabledSmartcardNACK(const USART_TypeDef * USARTx)1267 __STATIC_INLINE uint32_t LL_USART_IsEnabledSmartcardNACK(const USART_TypeDef *USARTx)
1268 {
1269 return (READ_BIT(USARTx->CR3, USART_CR3_NACK) == (USART_CR3_NACK));
1270 }
1271
1272 /**
1273 * @brief Enable Smartcard mode
1274 * @note Macro IS_SMARTCARD_INSTANCE(USARTx) can be used to check whether or not
1275 * Smartcard feature is supported by the USARTx instance.
1276 * @rmtoll CR3 SCEN LL_USART_EnableSmartcard
1277 * @param USARTx USART Instance
1278 * @retval None
1279 */
LL_USART_EnableSmartcard(USART_TypeDef * USARTx)1280 __STATIC_INLINE void LL_USART_EnableSmartcard(USART_TypeDef *USARTx)
1281 {
1282 SET_BIT(USARTx->CR3, USART_CR3_SCEN);
1283 }
1284
1285 /**
1286 * @brief Disable Smartcard mode
1287 * @note Macro IS_SMARTCARD_INSTANCE(USARTx) can be used to check whether or not
1288 * Smartcard feature is supported by the USARTx instance.
1289 * @rmtoll CR3 SCEN LL_USART_DisableSmartcard
1290 * @param USARTx USART Instance
1291 * @retval None
1292 */
LL_USART_DisableSmartcard(USART_TypeDef * USARTx)1293 __STATIC_INLINE void LL_USART_DisableSmartcard(USART_TypeDef *USARTx)
1294 {
1295 CLEAR_BIT(USARTx->CR3, USART_CR3_SCEN);
1296 }
1297
1298 /**
1299 * @brief Indicate if Smartcard mode is enabled
1300 * @note Macro IS_SMARTCARD_INSTANCE(USARTx) can be used to check whether or not
1301 * Smartcard feature is supported by the USARTx instance.
1302 * @rmtoll CR3 SCEN LL_USART_IsEnabledSmartcard
1303 * @param USARTx USART Instance
1304 * @retval State of bit (1 or 0).
1305 */
LL_USART_IsEnabledSmartcard(const USART_TypeDef * USARTx)1306 __STATIC_INLINE uint32_t LL_USART_IsEnabledSmartcard(const USART_TypeDef *USARTx)
1307 {
1308 return (READ_BIT(USARTx->CR3, USART_CR3_SCEN) == (USART_CR3_SCEN));
1309 }
1310
1311 /**
1312 * @brief Set Smartcard prescaler value, used for dividing the USART clock
1313 * source to provide the SMARTCARD Clock (5 bits value)
1314 * @note Macro IS_SMARTCARD_INSTANCE(USARTx) can be used to check whether or not
1315 * Smartcard feature is supported by the USARTx instance.
1316 * @rmtoll GTPR PSC LL_USART_SetSmartcardPrescaler
1317 * @param USARTx USART Instance
1318 * @param PrescalerValue Value between Min_Data=0 and Max_Data=31
1319 * @retval None
1320 */
LL_USART_SetSmartcardPrescaler(USART_TypeDef * USARTx,uint32_t PrescalerValue)1321 __STATIC_INLINE void LL_USART_SetSmartcardPrescaler(USART_TypeDef *USARTx, uint32_t PrescalerValue)
1322 {
1323 MODIFY_REG(USARTx->GTPR, USART_GTPR_PSC, PrescalerValue);
1324 }
1325
1326 /**
1327 * @brief Return Smartcard prescaler value, used for dividing the USART clock
1328 * source to provide the SMARTCARD Clock (5 bits value)
1329 * @note Macro IS_SMARTCARD_INSTANCE(USARTx) can be used to check whether or not
1330 * Smartcard feature is supported by the USARTx instance.
1331 * @rmtoll GTPR PSC LL_USART_GetSmartcardPrescaler
1332 * @param USARTx USART Instance
1333 * @retval Smartcard prescaler value (Value between Min_Data=0 and Max_Data=31)
1334 */
LL_USART_GetSmartcardPrescaler(const USART_TypeDef * USARTx)1335 __STATIC_INLINE uint32_t LL_USART_GetSmartcardPrescaler(const USART_TypeDef *USARTx)
1336 {
1337 return (uint32_t)(READ_BIT(USARTx->GTPR, USART_GTPR_PSC));
1338 }
1339
1340 /**
1341 * @brief Set Smartcard Guard time value, expressed in nb of baud clocks periods
1342 * (GT[7:0] bits : Guard time value)
1343 * @note Macro IS_SMARTCARD_INSTANCE(USARTx) can be used to check whether or not
1344 * Smartcard feature is supported by the USARTx instance.
1345 * @rmtoll GTPR GT LL_USART_SetSmartcardGuardTime
1346 * @param USARTx USART Instance
1347 * @param GuardTime Value between Min_Data=0x00 and Max_Data=0xFF
1348 * @retval None
1349 */
LL_USART_SetSmartcardGuardTime(USART_TypeDef * USARTx,uint32_t GuardTime)1350 __STATIC_INLINE void LL_USART_SetSmartcardGuardTime(USART_TypeDef *USARTx, uint32_t GuardTime)
1351 {
1352 MODIFY_REG(USARTx->GTPR, USART_GTPR_GT, GuardTime << USART_POSITION_GTPR_GT);
1353 }
1354
1355 /**
1356 * @brief Return Smartcard Guard time value, expressed in nb of baud clocks periods
1357 * (GT[7:0] bits : Guard time value)
1358 * @note Macro IS_SMARTCARD_INSTANCE(USARTx) can be used to check whether or not
1359 * Smartcard feature is supported by the USARTx instance.
1360 * @rmtoll GTPR GT LL_USART_GetSmartcardGuardTime
1361 * @param USARTx USART Instance
1362 * @retval Smartcard Guard time value (Value between Min_Data=0x00 and Max_Data=0xFF)
1363 */
LL_USART_GetSmartcardGuardTime(const USART_TypeDef * USARTx)1364 __STATIC_INLINE uint32_t LL_USART_GetSmartcardGuardTime(const USART_TypeDef *USARTx)
1365 {
1366 return (uint32_t)(READ_BIT(USARTx->GTPR, USART_GTPR_GT) >> USART_POSITION_GTPR_GT);
1367 }
1368
1369 /**
1370 * @}
1371 */
1372
1373 /** @defgroup USART_LL_EF_Configuration_HalfDuplex Configuration functions related to Half Duplex feature
1374 * @{
1375 */
1376
1377 /**
1378 * @brief Enable Single Wire Half-Duplex mode
1379 * @note Macro IS_UART_HALFDUPLEX_INSTANCE(USARTx) can be used to check whether or not
1380 * Half-Duplex mode is supported by the USARTx instance.
1381 * @rmtoll CR3 HDSEL LL_USART_EnableHalfDuplex
1382 * @param USARTx USART Instance
1383 * @retval None
1384 */
LL_USART_EnableHalfDuplex(USART_TypeDef * USARTx)1385 __STATIC_INLINE void LL_USART_EnableHalfDuplex(USART_TypeDef *USARTx)
1386 {
1387 SET_BIT(USARTx->CR3, USART_CR3_HDSEL);
1388 }
1389
1390 /**
1391 * @brief Disable Single Wire Half-Duplex mode
1392 * @note Macro IS_UART_HALFDUPLEX_INSTANCE(USARTx) can be used to check whether or not
1393 * Half-Duplex mode is supported by the USARTx instance.
1394 * @rmtoll CR3 HDSEL LL_USART_DisableHalfDuplex
1395 * @param USARTx USART Instance
1396 * @retval None
1397 */
LL_USART_DisableHalfDuplex(USART_TypeDef * USARTx)1398 __STATIC_INLINE void LL_USART_DisableHalfDuplex(USART_TypeDef *USARTx)
1399 {
1400 CLEAR_BIT(USARTx->CR3, USART_CR3_HDSEL);
1401 }
1402
1403 /**
1404 * @brief Indicate if Single Wire Half-Duplex mode is enabled
1405 * @note Macro IS_UART_HALFDUPLEX_INSTANCE(USARTx) can be used to check whether or not
1406 * Half-Duplex mode is supported by the USARTx instance.
1407 * @rmtoll CR3 HDSEL LL_USART_IsEnabledHalfDuplex
1408 * @param USARTx USART Instance
1409 * @retval State of bit (1 or 0).
1410 */
LL_USART_IsEnabledHalfDuplex(const USART_TypeDef * USARTx)1411 __STATIC_INLINE uint32_t LL_USART_IsEnabledHalfDuplex(const USART_TypeDef *USARTx)
1412 {
1413 return (READ_BIT(USARTx->CR3, USART_CR3_HDSEL) == (USART_CR3_HDSEL));
1414 }
1415
1416 /**
1417 * @}
1418 */
1419
1420 /** @defgroup USART_LL_EF_Configuration_LIN Configuration functions related to LIN feature
1421 * @{
1422 */
1423
1424 /**
1425 * @brief Set LIN Break Detection Length
1426 * @note Macro IS_UART_LIN_INSTANCE(USARTx) can be used to check whether or not
1427 * LIN feature is supported by the USARTx instance.
1428 * @rmtoll CR2 LBDL LL_USART_SetLINBrkDetectionLen
1429 * @param USARTx USART Instance
1430 * @param LINBDLength This parameter can be one of the following values:
1431 * @arg @ref LL_USART_LINBREAK_DETECT_10B
1432 * @arg @ref LL_USART_LINBREAK_DETECT_11B
1433 * @retval None
1434 */
LL_USART_SetLINBrkDetectionLen(USART_TypeDef * USARTx,uint32_t LINBDLength)1435 __STATIC_INLINE void LL_USART_SetLINBrkDetectionLen(USART_TypeDef *USARTx, uint32_t LINBDLength)
1436 {
1437 MODIFY_REG(USARTx->CR2, USART_CR2_LBDL, LINBDLength);
1438 }
1439
1440 /**
1441 * @brief Return LIN Break Detection Length
1442 * @note Macro IS_UART_LIN_INSTANCE(USARTx) can be used to check whether or not
1443 * LIN feature is supported by the USARTx instance.
1444 * @rmtoll CR2 LBDL LL_USART_GetLINBrkDetectionLen
1445 * @param USARTx USART Instance
1446 * @retval Returned value can be one of the following values:
1447 * @arg @ref LL_USART_LINBREAK_DETECT_10B
1448 * @arg @ref LL_USART_LINBREAK_DETECT_11B
1449 */
LL_USART_GetLINBrkDetectionLen(const USART_TypeDef * USARTx)1450 __STATIC_INLINE uint32_t LL_USART_GetLINBrkDetectionLen(const USART_TypeDef *USARTx)
1451 {
1452 return (uint32_t)(READ_BIT(USARTx->CR2, USART_CR2_LBDL));
1453 }
1454
1455 /**
1456 * @brief Enable LIN mode
1457 * @note Macro IS_UART_LIN_INSTANCE(USARTx) can be used to check whether or not
1458 * LIN feature is supported by the USARTx instance.
1459 * @rmtoll CR2 LINEN LL_USART_EnableLIN
1460 * @param USARTx USART Instance
1461 * @retval None
1462 */
LL_USART_EnableLIN(USART_TypeDef * USARTx)1463 __STATIC_INLINE void LL_USART_EnableLIN(USART_TypeDef *USARTx)
1464 {
1465 SET_BIT(USARTx->CR2, USART_CR2_LINEN);
1466 }
1467
1468 /**
1469 * @brief Disable LIN mode
1470 * @note Macro IS_UART_LIN_INSTANCE(USARTx) can be used to check whether or not
1471 * LIN feature is supported by the USARTx instance.
1472 * @rmtoll CR2 LINEN LL_USART_DisableLIN
1473 * @param USARTx USART Instance
1474 * @retval None
1475 */
LL_USART_DisableLIN(USART_TypeDef * USARTx)1476 __STATIC_INLINE void LL_USART_DisableLIN(USART_TypeDef *USARTx)
1477 {
1478 CLEAR_BIT(USARTx->CR2, USART_CR2_LINEN);
1479 }
1480
1481 /**
1482 * @brief Indicate if LIN mode is enabled
1483 * @note Macro IS_UART_LIN_INSTANCE(USARTx) can be used to check whether or not
1484 * LIN feature is supported by the USARTx instance.
1485 * @rmtoll CR2 LINEN LL_USART_IsEnabledLIN
1486 * @param USARTx USART Instance
1487 * @retval State of bit (1 or 0).
1488 */
LL_USART_IsEnabledLIN(const USART_TypeDef * USARTx)1489 __STATIC_INLINE uint32_t LL_USART_IsEnabledLIN(const USART_TypeDef *USARTx)
1490 {
1491 return (READ_BIT(USARTx->CR2, USART_CR2_LINEN) == (USART_CR2_LINEN));
1492 }
1493
1494 /**
1495 * @}
1496 */
1497
1498 /** @defgroup USART_LL_EF_AdvancedConfiguration Advanced Configurations services
1499 * @{
1500 */
1501
1502 /**
1503 * @brief Perform basic configuration of USART for enabling use in Asynchronous Mode (UART)
1504 * @note In UART mode, the following bits must be kept cleared:
1505 * - LINEN bit in the USART_CR2 register,
1506 * - CLKEN bit in the USART_CR2 register,
1507 * - SCEN bit in the USART_CR3 register,
1508 * - IREN bit in the USART_CR3 register,
1509 * - HDSEL bit in the USART_CR3 register.
1510 * @note Call of this function is equivalent to following function call sequence :
1511 * - Clear LINEN in CR2 using @ref LL_USART_DisableLIN() function
1512 * - Clear CLKEN in CR2 using @ref LL_USART_DisableSCLKOutput() function
1513 * - Clear SCEN in CR3 using @ref LL_USART_DisableSmartcard() function
1514 * - Clear IREN in CR3 using @ref LL_USART_DisableIrda() function
1515 * - Clear HDSEL in CR3 using @ref LL_USART_DisableHalfDuplex() function
1516 * @note Other remaining configurations items related to Asynchronous Mode
1517 * (as Baud Rate, Word length, Parity, ...) should be set using
1518 * dedicated functions
1519 * @rmtoll CR2 LINEN LL_USART_ConfigAsyncMode\n
1520 * CR2 CLKEN LL_USART_ConfigAsyncMode\n
1521 * CR3 SCEN LL_USART_ConfigAsyncMode\n
1522 * CR3 IREN LL_USART_ConfigAsyncMode\n
1523 * CR3 HDSEL LL_USART_ConfigAsyncMode
1524 * @param USARTx USART Instance
1525 * @retval None
1526 */
LL_USART_ConfigAsyncMode(USART_TypeDef * USARTx)1527 __STATIC_INLINE void LL_USART_ConfigAsyncMode(USART_TypeDef *USARTx)
1528 {
1529 /* In Asynchronous mode, the following bits must be kept cleared:
1530 - LINEN, CLKEN bits in the USART_CR2 register,
1531 - SCEN, IREN and HDSEL bits in the USART_CR3 register.*/
1532 CLEAR_BIT(USARTx->CR2, (USART_CR2_LINEN | USART_CR2_CLKEN));
1533 CLEAR_BIT(USARTx->CR3, (USART_CR3_SCEN | USART_CR3_IREN | USART_CR3_HDSEL));
1534 }
1535
1536 /**
1537 * @brief Perform basic configuration of USART for enabling use in Synchronous Mode
1538 * @note In Synchronous mode, the following bits must be kept cleared:
1539 * - LINEN bit in the USART_CR2 register,
1540 * - SCEN bit in the USART_CR3 register,
1541 * - IREN bit in the USART_CR3 register,
1542 * - HDSEL bit in the USART_CR3 register.
1543 * This function also sets the USART in Synchronous mode.
1544 * @note Macro IS_USART_INSTANCE(USARTx) can be used to check whether or not
1545 * Synchronous mode is supported by the USARTx instance.
1546 * @note Call of this function is equivalent to following function call sequence :
1547 * - Clear LINEN in CR2 using @ref LL_USART_DisableLIN() function
1548 * - Clear IREN in CR3 using @ref LL_USART_DisableIrda() function
1549 * - Clear SCEN in CR3 using @ref LL_USART_DisableSmartcard() function
1550 * - Clear HDSEL in CR3 using @ref LL_USART_DisableHalfDuplex() function
1551 * - Set CLKEN in CR2 using @ref LL_USART_EnableSCLKOutput() function
1552 * @note Other remaining configurations items related to Synchronous Mode
1553 * (as Baud Rate, Word length, Parity, Clock Polarity, ...) should be set using
1554 * dedicated functions
1555 * @rmtoll CR2 LINEN LL_USART_ConfigSyncMode\n
1556 * CR2 CLKEN LL_USART_ConfigSyncMode\n
1557 * CR3 SCEN LL_USART_ConfigSyncMode\n
1558 * CR3 IREN LL_USART_ConfigSyncMode\n
1559 * CR3 HDSEL LL_USART_ConfigSyncMode
1560 * @param USARTx USART Instance
1561 * @retval None
1562 */
LL_USART_ConfigSyncMode(USART_TypeDef * USARTx)1563 __STATIC_INLINE void LL_USART_ConfigSyncMode(USART_TypeDef *USARTx)
1564 {
1565 /* In Synchronous mode, the following bits must be kept cleared:
1566 - LINEN bit in the USART_CR2 register,
1567 - SCEN, IREN and HDSEL bits in the USART_CR3 register.*/
1568 CLEAR_BIT(USARTx->CR2, (USART_CR2_LINEN));
1569 CLEAR_BIT(USARTx->CR3, (USART_CR3_SCEN | USART_CR3_IREN | USART_CR3_HDSEL));
1570 /* set the UART/USART in Synchronous mode */
1571 SET_BIT(USARTx->CR2, USART_CR2_CLKEN);
1572 }
1573
1574 /**
1575 * @brief Perform basic configuration of USART for enabling use in LIN Mode
1576 * @note In LIN mode, the following bits must be kept cleared:
1577 * - STOP and CLKEN bits in the USART_CR2 register,
1578 * - SCEN bit in the USART_CR3 register,
1579 * - IREN bit in the USART_CR3 register,
1580 * - HDSEL bit in the USART_CR3 register.
1581 * This function also set the UART/USART in LIN mode.
1582 * @note Macro IS_UART_LIN_INSTANCE(USARTx) can be used to check whether or not
1583 * LIN feature is supported by the USARTx instance.
1584 * @note Call of this function is equivalent to following function call sequence :
1585 * - Clear CLKEN in CR2 using @ref LL_USART_DisableSCLKOutput() function
1586 * - Clear STOP in CR2 using @ref LL_USART_SetStopBitsLength() function
1587 * - Clear SCEN in CR3 using @ref LL_USART_DisableSmartcard() function
1588 * - Clear IREN in CR3 using @ref LL_USART_DisableIrda() function
1589 * - Clear HDSEL in CR3 using @ref LL_USART_DisableHalfDuplex() function
1590 * - Set LINEN in CR2 using @ref LL_USART_EnableLIN() function
1591 * @note Other remaining configurations items related to LIN Mode
1592 * (as Baud Rate, Word length, LIN Break Detection Length, ...) should be set using
1593 * dedicated functions
1594 * @rmtoll CR2 CLKEN LL_USART_ConfigLINMode\n
1595 * CR2 STOP LL_USART_ConfigLINMode\n
1596 * CR2 LINEN LL_USART_ConfigLINMode\n
1597 * CR3 IREN LL_USART_ConfigLINMode\n
1598 * CR3 SCEN LL_USART_ConfigLINMode\n
1599 * CR3 HDSEL LL_USART_ConfigLINMode
1600 * @param USARTx USART Instance
1601 * @retval None
1602 */
LL_USART_ConfigLINMode(USART_TypeDef * USARTx)1603 __STATIC_INLINE void LL_USART_ConfigLINMode(USART_TypeDef *USARTx)
1604 {
1605 /* In LIN mode, the following bits must be kept cleared:
1606 - STOP and CLKEN bits in the USART_CR2 register,
1607 - IREN, SCEN and HDSEL bits in the USART_CR3 register.*/
1608 CLEAR_BIT(USARTx->CR2, (USART_CR2_CLKEN | USART_CR2_STOP));
1609 CLEAR_BIT(USARTx->CR3, (USART_CR3_IREN | USART_CR3_SCEN | USART_CR3_HDSEL));
1610 /* Set the UART/USART in LIN mode */
1611 SET_BIT(USARTx->CR2, USART_CR2_LINEN);
1612 }
1613
1614 /**
1615 * @brief Perform basic configuration of USART for enabling use in Half Duplex Mode
1616 * @note In Half Duplex mode, the following bits must be kept cleared:
1617 * - LINEN bit in the USART_CR2 register,
1618 * - CLKEN bit in the USART_CR2 register,
1619 * - SCEN bit in the USART_CR3 register,
1620 * - IREN bit in the USART_CR3 register,
1621 * This function also sets the UART/USART in Half Duplex mode.
1622 * @note Macro IS_UART_HALFDUPLEX_INSTANCE(USARTx) can be used to check whether or not
1623 * Half-Duplex mode is supported by the USARTx instance.
1624 * @note Call of this function is equivalent to following function call sequence :
1625 * - Clear LINEN in CR2 using @ref LL_USART_DisableLIN() function
1626 * - Clear CLKEN in CR2 using @ref LL_USART_DisableSCLKOutput() function
1627 * - Clear SCEN in CR3 using @ref LL_USART_DisableSmartcard() function
1628 * - Clear IREN in CR3 using @ref LL_USART_DisableIrda() function
1629 * - Set HDSEL in CR3 using @ref LL_USART_EnableHalfDuplex() function
1630 * @note Other remaining configurations items related to Half Duplex Mode
1631 * (as Baud Rate, Word length, Parity, ...) should be set using
1632 * dedicated functions
1633 * @rmtoll CR2 LINEN LL_USART_ConfigHalfDuplexMode\n
1634 * CR2 CLKEN LL_USART_ConfigHalfDuplexMode\n
1635 * CR3 HDSEL LL_USART_ConfigHalfDuplexMode\n
1636 * CR3 SCEN LL_USART_ConfigHalfDuplexMode\n
1637 * CR3 IREN LL_USART_ConfigHalfDuplexMode
1638 * @param USARTx USART Instance
1639 * @retval None
1640 */
LL_USART_ConfigHalfDuplexMode(USART_TypeDef * USARTx)1641 __STATIC_INLINE void LL_USART_ConfigHalfDuplexMode(USART_TypeDef *USARTx)
1642 {
1643 /* In Half Duplex mode, the following bits must be kept cleared:
1644 - LINEN and CLKEN bits in the USART_CR2 register,
1645 - SCEN and IREN bits in the USART_CR3 register.*/
1646 CLEAR_BIT(USARTx->CR2, (USART_CR2_LINEN | USART_CR2_CLKEN));
1647 CLEAR_BIT(USARTx->CR3, (USART_CR3_SCEN | USART_CR3_IREN));
1648 /* set the UART/USART in Half Duplex mode */
1649 SET_BIT(USARTx->CR3, USART_CR3_HDSEL);
1650 }
1651
1652 /**
1653 * @brief Perform basic configuration of USART for enabling use in Smartcard Mode
1654 * @note In Smartcard mode, the following bits must be kept cleared:
1655 * - LINEN bit in the USART_CR2 register,
1656 * - IREN bit in the USART_CR3 register,
1657 * - HDSEL bit in the USART_CR3 register.
1658 * This function also configures Stop bits to 1.5 bits and
1659 * sets the USART in Smartcard mode (SCEN bit).
1660 * Clock Output is also enabled (CLKEN).
1661 * @note Macro IS_SMARTCARD_INSTANCE(USARTx) can be used to check whether or not
1662 * Smartcard feature is supported by the USARTx instance.
1663 * @note Call of this function is equivalent to following function call sequence :
1664 * - Clear LINEN in CR2 using @ref LL_USART_DisableLIN() function
1665 * - Clear IREN in CR3 using @ref LL_USART_DisableIrda() function
1666 * - Clear HDSEL in CR3 using @ref LL_USART_DisableHalfDuplex() function
1667 * - Configure STOP in CR2 using @ref LL_USART_SetStopBitsLength() function
1668 * - Set CLKEN in CR2 using @ref LL_USART_EnableSCLKOutput() function
1669 * - Set SCEN in CR3 using @ref LL_USART_EnableSmartcard() function
1670 * @note Other remaining configurations items related to Smartcard Mode
1671 * (as Baud Rate, Word length, Parity, ...) should be set using
1672 * dedicated functions
1673 * @rmtoll CR2 LINEN LL_USART_ConfigSmartcardMode\n
1674 * CR2 STOP LL_USART_ConfigSmartcardMode\n
1675 * CR2 CLKEN LL_USART_ConfigSmartcardMode\n
1676 * CR3 HDSEL LL_USART_ConfigSmartcardMode\n
1677 * CR3 SCEN LL_USART_ConfigSmartcardMode
1678 * @param USARTx USART Instance
1679 * @retval None
1680 */
LL_USART_ConfigSmartcardMode(USART_TypeDef * USARTx)1681 __STATIC_INLINE void LL_USART_ConfigSmartcardMode(USART_TypeDef *USARTx)
1682 {
1683 /* In Smartcard mode, the following bits must be kept cleared:
1684 - LINEN bit in the USART_CR2 register,
1685 - IREN and HDSEL bits in the USART_CR3 register.*/
1686 CLEAR_BIT(USARTx->CR2, (USART_CR2_LINEN));
1687 CLEAR_BIT(USARTx->CR3, (USART_CR3_IREN | USART_CR3_HDSEL));
1688 /* Configure Stop bits to 1.5 bits */
1689 /* Synchronous mode is activated by default */
1690 SET_BIT(USARTx->CR2, (USART_CR2_STOP_0 | USART_CR2_STOP_1 | USART_CR2_CLKEN));
1691 /* set the UART/USART in Smartcard mode */
1692 SET_BIT(USARTx->CR3, USART_CR3_SCEN);
1693 }
1694
1695 /**
1696 * @brief Perform basic configuration of USART for enabling use in Irda Mode
1697 * @note In IRDA mode, the following bits must be kept cleared:
1698 * - LINEN bit in the USART_CR2 register,
1699 * - STOP and CLKEN bits in the USART_CR2 register,
1700 * - SCEN bit in the USART_CR3 register,
1701 * - HDSEL bit in the USART_CR3 register.
1702 * This function also sets the UART/USART in IRDA mode (IREN bit).
1703 * @note Macro IS_IRDA_INSTANCE(USARTx) can be used to check whether or not
1704 * IrDA feature is supported by the USARTx instance.
1705 * @note Call of this function is equivalent to following function call sequence :
1706 * - Clear LINEN in CR2 using @ref LL_USART_DisableLIN() function
1707 * - Clear CLKEN in CR2 using @ref LL_USART_DisableSCLKOutput() function
1708 * - Clear SCEN in CR3 using @ref LL_USART_DisableSmartcard() function
1709 * - Clear HDSEL in CR3 using @ref LL_USART_DisableHalfDuplex() function
1710 * - Configure STOP in CR2 using @ref LL_USART_SetStopBitsLength() function
1711 * - Set IREN in CR3 using @ref LL_USART_EnableIrda() function
1712 * @note Other remaining configurations items related to Irda Mode
1713 * (as Baud Rate, Word length, Power mode, ...) should be set using
1714 * dedicated functions
1715 * @rmtoll CR2 LINEN LL_USART_ConfigIrdaMode\n
1716 * CR2 CLKEN LL_USART_ConfigIrdaMode\n
1717 * CR2 STOP LL_USART_ConfigIrdaMode\n
1718 * CR3 SCEN LL_USART_ConfigIrdaMode\n
1719 * CR3 HDSEL LL_USART_ConfigIrdaMode\n
1720 * CR3 IREN LL_USART_ConfigIrdaMode
1721 * @param USARTx USART Instance
1722 * @retval None
1723 */
LL_USART_ConfigIrdaMode(USART_TypeDef * USARTx)1724 __STATIC_INLINE void LL_USART_ConfigIrdaMode(USART_TypeDef *USARTx)
1725 {
1726 /* In IRDA mode, the following bits must be kept cleared:
1727 - LINEN, STOP and CLKEN bits in the USART_CR2 register,
1728 - SCEN and HDSEL bits in the USART_CR3 register.*/
1729 CLEAR_BIT(USARTx->CR2, (USART_CR2_LINEN | USART_CR2_CLKEN | USART_CR2_STOP));
1730 CLEAR_BIT(USARTx->CR3, (USART_CR3_SCEN | USART_CR3_HDSEL));
1731 /* set the UART/USART in IRDA mode */
1732 SET_BIT(USARTx->CR3, USART_CR3_IREN);
1733 }
1734
1735 /**
1736 * @brief Perform basic configuration of USART for enabling use in Multi processor Mode
1737 * (several USARTs connected in a network, one of the USARTs can be the master,
1738 * its TX output connected to the RX inputs of the other slaves USARTs).
1739 * @note In MultiProcessor mode, the following bits must be kept cleared:
1740 * - LINEN bit in the USART_CR2 register,
1741 * - CLKEN bit in the USART_CR2 register,
1742 * - SCEN bit in the USART_CR3 register,
1743 * - IREN bit in the USART_CR3 register,
1744 * - HDSEL bit in the USART_CR3 register.
1745 * @note Call of this function is equivalent to following function call sequence :
1746 * - Clear LINEN in CR2 using @ref LL_USART_DisableLIN() function
1747 * - Clear CLKEN in CR2 using @ref LL_USART_DisableSCLKOutput() function
1748 * - Clear SCEN in CR3 using @ref LL_USART_DisableSmartcard() function
1749 * - Clear IREN in CR3 using @ref LL_USART_DisableIrda() function
1750 * - Clear HDSEL in CR3 using @ref LL_USART_DisableHalfDuplex() function
1751 * @note Other remaining configurations items related to Multi processor Mode
1752 * (as Baud Rate, Wake Up Method, Node address, ...) should be set using
1753 * dedicated functions
1754 * @rmtoll CR2 LINEN LL_USART_ConfigMultiProcessMode\n
1755 * CR2 CLKEN LL_USART_ConfigMultiProcessMode\n
1756 * CR3 SCEN LL_USART_ConfigMultiProcessMode\n
1757 * CR3 HDSEL LL_USART_ConfigMultiProcessMode\n
1758 * CR3 IREN LL_USART_ConfigMultiProcessMode
1759 * @param USARTx USART Instance
1760 * @retval None
1761 */
LL_USART_ConfigMultiProcessMode(USART_TypeDef * USARTx)1762 __STATIC_INLINE void LL_USART_ConfigMultiProcessMode(USART_TypeDef *USARTx)
1763 {
1764 /* In Multi Processor mode, the following bits must be kept cleared:
1765 - LINEN and CLKEN bits in the USART_CR2 register,
1766 - IREN, SCEN and HDSEL bits in the USART_CR3 register.*/
1767 CLEAR_BIT(USARTx->CR2, (USART_CR2_LINEN | USART_CR2_CLKEN));
1768 CLEAR_BIT(USARTx->CR3, (USART_CR3_SCEN | USART_CR3_HDSEL | USART_CR3_IREN));
1769 }
1770
1771 /**
1772 * @}
1773 */
1774
1775 /** @defgroup USART_LL_EF_FLAG_Management FLAG_Management
1776 * @{
1777 */
1778
1779 /**
1780 * @brief Check if the USART Parity Error Flag is set or not
1781 * @rmtoll SR PE LL_USART_IsActiveFlag_PE
1782 * @param USARTx USART Instance
1783 * @retval State of bit (1 or 0).
1784 */
LL_USART_IsActiveFlag_PE(const USART_TypeDef * USARTx)1785 __STATIC_INLINE uint32_t LL_USART_IsActiveFlag_PE(const USART_TypeDef *USARTx)
1786 {
1787 return (READ_BIT(USARTx->SR, USART_SR_PE) == (USART_SR_PE));
1788 }
1789
1790 /**
1791 * @brief Check if the USART Framing Error Flag is set or not
1792 * @rmtoll SR FE LL_USART_IsActiveFlag_FE
1793 * @param USARTx USART Instance
1794 * @retval State of bit (1 or 0).
1795 */
LL_USART_IsActiveFlag_FE(const USART_TypeDef * USARTx)1796 __STATIC_INLINE uint32_t LL_USART_IsActiveFlag_FE(const USART_TypeDef *USARTx)
1797 {
1798 return (READ_BIT(USARTx->SR, USART_SR_FE) == (USART_SR_FE));
1799 }
1800
1801 /**
1802 * @brief Check if the USART Noise error detected Flag is set or not
1803 * @rmtoll SR NF LL_USART_IsActiveFlag_NE
1804 * @param USARTx USART Instance
1805 * @retval State of bit (1 or 0).
1806 */
LL_USART_IsActiveFlag_NE(const USART_TypeDef * USARTx)1807 __STATIC_INLINE uint32_t LL_USART_IsActiveFlag_NE(const USART_TypeDef *USARTx)
1808 {
1809 return (READ_BIT(USARTx->SR, USART_SR_NE) == (USART_SR_NE));
1810 }
1811
1812 /**
1813 * @brief Check if the USART OverRun Error Flag is set or not
1814 * @rmtoll SR ORE LL_USART_IsActiveFlag_ORE
1815 * @param USARTx USART Instance
1816 * @retval State of bit (1 or 0).
1817 */
LL_USART_IsActiveFlag_ORE(const USART_TypeDef * USARTx)1818 __STATIC_INLINE uint32_t LL_USART_IsActiveFlag_ORE(const USART_TypeDef *USARTx)
1819 {
1820 return (READ_BIT(USARTx->SR, USART_SR_ORE) == (USART_SR_ORE));
1821 }
1822
1823 /**
1824 * @brief Check if the USART IDLE line detected Flag is set or not
1825 * @rmtoll SR IDLE LL_USART_IsActiveFlag_IDLE
1826 * @param USARTx USART Instance
1827 * @retval State of bit (1 or 0).
1828 */
LL_USART_IsActiveFlag_IDLE(const USART_TypeDef * USARTx)1829 __STATIC_INLINE uint32_t LL_USART_IsActiveFlag_IDLE(const USART_TypeDef *USARTx)
1830 {
1831 return (READ_BIT(USARTx->SR, USART_SR_IDLE) == (USART_SR_IDLE));
1832 }
1833
1834 /**
1835 * @brief Check if the USART Read Data Register Not Empty Flag is set or not
1836 * @rmtoll SR RXNE LL_USART_IsActiveFlag_RXNE
1837 * @param USARTx USART Instance
1838 * @retval State of bit (1 or 0).
1839 */
LL_USART_IsActiveFlag_RXNE(const USART_TypeDef * USARTx)1840 __STATIC_INLINE uint32_t LL_USART_IsActiveFlag_RXNE(const USART_TypeDef *USARTx)
1841 {
1842 return (READ_BIT(USARTx->SR, USART_SR_RXNE) == (USART_SR_RXNE));
1843 }
1844
1845 /**
1846 * @brief Check if the USART Transmission Complete Flag is set or not
1847 * @rmtoll SR TC LL_USART_IsActiveFlag_TC
1848 * @param USARTx USART Instance
1849 * @retval State of bit (1 or 0).
1850 */
LL_USART_IsActiveFlag_TC(const USART_TypeDef * USARTx)1851 __STATIC_INLINE uint32_t LL_USART_IsActiveFlag_TC(const USART_TypeDef *USARTx)
1852 {
1853 return (READ_BIT(USARTx->SR, USART_SR_TC) == (USART_SR_TC));
1854 }
1855
1856 /**
1857 * @brief Check if the USART Transmit Data Register Empty Flag is set or not
1858 * @rmtoll SR TXE LL_USART_IsActiveFlag_TXE
1859 * @param USARTx USART Instance
1860 * @retval State of bit (1 or 0).
1861 */
LL_USART_IsActiveFlag_TXE(const USART_TypeDef * USARTx)1862 __STATIC_INLINE uint32_t LL_USART_IsActiveFlag_TXE(const USART_TypeDef *USARTx)
1863 {
1864 return (READ_BIT(USARTx->SR, USART_SR_TXE) == (USART_SR_TXE));
1865 }
1866
1867 /**
1868 * @brief Check if the USART LIN Break Detection Flag is set or not
1869 * @note Macro IS_UART_LIN_INSTANCE(USARTx) can be used to check whether or not
1870 * LIN feature is supported by the USARTx instance.
1871 * @rmtoll SR LBD LL_USART_IsActiveFlag_LBD
1872 * @param USARTx USART Instance
1873 * @retval State of bit (1 or 0).
1874 */
LL_USART_IsActiveFlag_LBD(const USART_TypeDef * USARTx)1875 __STATIC_INLINE uint32_t LL_USART_IsActiveFlag_LBD(const USART_TypeDef *USARTx)
1876 {
1877 return (READ_BIT(USARTx->SR, USART_SR_LBD) == (USART_SR_LBD));
1878 }
1879
1880 /**
1881 * @brief Check if the USART CTS Flag is set or not
1882 * @note Macro IS_UART_HWFLOW_INSTANCE(USARTx) can be used to check whether or not
1883 * Hardware Flow control feature is supported by the USARTx instance.
1884 * @rmtoll SR CTS LL_USART_IsActiveFlag_nCTS
1885 * @param USARTx USART Instance
1886 * @retval State of bit (1 or 0).
1887 */
LL_USART_IsActiveFlag_nCTS(const USART_TypeDef * USARTx)1888 __STATIC_INLINE uint32_t LL_USART_IsActiveFlag_nCTS(const USART_TypeDef *USARTx)
1889 {
1890 return (READ_BIT(USARTx->SR, USART_SR_CTS) == (USART_SR_CTS));
1891 }
1892
1893 /**
1894 * @brief Check if the USART Send Break Flag is set or not
1895 * @rmtoll CR1 SBK LL_USART_IsActiveFlag_SBK
1896 * @param USARTx USART Instance
1897 * @retval State of bit (1 or 0).
1898 */
LL_USART_IsActiveFlag_SBK(const USART_TypeDef * USARTx)1899 __STATIC_INLINE uint32_t LL_USART_IsActiveFlag_SBK(const USART_TypeDef *USARTx)
1900 {
1901 return (READ_BIT(USARTx->CR1, USART_CR1_SBK) == (USART_CR1_SBK));
1902 }
1903
1904 /**
1905 * @brief Check if the USART Receive Wake Up from mute mode Flag is set or not
1906 * @rmtoll CR1 RWU LL_USART_IsActiveFlag_RWU
1907 * @param USARTx USART Instance
1908 * @retval State of bit (1 or 0).
1909 */
LL_USART_IsActiveFlag_RWU(const USART_TypeDef * USARTx)1910 __STATIC_INLINE uint32_t LL_USART_IsActiveFlag_RWU(const USART_TypeDef *USARTx)
1911 {
1912 return (READ_BIT(USARTx->CR1, USART_CR1_RWU) == (USART_CR1_RWU));
1913 }
1914
1915 /**
1916 * @brief Clear Parity Error Flag
1917 * @note Clearing this flag is done by a read access to the USARTx_SR
1918 * register followed by a read access to the USARTx_DR register.
1919 * @note Please also consider that when clearing this flag, other flags as
1920 * NE, FE, ORE, IDLE would also be cleared.
1921 * @rmtoll SR PE LL_USART_ClearFlag_PE
1922 * @param USARTx USART Instance
1923 * @retval None
1924 */
LL_USART_ClearFlag_PE(USART_TypeDef * USARTx)1925 __STATIC_INLINE void LL_USART_ClearFlag_PE(USART_TypeDef *USARTx)
1926 {
1927 __IO uint32_t tmpreg;
1928 tmpreg = USARTx->SR;
1929 (void) tmpreg;
1930 tmpreg = USARTx->DR;
1931 (void) tmpreg;
1932 }
1933
1934 /**
1935 * @brief Clear Framing Error Flag
1936 * @note Clearing this flag is done by a read access to the USARTx_SR
1937 * register followed by a read access to the USARTx_DR register.
1938 * @note Please also consider that when clearing this flag, other flags as
1939 * PE, NE, ORE, IDLE would also be cleared.
1940 * @rmtoll SR FE LL_USART_ClearFlag_FE
1941 * @param USARTx USART Instance
1942 * @retval None
1943 */
LL_USART_ClearFlag_FE(USART_TypeDef * USARTx)1944 __STATIC_INLINE void LL_USART_ClearFlag_FE(USART_TypeDef *USARTx)
1945 {
1946 __IO uint32_t tmpreg;
1947 tmpreg = USARTx->SR;
1948 (void) tmpreg;
1949 tmpreg = USARTx->DR;
1950 (void) tmpreg;
1951 }
1952
1953 /**
1954 * @brief Clear Noise detected Flag
1955 * @note Clearing this flag is done by a read access to the USARTx_SR
1956 * register followed by a read access to the USARTx_DR register.
1957 * @note Please also consider that when clearing this flag, other flags as
1958 * PE, FE, ORE, IDLE would also be cleared.
1959 * @rmtoll SR NF LL_USART_ClearFlag_NE
1960 * @param USARTx USART Instance
1961 * @retval None
1962 */
LL_USART_ClearFlag_NE(USART_TypeDef * USARTx)1963 __STATIC_INLINE void LL_USART_ClearFlag_NE(USART_TypeDef *USARTx)
1964 {
1965 __IO uint32_t tmpreg;
1966 tmpreg = USARTx->SR;
1967 (void) tmpreg;
1968 tmpreg = USARTx->DR;
1969 (void) tmpreg;
1970 }
1971
1972 /**
1973 * @brief Clear OverRun Error Flag
1974 * @note Clearing this flag is done by a read access to the USARTx_SR
1975 * register followed by a read access to the USARTx_DR register.
1976 * @note Please also consider that when clearing this flag, other flags as
1977 * PE, NE, FE, IDLE would also be cleared.
1978 * @rmtoll SR ORE LL_USART_ClearFlag_ORE
1979 * @param USARTx USART Instance
1980 * @retval None
1981 */
LL_USART_ClearFlag_ORE(USART_TypeDef * USARTx)1982 __STATIC_INLINE void LL_USART_ClearFlag_ORE(USART_TypeDef *USARTx)
1983 {
1984 __IO uint32_t tmpreg;
1985 tmpreg = USARTx->SR;
1986 (void) tmpreg;
1987 tmpreg = USARTx->DR;
1988 (void) tmpreg;
1989 }
1990
1991 /**
1992 * @brief Clear IDLE line detected Flag
1993 * @note Clearing this flag is done by a read access to the USARTx_SR
1994 * register followed by a read access to the USARTx_DR register.
1995 * @note Please also consider that when clearing this flag, other flags as
1996 * PE, NE, FE, ORE would also be cleared.
1997 * @rmtoll SR IDLE LL_USART_ClearFlag_IDLE
1998 * @param USARTx USART Instance
1999 * @retval None
2000 */
LL_USART_ClearFlag_IDLE(USART_TypeDef * USARTx)2001 __STATIC_INLINE void LL_USART_ClearFlag_IDLE(USART_TypeDef *USARTx)
2002 {
2003 __IO uint32_t tmpreg;
2004 tmpreg = USARTx->SR;
2005 (void) tmpreg;
2006 tmpreg = USARTx->DR;
2007 (void) tmpreg;
2008 }
2009
2010 /**
2011 * @brief Clear Transmission Complete Flag
2012 * @rmtoll SR TC LL_USART_ClearFlag_TC
2013 * @param USARTx USART Instance
2014 * @retval None
2015 */
LL_USART_ClearFlag_TC(USART_TypeDef * USARTx)2016 __STATIC_INLINE void LL_USART_ClearFlag_TC(USART_TypeDef *USARTx)
2017 {
2018 WRITE_REG(USARTx->SR, ~(USART_SR_TC));
2019 }
2020
2021 /**
2022 * @brief Clear RX Not Empty Flag
2023 * @rmtoll SR RXNE LL_USART_ClearFlag_RXNE
2024 * @param USARTx USART Instance
2025 * @retval None
2026 */
LL_USART_ClearFlag_RXNE(USART_TypeDef * USARTx)2027 __STATIC_INLINE void LL_USART_ClearFlag_RXNE(USART_TypeDef *USARTx)
2028 {
2029 WRITE_REG(USARTx->SR, ~(USART_SR_RXNE));
2030 }
2031
2032 /**
2033 * @brief Clear LIN Break Detection Flag
2034 * @note Macro IS_UART_LIN_INSTANCE(USARTx) can be used to check whether or not
2035 * LIN feature is supported by the USARTx instance.
2036 * @rmtoll SR LBD LL_USART_ClearFlag_LBD
2037 * @param USARTx USART Instance
2038 * @retval None
2039 */
LL_USART_ClearFlag_LBD(USART_TypeDef * USARTx)2040 __STATIC_INLINE void LL_USART_ClearFlag_LBD(USART_TypeDef *USARTx)
2041 {
2042 WRITE_REG(USARTx->SR, ~(USART_SR_LBD));
2043 }
2044
2045 /**
2046 * @brief Clear CTS Interrupt Flag
2047 * @note Macro IS_UART_HWFLOW_INSTANCE(USARTx) can be used to check whether or not
2048 * Hardware Flow control feature is supported by the USARTx instance.
2049 * @rmtoll SR CTS LL_USART_ClearFlag_nCTS
2050 * @param USARTx USART Instance
2051 * @retval None
2052 */
LL_USART_ClearFlag_nCTS(USART_TypeDef * USARTx)2053 __STATIC_INLINE void LL_USART_ClearFlag_nCTS(USART_TypeDef *USARTx)
2054 {
2055 WRITE_REG(USARTx->SR, ~(USART_SR_CTS));
2056 }
2057
2058 /**
2059 * @}
2060 */
2061
2062 /** @defgroup USART_LL_EF_IT_Management IT_Management
2063 * @{
2064 */
2065
2066 /**
2067 * @brief Enable IDLE Interrupt
2068 * @rmtoll CR1 IDLEIE LL_USART_EnableIT_IDLE
2069 * @param USARTx USART Instance
2070 * @retval None
2071 */
LL_USART_EnableIT_IDLE(USART_TypeDef * USARTx)2072 __STATIC_INLINE void LL_USART_EnableIT_IDLE(USART_TypeDef *USARTx)
2073 {
2074 ATOMIC_SET_BIT(USARTx->CR1, USART_CR1_IDLEIE);
2075 }
2076
2077 /**
2078 * @brief Enable RX Not Empty Interrupt
2079 * @rmtoll CR1 RXNEIE LL_USART_EnableIT_RXNE
2080 * @param USARTx USART Instance
2081 * @retval None
2082 */
LL_USART_EnableIT_RXNE(USART_TypeDef * USARTx)2083 __STATIC_INLINE void LL_USART_EnableIT_RXNE(USART_TypeDef *USARTx)
2084 {
2085 ATOMIC_SET_BIT(USARTx->CR1, USART_CR1_RXNEIE);
2086 }
2087
2088 /**
2089 * @brief Enable Transmission Complete Interrupt
2090 * @rmtoll CR1 TCIE LL_USART_EnableIT_TC
2091 * @param USARTx USART Instance
2092 * @retval None
2093 */
LL_USART_EnableIT_TC(USART_TypeDef * USARTx)2094 __STATIC_INLINE void LL_USART_EnableIT_TC(USART_TypeDef *USARTx)
2095 {
2096 ATOMIC_SET_BIT(USARTx->CR1, USART_CR1_TCIE);
2097 }
2098
2099 /**
2100 * @brief Enable TX Empty Interrupt
2101 * @rmtoll CR1 TXEIE LL_USART_EnableIT_TXE
2102 * @param USARTx USART Instance
2103 * @retval None
2104 */
LL_USART_EnableIT_TXE(USART_TypeDef * USARTx)2105 __STATIC_INLINE void LL_USART_EnableIT_TXE(USART_TypeDef *USARTx)
2106 {
2107 ATOMIC_SET_BIT(USARTx->CR1, USART_CR1_TXEIE);
2108 }
2109
2110 /**
2111 * @brief Enable Parity Error Interrupt
2112 * @rmtoll CR1 PEIE LL_USART_EnableIT_PE
2113 * @param USARTx USART Instance
2114 * @retval None
2115 */
LL_USART_EnableIT_PE(USART_TypeDef * USARTx)2116 __STATIC_INLINE void LL_USART_EnableIT_PE(USART_TypeDef *USARTx)
2117 {
2118 ATOMIC_SET_BIT(USARTx->CR1, USART_CR1_PEIE);
2119 }
2120
2121 /**
2122 * @brief Enable LIN Break Detection Interrupt
2123 * @note Macro IS_UART_LIN_INSTANCE(USARTx) can be used to check whether or not
2124 * LIN feature is supported by the USARTx instance.
2125 * @rmtoll CR2 LBDIE LL_USART_EnableIT_LBD
2126 * @param USARTx USART Instance
2127 * @retval None
2128 */
LL_USART_EnableIT_LBD(USART_TypeDef * USARTx)2129 __STATIC_INLINE void LL_USART_EnableIT_LBD(USART_TypeDef *USARTx)
2130 {
2131 SET_BIT(USARTx->CR2, USART_CR2_LBDIE);
2132 }
2133
2134 /**
2135 * @brief Enable Error Interrupt
2136 * @note When set, Error Interrupt Enable Bit is enabling interrupt generation in case of a framing
2137 * error, overrun error or noise flag (FE=1 or ORE=1 or NF=1 in the USARTx_SR register).
2138 * 0: Interrupt is inhibited
2139 * 1: An interrupt is generated when FE=1 or ORE=1 or NF=1 in the USARTx_SR register.
2140 * @rmtoll CR3 EIE LL_USART_EnableIT_ERROR
2141 * @param USARTx USART Instance
2142 * @retval None
2143 */
LL_USART_EnableIT_ERROR(USART_TypeDef * USARTx)2144 __STATIC_INLINE void LL_USART_EnableIT_ERROR(USART_TypeDef *USARTx)
2145 {
2146 ATOMIC_SET_BIT(USARTx->CR3, USART_CR3_EIE);
2147 }
2148
2149 /**
2150 * @brief Enable CTS Interrupt
2151 * @note Macro IS_UART_HWFLOW_INSTANCE(USARTx) can be used to check whether or not
2152 * Hardware Flow control feature is supported by the USARTx instance.
2153 * @rmtoll CR3 CTSIE LL_USART_EnableIT_CTS
2154 * @param USARTx USART Instance
2155 * @retval None
2156 */
LL_USART_EnableIT_CTS(USART_TypeDef * USARTx)2157 __STATIC_INLINE void LL_USART_EnableIT_CTS(USART_TypeDef *USARTx)
2158 {
2159 ATOMIC_SET_BIT(USARTx->CR3, USART_CR3_CTSIE);
2160 }
2161
2162 /**
2163 * @brief Disable IDLE Interrupt
2164 * @rmtoll CR1 IDLEIE LL_USART_DisableIT_IDLE
2165 * @param USARTx USART Instance
2166 * @retval None
2167 */
LL_USART_DisableIT_IDLE(USART_TypeDef * USARTx)2168 __STATIC_INLINE void LL_USART_DisableIT_IDLE(USART_TypeDef *USARTx)
2169 {
2170 ATOMIC_CLEAR_BIT(USARTx->CR1, USART_CR1_IDLEIE);
2171 }
2172
2173 /**
2174 * @brief Disable RX Not Empty Interrupt
2175 * @rmtoll CR1 RXNEIE LL_USART_DisableIT_RXNE
2176 * @param USARTx USART Instance
2177 * @retval None
2178 */
LL_USART_DisableIT_RXNE(USART_TypeDef * USARTx)2179 __STATIC_INLINE void LL_USART_DisableIT_RXNE(USART_TypeDef *USARTx)
2180 {
2181 ATOMIC_CLEAR_BIT(USARTx->CR1, USART_CR1_RXNEIE);
2182 }
2183
2184 /**
2185 * @brief Disable Transmission Complete Interrupt
2186 * @rmtoll CR1 TCIE LL_USART_DisableIT_TC
2187 * @param USARTx USART Instance
2188 * @retval None
2189 */
LL_USART_DisableIT_TC(USART_TypeDef * USARTx)2190 __STATIC_INLINE void LL_USART_DisableIT_TC(USART_TypeDef *USARTx)
2191 {
2192 ATOMIC_CLEAR_BIT(USARTx->CR1, USART_CR1_TCIE);
2193 }
2194
2195 /**
2196 * @brief Disable TX Empty Interrupt
2197 * @rmtoll CR1 TXEIE LL_USART_DisableIT_TXE
2198 * @param USARTx USART Instance
2199 * @retval None
2200 */
LL_USART_DisableIT_TXE(USART_TypeDef * USARTx)2201 __STATIC_INLINE void LL_USART_DisableIT_TXE(USART_TypeDef *USARTx)
2202 {
2203 ATOMIC_CLEAR_BIT(USARTx->CR1, USART_CR1_TXEIE);
2204 }
2205
2206 /**
2207 * @brief Disable Parity Error Interrupt
2208 * @rmtoll CR1 PEIE LL_USART_DisableIT_PE
2209 * @param USARTx USART Instance
2210 * @retval None
2211 */
LL_USART_DisableIT_PE(USART_TypeDef * USARTx)2212 __STATIC_INLINE void LL_USART_DisableIT_PE(USART_TypeDef *USARTx)
2213 {
2214 ATOMIC_CLEAR_BIT(USARTx->CR1, USART_CR1_PEIE);
2215 }
2216
2217 /**
2218 * @brief Disable LIN Break Detection Interrupt
2219 * @note Macro IS_UART_LIN_INSTANCE(USARTx) can be used to check whether or not
2220 * LIN feature is supported by the USARTx instance.
2221 * @rmtoll CR2 LBDIE LL_USART_DisableIT_LBD
2222 * @param USARTx USART Instance
2223 * @retval None
2224 */
LL_USART_DisableIT_LBD(USART_TypeDef * USARTx)2225 __STATIC_INLINE void LL_USART_DisableIT_LBD(USART_TypeDef *USARTx)
2226 {
2227 CLEAR_BIT(USARTx->CR2, USART_CR2_LBDIE);
2228 }
2229
2230 /**
2231 * @brief Disable Error Interrupt
2232 * @note When set, Error Interrupt Enable Bit is enabling interrupt generation in case of a framing
2233 * error, overrun error or noise flag (FE=1 or ORE=1 or NF=1 in the USARTx_SR register).
2234 * 0: Interrupt is inhibited
2235 * 1: An interrupt is generated when FE=1 or ORE=1 or NF=1 in the USARTx_SR register.
2236 * @rmtoll CR3 EIE LL_USART_DisableIT_ERROR
2237 * @param USARTx USART Instance
2238 * @retval None
2239 */
LL_USART_DisableIT_ERROR(USART_TypeDef * USARTx)2240 __STATIC_INLINE void LL_USART_DisableIT_ERROR(USART_TypeDef *USARTx)
2241 {
2242 ATOMIC_CLEAR_BIT(USARTx->CR3, USART_CR3_EIE);
2243 }
2244
2245 /**
2246 * @brief Disable CTS Interrupt
2247 * @note Macro IS_UART_HWFLOW_INSTANCE(USARTx) can be used to check whether or not
2248 * Hardware Flow control feature is supported by the USARTx instance.
2249 * @rmtoll CR3 CTSIE LL_USART_DisableIT_CTS
2250 * @param USARTx USART Instance
2251 * @retval None
2252 */
LL_USART_DisableIT_CTS(USART_TypeDef * USARTx)2253 __STATIC_INLINE void LL_USART_DisableIT_CTS(USART_TypeDef *USARTx)
2254 {
2255 ATOMIC_CLEAR_BIT(USARTx->CR3, USART_CR3_CTSIE);
2256 }
2257
2258 /**
2259 * @brief Check if the USART IDLE Interrupt source is enabled or disabled.
2260 * @rmtoll CR1 IDLEIE LL_USART_IsEnabledIT_IDLE
2261 * @param USARTx USART Instance
2262 * @retval State of bit (1 or 0).
2263 */
LL_USART_IsEnabledIT_IDLE(const USART_TypeDef * USARTx)2264 __STATIC_INLINE uint32_t LL_USART_IsEnabledIT_IDLE(const USART_TypeDef *USARTx)
2265 {
2266 return (READ_BIT(USARTx->CR1, USART_CR1_IDLEIE) == (USART_CR1_IDLEIE));
2267 }
2268
2269 /**
2270 * @brief Check if the USART RX Not Empty Interrupt is enabled or disabled.
2271 * @rmtoll CR1 RXNEIE LL_USART_IsEnabledIT_RXNE
2272 * @param USARTx USART Instance
2273 * @retval State of bit (1 or 0).
2274 */
LL_USART_IsEnabledIT_RXNE(const USART_TypeDef * USARTx)2275 __STATIC_INLINE uint32_t LL_USART_IsEnabledIT_RXNE(const USART_TypeDef *USARTx)
2276 {
2277 return (READ_BIT(USARTx->CR1, USART_CR1_RXNEIE) == (USART_CR1_RXNEIE));
2278 }
2279
2280 /**
2281 * @brief Check if the USART Transmission Complete Interrupt is enabled or disabled.
2282 * @rmtoll CR1 TCIE LL_USART_IsEnabledIT_TC
2283 * @param USARTx USART Instance
2284 * @retval State of bit (1 or 0).
2285 */
LL_USART_IsEnabledIT_TC(const USART_TypeDef * USARTx)2286 __STATIC_INLINE uint32_t LL_USART_IsEnabledIT_TC(const USART_TypeDef *USARTx)
2287 {
2288 return (READ_BIT(USARTx->CR1, USART_CR1_TCIE) == (USART_CR1_TCIE));
2289 }
2290
2291 /**
2292 * @brief Check if the USART TX Empty Interrupt is enabled or disabled.
2293 * @rmtoll CR1 TXEIE LL_USART_IsEnabledIT_TXE
2294 * @param USARTx USART Instance
2295 * @retval State of bit (1 or 0).
2296 */
LL_USART_IsEnabledIT_TXE(const USART_TypeDef * USARTx)2297 __STATIC_INLINE uint32_t LL_USART_IsEnabledIT_TXE(const USART_TypeDef *USARTx)
2298 {
2299 return (READ_BIT(USARTx->CR1, USART_CR1_TXEIE) == (USART_CR1_TXEIE));
2300 }
2301
2302 /**
2303 * @brief Check if the USART Parity Error Interrupt is enabled or disabled.
2304 * @rmtoll CR1 PEIE LL_USART_IsEnabledIT_PE
2305 * @param USARTx USART Instance
2306 * @retval State of bit (1 or 0).
2307 */
LL_USART_IsEnabledIT_PE(const USART_TypeDef * USARTx)2308 __STATIC_INLINE uint32_t LL_USART_IsEnabledIT_PE(const USART_TypeDef *USARTx)
2309 {
2310 return (READ_BIT(USARTx->CR1, USART_CR1_PEIE) == (USART_CR1_PEIE));
2311 }
2312
2313 /**
2314 * @brief Check if the USART LIN Break Detection Interrupt is enabled or disabled.
2315 * @note Macro IS_UART_LIN_INSTANCE(USARTx) can be used to check whether or not
2316 * LIN feature is supported by the USARTx instance.
2317 * @rmtoll CR2 LBDIE LL_USART_IsEnabledIT_LBD
2318 * @param USARTx USART Instance
2319 * @retval State of bit (1 or 0).
2320 */
LL_USART_IsEnabledIT_LBD(const USART_TypeDef * USARTx)2321 __STATIC_INLINE uint32_t LL_USART_IsEnabledIT_LBD(const USART_TypeDef *USARTx)
2322 {
2323 return (READ_BIT(USARTx->CR2, USART_CR2_LBDIE) == (USART_CR2_LBDIE));
2324 }
2325
2326 /**
2327 * @brief Check if the USART Error Interrupt is enabled or disabled.
2328 * @rmtoll CR3 EIE LL_USART_IsEnabledIT_ERROR
2329 * @param USARTx USART Instance
2330 * @retval State of bit (1 or 0).
2331 */
LL_USART_IsEnabledIT_ERROR(const USART_TypeDef * USARTx)2332 __STATIC_INLINE uint32_t LL_USART_IsEnabledIT_ERROR(const USART_TypeDef *USARTx)
2333 {
2334 return (READ_BIT(USARTx->CR3, USART_CR3_EIE) == (USART_CR3_EIE));
2335 }
2336
2337 /**
2338 * @brief Check if the USART CTS Interrupt is enabled or disabled.
2339 * @note Macro IS_UART_HWFLOW_INSTANCE(USARTx) can be used to check whether or not
2340 * Hardware Flow control feature is supported by the USARTx instance.
2341 * @rmtoll CR3 CTSIE LL_USART_IsEnabledIT_CTS
2342 * @param USARTx USART Instance
2343 * @retval State of bit (1 or 0).
2344 */
LL_USART_IsEnabledIT_CTS(const USART_TypeDef * USARTx)2345 __STATIC_INLINE uint32_t LL_USART_IsEnabledIT_CTS(const USART_TypeDef *USARTx)
2346 {
2347 return (READ_BIT(USARTx->CR3, USART_CR3_CTSIE) == (USART_CR3_CTSIE));
2348 }
2349
2350 /**
2351 * @}
2352 */
2353
2354 /** @defgroup USART_LL_EF_DMA_Management DMA_Management
2355 * @{
2356 */
2357
2358 /**
2359 * @brief Enable DMA Mode for reception
2360 * @rmtoll CR3 DMAR LL_USART_EnableDMAReq_RX
2361 * @param USARTx USART Instance
2362 * @retval None
2363 */
LL_USART_EnableDMAReq_RX(USART_TypeDef * USARTx)2364 __STATIC_INLINE void LL_USART_EnableDMAReq_RX(USART_TypeDef *USARTx)
2365 {
2366 ATOMIC_SET_BIT(USARTx->CR3, USART_CR3_DMAR);
2367 }
2368
2369 /**
2370 * @brief Disable DMA Mode for reception
2371 * @rmtoll CR3 DMAR LL_USART_DisableDMAReq_RX
2372 * @param USARTx USART Instance
2373 * @retval None
2374 */
LL_USART_DisableDMAReq_RX(USART_TypeDef * USARTx)2375 __STATIC_INLINE void LL_USART_DisableDMAReq_RX(USART_TypeDef *USARTx)
2376 {
2377 ATOMIC_CLEAR_BIT(USARTx->CR3, USART_CR3_DMAR);
2378 }
2379
2380 /**
2381 * @brief Check if DMA Mode is enabled for reception
2382 * @rmtoll CR3 DMAR LL_USART_IsEnabledDMAReq_RX
2383 * @param USARTx USART Instance
2384 * @retval State of bit (1 or 0).
2385 */
LL_USART_IsEnabledDMAReq_RX(const USART_TypeDef * USARTx)2386 __STATIC_INLINE uint32_t LL_USART_IsEnabledDMAReq_RX(const USART_TypeDef *USARTx)
2387 {
2388 return (READ_BIT(USARTx->CR3, USART_CR3_DMAR) == (USART_CR3_DMAR));
2389 }
2390
2391 /**
2392 * @brief Enable DMA Mode for transmission
2393 * @rmtoll CR3 DMAT LL_USART_EnableDMAReq_TX
2394 * @param USARTx USART Instance
2395 * @retval None
2396 */
LL_USART_EnableDMAReq_TX(USART_TypeDef * USARTx)2397 __STATIC_INLINE void LL_USART_EnableDMAReq_TX(USART_TypeDef *USARTx)
2398 {
2399 ATOMIC_SET_BIT(USARTx->CR3, USART_CR3_DMAT);
2400 }
2401
2402 /**
2403 * @brief Disable DMA Mode for transmission
2404 * @rmtoll CR3 DMAT LL_USART_DisableDMAReq_TX
2405 * @param USARTx USART Instance
2406 * @retval None
2407 */
LL_USART_DisableDMAReq_TX(USART_TypeDef * USARTx)2408 __STATIC_INLINE void LL_USART_DisableDMAReq_TX(USART_TypeDef *USARTx)
2409 {
2410 ATOMIC_CLEAR_BIT(USARTx->CR3, USART_CR3_DMAT);
2411 }
2412
2413 /**
2414 * @brief Check if DMA Mode is enabled for transmission
2415 * @rmtoll CR3 DMAT LL_USART_IsEnabledDMAReq_TX
2416 * @param USARTx USART Instance
2417 * @retval State of bit (1 or 0).
2418 */
LL_USART_IsEnabledDMAReq_TX(const USART_TypeDef * USARTx)2419 __STATIC_INLINE uint32_t LL_USART_IsEnabledDMAReq_TX(const USART_TypeDef *USARTx)
2420 {
2421 return (READ_BIT(USARTx->CR3, USART_CR3_DMAT) == (USART_CR3_DMAT));
2422 }
2423
2424 /**
2425 * @brief Get the data register address used for DMA transfer
2426 * @rmtoll DR DR LL_USART_DMA_GetRegAddr
2427 * @note Address of Data Register is valid for both Transmit and Receive transfers.
2428 * @param USARTx USART Instance
2429 * @retval Address of data register
2430 */
LL_USART_DMA_GetRegAddr(const USART_TypeDef * USARTx)2431 __STATIC_INLINE uint32_t LL_USART_DMA_GetRegAddr(const USART_TypeDef *USARTx)
2432 {
2433 /* return address of DR register */
2434 return ((uint32_t) &(USARTx->DR));
2435 }
2436
2437 /**
2438 * @}
2439 */
2440
2441 /** @defgroup USART_LL_EF_Data_Management Data_Management
2442 * @{
2443 */
2444
2445 /**
2446 * @brief Read Receiver Data register (Receive Data value, 8 bits)
2447 * @rmtoll DR DR LL_USART_ReceiveData8
2448 * @param USARTx USART Instance
2449 * @retval Value between Min_Data=0x00 and Max_Data=0xFF
2450 */
LL_USART_ReceiveData8(const USART_TypeDef * USARTx)2451 __STATIC_INLINE uint8_t LL_USART_ReceiveData8(const USART_TypeDef *USARTx)
2452 {
2453 return (uint8_t)(READ_BIT(USARTx->DR, USART_DR_DR));
2454 }
2455
2456 /**
2457 * @brief Read Receiver Data register (Receive Data value, 9 bits)
2458 * @rmtoll DR DR LL_USART_ReceiveData9
2459 * @param USARTx USART Instance
2460 * @retval Value between Min_Data=0x00 and Max_Data=0x1FF
2461 */
LL_USART_ReceiveData9(const USART_TypeDef * USARTx)2462 __STATIC_INLINE uint16_t LL_USART_ReceiveData9(const USART_TypeDef *USARTx)
2463 {
2464 return (uint16_t)(READ_BIT(USARTx->DR, USART_DR_DR));
2465 }
2466
2467 /**
2468 * @brief Write in Transmitter Data Register (Transmit Data value, 8 bits)
2469 * @rmtoll DR DR LL_USART_TransmitData8
2470 * @param USARTx USART Instance
2471 * @param Value between Min_Data=0x00 and Max_Data=0xFF
2472 * @retval None
2473 */
LL_USART_TransmitData8(USART_TypeDef * USARTx,uint8_t Value)2474 __STATIC_INLINE void LL_USART_TransmitData8(USART_TypeDef *USARTx, uint8_t Value)
2475 {
2476 USARTx->DR = Value;
2477 }
2478
2479 /**
2480 * @brief Write in Transmitter Data Register (Transmit Data value, 9 bits)
2481 * @rmtoll DR DR LL_USART_TransmitData9
2482 * @param USARTx USART Instance
2483 * @param Value between Min_Data=0x00 and Max_Data=0x1FF
2484 * @retval None
2485 */
LL_USART_TransmitData9(USART_TypeDef * USARTx,uint16_t Value)2486 __STATIC_INLINE void LL_USART_TransmitData9(USART_TypeDef *USARTx, uint16_t Value)
2487 {
2488 USARTx->DR = Value & 0x1FFU;
2489 }
2490
2491 /**
2492 * @}
2493 */
2494
2495 /** @defgroup USART_LL_EF_Execution Execution
2496 * @{
2497 */
2498
2499 /**
2500 * @brief Request Break sending
2501 * @rmtoll CR1 SBK LL_USART_RequestBreakSending
2502 * @param USARTx USART Instance
2503 * @retval None
2504 */
LL_USART_RequestBreakSending(USART_TypeDef * USARTx)2505 __STATIC_INLINE void LL_USART_RequestBreakSending(USART_TypeDef *USARTx)
2506 {
2507 SET_BIT(USARTx->CR1, USART_CR1_SBK);
2508 }
2509
2510 /**
2511 * @brief Put USART in Mute mode
2512 * @rmtoll CR1 RWU LL_USART_RequestEnterMuteMode
2513 * @param USARTx USART Instance
2514 * @retval None
2515 */
LL_USART_RequestEnterMuteMode(USART_TypeDef * USARTx)2516 __STATIC_INLINE void LL_USART_RequestEnterMuteMode(USART_TypeDef *USARTx)
2517 {
2518 SET_BIT(USARTx->CR1, USART_CR1_RWU);
2519 }
2520
2521 /**
2522 * @brief Put USART in Active mode
2523 * @rmtoll CR1 RWU LL_USART_RequestExitMuteMode
2524 * @param USARTx USART Instance
2525 * @retval None
2526 */
LL_USART_RequestExitMuteMode(USART_TypeDef * USARTx)2527 __STATIC_INLINE void LL_USART_RequestExitMuteMode(USART_TypeDef *USARTx)
2528 {
2529 CLEAR_BIT(USARTx->CR1, USART_CR1_RWU);
2530 }
2531
2532 /**
2533 * @}
2534 */
2535
2536 #if defined(USE_FULL_LL_DRIVER)
2537 /** @defgroup USART_LL_EF_Init Initialization and de-initialization functions
2538 * @{
2539 */
2540 ErrorStatus LL_USART_DeInit(const USART_TypeDef *USARTx);
2541 ErrorStatus LL_USART_Init(USART_TypeDef *USARTx, const LL_USART_InitTypeDef *USART_InitStruct);
2542 void LL_USART_StructInit(LL_USART_InitTypeDef *USART_InitStruct);
2543 ErrorStatus LL_USART_ClockInit(USART_TypeDef *USARTx, const LL_USART_ClockInitTypeDef *USART_ClockInitStruct);
2544 void LL_USART_ClockStructInit(LL_USART_ClockInitTypeDef *USART_ClockInitStruct);
2545 /**
2546 * @}
2547 */
2548 #endif /* USE_FULL_LL_DRIVER */
2549
2550 /**
2551 * @}
2552 */
2553
2554 /**
2555 * @}
2556 */
2557
2558 #endif /* USART1 || USART2 || USART3 || UART4 || UART5 */
2559
2560 /**
2561 * @}
2562 */
2563
2564 #ifdef __cplusplus
2565 }
2566 #endif
2567
2568 #endif /* __STM32F1xx_LL_USART_H */
2569
2570
