Subversion Repositories EDIS_Ignition

Rev

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

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