Subversion Repositories FuelGauge

Rev

Rev 2 | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. /**
  2.   ******************************************************************************
  3.   * @file    stm32f0xx_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) 2016 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 STM32F0xx_HAL_UART_EX_H
  22. #define STM32F0xx_HAL_UART_EX_H
  23.  
  24. #ifdef __cplusplus
  25. extern "C" {
  26. #endif
  27.  
  28. /* Includes ------------------------------------------------------------------*/
  29. #include "stm32f0xx_hal_def.h"
  30.  
  31. /** @addtogroup STM32F0xx_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. #if defined(USART_CR1_UESM)
  45. /**
  46.   * @brief  UART wake up from stop mode parameters
  47.   */
  48. typedef struct
  49. {
  50.   uint32_t WakeUpEvent;        /*!< Specifies which event will activate the Wakeup from Stop mode flag (WUF).
  51.                                     This parameter can be a value of @ref UART_WakeUp_from_Stop_Selection.
  52.                                     If set to UART_WAKEUP_ON_ADDRESS, the two other fields below must
  53.                                     be filled up. */
  54.  
  55.   uint16_t AddressLength;      /*!< Specifies whether the address is 4 or 7-bit long.
  56.                                     This parameter can be a value of @ref UARTEx_WakeUp_Address_Length.  */
  57.  
  58.   uint8_t Address;             /*!< UART/USART node address (7-bit long max). */
  59. } UART_WakeUpTypeDef;
  60.  
  61. #endif /* USART_CR1_UESM */
  62. /**
  63.   * @}
  64.   */
  65.  
  66. /* Exported constants --------------------------------------------------------*/
  67. /** @defgroup UARTEx_Exported_Constants UARTEx Exported Constants
  68.   * @{
  69.   */
  70.  
  71. /** @defgroup UARTEx_Word_Length UARTEx Word Length
  72.   * @{
  73.   */
  74. #if defined(USART_CR1_M1)
  75. #define UART_WORDLENGTH_7B          USART_CR1_M1   /*!< 7-bit long UART frame */
  76. #endif /* USART_CR1_M1 */
  77. #define UART_WORDLENGTH_8B          0x00000000U    /*!< 8-bit long UART frame */
  78. #if defined (USART_CR1_M0)
  79. #define UART_WORDLENGTH_9B          USART_CR1_M0   /*!< 9-bit long UART frame */
  80. #else
  81. #define UART_WORDLENGTH_9B          USART_CR1_M   /*!< 9-bit long UART frame */
  82. #endif /* USART_CR1_M0 */
  83. /**
  84.   * @}
  85.   */
  86.  
  87. /** @defgroup UARTEx_WakeUp_Address_Length UARTEx WakeUp Address Length
  88.   * @{
  89.   */
  90. #define UART_ADDRESS_DETECT_4B      0x00000000U      /*!< 4-bit long wake-up address */
  91. #define UART_ADDRESS_DETECT_7B      USART_CR2_ADDM7  /*!< 7-bit long wake-up address */
  92. /**
  93.   * @}
  94.   */
  95.  
  96. /**
  97.   * @}
  98.   */
  99.  
  100. /* Exported macros -----------------------------------------------------------*/
  101. /* Exported functions --------------------------------------------------------*/
  102. /** @addtogroup UARTEx_Exported_Functions
  103.   * @{
  104.   */
  105.  
  106. /** @addtogroup UARTEx_Exported_Functions_Group1
  107.   * @{
  108.   */
  109.  
  110. /* Initialization and de-initialization functions  ****************************/
  111. HAL_StatusTypeDef HAL_RS485Ex_Init(UART_HandleTypeDef *huart, uint32_t Polarity, uint32_t AssertionTime,
  112.                                    uint32_t DeassertionTime);
  113.  
  114. /**
  115.   * @}
  116.   */
  117.  
  118. /** @addtogroup UARTEx_Exported_Functions_Group2
  119.   * @{
  120.   */
  121.  
  122. #if defined(USART_CR1_UESM)
  123. void HAL_UARTEx_WakeupCallback(UART_HandleTypeDef *huart);
  124.  
  125. #endif /* USART_CR1_UESM */
  126. /**
  127.   * @}
  128.   */
  129.  
  130. /** @addtogroup UARTEx_Exported_Functions_Group3
  131.   * @{
  132.   */
  133.  
  134. /* Peripheral Control functions  **********************************************/
  135. #if defined(USART_CR1_UESM)
  136. HAL_StatusTypeDef HAL_UARTEx_StopModeWakeUpSourceConfig(UART_HandleTypeDef *huart, UART_WakeUpTypeDef WakeUpSelection);
  137. HAL_StatusTypeDef HAL_UARTEx_EnableStopMode(UART_HandleTypeDef *huart);
  138. HAL_StatusTypeDef HAL_UARTEx_DisableStopMode(UART_HandleTypeDef *huart);
  139.  
  140. #endif/* USART_CR1_UESM */
  141. HAL_StatusTypeDef HAL_MultiProcessorEx_AddressLength_Set(UART_HandleTypeDef *huart, uint32_t AddressLength);
  142.  
  143.  
  144. HAL_StatusTypeDef HAL_UARTEx_ReceiveToIdle(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint16_t *RxLen,
  145.                                            uint32_t Timeout);
  146. HAL_StatusTypeDef HAL_UARTEx_ReceiveToIdle_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size);
  147. HAL_StatusTypeDef HAL_UARTEx_ReceiveToIdle_DMA(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size);
  148.  
  149.  
  150. /**
  151.   * @}
  152.   */
  153.  
  154. /**
  155.   * @}
  156.   */
  157.  
  158. /* Private macros ------------------------------------------------------------*/
  159. /** @defgroup UARTEx_Private_Macros UARTEx Private Macros
  160.   * @{
  161.   */
  162.  
  163. /** @brief  Report the UART clock source.
  164.   * @param  __HANDLE__ specifies the UART Handle.
  165.   * @param  __CLOCKSOURCE__ output variable.
  166.   * @retval UART clocking source, written in __CLOCKSOURCE__.
  167.   */
  168.  
  169. #if defined(STM32F030x6) || defined(STM32F031x6) || defined(STM32F038xx)
  170. #define UART_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__)       \
  171.   do {                                                        \
  172.      switch(__HAL_RCC_GET_USART1_SOURCE())                    \
  173.      {                                                        \
  174.       case RCC_USART1CLKSOURCE_PCLK1:                         \
  175.         (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;           \
  176.         break;                                                \
  177.       case RCC_USART1CLKSOURCE_HSI:                           \
  178.         (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;             \
  179.         break;                                                \
  180.       case RCC_USART1CLKSOURCE_SYSCLK:                        \
  181.         (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK;          \
  182.         break;                                                \
  183.       case RCC_USART1CLKSOURCE_LSE:                           \
  184.         (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;             \
  185.         break;                                                \
  186.       default:                                                \
  187.         (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;       \
  188.         break;                                                \
  189.      }                                                        \
  190.   } while(0)
  191. #elif defined (STM32F030x8) || defined (STM32F070x6) || defined (STM32F042x6) || defined (STM32F048xx) || defined (STM32F051x8) || defined (STM32F058xx)
  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_PCLK1:                       \
  199.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;         \
  200.           break;                                              \
  201.         case RCC_USART1CLKSOURCE_HSI:                         \
  202.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \
  203.           break;                                              \
  204.         case RCC_USART1CLKSOURCE_SYSCLK:                      \
  205.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK;        \
  206.           break;                                              \
  207.         case RCC_USART1CLKSOURCE_LSE:                         \
  208.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \
  209.           break;                                              \
  210.         default:                                              \
  211.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \
  212.           break;                                              \
  213.        }                                                      \
  214.     }                                                         \
  215.     else if((__HANDLE__)->Instance == USART2)                 \
  216.     {                                                         \
  217.       (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;             \
  218.     }                                                         \
  219.     else                                                      \
  220.     {                                                         \
  221.       (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;         \
  222.     }                                                         \
  223.   } while(0)
  224. #elif defined(STM32F070xB)
  225. #define UART_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__) \
  226.   do {                                                        \
  227.     if((__HANDLE__)->Instance == USART1)                      \
  228.     {                                                         \
  229.        switch(__HAL_RCC_GET_USART1_SOURCE())                  \
  230.        {                                                      \
  231.         case RCC_USART1CLKSOURCE_PCLK1:                       \
  232.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;         \
  233.           break;                                              \
  234.         case RCC_USART1CLKSOURCE_HSI:                         \
  235.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \
  236.           break;                                              \
  237.         case RCC_USART1CLKSOURCE_SYSCLK:                      \
  238.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK;        \
  239.           break;                                              \
  240.         case RCC_USART1CLKSOURCE_LSE:                         \
  241.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \
  242.           break;                                              \
  243.         default:                                              \
  244.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \
  245.           break;                                              \
  246.        }                                                      \
  247.     }                                                         \
  248.     else if((__HANDLE__)->Instance == USART2)                 \
  249.     {                                                         \
  250.       (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;             \
  251.     }                                                         \
  252.     else if((__HANDLE__)->Instance == USART3)                 \
  253.     {                                                         \
  254.       (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;             \
  255.     }                                                         \
  256.     else if((__HANDLE__)->Instance == USART4)                 \
  257.     {                                                         \
  258.       (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;             \
  259.     }                                                         \
  260.     else                                                      \
  261.     {                                                         \
  262.       (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;         \
  263.     }                                                         \
  264.   } while(0)  
  265. #elif defined(STM32F071xB) || defined(STM32F072xB) || defined(STM32F078xx)
  266. #define UART_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__) \
  267.   do {                                                        \
  268.     if((__HANDLE__)->Instance == USART1)                      \
  269.     {                                                         \
  270.        switch(__HAL_RCC_GET_USART1_SOURCE())                  \
  271.        {                                                      \
  272.         case RCC_USART1CLKSOURCE_PCLK1:                       \
  273.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;         \
  274.           break;                                              \
  275.         case RCC_USART1CLKSOURCE_HSI:                         \
  276.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \
  277.           break;                                              \
  278.         case RCC_USART1CLKSOURCE_SYSCLK:                      \
  279.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK;        \
  280.           break;                                              \
  281.         case RCC_USART1CLKSOURCE_LSE:                         \
  282.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \
  283.           break;                                              \
  284.         default:                                              \
  285.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \
  286.           break;                                              \
  287.        }                                                      \
  288.     }                                                         \
  289.     else if((__HANDLE__)->Instance == USART2)                 \
  290.     {                                                         \
  291.        switch(__HAL_RCC_GET_USART2_SOURCE())                  \
  292.        {                                                      \
  293.         case RCC_USART2CLKSOURCE_PCLK1:                       \
  294.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;         \
  295.           break;                                              \
  296.         case RCC_USART2CLKSOURCE_HSI:                         \
  297.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \
  298.           break;                                              \
  299.         case RCC_USART2CLKSOURCE_SYSCLK:                      \
  300.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK;        \
  301.           break;                                              \
  302.         case RCC_USART2CLKSOURCE_LSE:                         \
  303.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \
  304.           break;                                              \
  305.         default:                                              \
  306.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \
  307.           break;                                              \
  308.        }                                                      \
  309.     }                                                         \
  310.     else if((__HANDLE__)->Instance == USART3)                 \
  311.     {                                                         \
  312.       (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;             \
  313.     }                                                         \
  314.     else if((__HANDLE__)->Instance == USART4)                 \
  315.     {                                                         \
  316.       (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;             \
  317.     }                                                         \
  318.     else                                                      \
  319.     {                                                         \
  320.       (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;         \
  321.     }                                                         \
  322.   } while(0)  
  323. #elif defined(STM32F091xC) || defined (STM32F098xx)
  324. #define UART_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__) \
  325.   do {                                                        \
  326.     if((__HANDLE__)->Instance == USART1)                      \
  327.     {                                                         \
  328.        switch(__HAL_RCC_GET_USART1_SOURCE())                  \
  329.        {                                                      \
  330.         case RCC_USART1CLKSOURCE_PCLK1:                       \
  331.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;         \
  332.           break;                                              \
  333.         case RCC_USART1CLKSOURCE_HSI:                         \
  334.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \
  335.           break;                                              \
  336.         case RCC_USART1CLKSOURCE_SYSCLK:                      \
  337.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK;        \
  338.           break;                                              \
  339.         case RCC_USART1CLKSOURCE_LSE:                         \
  340.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \
  341.           break;                                              \
  342.         default:                                              \
  343.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \
  344.           break;                                              \
  345.        }                                                      \
  346.     }                                                         \
  347.     else if((__HANDLE__)->Instance == USART2)                 \
  348.     {                                                         \
  349.        switch(__HAL_RCC_GET_USART2_SOURCE())                  \
  350.        {                                                      \
  351.         case RCC_USART2CLKSOURCE_PCLK1:                       \
  352.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;         \
  353.           break;                                              \
  354.         case RCC_USART2CLKSOURCE_HSI:                         \
  355.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \
  356.           break;                                              \
  357.         case RCC_USART2CLKSOURCE_SYSCLK:                      \
  358.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK;        \
  359.           break;                                              \
  360.         case RCC_USART2CLKSOURCE_LSE:                         \
  361.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \
  362.           break;                                              \
  363.         default:                                              \
  364.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \
  365.           break;                                              \
  366.        }                                                      \
  367.     }                                                         \
  368.     else if((__HANDLE__)->Instance == USART3)                 \
  369.     {                                                         \
  370.        switch(__HAL_RCC_GET_USART3_SOURCE())                  \
  371.        {                                                      \
  372.         case RCC_USART3CLKSOURCE_PCLK1:                       \
  373.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;         \
  374.           break;                                              \
  375.         case RCC_USART3CLKSOURCE_HSI:                         \
  376.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \
  377.           break;                                              \
  378.         case RCC_USART3CLKSOURCE_SYSCLK:                      \
  379.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK;        \
  380.           break;                                              \
  381.         case RCC_USART3CLKSOURCE_LSE:                         \
  382.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \
  383.           break;                                              \
  384.         default:                                              \
  385.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \
  386.           break;                                              \
  387.        }                                                      \
  388.     }                                                         \
  389.     else if((__HANDLE__)->Instance == USART4)                 \
  390.     {                                                         \
  391.       (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;             \
  392.     }                                                         \
  393.     else if((__HANDLE__)->Instance == USART5)                 \
  394.     {                                                         \
  395.       (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;             \
  396.     }                                                         \
  397.     else if((__HANDLE__)->Instance == USART6)                 \
  398.     {                                                         \
  399.       (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;             \
  400.     }                                                         \
  401.     else if((__HANDLE__)->Instance == USART7)                 \
  402.     {                                                         \
  403.       (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;             \
  404.     }                                                         \
  405.     else if((__HANDLE__)->Instance == USART8)                 \
  406.     {                                                         \
  407.       (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;             \
  408.     }                                                         \
  409.     else                                                      \
  410.     {                                                         \
  411.       (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;         \
  412.     }                                                         \
  413.   } while(0)
  414. #elif defined(STM32F030xC)
  415. #define UART_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__) \
  416.   do {                                                        \
  417.     if((__HANDLE__)->Instance == USART1)                      \
  418.     {                                                         \
  419.        switch(__HAL_RCC_GET_USART1_SOURCE())                  \
  420.        {                                                      \
  421.         case RCC_USART1CLKSOURCE_PCLK1:                       \
  422.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;         \
  423.           break;                                              \
  424.         case RCC_USART1CLKSOURCE_HSI:                         \
  425.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \
  426.           break;                                              \
  427.         case RCC_USART1CLKSOURCE_SYSCLK:                      \
  428.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK;        \
  429.           break;                                              \
  430.         case RCC_USART1CLKSOURCE_LSE:                         \
  431.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \
  432.           break;                                              \
  433.         default:                                              \
  434.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \
  435.           break;                                              \
  436.        }                                                      \
  437.     }                                                         \
  438.     else if((__HANDLE__)->Instance == USART2)                 \
  439.     {                                                         \
  440.       (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;             \
  441.     }                                                         \
  442.     else if((__HANDLE__)->Instance == USART3)                 \
  443.     {                                                         \
  444.       (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;             \
  445.     }                                                         \
  446.     else if((__HANDLE__)->Instance == USART4)                 \
  447.     {                                                         \
  448.       (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;             \
  449.     }                                                         \
  450.     else if((__HANDLE__)->Instance == USART5)                 \
  451.     {                                                         \
  452.       (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;             \
  453.     }                                                         \
  454.     else if((__HANDLE__)->Instance == USART6)                 \
  455.     {                                                         \
  456.       (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;             \
  457.     }                                                         \
  458.     else                                                      \
  459.     {                                                         \
  460.       (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;         \
  461.     }                                                         \
  462.   } while(0)
  463.  
  464. #endif /* defined(STM32F030x6) || defined(STM32F031x6) || defined(STM32F038xx) */
  465.  
  466. /** @brief  Report the UART mask to apply to retrieve the received data
  467.   *         according to the word length and to the parity bits activation.
  468.   * @note   If PCE = 1, the parity bit is not included in the data extracted
  469.   *         by the reception API().
  470.   *         This masking operation is not carried out in the case of
  471.   *         DMA transfers.
  472.   * @param  __HANDLE__ specifies the UART Handle.
  473.   * @retval None, the mask to apply to UART RDR register is stored in (__HANDLE__)->Mask field.
  474.   */
  475. #if defined (USART_CR1_M1)
  476. #define UART_MASK_COMPUTATION(__HANDLE__)                             \
  477.   do {                                                                \
  478.     if ((__HANDLE__)->Init.WordLength == UART_WORDLENGTH_9B)          \
  479.     {                                                                 \
  480.       if ((__HANDLE__)->Init.Parity == UART_PARITY_NONE)              \
  481.       {                                                               \
  482.         (__HANDLE__)->Mask = 0x01FFU ;                                \
  483.       }                                                               \
  484.       else                                                            \
  485.       {                                                               \
  486.         (__HANDLE__)->Mask = 0x00FFU ;                                \
  487.       }                                                               \
  488.     }                                                                 \
  489.     else if ((__HANDLE__)->Init.WordLength == UART_WORDLENGTH_8B)     \
  490.     {                                                                 \
  491.       if ((__HANDLE__)->Init.Parity == UART_PARITY_NONE)              \
  492.       {                                                               \
  493.         (__HANDLE__)->Mask = 0x00FFU ;                                \
  494.       }                                                               \
  495.       else                                                            \
  496.       {                                                               \
  497.         (__HANDLE__)->Mask = 0x007FU ;                                \
  498.       }                                                               \
  499.     }                                                                 \
  500.     else if ((__HANDLE__)->Init.WordLength == UART_WORDLENGTH_7B)     \
  501.     {                                                                 \
  502.       if ((__HANDLE__)->Init.Parity == UART_PARITY_NONE)              \
  503.       {                                                               \
  504.         (__HANDLE__)->Mask = 0x007FU ;                                \
  505.       }                                                               \
  506.       else                                                            \
  507.       {                                                               \
  508.         (__HANDLE__)->Mask = 0x003FU ;                                \
  509.       }                                                               \
  510.     }                                                                 \
  511.     else                                                              \
  512.     {                                                                 \
  513.       (__HANDLE__)->Mask = 0x0000U;                                   \
  514.     }                                                                 \
  515.   } while(0U)
  516.  
  517. #else
  518. #define UART_MASK_COMPUTATION(__HANDLE__)                             \
  519.   do {                                                                \
  520.     if ((__HANDLE__)->Init.WordLength == UART_WORDLENGTH_9B)          \
  521.     {                                                                 \
  522.       if ((__HANDLE__)->Init.Parity == UART_PARITY_NONE)              \
  523.       {                                                               \
  524.         (__HANDLE__)->Mask = 0x01FFU ;                                \
  525.       }                                                               \
  526.       else                                                            \
  527.       {                                                               \
  528.         (__HANDLE__)->Mask = 0x00FFU ;                                \
  529.       }                                                               \
  530.     }                                                                 \
  531.     else if ((__HANDLE__)->Init.WordLength == UART_WORDLENGTH_8B)     \
  532.     {                                                                 \
  533.       if ((__HANDLE__)->Init.Parity == UART_PARITY_NONE)              \
  534.       {                                                               \
  535.         (__HANDLE__)->Mask = 0x00FFU ;                                \
  536.       }                                                               \
  537.       else                                                            \
  538.       {                                                               \
  539.         (__HANDLE__)->Mask = 0x007FU ;                                \
  540.       }                                                               \
  541.     }                                                                 \
  542.     else                                                              \
  543.     {                                                                 \
  544.       (__HANDLE__)->Mask = 0x0000U;                                   \
  545.     }                                                                 \
  546.   } while(0U)
  547.  
  548. #endif /* USART_CR1_M1 */
  549.  
  550. /**
  551.   * @brief Ensure that UART frame length is valid.
  552.   * @param __LENGTH__ UART frame length.
  553.   * @retval SET (__LENGTH__ is valid) or RESET (__LENGTH__ is invalid)
  554.   */
  555. #if defined (USART_CR1_M1)
  556. #define IS_UART_WORD_LENGTH(__LENGTH__) (((__LENGTH__) == UART_WORDLENGTH_7B) || \
  557.                                          ((__LENGTH__) == UART_WORDLENGTH_8B) || \
  558.                                          ((__LENGTH__) == UART_WORDLENGTH_9B))
  559. #else
  560. #define IS_UART_WORD_LENGTH(__LENGTH__) (((__LENGTH__) == UART_WORDLENGTH_8B) || \
  561.                                          ((__LENGTH__) == UART_WORDLENGTH_9B))
  562. #endif /* USART_CR1_M1 */
  563.  
  564. /**
  565.   * @brief Ensure that UART wake-up address length is valid.
  566.   * @param __ADDRESS__ UART wake-up address length.
  567.   * @retval SET (__ADDRESS__ is valid) or RESET (__ADDRESS__ is invalid)
  568.   */
  569. #define IS_UART_ADDRESSLENGTH_DETECT(__ADDRESS__) (((__ADDRESS__) == UART_ADDRESS_DETECT_4B) || \
  570.                                                    ((__ADDRESS__) == UART_ADDRESS_DETECT_7B))
  571.  
  572. /**
  573.   * @}
  574.   */
  575.  
  576. /* Private functions ---------------------------------------------------------*/
  577.  
  578. /**
  579.   * @}
  580.   */
  581.  
  582. /**
  583.   * @}
  584.   */
  585.  
  586. #ifdef __cplusplus
  587. }
  588. #endif
  589.  
  590. #endif /* STM32F0xx_HAL_UART_EX_H */
  591.  
  592. /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
  593.