git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/CORTEX_M7_STM32F7_STM32756G-EVAL_IAR_Keil/ST_Library/include/stm32f7xx_hal_uart_ex.h

   1 /**\r
   2   ******************************************************************************\r
   3   * @file    stm32f7xx_hal_uart_ex.h\r
   4   * @author  MCD Application Team\r
   5   * @version V1.0.0RC1\r
   6   * @date    24-March-2015\r
   7   * @brief   Header file of UART 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_UART_EX_H\r
  40 #define __STM32F7xx_HAL_UART_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 UARTEx\r
  54   * @{\r
  55   */\r
  56 \r
  57 /* Exported types ------------------------------------------------------------*/\r
  58 /* Exported constants --------------------------------------------------------*/\r
  59 /** @defgroup UARTEx_Exported_Constants UARTEx Exported Constants\r
  60   * @{\r
  61   */\r
  62   \r
  63 /** @defgroup UARTEx_Word_Length UARTEx Word Length\r
  64   * @{\r
  65   */\r
  66 #define UART_WORDLENGTH_7B                  ((uint32_t)USART_CR1_M_1)\r
  67 #define UART_WORDLENGTH_8B                  ((uint32_t)0x0000)\r
  68 #define UART_WORDLENGTH_9B                  ((uint32_t)USART_CR1_M_0)\r
  69 #define IS_UART_WORD_LENGTH(__LENGTH__) (((__LENGTH__) == UART_WORDLENGTH_7B) || \\r
  70                                          ((__LENGTH__) == UART_WORDLENGTH_8B) || \\r
  71                                          ((__LENGTH__) == UART_WORDLENGTH_9B))\r
  72 #define IS_LIN_WORD_LENGTH(LENGTH) (((LENGTH) == UART_WORDLENGTH_8B))                                                                                                                                                            \r
  73 /**\r
  74   * @}\r
  75   */\r
  76 \r
  77   \r
  78 /** @defgroup UARTEx_WakeUp_Address_Length UARTEx WakeUp Address Length\r
  79   * @{\r
  80   */\r
  81 #define UART_ADDRESS_DETECT_4B                ((uint32_t)0x00000000)\r
  82 #define UART_ADDRESS_DETECT_7B                ((uint32_t)USART_CR2_ADDM7)\r
  83 #define IS_UART_ADDRESSLENGTH_DETECT(__ADDRESS__) (((__ADDRESS__) == UART_ADDRESS_DETECT_4B) || \\r
  84                                                    ((__ADDRESS__) == UART_ADDRESS_DETECT_7B))\r
  85 /**\r
  86   * @}\r
  87   */  \r
  88 \r
  89   \r
  90 /**\r
  91   * @}\r
  92   */  \r
  93   \r
  94 /* Exported macro ------------------------------------------------------------*/\r
  95 \r
  96 /** @defgroup UARTEx_Exported_Macros UARTEx Exported Macros\r
  97   * @{\r
  98   */\r
  99            \r
 100 /** @brief  Reports the UART clock source.\r
 101   * @param  __HANDLE__: specifies the UART Handle\r
 102   * @param  __CLOCKSOURCE__ : output variable   \r
 103   * @retval UART clocking source, written in __CLOCKSOURCE__.\r
 104   */\r
 105 #define UART_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__) \\r
 106   do {                                                        \\r
 107     if((__HANDLE__)->Instance == USART1)                      \\r
 108     {                                                         \\r
 109        switch(__HAL_RCC_GET_USART1_SOURCE())                  \\r
 110        {                                                      \\r
 111         case RCC_USART1CLKSOURCE_PCLK2:                       \\r
 112           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK2;         \\r
 113           break;                                              \\r
 114         case RCC_USART1CLKSOURCE_HSI:                         \\r
 115           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \\r
 116           break;                                              \\r
 117         case RCC_USART1CLKSOURCE_SYSCLK:                      \\r
 118           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK;        \\r
 119           break;                                              \\r
 120         case RCC_USART1CLKSOURCE_LSE:                         \\r
 121           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \\r
 122           break;                                              \\r
 123         default:                                              \\r
 124           break;                                              \\r
 125        }                                                      \\r
 126     }                                                         \\r
 127     else if((__HANDLE__)->Instance == USART2)                 \\r
 128     {                                                         \\r
 129        switch(__HAL_RCC_GET_USART2_SOURCE())                  \\r
 130        {                                                      \\r
 131         case RCC_USART2CLKSOURCE_PCLK1:                       \\r
 132           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;         \\r
 133           break;                                              \\r
 134         case RCC_USART2CLKSOURCE_HSI:                         \\r
 135           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \\r
 136           break;                                              \\r
 137         case RCC_USART2CLKSOURCE_SYSCLK:                      \\r
 138           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK;        \\r
 139           break;                                              \\r
 140         case RCC_USART2CLKSOURCE_LSE:                         \\r
 141           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \\r
 142           break;                                              \\r
 143         default:                                              \\r
 144           break;                                              \\r
 145        }                                                      \\r
 146     }                                                         \\r
 147     else if((__HANDLE__)->Instance == USART3)                 \\r
 148     {                                                         \\r
 149        switch(__HAL_RCC_GET_USART3_SOURCE())                  \\r
 150        {                                                      \\r
 151         case RCC_USART3CLKSOURCE_PCLK1:                       \\r
 152           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;         \\r
 153           break;                                              \\r
 154         case RCC_USART3CLKSOURCE_HSI:                         \\r
 155           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \\r
 156           break;                                              \\r
 157         case RCC_USART3CLKSOURCE_SYSCLK:                      \\r
 158           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK;        \\r
 159           break;                                              \\r
 160         case RCC_USART3CLKSOURCE_LSE:                         \\r
 161           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \\r
 162           break;                                              \\r
 163         default:                                              \\r
 164           break;                                              \\r
 165        }                                                      \\r
 166     }                                                         \\r
 167     else if((__HANDLE__)->Instance == UART4)                  \\r
 168     {                                                         \\r
 169        switch(__HAL_RCC_GET_UART4_SOURCE())                   \\r
 170        {                                                      \\r
 171         case RCC_UART4CLKSOURCE_PCLK1:                        \\r
 172           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;         \\r
 173           break;                                              \\r
 174         case RCC_UART4CLKSOURCE_HSI:                          \\r
 175           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \\r
 176           break;                                              \\r
 177         case RCC_UART4CLKSOURCE_SYSCLK:                       \\r
 178           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK;        \\r
 179           break;                                              \\r
 180         case RCC_UART4CLKSOURCE_LSE:                          \\r
 181           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \\r
 182           break;                                              \\r
 183         default:                                              \\r
 184           break;                                              \\r
 185        }                                                      \\r
 186     }                                                         \\r
 187     else if ((__HANDLE__)->Instance == UART5)                 \\r
 188     {                                                         \\r
 189        switch(__HAL_RCC_GET_UART5_SOURCE())                   \\r
 190        {                                                      \\r
 191         case RCC_UART5CLKSOURCE_PCLK1:                        \\r
 192           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;         \\r
 193           break;                                              \\r
 194         case RCC_UART5CLKSOURCE_HSI:                          \\r
 195           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \\r
 196           break;                                              \\r
 197         case RCC_UART5CLKSOURCE_SYSCLK:                       \\r
 198           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK;        \\r
 199           break;                                              \\r
 200         case RCC_UART5CLKSOURCE_LSE:                          \\r
 201           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \\r
 202           break;                                              \\r
 203         default:                                              \\r
 204           break;                                              \\r
 205        }                                                      \\r
 206     }                                                         \\r
 207     else if((__HANDLE__)->Instance == USART6)                 \\r
 208     {                                                         \\r
 209        switch(__HAL_RCC_GET_USART6_SOURCE())                  \\r
 210        {                                                      \\r
 211         case RCC_USART6CLKSOURCE_PCLK2:                       \\r
 212           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK2;         \\r
 213           break;                                              \\r
 214         case RCC_USART6CLKSOURCE_HSI:                         \\r
 215           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \\r
 216           break;                                              \\r
 217         case RCC_USART6CLKSOURCE_SYSCLK:                      \\r
 218           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK;        \\r
 219           break;                                              \\r
 220         case RCC_USART6CLKSOURCE_LSE:                         \\r
 221           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \\r
 222           break;                                              \\r
 223         default:                                              \\r
 224           break;                                              \\r
 225        }                                                      \\r
 226     }                                                         \\r
 227     else if ((__HANDLE__)->Instance == UART7)                 \\r
 228     {                                                         \\r
 229        switch(__HAL_RCC_GET_UART7_SOURCE())                   \\r
 230        {                                                      \\r
 231         case RCC_UART7CLKSOURCE_PCLK1:                        \\r
 232           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;         \\r
 233           break;                                              \\r
 234         case RCC_UART7CLKSOURCE_HSI:                          \\r
 235           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \\r
 236           break;                                              \\r
 237         case RCC_UART7CLKSOURCE_SYSCLK:                       \\r
 238           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK;        \\r
 239           break;                                              \\r
 240         case RCC_UART7CLKSOURCE_LSE:                          \\r
 241           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \\r
 242           break;                                              \\r
 243         default:                                              \\r
 244           break;                                              \\r
 245        }                                                      \\r
 246     }                                                                                                                                                                                                                           \\r
 247     else if ((__HANDLE__)->Instance == UART8)                 \\r
 248     {                                                         \\r
 249        switch(__HAL_RCC_GET_UART8_SOURCE())                   \\r
 250        {                                                      \\r
 251         case RCC_UART8CLKSOURCE_PCLK1:                        \\r
 252           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;         \\r
 253           break;                                              \\r
 254         case RCC_UART8CLKSOURCE_HSI:                          \\r
 255           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \\r
 256           break;                                              \\r
 257         case RCC_UART8CLKSOURCE_SYSCLK:                       \\r
 258           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK;        \\r
 259           break;                                              \\r
 260         case RCC_UART8CLKSOURCE_LSE:                          \\r
 261           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \\r
 262           break;                                              \\r
 263         default:                                              \\r
 264           break;                                              \\r
 265        }                                                      \\r
 266     }                                                                                                                                                                                                                           \\r
 267   } while(0)\r
 268 \r
 269 /** @brief  Reports the UART mask to apply to retrieve the received data\r
 270   *         according to the word length and to the parity bits activation.\r
 271   *         If PCE = 1, the parity bit is not included in the data extracted\r
 272   *         by the reception API().\r
 273   *         This masking operation is not carried out in the case of\r
 274   *         DMA transfers.        \r
 275   * @param  __HANDLE__: specifies the UART Handle\r
 276   * @retval mask to apply to UART RDR register value.\r
 277   */\r
 278 #define UART_MASK_COMPUTATION(__HANDLE__)                       \\r
 279   do {                                                                \\r
 280   if ((__HANDLE__)->Init.WordLength == UART_WORDLENGTH_9B)            \\r
 281   {                                                                   \\r
 282      if ((__HANDLE__)->Init.Parity == UART_PARITY_NONE)               \\r
 283      {                                                                \\r
 284         (__HANDLE__)->Mask = 0x01FF ;                                 \\r
 285      }                                                                \\r
 286      else                                                             \\r
 287      {                                                                \\r
 288         (__HANDLE__)->Mask = 0x00FF ;                                 \\r
 289      }                                                                \\r
 290   }                                                                   \\r
 291   else if ((__HANDLE__)->Init.WordLength == UART_WORDLENGTH_8B)       \\r
 292   {                                                                   \\r
 293      if ((__HANDLE__)->Init.Parity == UART_PARITY_NONE)               \\r
 294      {                                                                \\r
 295         (__HANDLE__)->Mask = 0x00FF ;                                 \\r
 296      }                                                                \\r
 297      else                                                             \\r
 298      {                                                                \\r
 299         (__HANDLE__)->Mask = 0x007F ;                                 \\r
 300      }                                                                \\r
 301   }                                                                   \\r
 302   else if ((__HANDLE__)->Init.WordLength == UART_WORDLENGTH_7B)       \\r
 303   {                                                                   \\r
 304      if ((__HANDLE__)->Init.Parity == UART_PARITY_NONE)               \\r
 305      {                                                                \\r
 306         (__HANDLE__)->Mask = 0x007F ;                                 \\r
 307      }                                                                \\r
 308      else                                                             \\r
 309      {                                                                \\r
 310         (__HANDLE__)->Mask = 0x003F ;                                 \\r
 311      }                                                                \\r
 312   }                                                                   \\r
 313 } while(0)\r
 314 \r
 315 /**\r
 316   * @}\r
 317   */\r
 318 \r
 319 /* Exported functions --------------------------------------------------------*/\r
 320 \r
 321 /**\r
 322   * @}\r
 323   */ \r
 324 \r
 325 /**\r
 326   * @}\r
 327   */ \r
 328   \r
 329 #ifdef __cplusplus\r
 330 }\r
 331 #endif\r
 332 \r
 333 #endif /* __STM32F7xx_HAL_UART_EX_H */\r
 334 \r
 335 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/\r