Subversion Repositories LedShow

Rev

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