git.leonardobizzoni.com Git - pioneer-stm32/blob

   1 /**\r
   2   ******************************************************************************\r
   3   * @file    stm32f7xx_hal_uart_ex.h\r
   4   * @author  MCD Application Team\r
   5   * @brief   Header file of UART HAL Extended module.\r
   6   ******************************************************************************\r
   7   * @attention\r
   8   *\r
   9   * <h2><center>&copy; Copyright (c) 2017 STMicroelectronics.\r
  10   * All rights reserved.</center></h2>\r
  11   *\r
  12   * This software component is licensed by ST under BSD 3-Clause license,\r
  13   * the "License"; You may not use this file except in compliance with the\r
  14   * License. You may obtain a copy of the License at:\r
  15   *                        opensource.org/licenses/BSD-3-Clause\r
  16   *\r
  17   ******************************************************************************\r
  18   */\r
  19 \r
  20 /* Define to prevent recursive inclusion -------------------------------------*/\r
  21 #ifndef STM32F7xx_HAL_UART_EX_H\r
  22 #define STM32F7xx_HAL_UART_EX_H\r
  23 \r
  24 #ifdef __cplusplus\r
  25 extern "C" {\r
  26 #endif\r
  27 \r
  28 /* Includes ------------------------------------------------------------------*/\r
  29 #include "stm32f7xx_hal_def.h"\r
  30 \r
  31 /** @addtogroup STM32F7xx_HAL_Driver\r
  32   * @{\r
  33   */\r
  34 \r
  35 /** @addtogroup UARTEx\r
  36   * @{\r
  37   */\r
  38 \r
  39 /* Exported types ------------------------------------------------------------*/\r
  40 /** @defgroup UARTEx_Exported_Types UARTEx Exported Types\r
  41   * @{\r
  42   */\r
  43 \r
  44 \r
  45 /**\r
  46   * @}\r
  47   */\r
  48 \r
  49 /* Exported constants --------------------------------------------------------*/\r
  50 /** @defgroup UARTEx_Exported_Constants UARTEx Exported Constants\r
  51   * @{\r
  52   */\r
  53 \r
  54 /** @defgroup UARTEx_Word_Length UARTEx Word Length\r
  55   * @{\r
  56   */\r
  57 #define UART_WORDLENGTH_7B                  USART_CR1_M1   /*!< 7-bit long UART frame */\r
  58 #define UART_WORDLENGTH_8B                  0x00000000U    /*!< 8-bit long UART frame */\r
  59 #define UART_WORDLENGTH_9B                  USART_CR1_M0   /*!< 9-bit long UART frame */\r
  60 /**\r
  61   * @}\r
  62   */\r
  63 \r
  64 /** @defgroup UARTEx_WakeUp_Address_Length UARTEx WakeUp Address Length\r
  65   * @{\r
  66   */\r
  67 #define UART_ADDRESS_DETECT_4B              0x00000000U      /*!< 4-bit long wake-up address */\r
  68 #define UART_ADDRESS_DETECT_7B              USART_CR2_ADDM7  /*!< 7-bit long wake-up address */\r
  69 /**\r
  70   * @}\r
  71   */\r
  72 \r
  73 \r
  74 /**\r
  75   * @}\r
  76   */\r
  77 \r
  78 /* Exported macros -----------------------------------------------------------*/\r
  79 /* Exported functions --------------------------------------------------------*/\r
  80 /** @addtogroup UARTEx_Exported_Functions\r
  81   * @{\r
  82   */\r
  83 \r
  84 /** @addtogroup UARTEx_Exported_Functions_Group1\r
  85   * @{\r
  86   */\r
  87 \r
  88 /* Initialization and de-initialization functions  ****************************/\r
  89 HAL_StatusTypeDef HAL_RS485Ex_Init(UART_HandleTypeDef *huart, uint32_t Polarity, uint32_t AssertionTime, uint32_t DeassertionTime);\r
  90 \r
  91 /**\r
  92   * @}\r
  93   */\r
  94 \r
  95 /** @addtogroup UARTEx_Exported_Functions_Group2\r
  96   * @{\r
  97   */\r
  98 \r
  99 \r
 100 /**\r
 101   * @}\r
 102   */\r
 103 \r
 104 /** @addtogroup UARTEx_Exported_Functions_Group3\r
 105   * @{\r
 106   */\r
 107 \r
 108 /* Peripheral Control functions  **********************************************/\r
 109 HAL_StatusTypeDef HAL_MultiProcessorEx_AddressLength_Set(UART_HandleTypeDef *huart, uint32_t AddressLength);\r
 110 \r
 111 /**\r
 112   * @}\r
 113   */\r
 114 \r
 115 /**\r
 116   * @}\r
 117   */\r
 118 \r
 119 /* Private macros ------------------------------------------------------------*/\r
 120 /** @defgroup UARTEx_Private_Macros UARTEx Private Macros\r
 121   * @{\r
 122   */\r
 123 \r
 124 /** @brief  Report the UART clock source.\r
 125   * @param  __HANDLE__ specifies the UART Handle.\r
 126   * @param  __CLOCKSOURCE__ output variable.\r
 127   * @retval UART clocking source, written in __CLOCKSOURCE__.\r
 128   */\r
 129 #define UART_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__) \\r
 130   do {                                                        \\r
 131     if((__HANDLE__)->Instance == USART1)                      \\r
 132     {                                                         \\r
 133        switch(__HAL_RCC_GET_USART1_SOURCE())                  \\r
 134        {                                                      \\r
 135         case RCC_USART1CLKSOURCE_PCLK2:                       \\r
 136           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK2;         \\r
 137           break;                                              \\r
 138         case RCC_USART1CLKSOURCE_HSI:                         \\r
 139           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \\r
 140           break;                                              \\r
 141         case RCC_USART1CLKSOURCE_SYSCLK:                      \\r
 142           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK;        \\r
 143           break;                                              \\r
 144         case RCC_USART1CLKSOURCE_LSE:                         \\r
 145           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \\r
 146           break;                                              \\r
 147         default:                                              \\r
 148           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \\r
 149           break;                                              \\r
 150        }                                                      \\r
 151     }                                                         \\r
 152     else if((__HANDLE__)->Instance == USART2)                 \\r
 153     {                                                         \\r
 154        switch(__HAL_RCC_GET_USART2_SOURCE())                  \\r
 155        {                                                      \\r
 156         case RCC_USART2CLKSOURCE_PCLK1:                       \\r
 157           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;         \\r
 158           break;                                              \\r
 159         case RCC_USART2CLKSOURCE_HSI:                         \\r
 160           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \\r
 161           break;                                              \\r
 162         case RCC_USART2CLKSOURCE_SYSCLK:                      \\r
 163           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK;        \\r
 164           break;                                              \\r
 165         case RCC_USART2CLKSOURCE_LSE:                         \\r
 166           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \\r
 167           break;                                              \\r
 168         default:                                              \\r
 169           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \\r
 170           break;                                              \\r
 171        }                                                      \\r
 172     }                                                         \\r
 173     else if((__HANDLE__)->Instance == USART3)                 \\r
 174     {                                                         \\r
 175        switch(__HAL_RCC_GET_USART3_SOURCE())                  \\r
 176        {                                                      \\r
 177         case RCC_USART3CLKSOURCE_PCLK1:                       \\r
 178           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;         \\r
 179           break;                                              \\r
 180         case RCC_USART3CLKSOURCE_HSI:                         \\r
 181           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \\r
 182           break;                                              \\r
 183         case RCC_USART3CLKSOURCE_SYSCLK:                      \\r
 184           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK;        \\r
 185           break;                                              \\r
 186         case RCC_USART3CLKSOURCE_LSE:                         \\r
 187           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \\r
 188           break;                                              \\r
 189         default:                                              \\r
 190           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \\r
 191           break;                                              \\r
 192        }                                                      \\r
 193     }                                                         \\r
 194     else if((__HANDLE__)->Instance == UART4)                  \\r
 195     {                                                         \\r
 196        switch(__HAL_RCC_GET_UART4_SOURCE())                   \\r
 197        {                                                      \\r
 198         case RCC_UART4CLKSOURCE_PCLK1:                        \\r
 199           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;         \\r
 200           break;                                              \\r
 201         case RCC_UART4CLKSOURCE_HSI:                          \\r
 202           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \\r
 203           break;                                              \\r
 204         case RCC_UART4CLKSOURCE_SYSCLK:                       \\r
 205           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK;        \\r
 206           break;                                              \\r
 207         case RCC_UART4CLKSOURCE_LSE:                          \\r
 208           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \\r
 209           break;                                              \\r
 210         default:                                              \\r
 211           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \\r
 212           break;                                              \\r
 213        }                                                      \\r
 214     }                                                         \\r
 215     else if ((__HANDLE__)->Instance == UART5)                 \\r
 216     {                                                         \\r
 217        switch(__HAL_RCC_GET_UART5_SOURCE())                   \\r
 218        {                                                      \\r
 219         case RCC_UART5CLKSOURCE_PCLK1:                        \\r
 220           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;         \\r
 221           break;                                              \\r
 222         case RCC_UART5CLKSOURCE_HSI:                          \\r
 223           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \\r
 224           break;                                              \\r
 225         case RCC_UART5CLKSOURCE_SYSCLK:                       \\r
 226           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK;        \\r
 227           break;                                              \\r
 228         case RCC_UART5CLKSOURCE_LSE:                          \\r
 229           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \\r
 230           break;                                              \\r
 231         default:                                              \\r
 232           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \\r
 233           break;                                              \\r
 234        }                                                      \\r
 235     }                                                         \\r
 236     else if((__HANDLE__)->Instance == USART6)                 \\r
 237     {                                                         \\r
 238        switch(__HAL_RCC_GET_USART6_SOURCE())                  \\r
 239        {                                                      \\r
 240         case RCC_USART6CLKSOURCE_PCLK2:                       \\r
 241           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK2;         \\r
 242           break;                                              \\r
 243         case RCC_USART6CLKSOURCE_HSI:                         \\r
 244           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \\r
 245           break;                                              \\r
 246         case RCC_USART6CLKSOURCE_SYSCLK:                      \\r
 247           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK;        \\r
 248           break;                                              \\r
 249         case RCC_USART6CLKSOURCE_LSE:                         \\r
 250           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \\r
 251           break;                                              \\r
 252         default:                                              \\r
 253           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \\r
 254           break;                                              \\r
 255        }                                                      \\r
 256     }                                                         \\r
 257     else if ((__HANDLE__)->Instance == UART7)                 \\r
 258     {                                                         \\r
 259        switch(__HAL_RCC_GET_UART7_SOURCE())                   \\r
 260        {                                                      \\r
 261         case RCC_UART7CLKSOURCE_PCLK1:                        \\r
 262           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;         \\r
 263           break;                                              \\r
 264         case RCC_UART7CLKSOURCE_HSI:                          \\r
 265           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \\r
 266           break;                                              \\r
 267         case RCC_UART7CLKSOURCE_SYSCLK:                       \\r
 268           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK;        \\r
 269           break;                                              \\r
 270         case RCC_UART7CLKSOURCE_LSE:                          \\r
 271           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \\r
 272           break;                                              \\r
 273         default:                                              \\r
 274           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \\r
 275           break;                                              \\r
 276        }                                                      \\r
 277     }                                                         \\r
 278     else if ((__HANDLE__)->Instance == UART8)                 \\r
 279     {                                                         \\r
 280        switch(__HAL_RCC_GET_UART8_SOURCE())                   \\r
 281        {                                                      \\r
 282         case RCC_UART8CLKSOURCE_PCLK1:                        \\r
 283           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_PCLK1;         \\r
 284           break;                                              \\r
 285         case RCC_UART8CLKSOURCE_HSI:                          \\r
 286           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_HSI;           \\r
 287           break;                                              \\r
 288         case RCC_UART8CLKSOURCE_SYSCLK:                       \\r
 289           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_SYSCLK;        \\r
 290           break;                                              \\r
 291         case RCC_UART8CLKSOURCE_LSE:                          \\r
 292           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_LSE;           \\r
 293           break;                                              \\r
 294         default:                                              \\r
 295           (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;     \\r
 296           break;                                              \\r
 297        }                                                      \\r
 298     }                                                         \\r
 299     else                                                      \\r
 300     {                                                         \\r
 301       (__CLOCKSOURCE__) = UART_CLOCKSOURCE_UNDEFINED;         \\r
 302     }                                                         \\r
 303   } while(0U)\r
 304 \r
 305 /** @brief  Report the UART mask to apply to retrieve the received data\r
 306   *         according to the word length and to the parity bits activation.\r
 307   * @note   If PCE = 1, the parity bit is not included in the data extracted\r
 308   *         by the reception API().\r
 309   *         This masking operation is not carried out in the case of\r
 310   *         DMA transfers.\r
 311   * @param  __HANDLE__ specifies the UART Handle.\r
 312   * @retval None, the mask to apply to UART RDR register is stored in (__HANDLE__)->Mask field.\r
 313   */\r
 314 #define UART_MASK_COMPUTATION(__HANDLE__)                             \\r
 315   do {                                                                \\r
 316   if ((__HANDLE__)->Init.WordLength == UART_WORDLENGTH_9B)            \\r
 317   {                                                                   \\r
 318      if ((__HANDLE__)->Init.Parity == UART_PARITY_NONE)               \\r
 319      {                                                                \\r
 320         (__HANDLE__)->Mask = 0x01FFU ;                                \\r
 321      }                                                                \\r
 322      else                                                             \\r
 323      {                                                                \\r
 324         (__HANDLE__)->Mask = 0x00FFU ;                                \\r
 325      }                                                                \\r
 326   }                                                                   \\r
 327   else if ((__HANDLE__)->Init.WordLength == UART_WORDLENGTH_8B)       \\r
 328   {                                                                   \\r
 329      if ((__HANDLE__)->Init.Parity == UART_PARITY_NONE)               \\r
 330      {                                                                \\r
 331         (__HANDLE__)->Mask = 0x00FFU ;                                \\r
 332      }                                                                \\r
 333      else                                                             \\r
 334      {                                                                \\r
 335         (__HANDLE__)->Mask = 0x007FU ;                                \\r
 336      }                                                                \\r
 337   }                                                                   \\r
 338   else if ((__HANDLE__)->Init.WordLength == UART_WORDLENGTH_7B)       \\r
 339   {                                                                   \\r
 340      if ((__HANDLE__)->Init.Parity == UART_PARITY_NONE)               \\r
 341      {                                                                \\r
 342         (__HANDLE__)->Mask = 0x007FU ;                                \\r
 343      }                                                                \\r
 344      else                                                             \\r
 345      {                                                                \\r
 346         (__HANDLE__)->Mask = 0x003FU ;                                \\r
 347      }                                                                \\r
 348   }                                                                   \\r
 349   else                                                                \\r
 350   {                                                                   \\r
 351     (__HANDLE__)->Mask = 0x0000U;                                     \\r
 352   }                                                                   \\r
 353 } while(0U)\r
 354 \r
 355 /**\r
 356   * @brief Ensure that UART frame length is valid.\r
 357   * @param __LENGTH__ UART frame length.\r
 358   * @retval SET (__LENGTH__ is valid) or RESET (__LENGTH__ is invalid)\r
 359   */\r
 360 #define IS_UART_WORD_LENGTH(__LENGTH__) (((__LENGTH__) == UART_WORDLENGTH_7B) || \\r
 361                                          ((__LENGTH__) == UART_WORDLENGTH_8B) || \\r
 362                                          ((__LENGTH__) == UART_WORDLENGTH_9B))\r
 363 \r
 364 /**\r
 365   * @brief Ensure that UART wake-up address length is valid.\r
 366   * @param __ADDRESS__ UART wake-up address length.\r
 367   * @retval SET (__ADDRESS__ is valid) or RESET (__ADDRESS__ is invalid)\r
 368   */\r
 369 #define IS_UART_ADDRESSLENGTH_DETECT(__ADDRESS__) (((__ADDRESS__) == UART_ADDRESS_DETECT_4B) || \\r
 370                                                    ((__ADDRESS__) == UART_ADDRESS_DETECT_7B))\r
 371 \r
 372 \r
 373 /**\r
 374   * @}\r
 375   */\r
 376 \r
 377 /* Private functions ---------------------------------------------------------*/\r
 378 \r
 379 /**\r
 380   * @}\r
 381   */\r
 382 \r
 383 /**\r
 384   * @}\r
 385   */\r
 386 \r
 387 #ifdef __cplusplus\r
 388 }\r
 389 #endif\r
 390 \r
 391 #endif /* STM32F7xx_HAL_UART_EX_H */\r
 392 \r
 393 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/\r