jmg
/
stm32lib
1
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
18 Commits
1 Branch
14 MiB
 
 
 
Tree: 8e37b3563a
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '8e37b3563a'
${ noResults }
stm32lib/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_uart_ex.h

555 lines
28 KiB
Raw Blame History 

  1. /**

  2.   ******************************************************************************

  3.   * @file    stm32h7xx_hal_uart_ex.h

  4.   * @author  MCD Application Team

  5.   * @brief   Header file of UART HAL Extended module.

  6.   ******************************************************************************

  7.   * @attention

  8.   *

  9.   * <h2><center>&copy; Copyright (c) 2017 STMicroelectronics.

  10.   * All rights reserved.</center></h2>

  11.   *

  12.   * This software component is licensed by ST under BSD 3-Clause license,

  13.   * the "License"; You may not use this file except in compliance with the

  14.   * License. You may obtain a copy of the License at:

  15.   *                        opensource.org/licenses/BSD-3-Clause

  16.   *

  17.   ******************************************************************************

  18.   */

  19. 

  20. /* Define to prevent recursive inclusion -------------------------------------*/

  21. #ifndef STM32H7xx_HAL_UART_EX_H

  22. #define STM32H7xx_HAL_UART_EX_H

  23. 

  24. #ifdef __cplusplus

  25. extern "C" {

  26. #endif

  27. 

  28. /* Includes ------------------------------------------------------------------*/

  29. #include "stm32h7xx_hal_def.h"

  30. 

  31. /** @addtogroup STM32H7xx_HAL_Driver

  32.   * @{

  33.   */

  34. 

  35. /** @addtogroup UARTEx

  36.   * @{

  37.   */

  38. 

  39. /* Exported types ------------------------------------------------------------*/

  40. /** @defgroup UARTEx_Exported_Types UARTEx Exported Types

  41.   * @{

  42.   */

  43. 

  44. /**

  45.   * @brief  UART wake up from stop mode parameters

  46.   */

  47. typedef struct

  48. {

  49.   uint32_t WakeUpEvent;        /*!< Specifies which event will activate the Wakeup from Stop mode flag (WUF).

  50.                                     This parameter can be a value of @ref UART_WakeUp_from_Stop_Selection.

  51.                                     If set to UART_WAKEUP_ON_ADDRESS, the two other fields below must

  52.                                     be filled up. */

  53. 

  54.   uint16_t AddressLength;      /*!< Specifies whether the address is 4 or 7-bit long.

  55.                                     This parameter can be a value of @ref UARTEx_WakeUp_Address_Length.  */

  56. 

  57.   uint8_t Address;             /*!< UART/USART node address (7-bit long max). */

  58. } UART_WakeUpTypeDef;

  59. 

  60. /**

  61.   * @}

  62.   */

  63. 

  64. /* Exported constants --------------------------------------------------------*/

  65. /** @defgroup UARTEx_Exported_Constants UARTEx Exported Constants

  66.   * @{

  67.   */

  68. 

  69. /** @defgroup UARTEx_Word_Length UARTEx Word Length

  70.   * @{

  71.   */

  72. #define UART_WORDLENGTH_7B                  USART_CR1_M1   /*!< 7-bit long UART frame */

  73. #define UART_WORDLENGTH_8B                  0x00000000U    /*!< 8-bit long UART frame */

  74. #define UART_WORDLENGTH_9B                  USART_CR1_M0   /*!< 9-bit long UART frame */

  75. /**

  76.   * @}

  77.   */

  78. 

  79. /** @defgroup UARTEx_WakeUp_Address_Length UARTEx WakeUp Address Length

  80.   * @{

  81.   */

  82. #define UART_ADDRESS_DETECT_4B              0x00000000U      /*!< 4-bit long wake-up address */

  83. #define UART_ADDRESS_DETECT_7B              USART_CR2_ADDM7  /*!< 7-bit long wake-up address */

  84. /**

  85.   * @}

  86.   */

  87. 

  88. /** @defgroup UARTEx_FIFO_mode UARTEx FIFO mode

  89.   * @brief    UART FIFO mode

  90.   * @{

  91.   */

  92. #define UART_FIFOMODE_DISABLE        0x00000000U       /*!< FIFO mode disable */

  93. #define UART_FIFOMODE_ENABLE         USART_CR1_FIFOEN  /*!< FIFO mode enable  */

  94. /**

  95.   * @}

  96.   */

  97. 

  98. /** @defgroup UARTEx_TXFIFO_threshold_level UARTEx TXFIFO threshold level

  99.   * @brief    UART TXFIFO threshold level

  100.   * @{

  101.   */

  102. #define UART_TXFIFO_THRESHOLD_1_8   0x00000000U                               /*!< TXFIFO reaches 1/8 of its depth */

  103. #define UART_TXFIFO_THRESHOLD_1_4   USART_CR3_TXFTCFG_0                       /*!< TXFIFO reaches 1/4 of its depth */

  104. #define UART_TXFIFO_THRESHOLD_1_2   USART_CR3_TXFTCFG_1                       /*!< TXFIFO reaches 1/2 of its depth */

  105. #define UART_TXFIFO_THRESHOLD_3_4   (USART_CR3_TXFTCFG_0|USART_CR3_TXFTCFG_1) /*!< TXFIFO reaches 3/4 of its depth */

  106. #define UART_TXFIFO_THRESHOLD_7_8   USART_CR3_TXFTCFG_2                       /*!< TXFIFO reaches 7/8 of its depth */

  107. #define UART_TXFIFO_THRESHOLD_8_8   (USART_CR3_TXFTCFG_2|USART_CR3_TXFTCFG_0) /*!< TXFIFO becomes empty            */

  108. /**

  109.   * @}

  110.   */

  111. 

  112. /** @defgroup UARTEx_RXFIFO_threshold_level UARTEx RXFIFO threshold level

  113.   * @brief    UART RXFIFO threshold level

  114.   * @{

  115.   */

  116. #define UART_RXFIFO_THRESHOLD_1_8   0x00000000U                               /*!< RXFIFO FIFO reaches 1/8 of its depth */

  117. #define UART_RXFIFO_THRESHOLD_1_4   USART_CR3_RXFTCFG_0                       /*!< RXFIFO FIFO reaches 1/4 of its depth */

  118. #define UART_RXFIFO_THRESHOLD_1_2   USART_CR3_RXFTCFG_1                       /*!< RXFIFO FIFO reaches 1/2 of its depth */

  119. #define UART_RXFIFO_THRESHOLD_3_4   (USART_CR3_RXFTCFG_0|USART_CR3_RXFTCFG_1) /*!< RXFIFO FIFO reaches 3/4 of its depth */

  120. #define UART_RXFIFO_THRESHOLD_7_8   USART_CR3_RXFTCFG_2                       /*!< RXFIFO FIFO reaches 7/8 of its depth */

  121. #define UART_RXFIFO_THRESHOLD_8_8   (USART_CR3_RXFTCFG_2|USART_CR3_RXFTCFG_0) /*!< RXFIFO FIFO becomes full             */

  122. /**

  123.   * @}

  124.   */

  125. 

  126. /**

  127.   * @}

  128.   */

  129. 

  130. /* Exported macros -----------------------------------------------------------*/

  131. /* Exported functions --------------------------------------------------------*/

  132. /** @addtogroup UARTEx_Exported_Functions

  133.   * @{

  134.   */

  135. 

  136. /** @addtogroup UARTEx_Exported_Functions_Group1

  137.   * @{

  138.   */

  139. 

  140. /* Initialization and de-initialization functions  ****************************/

  141. HAL_StatusTypeDef HAL_RS485Ex_Init(UART_HandleTypeDef *huart, uint32_t Polarity, uint32_t AssertionTime, uint32_t DeassertionTime);

  142. 

  143. /**

  144.   * @}

  145.   */

  146. 

  147. /** @addtogroup UARTEx_Exported_Functions_Group2

  148.   * @{

  149.   */

  150. 

  151. void HAL_UARTEx_WakeupCallback(UART_HandleTypeDef *huart);

  152. 

  153. void HAL_UARTEx_RxFifoFullCallback(UART_HandleTypeDef *huart);

  154. void HAL_UARTEx_TxFifoEmptyCallback(UART_HandleTypeDef *huart);

  155. 

  156. /**

  157.   * @}

  158.   */

  159. 

  160. /** @addtogroup UARTEx_Exported_Functions_Group3

  161.   * @{

  162.   */

  163. 

  164. /* Peripheral Control functions  **********************************************/

  165. HAL_StatusTypeDef HAL_UARTEx_StopModeWakeUpSourceConfig(UART_HandleTypeDef *huart, UART_WakeUpTypeDef WakeUpSelection);

  166. HAL_StatusTypeDef HAL_UARTEx_EnableStopMode(UART_HandleTypeDef *huart);

  167. HAL_StatusTypeDef HAL_UARTEx_DisableStopMode(UART_HandleTypeDef *huart);

  168. HAL_StatusTypeDef HAL_MultiProcessorEx_AddressLength_Set(UART_HandleTypeDef *huart, uint32_t AddressLength);

  169. HAL_StatusTypeDef HAL_UARTEx_EnableFifoMode(UART_HandleTypeDef *huart);

  170. HAL_StatusTypeDef HAL_UARTEx_DisableFifoMode(UART_HandleTypeDef *huart);

  171. HAL_StatusTypeDef HAL_UARTEx_SetTxFifoThreshold(UART_HandleTypeDef *huart, uint32_t Threshold);

  172. HAL_StatusTypeDef HAL_UARTEx_SetRxFifoThreshold(UART_HandleTypeDef *huart, uint32_t Threshold);

  173. 

  174. /**

  175.   * @}

  176.   */

  177. 

  178. /**

  179.   * @}

  180.   */

  181. 

  182. /* Private macros ------------------------------------------------------------*/

  183. /** @defgroup UARTEx_Private_Macros UARTEx Private Macros

  184.   * @{

  185.   */

  186. 

  187. /** @brief  Report the UART clock source.

  188.   * @param  __HANDLE__ specifies the UART Handle.

  189.   * @param  __CLOCKSOURCE__ output variable.

  190.   * @retval UART clocking source, written in __CLOCKSOURCE__.

  191.   */

  192. #define UART_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__)       \

  193.   do {                                                        \

  194.     if((__HANDLE__)->Instance == USART1)                      \

  195.     {                                                         \

  196.       switch(__HAL_RCC_GET_USART1_SOURCE())                   \

  197.       {                                                       \

  198.         case RCC_USART1CLKSOURCE_D2PCLK2:                     \

  199.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D2PCLK2;       \

  200.           break;                                              \

  201.         case RCC_USART1CLKSOURCE_PLL2:                        \

  202.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2;          \

  203.           break;                                              \

  204.         case RCC_USART1CLKSOURCE_PLL3:                        \

  205.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3;          \

  206.           break;                                              \

  207.         case RCC_USART1CLKSOURCE_HSI:                         \

  208.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \

  209.           break;                                              \

  210.         case RCC_USART1CLKSOURCE_CSI:                         \

  211.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI;           \

  212.           break;                                              \

  213.         case RCC_USART1CLKSOURCE_LSE:                         \

  214.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \

  215.           break;                                              \

  216.         default:                                              \

  217.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \

  218.           break;                                              \

  219.       }                                                       \

  220.     }                                                         \

  221.     else if((__HANDLE__)->Instance == USART2)                 \

  222.     {                                                         \

  223.       switch(__HAL_RCC_GET_USART2_SOURCE())                   \

  224.       {                                                       \

  225.         case RCC_USART2CLKSOURCE_D2PCLK1:                     \

  226.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D2PCLK1;       \

  227.           break;                                              \

  228.         case RCC_USART2CLKSOURCE_PLL2:                        \

  229.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2;          \

  230.           break;                                              \

  231.         case RCC_USART2CLKSOURCE_PLL3:                        \

  232.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3;          \

  233.           break;                                              \

  234.         case RCC_USART2CLKSOURCE_HSI:                         \

  235.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \

  236.           break;                                              \

  237.         case RCC_USART2CLKSOURCE_CSI:                         \

  238.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI;           \

  239.           break;                                              \

  240.         case RCC_USART2CLKSOURCE_LSE:                         \

  241.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \

  242.           break;                                              \

  243.         default:                                              \

  244.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \

  245.           break;                                              \

  246.       }                                                       \

  247.     }                                                         \

  248.     else if((__HANDLE__)->Instance == USART3)                 \

  249.     {                                                         \

  250.       switch(__HAL_RCC_GET_USART3_SOURCE())                   \

  251.       {                                                       \

  252.         case RCC_USART3CLKSOURCE_D2PCLK1:                     \

  253.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D2PCLK1;       \

  254.           break;                                              \

  255.         case RCC_USART3CLKSOURCE_PLL2:                        \

  256.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2;          \

  257.           break;                                              \

  258.         case RCC_USART3CLKSOURCE_PLL3:                        \

  259.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3;          \

  260.           break;                                              \

  261.         case RCC_USART3CLKSOURCE_HSI:                         \

  262.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \

  263.           break;                                              \

  264.         case RCC_USART3CLKSOURCE_CSI:                         \

  265.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI;           \

  266.           break;                                              \

  267.         case RCC_USART3CLKSOURCE_LSE:                         \

  268.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \

  269.           break;                                              \

  270.         default:                                              \

  271.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \

  272.           break;                                              \

  273.       }                                                       \

  274.     }                                                         \

  275.     else if((__HANDLE__)->Instance == UART4)                  \

  276.     {                                                         \

  277.       switch(__HAL_RCC_GET_UART4_SOURCE())                    \

  278.       {                                                       \

  279.         case RCC_UART4CLKSOURCE_D2PCLK1:                      \

  280.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D2PCLK1;       \

  281.           break;                                              \

  282.         case RCC_UART4CLKSOURCE_PLL2:                         \

  283.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2;          \

  284.           break;                                              \

  285.         case RCC_UART4CLKSOURCE_PLL3:                         \

  286.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3;          \

  287.           break;                                              \

  288.         case RCC_UART4CLKSOURCE_HSI:                          \

  289.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \

  290.           break;                                              \

  291.         case RCC_UART4CLKSOURCE_CSI:                          \

  292.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI;           \

  293.           break;                                              \

  294.         case RCC_UART4CLKSOURCE_LSE:                          \

  295.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \

  296.           break;                                              \

  297.         default:                                              \

  298.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \

  299.           break;                                              \

  300.       }                                                       \

  301.     }                                                         \

  302.     else if ((__HANDLE__)->Instance == UART5)                 \

  303.     {                                                         \

  304.       switch(__HAL_RCC_GET_UART5_SOURCE())                    \

  305.       {                                                       \

  306.         case RCC_UART5CLKSOURCE_D2PCLK1:                      \

  307.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D2PCLK1;       \

  308.           break;                                              \

  309.         case RCC_UART5CLKSOURCE_PLL2:                         \

  310.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2;          \

  311.           break;                                              \

  312.         case RCC_UART5CLKSOURCE_PLL3:                         \

  313.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3;          \

  314.           break;                                              \

  315.         case RCC_UART5CLKSOURCE_HSI:                          \

  316.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \

  317.           break;                                              \

  318.         case RCC_UART5CLKSOURCE_CSI:                          \

  319.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI;           \

  320.           break;                                              \

  321.         case RCC_UART5CLKSOURCE_LSE:                          \

  322.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \

  323.           break;                                              \

  324.         default:                                              \

  325.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \

  326.           break;                                              \

  327.       }                                                       \

  328.     }                                                         \

  329.     else if((__HANDLE__)->Instance == USART6)                 \

  330.     {                                                         \

  331.       switch(__HAL_RCC_GET_USART6_SOURCE())                   \

  332.       {                                                       \

  333.         case RCC_USART6CLKSOURCE_D2PCLK2:                     \

  334.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D2PCLK2;       \

  335.           break;                                              \

  336.         case RCC_USART6CLKSOURCE_PLL2:                        \

  337.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2;          \

  338.           break;                                              \

  339.         case RCC_USART6CLKSOURCE_PLL3:                        \

  340.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3;          \

  341.           break;                                              \

  342.         case RCC_USART6CLKSOURCE_HSI:                         \

  343.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \

  344.           break;                                              \

  345.         case RCC_USART6CLKSOURCE_CSI:                         \

  346.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI;           \

  347.           break;                                              \

  348.         case RCC_USART6CLKSOURCE_LSE:                         \

  349.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \

  350.           break;                                              \

  351.         default:                                              \

  352.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \

  353.           break;                                              \

  354.       }                                                       \

  355.     }                                                         \

  356.     else if((__HANDLE__)->Instance == UART7)                  \

  357.     {                                                         \

  358.       switch(__HAL_RCC_GET_UART7_SOURCE())                    \

  359.       {                                                       \

  360.         case RCC_UART7CLKSOURCE_D2PCLK1:                      \

  361.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D2PCLK1;       \

  362.           break;                                              \

  363.         case RCC_UART7CLKSOURCE_PLL2:                         \

  364.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2;          \

  365.           break;                                              \

  366.         case RCC_UART7CLKSOURCE_PLL3:                         \

  367.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3;          \

  368.           break;                                              \

  369.         case RCC_UART7CLKSOURCE_HSI:                          \

  370.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \

  371.           break;                                              \

  372.         case RCC_UART7CLKSOURCE_CSI:                          \

  373.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI;           \

  374.           break;                                              \

  375.         case RCC_UART7CLKSOURCE_LSE:                          \

  376.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \

  377.           break;                                              \

  378.         default:                                              \

  379.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \

  380.           break;                                              \

  381.       }                                                       \

  382.     }                                                         \

  383.     else if((__HANDLE__)->Instance == UART8)                  \

  384.     {                                                         \

  385.       switch(__HAL_RCC_GET_UART8_SOURCE())                    \

  386.       {                                                       \

  387.         case RCC_UART8CLKSOURCE_D2PCLK1:                      \

  388.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D2PCLK1;       \

  389.           break;                                              \

  390.         case RCC_UART8CLKSOURCE_PLL2:                         \

  391.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2;          \

  392.           break;                                              \

  393.         case RCC_UART8CLKSOURCE_PLL3:                         \

  394.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3;          \

  395.           break;                                              \

  396.         case RCC_UART8CLKSOURCE_HSI:                          \

  397.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \

  398.           break;                                              \

  399.         case RCC_UART8CLKSOURCE_CSI:                          \

  400.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI;           \

  401.           break;                                              \

  402.         case RCC_UART8CLKSOURCE_LSE:                          \

  403.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \

  404.           break;                                              \

  405.         default:                                              \

  406.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \

  407.           break;                                              \

  408.       }                                                       \

  409.     }                                                         \

  410.     else if((__HANDLE__)->Instance == LPUART1)                \

  411.     {                                                         \

  412.       switch(__HAL_RCC_GET_LPUART1_SOURCE())                  \

  413.       {                                                       \

  414.         case RCC_LPUART1CLKSOURCE_D3PCLK1:                    \

  415.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D3PCLK1;       \

  416.           break;                                              \

  417.         case RCC_LPUART1CLKSOURCE_PLL2:                       \

  418.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2;          \

  419.           break;                                              \

  420.         case RCC_LPUART1CLKSOURCE_PLL3:                       \

  421.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3;          \

  422.           break;                                              \

  423.         case RCC_LPUART1CLKSOURCE_HSI:                        \

  424.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \

  425.           break;                                              \

  426.         case RCC_LPUART1CLKSOURCE_CSI:                        \

  427.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI;           \

  428.           break;                                              \

  429.         case RCC_LPUART1CLKSOURCE_LSE:                        \

  430.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \

  431.           break;                                              \

  432.         default:                                              \

  433.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \

  434.           break;                                              \

  435.       }                                                       \

  436.     }                                                         \

  437.     else                                                      \

  438.     {                                                         \

  439.       (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;         \

  440.     }                                                         \

  441.   } while(0U)

  442. 

  443. /** @brief  Report the UART mask to apply to retrieve the received data

  444.   *         according to the word length and to the parity bits activation.

  445.   * @note   If PCE = 1, the parity bit is not included in the data extracted

  446.   *         by the reception API().

  447.   *         This masking operation is not carried out in the case of

  448.   *         DMA transfers.

  449.   * @param  __HANDLE__ specifies the UART Handle.

  450.   * @retval None, the mask to apply to UART RDR register is stored in (__HANDLE__)->Mask field.

  451.   */

  452. #define UART_MASK_COMPUTATION(__HANDLE__)                             \

  453.   do {                                                                \

  454.   if ((__HANDLE__)->Init.WordLength == UART_WORDLENGTH_9B)            \

  455.   {                                                                   \

  456.      if ((__HANDLE__)->Init.Parity == UART_PARITY_NONE)               \

  457.      {                                                                \

  458.         (__HANDLE__)->Mask = 0x01FFU ;                                \

  459.      }                                                                \

  460.      else                                                             \

  461.      {                                                                \

  462.         (__HANDLE__)->Mask = 0x00FFU ;                                \

  463.      }                                                                \

  464.   }                                                                   \

  465.   else if ((__HANDLE__)->Init.WordLength == UART_WORDLENGTH_8B)       \

  466.   {                                                                   \

  467.      if ((__HANDLE__)->Init.Parity == UART_PARITY_NONE)               \

  468.      {                                                                \

  469.         (__HANDLE__)->Mask = 0x00FFU ;                                \

  470.      }                                                                \

  471.      else                                                             \

  472.      {                                                                \

  473.         (__HANDLE__)->Mask = 0x007FU ;                                \

  474.      }                                                                \

  475.   }                                                                   \

  476.   else if ((__HANDLE__)->Init.WordLength == UART_WORDLENGTH_7B)       \

  477.   {                                                                   \

  478.      if ((__HANDLE__)->Init.Parity == UART_PARITY_NONE)               \

  479.      {                                                                \

  480.         (__HANDLE__)->Mask = 0x007FU ;                                \

  481.      }                                                                \

  482.      else                                                             \

  483.      {                                                                \

  484.         (__HANDLE__)->Mask = 0x003FU ;                                \

  485.      }                                                                \

  486.   }                                                                   \

  487.   else                                                                \

  488.   {                                                                   \

  489.     (__HANDLE__)->Mask = 0x0000U;                                     \

  490.   }                                                                   \

  491. } while(0U)

  492. 

  493. /**

  494.   * @brief Ensure that UART frame length is valid.

  495.   * @param __LENGTH__ UART frame length.

  496.   * @retval SET (__LENGTH__ is valid) or RESET (__LENGTH__ is invalid)

  497.   */

  498. #define IS_UART_WORD_LENGTH(__LENGTH__) (((__LENGTH__) == UART_WORDLENGTH_7B) || \

  499.                                          ((__LENGTH__) == UART_WORDLENGTH_8B) || \

  500.                                          ((__LENGTH__) == UART_WORDLENGTH_9B))

  501. 

  502. /**

  503.   * @brief Ensure that UART wake-up address length is valid.

  504.   * @param __ADDRESS__ UART wake-up address length.

  505.   * @retval SET (__ADDRESS__ is valid) or RESET (__ADDRESS__ is invalid)

  506.   */

  507. #define IS_UART_ADDRESSLENGTH_DETECT(__ADDRESS__) (((__ADDRESS__) == UART_ADDRESS_DETECT_4B) || \

  508.                                                    ((__ADDRESS__) == UART_ADDRESS_DETECT_7B))

  509. 

  510. /**

  511.   * @brief Ensure that UART TXFIFO threshold level is valid.

  512.   * @param __THRESHOLD__ UART TXFIFO threshold level.

  513.   * @retval SET (__THRESHOLD__ is valid) or RESET (__THRESHOLD__ is invalid)

  514.   */

  515. #define IS_UART_TXFIFO_THRESHOLD(__THRESHOLD__) (((__THRESHOLD__) == UART_TXFIFO_THRESHOLD_1_8) || \

  516.                                                  ((__THRESHOLD__) == UART_TXFIFO_THRESHOLD_1_4) || \

  517.                                                  ((__THRESHOLD__) == UART_TXFIFO_THRESHOLD_1_2) || \

  518.                                                  ((__THRESHOLD__) == UART_TXFIFO_THRESHOLD_3_4) || \

  519.                                                  ((__THRESHOLD__) == UART_TXFIFO_THRESHOLD_7_8) || \

  520.                                                  ((__THRESHOLD__) == UART_TXFIFO_THRESHOLD_8_8))

  521. 

  522. /**

  523.   * @brief Ensure that UART RXFIFO threshold level is valid.

  524.   * @param __THRESHOLD__ UART RXFIFO threshold level.

  525.   * @retval SET (__THRESHOLD__ is valid) or RESET (__THRESHOLD__ is invalid)

  526.   */

  527. #define IS_UART_RXFIFO_THRESHOLD(__THRESHOLD__) (((__THRESHOLD__) == UART_RXFIFO_THRESHOLD_1_8) || \

  528.                                                  ((__THRESHOLD__) == UART_RXFIFO_THRESHOLD_1_4) || \

  529.                                                  ((__THRESHOLD__) == UART_RXFIFO_THRESHOLD_1_2) || \

  530.                                                  ((__THRESHOLD__) == UART_RXFIFO_THRESHOLD_3_4) || \

  531.                                                  ((__THRESHOLD__) == UART_RXFIFO_THRESHOLD_7_8) || \

  532.                                                  ((__THRESHOLD__) == UART_RXFIFO_THRESHOLD_8_8))

  533. 

  534. /**

  535.   * @}

  536.   */

  537. 

  538. /* Private functions ---------------------------------------------------------*/

  539. 

  540. /**

  541.   * @}

  542.   */

  543. 

  544. /**

  545.   * @}

  546.   */

  547. 

  548. #ifdef __cplusplus

  549. }

  550. #endif

  551. 

  552. #endif /* STM32H7xx_HAL_UART_EX_H */

  553. 

  554. /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/