Subversion Repositories FuelGauge

Rev

Go to most recent revision | 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.  
  131. /** @addtogroup UARTEx_Exported_Functions_Group3
  132.   * @{
  133.   */
  134.  
  135. /* Peripheral Control functions  **********************************************/
  136. #if defined(USART_CR1_UESM)
  137. HAL_StatusTypeDef HAL_UARTEx_StopModeWakeUpSourceConfig(UART_HandleTypeDef *huart, UART_WakeUpTypeDef WakeUpSelection);
  138. HAL_StatusTypeDef HAL_UARTEx_EnableStopMode(UART_HandleTypeDef *huart);
  139. HAL_StatusTypeDef HAL_UARTEx_DisableStopMode(UART_HandleTypeDef *huart);
  140.  
  141. #endif/* USART_CR1_UESM */
  142. HAL_StatusTypeDef HAL_MultiProcessorEx_AddressLength_Set(UART_HandleTypeDef *huart, uint32_t AddressLength);
  143.  
  144.  
  145. /**
  146.   * @}
  147.   */
  148.  
  149. /**
  150.   * @}
  151.   */
  152.  
  153. /* Private macros ------------------------------------------------------------*/
  154. /** @defgroup UARTEx_Private_Macros UARTEx Private Macros
  155.   * @{
  156.   */
  157.  
  158. /** @brief  Report the UART clock source.
  159.   * @param  __HANDLE__ specifies the UART Handle.
  160.   * @param  __CLOCKSOURCE__ output variable.
  161.   * @retval UART clocking source, written in __CLOCKSOURCE__.
  162.   */
  163.  
  164. #if defined(STM32F030x6) || defined(STM32F031x6) || defined(STM32F038xx)
  165. #define UART_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__)       \
  166.   do {                                                        \
  167.      switch(__HAL_RCC_GET_USART1_SOURCE())                    \
  168.      {                                                        \
  169.       case RCC_USART1CLKSOURCE_PCLK1:                         \
  170.         (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;           \
  171.         break;                                                \
  172.       case RCC_USART1CLKSOURCE_HSI:                           \
  173.         (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;             \
  174.         break;                                                \
  175.       case RCC_USART1CLKSOURCE_SYSCLK:                        \
  176.         (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK;          \
  177.         break;                                                \
  178.       case RCC_USART1CLKSOURCE_LSE:                           \
  179.         (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;             \
  180.         break;                                                \
  181.       default:                                                \
  182.         (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;       \
  183.         break;                                                \
  184.      }                                                        \
  185.   } while(0)
  186. #elif defined (STM32F030x8) || defined (STM32F070x6) || defined (STM32F042x6) || defined (STM32F048xx) || defined (STM32F051x8) || defined (STM32F058xx)
  187. #define UART_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__) \
  188.   do {                                                        \
  189.     if((__HANDLE__)->Instance == USART1)                      \
  190.     {                                                         \
  191.        switch(__HAL_RCC_GET_USART1_SOURCE())                  \
  192.        {                                                      \
  193.         case RCC_USART1CLKSOURCE_PCLK1:                       \
  194.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;         \
  195.           break;                                              \
  196.         case RCC_USART1CLKSOURCE_HSI:                         \
  197.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \
  198.           break;                                              \
  199.         case RCC_USART1CLKSOURCE_SYSCLK:                      \
  200.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK;        \
  201.           break;                                              \
  202.         case RCC_USART1CLKSOURCE_LSE:                         \
  203.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \
  204.           break;                                              \
  205.         default:                                              \
  206.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \
  207.           break;                                              \
  208.        }                                                      \
  209.     }                                                         \
  210.     else if((__HANDLE__)->Instance == USART2)                 \
  211.     {                                                         \
  212.       (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;             \
  213.     }                                                         \
  214.     else                                                      \
  215.     {                                                         \
  216.       (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;         \
  217.     }                                                         \
  218.   } while(0)
  219. #elif defined(STM32F070xB)
  220. #define UART_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__) \
  221.   do {                                                        \
  222.     if((__HANDLE__)->Instance == USART1)                      \
  223.     {                                                         \
  224.        switch(__HAL_RCC_GET_USART1_SOURCE())                  \
  225.        {                                                      \
  226.         case RCC_USART1CLKSOURCE_PCLK1:                       \
  227.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;         \
  228.           break;                                              \
  229.         case RCC_USART1CLKSOURCE_HSI:                         \
  230.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \
  231.           break;                                              \
  232.         case RCC_USART1CLKSOURCE_SYSCLK:                      \
  233.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK;        \
  234.           break;                                              \
  235.         case RCC_USART1CLKSOURCE_LSE:                         \
  236.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \
  237.           break;                                              \
  238.         default:                                              \
  239.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \
  240.           break;                                              \
  241.        }                                                      \
  242.     }                                                         \
  243.     else if((__HANDLE__)->Instance == USART2)                 \
  244.     {                                                         \
  245.       (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;             \
  246.     }                                                         \
  247.     else if((__HANDLE__)->Instance == USART3)                 \
  248.     {                                                         \
  249.       (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;             \
  250.     }                                                         \
  251.     else if((__HANDLE__)->Instance == USART4)                 \
  252.     {                                                         \
  253.       (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;             \
  254.     }                                                         \
  255.     else                                                      \
  256.     {                                                         \
  257.       (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;         \
  258.     }                                                         \
  259.   } while(0)  
  260. #elif defined(STM32F071xB) || defined(STM32F072xB) || defined(STM32F078xx)
  261. #define UART_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__) \
  262.   do {                                                        \
  263.     if((__HANDLE__)->Instance == USART1)                      \
  264.     {                                                         \
  265.        switch(__HAL_RCC_GET_USART1_SOURCE())                  \
  266.        {                                                      \
  267.         case RCC_USART1CLKSOURCE_PCLK1:                       \
  268.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;         \
  269.           break;                                              \
  270.         case RCC_USART1CLKSOURCE_HSI:                         \
  271.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \
  272.           break;                                              \
  273.         case RCC_USART1CLKSOURCE_SYSCLK:                      \
  274.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK;        \
  275.           break;                                              \
  276.         case RCC_USART1CLKSOURCE_LSE:                         \
  277.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \
  278.           break;                                              \
  279.         default:                                              \
  280.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \
  281.           break;                                              \
  282.        }                                                      \
  283.     }                                                         \
  284.     else if((__HANDLE__)->Instance == USART2)                 \
  285.     {                                                         \
  286.        switch(__HAL_RCC_GET_USART2_SOURCE())                  \
  287.        {                                                      \
  288.         case RCC_USART2CLKSOURCE_PCLK1:                       \
  289.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;         \
  290.           break;                                              \
  291.         case RCC_USART2CLKSOURCE_HSI:                         \
  292.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \
  293.           break;                                              \
  294.         case RCC_USART2CLKSOURCE_SYSCLK:                      \
  295.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK;        \
  296.           break;                                              \
  297.         case RCC_USART2CLKSOURCE_LSE:                         \
  298.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \
  299.           break;                                              \
  300.         default:                                              \
  301.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \
  302.           break;                                              \
  303.        }                                                      \
  304.     }                                                         \
  305.     else if((__HANDLE__)->Instance == USART3)                 \
  306.     {                                                         \
  307.       (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;             \
  308.     }                                                         \
  309.     else if((__HANDLE__)->Instance == USART4)                 \
  310.     {                                                         \
  311.       (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;             \
  312.     }                                                         \
  313.     else                                                      \
  314.     {                                                         \
  315.       (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;         \
  316.     }                                                         \
  317.   } while(0)  
  318. #elif defined(STM32F091xC) || defined (STM32F098xx)
  319. #define UART_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__) \
  320.   do {                                                        \
  321.     if((__HANDLE__)->Instance == USART1)                      \
  322.     {                                                         \
  323.        switch(__HAL_RCC_GET_USART1_SOURCE())                  \
  324.        {                                                      \
  325.         case RCC_USART1CLKSOURCE_PCLK1:                       \
  326.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;         \
  327.           break;                                              \
  328.         case RCC_USART1CLKSOURCE_HSI:                         \
  329.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \
  330.           break;                                              \
  331.         case RCC_USART1CLKSOURCE_SYSCLK:                      \
  332.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK;        \
  333.           break;                                              \
  334.         case RCC_USART1CLKSOURCE_LSE:                         \
  335.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \
  336.           break;                                              \
  337.         default:                                              \
  338.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \
  339.           break;                                              \
  340.        }                                                      \
  341.     }                                                         \
  342.     else if((__HANDLE__)->Instance == USART2)                 \
  343.     {                                                         \
  344.        switch(__HAL_RCC_GET_USART2_SOURCE())                  \
  345.        {                                                      \
  346.         case RCC_USART2CLKSOURCE_PCLK1:                       \
  347.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;         \
  348.           break;                                              \
  349.         case RCC_USART2CLKSOURCE_HSI:                         \
  350.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \
  351.           break;                                              \
  352.         case RCC_USART2CLKSOURCE_SYSCLK:                      \
  353.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK;        \
  354.           break;                                              \
  355.         case RCC_USART2CLKSOURCE_LSE:                         \
  356.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \
  357.           break;                                              \
  358.         default:                                              \
  359.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \
  360.           break;                                              \
  361.        }                                                      \
  362.     }                                                         \
  363.     else if((__HANDLE__)->Instance == USART3)                 \
  364.     {                                                         \
  365.        switch(__HAL_RCC_GET_USART3_SOURCE())                  \
  366.        {                                                      \
  367.         case RCC_USART3CLKSOURCE_PCLK1:                       \
  368.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;         \
  369.           break;                                              \
  370.         case RCC_USART3CLKSOURCE_HSI:                         \
  371.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \
  372.           break;                                              \
  373.         case RCC_USART3CLKSOURCE_SYSCLK:                      \
  374.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK;        \
  375.           break;                                              \
  376.         case RCC_USART3CLKSOURCE_LSE:                         \
  377.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \
  378.           break;                                              \
  379.         default:                                              \
  380.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \
  381.           break;                                              \
  382.        }                                                      \
  383.     }                                                         \
  384.     else if((__HANDLE__)->Instance == USART4)                 \
  385.     {                                                         \
  386.       (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;             \
  387.     }                                                         \
  388.     else if((__HANDLE__)->Instance == USART5)                 \
  389.     {                                                         \
  390.       (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;             \
  391.     }                                                         \
  392.     else if((__HANDLE__)->Instance == USART6)                 \
  393.     {                                                         \
  394.       (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;             \
  395.     }                                                         \
  396.     else if((__HANDLE__)->Instance == USART7)                 \
  397.     {                                                         \
  398.       (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;             \
  399.     }                                                         \
  400.     else if((__HANDLE__)->Instance == USART8)                 \
  401.     {                                                         \
  402.       (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;             \
  403.     }                                                         \
  404.     else                                                      \
  405.     {                                                         \
  406.       (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;         \
  407.     }                                                         \
  408.   } while(0)
  409. #elif defined(STM32F030xC)
  410. #define UART_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__) \
  411.   do {                                                        \
  412.     if((__HANDLE__)->Instance == USART1)                      \
  413.     {                                                         \
  414.        switch(__HAL_RCC_GET_USART1_SOURCE())                  \
  415.        {                                                      \
  416.         case RCC_USART1CLKSOURCE_PCLK1:                       \
  417.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;         \
  418.           break;                                              \
  419.         case RCC_USART1CLKSOURCE_HSI:                         \
  420.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \
  421.           break;                                              \
  422.         case RCC_USART1CLKSOURCE_SYSCLK:                      \
  423.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK;        \
  424.           break;                                              \
  425.         case RCC_USART1CLKSOURCE_LSE:                         \
  426.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \
  427.           break;                                              \
  428.         default:                                              \
  429.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \
  430.           break;                                              \
  431.        }                                                      \
  432.     }                                                         \
  433.     else if((__HANDLE__)->Instance == USART2)                 \
  434.     {                                                         \
  435.       (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;             \
  436.     }                                                         \
  437.     else if((__HANDLE__)->Instance == USART3)                 \
  438.     {                                                         \
  439.       (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;             \
  440.     }                                                         \
  441.     else if((__HANDLE__)->Instance == USART4)                 \
  442.     {                                                         \
  443.       (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;             \
  444.     }                                                         \
  445.     else if((__HANDLE__)->Instance == USART5)                 \
  446.     {                                                         \
  447.       (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;             \
  448.     }                                                         \
  449.     else if((__HANDLE__)->Instance == USART6)                 \
  450.     {                                                         \
  451.       (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;             \
  452.     }                                                         \
  453.     else                                                      \
  454.     {                                                         \
  455.       (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;         \
  456.     }                                                         \
  457.   } while(0)
  458.  
  459. #endif /* defined(STM32F030x6) || defined(STM32F031x6) || defined(STM32F038xx) */
  460.  
  461. /** @brief  Report the UART mask to apply to retrieve the received data
  462.   *         according to the word length and to the parity bits activation.
  463.   * @note   If PCE = 1, the parity bit is not included in the data extracted
  464.   *         by the reception API().
  465.   *         This masking operation is not carried out in the case of
  466.   *         DMA transfers.
  467.   * @param  __HANDLE__ specifies the UART Handle.
  468.   * @retval None, the mask to apply to UART RDR register is stored in (__HANDLE__)->Mask field.
  469.   */
  470. #if defined (USART_CR1_M1)
  471. #define UART_MASK_COMPUTATION(__HANDLE__)                             \
  472.   do {                                                                \
  473.     if ((__HANDLE__)->Init.WordLength == UART_WORDLENGTH_9B)          \
  474.     {                                                                 \
  475.       if ((__HANDLE__)->Init.Parity == UART_PARITY_NONE)              \
  476.       {                                                               \
  477.         (__HANDLE__)->Mask = 0x01FFU ;                                \
  478.       }                                                               \
  479.       else                                                            \
  480.       {                                                               \
  481.         (__HANDLE__)->Mask = 0x00FFU ;                                \
  482.       }                                                               \
  483.     }                                                                 \
  484.     else if ((__HANDLE__)->Init.WordLength == UART_WORDLENGTH_8B)     \
  485.     {                                                                 \
  486.       if ((__HANDLE__)->Init.Parity == UART_PARITY_NONE)              \
  487.       {                                                               \
  488.         (__HANDLE__)->Mask = 0x00FFU ;                                \
  489.       }                                                               \
  490.       else                                                            \
  491.       {                                                               \
  492.         (__HANDLE__)->Mask = 0x007FU ;                                \
  493.       }                                                               \
  494.     }                                                                 \
  495.     else if ((__HANDLE__)->Init.WordLength == UART_WORDLENGTH_7B)     \
  496.     {                                                                 \
  497.       if ((__HANDLE__)->Init.Parity == UART_PARITY_NONE)              \
  498.       {                                                               \
  499.         (__HANDLE__)->Mask = 0x007FU ;                                \
  500.       }                                                               \
  501.       else                                                            \
  502.       {                                                               \
  503.         (__HANDLE__)->Mask = 0x003FU ;                                \
  504.       }                                                               \
  505.     }                                                                 \
  506.     else                                                              \
  507.     {                                                                 \
  508.       (__HANDLE__)->Mask = 0x0000U;                                   \
  509.     }                                                                 \
  510.   } while(0U)
  511.  
  512. #else
  513. #define UART_MASK_COMPUTATION(__HANDLE__)                             \
  514.   do {                                                                \
  515.     if ((__HANDLE__)->Init.WordLength == UART_WORDLENGTH_9B)          \
  516.     {                                                                 \
  517.       if ((__HANDLE__)->Init.Parity == UART_PARITY_NONE)              \
  518.       {                                                               \
  519.         (__HANDLE__)->Mask = 0x01FFU ;                                \
  520.       }                                                               \
  521.       else                                                            \
  522.       {                                                               \
  523.         (__HANDLE__)->Mask = 0x00FFU ;                                \
  524.       }                                                               \
  525.     }                                                                 \
  526.     else if ((__HANDLE__)->Init.WordLength == UART_WORDLENGTH_8B)     \
  527.     {                                                                 \
  528.       if ((__HANDLE__)->Init.Parity == UART_PARITY_NONE)              \
  529.       {                                                               \
  530.         (__HANDLE__)->Mask = 0x00FFU ;                                \
  531.       }                                                               \
  532.       else                                                            \
  533.       {                                                               \
  534.         (__HANDLE__)->Mask = 0x007FU ;                                \
  535.       }                                                               \
  536.     }                                                                 \
  537.     else                                                              \
  538.     {                                                                 \
  539.       (__HANDLE__)->Mask = 0x0000U;                                   \
  540.     }                                                                 \
  541.   } while(0U)
  542.  
  543. #endif /* USART_CR1_M1 */
  544.  
  545. /**
  546.   * @brief Ensure that UART frame length is valid.
  547.   * @param __LENGTH__ UART frame length.
  548.   * @retval SET (__LENGTH__ is valid) or RESET (__LENGTH__ is invalid)
  549.   */
  550. #if defined (USART_CR1_M1)
  551. #define IS_UART_WORD_LENGTH(__LENGTH__) (((__LENGTH__) == UART_WORDLENGTH_7B) || \
  552.                                          ((__LENGTH__) == UART_WORDLENGTH_8B) || \
  553.                                          ((__LENGTH__) == UART_WORDLENGTH_9B))
  554. #else
  555. #define IS_UART_WORD_LENGTH(__LENGTH__) (((__LENGTH__) == UART_WORDLENGTH_8B) || \
  556.                                          ((__LENGTH__) == UART_WORDLENGTH_9B))
  557. #endif /* USART_CR1_M1 */
  558.  
  559. /**
  560.   * @brief Ensure that UART wake-up address length is valid.
  561.   * @param __ADDRESS__ UART wake-up address length.
  562.   * @retval SET (__ADDRESS__ is valid) or RESET (__ADDRESS__ is invalid)
  563.   */
  564. #define IS_UART_ADDRESSLENGTH_DETECT(__ADDRESS__) (((__ADDRESS__) == UART_ADDRESS_DETECT_4B) || \
  565.                                                    ((__ADDRESS__) == UART_ADDRESS_DETECT_7B))
  566.  
  567. /**
  568.   * @}
  569.   */
  570.  
  571. /* Private functions ---------------------------------------------------------*/
  572.  
  573. /**
  574.   * @}
  575.   */
  576.  
  577. /**
  578.   * @}
  579.   */
  580.  
  581. #ifdef __cplusplus
  582. }
  583. #endif
  584.  
  585. #endif /* STM32F0xx_HAL_UART_EX_H */
  586.  
  587. /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
  588.