1 /** 2 ****************************************************************************** 3 * @file stm32l4xx_hal_irda_ex.h 4 * @author MCD Application Team 5 * @brief Header file of IRDA HAL Extended module. 6 ****************************************************************************** 7 * @attention 8 * 9 * Copyright (c) 2017 STMicroelectronics. 10 * All rights reserved. 11 * 12 * This software is licensed under terms that can be found in the LICENSE file 13 * in the root directory of this software component. 14 * If no LICENSE file comes with this software, it is provided AS-IS. 15 * 16 ****************************************************************************** 17 */ 18 19 /* Define to prevent recursive inclusion -------------------------------------*/ 20 #ifndef STM32L4xx_HAL_IRDA_EX_H 21 #define STM32L4xx_HAL_IRDA_EX_H 22 23 #ifdef __cplusplus 24 extern "C" { 25 #endif 26 27 /* Includes ------------------------------------------------------------------*/ 28 #include "stm32l4xx_hal_def.h" 29 30 /** @addtogroup STM32L4xx_HAL_Driver 31 * @{ 32 */ 33 34 /** @defgroup IRDAEx IRDAEx 35 * @brief IRDA Extended HAL module driver 36 * @{ 37 */ 38 39 /* Exported types ------------------------------------------------------------*/ 40 /* Exported constants --------------------------------------------------------*/ 41 /** @defgroup IRDAEx_Extended_Exported_Constants IRDAEx Extended Exported Constants 42 * @{ 43 */ 44 45 /** @defgroup IRDAEx_Word_Length IRDAEx Word Length 46 * @{ 47 */ 48 #define IRDA_WORDLENGTH_7B USART_CR1_M1 /*!< 7-bit long frame */ 49 #define IRDA_WORDLENGTH_8B 0x00000000U /*!< 8-bit long frame */ 50 #define IRDA_WORDLENGTH_9B USART_CR1_M0 /*!< 9-bit long frame */ 51 /** 52 * @} 53 */ 54 55 /** 56 * @} 57 */ 58 59 /* Exported macros -----------------------------------------------------------*/ 60 61 /* Private macros ------------------------------------------------------------*/ 62 63 /** @defgroup IRDAEx_Private_Macros IRDAEx Private Macros 64 * @{ 65 */ 66 67 /** @brief Report the IRDA clock source. 68 * @param __HANDLE__ specifies the IRDA Handle. 69 * @param __CLOCKSOURCE__ output variable. 70 * @retval IRDA clocking source, written in __CLOCKSOURCE__. 71 */ 72 #if defined (STM32L471xx) || defined (STM32L475xx) || defined (STM32L476xx) \ 73 || defined (STM32L485xx) || defined (STM32L486xx) \ 74 || defined (STM32L496xx) || defined (STM32L4A6xx) \ 75 || defined (STM32L4P5xx) || defined (STM32L4Q5xx) \ 76 || defined (STM32L4R5xx) || defined (STM32L4R7xx) \ 77 || defined (STM32L4R9xx) || defined (STM32L4S5xx) || defined (STM32L4S7xx) || defined (STM32L4S9xx) 78 #define IRDA_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__) \ 79 do { \ 80 if((__HANDLE__)->Instance == USART1) \ 81 { \ 82 switch(__HAL_RCC_GET_USART1_SOURCE()) \ 83 { \ 84 case RCC_USART1CLKSOURCE_PCLK2: \ 85 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK2; \ 86 break; \ 87 case RCC_USART1CLKSOURCE_HSI: \ 88 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 89 break; \ 90 case RCC_USART1CLKSOURCE_SYSCLK: \ 91 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK; \ 92 break; \ 93 case RCC_USART1CLKSOURCE_LSE: \ 94 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 95 break; \ 96 default: \ 97 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 98 break; \ 99 } \ 100 } \ 101 else if((__HANDLE__)->Instance == USART2) \ 102 { \ 103 switch(__HAL_RCC_GET_USART2_SOURCE()) \ 104 { \ 105 case RCC_USART2CLKSOURCE_PCLK1: \ 106 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1; \ 107 break; \ 108 case RCC_USART2CLKSOURCE_HSI: \ 109 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 110 break; \ 111 case RCC_USART2CLKSOURCE_SYSCLK: \ 112 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK; \ 113 break; \ 114 case RCC_USART2CLKSOURCE_LSE: \ 115 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 116 break; \ 117 default: \ 118 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 119 break; \ 120 } \ 121 } \ 122 else if((__HANDLE__)->Instance == USART3) \ 123 { \ 124 switch(__HAL_RCC_GET_USART3_SOURCE()) \ 125 { \ 126 case RCC_USART3CLKSOURCE_PCLK1: \ 127 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1; \ 128 break; \ 129 case RCC_USART3CLKSOURCE_HSI: \ 130 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 131 break; \ 132 case RCC_USART3CLKSOURCE_SYSCLK: \ 133 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK; \ 134 break; \ 135 case RCC_USART3CLKSOURCE_LSE: \ 136 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 137 break; \ 138 default: \ 139 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 140 break; \ 141 } \ 142 } \ 143 else if((__HANDLE__)->Instance == UART4) \ 144 { \ 145 switch(__HAL_RCC_GET_UART4_SOURCE()) \ 146 { \ 147 case RCC_UART4CLKSOURCE_PCLK1: \ 148 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1; \ 149 break; \ 150 case RCC_UART4CLKSOURCE_HSI: \ 151 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 152 break; \ 153 case RCC_UART4CLKSOURCE_SYSCLK: \ 154 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK; \ 155 break; \ 156 case RCC_UART4CLKSOURCE_LSE: \ 157 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 158 break; \ 159 default: \ 160 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 161 break; \ 162 } \ 163 } \ 164 else if ((__HANDLE__)->Instance == UART5) \ 165 { \ 166 switch(__HAL_RCC_GET_UART5_SOURCE()) \ 167 { \ 168 case RCC_UART5CLKSOURCE_PCLK1: \ 169 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1; \ 170 break; \ 171 case RCC_UART5CLKSOURCE_HSI: \ 172 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 173 break; \ 174 case RCC_UART5CLKSOURCE_SYSCLK: \ 175 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK; \ 176 break; \ 177 case RCC_UART5CLKSOURCE_LSE: \ 178 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 179 break; \ 180 default: \ 181 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 182 break; \ 183 } \ 184 } \ 185 else \ 186 { \ 187 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 188 } \ 189 } while(0) 190 #elif defined(STM32L412xx) || defined(STM32L422xx) \ 191 || defined(STM32L431xx) || defined(STM32L433xx) || defined(STM32L443xx) 192 #define IRDA_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__) \ 193 do { \ 194 if((__HANDLE__)->Instance == USART1) \ 195 { \ 196 switch(__HAL_RCC_GET_USART1_SOURCE()) \ 197 { \ 198 case RCC_USART1CLKSOURCE_PCLK2: \ 199 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK2; \ 200 break; \ 201 case RCC_USART1CLKSOURCE_HSI: \ 202 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 203 break; \ 204 case RCC_USART1CLKSOURCE_SYSCLK: \ 205 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK; \ 206 break; \ 207 case RCC_USART1CLKSOURCE_LSE: \ 208 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 209 break; \ 210 default: \ 211 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 212 break; \ 213 } \ 214 } \ 215 else if((__HANDLE__)->Instance == USART2) \ 216 { \ 217 switch(__HAL_RCC_GET_USART2_SOURCE()) \ 218 { \ 219 case RCC_USART2CLKSOURCE_PCLK1: \ 220 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1; \ 221 break; \ 222 case RCC_USART2CLKSOURCE_HSI: \ 223 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 224 break; \ 225 case RCC_USART2CLKSOURCE_SYSCLK: \ 226 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK; \ 227 break; \ 228 case RCC_USART2CLKSOURCE_LSE: \ 229 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 230 break; \ 231 default: \ 232 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 233 break; \ 234 } \ 235 } \ 236 else if((__HANDLE__)->Instance == USART3) \ 237 { \ 238 switch(__HAL_RCC_GET_USART3_SOURCE()) \ 239 { \ 240 case RCC_USART3CLKSOURCE_PCLK1: \ 241 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1; \ 242 break; \ 243 case RCC_USART3CLKSOURCE_HSI: \ 244 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 245 break; \ 246 case RCC_USART3CLKSOURCE_SYSCLK: \ 247 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK; \ 248 break; \ 249 case RCC_USART3CLKSOURCE_LSE: \ 250 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 251 break; \ 252 default: \ 253 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 254 break; \ 255 } \ 256 } \ 257 else \ 258 { \ 259 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 260 } \ 261 } while(0) 262 #elif defined (STM32L432xx) || defined (STM32L442xx) 263 #define IRDA_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__) \ 264 do { \ 265 if((__HANDLE__)->Instance == USART1) \ 266 { \ 267 switch(__HAL_RCC_GET_USART1_SOURCE()) \ 268 { \ 269 case RCC_USART1CLKSOURCE_PCLK2: \ 270 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK2; \ 271 break; \ 272 case RCC_USART1CLKSOURCE_HSI: \ 273 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 274 break; \ 275 case RCC_USART1CLKSOURCE_SYSCLK: \ 276 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK; \ 277 break; \ 278 case RCC_USART1CLKSOURCE_LSE: \ 279 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 280 break; \ 281 default: \ 282 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 283 break; \ 284 } \ 285 } \ 286 else if((__HANDLE__)->Instance == USART2) \ 287 { \ 288 switch(__HAL_RCC_GET_USART2_SOURCE()) \ 289 { \ 290 case RCC_USART2CLKSOURCE_PCLK1: \ 291 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1; \ 292 break; \ 293 case RCC_USART2CLKSOURCE_HSI: \ 294 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 295 break; \ 296 case RCC_USART2CLKSOURCE_SYSCLK: \ 297 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK; \ 298 break; \ 299 case RCC_USART2CLKSOURCE_LSE: \ 300 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 301 break; \ 302 default: \ 303 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 304 break; \ 305 } \ 306 } \ 307 else \ 308 { \ 309 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 310 } \ 311 } while(0) 312 #elif defined (STM32L451xx) || defined (STM32L452xx) || defined (STM32L462xx) 313 #define IRDA_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__) \ 314 do { \ 315 if((__HANDLE__)->Instance == USART1) \ 316 { \ 317 switch(__HAL_RCC_GET_USART1_SOURCE()) \ 318 { \ 319 case RCC_USART1CLKSOURCE_PCLK2: \ 320 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK2; \ 321 break; \ 322 case RCC_USART1CLKSOURCE_HSI: \ 323 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 324 break; \ 325 case RCC_USART1CLKSOURCE_SYSCLK: \ 326 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK; \ 327 break; \ 328 case RCC_USART1CLKSOURCE_LSE: \ 329 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 330 break; \ 331 default: \ 332 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 333 break; \ 334 } \ 335 } \ 336 else if((__HANDLE__)->Instance == USART2) \ 337 { \ 338 switch(__HAL_RCC_GET_USART2_SOURCE()) \ 339 { \ 340 case RCC_USART2CLKSOURCE_PCLK1: \ 341 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1; \ 342 break; \ 343 case RCC_USART2CLKSOURCE_HSI: \ 344 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 345 break; \ 346 case RCC_USART2CLKSOURCE_SYSCLK: \ 347 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK; \ 348 break; \ 349 case RCC_USART2CLKSOURCE_LSE: \ 350 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 351 break; \ 352 default: \ 353 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 354 break; \ 355 } \ 356 } \ 357 else if((__HANDLE__)->Instance == USART3) \ 358 { \ 359 switch(__HAL_RCC_GET_USART3_SOURCE()) \ 360 { \ 361 case RCC_USART3CLKSOURCE_PCLK1: \ 362 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1; \ 363 break; \ 364 case RCC_USART3CLKSOURCE_HSI: \ 365 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 366 break; \ 367 case RCC_USART3CLKSOURCE_SYSCLK: \ 368 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK; \ 369 break; \ 370 case RCC_USART3CLKSOURCE_LSE: \ 371 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 372 break; \ 373 default: \ 374 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 375 break; \ 376 } \ 377 } \ 378 else if((__HANDLE__)->Instance == UART4) \ 379 { \ 380 switch(__HAL_RCC_GET_UART4_SOURCE()) \ 381 { \ 382 case RCC_UART4CLKSOURCE_PCLK1: \ 383 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1; \ 384 break; \ 385 case RCC_UART4CLKSOURCE_HSI: \ 386 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 387 break; \ 388 case RCC_UART4CLKSOURCE_SYSCLK: \ 389 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK; \ 390 break; \ 391 case RCC_UART4CLKSOURCE_LSE: \ 392 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 393 break; \ 394 default: \ 395 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 396 break; \ 397 } \ 398 } \ 399 else \ 400 { \ 401 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 402 } \ 403 } while(0) 404 #endif /* STM32L471xx || STM32L475xx || STM32L476xx || STM32L485xx || STM32L486xx || 405 * STM32L496xx || STM32L4A6xx || 406 * STM32L4P5xx || STM32L4Q5xx || 407 * STM32L4R5xx || STM32L4R7xx || STM32L4R9xx || STM32L4S5xx || STM32L4S7xx || STM32L4S9xx 408 */ 409 410 /** @brief Compute the mask to apply to retrieve the received data 411 * according to the word length and to the parity bits activation. 412 * @param __HANDLE__ specifies the IRDA Handle. 413 * @retval None, the mask to apply to the associated UART RDR register is stored in (__HANDLE__)->Mask field. 414 */ 415 #define IRDA_MASK_COMPUTATION(__HANDLE__) \ 416 do { \ 417 if ((__HANDLE__)->Init.WordLength == IRDA_WORDLENGTH_9B) \ 418 { \ 419 if ((__HANDLE__)->Init.Parity == IRDA_PARITY_NONE) \ 420 { \ 421 (__HANDLE__)->Mask = 0x01FFU ; \ 422 } \ 423 else \ 424 { \ 425 (__HANDLE__)->Mask = 0x00FFU ; \ 426 } \ 427 } \ 428 else if ((__HANDLE__)->Init.WordLength == IRDA_WORDLENGTH_8B) \ 429 { \ 430 if ((__HANDLE__)->Init.Parity == IRDA_PARITY_NONE) \ 431 { \ 432 (__HANDLE__)->Mask = 0x00FFU ; \ 433 } \ 434 else \ 435 { \ 436 (__HANDLE__)->Mask = 0x007FU ; \ 437 } \ 438 } \ 439 else if ((__HANDLE__)->Init.WordLength == IRDA_WORDLENGTH_7B) \ 440 { \ 441 if ((__HANDLE__)->Init.Parity == IRDA_PARITY_NONE) \ 442 { \ 443 (__HANDLE__)->Mask = 0x007FU ; \ 444 } \ 445 else \ 446 { \ 447 (__HANDLE__)->Mask = 0x003FU ; \ 448 } \ 449 } \ 450 else \ 451 { \ 452 (__HANDLE__)->Mask = 0x0000U; \ 453 } \ 454 } while(0U) 455 456 /** @brief Ensure that IRDA frame length is valid. 457 * @param __LENGTH__ IRDA frame length. 458 * @retval SET (__LENGTH__ is valid) or RESET (__LENGTH__ is invalid) 459 */ 460 #define IS_IRDA_WORD_LENGTH(__LENGTH__) (((__LENGTH__) == IRDA_WORDLENGTH_7B) || \ 461 ((__LENGTH__) == IRDA_WORDLENGTH_8B) || \ 462 ((__LENGTH__) == IRDA_WORDLENGTH_9B)) 463 /** 464 * @} 465 */ 466 467 /* Exported functions --------------------------------------------------------*/ 468 469 /** 470 * @} 471 */ 472 473 /** 474 * @} 475 */ 476 477 #ifdef __cplusplus 478 } 479 #endif 480 481 #endif /* STM32L4xx_HAL_IRDA_EX_H */ 482 483
