Subversion Repositories FuelGauge

Rev

Rev 2 | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. /**
  2.   ******************************************************************************
  3.   * @file    stm32f0xx_hal_irda_ex.h
  4.   * @author  MCD Application Team
  5.   * @brief   Header file of IRDA HAL Extended module.
  6.   ******************************************************************************
  7.   * @attention
  8.   *
  9.   * <h2><center>&copy; 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 STM32F0xx_HAL_IRDA_EX_H
  22. #define STM32F0xx_HAL_IRDA_EX_H
  23.  
  24. #ifdef __cplusplus
  25. extern "C" {
  26. #endif
  27.  
  28. #if defined(USART_IRDA_SUPPORT)
  29. /* Includes ------------------------------------------------------------------*/
  30. #include "stm32f0xx_hal_def.h"
  31.  
  32. /** @addtogroup STM32F0xx_HAL_Driver
  33.   * @{
  34.   */
  35.  
  36. /** @defgroup IRDAEx IRDAEx
  37.   * @brief IRDA Extended HAL module driver
  38.   * @{
  39.   */
  40.  
  41. /* Exported types ------------------------------------------------------------*/
  42. /* Exported constants --------------------------------------------------------*/
  43. /** @defgroup IRDAEx_Extended_Exported_Constants IRDAEx Extended Exported Constants
  44.   * @{
  45.   */
  46.  
  47. /** @defgroup IRDAEx_Word_Length IRDAEx Word Length
  48.   * @{
  49.   */
  50. #if defined(USART_CR1_M1)&&defined(USART_CR1_M0)
  51. #define IRDA_WORDLENGTH_7B                  USART_CR1_M1   /*!< 7-bit long frame */
  52. #define IRDA_WORDLENGTH_8B                  0x00000000U    /*!< 8-bit long frame */
  53. #define IRDA_WORDLENGTH_9B                  USART_CR1_M0   /*!< 9-bit long frame */
  54. #elif defined(USART_CR1_M)
  55. #define IRDA_WORDLENGTH_8B                  (0x00000000U)              /*!< 8-bit long frame */
  56. #define IRDA_WORDLENGTH_9B                  USART_CR1_M    /*!< 9-bit long frame */
  57. #endif
  58. /**
  59.   * @}
  60.   */
  61.  
  62. /**
  63.   * @}
  64.   */
  65.  
  66. /* Exported macros -----------------------------------------------------------*/
  67.  
  68. /* Private macros ------------------------------------------------------------*/
  69.  
  70. /** @defgroup IRDAEx_Private_Macros IRDAEx Private Macros
  71.   * @{
  72.   */
  73.  
  74. /** @brief  Report the IRDA clock source.
  75.   * @param  __HANDLE__ specifies the IRDA Handle.
  76.   * @param  __CLOCKSOURCE__ output variable.
  77.   * @retval IRDA clocking source, written in __CLOCKSOURCE__.
  78.   */
  79.  
  80. #if defined(STM32F031x6) || defined(STM32F038xx)
  81. #define IRDA_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__)       \
  82.   do {                                                        \
  83.      switch(__HAL_RCC_GET_USART1_SOURCE())                    \
  84.      {                                                        \
  85.       case RCC_USART1CLKSOURCE_PCLK1:                         \
  86.         (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1;           \
  87.         break;                                                \
  88.       case RCC_USART1CLKSOURCE_HSI:                           \
  89.         (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI;             \
  90.         break;                                                \
  91.       case RCC_USART1CLKSOURCE_SYSCLK:                        \
  92.         (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK;          \
  93.         break;                                                \
  94.       case RCC_USART1CLKSOURCE_LSE:                           \
  95.         (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE;             \
  96.         break;                                                \
  97.       default:                                                \
  98.         (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED;       \
  99.         break;                                                \
  100.      }                                                        \
  101.   } while(0)
  102. #elif defined (STM32F042x6) || defined (STM32F048xx) || defined (STM32F051x8) || defined (STM32F058xx)
  103. #define IRDA_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__)       \
  104.   do {                                                        \
  105.     if((__HANDLE__)->Instance == USART1)                      \
  106.     {                                                         \
  107.        switch(__HAL_RCC_GET_USART1_SOURCE())                  \
  108.        {                                                      \
  109.         case RCC_USART1CLKSOURCE_PCLK1:                       \
  110.           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1;         \
  111.           break;                                              \
  112.         case RCC_USART1CLKSOURCE_HSI:                         \
  113.           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI;           \
  114.           break;                                              \
  115.         case RCC_USART1CLKSOURCE_SYSCLK:                      \
  116.           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK;        \
  117.           break;                                              \
  118.         case RCC_USART1CLKSOURCE_LSE:                         \
  119.           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE;           \
  120.           break;                                              \
  121.         default:                                              \
  122.           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED;     \
  123.           break;                                              \
  124.        }                                                      \
  125.     }                                                         \
  126.     else if((__HANDLE__)->Instance == USART2)                 \
  127.     {                                                         \
  128.       (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1;             \
  129.     }                                                         \
  130.     else                                                      \
  131.     {                                                         \
  132.       (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED;         \
  133.     }                                                         \
  134.   } while(0)
  135. #elif defined(STM32F071xB) || defined(STM32F072xB) || defined(STM32F078xx)
  136. #define IRDA_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__)       \
  137.   do {                                                        \
  138.     if((__HANDLE__)->Instance == USART1)                      \
  139.     {                                                         \
  140.        switch(__HAL_RCC_GET_USART1_SOURCE())                  \
  141.        {                                                      \
  142.         case RCC_USART1CLKSOURCE_PCLK1:                       \
  143.           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1;         \
  144.           break;                                              \
  145.         case RCC_USART1CLKSOURCE_HSI:                         \
  146.           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI;           \
  147.           break;                                              \
  148.         case RCC_USART1CLKSOURCE_SYSCLK:                      \
  149.           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK;        \
  150.           break;                                              \
  151.         case RCC_USART1CLKSOURCE_LSE:                         \
  152.           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE;           \
  153.           break;                                              \
  154.         default:                                              \
  155.           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED;     \
  156.           break;                                              \
  157.        }                                                      \
  158.     }                                                         \
  159.     else if((__HANDLE__)->Instance == USART2)                 \
  160.     {                                                         \
  161.        switch(__HAL_RCC_GET_USART2_SOURCE())                  \
  162.        {                                                      \
  163.         case RCC_USART2CLKSOURCE_PCLK1:                       \
  164.           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1;         \
  165.           break;                                              \
  166.         case RCC_USART2CLKSOURCE_HSI:                         \
  167.           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI;           \
  168.           break;                                              \
  169.         case RCC_USART2CLKSOURCE_SYSCLK:                      \
  170.           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK;        \
  171.           break;                                              \
  172.         case RCC_USART2CLKSOURCE_LSE:                         \
  173.           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE;           \
  174.           break;                                              \
  175.         default:                                              \
  176.           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED;     \
  177.           break;                                              \
  178.        }                                                      \
  179.     }                                                         \
  180.     else if((__HANDLE__)->Instance == USART3)                 \
  181.     {                                                         \
  182.       (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1;             \
  183.     }                                                         \
  184.     else if((__HANDLE__)->Instance == USART4)                 \
  185.     {                                                         \
  186.       (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1;             \
  187.     }                                                         \
  188.     else                                                      \
  189.     {                                                         \
  190.       (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED;         \
  191.     }                                                         \
  192.   } while(0)
  193. #elif defined(STM32F091xC) || defined(STM32F098xx)
  194. #define IRDA_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__)       \
  195.   do {                                                        \
  196.     if((__HANDLE__)->Instance == USART1)                      \
  197.     {                                                         \
  198.        switch(__HAL_RCC_GET_USART1_SOURCE())                  \
  199.        {                                                      \
  200.         case RCC_USART1CLKSOURCE_PCLK1:                       \
  201.           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1;         \
  202.           break;                                              \
  203.         case RCC_USART1CLKSOURCE_HSI:                         \
  204.           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI;           \
  205.           break;                                              \
  206.         case RCC_USART1CLKSOURCE_SYSCLK:                      \
  207.           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK;        \
  208.           break;                                              \
  209.         case RCC_USART1CLKSOURCE_LSE:                         \
  210.           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE;           \
  211.           break;                                              \
  212.         default:                                              \
  213.           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED;     \
  214.           break;                                              \
  215.        }                                                      \
  216.     }                                                         \
  217.     else if((__HANDLE__)->Instance == USART2)                 \
  218.     {                                                         \
  219.        switch(__HAL_RCC_GET_USART2_SOURCE())                  \
  220.        {                                                      \
  221.         case RCC_USART2CLKSOURCE_PCLK1:                       \
  222.           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1;         \
  223.           break;                                              \
  224.         case RCC_USART2CLKSOURCE_HSI:                         \
  225.           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI;           \
  226.           break;                                              \
  227.         case RCC_USART2CLKSOURCE_SYSCLK:                      \
  228.           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK;        \
  229.           break;                                              \
  230.         case RCC_USART2CLKSOURCE_LSE:                         \
  231.           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE;           \
  232.           break;                                              \
  233.         default:                                              \
  234.           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED;     \
  235.           break;                                              \
  236.        }                                                      \
  237.     }                                                         \
  238.     else if((__HANDLE__)->Instance == USART3)                 \
  239.     {                                                         \
  240.        switch(__HAL_RCC_GET_USART3_SOURCE())                  \
  241.        {                                                      \
  242.         case RCC_USART3CLKSOURCE_PCLK1:                       \
  243.           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1;         \
  244.           break;                                              \
  245.         case RCC_USART3CLKSOURCE_HSI:                         \
  246.           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI;           \
  247.           break;                                              \
  248.         case RCC_USART3CLKSOURCE_SYSCLK:                      \
  249.           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK;        \
  250.           break;                                              \
  251.         case RCC_USART3CLKSOURCE_LSE:                         \
  252.           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE;           \
  253.           break;                                              \
  254.         default:                                              \
  255.           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED;     \
  256.           break;                                              \
  257.        }                                                      \
  258.     }                                                         \
  259.     else if((__HANDLE__)->Instance == USART4)                 \
  260.     {                                                         \
  261.       (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1;             \
  262.     }                                                         \
  263.     else if((__HANDLE__)->Instance == USART5)                 \
  264.     {                                                         \
  265.       (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1;             \
  266.     }                                                         \
  267.     else if((__HANDLE__)->Instance == USART6)                 \
  268.     {                                                         \
  269.       (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1;             \
  270.     }                                                         \
  271.     else if((__HANDLE__)->Instance == USART7)                 \
  272.     {                                                         \
  273.       (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1;             \
  274.     }                                                         \
  275.     else if((__HANDLE__)->Instance == USART8)                 \
  276.     {                                                         \
  277.       (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1;             \
  278.     }                                                         \
  279.     else                                                      \
  280.     {                                                         \
  281.       (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED;         \
  282.     }                                                         \
  283.   } while(0)
  284.  
  285. #endif /* defined(STM32F031x6) || defined(STM32F038xx) */
  286.  
  287.  
  288. /** @brief  Compute the mask to apply to retrieve the received data
  289.   *         according to the word length and to the parity bits activation.
  290.   * @note   If PCE = 1, the parity bit is not included in the data extracted
  291.   *         by the reception API().
  292.   *         This masking operation is not carried out in the case of
  293.   *         DMA transfers.
  294.   * @param  __HANDLE__ specifies the IRDA Handle.
  295.   * @retval None, the mask to apply to the associated UART RDR register is stored in (__HANDLE__)->Mask field.
  296.   */
  297. #if defined(USART_CR1_M1)&&defined(USART_CR1_M0)
  298. #define IRDA_MASK_COMPUTATION(__HANDLE__)                             \
  299.   do {                                                                \
  300.     if ((__HANDLE__)->Init.WordLength == IRDA_WORDLENGTH_9B)          \
  301.     {                                                                 \
  302.       if ((__HANDLE__)->Init.Parity == IRDA_PARITY_NONE)              \
  303.       {                                                               \
  304.         (__HANDLE__)->Mask = 0x01FFU ;                                \
  305.       }                                                               \
  306.       else                                                            \
  307.       {                                                               \
  308.         (__HANDLE__)->Mask = 0x00FFU ;                                \
  309.       }                                                               \
  310.     }                                                                 \
  311.     else if ((__HANDLE__)->Init.WordLength == IRDA_WORDLENGTH_8B)     \
  312.     {                                                                 \
  313.       if ((__HANDLE__)->Init.Parity == IRDA_PARITY_NONE)              \
  314.       {                                                               \
  315.         (__HANDLE__)->Mask = 0x00FFU ;                                \
  316.       }                                                               \
  317.       else                                                            \
  318.       {                                                               \
  319.         (__HANDLE__)->Mask = 0x007FU ;                                \
  320.       }                                                               \
  321.     }                                                                 \
  322.     else if ((__HANDLE__)->Init.WordLength == IRDA_WORDLENGTH_7B)     \
  323.     {                                                                 \
  324.       if ((__HANDLE__)->Init.Parity == IRDA_PARITY_NONE)              \
  325.       {                                                               \
  326.         (__HANDLE__)->Mask = 0x007FU ;                                \
  327.       }                                                               \
  328.       else                                                            \
  329.       {                                                               \
  330.         (__HANDLE__)->Mask = 0x003FU ;                                \
  331.       }                                                               \
  332.     }                                                                 \
  333.     else                                                              \
  334.     {                                                                 \
  335.       (__HANDLE__)->Mask = 0x0000U;                                   \
  336.     }                                                                 \
  337.   } while(0U)
  338. #elif defined(USART_CR1_M)
  339. #define IRDA_MASK_COMPUTATION(__HANDLE__)                             \
  340.   do {                                                                \
  341.   if ((__HANDLE__)->Init.WordLength == IRDA_WORDLENGTH_9B)            \
  342.   {                                                                   \
  343.      if ((__HANDLE__)->Init.Parity == IRDA_PARITY_NONE)               \
  344.      {                                                                \
  345.         (__HANDLE__)->Mask = 0x01FFU ;                                \
  346.      }                                                                \
  347.      else                                                             \
  348.      {                                                                \
  349.         (__HANDLE__)->Mask = 0x00FFU ;                                \
  350.      }                                                                \
  351.   }                                                                   \
  352.   else if ((__HANDLE__)->Init.WordLength == IRDA_WORDLENGTH_8B)       \
  353.   {                                                                   \
  354.      if ((__HANDLE__)->Init.Parity == IRDA_PARITY_NONE)               \
  355.      {                                                                \
  356.         (__HANDLE__)->Mask = 0x00FFU ;                                \
  357.      }                                                                \
  358.      else                                                             \
  359.      {                                                                \
  360.         (__HANDLE__)->Mask = 0x007FU ;                                \
  361.      }                                                                \
  362.   }                                                                   \
  363. } while(0U)
  364. #endif
  365.  
  366. /** @brief Ensure that IRDA frame length is valid.
  367.   * @param __LENGTH__ IRDA frame length.
  368.   * @retval SET (__LENGTH__ is valid) or RESET (__LENGTH__ is invalid)
  369.   */
  370. #if defined(USART_CR1_M1)&&defined(USART_CR1_M0)
  371. #define IS_IRDA_WORD_LENGTH(__LENGTH__) (((__LENGTH__) == IRDA_WORDLENGTH_7B) || \
  372.                                          ((__LENGTH__) == IRDA_WORDLENGTH_8B) || \
  373.                                          ((__LENGTH__) == IRDA_WORDLENGTH_9B))
  374. #elif defined(USART_CR1_M)
  375. #define IS_IRDA_WORD_LENGTH(__LENGTH__) (((__LENGTH__) == IRDA_WORDLENGTH_8B) || \
  376.                                          ((__LENGTH__) == IRDA_WORDLENGTH_9B))
  377. #endif
  378. /**
  379.   * @}
  380.   */
  381.  
  382. /* Exported functions --------------------------------------------------------*/
  383.  
  384. /**
  385.   * @}
  386.   */
  387.  
  388. /**
  389.   * @}
  390.   */
  391. #endif /* USART_IRDA_SUPPORT */  
  392.  
  393. #ifdef __cplusplus
  394. }
  395. #endif
  396.  
  397. #endif /* STM32F0xx_HAL_IRDA_EX_H */
  398.  
  399. /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
  400.