tmk_core/tool/mbed/mbed-sdk/libraries/mbed/targets/cmsis/TARGET_STM/TARGET_STM32F3/stm32f3xx_hal_irda_ex.h

   1 /**
   2   ******************************************************************************
   3   * @file    stm32f3xx_hal_irda_ex.h
   4   * @author  MCD Application Team
   5   * @version V1.1.0
   6   * @date    12-Sept-2014
   7   * @brief   Header file of IRDA HAL Extended module.
   8   ******************************************************************************
   9   * @attention
  10   *
  11   * <h2><center>&copy; COPYRIGHT(c) 2014 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
  38 /* Define to prevent recursive inclusion -------------------------------------*/
  39 #ifndef __STM32F3xx_HAL_IRDA_EX_H
  40 #define __STM32F3xx_HAL_IRDA_EX_H
  41
  42 #ifdef __cplusplus
  43  extern "C" {
  44 #endif
  45
  46 /* Includes ------------------------------------------------------------------*/
  47 #include "stm32f3xx_hal_def.h"
  48
  49 /** @addtogroup STM32F3xx_HAL_Driver
  50   * @{
  51   */
  52
  53 /** @addtogroup IRDAEx IRDA Extended HAL module driver
  54   * @{
  55   */
  56
  57 /* Exported types ------------------------------------------------------------*/
  58 /* Exported constants --------------------------------------------------------*/
  59 /** @defgroup IRDAEx_Exported_Constants IRDA Extended Exported Constants
  60   * @{
  61   */
  62
  63 /** @defgroup IRDAEx_Word_Length IRDA Extended Word Length
  64   * @{
  65   */
  66 #if defined(STM32F302xE) || defined(STM32F303xE) || defined(STM32F398xx) || \
  67     defined(STM32F334x8)                                                 || \
  68     defined(STM32F301x8) || defined(STM32F302x8) || defined(STM32F318xx)
  69 #define IRDA_WORDLENGTH_7B                  ((uint32_t)USART_CR1_M1)
  70 #define IRDA_WORDLENGTH_8B                  ((uint32_t)0x00000000)
  71 #define IRDA_WORDLENGTH_9B                  ((uint32_t)USART_CR1_M0)
  72 #define IS_IRDA_WORD_LENGTH(LENGTH) (((LENGTH) == IRDA_WORDLENGTH_7B) || \
  73                                      ((LENGTH) == IRDA_WORDLENGTH_8B) || \
  74                                      ((LENGTH) == IRDA_WORDLENGTH_9B))
  75 #else
  76 #define IRDA_WORDLENGTH_8B                  ((uint32_t)0x00000000)
  77 #define IRDA_WORDLENGTH_9B                  ((uint32_t)USART_CR1_M)
  78 #define IS_IRDA_WORD_LENGTH(LENGTH) (((LENGTH) == IRDA_WORDLENGTH_8B) || \
  79                                      ((LENGTH) == IRDA_WORDLENGTH_9B))
  80 #endif /* STM32F302xE || STM32F303xE || STM32F398xx || */
  81        /* STM32F334x8                               || */
  82        /* STM32F301x8 || STM32F302x8 || STM32F318xx    */
  83 /**
  84   * @}
  85   */
  86
  87
  88 /**
  89   * @}
  90   */
  91
  92 /* Exported macros -----------------------------------------------------------*/
  93
  94 /** @defgroup IRDAEx_Exported_Macros IRDA Extended Exported Macros
  95   * @{
  96   */
  97
  98 /** @brief  Reports the IRDA clock source.
  99   * @param  __HANDLE__: specifies the IRDA Handle
 100   * @param  __CLOCKSOURCE__ : output variable
 101   * @retval IRDA clocking source, written in __CLOCKSOURCE__.
 102   */
 103 #if defined(STM32F302xE) || defined(STM32F303xE) || defined(STM32F398xx) || \
 104     defined(STM32F302xC) || defined(STM32F303xC) || defined(STM32F358xx)
 105 #define __HAL_IRDA_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__) \
 106   do {                                                        \
 107     if((__HANDLE__)->Instance == USART1)                      \
 108     {                                                         \
 109        switch(__HAL_RCC_GET_USART1_SOURCE())                  \
 110        {                                                      \
 111         case RCC_USART1CLKSOURCE_PCLK2:                       \
 112           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK2;         \
 113           break;                                              \
 114         case RCC_USART1CLKSOURCE_HSI:                         \
 115           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI;           \
 116           break;                                              \
 117         case RCC_USART1CLKSOURCE_SYSCLK:                      \
 118           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK;        \
 119           break;                                              \
 120         case RCC_USART1CLKSOURCE_LSE:                         \
 121           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE;           \
 122           break;                                              \
 123        }                                                      \
 124     }                                                         \
 125     else if((__HANDLE__)->Instance == USART2)                 \
 126     {                                                         \
 127        switch(__HAL_RCC_GET_USART2_SOURCE())                  \
 128        {                                                      \
 129         case RCC_USART2CLKSOURCE_PCLK1:                       \
 130           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1;         \
 131           break;                                              \
 132         case RCC_USART2CLKSOURCE_HSI:                         \
 133           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI;           \
 134           break;                                              \
 135         case RCC_USART2CLKSOURCE_SYSCLK:                      \
 136           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK;        \
 137           break;                                              \
 138         case RCC_USART2CLKSOURCE_LSE:                         \
 139           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE;           \
 140           break;                                              \
 141        }                                                      \
 142     }                                                         \
 143     else if((__HANDLE__)->Instance == USART3)                 \
 144     {                                                         \
 145        switch(__HAL_RCC_GET_USART3_SOURCE())                  \
 146        {                                                      \
 147         case RCC_USART3CLKSOURCE_PCLK1:                       \
 148           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1;         \
 149           break;                                              \
 150         case RCC_USART3CLKSOURCE_HSI:                         \
 151           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI;           \
 152           break;                                              \
 153         case RCC_USART3CLKSOURCE_SYSCLK:                      \
 154           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK;        \
 155           break;                                              \
 156         case RCC_USART3CLKSOURCE_LSE:                         \
 157           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE;           \
 158           break;                                              \
 159        }                                                      \
 160     }                                                         \
 161     else if((__HANDLE__)->Instance == UART4)                  \
 162     {                                                         \
 163        switch(__HAL_RCC_GET_UART4_SOURCE())                   \
 164        {                                                      \
 165         case RCC_UART4CLKSOURCE_PCLK1:                        \
 166           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1;         \
 167           break;                                              \
 168         case RCC_UART4CLKSOURCE_HSI:                          \
 169           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI;           \
 170           break;                                              \
 171         case RCC_UART4CLKSOURCE_SYSCLK:                       \
 172           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK;        \
 173           break;                                              \
 174         case RCC_UART4CLKSOURCE_LSE:                          \
 175           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE;           \
 176           break;                                              \
 177        }                                                      \
 178     }                                                         \
 179     else if ((__HANDLE__)->Instance == UART5)                 \
 180     {                                                         \
 181        switch(__HAL_RCC_GET_UART5_SOURCE())                   \
 182        {                                                      \
 183         case RCC_UART5CLKSOURCE_PCLK1:                        \
 184           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1;         \
 185           break;                                              \
 186         case RCC_UART5CLKSOURCE_HSI:                          \
 187           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI;           \
 188           break;                                              \
 189         case RCC_UART5CLKSOURCE_SYSCLK:                       \
 190           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK;        \
 191           break;                                              \
 192         case RCC_UART5CLKSOURCE_LSE:                          \
 193           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE;           \
 194           break;                                              \
 195        }                                                      \
 196     }                                                         \
 197   } while(0)
 198 #elif defined(STM32F303x8) || defined(STM32F334x8) ||defined(STM32F328xx)
 199 #define __HAL_IRDA_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__) \
 200   do {                                                        \
 201     if((__HANDLE__)->Instance == USART1)                      \
 202     {                                                         \
 203        switch(__HAL_RCC_GET_USART1_SOURCE())                  \
 204        {                                                      \
 205         case RCC_USART1CLKSOURCE_PCLK1:                       \
 206           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1;         \
 207           break;                                              \
 208         case RCC_USART1CLKSOURCE_HSI:                         \
 209           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI;           \
 210           break;                                              \
 211         case RCC_USART1CLKSOURCE_SYSCLK:                      \
 212           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK;        \
 213           break;                                              \
 214         case RCC_USART1CLKSOURCE_LSE:                         \
 215           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE;           \
 216           break;                                              \
 217        }                                                      \
 218     }                                                         \
 219     else if((__HANDLE__)->Instance == USART2)                 \
 220     {                                                         \
 221        switch(__HAL_RCC_GET_USART2_SOURCE())                  \
 222        {                                                      \
 223         case RCC_USART2CLKSOURCE_PCLK1:                       \
 224           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1;         \
 225           break;                                              \
 226         case RCC_USART2CLKSOURCE_HSI:                         \
 227           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI;           \
 228           break;                                              \
 229         case RCC_USART2CLKSOURCE_SYSCLK:                      \
 230           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK;        \
 231           break;                                              \
 232         case RCC_USART2CLKSOURCE_LSE:                         \
 233           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE;           \
 234           break;                                              \
 235        }                                                      \
 236     }                                                         \
 237     else if((__HANDLE__)->Instance == USART3)                 \
 238     {                                                         \
 239        switch(__HAL_RCC_GET_USART3_SOURCE())                  \
 240        {                                                      \
 241         case RCC_USART3CLKSOURCE_PCLK1:                       \
 242           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1;         \
 243           break;                                              \
 244         case RCC_USART3CLKSOURCE_HSI:                         \
 245           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI;           \
 246           break;                                              \
 247         case RCC_USART3CLKSOURCE_SYSCLK:                      \
 248           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK;        \
 249           break;                                              \
 250         case RCC_USART3CLKSOURCE_LSE:                         \
 251           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE;           \
 252           break;                                              \
 253        }                                                      \
 254     }                                                         \
 255   } while(0)
 256 #else
 257 #define __HAL_IRDA_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__) \
 258   do {                                                        \
 259     if((__HANDLE__)->Instance == USART1)                      \
 260     {                                                         \
 261        switch(__HAL_RCC_GET_USART1_SOURCE())                  \
 262        {                                                      \
 263         case RCC_USART1CLKSOURCE_PCLK2:                       \
 264           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK2;         \
 265           break;                                              \
 266         case RCC_USART1CLKSOURCE_HSI:                         \
 267           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI;           \
 268           break;                                              \
 269         case RCC_USART1CLKSOURCE_SYSCLK:                      \
 270           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK;        \
 271           break;                                              \
 272         case RCC_USART1CLKSOURCE_LSE:                         \
 273           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE;           \
 274           break;                                              \
 275        }                                                      \
 276     }                                                         \
 277     else if((__HANDLE__)->Instance == USART2)                 \
 278     {                                                         \
 279        switch(__HAL_RCC_GET_USART2_SOURCE())                  \
 280        {                                                      \
 281         case RCC_USART2CLKSOURCE_PCLK1:                       \
 282           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1;         \
 283           break;                                              \
 284         case RCC_USART2CLKSOURCE_HSI:                         \
 285           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI;           \
 286           break;                                              \
 287         case RCC_USART2CLKSOURCE_SYSCLK:                      \
 288           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK;        \
 289           break;                                              \
 290         case RCC_USART2CLKSOURCE_LSE:                         \
 291           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE;           \
 292           break;                                              \
 293        }                                                      \
 294     }                                                         \
 295     else if((__HANDLE__)->Instance == USART3)                 \
 296     {                                                         \
 297        switch(__HAL_RCC_GET_USART3_SOURCE())                  \
 298        {                                                      \
 299         case RCC_USART3CLKSOURCE_PCLK1:                       \
 300           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1;         \
 301           break;                                              \
 302         case RCC_USART3CLKSOURCE_HSI:                         \
 303           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI;           \
 304           break;                                              \
 305         case RCC_USART3CLKSOURCE_SYSCLK:                      \
 306           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK;        \
 307           break;                                              \
 308         case RCC_USART3CLKSOURCE_LSE:                         \
 309           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE;           \
 310           break;                                              \
 311        }                                                      \
 312     }                                                         \
 313   } while(0)
 314 #endif /* STM32F302xE || STM32F303xE || STM32F398xx || */
 315        /* STM32F302xC || STM32F303xC || STM32F358xx || */
 316
 317
 318 /** @brief  Computes the mask to apply to retrieve the received data
 319   *         according to the word length and to the parity bits activation.
 320   * @param  __HANDLE__: specifies the IRDA Handle
 321   * @retval none
 322   */
 323 #if defined(STM32F302xE) || defined(STM32F303xE) || defined(STM32F398xx) || \
 324     defined(STM32F301x8) || defined(STM32F302x8) || defined(STM32F318xx) || \
 325     defined(STM32F334x8)
 326 #define __HAL_IRDA_MASK_COMPUTATION(__HANDLE__)                       \
 327   do {                                                                \
 328   if ((__HANDLE__)->Init.WordLength == IRDA_WORDLENGTH_9B)            \
 329   {                                                                   \
 330      if ((__HANDLE__)->Init.Parity == IRDA_PARITY_NONE)               \
 331      {                                                                \
 332         (__HANDLE__)->Mask = 0x01FF ;                                 \
 333      }                                                                \
 334      else                                                             \
 335      {                                                                \
 336         (__HANDLE__)->Mask = 0x00FF ;                                 \
 337      }                                                                \
 338   }                                                                   \
 339   else if ((__HANDLE__)->Init.WordLength == IRDA_WORDLENGTH_8B)       \
 340   {                                                                   \
 341      if ((__HANDLE__)->Init.Parity == IRDA_PARITY_NONE)               \
 342      {                                                                \
 343         (__HANDLE__)->Mask = 0x00FF ;                                 \
 344      }                                                                \
 345      else                                                             \
 346      {                                                                \
 347         (__HANDLE__)->Mask = 0x007F ;                                 \
 348      }                                                                \
 349   }                                                                   \
 350   else if ((__HANDLE__)->Init.WordLength == IRDA_WORDLENGTH_7B)       \
 351   {                                                                   \
 352      if ((__HANDLE__)->Init.Parity == IRDA_PARITY_NONE)               \
 353      {                                                                \
 354         (__HANDLE__)->Mask = 0x007F ;                                 \
 355      }                                                                \
 356      else                                                             \
 357      {                                                                \
 358         (__HANDLE__)->Mask = 0x003F ;                                 \
 359      }                                                                \
 360   }                                                                   \
 361 } while(0)
 362 #else
 363 #define __HAL_IRDA_MASK_COMPUTATION(__HANDLE__)                       \
 364   do {                                                                \
 365   if ((__HANDLE__)->Init.WordLength == IRDA_WORDLENGTH_9B)            \
 366   {                                                                   \
 367      if ((__HANDLE__)->Init.Parity == IRDA_PARITY_NONE)               \
 368      {                                                                \
 369         (__HANDLE__)->Mask = 0x01FF ;                                 \
 370      }                                                                \
 371      else                                                             \
 372      {                                                                \
 373         (__HANDLE__)->Mask = 0x00FF ;                                 \
 374      }                                                                \
 375   }                                                                   \
 376   else if ((__HANDLE__)->Init.WordLength == IRDA_WORDLENGTH_8B)       \
 377   {                                                                   \
 378      if ((__HANDLE__)->Init.Parity == IRDA_PARITY_NONE)               \
 379      {                                                                \
 380         (__HANDLE__)->Mask = 0x00FF ;                                 \
 381      }                                                                \
 382      else                                                             \
 383      {                                                                \
 384         (__HANDLE__)->Mask = 0x007F ;                                 \
 385      }                                                                \
 386   }                                                                   \
 387 } while(0)
 388 #endif /* STM32F302xE || STM32F303xE || STM32F398xx || */
 389        /* STM32F301x8 || STM32F302x8 || STM32F318xx || */
 390        /* STM32F334x8                                  */
 391 /**
 392   * @}
 393   */
 394
 395 /* Exported functions --------------------------------------------------------*/
 396 /* Initialization and de-initialization functions  ****************************/
 397 /* IO operation functions *****************************************************/
 398 /* Peripheral Control functions ***********************************************/
 399 /* Peripheral State and Error functions ***************************************/
 400
 401 /**
 402   * @}
 403   */
 404
 405 /**
 406   * @}
 407   */
 408
 409 #ifdef __cplusplus
 410 }
 411 #endif
 412
 413 #endif /* __STM32F3xx_HAL_IRDA_EX_H */
 414
 415 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/