lib/main/STM32F1/Drivers/STM32F1xx_HAL_Driver/Inc/stm32f1xx_hal_uart.h

   1 /**
   2   ******************************************************************************
   3   * @file    stm32f1xx_hal_uart.h
   4   * @author  MCD Application Team
   5   * @version V1.1.1
   6   * @date    12-May-2017
   7   * @brief   Header file of UART HAL module.
   8   ******************************************************************************
   9   * @attention
  10   *
  11   * <h2><center>&copy; COPYRIGHT(c) 2016 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 __STM32F1xx_HAL_UART_H
  40 #define __STM32F1xx_HAL_UART_H
  41
  42 #ifdef __cplusplus
  43  extern "C" {
  44 #endif
  45
  46 /* Includes ------------------------------------------------------------------*/
  47 #include "stm32f1xx_hal_def.h"
  48
  49 /** @addtogroup STM32F1xx_HAL_Driver
  50   * @{
  51   */
  52
  53 /** @addtogroup UART
  54   * @{
  55   */
  56
  57 /* Exported types ------------------------------------------------------------*/
  58 /** @defgroup UART_Exported_Types UART Exported Types
  59   * @{
  60   */
  61
  62 /**
  63   * @brief UART Init Structure definition
  64   */
  65 typedef struct
  66 {
  67   uint32_t BaudRate;                  /*!< This member configures the UART communication baud rate.
  68                                            The baud rate is computed using the following formula:
  69                                            - IntegerDivider = ((PCLKx) / (16 * (huart->Init.BaudRate)))
  70                                            - FractionalDivider = ((IntegerDivider - ((uint32_t) IntegerDivider)) * 16) + 0.5 */
  71
  72   uint32_t WordLength;                /*!< Specifies the number of data bits transmitted or received in a frame.
  73                                            This parameter can be a value of @ref UART_Word_Length */
  74
  75   uint32_t StopBits;                  /*!< Specifies the number of stop bits transmitted.
  76                                            This parameter can be a value of @ref UART_Stop_Bits */
  77
  78   uint32_t Parity;                    /*!< Specifies the parity mode.
  79                                            This parameter can be a value of @ref UART_Parity
  80                                            @note When parity is enabled, the computed parity is inserted
  81                                                  at the MSB position of the transmitted data (9th bit when
  82                                                  the word length is set to 9 data bits; 8th bit when the
  83                                                  word length is set to 8 data bits). */
  84
  85   uint32_t Mode;                      /*!< Specifies whether the Receive or Transmit mode is enabled or disabled.
  86                                            This parameter can be a value of @ref UART_Mode */
  87
  88   uint32_t HwFlowCtl;                 /*!< Specifies whether the hardware flow control mode is enabled or disabled.
  89                                            This parameter can be a value of @ref UART_Hardware_Flow_Control */
  90
  91   uint32_t OverSampling;              /*!< Specifies whether the Over sampling 8 is enabled or disabled, to achieve higher speed (up to fPCLK/8).
  92                                            This parameter can be a value of @ref UART_Over_Sampling. This feature is only available
  93                                            on STM32F100xx family, so OverSampling parameter should always be set to 16. */
  94 }UART_InitTypeDef;
  95
  96 /**
  97   * @brief HAL UART State structures definition
  98   * @note  HAL UART State value is a combination of 2 different substates: gState and RxState.
  99   *        - gState contains UART state information related to global Handle management
 100   *          and also information related to Tx operations.
 101   *          gState value coding follow below described bitmap :
 102   *          b7-b6  Error information
 103   *             00 : No Error
 104   *             01 : (Not Used)
 105   *             10 : Timeout
 106   *             11 : Error
 107   *          b5     IP initilisation status
 108   *             0  : Reset (IP not initialized)
 109   *             1  : Init done (IP not initialized. HAL UART Init function already called)
 110   *          b4-b3  (not used)
 111   *             xx : Should be set to 00
 112   *          b2     Intrinsic process state
 113   *             0  : Ready
 114   *             1  : Busy (IP busy with some configuration or internal operations)
 115   *          b1     (not used)
 116   *             x  : Should be set to 0
 117   *          b0     Tx state
 118   *             0  : Ready (no Tx operation ongoing)
 119   *             1  : Busy (Tx operation ongoing)
 120   *        - RxState contains information related to Rx operations.
 121   *          RxState value coding follow below described bitmap :
 122   *          b7-b6  (not used)
 123   *             xx : Should be set to 00
 124   *          b5     IP initilisation status
 125   *             0  : Reset (IP not initialized)
 126   *             1  : Init done (IP not initialized)
 127   *          b4-b2  (not used)
 128   *            xxx : Should be set to 000
 129   *          b1     Rx state
 130   *             0  : Ready (no Rx operation ongoing)
 131   *             1  : Busy (Rx operation ongoing)
 132   *          b0     (not used)
 133   *             x  : Should be set to 0.
 134   */
 135 typedef enum
 136 {
 137   HAL_UART_STATE_RESET             = 0x00U,    /*!< Peripheral is not yet Initialized
 138                                                    Value is allowed for gState and RxState */
 139   HAL_UART_STATE_READY             = 0x20U,    /*!< Peripheral Initialized and ready for use
 140                                                    Value is allowed for gState and RxState */
 141   HAL_UART_STATE_BUSY              = 0x24U,    /*!< an internal process is ongoing
 142                                                    Value is allowed for gState only */
 143   HAL_UART_STATE_BUSY_TX           = 0x21U,    /*!< Data Transmission process is ongoing
 144                                                    Value is allowed for gState only */
 145   HAL_UART_STATE_BUSY_RX           = 0x22U,    /*!< Data Reception process is ongoing
 146                                                    Value is allowed for RxState only */
 147   HAL_UART_STATE_BUSY_TX_RX        = 0x23U,    /*!< Data Transmission and Reception process is ongoing
 148                                                    Not to be used for neither gState nor RxState.
 149                                                    Value is result of combination (Or) between gState and RxState values */
 150   HAL_UART_STATE_TIMEOUT           = 0xA0U,    /*!< Timeout state
 151                                                    Value is allowed for gState only */
 152   HAL_UART_STATE_ERROR             = 0xE0U     /*!< Error
 153                                                    Value is allowed for gState only */
 154 }HAL_UART_StateTypeDef;
 155
 156 /**
 157   * @brief  UART handle Structure definition
 158   */
 159 typedef struct
 160 {
 161   USART_TypeDef                 *Instance;        /*!< UART registers base address        */
 162
 163   UART_InitTypeDef              Init;             /*!< UART communication parameters      */
 164
 165   uint8_t                       *pTxBuffPtr;      /*!< Pointer to UART Tx transfer Buffer */
 166
 167   uint16_t                      TxXferSize;       /*!< UART Tx Transfer size              */
 168
 169   __IO uint16_t                 TxXferCount;      /*!< UART Tx Transfer Counter           */
 170
 171   uint8_t                       *pRxBuffPtr;      /*!< Pointer to UART Rx transfer Buffer */
 172
 173   uint16_t                      RxXferSize;       /*!< UART Rx Transfer size              */
 174
 175   __IO uint16_t                 RxXferCount;      /*!< UART Rx Transfer Counter           */
 176
 177   DMA_HandleTypeDef             *hdmatx;          /*!< UART Tx DMA Handle parameters      */
 178
 179   DMA_HandleTypeDef             *hdmarx;          /*!< UART Rx DMA Handle parameters      */
 180
 181   HAL_LockTypeDef               Lock;             /*!< Locking object                     */
 182
 183   __IO HAL_UART_StateTypeDef    gState;           /*!< UART state information related to global Handle management
 184                                                        and also related to Tx operations.
 185                                                        This parameter can be a value of @ref HAL_UART_StateTypeDef */
 186
 187   __IO HAL_UART_StateTypeDef    RxState;          /*!< UART state information related to Rx operations.
 188                                                        This parameter can be a value of @ref HAL_UART_StateTypeDef */
 189
 190   __IO uint32_t                 ErrorCode;        /*!< UART Error code                    */
 191 }UART_HandleTypeDef;
 192
 193 /**
 194   * @}
 195   */
 196
 197 /* Exported constants --------------------------------------------------------*/
 198 /** @defgroup UART_Exported_Constants UART Exported constants
 199   * @{
 200   */
 201
 202 /** @defgroup UART_Error_Code UART Error Code
 203   * @{
 204   */
 205 #define HAL_UART_ERROR_NONE         0x00000000U   /*!< No error            */
 206 #define HAL_UART_ERROR_PE           0x00000001U   /*!< Parity error        */
 207 #define HAL_UART_ERROR_NE           0x00000002U   /*!< Noise error         */
 208 #define HAL_UART_ERROR_FE           0x00000004U   /*!< Frame error         */
 209 #define HAL_UART_ERROR_ORE          0x00000008U   /*!< Overrun error       */
 210 #define HAL_UART_ERROR_DMA          0x00000010U   /*!< DMA transfer error  */
 211 /**
 212   * @}
 213   */
 214
 215 /** @defgroup UART_Word_Length UART Word Length
 216   * @{
 217   */
 218 #define UART_WORDLENGTH_8B                  0x00000000U
 219 #define UART_WORDLENGTH_9B                  ((uint32_t)USART_CR1_M)
 220 /**
 221   * @}
 222   */
 223
 224 /** @defgroup UART_Stop_Bits  UART Number of Stop Bits
 225   * @{
 226   */
 227 #define UART_STOPBITS_1                     0x00000000U
 228 #define UART_STOPBITS_2                     ((uint32_t)USART_CR2_STOP_1)
 229 /**
 230   * @}
 231   */
 232
 233 /** @defgroup UART_Parity  UART Parity
 234   * @{
 235   */
 236 #define UART_PARITY_NONE                    0x00000000U
 237 #define UART_PARITY_EVEN                    ((uint32_t)USART_CR1_PCE)
 238 #define UART_PARITY_ODD                     ((uint32_t)(USART_CR1_PCE | USART_CR1_PS))
 239 /**
 240   * @}
 241   */
 242
 243 /** @defgroup UART_Hardware_Flow_Control UART Hardware Flow Control
 244   * @{
 245   */
 246 #define UART_HWCONTROL_NONE                  0x00000000U
 247 #define UART_HWCONTROL_RTS                   ((uint32_t)USART_CR3_RTSE)
 248 #define UART_HWCONTROL_CTS                   ((uint32_t)USART_CR3_CTSE)
 249 #define UART_HWCONTROL_RTS_CTS               ((uint32_t)(USART_CR3_RTSE | USART_CR3_CTSE))
 250 /**
 251   * @}
 252   */
 253
 254 /** @defgroup UART_Mode UART Transfer Mode
 255   * @{
 256   */
 257 #define UART_MODE_RX                        ((uint32_t)USART_CR1_RE)
 258 #define UART_MODE_TX                        ((uint32_t)USART_CR1_TE)
 259 #define UART_MODE_TX_RX                     ((uint32_t)(USART_CR1_TE |USART_CR1_RE))
 260 /**
 261   * @}
 262   */
 263
 264 /** @defgroup UART_State  UART State
 265   * @{
 266   */
 267 #define UART_STATE_DISABLE                  0x00000000U
 268 #define UART_STATE_ENABLE                   ((uint32_t)USART_CR1_UE)
 269 /**
 270   * @}
 271   */
 272
 273
 274 /** @defgroup UART_Over_Sampling UART Over Sampling
 275   * @{
 276   */
 277 #define UART_OVERSAMPLING_16                    0x00000000U
 278 #if defined(USART_CR1_OVER8)
 279 #define UART_OVERSAMPLING_8                     ((uint32_t)USART_CR1_OVER8)
 280 #endif /* USART_CR1_OVER8 */
 281 /**
 282   * @}
 283   */
 284
 285
 286 /** @defgroup UART_LIN_Break_Detection_Length  UART LIN Break Detection Length
 287   * @{
 288   */
 289 #define UART_LINBREAKDETECTLENGTH_10B      0x00000000U
 290 #define UART_LINBREAKDETECTLENGTH_11B      ((uint32_t)USART_CR2_LBDL)
 291 /**
 292   * @}
 293   */
 294 /** @defgroup UART_WakeUp_functions  UART Wakeup Functions
 295   * @{
 296   */
 297 #define UART_WAKEUPMETHOD_IDLELINE                0x00000000U
 298 #define UART_WAKEUPMETHOD_ADDRESSMARK             ((uint32_t)USART_CR1_WAKE)
 299 /**
 300   * @}
 301   */
 302
 303 /** @defgroup UART_Flags   UART FLags
 304   *        Elements values convention: 0xXXXX
 305   *           - 0xXXXX  : Flag mask in the SR register
 306   * @{
 307   */
 308 #define UART_FLAG_CTS                       ((uint32_t)USART_SR_CTS)
 309 #define UART_FLAG_LBD                       ((uint32_t)USART_SR_LBD)
 310 #define UART_FLAG_TXE                       ((uint32_t)USART_SR_TXE)
 311 #define UART_FLAG_TC                        ((uint32_t)USART_SR_TC)
 312 #define UART_FLAG_RXNE                      ((uint32_t)USART_SR_RXNE)
 313 #define UART_FLAG_IDLE                      ((uint32_t)USART_SR_IDLE)
 314 #define UART_FLAG_ORE                       ((uint32_t)USART_SR_ORE)
 315 #define UART_FLAG_NE                        ((uint32_t)USART_SR_NE)
 316 #define UART_FLAG_FE                        ((uint32_t)USART_SR_FE)
 317 #define UART_FLAG_PE                        ((uint32_t)USART_SR_PE)
 318 /**
 319   * @}
 320   */
 321
 322 /** @defgroup UART_Interrupt_definition  UART Interrupt Definitions
 323   *        Elements values convention: 0xY000XXXX
 324   *           - XXXX  : Interrupt mask (16 bits) in the Y register
 325   *           - Y  : Interrupt source register (2bits)
 326   *                   - 01: CR1 register
 327   *                   - 10: CR2 register
 328   *                   - 11: CR3 register
 329   * @{
 330   */
 331
 332 #define UART_IT_PE                       ((uint32_t)(UART_CR1_REG_INDEX << 28U | USART_CR1_PEIE))
 333 #define UART_IT_TXE                      ((uint32_t)(UART_CR1_REG_INDEX << 28U | USART_CR1_TXEIE))
 334 #define UART_IT_TC                       ((uint32_t)(UART_CR1_REG_INDEX << 28U | USART_CR1_TCIE))
 335 #define UART_IT_RXNE                     ((uint32_t)(UART_CR1_REG_INDEX << 28U | USART_CR1_RXNEIE))
 336 #define UART_IT_IDLE                     ((uint32_t)(UART_CR1_REG_INDEX << 28U | USART_CR1_IDLEIE))
 337
 338 #define UART_IT_LBD                      ((uint32_t)(UART_CR2_REG_INDEX << 28U | USART_CR2_LBDIE))
 339
 340 #define UART_IT_CTS                      ((uint32_t)(UART_CR3_REG_INDEX << 28U | USART_CR3_CTSIE))
 341 #define UART_IT_ERR                      ((uint32_t)(UART_CR3_REG_INDEX << 28U | USART_CR3_EIE))
 342 /**
 343   * @}
 344   */
 345
 346 /**
 347   * @}
 348   */
 349
 350 /* Exported macro ------------------------------------------------------------*/
 351 /** @defgroup UART_Exported_Macros UART Exported Macros
 352   * @{
 353   */
 354
 355 /** @brief Reset UART handle gstate & RxState
 356   * @param  __HANDLE__: specifies the UART Handle.
 357   *         UART Handle selects the USARTx or UARTy peripheral
 358   *         (USART,UART availability and x,y values depending on device).
 359   */
 360 #define __HAL_UART_RESET_HANDLE_STATE(__HANDLE__)  do{                                                   \
 361                                                        (__HANDLE__)->gState = HAL_UART_STATE_RESET;      \
 362                                                        (__HANDLE__)->RxState = HAL_UART_STATE_RESET;     \
 363                                                      } while(0U)
 364
 365 /** @brief  Flushs the UART DR register
 366   * @param  __HANDLE__: specifies the UART Handle.
 367   *         UART Handle selects the USARTx or UARTy peripheral
 368   *         (USART,UART availability and x,y values depending on device).
 369   */
 370 #define __HAL_UART_FLUSH_DRREGISTER(__HANDLE__) ((__HANDLE__)->Instance->DR)
 371
 372 /** @brief  Checks whether the specified UART flag is set or not.
 373   * @param  __HANDLE__: specifies the UART Handle.
 374   *         This parameter can be UARTx where x: 1, 2, 3, 4 or 5 to select the USART or
 375   *         UART peripheral.
 376   * @param  __FLAG__: specifies the flag to check.
 377   *        This parameter can be one of the following values:
 378   *            @arg UART_FLAG_CTS:  CTS Change flag (not available for UART4 and UART5)
 379   *            @arg UART_FLAG_LBD:  LIN Break detection flag
 380   *            @arg UART_FLAG_TXE:  Transmit data register empty flag
 381   *            @arg UART_FLAG_TC:   Transmission Complete flag
 382   *            @arg UART_FLAG_RXNE: Receive data register not empty flag
 383   *            @arg UART_FLAG_IDLE: Idle Line detection flag
 384   *            @arg UART_FLAG_ORE:  OverRun Error flag
 385   *            @arg UART_FLAG_NE:   Noise Error flag
 386   *            @arg UART_FLAG_FE:   Framing Error flag
 387   *            @arg UART_FLAG_PE:   Parity Error flag
 388   * @retval The new state of __FLAG__ (TRUE or FALSE).
 389   */
 390 #define __HAL_UART_GET_FLAG(__HANDLE__, __FLAG__) (((__HANDLE__)->Instance->SR & (__FLAG__)) == (__FLAG__))
 391
 392 /** @brief  Clears the specified UART pending flag.
 393   * @param  __HANDLE__: specifies the UART Handle.
 394   *         UART Handle selects the USARTx or UARTy peripheral
 395   *         (USART,UART availability and x,y values depending on device).
 396   * @param  __FLAG__: specifies the flag to check.
 397   *          This parameter can be any combination of the following values:
 398   *            @arg UART_FLAG_CTS:  CTS Change flag (not available for UART4 and UART5).
 399   *            @arg UART_FLAG_LBD:  LIN Break detection flag.
 400   *            @arg UART_FLAG_TC:   Transmission Complete flag.
 401   *            @arg UART_FLAG_RXNE: Receive data register not empty flag.
 402   *
 403   * @note   PE (Parity error), FE (Framing error), NE (Noise error), ORE (OverRun
 404   *          error) and IDLE (Idle line detected) flags are cleared by software
 405   *          sequence: a read operation to USART_SR register followed by a read
 406   *          operation to USART_DR register.
 407   * @note   RXNE flag can be also cleared by a read to the USART_DR register.
 408   * @note   TC flag can be also cleared by software sequence: a read operation to
 409   *          USART_SR register followed by a write operation to USART_DR register.
 410   * @note   TXE flag is cleared only by a write to the USART_DR register.
 411   *
 412   */
 413 #define __HAL_UART_CLEAR_FLAG(__HANDLE__, __FLAG__) ((__HANDLE__)->Instance->SR = ~(__FLAG__))
 414
 415 /** @brief  Clears the UART PE pending flag.
 416   * @param  __HANDLE__: specifies the UART Handle.
 417   *         UART Handle selects the USARTx or UARTy peripheral
 418   *         (USART,UART availability and x,y values depending on device).
 419   */
 420 #define __HAL_UART_CLEAR_PEFLAG(__HANDLE__)     \
 421   do{                                           \
 422     __IO uint32_t tmpreg = 0x00U;               \
 423     tmpreg = (__HANDLE__)->Instance->SR;        \
 424     tmpreg = (__HANDLE__)->Instance->DR;        \
 425     UNUSED(tmpreg);                             \
 426   } while(0U)
 427
 428 /** @brief  Clears the UART FE pending flag.
 429   * @param  __HANDLE__: specifies the UART Handle.
 430   *         UART Handle selects the USARTx or UARTy peripheral
 431   *         (USART,UART availability and x,y values depending on device).
 432   */
 433 #define __HAL_UART_CLEAR_FEFLAG(__HANDLE__) __HAL_UART_CLEAR_PEFLAG(__HANDLE__)
 434
 435 /** @brief  Clears the UART NE pending flag.
 436   * @param  __HANDLE__: specifies the UART Handle.
 437   *         UART Handle selects the USARTx or UARTy peripheral
 438   *         (USART,UART availability and x,y values depending on device).
 439   */
 440 #define __HAL_UART_CLEAR_NEFLAG(__HANDLE__) __HAL_UART_CLEAR_PEFLAG(__HANDLE__)
 441
 442 /** @brief  Clears the UART ORE pending flag.
 443   * @param  __HANDLE__: specifies the UART Handle.
 444   *         UART Handle selects the USARTx or UARTy peripheral
 445   *         (USART,UART availability and x,y values depending on device).
 446   */
 447 #define __HAL_UART_CLEAR_OREFLAG(__HANDLE__) __HAL_UART_CLEAR_PEFLAG(__HANDLE__)
 448
 449 /** @brief  Clears the UART IDLE pending flag.
 450   * @param  __HANDLE__: specifies the UART Handle.
 451   *         UART Handle selects the USARTx or UARTy peripheral
 452   *         (USART,UART availability and x,y values depending on device).
 453   */
 454 #define __HAL_UART_CLEAR_IDLEFLAG(__HANDLE__) __HAL_UART_CLEAR_PEFLAG(__HANDLE__)
 455
 456 /** @brief  Enable the specified UART interrupt.
 457   * @param  __HANDLE__: specifies the UART Handle.
 458   *         UART Handle selects the USARTx or UARTy peripheral
 459   *         (USART,UART availability and x,y values depending on device).
 460   * @param  __INTERRUPT__: specifies the UART interrupt source to enable.
 461   *          This parameter can be one of the following values:
 462   *            @arg UART_IT_CTS:  CTS change interrupt
 463   *            @arg UART_IT_LBD:  LIN Break detection interrupt
 464   *            @arg UART_IT_TXE:  Transmit Data Register empty interrupt
 465   *            @arg UART_IT_TC:   Transmission complete interrupt
 466   *            @arg UART_IT_RXNE: Receive Data register not empty interrupt
 467   *            @arg UART_IT_IDLE: Idle line detection interrupt
 468   *            @arg UART_IT_PE:   Parity Error interrupt
 469   *            @arg UART_IT_ERR:  Error interrupt(Frame error, noise error, overrun error)
 470   */
 471 #define __HAL_UART_ENABLE_IT(__HANDLE__, __INTERRUPT__)   ((((__INTERRUPT__) >> 28U) == UART_CR1_REG_INDEX)? ((__HANDLE__)->Instance->CR1 |= ((__INTERRUPT__) & UART_IT_MASK)): \
 472                                                            (((__INTERRUPT__) >> 28U) == UART_CR2_REG_INDEX)? ((__HANDLE__)->Instance->CR2 |= ((__INTERRUPT__) & UART_IT_MASK)): \
 473                                                            ((__HANDLE__)->Instance->CR3 |= ((__INTERRUPT__) & UART_IT_MASK)))
 474
 475 /** @brief  Disable the specified UART interrupt.
 476   * @param  __HANDLE__: specifies the UART Handle.
 477   *         UART Handle selects the USARTx or UARTy peripheral
 478   *         (USART,UART availability and x,y values depending on device).
 479   * @param  __INTERRUPT__: specifies the UART interrupt source to disable.
 480   *          This parameter can be one of the following values:
 481   *            @arg UART_IT_CTS:  CTS change interrupt
 482   *            @arg UART_IT_LBD:  LIN Break detection interrupt
 483   *            @arg UART_IT_TXE:  Transmit Data Register empty interrupt
 484   *            @arg UART_IT_TC:   Transmission complete interrupt
 485   *            @arg UART_IT_RXNE: Receive Data register not empty interrupt
 486   *            @arg UART_IT_IDLE: Idle line detection interrupt
 487   *            @arg UART_IT_PE:   Parity Error interrupt
 488   *            @arg UART_IT_ERR:  Error interrupt(Frame error, noise error, overrun error)
 489   */
 490 #define __HAL_UART_DISABLE_IT(__HANDLE__, __INTERRUPT__)  ((((__INTERRUPT__) >> 28U) == UART_CR1_REG_INDEX)? ((__HANDLE__)->Instance->CR1 &= ~((__INTERRUPT__) & UART_IT_MASK)): \
 491                                                            (((__INTERRUPT__) >> 28U) == UART_CR2_REG_INDEX)? ((__HANDLE__)->Instance->CR2 &= ~((__INTERRUPT__) & UART_IT_MASK)): \
 492                                                            ((__HANDLE__)->Instance->CR3 &= ~ ((__INTERRUPT__) & UART_IT_MASK)))
 493
 494 /** @brief  Checks whether the specified UART interrupt has occurred or not.
 495   * @param  __HANDLE__: specifies the UART Handle.
 496   *         UART Handle selects the USARTx or UARTy peripheral
 497   *         (USART,UART availability and x,y values depending on device).
 498   * @param  __IT__: specifies the UART interrupt source to check.
 499   *          This parameter can be one of the following values:
 500   *            @arg UART_IT_CTS: CTS change interrupt (not available for UART4 and UART5)
 501   *            @arg UART_IT_LBD: LIN Break detection interrupt
 502   *            @arg UART_IT_TXE: Transmit Data Register empty interrupt
 503   *            @arg UART_IT_TC:  Transmission complete interrupt
 504   *            @arg UART_IT_RXNE: Receive Data register not empty interrupt
 505   *            @arg UART_IT_IDLE: Idle line detection interrupt
 506   *            @arg UART_IT_ERR: Error interrupt
 507   * @retval The new state of __IT__ (TRUE or FALSE).
 508   */
 509 #define __HAL_UART_GET_IT_SOURCE(__HANDLE__, __IT__) (((((__IT__) >> 28U) == UART_CR1_REG_INDEX)? (__HANDLE__)->Instance->CR1:(((((uint32_t)(__IT__)) >> 28U) == UART_CR2_REG_INDEX)? \
 510                                                       (__HANDLE__)->Instance->CR2 : (__HANDLE__)->Instance->CR3)) & (((uint32_t)(__IT__)) & UART_IT_MASK))
 511
 512 /** @brief  Enable CTS flow control
 513   *         This macro allows to enable CTS hardware flow control for a given UART instance,
 514   *         without need to call HAL_UART_Init() function.
 515   *         As involving direct access to UART registers, usage of this macro should be fully endorsed by user.
 516   * @note   As macro is expected to be used for modifying CTS Hw flow control feature activation, without need
 517   *         for USART instance Deinit/Init, following conditions for macro call should be fulfilled :
 518   *           - UART instance should have already been initialised (through call of HAL_UART_Init() )
 519   *           - macro could only be called when corresponding UART instance is disabled (i.e __HAL_UART_DISABLE(__HANDLE__))
 520   *             and should be followed by an Enable macro (i.e __HAL_UART_ENABLE(__HANDLE__)).
 521   * @param  __HANDLE__: specifies the UART Handle.
 522   *         The Handle Instance can be any USARTx (supporting the HW Flow control feature).
 523   *         It is used to select the USART peripheral (USART availability and x value depending on device).
 524   */
 525 #define __HAL_UART_HWCONTROL_CTS_ENABLE(__HANDLE__)        \
 526   do{                                                      \
 527     SET_BIT((__HANDLE__)->Instance->CR3, USART_CR3_CTSE);  \
 528     (__HANDLE__)->Init.HwFlowCtl |= USART_CR3_CTSE;        \
 529   } while(0U)
 530
 531 /** @brief  Disable CTS flow control
 532   *         This macro allows to disable CTS hardware flow control for a given UART instance,
 533   *         without need to call HAL_UART_Init() function.
 534   *         As involving direct access to UART registers, usage of this macro should be fully endorsed by user.
 535   * @note   As macro is expected to be used for modifying CTS Hw flow control feature activation, without need
 536   *         for USART instance Deinit/Init, following conditions for macro call should be fulfilled :
 537   *           - UART instance should have already been initialised (through call of HAL_UART_Init() )
 538   *           - macro could only be called when corresponding UART instance is disabled (i.e __HAL_UART_DISABLE(__HANDLE__))
 539   *             and should be followed by an Enable macro (i.e __HAL_UART_ENABLE(__HANDLE__)).
 540   * @param  __HANDLE__: specifies the UART Handle.
 541   *         The Handle Instance can be any USARTx (supporting the HW Flow control feature).
 542   *         It is used to select the USART peripheral (USART availability and x value depending on device).
 543   */
 544 #define __HAL_UART_HWCONTROL_CTS_DISABLE(__HANDLE__)        \
 545   do{                                                       \
 546     CLEAR_BIT((__HANDLE__)->Instance->CR3, USART_CR3_CTSE); \
 547     (__HANDLE__)->Init.HwFlowCtl &= ~(USART_CR3_CTSE);      \
 548   } while(0U)
 549
 550 /** @brief  Enable RTS flow control
 551   *         This macro allows to enable RTS hardware flow control for a given UART instance,
 552   *         without need to call HAL_UART_Init() function.
 553   *         As involving direct access to UART registers, usage of this macro should be fully endorsed by user.
 554   * @note   As macro is expected to be used for modifying RTS Hw flow control feature activation, without need
 555   *         for USART instance Deinit/Init, following conditions for macro call should be fulfilled :
 556   *           - UART instance should have already been initialised (through call of HAL_UART_Init() )
 557   *           - macro could only be called when corresponding UART instance is disabled (i.e __HAL_UART_DISABLE(__HANDLE__))
 558   *             and should be followed by an Enable macro (i.e __HAL_UART_ENABLE(__HANDLE__)).
 559   * @param  __HANDLE__: specifies the UART Handle.
 560   *         The Handle Instance can be any USARTx (supporting the HW Flow control feature).
 561   *         It is used to select the USART peripheral (USART availability and x value depending on device).
 562   */
 563 #define __HAL_UART_HWCONTROL_RTS_ENABLE(__HANDLE__)       \
 564   do{                                                     \
 565     SET_BIT((__HANDLE__)->Instance->CR3, USART_CR3_RTSE); \
 566     (__HANDLE__)->Init.HwFlowCtl |= USART_CR3_RTSE;       \
 567   } while(0U)
 568
 569 /** @brief  Disable RTS flow control
 570   *         This macro allows to disable RTS hardware flow control for a given UART instance,
 571   *         without need to call HAL_UART_Init() function.
 572   *         As involving direct access to UART registers, usage of this macro should be fully endorsed by user.
 573   * @note   As macro is expected to be used for modifying RTS Hw flow control feature activation, without need
 574   *         for USART instance Deinit/Init, following conditions for macro call should be fulfilled :
 575   *           - UART instance should have already been initialised (through call of HAL_UART_Init() )
 576   *           - macro could only be called when corresponding UART instance is disabled (i.e __HAL_UART_DISABLE(__HANDLE__))
 577   *             and should be followed by an Enable macro (i.e __HAL_UART_ENABLE(__HANDLE__)).
 578   * @param  __HANDLE__: specifies the UART Handle.
 579   *         The Handle Instance can be any USARTx (supporting the HW Flow control feature).
 580   *         It is used to select the USART peripheral (USART availability and x value depending on device).
 581   */
 582 #define __HAL_UART_HWCONTROL_RTS_DISABLE(__HANDLE__)       \
 583   do{                                                      \
 584     CLEAR_BIT((__HANDLE__)->Instance->CR3, USART_CR3_RTSE);\
 585     (__HANDLE__)->Init.HwFlowCtl &= ~(USART_CR3_RTSE);     \
 586   } while(0U)
 587
 588 #if defined(USART_CR3_ONEBIT)
 589 /** @brief  macros to enables the UART's one bit sample method
 590   * @param  __HANDLE__: specifies the UART Handle.
 591   */
 592 #define __HAL_UART_ONE_BIT_SAMPLE_ENABLE(__HANDLE__) ((__HANDLE__)->Instance->CR3|= USART_CR3_ONEBIT)
 593
 594 /** @brief  macros to disables the UART's one bit sample method
 595   * @param  __HANDLE__: specifies the UART Handle.
 596   * @retval None
 597   */
 598 #define __HAL_UART_ONE_BIT_SAMPLE_DISABLE(__HANDLE__) ((__HANDLE__)->Instance->CR3 &= (uint16_t)~((uint16_t)USART_CR3_ONEBIT))
 599 #endif /* USART_CR3_ONEBIT */
 600
 601 /** @brief  Enable UART
 602   * @param  __HANDLE__: specifies the UART Handle.
 603   */
 604 #define __HAL_UART_ENABLE(__HANDLE__)               ((__HANDLE__)->Instance->CR1 |=  USART_CR1_UE)
 605
 606 /** @brief  Disable UART
 607   * @param  __HANDLE__: specifies the UART Handle.
 608   */
 609 #define __HAL_UART_DISABLE(__HANDLE__)              ((__HANDLE__)->Instance->CR1 &=  ~USART_CR1_UE)
 610 /**
 611   * @}
 612   */
 613 /* Exported functions --------------------------------------------------------*/
 614 /** @addtogroup UART_Exported_Functions
 615   * @{
 616   */
 617
 618 /** @addtogroup UART_Exported_Functions_Group1
 619   * @{
 620   */
 621 /* Initialization/de-initialization functions  **********************************/
 622 HAL_StatusTypeDef HAL_UART_Init(UART_HandleTypeDef *huart);
 623 HAL_StatusTypeDef HAL_HalfDuplex_Init(UART_HandleTypeDef *huart);
 624 HAL_StatusTypeDef HAL_LIN_Init(UART_HandleTypeDef *huart, uint32_t BreakDetectLength);
 625 HAL_StatusTypeDef HAL_MultiProcessor_Init(UART_HandleTypeDef *huart, uint8_t Address, uint32_t WakeUpMethod);
 626 HAL_StatusTypeDef HAL_UART_DeInit (UART_HandleTypeDef *huart);
 627 void HAL_UART_MspInit(UART_HandleTypeDef *huart);
 628 void HAL_UART_MspDeInit(UART_HandleTypeDef *huart);
 629 /**
 630   * @}
 631   */
 632
 633 /** @addtogroup UART_Exported_Functions_Group2
 634   * @{
 635   */
 636 /* IO operation functions *******************************************************/
 637 HAL_StatusTypeDef HAL_UART_Transmit(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout);
 638 HAL_StatusTypeDef HAL_UART_Receive(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout);
 639 HAL_StatusTypeDef HAL_UART_Transmit_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size);
 640 HAL_StatusTypeDef HAL_UART_Receive_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size);
 641 HAL_StatusTypeDef HAL_UART_Transmit_DMA(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size);
 642 HAL_StatusTypeDef HAL_UART_Receive_DMA(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size);
 643 HAL_StatusTypeDef HAL_UART_DMAPause(UART_HandleTypeDef *huart);
 644 HAL_StatusTypeDef HAL_UART_DMAResume(UART_HandleTypeDef *huart);
 645 HAL_StatusTypeDef HAL_UART_DMAStop(UART_HandleTypeDef *huart);
 646 /* Transfer Abort functions */
 647 HAL_StatusTypeDef HAL_UART_Abort(UART_HandleTypeDef *huart);
 648 HAL_StatusTypeDef HAL_UART_AbortTransmit(UART_HandleTypeDef *huart);
 649 HAL_StatusTypeDef HAL_UART_AbortReceive(UART_HandleTypeDef *huart);
 650 HAL_StatusTypeDef HAL_UART_Abort_IT(UART_HandleTypeDef *huart);
 651 HAL_StatusTypeDef HAL_UART_AbortTransmit_IT(UART_HandleTypeDef *huart);
 652 HAL_StatusTypeDef HAL_UART_AbortReceive_IT(UART_HandleTypeDef *huart);
 653
 654 void HAL_UART_IRQHandler(UART_HandleTypeDef *huart);
 655 void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart);
 656 void HAL_UART_TxHalfCpltCallback(UART_HandleTypeDef *huart);
 657 void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart);
 658 void HAL_UART_RxHalfCpltCallback(UART_HandleTypeDef *huart);
 659 void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart);
 660 void HAL_UART_AbortCpltCallback (UART_HandleTypeDef *huart);
 661 void HAL_UART_AbortTransmitCpltCallback (UART_HandleTypeDef *huart);
 662 void HAL_UART_AbortReceiveCpltCallback (UART_HandleTypeDef *huart);
 663 /**
 664   * @}
 665   */
 666
 667 /** @addtogroup UART_Exported_Functions_Group3
 668   * @{
 669   */
 670 /* Peripheral Control functions  ************************************************/
 671 HAL_StatusTypeDef HAL_LIN_SendBreak(UART_HandleTypeDef *huart);
 672 HAL_StatusTypeDef HAL_MultiProcessor_EnterMuteMode(UART_HandleTypeDef *huart);
 673 HAL_StatusTypeDef HAL_MultiProcessor_ExitMuteMode(UART_HandleTypeDef *huart);
 674 HAL_StatusTypeDef HAL_HalfDuplex_EnableTransmitter(UART_HandleTypeDef *huart);
 675 HAL_StatusTypeDef HAL_HalfDuplex_EnableReceiver(UART_HandleTypeDef *huart);
 676 /**
 677   * @}
 678   */
 679
 680 /** @addtogroup UART_Exported_Functions_Group4
 681   * @{
 682   */
 683 /* Peripheral State functions  **************************************************/
 684 HAL_UART_StateTypeDef HAL_UART_GetState(UART_HandleTypeDef *huart);
 685 uint32_t HAL_UART_GetError(UART_HandleTypeDef *huart);
 686 /**
 687   * @}
 688   */
 689
 690 /**
 691   * @}
 692   */
 693 /* Private types -------------------------------------------------------------*/
 694 /* Private variables ---------------------------------------------------------*/
 695 /* Private constants ---------------------------------------------------------*/
 696 /** @defgroup UART_Private_Constants UART Private Constants
 697   * @{
 698   */
 699 /** @brief UART interruptions flag mask
 700   *
 701   */
 702 #define UART_IT_MASK                     0x0000FFFFU
 703
 704 #define UART_CR1_REG_INDEX               1U
 705 #define UART_CR2_REG_INDEX               2U
 706 #define UART_CR3_REG_INDEX               3U
 707 /**
 708   * @}
 709   */
 710
 711 /* Private macros ------------------------------------------------------------*/
 712 /** @defgroup UART_Private_Macros UART Private Macros
 713   * @{
 714   */
 715 #define IS_UART_WORD_LENGTH(LENGTH) (((LENGTH) == UART_WORDLENGTH_8B) || \
 716                                      ((LENGTH) == UART_WORDLENGTH_9B))
 717 #define IS_UART_LIN_WORD_LENGTH(LENGTH) (((LENGTH) == UART_WORDLENGTH_8B))
 718 #define IS_UART_STOPBITS(STOPBITS) (((STOPBITS) == UART_STOPBITS_1) || \
 719                                     ((STOPBITS) == UART_STOPBITS_2))
 720 #define IS_UART_PARITY(PARITY) (((PARITY) == UART_PARITY_NONE) || \
 721                                 ((PARITY) == UART_PARITY_EVEN) || \
 722                                 ((PARITY) == UART_PARITY_ODD))
 723 #define IS_UART_HARDWARE_FLOW_CONTROL(CONTROL)\
 724                               (((CONTROL) == UART_HWCONTROL_NONE) || \
 725                                ((CONTROL) == UART_HWCONTROL_RTS) || \
 726                                ((CONTROL) == UART_HWCONTROL_CTS) || \
 727                                ((CONTROL) == UART_HWCONTROL_RTS_CTS))
 728 #define IS_UART_MODE(MODE) ((((MODE) & 0x0000FFF3U) == 0x00U) && ((MODE) != 0x00U))
 729 #define IS_UART_STATE(STATE) (((STATE) == UART_STATE_DISABLE) || \
 730                               ((STATE) == UART_STATE_ENABLE))
 731 #if defined(USART_CR1_OVER8)
 732 #define IS_UART_OVERSAMPLING(SAMPLING) (((SAMPLING) == UART_OVERSAMPLING_16) || \
 733                                         ((SAMPLING) == UART_OVERSAMPLING_8))
 734 #endif /* USART_CR1_OVER8 */
 735 #define IS_UART_LIN_OVERSAMPLING(SAMPLING) (((SAMPLING) == UART_OVERSAMPLING_16))
 736 #define IS_UART_LIN_BREAK_DETECT_LENGTH(LENGTH) (((LENGTH) == UART_LINBREAKDETECTLENGTH_10B) || \
 737                                                  ((LENGTH) == UART_LINBREAKDETECTLENGTH_11B))
 738 #define IS_UART_WAKEUPMETHOD(WAKEUP) (((WAKEUP) == UART_WAKEUPMETHOD_IDLELINE) || \
 739                                       ((WAKEUP) == UART_WAKEUPMETHOD_ADDRESSMARK))
 740 #define IS_UART_BAUDRATE(BAUDRATE) ((BAUDRATE) < 4500001U)
 741 #define IS_UART_ADDRESS(ADDRESS) ((ADDRESS) <= 0x0FU)
 742
 743 #define UART_DIV_SAMPLING16(_PCLK_, _BAUD_)            (((_PCLK_)*25U)/(4U*(_BAUD_)))
 744 #define UART_DIVMANT_SAMPLING16(_PCLK_, _BAUD_)        (UART_DIV_SAMPLING16((_PCLK_), (_BAUD_))/100U)
 745 #define UART_DIVFRAQ_SAMPLING16(_PCLK_, _BAUD_)        (((UART_DIV_SAMPLING16((_PCLK_), (_BAUD_)) - (UART_DIVMANT_SAMPLING16((_PCLK_), (_BAUD_)) * 100U)) * 16U + 50U) / 100U)
 746 /* UART BRR = mantissa + overflow + fraction
 747             = (UART DIVMANT << 4) + (UART DIVFRAQ & 0xF0) + (UART DIVFRAQ & 0x0FU) */
 748 #define UART_BRR_SAMPLING16(_PCLK_, _BAUD_)            (((UART_DIVMANT_SAMPLING16((_PCLK_), (_BAUD_)) << 4U) + \
 749                                                         (UART_DIVFRAQ_SAMPLING16((_PCLK_), (_BAUD_)) & 0xF0U)) + \
 750                                                         (UART_DIVFRAQ_SAMPLING16((_PCLK_), (_BAUD_)) & 0x0FU))
 751
 752 #define UART_DIV_SAMPLING8(_PCLK_, _BAUD_)             (((_PCLK_)*25U)/(2U*(_BAUD_)))
 753 #define UART_DIVMANT_SAMPLING8(_PCLK_, _BAUD_)         (UART_DIV_SAMPLING8((_PCLK_), (_BAUD_))/100U)
 754 #define UART_DIVFRAQ_SAMPLING8(_PCLK_, _BAUD_)         (((UART_DIV_SAMPLING8((_PCLK_), (_BAUD_)) - (UART_DIVMANT_SAMPLING8((_PCLK_), (_BAUD_)) * 100U)) * 8U + 50U) / 100U)
 755 /* UART BRR = mantissa + overflow + fraction
 756             = (UART DIVMANT << 4) + ((UART DIVFRAQ & 0xF8) << 1) + (UART DIVFRAQ & 0x07U) */
 757 #define UART_BRR_SAMPLING8(_PCLK_, _BAUD_)             (((UART_DIVMANT_SAMPLING8((_PCLK_), (_BAUD_)) << 4U) + \
 758                                                         ((UART_DIVFRAQ_SAMPLING8((_PCLK_), (_BAUD_)) & 0xF8U) << 1U)) + \
 759                                                         (UART_DIVFRAQ_SAMPLING8((_PCLK_), (_BAUD_)) & 0x07U))
 760 /**
 761   * @}
 762   */
 763
 764 /* Private functions ---------------------------------------------------------*/
 765 /** @defgroup UART_Private_Functions UART Private Functions
 766   * @{
 767   */
 768
 769 /**
 770   * @}
 771   */
 772
 773 /**
 774   * @}
 775   */
 776
 777 /**
 778   * @}
 779   */
 780
 781 #ifdef __cplusplus
 782 }
 783 #endif
 784
 785 #endif /* __STM32F1xx_HAL_UART_H */
 786
 787 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/