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.
 
 
 

639 lines
34 KiB

  1. /**
  2. ******************************************************************************
  3. * @file stm32l4xx_hal_uart_ex.h
  4. * @author MCD Application Team
  5. * @version V1.7.2
  6. * @date 16-June-2017
  7. * @brief Header file of UART HAL Extended module.
  8. ******************************************************************************
  9. * @attention
  10. *
  11. * <h2><center>&copy; COPYRIGHT(c) 2017 STMicroelectronics</center></h2>
  12. *
  13. * Redistribution and use in source and binary forms, with or without modification,
  14. * are permitted provided that the following conditions are met:
  15. * 1. Redistributions of source code must retain the above copyright notice,
  16. * this list of conditions and the following disclaimer.
  17. * 2. Redistributions in binary form must reproduce the above copyright notice,
  18. * this list of conditions and the following disclaimer in the documentation
  19. * and/or other materials provided with the distribution.
  20. * 3. Neither the name of STMicroelectronics nor the names of its contributors
  21. * may be used to endorse or promote products derived from this software
  22. * without specific prior written permission.
  23. *
  24. * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  25. * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  26. * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  27. * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  28. * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  29. * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  30. * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  31. * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  32. * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  33. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  34. *
  35. ******************************************************************************
  36. */
  37. /* Define to prevent recursive inclusion -------------------------------------*/
  38. #ifndef __STM32L4xx_HAL_UART_EX_H
  39. #define __STM32L4xx_HAL_UART_EX_H
  40. #ifdef __cplusplus
  41. extern "C" {
  42. #endif
  43. /* Includes ------------------------------------------------------------------*/
  44. #include "stm32l4xx_hal_def.h"
  45. /** @addtogroup STM32L4xx_HAL_Driver
  46. * @{
  47. */
  48. /** @addtogroup UARTEx
  49. * @{
  50. */
  51. /* Exported types ------------------------------------------------------------*/
  52. /** @defgroup UARTEx_Exported_Types UARTEx Exported Types
  53. * @{
  54. */
  55. /**
  56. * @brief UART wake up from stop mode parameters
  57. */
  58. typedef struct
  59. {
  60. uint32_t WakeUpEvent; /*!< Specifies which event will activat the Wakeup from Stop mode flag (WUF).
  61. This parameter can be a value of @ref UART_WakeUp_from_Stop_Selection.
  62. If set to UART_WAKEUP_ON_ADDRESS, the two other fields below must
  63. be filled up. */
  64. uint16_t AddressLength; /*!< Specifies whether the address is 4 or 7-bit long.
  65. This parameter can be a value of @ref UARTEx_WakeUp_Address_Length. */
  66. uint8_t Address; /*!< UART/USART node address (7-bit long max). */
  67. } UART_WakeUpTypeDef;
  68. /**
  69. * @}
  70. */
  71. /* Exported constants --------------------------------------------------------*/
  72. /** @defgroup UARTEx_Exported_Constants UARTEx Exported Constants
  73. * @{
  74. */
  75. /** @defgroup UARTEx_Word_Length UART Word Length
  76. * @{
  77. */
  78. #define UART_WORDLENGTH_7B ((uint32_t)USART_CR1_M1) /*!< 7-bit long UART frame */
  79. #define UART_WORDLENGTH_8B ((uint32_t)0x00000000) /*!< 8-bit long UART frame */
  80. #define UART_WORDLENGTH_9B ((uint32_t)USART_CR1_M0) /*!< 9-bit long UART frame */
  81. /**
  82. * @}
  83. */
  84. /** @defgroup UARTEx_WakeUp_Address_Length UART Extended WakeUp Address Length
  85. * @{
  86. */
  87. #define UART_ADDRESS_DETECT_4B ((uint32_t)0x00000000) /*!< 4-bit long wake-up address */
  88. #define UART_ADDRESS_DETECT_7B ((uint32_t)USART_CR2_ADDM7) /*!< 7-bit long wake-up address */
  89. /**
  90. * @}
  91. */
  92. /**
  93. * @}
  94. */
  95. /* Exported macros -----------------------------------------------------------*/
  96. /* Exported functions --------------------------------------------------------*/
  97. /** @addtogroup UARTEx_Exported_Functions
  98. * @{
  99. */
  100. /** @addtogroup UARTEx_Exported_Functions_Group1
  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. /* IO operation functions *****************************************************/
  109. /** @addtogroup UARTEx_Exported_Functions_Group3
  110. * @{
  111. */
  112. /* Peripheral Control functions **********************************************/
  113. HAL_StatusTypeDef HAL_UARTEx_StopModeWakeUpSourceConfig(UART_HandleTypeDef *huart, UART_WakeUpTypeDef WakeUpSelection);
  114. HAL_StatusTypeDef HAL_UARTEx_EnableStopMode(UART_HandleTypeDef *huart);
  115. HAL_StatusTypeDef HAL_UARTEx_DisableStopMode(UART_HandleTypeDef *huart);
  116. HAL_StatusTypeDef HAL_MultiProcessorEx_AddressLength_Set(UART_HandleTypeDef *huart, uint32_t AddressLength);
  117. void HAL_UARTEx_WakeupCallback(UART_HandleTypeDef *huart);
  118. /**
  119. * @}
  120. */
  121. /**
  122. * @}
  123. */
  124. /* Private macros ------------------------------------------------------------*/
  125. /** @defgroup UARTEx_Private_Macros UARTEx Private Macros
  126. * @{
  127. */
  128. /** @brief Report the UART clock source.
  129. * @param __HANDLE__: specifies the UART Handle.
  130. * @param __CLOCKSOURCE__: output variable.
  131. * @retval UART clocking source, written in __CLOCKSOURCE__.
  132. */
  133. #if defined (STM32L471xx) || defined (STM32L475xx) || defined (STM32L476xx) || defined (STM32L485xx) || defined (STM32L486xx) || defined (STM32L496xx) || defined (STM32L4A6xx)
  134. #define UART_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__) \
  135. do { \
  136. if((__HANDLE__)->Instance == USART1) \
  137. { \
  138. switch(__HAL_RCC_GET_USART1_SOURCE()) \
  139. { \
  140. case RCC_USART1CLKSOURCE_PCLK2: \
  141. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK2; \
  142. break; \
  143. case RCC_USART1CLKSOURCE_HSI: \
  144. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
  145. break; \
  146. case RCC_USART1CLKSOURCE_SYSCLK: \
  147. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK; \
  148. break; \
  149. case RCC_USART1CLKSOURCE_LSE: \
  150. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
  151. break; \
  152. default: \
  153. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
  154. break; \
  155. } \
  156. } \
  157. else if((__HANDLE__)->Instance == USART2) \
  158. { \
  159. switch(__HAL_RCC_GET_USART2_SOURCE()) \
  160. { \
  161. case RCC_USART2CLKSOURCE_PCLK1: \
  162. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1; \
  163. break; \
  164. case RCC_USART2CLKSOURCE_HSI: \
  165. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
  166. break; \
  167. case RCC_USART2CLKSOURCE_SYSCLK: \
  168. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK; \
  169. break; \
  170. case RCC_USART2CLKSOURCE_LSE: \
  171. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
  172. break; \
  173. default: \
  174. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
  175. break; \
  176. } \
  177. } \
  178. else if((__HANDLE__)->Instance == USART3) \
  179. { \
  180. switch(__HAL_RCC_GET_USART3_SOURCE()) \
  181. { \
  182. case RCC_USART3CLKSOURCE_PCLK1: \
  183. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1; \
  184. break; \
  185. case RCC_USART3CLKSOURCE_HSI: \
  186. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
  187. break; \
  188. case RCC_USART3CLKSOURCE_SYSCLK: \
  189. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK; \
  190. break; \
  191. case RCC_USART3CLKSOURCE_LSE: \
  192. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
  193. break; \
  194. default: \
  195. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
  196. break; \
  197. } \
  198. } \
  199. else if((__HANDLE__)->Instance == UART4) \
  200. { \
  201. switch(__HAL_RCC_GET_UART4_SOURCE()) \
  202. { \
  203. case RCC_UART4CLKSOURCE_PCLK1: \
  204. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1; \
  205. break; \
  206. case RCC_UART4CLKSOURCE_HSI: \
  207. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
  208. break; \
  209. case RCC_UART4CLKSOURCE_SYSCLK: \
  210. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK; \
  211. break; \
  212. case RCC_UART4CLKSOURCE_LSE: \
  213. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
  214. break; \
  215. default: \
  216. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
  217. break; \
  218. } \
  219. } \
  220. else if ((__HANDLE__)->Instance == UART5) \
  221. { \
  222. switch(__HAL_RCC_GET_UART5_SOURCE()) \
  223. { \
  224. case RCC_UART5CLKSOURCE_PCLK1: \
  225. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1; \
  226. break; \
  227. case RCC_UART5CLKSOURCE_HSI: \
  228. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
  229. break; \
  230. case RCC_UART5CLKSOURCE_SYSCLK: \
  231. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK; \
  232. break; \
  233. case RCC_UART5CLKSOURCE_LSE: \
  234. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
  235. break; \
  236. default: \
  237. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
  238. break; \
  239. } \
  240. } \
  241. else if((__HANDLE__)->Instance == LPUART1) \
  242. { \
  243. switch(__HAL_RCC_GET_LPUART1_SOURCE()) \
  244. { \
  245. case RCC_LPUART1CLKSOURCE_PCLK1: \
  246. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1; \
  247. break; \
  248. case RCC_LPUART1CLKSOURCE_HSI: \
  249. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
  250. break; \
  251. case RCC_LPUART1CLKSOURCE_SYSCLK: \
  252. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK; \
  253. break; \
  254. case RCC_LPUART1CLKSOURCE_LSE: \
  255. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
  256. break; \
  257. default: \
  258. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
  259. break; \
  260. } \
  261. } \
  262. } while(0)
  263. #elif defined (STM32L431xx) || defined (STM32L433xx) || defined (STM32L443xx)
  264. #define UART_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__) \
  265. do { \
  266. if((__HANDLE__)->Instance == USART1) \
  267. { \
  268. switch(__HAL_RCC_GET_USART1_SOURCE()) \
  269. { \
  270. case RCC_USART1CLKSOURCE_PCLK2: \
  271. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK2; \
  272. break; \
  273. case RCC_USART1CLKSOURCE_HSI: \
  274. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
  275. break; \
  276. case RCC_USART1CLKSOURCE_SYSCLK: \
  277. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK; \
  278. break; \
  279. case RCC_USART1CLKSOURCE_LSE: \
  280. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
  281. break; \
  282. default: \
  283. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
  284. break; \
  285. } \
  286. } \
  287. else if((__HANDLE__)->Instance == USART2) \
  288. { \
  289. switch(__HAL_RCC_GET_USART2_SOURCE()) \
  290. { \
  291. case RCC_USART2CLKSOURCE_PCLK1: \
  292. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1; \
  293. break; \
  294. case RCC_USART2CLKSOURCE_HSI: \
  295. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
  296. break; \
  297. case RCC_USART2CLKSOURCE_SYSCLK: \
  298. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK; \
  299. break; \
  300. case RCC_USART2CLKSOURCE_LSE: \
  301. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
  302. break; \
  303. default: \
  304. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
  305. break; \
  306. } \
  307. } \
  308. else if((__HANDLE__)->Instance == USART3) \
  309. { \
  310. switch(__HAL_RCC_GET_USART3_SOURCE()) \
  311. { \
  312. case RCC_USART3CLKSOURCE_PCLK1: \
  313. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1; \
  314. break; \
  315. case RCC_USART3CLKSOURCE_HSI: \
  316. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
  317. break; \
  318. case RCC_USART3CLKSOURCE_SYSCLK: \
  319. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK; \
  320. break; \
  321. case RCC_USART3CLKSOURCE_LSE: \
  322. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
  323. break; \
  324. default: \
  325. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
  326. break; \
  327. } \
  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. } while(0)
  351. #elif defined (STM32L432xx) || defined (STM32L442xx)
  352. #define UART_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__) \
  353. do { \
  354. if((__HANDLE__)->Instance == USART1) \
  355. { \
  356. switch(__HAL_RCC_GET_USART1_SOURCE()) \
  357. { \
  358. case RCC_USART1CLKSOURCE_PCLK2: \
  359. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK2; \
  360. break; \
  361. case RCC_USART1CLKSOURCE_HSI: \
  362. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
  363. break; \
  364. case RCC_USART1CLKSOURCE_SYSCLK: \
  365. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK; \
  366. break; \
  367. case RCC_USART1CLKSOURCE_LSE: \
  368. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
  369. break; \
  370. default: \
  371. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
  372. break; \
  373. } \
  374. } \
  375. else if((__HANDLE__)->Instance == USART2) \
  376. { \
  377. switch(__HAL_RCC_GET_USART2_SOURCE()) \
  378. { \
  379. case RCC_USART2CLKSOURCE_PCLK1: \
  380. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1; \
  381. break; \
  382. case RCC_USART2CLKSOURCE_HSI: \
  383. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
  384. break; \
  385. case RCC_USART2CLKSOURCE_SYSCLK: \
  386. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK; \
  387. break; \
  388. case RCC_USART2CLKSOURCE_LSE: \
  389. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
  390. break; \
  391. default: \
  392. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
  393. break; \
  394. } \
  395. } \
  396. else if((__HANDLE__)->Instance == LPUART1) \
  397. { \
  398. switch(__HAL_RCC_GET_LPUART1_SOURCE()) \
  399. { \
  400. case RCC_LPUART1CLKSOURCE_PCLK1: \
  401. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1; \
  402. break; \
  403. case RCC_LPUART1CLKSOURCE_HSI: \
  404. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
  405. break; \
  406. case RCC_LPUART1CLKSOURCE_SYSCLK: \
  407. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK; \
  408. break; \
  409. case RCC_LPUART1CLKSOURCE_LSE: \
  410. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
  411. break; \
  412. default: \
  413. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
  414. break; \
  415. } \
  416. } \
  417. } while(0)
  418. #elif defined (STM32L451xx) || defined (STM32L452xx) || defined (STM32L462xx)
  419. #define UART_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__) \
  420. do { \
  421. if((__HANDLE__)->Instance == USART1) \
  422. { \
  423. switch(__HAL_RCC_GET_USART1_SOURCE()) \
  424. { \
  425. case RCC_USART1CLKSOURCE_PCLK2: \
  426. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK2; \
  427. break; \
  428. case RCC_USART1CLKSOURCE_HSI: \
  429. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
  430. break; \
  431. case RCC_USART1CLKSOURCE_SYSCLK: \
  432. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK; \
  433. break; \
  434. case RCC_USART1CLKSOURCE_LSE: \
  435. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
  436. break; \
  437. default: \
  438. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
  439. break; \
  440. } \
  441. } \
  442. else if((__HANDLE__)->Instance == USART2) \
  443. { \
  444. switch(__HAL_RCC_GET_USART2_SOURCE()) \
  445. { \
  446. case RCC_USART2CLKSOURCE_PCLK1: \
  447. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1; \
  448. break; \
  449. case RCC_USART2CLKSOURCE_HSI: \
  450. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
  451. break; \
  452. case RCC_USART2CLKSOURCE_SYSCLK: \
  453. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK; \
  454. break; \
  455. case RCC_USART2CLKSOURCE_LSE: \
  456. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
  457. break; \
  458. default: \
  459. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
  460. break; \
  461. } \
  462. } \
  463. else if((__HANDLE__)->Instance == USART3) \
  464. { \
  465. switch(__HAL_RCC_GET_USART3_SOURCE()) \
  466. { \
  467. case RCC_USART3CLKSOURCE_PCLK1: \
  468. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1; \
  469. break; \
  470. case RCC_USART3CLKSOURCE_HSI: \
  471. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
  472. break; \
  473. case RCC_USART3CLKSOURCE_SYSCLK: \
  474. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK; \
  475. break; \
  476. case RCC_USART3CLKSOURCE_LSE: \
  477. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
  478. break; \
  479. default: \
  480. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
  481. break; \
  482. } \
  483. } \
  484. else if((__HANDLE__)->Instance == UART4) \
  485. { \
  486. switch(__HAL_RCC_GET_UART4_SOURCE()) \
  487. { \
  488. case RCC_UART4CLKSOURCE_PCLK1: \
  489. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1; \
  490. break; \
  491. case RCC_UART4CLKSOURCE_HSI: \
  492. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
  493. break; \
  494. case RCC_UART4CLKSOURCE_SYSCLK: \
  495. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK; \
  496. break; \
  497. case RCC_UART4CLKSOURCE_LSE: \
  498. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
  499. break; \
  500. default: \
  501. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
  502. break; \
  503. } \
  504. } \
  505. else if((__HANDLE__)->Instance == LPUART1) \
  506. { \
  507. switch(__HAL_RCC_GET_LPUART1_SOURCE()) \
  508. { \
  509. case RCC_LPUART1CLKSOURCE_PCLK1: \
  510. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1; \
  511. break; \
  512. case RCC_LPUART1CLKSOURCE_HSI: \
  513. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI; \
  514. break; \
  515. case RCC_LPUART1CLKSOURCE_SYSCLK: \
  516. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK; \
  517. break; \
  518. case RCC_LPUART1CLKSOURCE_LSE: \
  519. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE; \
  520. break; \
  521. default: \
  522. (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED; \
  523. break; \
  524. } \
  525. } \
  526. } while(0)
  527. #endif
  528. /** @brief Report the UART mask to apply to retrieve the received data
  529. * according to the word length and to the parity bits activation.
  530. * @note If PCE = 1, the parity bit is not included in the data extracted
  531. * by the reception API().
  532. * This masking operation is not carried out in the case of
  533. * DMA transfers.
  534. * @param __HANDLE__: specifies the UART Handle.
  535. * @retval None, the mask to apply to UART RDR register is stored in (__HANDLE__)->Mask field.
  536. */
  537. #define UART_MASK_COMPUTATION(__HANDLE__) \
  538. do { \
  539. if ((__HANDLE__)->Init.WordLength == UART_WORDLENGTH_9B) \
  540. { \
  541. if ((__HANDLE__)->Init.Parity == UART_PARITY_NONE) \
  542. { \
  543. (__HANDLE__)->Mask = 0x01FF ; \
  544. } \
  545. else \
  546. { \
  547. (__HANDLE__)->Mask = 0x00FF ; \
  548. } \
  549. } \
  550. else if ((__HANDLE__)->Init.WordLength == UART_WORDLENGTH_8B) \
  551. { \
  552. if ((__HANDLE__)->Init.Parity == UART_PARITY_NONE) \
  553. { \
  554. (__HANDLE__)->Mask = 0x00FF ; \
  555. } \
  556. else \
  557. { \
  558. (__HANDLE__)->Mask = 0x007F ; \
  559. } \
  560. } \
  561. else if ((__HANDLE__)->Init.WordLength == UART_WORDLENGTH_7B) \
  562. { \
  563. if ((__HANDLE__)->Init.Parity == UART_PARITY_NONE) \
  564. { \
  565. (__HANDLE__)->Mask = 0x007F ; \
  566. } \
  567. else \
  568. { \
  569. (__HANDLE__)->Mask = 0x003F ; \
  570. } \
  571. } \
  572. } while(0)
  573. /**
  574. * @brief Ensure that UART frame length is valid.
  575. * @param __LENGTH__: UART frame length.
  576. * @retval SET (__LENGTH__ is valid) or RESET (__LENGTH__ is invalid)
  577. */
  578. #define IS_UART_WORD_LENGTH(__LENGTH__) (((__LENGTH__) == UART_WORDLENGTH_7B) || \
  579. ((__LENGTH__) == UART_WORDLENGTH_8B) || \
  580. ((__LENGTH__) == UART_WORDLENGTH_9B))
  581. /**
  582. * @brief Ensure that UART wake-up address length is valid.
  583. * @param __ADDRESS__: UART wake-up address length.
  584. * @retval SET (__ADDRESS__ is valid) or RESET (__ADDRESS__ is invalid)
  585. */
  586. #define IS_UART_ADDRESSLENGTH_DETECT(__ADDRESS__) (((__ADDRESS__) == UART_ADDRESS_DETECT_4B) || \
  587. ((__ADDRESS__) == UART_ADDRESS_DETECT_7B))
  588. /**
  589. * @}
  590. */
  591. /* Private functions ---------------------------------------------------------*/
  592. /**
  593. * @}
  594. */
  595. /**
  596. * @}
  597. */
  598. #ifdef __cplusplus
  599. }
  600. #endif
  601. #endif /* __STM32L4xx_HAL_UART_EX_H */
  602. /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/