1 /** 2 ****************************************************************************** 3 * @file stm32g4xx_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) 2019 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 STM32G4xx_HAL_IRDA_EX_H 21 #define STM32G4xx_HAL_IRDA_EX_H 22 23 #ifdef __cplusplus 24 extern "C" { 25 #endif 26 27 /* Includes ------------------------------------------------------------------*/ 28 #include "stm32g4xx_hal_def.h" 29 30 /** @addtogroup STM32G4xx_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(UART5) && !defined(USART3) 73 #define IRDA_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__) \ 74 do { \ 75 if((__HANDLE__)->Instance == USART1) \ 76 { \ 77 switch(__HAL_RCC_GET_USART1_SOURCE()) \ 78 { \ 79 case RCC_USART1CLKSOURCE_PCLK2: \ 80 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK2; \ 81 break; \ 82 case RCC_USART1CLKSOURCE_HSI: \ 83 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 84 break; \ 85 case RCC_USART1CLKSOURCE_SYSCLK: \ 86 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK; \ 87 break; \ 88 case RCC_USART1CLKSOURCE_LSE: \ 89 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 90 break; \ 91 default: \ 92 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 93 break; \ 94 } \ 95 } \ 96 else if((__HANDLE__)->Instance == USART2) \ 97 { \ 98 switch(__HAL_RCC_GET_USART2_SOURCE()) \ 99 { \ 100 case RCC_USART2CLKSOURCE_PCLK1: \ 101 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1; \ 102 break; \ 103 case RCC_USART2CLKSOURCE_HSI: \ 104 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 105 break; \ 106 case RCC_USART2CLKSOURCE_SYSCLK: \ 107 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK; \ 108 break; \ 109 case RCC_USART2CLKSOURCE_LSE: \ 110 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 111 break; \ 112 default: \ 113 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 114 break; \ 115 } \ 116 } \ 117 else if((__HANDLE__)->Instance == UART4) \ 118 { \ 119 switch(__HAL_RCC_GET_UART4_SOURCE()) \ 120 { \ 121 case RCC_UART4CLKSOURCE_PCLK1: \ 122 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1; \ 123 break; \ 124 case RCC_UART4CLKSOURCE_HSI: \ 125 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 126 break; \ 127 case RCC_UART4CLKSOURCE_SYSCLK: \ 128 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK; \ 129 break; \ 130 case RCC_UART4CLKSOURCE_LSE: \ 131 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 132 break; \ 133 default: \ 134 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 135 break; \ 136 } \ 137 } \ 138 else if((__HANDLE__)->Instance == UART5) \ 139 { \ 140 switch(__HAL_RCC_GET_UART5_SOURCE()) \ 141 { \ 142 case RCC_UART5CLKSOURCE_PCLK1: \ 143 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1; \ 144 break; \ 145 case RCC_UART5CLKSOURCE_HSI: \ 146 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 147 break; \ 148 case RCC_UART5CLKSOURCE_SYSCLK: \ 149 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK; \ 150 break; \ 151 case RCC_UART5CLKSOURCE_LSE: \ 152 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 153 break; \ 154 default: \ 155 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 156 break; \ 157 } \ 158 } \ 159 else \ 160 { \ 161 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 162 } \ 163 } while(0U) 164 #elif defined(UART5) && defined(USART3) 165 #define IRDA_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__) \ 166 do { \ 167 if((__HANDLE__)->Instance == USART1) \ 168 { \ 169 switch(__HAL_RCC_GET_USART1_SOURCE()) \ 170 { \ 171 case RCC_USART1CLKSOURCE_PCLK2: \ 172 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK2; \ 173 break; \ 174 case RCC_USART1CLKSOURCE_HSI: \ 175 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 176 break; \ 177 case RCC_USART1CLKSOURCE_SYSCLK: \ 178 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK; \ 179 break; \ 180 case RCC_USART1CLKSOURCE_LSE: \ 181 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 182 break; \ 183 default: \ 184 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 185 break; \ 186 } \ 187 } \ 188 else if((__HANDLE__)->Instance == USART2) \ 189 { \ 190 switch(__HAL_RCC_GET_USART2_SOURCE()) \ 191 { \ 192 case RCC_USART2CLKSOURCE_PCLK1: \ 193 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1; \ 194 break; \ 195 case RCC_USART2CLKSOURCE_HSI: \ 196 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 197 break; \ 198 case RCC_USART2CLKSOURCE_SYSCLK: \ 199 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK; \ 200 break; \ 201 case RCC_USART2CLKSOURCE_LSE: \ 202 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 203 break; \ 204 default: \ 205 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 206 break; \ 207 } \ 208 } \ 209 else if((__HANDLE__)->Instance == USART3) \ 210 { \ 211 switch(__HAL_RCC_GET_USART3_SOURCE()) \ 212 { \ 213 case RCC_USART3CLKSOURCE_PCLK1: \ 214 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1; \ 215 break; \ 216 case RCC_USART3CLKSOURCE_HSI: \ 217 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 218 break; \ 219 case RCC_USART3CLKSOURCE_SYSCLK: \ 220 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK; \ 221 break; \ 222 case RCC_USART3CLKSOURCE_LSE: \ 223 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 224 break; \ 225 default: \ 226 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 227 break; \ 228 } \ 229 } \ 230 else if((__HANDLE__)->Instance == UART4) \ 231 { \ 232 switch(__HAL_RCC_GET_UART4_SOURCE()) \ 233 { \ 234 case RCC_UART4CLKSOURCE_PCLK1: \ 235 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1; \ 236 break; \ 237 case RCC_UART4CLKSOURCE_HSI: \ 238 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 239 break; \ 240 case RCC_UART4CLKSOURCE_SYSCLK: \ 241 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK; \ 242 break; \ 243 case RCC_UART4CLKSOURCE_LSE: \ 244 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 245 break; \ 246 default: \ 247 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 248 break; \ 249 } \ 250 } \ 251 else if((__HANDLE__)->Instance == UART5) \ 252 { \ 253 switch(__HAL_RCC_GET_UART5_SOURCE()) \ 254 { \ 255 case RCC_UART5CLKSOURCE_PCLK1: \ 256 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1; \ 257 break; \ 258 case RCC_UART5CLKSOURCE_HSI: \ 259 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 260 break; \ 261 case RCC_UART5CLKSOURCE_SYSCLK: \ 262 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK; \ 263 break; \ 264 case RCC_UART5CLKSOURCE_LSE: \ 265 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 266 break; \ 267 default: \ 268 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 269 break; \ 270 } \ 271 } \ 272 else \ 273 { \ 274 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 275 } \ 276 } while(0U) 277 #elif defined(UART4) && !defined(USART3) 278 #define IRDA_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__) \ 279 do { \ 280 if((__HANDLE__)->Instance == USART1) \ 281 { \ 282 switch(__HAL_RCC_GET_USART1_SOURCE()) \ 283 { \ 284 case RCC_USART1CLKSOURCE_PCLK2: \ 285 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK2; \ 286 break; \ 287 case RCC_USART1CLKSOURCE_HSI: \ 288 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 289 break; \ 290 case RCC_USART1CLKSOURCE_SYSCLK: \ 291 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK; \ 292 break; \ 293 case RCC_USART1CLKSOURCE_LSE: \ 294 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 295 break; \ 296 default: \ 297 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 298 break; \ 299 } \ 300 } \ 301 else if((__HANDLE__)->Instance == USART2) \ 302 { \ 303 switch(__HAL_RCC_GET_USART2_SOURCE()) \ 304 { \ 305 case RCC_USART2CLKSOURCE_PCLK1: \ 306 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1; \ 307 break; \ 308 case RCC_USART2CLKSOURCE_HSI: \ 309 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 310 break; \ 311 case RCC_USART2CLKSOURCE_SYSCLK: \ 312 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK; \ 313 break; \ 314 case RCC_USART2CLKSOURCE_LSE: \ 315 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 316 break; \ 317 default: \ 318 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 319 break; \ 320 } \ 321 } \ 322 else if((__HANDLE__)->Instance == UART4) \ 323 { \ 324 switch(__HAL_RCC_GET_UART4_SOURCE()) \ 325 { \ 326 case RCC_UART4CLKSOURCE_PCLK1: \ 327 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1; \ 328 break; \ 329 case RCC_UART4CLKSOURCE_HSI: \ 330 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 331 break; \ 332 case RCC_UART4CLKSOURCE_SYSCLK: \ 333 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK; \ 334 break; \ 335 case RCC_UART4CLKSOURCE_LSE: \ 336 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 337 break; \ 338 default: \ 339 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 340 break; \ 341 } \ 342 } \ 343 else \ 344 { \ 345 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 346 } \ 347 } while(0U) 348 #elif defined(UART4) && defined(USART3) 349 #define IRDA_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__) \ 350 do { \ 351 if((__HANDLE__)->Instance == USART1) \ 352 { \ 353 switch(__HAL_RCC_GET_USART1_SOURCE()) \ 354 { \ 355 case RCC_USART1CLKSOURCE_PCLK2: \ 356 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK2; \ 357 break; \ 358 case RCC_USART1CLKSOURCE_HSI: \ 359 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 360 break; \ 361 case RCC_USART1CLKSOURCE_SYSCLK: \ 362 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK; \ 363 break; \ 364 case RCC_USART1CLKSOURCE_LSE: \ 365 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 366 break; \ 367 default: \ 368 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 369 break; \ 370 } \ 371 } \ 372 else if((__HANDLE__)->Instance == USART2) \ 373 { \ 374 switch(__HAL_RCC_GET_USART2_SOURCE()) \ 375 { \ 376 case RCC_USART2CLKSOURCE_PCLK1: \ 377 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1; \ 378 break; \ 379 case RCC_USART2CLKSOURCE_HSI: \ 380 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 381 break; \ 382 case RCC_USART2CLKSOURCE_SYSCLK: \ 383 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK; \ 384 break; \ 385 case RCC_USART2CLKSOURCE_LSE: \ 386 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 387 break; \ 388 default: \ 389 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 390 break; \ 391 } \ 392 } \ 393 else if((__HANDLE__)->Instance == USART3) \ 394 { \ 395 switch(__HAL_RCC_GET_USART3_SOURCE()) \ 396 { \ 397 case RCC_USART3CLKSOURCE_PCLK1: \ 398 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1; \ 399 break; \ 400 case RCC_USART3CLKSOURCE_HSI: \ 401 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 402 break; \ 403 case RCC_USART3CLKSOURCE_SYSCLK: \ 404 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK; \ 405 break; \ 406 case RCC_USART3CLKSOURCE_LSE: \ 407 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 408 break; \ 409 default: \ 410 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 411 break; \ 412 } \ 413 } \ 414 else if((__HANDLE__)->Instance == UART4) \ 415 { \ 416 switch(__HAL_RCC_GET_UART4_SOURCE()) \ 417 { \ 418 case RCC_UART4CLKSOURCE_PCLK1: \ 419 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1; \ 420 break; \ 421 case RCC_UART4CLKSOURCE_HSI: \ 422 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 423 break; \ 424 case RCC_UART4CLKSOURCE_SYSCLK: \ 425 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK; \ 426 break; \ 427 case RCC_UART4CLKSOURCE_LSE: \ 428 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 429 break; \ 430 default: \ 431 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 432 break; \ 433 } \ 434 } \ 435 else \ 436 { \ 437 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 438 } \ 439 } while(0U) 440 #elif defined(USART3) 441 #define IRDA_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__) \ 442 do { \ 443 if((__HANDLE__)->Instance == USART1) \ 444 { \ 445 switch(__HAL_RCC_GET_USART1_SOURCE()) \ 446 { \ 447 case RCC_USART1CLKSOURCE_PCLK2: \ 448 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK2; \ 449 break; \ 450 case RCC_USART1CLKSOURCE_HSI: \ 451 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 452 break; \ 453 case RCC_USART1CLKSOURCE_SYSCLK: \ 454 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK; \ 455 break; \ 456 case RCC_USART1CLKSOURCE_LSE: \ 457 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 458 break; \ 459 default: \ 460 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 461 break; \ 462 } \ 463 } \ 464 else if((__HANDLE__)->Instance == USART2) \ 465 { \ 466 switch(__HAL_RCC_GET_USART2_SOURCE()) \ 467 { \ 468 case RCC_USART2CLKSOURCE_PCLK1: \ 469 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1; \ 470 break; \ 471 case RCC_USART2CLKSOURCE_HSI: \ 472 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 473 break; \ 474 case RCC_USART2CLKSOURCE_SYSCLK: \ 475 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK; \ 476 break; \ 477 case RCC_USART2CLKSOURCE_LSE: \ 478 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 479 break; \ 480 default: \ 481 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 482 break; \ 483 } \ 484 } \ 485 else if((__HANDLE__)->Instance == USART3) \ 486 { \ 487 switch(__HAL_RCC_GET_USART3_SOURCE()) \ 488 { \ 489 case RCC_USART3CLKSOURCE_PCLK1: \ 490 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1; \ 491 break; \ 492 case RCC_USART3CLKSOURCE_HSI: \ 493 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 494 break; \ 495 case RCC_USART3CLKSOURCE_SYSCLK: \ 496 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK; \ 497 break; \ 498 case RCC_USART3CLKSOURCE_LSE: \ 499 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 500 break; \ 501 default: \ 502 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 503 break; \ 504 } \ 505 } \ 506 else \ 507 { \ 508 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 509 } \ 510 } while(0U) 511 #else 512 #define IRDA_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__) \ 513 do { \ 514 if((__HANDLE__)->Instance == USART1) \ 515 { \ 516 switch(__HAL_RCC_GET_USART1_SOURCE()) \ 517 { \ 518 case RCC_USART1CLKSOURCE_PCLK2: \ 519 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK2; \ 520 break; \ 521 case RCC_USART1CLKSOURCE_HSI: \ 522 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 523 break; \ 524 case RCC_USART1CLKSOURCE_SYSCLK: \ 525 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK; \ 526 break; \ 527 case RCC_USART1CLKSOURCE_LSE: \ 528 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 529 break; \ 530 default: \ 531 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 532 break; \ 533 } \ 534 } \ 535 else if((__HANDLE__)->Instance == USART2) \ 536 { \ 537 switch(__HAL_RCC_GET_USART2_SOURCE()) \ 538 { \ 539 case RCC_USART2CLKSOURCE_PCLK1: \ 540 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1; \ 541 break; \ 542 case RCC_USART2CLKSOURCE_HSI: \ 543 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI; \ 544 break; \ 545 case RCC_USART2CLKSOURCE_SYSCLK: \ 546 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK; \ 547 break; \ 548 case RCC_USART2CLKSOURCE_LSE: \ 549 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE; \ 550 break; \ 551 default: \ 552 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 553 break; \ 554 } \ 555 } \ 556 else \ 557 { \ 558 (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED; \ 559 } \ 560 } while(0U) 561 #endif /* UART5 && !USART3 */ 562 563 /** @brief Compute the mask to apply to retrieve the received data 564 * according to the word length and to the parity bits activation. 565 * @param __HANDLE__ specifies the IRDA Handle. 566 * @retval None, the mask to apply to the associated UART RDR register is stored in (__HANDLE__)->Mask field. 567 */ 568 #define IRDA_MASK_COMPUTATION(__HANDLE__) \ 569 do { \ 570 if ((__HANDLE__)->Init.WordLength == IRDA_WORDLENGTH_9B) \ 571 { \ 572 if ((__HANDLE__)->Init.Parity == IRDA_PARITY_NONE) \ 573 { \ 574 (__HANDLE__)->Mask = 0x01FFU ; \ 575 } \ 576 else \ 577 { \ 578 (__HANDLE__)->Mask = 0x00FFU ; \ 579 } \ 580 } \ 581 else if ((__HANDLE__)->Init.WordLength == IRDA_WORDLENGTH_8B) \ 582 { \ 583 if ((__HANDLE__)->Init.Parity == IRDA_PARITY_NONE) \ 584 { \ 585 (__HANDLE__)->Mask = 0x00FFU ; \ 586 } \ 587 else \ 588 { \ 589 (__HANDLE__)->Mask = 0x007FU ; \ 590 } \ 591 } \ 592 else if ((__HANDLE__)->Init.WordLength == IRDA_WORDLENGTH_7B) \ 593 { \ 594 if ((__HANDLE__)->Init.Parity == IRDA_PARITY_NONE) \ 595 { \ 596 (__HANDLE__)->Mask = 0x007FU ; \ 597 } \ 598 else \ 599 { \ 600 (__HANDLE__)->Mask = 0x003FU ; \ 601 } \ 602 } \ 603 else \ 604 { \ 605 (__HANDLE__)->Mask = 0x0000U; \ 606 } \ 607 } while(0U) 608 609 /** @brief Ensure that IRDA frame length is valid. 610 * @param __LENGTH__ IRDA frame length. 611 * @retval SET (__LENGTH__ is valid) or RESET (__LENGTH__ is invalid) 612 */ 613 #define IS_IRDA_WORD_LENGTH(__LENGTH__) (((__LENGTH__) == IRDA_WORDLENGTH_7B) || \ 614 ((__LENGTH__) == IRDA_WORDLENGTH_8B) || \ 615 ((__LENGTH__) == IRDA_WORDLENGTH_9B)) 616 /** 617 * @} 618 */ 619 620 /* Exported functions --------------------------------------------------------*/ 621 622 /** 623 * @} 624 */ 625 626 /** 627 * @} 628 */ 629 630 #ifdef __cplusplus 631 } 632 #endif 633 634 #endif /* STM32G4xx_HAL_IRDA_EX_H */ 635 636
