git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/CORTEX_M7_STM32F7_STM32756G-EVAL/ST_Library/include/stm32f7xx_hal_irda_ex.h

   1 /**\r
   2   ******************************************************************************\r
   3   * @file    stm32f7xx_hal_irda_ex.h\r
   4   * @author  MCD Application Team\r
   5   * @version V0.3.0\r
   6   * @date    06-March-2015\r
   7   * @brief   Header file of IRDA HAL Extension module.\r
   8   ******************************************************************************\r
   9   * @attention\r
  10   *                               \r
  11   * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>\r
  12   *\r
  13   * Redistribution and use in source and binary forms, with or without modification,\r
  14   * are permitted provided that the following conditions are met:\r
  15   *   1. Redistributions of source code must retain the above copyright notice,\r
  16   *      this list of conditions and the following disclaimer.\r
  17   *   2. Redistributions in binary form must reproduce the above copyright notice,\r
  18   *      this list of conditions and the following disclaimer in the documentation\r
  19   *      and/or other materials provided with the distribution.\r
  20   *   3. Neither the name of STMicroelectronics nor the names of its contributors\r
  21   *      may be used to endorse or promote products derived from this software\r
  22   *      without specific prior written permission.\r
  23   *\r
  24   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"\r
  25   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
  26   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\r
  27   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\r
  28   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\r
  29   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\r
  30   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\r
  31   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\r
  32   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\r
  33   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
  34   *\r
  35   ******************************************************************************  \r
  36   */\r
  37 \r
  38 /* Define to prevent recursive inclusion -------------------------------------*/\r
  39 #ifndef __STM32F7xx_HAL_IRDA_EX_H\r
  40 #define __STM32F7xx_HAL_IRDA_EX_H\r
  41 \r
  42 #ifdef __cplusplus\r
  43  extern "C" {\r
  44 #endif\r
  45 \r
  46 /* Includes ------------------------------------------------------------------*/\r
  47 #include "stm32f7xx_hal_def.h"\r
  48 \r
  49 /** @addtogroup STM32F7xx_HAL_Driver\r
  50   * @{\r
  51   */\r
  52 \r
  53 /** @addtogroup IRDAEx\r
  54   * @{\r
  55   */ \r
  56 \r
  57 /* Exported types ------------------------------------------------------------*/\r
  58 /* Exported constants --------------------------------------------------------*/\r
  59 /** @defgroup IRDAEx_Extended_Exported_Constants IRDAEx Extended Exported Constants\r
  60   * @{\r
  61   */\r
  62   \r
  63 /** @defgroup IRDAEx_Word_Length IRDAEx Word Length\r
  64   * @{\r
  65   */\r
  66 #define IRDA_WORDLENGTH_7B                  ((uint32_t)USART_CR1_M_1)\r
  67 #define IRDA_WORDLENGTH_8B                  ((uint32_t)0x00000000)\r
  68 #define IRDA_WORDLENGTH_9B                  ((uint32_t)USART_CR1_M_0)\r
  69 /**\r
  70   * @}\r
  71   */\r
  72   \r
  73   \r
  74 /**\r
  75   * @}\r
  76   */  \r
  77   \r
  78 /* Exported macro ------------------------------------------------------------*/\r
  79 \r
  80 /* Private macros ------------------------------------------------------------*/\r
  81 \r
  82 /** @defgroup IRDAEx_Private_Macros IRDAEx Private Macros\r
  83   * @{\r
  84   */\r
  85 /** @brief  Reports the IRDA clock source.\r
  86   * @param  __HANDLE__: specifies the IRDA Handle\r
  87   * @param  __CLOCKSOURCE__ : output variable\r
  88   * @retval IRDA clocking source, written in __CLOCKSOURCE__.\r
  89   */\r
  90 #define IRDA_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__)       \\r
  91   do {                                                        \\r
  92     if((__HANDLE__)->Instance == USART1)                      \\r
  93     {                                                         \\r
  94        switch(__HAL_RCC_GET_USART1_SOURCE())                  \\r
  95        {                                                      \\r
  96         case RCC_USART1CLKSOURCE_PCLK2:                       \\r
  97           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK2;         \\r
  98           break;                                              \\r
  99         case RCC_USART1CLKSOURCE_HSI:                         \\r
 100           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI;           \\r
 101           break;                                              \\r
 102         case RCC_USART1CLKSOURCE_SYSCLK:                      \\r
 103           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK;        \\r
 104           break;                                              \\r
 105         case RCC_USART1CLKSOURCE_LSE:                         \\r
 106           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE;           \\r
 107           break;                                              \\r
 108         default:                                              \\r
 109           break;                                              \\r
 110        }                                                      \\r
 111     }                                                         \\r
 112     else if((__HANDLE__)->Instance == USART2)                 \\r
 113     {                                                         \\r
 114        switch(__HAL_RCC_GET_USART2_SOURCE())                  \\r
 115        {                                                      \\r
 116         case RCC_USART2CLKSOURCE_PCLK1:                       \\r
 117           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1;         \\r
 118           break;                                              \\r
 119         case RCC_USART2CLKSOURCE_HSI:                         \\r
 120           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI;           \\r
 121           break;                                              \\r
 122         case RCC_USART2CLKSOURCE_SYSCLK:                      \\r
 123           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK;        \\r
 124           break;                                              \\r
 125         case RCC_USART2CLKSOURCE_LSE:                         \\r
 126           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE;           \\r
 127           break;                                              \\r
 128         default:                                              \\r
 129           break;                                              \\r
 130        }                                                      \\r
 131     }                                                         \\r
 132     else if((__HANDLE__)->Instance == USART3)                 \\r
 133     {                                                         \\r
 134        switch(__HAL_RCC_GET_USART3_SOURCE())                  \\r
 135        {                                                      \\r
 136         case RCC_USART3CLKSOURCE_PCLK1:                       \\r
 137           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1;         \\r
 138           break;                                              \\r
 139         case RCC_USART3CLKSOURCE_HSI:                         \\r
 140           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI;           \\r
 141           break;                                              \\r
 142         case RCC_USART3CLKSOURCE_SYSCLK:                      \\r
 143           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK;        \\r
 144           break;                                              \\r
 145         case RCC_USART3CLKSOURCE_LSE:                         \\r
 146           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE;           \\r
 147           break;                                              \\r
 148         default:                                              \\r
 149           break;                                              \\r
 150        }                                                      \\r
 151     }                                                         \\r
 152     else if((__HANDLE__)->Instance == USART6)                 \\r
 153     {                                                         \\r
 154        switch(__HAL_RCC_GET_USART6_SOURCE())                  \\r
 155        {                                                      \\r
 156         case RCC_USART6CLKSOURCE_PCLK2:                       \\r
 157           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK2;         \\r
 158           break;                                              \\r
 159         case RCC_USART6CLKSOURCE_HSI:                         \\r
 160           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI;           \\r
 161           break;                                              \\r
 162         case RCC_USART6CLKSOURCE_SYSCLK:                      \\r
 163           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK;        \\r
 164           break;                                              \\r
 165         case RCC_USART6CLKSOURCE_LSE:                         \\r
 166           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE;           \\r
 167           break;                                              \\r
 168         default:                                              \\r
 169           break;                                              \\r
 170        }                                                      \\r
 171     }                                                         \\r
 172         } while(0)\r
 173 \r
 174 /** @brief  Reports the mask to apply to retrieve the received data\r
 175   *         according to the word length and to the parity bits activation.\r
 176   * @param  __HANDLE__: specifies the IRDA Handle\r
 177   * @retval mask to apply to USART RDR register value.\r
 178   */    \r
 179 #define IRDA_MASK_COMPUTATION(__HANDLE__)                       \\r
 180   do {                                                                \\r
 181   if ((__HANDLE__)->Init.WordLength == IRDA_WORDLENGTH_9B)            \\r
 182   {                                                                   \\r
 183      if ((__HANDLE__)->Init.Parity == IRDA_PARITY_NONE)               \\r
 184      {                                                                \\r
 185         (__HANDLE__)->Mask = 0x01FF ;                                 \\r
 186      }                                                                \\r
 187      else                                                             \\r
 188      {                                                                \\r
 189         (__HANDLE__)->Mask = 0x00FF ;                                 \\r
 190      }                                                                \\r
 191   }                                                                   \\r
 192   else if ((__HANDLE__)->Init.WordLength == IRDA_WORDLENGTH_8B)       \\r
 193   {                                                                   \\r
 194      if ((__HANDLE__)->Init.Parity == IRDA_PARITY_NONE)               \\r
 195      {                                                                \\r
 196         (__HANDLE__)->Mask = 0x00FF ;                                 \\r
 197      }                                                                \\r
 198      else                                                             \\r
 199      {                                                                \\r
 200         (__HANDLE__)->Mask = 0x007F ;                                 \\r
 201      }                                                                \\r
 202   }                                                                   \\r
 203   else if ((__HANDLE__)->Init.WordLength == IRDA_WORDLENGTH_7B)       \\r
 204   {                                                                   \\r
 205      if ((__HANDLE__)->Init.Parity == IRDA_PARITY_NONE)               \\r
 206      {                                                                \\r
 207         (__HANDLE__)->Mask = 0x007F ;                                 \\r
 208      }                                                                \\r
 209      else                                                             \\r
 210      {                                                                \\r
 211         (__HANDLE__)->Mask = 0x003F ;                                 \\r
 212      }                                                                \\r
 213   }                                                                   \\r
 214 } while(0)\r
 215 \r
 216 #define IS_IRDA_WORD_LENGTH(LENGTH) (((LENGTH) == IRDA_WORDLENGTH_7B) || \\r
 217                                      ((LENGTH) == IRDA_WORDLENGTH_8B) || \\r
 218                                      ((LENGTH) == IRDA_WORDLENGTH_9B))\r
 219 /**\r
 220   * @}\r
 221   */\r
 222 \r
 223 /* Exported functions --------------------------------------------------------*/\r
 224 \r
 225 /**\r
 226   * @}\r
 227   */\r
 228 \r
 229 /**\r
 230   * @}\r
 231   */\r
 232 \r
 233 #ifdef __cplusplus\r
 234 }\r
 235 #endif\r
 236 \r
 237 #endif /* __STM32F7xx_HAL_IRDA_EX_H */\r
 238 \r
 239 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/\r