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>© 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****/ 447