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.
40 Commits
1 Branch
14 MiB
 
 
 
Tree: 33ac8224e6
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '33ac8224e6'
${ noResults }
stm32lib/STM32L0xx_HAL_Driver/Inc/stm32l0xx_hal_uart_ex.h

447 lines
22 KiB
Raw Blame History 

  1. /**

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

  3.   * @file    stm32l0xx_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 __STM32L0xx_HAL_UART_EX_H

  22. #define __STM32L0xx_HAL_UART_EX_H

  23. 

  24. #ifdef __cplusplus

  25. extern "C" {

  26. #endif

  27. 

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

  29. #include "stm32l0xx_hal_def.h"

  30. 

  31. /** @addtogroup STM32L0xx_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. 

  89. /**

  90.   * @}

  91.   */

  92. 

  93. /* Exported macros -----------------------------------------------------------*/

  94. /* Exported functions --------------------------------------------------------*/

  95. /** @addtogroup UARTEx_Exported_Functions

  96.   * @{

  97.   */

  98. 

  99. /** @addtogroup UARTEx_Exported_Functions_Group1

  100.   * @{

  101.   */

  102. 

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

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

  105. 

  106. /**

  107.   * @}

  108.   */

  109. 

  110. /** @addtogroup UARTEx_Exported_Functions_Group2

  111.   * @{

  112.   */

  113. 

  114. void HAL_UARTEx_WakeupCallback(UART_HandleTypeDef *huart);

  115. 

  116. 

  117. /**

  118.   * @}

  119.   */

  120. 

  121. /** @addtogroup UARTEx_Exported_Functions_Group3

  122.   * @{

  123.   */

  124. 

  125. /* Peripheral Control functions  **********************************************/

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

  127. HAL_StatusTypeDef HAL_UARTEx_EnableStopMode(UART_HandleTypeDef *huart);

  128. HAL_StatusTypeDef HAL_UARTEx_DisableStopMode(UART_HandleTypeDef *huart);

  129. HAL_StatusTypeDef HAL_UARTEx_EnableClockStopMode(UART_HandleTypeDef *huart);

  130. HAL_StatusTypeDef HAL_UARTEx_DisableClockStopMode(UART_HandleTypeDef *huart);

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

  132. 

  133. /**

  134.   * @}

  135.   */

  136. 

  137. /**

  138.   * @}

  139.   */

  140. 

  141. /* Private macros ------------------------------------------------------------*/

  142. /** @defgroup UARTEx_Private_Macros UARTEx Private Macros

  143.   * @{

  144.   */

  145. 

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

  147.   * @param  __HANDLE__ specifies the UART Handle.

  148.   * @param  __CLOCKSOURCE__ output variable.

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

  150.   */

  151. #if defined (STM32L031xx) || defined (STM32L041xx) || defined (STM32L011xx) || defined (STM32L021xx) || defined (STM32L010xB) || defined (STM32L010x8) || defined (STM32L010x6) || defined (STM32L010x4)

  152. #define UART_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__)       \

  153.   do {                                                        \

  154.     if((__HANDLE__)->Instance == USART2)                      \

  155.     {                                                         \

  156.        switch(__HAL_RCC_GET_USART2_SOURCE())                  \

  157.        {                                                      \

  158.         case RCC_USART2CLKSOURCE_PCLK1:                       \

  159.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;         \

  160.           break;                                              \

  161.         case RCC_USART2CLKSOURCE_HSI:                         \

  162.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \

  163.           break;                                              \

  164.         case RCC_USART2CLKSOURCE_SYSCLK:                      \

  165.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK;        \

  166.           break;                                              \

  167.         case RCC_USART2CLKSOURCE_LSE:                         \

  168.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \

  169.           break;                                              \

  170.         default:                                              \

  171.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \

  172.           break;                                              \

  173.        }                                                      \

  174.     }                                                         \

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

  176.     {                                                         \

  177.        switch(__HAL_RCC_GET_LPUART1_SOURCE())                 \

  178.        {                                                      \

  179.         case RCC_LPUART1CLKSOURCE_PCLK1:                      \

  180.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;         \

  181.           break;                                              \

  182.         case RCC_LPUART1CLKSOURCE_HSI:                        \

  183.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \

  184.           break;                                              \

  185.         case RCC_LPUART1CLKSOURCE_SYSCLK:                     \

  186.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK;        \

  187.           break;                                              \

  188.         case RCC_LPUART1CLKSOURCE_LSE:                        \

  189.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \

  190.           break;                                              \

  191.         default:                                              \

  192.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \

  193.           break;                                              \

  194.        }                                                      \

  195.     }                                                         \

  196.     else                                                      \

  197.     {                                                         \

  198.       (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;         \

  199.     }                                                         \

  200.   } while(0)

  201. 

  202. #elif defined (STM32L051xx) || defined (STM32L052xx) || defined (STM32L053xx) || defined (STM32L061xx)  || defined (STM32L062xx) || defined (STM32L063xx)

  203. 

  204. #define UART_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__)       \

  205.   do {                                                        \

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

  207.     {                                                         \

  208.        switch(__HAL_RCC_GET_USART1_SOURCE())                  \

  209.        {                                                      \

  210.         case RCC_USART1CLKSOURCE_PCLK2:                       \

  211.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK2;         \

  212.           break;                                              \

  213.         case RCC_USART1CLKSOURCE_HSI:                         \

  214.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \

  215.           break;                                              \

  216.         case RCC_USART1CLKSOURCE_SYSCLK:                      \

  217.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK;        \

  218.           break;                                              \

  219.         case RCC_USART1CLKSOURCE_LSE:                         \

  220.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \

  221.           break;                                              \

  222.         default:                                              \

  223.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \

  224.           break;                                              \

  225.        }                                                      \

  226.     }                                                         \

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

  228.     {                                                         \

  229.        switch(__HAL_RCC_GET_USART2_SOURCE())                  \

  230.        {                                                      \

  231.         case RCC_USART2CLKSOURCE_PCLK1:                       \

  232.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;         \

  233.           break;                                              \

  234.         case RCC_USART2CLKSOURCE_HSI:                         \

  235.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \

  236.           break;                                              \

  237.         case RCC_USART2CLKSOURCE_SYSCLK:                      \

  238.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK;        \

  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 == LPUART1)                \

  249.     {                                                         \

  250.        switch(__HAL_RCC_GET_LPUART1_SOURCE())                 \

  251.        {                                                      \

  252.         case RCC_LPUART1CLKSOURCE_PCLK1:                      \

  253.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;         \

  254.           break;                                              \

  255.         case RCC_LPUART1CLKSOURCE_HSI:                        \

  256.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \

  257.           break;                                              \

  258.         case RCC_LPUART1CLKSOURCE_SYSCLK:                     \

  259.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK;        \

  260.           break;                                              \

  261.         case RCC_LPUART1CLKSOURCE_LSE:                        \

  262.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \

  263.           break;                                              \

  264.         default:                                              \

  265.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \

  266.           break;                                              \

  267.        }                                                      \

  268.     }                                                         \

  269.     else                                                      \

  270.     {                                                         \

  271.       (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;         \

  272.     }                                                         \

  273.   } while(0)

  274. 

  275. #else

  276. 

  277. #define UART_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__)       \

  278.   do {                                                        \

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

  280.     {                                                         \

  281.        switch(__HAL_RCC_GET_USART1_SOURCE())                  \

  282.        {                                                      \

  283.         case RCC_USART1CLKSOURCE_PCLK2:                       \

  284.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK2;         \

  285.           break;                                              \

  286.         case RCC_USART1CLKSOURCE_HSI:                         \

  287.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \

  288.           break;                                              \

  289.         case RCC_USART1CLKSOURCE_SYSCLK:                      \

  290.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK;        \

  291.           break;                                              \

  292.         case RCC_USART1CLKSOURCE_LSE:                         \

  293.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \

  294.           break;                                              \

  295.         default:                                              \

  296.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \

  297.           break;                                              \

  298.        }                                                      \

  299.     }                                                         \

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

  301.     {                                                         \

  302.        switch(__HAL_RCC_GET_USART2_SOURCE())                  \

  303.        {                                                      \

  304.         case RCC_USART2CLKSOURCE_PCLK1:                       \

  305.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;         \

  306.           break;                                              \

  307.         case RCC_USART2CLKSOURCE_HSI:                         \

  308.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \

  309.           break;                                              \

  310.         case RCC_USART2CLKSOURCE_SYSCLK:                      \

  311.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK;        \

  312.           break;                                              \

  313.         case RCC_USART2CLKSOURCE_LSE:                         \

  314.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \

  315.           break;                                              \

  316.         default:                                              \

  317.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \

  318.           break;                                              \

  319.        }                                                      \

  320.     }                                                         \

  321.     else if((__HANDLE__)->Instance == USART4)                 \

  322.     {                                                         \

  323.       (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;             \

  324.     }                                                         \

  325.     else if((__HANDLE__)->Instance == USART5)                 \

  326.     {                                                         \

  327.       (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;             \

  328.     }                                                         \

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

  330.     {                                                         \

  331.        switch(__HAL_RCC_GET_LPUART1_SOURCE())                 \

  332.        {                                                      \

  333.         case RCC_LPUART1CLKSOURCE_PCLK1:                      \

  334.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;         \

  335.           break;                                              \

  336.         case RCC_LPUART1CLKSOURCE_HSI:                        \

  337.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \

  338.           break;                                              \

  339.         case RCC_LPUART1CLKSOURCE_SYSCLK:                     \

  340.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK;        \

  341.           break;                                              \

  342.         case RCC_LPUART1CLKSOURCE_LSE:                        \

  343.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \

  344.           break;                                              \

  345.         default:                                              \

  346.           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \

  347.           break;                                              \

  348.        }                                                      \

  349.     }                                                         \

  350.     else                                                      \

  351.     {                                                         \

  352.       (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;         \

  353.     }                                                         \

  354.   } while(0)

  355. #endif /* (STM32L031xx) || (STM32L041xx) || (STM32L011xx) || (STM32L021xx) || (STM32L010xB) || (STM32L010x8) || (STM32L010x6) || (STM32L010x4)*/

  356. 

  357. 

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

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

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

  361.   *         by the reception API().

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

  363.   *         DMA transfers.

  364.   * @param  __HANDLE__ specifies the UART Handle.

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

  366.   */

  367. #define UART_MASK_COMPUTATION(__HANDLE__)                             \

  368.   do {                                                                \

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

  370.   {                                                                   \

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

  372.      {                                                                \

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

  374.      }                                                                \

  375.      else                                                             \

  376.      {                                                                \

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

  378.      }                                                                \

  379.   }                                                                   \

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

  381.   {                                                                   \

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

  383.      {                                                                \

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

  385.      }                                                                \

  386.      else                                                             \

  387.      {                                                                \

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

  389.      }                                                                \

  390.   }                                                                   \

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

  392.   {                                                                   \

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

  394.      {                                                                \

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

  396.      }                                                                \

  397.      else                                                             \

  398.      {                                                                \

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

  400.      }                                                                \

  401.   }                                                                   \

  402.   else                                                                \

  403.   {                                                                   \

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

  405.   }                                                                   \

  406. } while(0U)

  407. 

  408. /**

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

  410.   * @param __LENGTH__ UART frame length.

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

  412.   */

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

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

  415.                                          ((__LENGTH__) == UART_WORDLENGTH_9B))

  416. 

  417. /**

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

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

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

  421.   */

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

  423.                                                    ((__ADDRESS__) == UART_ADDRESS_DETECT_7B))

  424. 

  425. 

  426. /**

  427.   * @}

  428.   */

  429. 

  430. /* Private functions ---------------------------------------------------------*/

  431. 

  432. /**

  433.   * @}

  434.   */

  435. 

  436. /**

  437.   * @}

  438.   */

  439. 

  440. #ifdef __cplusplus

  441. }

  442. #endif

  443. 

  444. #endif /* __STM32L0xx_HAL_UART_EX_H */

  445. 

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