STM32L4xx_HAL_Driver  1.14.0
stm32l4xx_hal_uart_ex.h
Go to the documentation of this file.
1 
20 /* Define to prevent recursive inclusion -------------------------------------*/
21 #ifndef STM32L4xx_HAL_UART_EX_H
22 #define STM32L4xx_HAL_UART_EX_H
23 
24 #ifdef __cplusplus
25 extern "C" {
26 #endif
27 
28 /* Includes ------------------------------------------------------------------*/
29 #include "stm32l4xx_hal_def.h"
30 
39 /* Exported types ------------------------------------------------------------*/
47 typedef struct
48 {
49  uint32_t WakeUpEvent;
54  uint16_t AddressLength;
57  uint8_t Address;
58 } UART_WakeUpTypeDef;
59 
64 /* Exported constants --------------------------------------------------------*/
72 #define UART_WORDLENGTH_7B USART_CR1_M1
73 #define UART_WORDLENGTH_8B 0x00000000U
74 #define UART_WORDLENGTH_9B USART_CR1_M0
82 #define UART_ADDRESS_DETECT_4B 0x00000000U
83 #define UART_ADDRESS_DETECT_7B USART_CR2_ADDM7
88 #if defined(USART_CR1_FIFOEN)
89 
93 #define UART_FIFOMODE_DISABLE 0x00000000U
94 #define UART_FIFOMODE_ENABLE USART_CR1_FIFOEN
103 #define UART_TXFIFO_THRESHOLD_1_8 0x00000000U
104 #define UART_TXFIFO_THRESHOLD_1_4 USART_CR3_TXFTCFG_0
105 #define UART_TXFIFO_THRESHOLD_1_2 USART_CR3_TXFTCFG_1
106 #define UART_TXFIFO_THRESHOLD_3_4 (USART_CR3_TXFTCFG_0|USART_CR3_TXFTCFG_1)
107 #define UART_TXFIFO_THRESHOLD_7_8 USART_CR3_TXFTCFG_2
108 #define UART_TXFIFO_THRESHOLD_8_8 (USART_CR3_TXFTCFG_2|USART_CR3_TXFTCFG_0)
117 #define UART_RXFIFO_THRESHOLD_1_8 0x00000000U
118 #define UART_RXFIFO_THRESHOLD_1_4 USART_CR3_RXFTCFG_0
119 #define UART_RXFIFO_THRESHOLD_1_2 USART_CR3_RXFTCFG_1
120 #define UART_RXFIFO_THRESHOLD_3_4 (USART_CR3_RXFTCFG_0|USART_CR3_RXFTCFG_1)
121 #define UART_RXFIFO_THRESHOLD_7_8 USART_CR3_RXFTCFG_2
122 #define UART_RXFIFO_THRESHOLD_8_8 (USART_CR3_RXFTCFG_2|USART_CR3_RXFTCFG_0)
126 #endif /* USART_CR1_FIFOEN */
127 
132 /* Exported macros -----------------------------------------------------------*/
133 /* Exported functions --------------------------------------------------------*/
142 /* Initialization and de-initialization functions ****************************/
143 HAL_StatusTypeDef HAL_RS485Ex_Init(UART_HandleTypeDef *huart, uint32_t Polarity, uint32_t AssertionTime,
144  uint32_t DeassertionTime);
145 
154 void HAL_UARTEx_WakeupCallback(UART_HandleTypeDef *huart);
155 
156 #if defined(USART_CR1_FIFOEN)
157 void HAL_UARTEx_RxFifoFullCallback(UART_HandleTypeDef *huart);
158 void HAL_UARTEx_TxFifoEmptyCallback(UART_HandleTypeDef *huart);
159 #endif /* USART_CR1_FIFOEN */
160 
169 /* Peripheral Control functions **********************************************/
170 HAL_StatusTypeDef HAL_UARTEx_StopModeWakeUpSourceConfig(UART_HandleTypeDef *huart, UART_WakeUpTypeDef WakeUpSelection);
171 HAL_StatusTypeDef HAL_UARTEx_EnableStopMode(UART_HandleTypeDef *huart);
172 HAL_StatusTypeDef HAL_UARTEx_DisableStopMode(UART_HandleTypeDef *huart);
173 #if defined(USART_CR3_UCESM)
174 HAL_StatusTypeDef HAL_UARTEx_EnableClockStopMode(UART_HandleTypeDef *huart);
175 HAL_StatusTypeDef HAL_UARTEx_DisableClockStopMode(UART_HandleTypeDef *huart);
176 #endif /* USART_CR3_UCESM */
177 HAL_StatusTypeDef HAL_MultiProcessorEx_AddressLength_Set(UART_HandleTypeDef *huart, uint32_t AddressLength);
178 #if defined(USART_CR1_FIFOEN)
179 HAL_StatusTypeDef HAL_UARTEx_EnableFifoMode(UART_HandleTypeDef *huart);
180 HAL_StatusTypeDef HAL_UARTEx_DisableFifoMode(UART_HandleTypeDef *huart);
181 HAL_StatusTypeDef HAL_UARTEx_SetTxFifoThreshold(UART_HandleTypeDef *huart, uint32_t Threshold);
182 HAL_StatusTypeDef HAL_UARTEx_SetRxFifoThreshold(UART_HandleTypeDef *huart, uint32_t Threshold);
183 #endif /* USART_CR1_FIFOEN */
184 
193 /* Private macros ------------------------------------------------------------*/
203 #if defined (STM32L471xx) || defined (STM32L475xx) || defined (STM32L476xx) || defined (STM32L485xx) || defined (STM32L486xx) \
204  || defined (STM32L496xx) || defined (STM32L4A6xx) \
205  || defined (STM32L4R5xx) || defined (STM32L4R7xx) || defined (STM32L4R9xx) || defined (STM32L4S5xx) || defined (STM32L4S7xx) || defined (STM32L4S9xx)
206 #define UART_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__) \
207  do { \
208  if((__HANDLE__)->Instance == USART1) \
209  { \
210  switch(__HAL_RCC_GET_USART1_SOURCE()) \
211  { \
212  case RCC_USART1CLKSOURCE_PCLK2: \
213  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK2; \
214  break; \
215  case RCC_USART1CLKSOURCE_HSI: \
216  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
217  break; \
218  case RCC_USART1CLKSOURCE_SYSCLK: \
219  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK; \
220  break; \
221  case RCC_USART1CLKSOURCE_LSE: \
222  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
223  break; \
224  default: \
225  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
226  break; \
227  } \
228  } \
229  else if((__HANDLE__)->Instance == USART2) \
230  { \
231  switch(__HAL_RCC_GET_USART2_SOURCE()) \
232  { \
233  case RCC_USART2CLKSOURCE_PCLK1: \
234  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1; \
235  break; \
236  case RCC_USART2CLKSOURCE_HSI: \
237  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
238  break; \
239  case RCC_USART2CLKSOURCE_SYSCLK: \
240  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK; \
241  break; \
242  case RCC_USART2CLKSOURCE_LSE: \
243  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
244  break; \
245  default: \
246  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
247  break; \
248  } \
249  } \
250  else if((__HANDLE__)->Instance == USART3) \
251  { \
252  switch(__HAL_RCC_GET_USART3_SOURCE()) \
253  { \
254  case RCC_USART3CLKSOURCE_PCLK1: \
255  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1; \
256  break; \
257  case RCC_USART3CLKSOURCE_HSI: \
258  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
259  break; \
260  case RCC_USART3CLKSOURCE_SYSCLK: \
261  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK; \
262  break; \
263  case RCC_USART3CLKSOURCE_LSE: \
264  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
265  break; \
266  default: \
267  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
268  break; \
269  } \
270  } \
271  else if((__HANDLE__)->Instance == UART4) \
272  { \
273  switch(__HAL_RCC_GET_UART4_SOURCE()) \
274  { \
275  case RCC_UART4CLKSOURCE_PCLK1: \
276  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1; \
277  break; \
278  case RCC_UART4CLKSOURCE_HSI: \
279  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
280  break; \
281  case RCC_UART4CLKSOURCE_SYSCLK: \
282  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK; \
283  break; \
284  case RCC_UART4CLKSOURCE_LSE: \
285  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
286  break; \
287  default: \
288  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
289  break; \
290  } \
291  } \
292  else if((__HANDLE__)->Instance == UART5) \
293  { \
294  switch(__HAL_RCC_GET_UART5_SOURCE()) \
295  { \
296  case RCC_UART5CLKSOURCE_PCLK1: \
297  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1; \
298  break; \
299  case RCC_UART5CLKSOURCE_HSI: \
300  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
301  break; \
302  case RCC_UART5CLKSOURCE_SYSCLK: \
303  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK; \
304  break; \
305  case RCC_UART5CLKSOURCE_LSE: \
306  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
307  break; \
308  default: \
309  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
310  break; \
311  } \
312  } \
313  else if((__HANDLE__)->Instance == LPUART1) \
314  { \
315  switch(__HAL_RCC_GET_LPUART1_SOURCE()) \
316  { \
317  case RCC_LPUART1CLKSOURCE_PCLK1: \
318  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1; \
319  break; \
320  case RCC_LPUART1CLKSOURCE_HSI: \
321  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
322  break; \
323  case RCC_LPUART1CLKSOURCE_SYSCLK: \
324  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK; \
325  break; \
326  case RCC_LPUART1CLKSOURCE_LSE: \
327  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
328  break; \
329  default: \
330  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
331  break; \
332  } \
333  } \
334  else \
335  { \
336  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
337  } \
338  } while(0U)
339 #elif defined (STM32L412xx) || defined (STM32L422xx) \
340  || defined (STM32L431xx) || defined (STM32L433xx) || defined (STM32L443xx)
341 #define UART_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__) \
342  do { \
343  if((__HANDLE__)->Instance == USART1) \
344  { \
345  switch(__HAL_RCC_GET_USART1_SOURCE()) \
346  { \
347  case RCC_USART1CLKSOURCE_PCLK2: \
348  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK2; \
349  break; \
350  case RCC_USART1CLKSOURCE_HSI: \
351  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
352  break; \
353  case RCC_USART1CLKSOURCE_SYSCLK: \
354  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK; \
355  break; \
356  case RCC_USART1CLKSOURCE_LSE: \
357  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
358  break; \
359  default: \
360  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
361  break; \
362  } \
363  } \
364  else if((__HANDLE__)->Instance == USART2) \
365  { \
366  switch(__HAL_RCC_GET_USART2_SOURCE()) \
367  { \
368  case RCC_USART2CLKSOURCE_PCLK1: \
369  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1; \
370  break; \
371  case RCC_USART2CLKSOURCE_HSI: \
372  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
373  break; \
374  case RCC_USART2CLKSOURCE_SYSCLK: \
375  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK; \
376  break; \
377  case RCC_USART2CLKSOURCE_LSE: \
378  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
379  break; \
380  default: \
381  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
382  break; \
383  } \
384  } \
385  else if((__HANDLE__)->Instance == USART3) \
386  { \
387  switch(__HAL_RCC_GET_USART3_SOURCE()) \
388  { \
389  case RCC_USART3CLKSOURCE_PCLK1: \
390  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1; \
391  break; \
392  case RCC_USART3CLKSOURCE_HSI: \
393  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
394  break; \
395  case RCC_USART3CLKSOURCE_SYSCLK: \
396  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK; \
397  break; \
398  case RCC_USART3CLKSOURCE_LSE: \
399  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
400  break; \
401  default: \
402  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
403  break; \
404  } \
405  } \
406  else if((__HANDLE__)->Instance == LPUART1) \
407  { \
408  switch(__HAL_RCC_GET_LPUART1_SOURCE()) \
409  { \
410  case RCC_LPUART1CLKSOURCE_PCLK1: \
411  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1; \
412  break; \
413  case RCC_LPUART1CLKSOURCE_HSI: \
414  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
415  break; \
416  case RCC_LPUART1CLKSOURCE_SYSCLK: \
417  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK; \
418  break; \
419  case RCC_LPUART1CLKSOURCE_LSE: \
420  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
421  break; \
422  default: \
423  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
424  break; \
425  } \
426  } \
427  else \
428  { \
429  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
430  } \
431  } while(0U)
432 #elif defined (STM32L432xx) || defined (STM32L442xx)
433 #define UART_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__) \
434  do { \
435  if((__HANDLE__)->Instance == USART1) \
436  { \
437  switch(__HAL_RCC_GET_USART1_SOURCE()) \
438  { \
439  case RCC_USART1CLKSOURCE_PCLK2: \
440  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK2; \
441  break; \
442  case RCC_USART1CLKSOURCE_HSI: \
443  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
444  break; \
445  case RCC_USART1CLKSOURCE_SYSCLK: \
446  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK; \
447  break; \
448  case RCC_USART1CLKSOURCE_LSE: \
449  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
450  break; \
451  default: \
452  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
453  break; \
454  } \
455  } \
456  else if((__HANDLE__)->Instance == USART2) \
457  { \
458  switch(__HAL_RCC_GET_USART2_SOURCE()) \
459  { \
460  case RCC_USART2CLKSOURCE_PCLK1: \
461  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1; \
462  break; \
463  case RCC_USART2CLKSOURCE_HSI: \
464  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
465  break; \
466  case RCC_USART2CLKSOURCE_SYSCLK: \
467  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK; \
468  break; \
469  case RCC_USART2CLKSOURCE_LSE: \
470  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
471  break; \
472  default: \
473  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
474  break; \
475  } \
476  } \
477  else if((__HANDLE__)->Instance == LPUART1) \
478  { \
479  switch(__HAL_RCC_GET_LPUART1_SOURCE()) \
480  { \
481  case RCC_LPUART1CLKSOURCE_PCLK1: \
482  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1; \
483  break; \
484  case RCC_LPUART1CLKSOURCE_HSI: \
485  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
486  break; \
487  case RCC_LPUART1CLKSOURCE_SYSCLK: \
488  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK; \
489  break; \
490  case RCC_LPUART1CLKSOURCE_LSE: \
491  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
492  break; \
493  default: \
494  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
495  break; \
496  } \
497  } \
498  else \
499  { \
500  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
501  } \
502  } while(0U)
503 #elif defined (STM32L451xx) || defined (STM32L452xx) || defined (STM32L462xx)
504 #define UART_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__) \
505  do { \
506  if((__HANDLE__)->Instance == USART1) \
507  { \
508  switch(__HAL_RCC_GET_USART1_SOURCE()) \
509  { \
510  case RCC_USART1CLKSOURCE_PCLK2: \
511  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK2; \
512  break; \
513  case RCC_USART1CLKSOURCE_HSI: \
514  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
515  break; \
516  case RCC_USART1CLKSOURCE_SYSCLK: \
517  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK; \
518  break; \
519  case RCC_USART1CLKSOURCE_LSE: \
520  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
521  break; \
522  default: \
523  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
524  break; \
525  } \
526  } \
527  else if((__HANDLE__)->Instance == USART2) \
528  { \
529  switch(__HAL_RCC_GET_USART2_SOURCE()) \
530  { \
531  case RCC_USART2CLKSOURCE_PCLK1: \
532  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1; \
533  break; \
534  case RCC_USART2CLKSOURCE_HSI: \
535  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
536  break; \
537  case RCC_USART2CLKSOURCE_SYSCLK: \
538  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK; \
539  break; \
540  case RCC_USART2CLKSOURCE_LSE: \
541  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
542  break; \
543  default: \
544  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
545  break; \
546  } \
547  } \
548  else if((__HANDLE__)->Instance == USART3) \
549  { \
550  switch(__HAL_RCC_GET_USART3_SOURCE()) \
551  { \
552  case RCC_USART3CLKSOURCE_PCLK1: \
553  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1; \
554  break; \
555  case RCC_USART3CLKSOURCE_HSI: \
556  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
557  break; \
558  case RCC_USART3CLKSOURCE_SYSCLK: \
559  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK; \
560  break; \
561  case RCC_USART3CLKSOURCE_LSE: \
562  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
563  break; \
564  default: \
565  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
566  break; \
567  } \
568  } \
569  else if((__HANDLE__)->Instance == UART4) \
570  { \
571  switch(__HAL_RCC_GET_UART4_SOURCE()) \
572  { \
573  case RCC_UART4CLKSOURCE_PCLK1: \
574  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1; \
575  break; \
576  case RCC_UART4CLKSOURCE_HSI: \
577  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
578  break; \
579  case RCC_UART4CLKSOURCE_SYSCLK: \
580  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK; \
581  break; \
582  case RCC_UART4CLKSOURCE_LSE: \
583  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
584  break; \
585  default: \
586  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
587  break; \
588  } \
589  } \
590  else if((__HANDLE__)->Instance == LPUART1) \
591  { \
592  switch(__HAL_RCC_GET_LPUART1_SOURCE()) \
593  { \
594  case RCC_LPUART1CLKSOURCE_PCLK1: \
595  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1; \
596  break; \
597  case RCC_LPUART1CLKSOURCE_HSI: \
598  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
599  break; \
600  case RCC_LPUART1CLKSOURCE_SYSCLK: \
601  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK; \
602  break; \
603  case RCC_LPUART1CLKSOURCE_LSE: \
604  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
605  break; \
606  default: \
607  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
608  break; \
609  } \
610  } \
611  else \
612  { \
613  (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
614  } \
615  } while(0U)
616 #endif /* STM32L471xx || STM32L475xx || STM32L476xx || STM32L485xx || STM32L486xx ||
617  * STM32L496xx || STM32L4A6xx ||
618  * STM32L4R5xx || STM32L4R7xx || STM32L4R9xx || STM32L4S5xx || STM32L4S7xx || STM32L4S9xx
619  */
620 
630 #define UART_MASK_COMPUTATION(__HANDLE__) \
631  do { \
632  if ((__HANDLE__)->Init.WordLength == UART_WORDLENGTH_9B) \
633  { \
634  if ((__HANDLE__)->Init.Parity == UART_PARITY_NONE) \
635  { \
636  (__HANDLE__)->Mask = 0x01FFU ; \
637  } \
638  else \
639  { \
640  (__HANDLE__)->Mask = 0x00FFU ; \
641  } \
642  } \
643  else if ((__HANDLE__)->Init.WordLength == UART_WORDLENGTH_8B) \
644  { \
645  if ((__HANDLE__)->Init.Parity == UART_PARITY_NONE) \
646  { \
647  (__HANDLE__)->Mask = 0x00FFU ; \
648  } \
649  else \
650  { \
651  (__HANDLE__)->Mask = 0x007FU ; \
652  } \
653  } \
654  else if ((__HANDLE__)->Init.WordLength == UART_WORDLENGTH_7B) \
655  { \
656  if ((__HANDLE__)->Init.Parity == UART_PARITY_NONE) \
657  { \
658  (__HANDLE__)->Mask = 0x007FU ; \
659  } \
660  else \
661  { \
662  (__HANDLE__)->Mask = 0x003FU ; \
663  } \
664  } \
665  else \
666  { \
667  (__HANDLE__)->Mask = 0x0000U; \
668  } \
669  } while(0U)
670 
676 #define IS_UART_WORD_LENGTH(__LENGTH__) (((__LENGTH__) == UART_WORDLENGTH_7B) || \
677  ((__LENGTH__) == UART_WORDLENGTH_8B) || \
678  ((__LENGTH__) == UART_WORDLENGTH_9B))
679 
685 #define IS_UART_ADDRESSLENGTH_DETECT(__ADDRESS__) (((__ADDRESS__) == UART_ADDRESS_DETECT_4B) || \
686  ((__ADDRESS__) == UART_ADDRESS_DETECT_7B))
687 
688 #if defined(USART_CR1_FIFOEN)
689 
694 #define IS_UART_TXFIFO_THRESHOLD(__THRESHOLD__) (((__THRESHOLD__) == UART_TXFIFO_THRESHOLD_1_8) || \
695  ((__THRESHOLD__) == UART_TXFIFO_THRESHOLD_1_4) || \
696  ((__THRESHOLD__) == UART_TXFIFO_THRESHOLD_1_2) || \
697  ((__THRESHOLD__) == UART_TXFIFO_THRESHOLD_3_4) || \
698  ((__THRESHOLD__) == UART_TXFIFO_THRESHOLD_7_8) || \
699  ((__THRESHOLD__) == UART_TXFIFO_THRESHOLD_8_8))
700 
706 #define IS_UART_RXFIFO_THRESHOLD(__THRESHOLD__) (((__THRESHOLD__) == UART_RXFIFO_THRESHOLD_1_8) || \
707  ((__THRESHOLD__) == UART_RXFIFO_THRESHOLD_1_4) || \
708  ((__THRESHOLD__) == UART_RXFIFO_THRESHOLD_1_2) || \
709  ((__THRESHOLD__) == UART_RXFIFO_THRESHOLD_3_4) || \
710  ((__THRESHOLD__) == UART_RXFIFO_THRESHOLD_7_8) || \
711  ((__THRESHOLD__) == UART_RXFIFO_THRESHOLD_8_8))
712 #endif /* USART_CR1_FIFOEN */
713 
718 /* Private functions ---------------------------------------------------------*/
719 
728 #ifdef __cplusplus
729 }
730 #endif
731 
732 #endif /* STM32L4xx_HAL_UART_EX_H */
733 
734 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
HAL_UARTEx_StopModeWakeUpSourceConfig
HAL_StatusTypeDef HAL_UARTEx_StopModeWakeUpSourceConfig(UART_HandleTypeDef *huart, UART_WakeUpTypeDef WakeUpSelection)
Set Wakeup from Stop mode interrupt flag selection.
Definition: stm32l4xx_hal_uart_ex.c:444
HAL_UARTEx_EnableClockStopMode
HAL_StatusTypeDef HAL_UARTEx_EnableClockStopMode(UART_HandleTypeDef *huart)
Keep UART Clock enabled when in Stop Mode.
Definition: stm32l4xx_hal_uart_ex.c:359
__UART_HandleTypeDef
UART handle Structure definition.
Definition: stm32l4xx_hal_uart.h:197
HAL_UARTEx_TxFifoEmptyCallback
void HAL_UARTEx_TxFifoEmptyCallback(UART_HandleTypeDef *huart)
UART TX Fifo empty callback.
Definition: stm32l4xx_hal_uart_ex.c:307
UART_WakeUpTypeDef::AddressLength
uint16_t AddressLength
Definition: stm32l4xx_hal_uart_ex.h:54
UART_WakeUpTypeDef::WakeUpEvent
uint32_t WakeUpEvent
Definition: stm32l4xx_hal_uart_ex.h:49
stm32l4xx_hal_def.h
This file contains HAL common defines, enumeration, macros and structures definitions.
HAL_UARTEx_RxFifoFullCallback
void HAL_UARTEx_RxFifoFullCallback(UART_HandleTypeDef *huart)
UART RX Fifo full callback.
Definition: stm32l4xx_hal_uart_ex.c:292
HAL_RS485Ex_Init
HAL_StatusTypeDef HAL_RS485Ex_Init(UART_HandleTypeDef *huart, uint32_t Polarity, uint32_t AssertionTime, uint32_t DeassertionTime)
Initialize the RS485 Driver enable feature according to the specified parameters in the UART_InitType...
Definition: stm32l4xx_hal_uart_ex.c:170
HAL_UARTEx_SetRxFifoThreshold
HAL_StatusTypeDef HAL_UARTEx_SetRxFifoThreshold(UART_HandleTypeDef *huart, uint32_t Threshold)
Set the RXFIFO threshold.
Definition: stm32l4xx_hal_uart_ex.c:674
UART_WakeUpTypeDef::Address
uint8_t Address
Definition: stm32l4xx_hal_uart_ex.h:57
UART_WakeUpTypeDef
UART wake up from stop mode parameters.
Definition: stm32l4xx_hal_uart_ex.h:47
HAL_MultiProcessorEx_AddressLength_Set
HAL_StatusTypeDef HAL_MultiProcessorEx_AddressLength_Set(UART_HandleTypeDef *huart, uint32_t AddressLength)
By default in multiprocessor mode, when the wake up method is set to address mark, the UART handles only 4-bit long addresses detection; this API allows to enable longer addresses detection (6-, 7- or 8-bit long).
Definition: stm32l4xx_hal_uart_ex.c:406
HAL_UARTEx_SetTxFifoThreshold
HAL_StatusTypeDef HAL_UARTEx_SetTxFifoThreshold(UART_HandleTypeDef *huart, uint32_t Threshold)
Set the TXFIFO threshold.
Definition: stm32l4xx_hal_uart_ex.c:625
HAL_UARTEx_EnableStopMode
HAL_StatusTypeDef HAL_UARTEx_EnableStopMode(UART_HandleTypeDef *huart)
Enable UART Stop Mode.
Definition: stm32l4xx_hal_uart_ex.c:499
HAL_UARTEx_DisableFifoMode
HAL_StatusTypeDef HAL_UARTEx_DisableFifoMode(UART_HandleTypeDef *huart)
Disable the FIFO mode.
Definition: stm32l4xx_hal_uart_ex.c:579
HAL_UARTEx_WakeupCallback
void HAL_UARTEx_WakeupCallback(UART_HandleTypeDef *huart)
UART wakeup from Stop mode callback.
Definition: stm32l4xx_hal_uart_ex.c:276
HAL_UARTEx_EnableFifoMode
HAL_StatusTypeDef HAL_UARTEx_EnableFifoMode(UART_HandleTypeDef *huart)
Enable the FIFO mode.
Definition: stm32l4xx_hal_uart_ex.c:538
HAL_UARTEx_DisableClockStopMode
HAL_StatusTypeDef HAL_UARTEx_DisableClockStopMode(UART_HandleTypeDef *huart)
Disable UART Clock when in Stop Mode.
Definition: stm32l4xx_hal_uart_ex.c:378
HAL_UARTEx_DisableStopMode
HAL_StatusTypeDef HAL_UARTEx_DisableStopMode(UART_HandleTypeDef *huart)
Disable UART Stop Mode.
Definition: stm32l4xx_hal_uart_ex.c:518