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.
 
 
 

865 lines
47 KiB

  1. /**
  2. ******************************************************************************
  3. * @file stm32h7xx_hal_uart_ex.h
  4. * @author MCD Application Team
  5. * @brief Header file of UART HAL Extended module.
  6. ******************************************************************************
  7. * @attention
  8. *
  9. * <h2><center>&copy; Copyright (c) 2017 STMicroelectronics.
  10. * All rights reserved.</center></h2>
  11. *
  12. * This software component is licensed by ST under BSD 3-Clause license,
  13. * the "License"; You may not use this file except in compliance with the
  14. * License. You may obtain a copy of the License at:
  15. * opensource.org/licenses/BSD-3-Clause
  16. *
  17. ******************************************************************************
  18. */
  19. /* Define to prevent recursive inclusion -------------------------------------*/
  20. #ifndef STM32H7xx_HAL_UART_EX_H
  21. #define STM32H7xx_HAL_UART_EX_H
  22. #ifdef __cplusplus
  23. extern "C" {
  24. #endif
  25. /* Includes ------------------------------------------------------------------*/
  26. #include "stm32h7xx_hal_def.h"
  27. /** @addtogroup STM32H7xx_HAL_Driver
  28. * @{
  29. */
  30. /** @addtogroup UARTEx
  31. * @{
  32. */
  33. /* Exported types ------------------------------------------------------------*/
  34. /** @defgroup UARTEx_Exported_Types UARTEx Exported Types
  35. * @{
  36. */
  37. /**
  38. * @brief UART wake up from stop mode parameters
  39. */
  40. typedef struct
  41. {
  42. uint32_t WakeUpEvent; /*!< Specifies which event will activate the Wakeup from Stop mode flag (WUF).
  43. This parameter can be a value of @ref UART_WakeUp_from_Stop_Selection.
  44. If set to UART_WAKEUP_ON_ADDRESS, the two other fields below must
  45. be filled up. */
  46. uint16_t AddressLength; /*!< Specifies whether the address is 4 or 7-bit long.
  47. This parameter can be a value of @ref UARTEx_WakeUp_Address_Length. */
  48. uint8_t Address; /*!< UART/USART node address (7-bit long max). */
  49. } UART_WakeUpTypeDef;
  50. /**
  51. * @}
  52. */
  53. /* Exported constants --------------------------------------------------------*/
  54. /** @defgroup UARTEx_Exported_Constants UARTEx Exported Constants
  55. * @{
  56. */
  57. /** @defgroup UARTEx_Word_Length UARTEx Word Length
  58. * @{
  59. */
  60. #define UART_WORDLENGTH_7B USART_CR1_M1 /*!< 7-bit long UART frame */
  61. #define UART_WORDLENGTH_8B 0x00000000U /*!< 8-bit long UART frame */
  62. #define UART_WORDLENGTH_9B USART_CR1_M0 /*!< 9-bit long UART frame */
  63. /**
  64. * @}
  65. */
  66. /** @defgroup UARTEx_WakeUp_Address_Length UARTEx WakeUp Address Length
  67. * @{
  68. */
  69. #define UART_ADDRESS_DETECT_4B 0x00000000U /*!< 4-bit long wake-up address */
  70. #define UART_ADDRESS_DETECT_7B USART_CR2_ADDM7 /*!< 7-bit long wake-up address */
  71. /**
  72. * @}
  73. */
  74. /** @defgroup UARTEx_FIFO_mode UARTEx FIFO mode
  75. * @brief UART FIFO mode
  76. * @{
  77. */
  78. #define UART_FIFOMODE_DISABLE 0x00000000U /*!< FIFO mode disable */
  79. #define UART_FIFOMODE_ENABLE USART_CR1_FIFOEN /*!< FIFO mode enable */
  80. /**
  81. * @}
  82. */
  83. /** @defgroup UARTEx_TXFIFO_threshold_level UARTEx TXFIFO threshold level
  84. * @brief UART TXFIFO threshold level
  85. * @{
  86. */
  87. #define UART_TXFIFO_THRESHOLD_1_8 0x00000000U /*!< TXFIFO reaches 1/8 of its depth */
  88. #define UART_TXFIFO_THRESHOLD_1_4 USART_CR3_TXFTCFG_0 /*!< TXFIFO reaches 1/4 of its depth */
  89. #define UART_TXFIFO_THRESHOLD_1_2 USART_CR3_TXFTCFG_1 /*!< TXFIFO reaches 1/2 of its depth */
  90. #define UART_TXFIFO_THRESHOLD_3_4 (USART_CR3_TXFTCFG_0|USART_CR3_TXFTCFG_1) /*!< TXFIFO reaches 3/4 of its depth */
  91. #define UART_TXFIFO_THRESHOLD_7_8 USART_CR3_TXFTCFG_2 /*!< TXFIFO reaches 7/8 of its depth */
  92. #define UART_TXFIFO_THRESHOLD_8_8 (USART_CR3_TXFTCFG_2|USART_CR3_TXFTCFG_0) /*!< TXFIFO becomes empty */
  93. /**
  94. * @}
  95. */
  96. /** @defgroup UARTEx_RXFIFO_threshold_level UARTEx RXFIFO threshold level
  97. * @brief UART RXFIFO threshold level
  98. * @{
  99. */
  100. #define UART_RXFIFO_THRESHOLD_1_8 0x00000000U /*!< RXFIFO FIFO reaches 1/8 of its depth */
  101. #define UART_RXFIFO_THRESHOLD_1_4 USART_CR3_RXFTCFG_0 /*!< RXFIFO FIFO reaches 1/4 of its depth */
  102. #define UART_RXFIFO_THRESHOLD_1_2 USART_CR3_RXFTCFG_1 /*!< RXFIFO FIFO reaches 1/2 of its depth */
  103. #define UART_RXFIFO_THRESHOLD_3_4 (USART_CR3_RXFTCFG_0|USART_CR3_RXFTCFG_1) /*!< RXFIFO FIFO reaches 3/4 of its depth */
  104. #define UART_RXFIFO_THRESHOLD_7_8 USART_CR3_RXFTCFG_2 /*!< RXFIFO FIFO reaches 7/8 of its depth */
  105. #define UART_RXFIFO_THRESHOLD_8_8 (USART_CR3_RXFTCFG_2|USART_CR3_RXFTCFG_0) /*!< RXFIFO FIFO becomes full */
  106. /**
  107. * @}
  108. */
  109. /**
  110. * @}
  111. */
  112. /* Exported macros -----------------------------------------------------------*/
  113. /* Exported functions --------------------------------------------------------*/
  114. /** @addtogroup UARTEx_Exported_Functions
  115. * @{
  116. */
  117. /** @addtogroup UARTEx_Exported_Functions_Group1
  118. * @{
  119. */
  120. /* Initialization and de-initialization functions ****************************/
  121. HAL_StatusTypeDef HAL_RS485Ex_Init(UART_HandleTypeDef *huart, uint32_t Polarity, uint32_t AssertionTime,
  122. uint32_t DeassertionTime);
  123. /**
  124. * @}
  125. */
  126. /** @addtogroup UARTEx_Exported_Functions_Group2
  127. * @{
  128. */
  129. void HAL_UARTEx_WakeupCallback(UART_HandleTypeDef *huart);
  130. void HAL_UARTEx_RxFifoFullCallback(UART_HandleTypeDef *huart);
  131. void HAL_UARTEx_TxFifoEmptyCallback(UART_HandleTypeDef *huart);
  132. /**
  133. * @}
  134. */
  135. /** @addtogroup UARTEx_Exported_Functions_Group3
  136. * @{
  137. */
  138. /* Peripheral Control functions **********************************************/
  139. HAL_StatusTypeDef HAL_UARTEx_StopModeWakeUpSourceConfig(UART_HandleTypeDef *huart, UART_WakeUpTypeDef WakeUpSelection);
  140. HAL_StatusTypeDef HAL_UARTEx_EnableStopMode(UART_HandleTypeDef *huart);
  141. HAL_StatusTypeDef HAL_UARTEx_DisableStopMode(UART_HandleTypeDef *huart);
  142. HAL_StatusTypeDef HAL_MultiProcessorEx_AddressLength_Set(UART_HandleTypeDef *huart, uint32_t AddressLength);
  143. HAL_StatusTypeDef HAL_UARTEx_EnableFifoMode(UART_HandleTypeDef *huart);
  144. HAL_StatusTypeDef HAL_UARTEx_DisableFifoMode(UART_HandleTypeDef *huart);
  145. HAL_StatusTypeDef HAL_UARTEx_SetTxFifoThreshold(UART_HandleTypeDef *huart, uint32_t Threshold);
  146. HAL_StatusTypeDef HAL_UARTEx_SetRxFifoThreshold(UART_HandleTypeDef *huart, uint32_t Threshold);
  147. /**
  148. * @}
  149. */
  150. /**
  151. * @}
  152. */
  153. /* Private macros ------------------------------------------------------------*/
  154. /** @defgroup UARTEx_Private_Macros UARTEx Private Macros
  155. * @{
  156. */
  157. /** @brief Report the UART clock source.
  158. * @param __HANDLE__ specifies the UART Handle.
  159. * @param __CLOCKSOURCE__ output variable.
  160. * @retval UART clocking source, written in __CLOCKSOURCE__.
  161. */
  162. #if defined(UART9) && defined(USART10)
  163. #define UART_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__) \
  164. do { \
  165. if((__HANDLE__)->Instance == USART1) \
  166. { \
  167. switch(__HAL_RCC_GET_USART1_SOURCE()) \
  168. { \
  169. case RCC_USART1CLKSOURCE_D2PCLK2: \
  170. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D2PCLK2; \
  171. break; \
  172. case RCC_USART1CLKSOURCE_PLL2: \
  173. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2; \
  174. break; \
  175. case RCC_USART1CLKSOURCE_PLL3: \
  176. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3; \
  177. break; \
  178. case RCC_USART1CLKSOURCE_HSI: \
  179. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
  180. break; \
  181. case RCC_USART1CLKSOURCE_CSI: \
  182. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI; \
  183. break; \
  184. case RCC_USART1CLKSOURCE_LSE: \
  185. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
  186. break; \
  187. default: \
  188. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
  189. break; \
  190. } \
  191. } \
  192. else if((__HANDLE__)->Instance == USART2) \
  193. { \
  194. switch(__HAL_RCC_GET_USART2_SOURCE()) \
  195. { \
  196. case RCC_USART2CLKSOURCE_D2PCLK1: \
  197. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D2PCLK1; \
  198. break; \
  199. case RCC_USART2CLKSOURCE_PLL2: \
  200. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2; \
  201. break; \
  202. case RCC_USART2CLKSOURCE_PLL3: \
  203. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3; \
  204. break; \
  205. case RCC_USART2CLKSOURCE_HSI: \
  206. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
  207. break; \
  208. case RCC_USART2CLKSOURCE_CSI: \
  209. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI; \
  210. break; \
  211. case RCC_USART2CLKSOURCE_LSE: \
  212. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
  213. break; \
  214. default: \
  215. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
  216. break; \
  217. } \
  218. } \
  219. else if((__HANDLE__)->Instance == USART3) \
  220. { \
  221. switch(__HAL_RCC_GET_USART3_SOURCE()) \
  222. { \
  223. case RCC_USART3CLKSOURCE_D2PCLK1: \
  224. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D2PCLK1; \
  225. break; \
  226. case RCC_USART3CLKSOURCE_PLL2: \
  227. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2; \
  228. break; \
  229. case RCC_USART3CLKSOURCE_PLL3: \
  230. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3; \
  231. break; \
  232. case RCC_USART3CLKSOURCE_HSI: \
  233. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
  234. break; \
  235. case RCC_USART3CLKSOURCE_CSI: \
  236. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI; \
  237. break; \
  238. case RCC_USART3CLKSOURCE_LSE: \
  239. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
  240. break; \
  241. default: \
  242. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
  243. break; \
  244. } \
  245. } \
  246. else if((__HANDLE__)->Instance == UART4) \
  247. { \
  248. switch(__HAL_RCC_GET_UART4_SOURCE()) \
  249. { \
  250. case RCC_UART4CLKSOURCE_D2PCLK1: \
  251. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D2PCLK1; \
  252. break; \
  253. case RCC_UART4CLKSOURCE_PLL2: \
  254. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2; \
  255. break; \
  256. case RCC_UART4CLKSOURCE_PLL3: \
  257. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3; \
  258. break; \
  259. case RCC_UART4CLKSOURCE_HSI: \
  260. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
  261. break; \
  262. case RCC_UART4CLKSOURCE_CSI: \
  263. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI; \
  264. break; \
  265. case RCC_UART4CLKSOURCE_LSE: \
  266. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
  267. break; \
  268. default: \
  269. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
  270. break; \
  271. } \
  272. } \
  273. else if ((__HANDLE__)->Instance == UART5) \
  274. { \
  275. switch(__HAL_RCC_GET_UART5_SOURCE()) \
  276. { \
  277. case RCC_UART5CLKSOURCE_D2PCLK1: \
  278. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D2PCLK1; \
  279. break; \
  280. case RCC_UART5CLKSOURCE_PLL2: \
  281. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2; \
  282. break; \
  283. case RCC_UART5CLKSOURCE_PLL3: \
  284. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3; \
  285. break; \
  286. case RCC_UART5CLKSOURCE_HSI: \
  287. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
  288. break; \
  289. case RCC_UART5CLKSOURCE_CSI: \
  290. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI; \
  291. break; \
  292. case RCC_UART5CLKSOURCE_LSE: \
  293. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
  294. break; \
  295. default: \
  296. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
  297. break; \
  298. } \
  299. } \
  300. else if((__HANDLE__)->Instance == USART6) \
  301. { \
  302. switch(__HAL_RCC_GET_USART6_SOURCE()) \
  303. { \
  304. case RCC_USART6CLKSOURCE_D2PCLK2: \
  305. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D2PCLK2; \
  306. break; \
  307. case RCC_USART6CLKSOURCE_PLL2: \
  308. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2; \
  309. break; \
  310. case RCC_USART6CLKSOURCE_PLL3: \
  311. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3; \
  312. break; \
  313. case RCC_USART6CLKSOURCE_HSI: \
  314. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
  315. break; \
  316. case RCC_USART6CLKSOURCE_CSI: \
  317. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI; \
  318. break; \
  319. case RCC_USART6CLKSOURCE_LSE: \
  320. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
  321. break; \
  322. default: \
  323. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
  324. break; \
  325. } \
  326. } \
  327. else if((__HANDLE__)->Instance == UART7) \
  328. { \
  329. switch(__HAL_RCC_GET_UART7_SOURCE()) \
  330. { \
  331. case RCC_UART7CLKSOURCE_D2PCLK1: \
  332. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D2PCLK1; \
  333. break; \
  334. case RCC_UART7CLKSOURCE_PLL2: \
  335. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2; \
  336. break; \
  337. case RCC_UART7CLKSOURCE_PLL3: \
  338. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3; \
  339. break; \
  340. case RCC_UART7CLKSOURCE_HSI: \
  341. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
  342. break; \
  343. case RCC_UART7CLKSOURCE_CSI: \
  344. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI; \
  345. break; \
  346. case RCC_UART7CLKSOURCE_LSE: \
  347. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
  348. break; \
  349. default: \
  350. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
  351. break; \
  352. } \
  353. } \
  354. else if((__HANDLE__)->Instance == UART8) \
  355. { \
  356. switch(__HAL_RCC_GET_UART8_SOURCE()) \
  357. { \
  358. case RCC_UART8CLKSOURCE_D2PCLK1: \
  359. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D2PCLK1; \
  360. break; \
  361. case RCC_UART8CLKSOURCE_PLL2: \
  362. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2; \
  363. break; \
  364. case RCC_UART8CLKSOURCE_PLL3: \
  365. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3; \
  366. break; \
  367. case RCC_UART8CLKSOURCE_HSI: \
  368. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
  369. break; \
  370. case RCC_UART8CLKSOURCE_CSI: \
  371. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI; \
  372. break; \
  373. case RCC_UART8CLKSOURCE_LSE: \
  374. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
  375. break; \
  376. default: \
  377. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
  378. break; \
  379. } \
  380. } \
  381. else if((__HANDLE__)->Instance == UART9) \
  382. { \
  383. switch(__HAL_RCC_GET_UART9_SOURCE()) \
  384. { \
  385. case RCC_UART9CLKSOURCE_D2PCLK2: \
  386. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D2PCLK2; \
  387. break; \
  388. case RCC_UART9CLKSOURCE_PLL2: \
  389. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2; \
  390. break; \
  391. case RCC_UART9CLKSOURCE_PLL3: \
  392. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3; \
  393. break; \
  394. case RCC_UART9CLKSOURCE_HSI: \
  395. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
  396. break; \
  397. case RCC_UART9CLKSOURCE_CSI: \
  398. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI; \
  399. break; \
  400. case RCC_UART9CLKSOURCE_LSE: \
  401. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
  402. break; \
  403. default: \
  404. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
  405. break; \
  406. } \
  407. } \
  408. else if((__HANDLE__)->Instance == USART10) \
  409. { \
  410. switch(__HAL_RCC_GET_USART10_SOURCE()) \
  411. { \
  412. case RCC_USART10CLKSOURCE_D2PCLK2: \
  413. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D2PCLK2; \
  414. break; \
  415. case RCC_USART10CLKSOURCE_PLL2: \
  416. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2; \
  417. break; \
  418. case RCC_USART10CLKSOURCE_PLL3: \
  419. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3; \
  420. break; \
  421. case RCC_USART10CLKSOURCE_HSI: \
  422. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
  423. break; \
  424. case RCC_USART10CLKSOURCE_CSI: \
  425. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI; \
  426. break; \
  427. case RCC_USART10CLKSOURCE_LSE: \
  428. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
  429. break; \
  430. default: \
  431. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
  432. break; \
  433. } \
  434. } \
  435. else if((__HANDLE__)->Instance == LPUART1) \
  436. { \
  437. switch(__HAL_RCC_GET_LPUART1_SOURCE()) \
  438. { \
  439. case RCC_LPUART1CLKSOURCE_D3PCLK1: \
  440. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D3PCLK1; \
  441. break; \
  442. case RCC_LPUART1CLKSOURCE_PLL2: \
  443. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2; \
  444. break; \
  445. case RCC_LPUART1CLKSOURCE_PLL3: \
  446. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3; \
  447. break; \
  448. case RCC_LPUART1CLKSOURCE_HSI: \
  449. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
  450. break; \
  451. case RCC_LPUART1CLKSOURCE_CSI: \
  452. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI; \
  453. break; \
  454. case RCC_LPUART1CLKSOURCE_LSE: \
  455. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
  456. break; \
  457. default: \
  458. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
  459. break; \
  460. } \
  461. } \
  462. else \
  463. { \
  464. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
  465. } \
  466. } while(0U)
  467. #else
  468. #define UART_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__) \
  469. do { \
  470. if((__HANDLE__)->Instance == USART1) \
  471. { \
  472. switch(__HAL_RCC_GET_USART1_SOURCE()) \
  473. { \
  474. case RCC_USART1CLKSOURCE_D2PCLK2: \
  475. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D2PCLK2; \
  476. break; \
  477. case RCC_USART1CLKSOURCE_PLL2: \
  478. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2; \
  479. break; \
  480. case RCC_USART1CLKSOURCE_PLL3: \
  481. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3; \
  482. break; \
  483. case RCC_USART1CLKSOURCE_HSI: \
  484. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
  485. break; \
  486. case RCC_USART1CLKSOURCE_CSI: \
  487. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI; \
  488. break; \
  489. case RCC_USART1CLKSOURCE_LSE: \
  490. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
  491. break; \
  492. default: \
  493. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
  494. break; \
  495. } \
  496. } \
  497. else if((__HANDLE__)->Instance == USART2) \
  498. { \
  499. switch(__HAL_RCC_GET_USART2_SOURCE()) \
  500. { \
  501. case RCC_USART2CLKSOURCE_D2PCLK1: \
  502. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D2PCLK1; \
  503. break; \
  504. case RCC_USART2CLKSOURCE_PLL2: \
  505. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2; \
  506. break; \
  507. case RCC_USART2CLKSOURCE_PLL3: \
  508. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3; \
  509. break; \
  510. case RCC_USART2CLKSOURCE_HSI: \
  511. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
  512. break; \
  513. case RCC_USART2CLKSOURCE_CSI: \
  514. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI; \
  515. break; \
  516. case RCC_USART2CLKSOURCE_LSE: \
  517. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
  518. break; \
  519. default: \
  520. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
  521. break; \
  522. } \
  523. } \
  524. else if((__HANDLE__)->Instance == USART3) \
  525. { \
  526. switch(__HAL_RCC_GET_USART3_SOURCE()) \
  527. { \
  528. case RCC_USART3CLKSOURCE_D2PCLK1: \
  529. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D2PCLK1; \
  530. break; \
  531. case RCC_USART3CLKSOURCE_PLL2: \
  532. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2; \
  533. break; \
  534. case RCC_USART3CLKSOURCE_PLL3: \
  535. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3; \
  536. break; \
  537. case RCC_USART3CLKSOURCE_HSI: \
  538. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
  539. break; \
  540. case RCC_USART3CLKSOURCE_CSI: \
  541. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI; \
  542. break; \
  543. case RCC_USART3CLKSOURCE_LSE: \
  544. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
  545. break; \
  546. default: \
  547. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
  548. break; \
  549. } \
  550. } \
  551. else if((__HANDLE__)->Instance == UART4) \
  552. { \
  553. switch(__HAL_RCC_GET_UART4_SOURCE()) \
  554. { \
  555. case RCC_UART4CLKSOURCE_D2PCLK1: \
  556. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D2PCLK1; \
  557. break; \
  558. case RCC_UART4CLKSOURCE_PLL2: \
  559. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2; \
  560. break; \
  561. case RCC_UART4CLKSOURCE_PLL3: \
  562. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3; \
  563. break; \
  564. case RCC_UART4CLKSOURCE_HSI: \
  565. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
  566. break; \
  567. case RCC_UART4CLKSOURCE_CSI: \
  568. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI; \
  569. break; \
  570. case RCC_UART4CLKSOURCE_LSE: \
  571. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
  572. break; \
  573. default: \
  574. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
  575. break; \
  576. } \
  577. } \
  578. else if ((__HANDLE__)->Instance == UART5) \
  579. { \
  580. switch(__HAL_RCC_GET_UART5_SOURCE()) \
  581. { \
  582. case RCC_UART5CLKSOURCE_D2PCLK1: \
  583. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D2PCLK1; \
  584. break; \
  585. case RCC_UART5CLKSOURCE_PLL2: \
  586. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2; \
  587. break; \
  588. case RCC_UART5CLKSOURCE_PLL3: \
  589. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3; \
  590. break; \
  591. case RCC_UART5CLKSOURCE_HSI: \
  592. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
  593. break; \
  594. case RCC_UART5CLKSOURCE_CSI: \
  595. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI; \
  596. break; \
  597. case RCC_UART5CLKSOURCE_LSE: \
  598. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
  599. break; \
  600. default: \
  601. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
  602. break; \
  603. } \
  604. } \
  605. else if((__HANDLE__)->Instance == USART6) \
  606. { \
  607. switch(__HAL_RCC_GET_USART6_SOURCE()) \
  608. { \
  609. case RCC_USART6CLKSOURCE_D2PCLK2: \
  610. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D2PCLK2; \
  611. break; \
  612. case RCC_USART6CLKSOURCE_PLL2: \
  613. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2; \
  614. break; \
  615. case RCC_USART6CLKSOURCE_PLL3: \
  616. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3; \
  617. break; \
  618. case RCC_USART6CLKSOURCE_HSI: \
  619. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
  620. break; \
  621. case RCC_USART6CLKSOURCE_CSI: \
  622. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI; \
  623. break; \
  624. case RCC_USART6CLKSOURCE_LSE: \
  625. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
  626. break; \
  627. default: \
  628. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
  629. break; \
  630. } \
  631. } \
  632. else if((__HANDLE__)->Instance == UART7) \
  633. { \
  634. switch(__HAL_RCC_GET_UART7_SOURCE()) \
  635. { \
  636. case RCC_UART7CLKSOURCE_D2PCLK1: \
  637. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D2PCLK1; \
  638. break; \
  639. case RCC_UART7CLKSOURCE_PLL2: \
  640. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2; \
  641. break; \
  642. case RCC_UART7CLKSOURCE_PLL3: \
  643. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3; \
  644. break; \
  645. case RCC_UART7CLKSOURCE_HSI: \
  646. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
  647. break; \
  648. case RCC_UART7CLKSOURCE_CSI: \
  649. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI; \
  650. break; \
  651. case RCC_UART7CLKSOURCE_LSE: \
  652. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
  653. break; \
  654. default: \
  655. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
  656. break; \
  657. } \
  658. } \
  659. else if((__HANDLE__)->Instance == UART8) \
  660. { \
  661. switch(__HAL_RCC_GET_UART8_SOURCE()) \
  662. { \
  663. case RCC_UART8CLKSOURCE_D2PCLK1: \
  664. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D2PCLK1; \
  665. break; \
  666. case RCC_UART8CLKSOURCE_PLL2: \
  667. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2; \
  668. break; \
  669. case RCC_UART8CLKSOURCE_PLL3: \
  670. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3; \
  671. break; \
  672. case RCC_UART8CLKSOURCE_HSI: \
  673. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
  674. break; \
  675. case RCC_UART8CLKSOURCE_CSI: \
  676. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI; \
  677. break; \
  678. case RCC_UART8CLKSOURCE_LSE: \
  679. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
  680. break; \
  681. default: \
  682. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
  683. break; \
  684. } \
  685. } \
  686. else if((__HANDLE__)->Instance == LPUART1) \
  687. { \
  688. switch(__HAL_RCC_GET_LPUART1_SOURCE()) \
  689. { \
  690. case RCC_LPUART1CLKSOURCE_D3PCLK1: \
  691. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_D3PCLK1; \
  692. break; \
  693. case RCC_LPUART1CLKSOURCE_PLL2: \
  694. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL2; \
  695. break; \
  696. case RCC_LPUART1CLKSOURCE_PLL3: \
  697. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PLL3; \
  698. break; \
  699. case RCC_LPUART1CLKSOURCE_HSI: \
  700. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
  701. break; \
  702. case RCC_LPUART1CLKSOURCE_CSI: \
  703. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_CSI; \
  704. break; \
  705. case RCC_LPUART1CLKSOURCE_LSE: \
  706. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
  707. break; \
  708. default: \
  709. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
  710. break; \
  711. } \
  712. } \
  713. else \
  714. { \
  715. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
  716. } \
  717. } while(0U)
  718. #endif /* UART9 && USART10 */
  719. /** @brief Report the UART mask to apply to retrieve the received data
  720. * according to the word length and to the parity bits activation.
  721. * @note If PCE = 1, the parity bit is not included in the data extracted
  722. * by the reception API().
  723. * This masking operation is not carried out in the case of
  724. * DMA transfers.
  725. * @param __HANDLE__ specifies the UART Handle.
  726. * @retval None, the mask to apply to UART RDR register is stored in (__HANDLE__)->Mask field.
  727. */
  728. #define UART_MASK_COMPUTATION(__HANDLE__) \
  729. do { \
  730. if ((__HANDLE__)->Init.WordLength == UART_WORDLENGTH_9B) \
  731. { \
  732. if ((__HANDLE__)->Init.Parity == UART_PARITY_NONE) \
  733. { \
  734. (__HANDLE__)->Mask = 0x01FFU ; \
  735. } \
  736. else \
  737. { \
  738. (__HANDLE__)->Mask = 0x00FFU ; \
  739. } \
  740. } \
  741. else if ((__HANDLE__)->Init.WordLength == UART_WORDLENGTH_8B) \
  742. { \
  743. if ((__HANDLE__)->Init.Parity == UART_PARITY_NONE) \
  744. { \
  745. (__HANDLE__)->Mask = 0x00FFU ; \
  746. } \
  747. else \
  748. { \
  749. (__HANDLE__)->Mask = 0x007FU ; \
  750. } \
  751. } \
  752. else if ((__HANDLE__)->Init.WordLength == UART_WORDLENGTH_7B) \
  753. { \
  754. if ((__HANDLE__)->Init.Parity == UART_PARITY_NONE) \
  755. { \
  756. (__HANDLE__)->Mask = 0x007FU ; \
  757. } \
  758. else \
  759. { \
  760. (__HANDLE__)->Mask = 0x003FU ; \
  761. } \
  762. } \
  763. else \
  764. { \
  765. (__HANDLE__)->Mask = 0x0000U; \
  766. } \
  767. } while(0U)
  768. /**
  769. * @brief Ensure that UART frame length is valid.
  770. * @param __LENGTH__ UART frame length.
  771. * @retval SET (__LENGTH__ is valid) or RESET (__LENGTH__ is invalid)
  772. */
  773. #define IS_UART_WORD_LENGTH(__LENGTH__) (((__LENGTH__) == UART_WORDLENGTH_7B) || \
  774. ((__LENGTH__) == UART_WORDLENGTH_8B) || \
  775. ((__LENGTH__) == UART_WORDLENGTH_9B))
  776. /**
  777. * @brief Ensure that UART wake-up address length is valid.
  778. * @param __ADDRESS__ UART wake-up address length.
  779. * @retval SET (__ADDRESS__ is valid) or RESET (__ADDRESS__ is invalid)
  780. */
  781. #define IS_UART_ADDRESSLENGTH_DETECT(__ADDRESS__) (((__ADDRESS__) == UART_ADDRESS_DETECT_4B) || \
  782. ((__ADDRESS__) == UART_ADDRESS_DETECT_7B))
  783. /**
  784. * @brief Ensure that UART TXFIFO threshold level is valid.
  785. * @param __THRESHOLD__ UART TXFIFO threshold level.
  786. * @retval SET (__THRESHOLD__ is valid) or RESET (__THRESHOLD__ is invalid)
  787. */
  788. #define IS_UART_TXFIFO_THRESHOLD(__THRESHOLD__) (((__THRESHOLD__) == UART_TXFIFO_THRESHOLD_1_8) || \
  789. ((__THRESHOLD__) == UART_TXFIFO_THRESHOLD_1_4) || \
  790. ((__THRESHOLD__) == UART_TXFIFO_THRESHOLD_1_2) || \
  791. ((__THRESHOLD__) == UART_TXFIFO_THRESHOLD_3_4) || \
  792. ((__THRESHOLD__) == UART_TXFIFO_THRESHOLD_7_8) || \
  793. ((__THRESHOLD__) == UART_TXFIFO_THRESHOLD_8_8))
  794. /**
  795. * @brief Ensure that UART RXFIFO threshold level is valid.
  796. * @param __THRESHOLD__ UART RXFIFO threshold level.
  797. * @retval SET (__THRESHOLD__ is valid) or RESET (__THRESHOLD__ is invalid)
  798. */
  799. #define IS_UART_RXFIFO_THRESHOLD(__THRESHOLD__) (((__THRESHOLD__) == UART_RXFIFO_THRESHOLD_1_8) || \
  800. ((__THRESHOLD__) == UART_RXFIFO_THRESHOLD_1_4) || \
  801. ((__THRESHOLD__) == UART_RXFIFO_THRESHOLD_1_2) || \
  802. ((__THRESHOLD__) == UART_RXFIFO_THRESHOLD_3_4) || \
  803. ((__THRESHOLD__) == UART_RXFIFO_THRESHOLD_7_8) || \
  804. ((__THRESHOLD__) == UART_RXFIFO_THRESHOLD_8_8))
  805. /**
  806. * @}
  807. */
  808. /* Private functions ---------------------------------------------------------*/
  809. /**
  810. * @}
  811. */
  812. /**
  813. * @}
  814. */
  815. #ifdef __cplusplus
  816. }
  817. #endif
  818. #endif /* STM32H7xx_HAL_UART_EX_H */
  819. /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/