Back to home page

LXR
 
 

    

File indexing completed on 2025-05-11 08:23:36 

0001 /**
0002   ******************************************************************************
0003   * @file    stm32h7xx_hal_usart.h
0004   * @author  MCD Application Team
0005   * @brief   Header file of USART HAL module.
0006   ******************************************************************************
0007   * @attention
0008   *
0009   * Copyright (c) 2017 STMicroelectronics.
0010   * All rights reserved.
0011   *
0012   * This software is licensed under terms that can be found in the LICENSE file
0013   * in the root directory of this software component.
0014   * If no LICENSE file comes with this software, it is provided AS-IS.
0015   *
0016   ******************************************************************************
0017   */
0018 
0019 /* Define to prevent recursive inclusion -------------------------------------*/
0020 #ifndef STM32H7xx_HAL_USART_H
0021 #define STM32H7xx_HAL_USART_H
0022 
0023 #ifdef __cplusplus
0024 extern "C" {
0025 #endif
0026 
0027 /* Includes ------------------------------------------------------------------*/
0028 #include "stm32h7xx_hal_def.h"
0029 
0030 /** @addtogroup STM32H7xx_HAL_Driver
0031   * @{
0032   */
0033 
0034 /** @addtogroup USART
0035   * @{
0036   */
0037 
0038 /* Exported types ------------------------------------------------------------*/
0039 /** @defgroup USART_Exported_Types USART Exported Types
0040   * @ingroup RTEMSBSPsARMSTM32H7
0041   * @{
0042   */
0043 
0044 /**
0045   * @brief USART Init Structure definition
0046   */
0047 typedef struct
0048 {
0049   uint32_t BaudRate;                  /*!< This member configures the Usart communication baud rate.
0050                                            The baud rate is computed using the following formula:
0051                                               Baud Rate Register[15:4] = ((2 * fclk_pres) /
0052                                               ((huart->Init.BaudRate)))[15:4]
0053                                               Baud Rate Register[3]    = 0
0054                                               Baud Rate Register[2:0]  =  (((2 * fclk_pres) /
0055                                               ((huart->Init.BaudRate)))[3:0]) >> 1
0056                                               where fclk_pres is the USART input clock frequency (fclk)
0057                                               divided by a prescaler.
0058                                            @note  Oversampling by 8 is systematically applied to
0059                                                   achieve high baud rates. */
0060 
0061   uint32_t WordLength;                /*!< Specifies the number of data bits transmitted or received in a frame.
0062                                            This parameter can be a value of @ref USARTEx_Word_Length. */
0063 
0064   uint32_t StopBits;                  /*!< Specifies the number of stop bits transmitted.
0065                                            This parameter can be a value of @ref USART_Stop_Bits. */
0066 
0067   uint32_t Parity;                   /*!< Specifies the parity mode.
0068                                            This parameter can be a value of @ref USART_Parity
0069                                            @note When parity is enabled, the computed parity is inserted
0070                                                  at the MSB position of the transmitted data (9th bit when
0071                                                  the word length is set to 9 data bits; 8th bit when the
0072                                                  word length is set to 8 data bits). */
0073 
0074   uint32_t Mode;                      /*!< Specifies whether the Receive or Transmit mode is enabled or disabled.
0075                                            This parameter can be a value of @ref USART_Mode. */
0076 
0077   uint32_t CLKPolarity;               /*!< Specifies the steady state of the serial clock.
0078                                            This parameter can be a value of @ref USART_Clock_Polarity. */
0079 
0080   uint32_t CLKPhase;                  /*!< Specifies the clock transition on which the bit capture is made.
0081                                            This parameter can be a value of @ref USART_Clock_Phase. */
0082 
0083   uint32_t CLKLastBit;                /*!< Specifies whether the clock pulse corresponding to the last transmitted
0084                                            data bit (MSB) has to be output on the SCLK pin in synchronous mode.
0085                                            This parameter can be a value of @ref USART_Last_Bit. */
0086 
0087   uint32_t ClockPrescaler;            /*!< Specifies the prescaler value used to divide the USART clock source.
0088                                            This parameter can be a value of @ref USART_ClockPrescaler. */
0089 } USART_InitTypeDef;
0090 
0091 /**
0092   * @brief HAL USART State structures definition
0093   */
0094 typedef enum
0095 {
0096   HAL_USART_STATE_RESET             = 0x00U,    /*!< Peripheral is not initialized                  */
0097   HAL_USART_STATE_READY             = 0x01U,    /*!< Peripheral Initialized and ready for use       */
0098   HAL_USART_STATE_BUSY              = 0x02U,    /*!< an internal process is ongoing                 */
0099   HAL_USART_STATE_BUSY_TX           = 0x12U,    /*!< Data Transmission process is ongoing           */
0100   HAL_USART_STATE_BUSY_RX           = 0x22U,    /*!< Data Reception process is ongoing              */
0101   HAL_USART_STATE_BUSY_TX_RX        = 0x32U,    /*!< Data Transmission Reception process is ongoing */
0102   HAL_USART_STATE_TIMEOUT           = 0x03U,    /*!< Timeout state                                  */
0103   HAL_USART_STATE_ERROR             = 0x04U     /*!< Error                                          */
0104 } HAL_USART_StateTypeDef;
0105 
0106 /**
0107   * @brief  USART clock sources definitions
0108   */
0109 typedef enum
0110 {
0111   USART_CLOCKSOURCE_D2PCLK1    = 0x00U,    /*!< Domain2 PCLK1 clock source */
0112   USART_CLOCKSOURCE_D2PCLK2    = 0x01U,    /*!< Domain2 PCLK2 clock source */
0113   USART_CLOCKSOURCE_PLL2       = 0x02U,    /*!< PLL2Q clock source         */
0114   USART_CLOCKSOURCE_PLL3       = 0x04U,    /*!< PLL3Q clock source         */
0115   USART_CLOCKSOURCE_HSI        = 0x08U,    /*!< HSI clock source           */
0116   USART_CLOCKSOURCE_CSI        = 0x10U,    /*!< CSI clock source           */
0117   USART_CLOCKSOURCE_LSE        = 0x20U,    /*!< LSE clock source           */
0118   USART_CLOCKSOURCE_UNDEFINED  = 0x40U     /*!< Undefined clock source     */
0119 } USART_ClockSourceTypeDef;
0120 
0121 /**
0122   * @brief  USART handle Structure definition
0123   */
0124 typedef struct __USART_HandleTypeDef
0125 {
0126   USART_TypeDef                 *Instance;               /*!< USART registers base address        */
0127 
0128   USART_InitTypeDef             Init;                    /*!< USART communication parameters      */
0129 
0130   const uint8_t                 *pTxBuffPtr;             /*!< Pointer to USART Tx transfer Buffer */
0131 
0132   uint16_t                      TxXferSize;              /*!< USART Tx Transfer size              */
0133 
0134   __IO uint16_t                 TxXferCount;             /*!< USART Tx Transfer Counter           */
0135 
0136   uint8_t                       *pRxBuffPtr;             /*!< Pointer to USART Rx transfer Buffer */
0137 
0138   uint16_t                      RxXferSize;              /*!< USART Rx Transfer size              */
0139 
0140   __IO uint16_t                 RxXferCount;             /*!< USART Rx Transfer Counter           */
0141 
0142   uint16_t                      Mask;                    /*!< USART Rx RDR register mask          */
0143 
0144   uint16_t                      NbRxDataToProcess;       /*!< Number of data to process during RX ISR execution */
0145 
0146   uint16_t                      NbTxDataToProcess;       /*!< Number of data to process during TX ISR execution */
0147 
0148   uint32_t                      SlaveMode;               /*!< Enable/Disable USART SPI Slave Mode. This parameter can be a value
0149                                                               of @ref USARTEx_Slave_Mode */
0150 
0151   uint32_t                      FifoMode;                /*!< Specifies if the FIFO mode will be used. This parameter can be a value
0152                                                               of @ref USARTEx_FIFO_mode. */
0153 
0154   void (*RxISR)(struct __USART_HandleTypeDef *husart);   /*!< Function pointer on Rx IRQ handler  */
0155 
0156   void (*TxISR)(struct __USART_HandleTypeDef *husart);   /*!< Function pointer on Tx IRQ handler  */
0157 
0158   DMA_HandleTypeDef             *hdmatx;                 /*!< USART Tx DMA Handle parameters      */
0159 
0160   DMA_HandleTypeDef             *hdmarx;                 /*!< USART Rx DMA Handle parameters      */
0161 
0162   HAL_LockTypeDef               Lock;                    /*!< Locking object                      */
0163 
0164   __IO HAL_USART_StateTypeDef   State;                   /*!< USART communication state           */
0165 
0166   __IO uint32_t                 ErrorCode;               /*!< USART Error code                    */
0167 
0168 #if (USE_HAL_USART_REGISTER_CALLBACKS == 1)
0169   void (* TxHalfCpltCallback)(struct __USART_HandleTypeDef *husart);        /*!< USART Tx Half Complete Callback        */
0170   void (* TxCpltCallback)(struct __USART_HandleTypeDef *husart);            /*!< USART Tx Complete Callback             */
0171   void (* RxHalfCpltCallback)(struct __USART_HandleTypeDef *husart);        /*!< USART Rx Half Complete Callback        */
0172   void (* RxCpltCallback)(struct __USART_HandleTypeDef *husart);            /*!< USART Rx Complete Callback             */
0173   void (* TxRxCpltCallback)(struct __USART_HandleTypeDef *husart);          /*!< USART Tx Rx Complete Callback          */
0174   void (* ErrorCallback)(struct __USART_HandleTypeDef *husart);             /*!< USART Error Callback                   */
0175   void (* AbortCpltCallback)(struct __USART_HandleTypeDef *husart);         /*!< USART Abort Complete Callback          */
0176   void (* RxFifoFullCallback)(struct __USART_HandleTypeDef *husart);        /*!< USART Rx Fifo Full Callback            */
0177   void (* TxFifoEmptyCallback)(struct __USART_HandleTypeDef *husart);       /*!< USART Tx Fifo Empty Callback           */
0178 
0179   void (* MspInitCallback)(struct __USART_HandleTypeDef *husart);           /*!< USART Msp Init callback                */
0180   void (* MspDeInitCallback)(struct __USART_HandleTypeDef *husart);         /*!< USART Msp DeInit callback              */
0181 #endif  /* USE_HAL_USART_REGISTER_CALLBACKS */
0182 
0183 } USART_HandleTypeDef;
0184 
0185 #if (USE_HAL_USART_REGISTER_CALLBACKS == 1)
0186 /**
0187   * @brief  HAL USART Callback ID enumeration definition
0188   */
0189 typedef enum
0190 {
0191   HAL_USART_TX_HALFCOMPLETE_CB_ID         = 0x00U,    /*!< USART Tx Half Complete Callback ID        */
0192   HAL_USART_TX_COMPLETE_CB_ID             = 0x01U,    /*!< USART Tx Complete Callback ID             */
0193   HAL_USART_RX_HALFCOMPLETE_CB_ID         = 0x02U,    /*!< USART Rx Half Complete Callback ID        */
0194   HAL_USART_RX_COMPLETE_CB_ID             = 0x03U,    /*!< USART Rx Complete Callback ID             */
0195   HAL_USART_TX_RX_COMPLETE_CB_ID          = 0x04U,    /*!< USART Tx Rx Complete Callback ID          */
0196   HAL_USART_ERROR_CB_ID                   = 0x05U,    /*!< USART Error Callback ID                   */
0197   HAL_USART_ABORT_COMPLETE_CB_ID          = 0x06U,    /*!< USART Abort Complete Callback ID          */
0198   HAL_USART_RX_FIFO_FULL_CB_ID            = 0x07U,    /*!< USART Rx Fifo Full Callback ID            */
0199   HAL_USART_TX_FIFO_EMPTY_CB_ID           = 0x08U,    /*!< USART Tx Fifo Empty Callback ID           */
0200 
0201   HAL_USART_MSPINIT_CB_ID                 = 0x09U,    /*!< USART MspInit callback ID                 */
0202   HAL_USART_MSPDEINIT_CB_ID               = 0x0AU     /*!< USART MspDeInit callback ID               */
0203 
0204 } HAL_USART_CallbackIDTypeDef;
0205 
0206 /**
0207   * @brief  HAL USART Callback pointer definition
0208   */
0209 typedef  void (*pUSART_CallbackTypeDef)(USART_HandleTypeDef *husart);  /*!< pointer to an USART callback function */
0210 
0211 #endif /* USE_HAL_USART_REGISTER_CALLBACKS */
0212 
0213 /**
0214   * @}
0215   */
0216 
0217 /* Exported constants --------------------------------------------------------*/
0218 /** @defgroup USART_Exported_Constants USART Exported Constants
0219   * @ingroup RTEMSBSPsARMSTM32H7
0220   * @{
0221   */
0222 
0223 /** @defgroup USART_Error_Definition   USART Error Definition
0224   * @ingroup RTEMSBSPsARMSTM32H7
0225   * @{
0226   */
0227 #define HAL_USART_ERROR_NONE             (0x00000000U)    /*!< No error                  */
0228 #define HAL_USART_ERROR_PE               (0x00000001U)    /*!< Parity error              */
0229 #define HAL_USART_ERROR_NE               (0x00000002U)    /*!< Noise error               */
0230 #define HAL_USART_ERROR_FE               (0x00000004U)    /*!< Frame error               */
0231 #define HAL_USART_ERROR_ORE              (0x00000008U)    /*!< Overrun error             */
0232 #define HAL_USART_ERROR_DMA              (0x00000010U)    /*!< DMA transfer error        */
0233 #define HAL_USART_ERROR_UDR              (0x00000020U)    /*!< SPI slave underrun error  */
0234 #if (USE_HAL_USART_REGISTER_CALLBACKS == 1)
0235 #define HAL_USART_ERROR_INVALID_CALLBACK (0x00000040U)    /*!< Invalid Callback error    */
0236 #endif /* USE_HAL_USART_REGISTER_CALLBACKS */
0237 #define  HAL_USART_ERROR_RTO              (0x00000080U)    /*!< Receiver Timeout error  */
0238 /**
0239   * @}
0240   */
0241 
0242 /** @defgroup USART_Stop_Bits  USART Number of Stop Bits
0243   * @ingroup RTEMSBSPsARMSTM32H7
0244   * @{
0245   */
0246 #define USART_STOPBITS_0_5                   USART_CR2_STOP_0                     /*!< USART frame with 0.5 stop bit  */
0247 #define USART_STOPBITS_1                     0x00000000U                          /*!< USART frame with 1 stop bit    */
0248 #define USART_STOPBITS_1_5                  (USART_CR2_STOP_0 | USART_CR2_STOP_1) /*!< USART frame with 1.5 stop bits */
0249 #define USART_STOPBITS_2                     USART_CR2_STOP_1                     /*!< USART frame with 2 stop bits   */
0250 /**
0251   * @}
0252   */
0253 
0254 /** @defgroup USART_Parity    USART Parity
0255   * @ingroup RTEMSBSPsARMSTM32H7
0256   * @{
0257   */
0258 #define USART_PARITY_NONE                   0x00000000U                      /*!< No parity   */
0259 #define USART_PARITY_EVEN                   USART_CR1_PCE                    /*!< Even parity */
0260 #define USART_PARITY_ODD                    (USART_CR1_PCE | USART_CR1_PS)   /*!< Odd parity  */
0261 /**
0262   * @}
0263   */
0264 
0265 /** @defgroup USART_Mode   USART Mode
0266   * @ingroup RTEMSBSPsARMSTM32H7
0267   * @{
0268   */
0269 #define USART_MODE_RX                       USART_CR1_RE                    /*!< RX mode        */
0270 #define USART_MODE_TX                       USART_CR1_TE                    /*!< TX mode        */
0271 #define USART_MODE_TX_RX                    (USART_CR1_TE |USART_CR1_RE)    /*!< RX and TX mode */
0272 /**
0273   * @}
0274   */
0275 
0276 /** @defgroup USART_Clock  USART Clock
0277   * @ingroup RTEMSBSPsARMSTM32H7
0278   * @{
0279   */
0280 #define USART_CLOCK_DISABLE                 0x00000000U       /*!< USART clock disable */
0281 #define USART_CLOCK_ENABLE                  USART_CR2_CLKEN   /*!< USART clock enable  */
0282 /**
0283   * @}
0284   */
0285 
0286 /** @defgroup USART_Clock_Polarity  USART Clock Polarity
0287   * @ingroup RTEMSBSPsARMSTM32H7
0288   * @{
0289   */
0290 #define USART_POLARITY_LOW                  0x00000000U      /*!< Driver enable signal is active high */
0291 #define USART_POLARITY_HIGH                 USART_CR2_CPOL   /*!< Driver enable signal is active low  */
0292 /**
0293   * @}
0294   */
0295 
0296 /** @defgroup USART_Clock_Phase   USART Clock Phase
0297   * @ingroup RTEMSBSPsARMSTM32H7
0298   * @{
0299   */
0300 #define USART_PHASE_1EDGE                   0x00000000U      /*!< USART frame phase on first clock transition  */
0301 #define USART_PHASE_2EDGE                   USART_CR2_CPHA   /*!< USART frame phase on second clock transition */
0302 /**
0303   * @}
0304   */
0305 
0306 /** @defgroup USART_Last_Bit  USART Last Bit
0307   * @ingroup RTEMSBSPsARMSTM32H7
0308   * @{
0309   */
0310 #define USART_LASTBIT_DISABLE               0x00000000U      /*!< USART frame last data bit clock pulse not output to SCLK pin */
0311 #define USART_LASTBIT_ENABLE                USART_CR2_LBCL   /*!< USART frame last data bit clock pulse output to SCLK pin     */
0312 /**
0313   * @}
0314   */
0315 
0316 /** @defgroup USART_ClockPrescaler  USART Clock Prescaler
0317   * @ingroup RTEMSBSPsARMSTM32H7
0318   * @{
0319   */
0320 #define USART_PRESCALER_DIV1    0x00000000U  /*!< fclk_pres = fclk     */
0321 #define USART_PRESCALER_DIV2    0x00000001U  /*!< fclk_pres = fclk/2   */
0322 #define USART_PRESCALER_DIV4    0x00000002U  /*!< fclk_pres = fclk/4   */
0323 #define USART_PRESCALER_DIV6    0x00000003U  /*!< fclk_pres = fclk/6   */
0324 #define USART_PRESCALER_DIV8    0x00000004U  /*!< fclk_pres = fclk/8   */
0325 #define USART_PRESCALER_DIV10   0x00000005U  /*!< fclk_pres = fclk/10  */
0326 #define USART_PRESCALER_DIV12   0x00000006U  /*!< fclk_pres = fclk/12  */
0327 #define USART_PRESCALER_DIV16   0x00000007U  /*!< fclk_pres = fclk/16  */
0328 #define USART_PRESCALER_DIV32   0x00000008U  /*!< fclk_pres = fclk/32  */
0329 #define USART_PRESCALER_DIV64   0x00000009U  /*!< fclk_pres = fclk/64  */
0330 #define USART_PRESCALER_DIV128  0x0000000AU  /*!< fclk_pres = fclk/128 */
0331 #define USART_PRESCALER_DIV256  0x0000000BU  /*!< fclk_pres = fclk/256 */
0332 
0333 /**
0334   * @}
0335   */
0336 
0337 /** @defgroup USART_Request_Parameters  USART Request Parameters
0338   * @ingroup RTEMSBSPsARMSTM32H7
0339   * @{
0340   */
0341 #define USART_RXDATA_FLUSH_REQUEST        USART_RQR_RXFRQ        /*!< Receive Data flush Request  */
0342 #define USART_TXDATA_FLUSH_REQUEST        USART_RQR_TXFRQ        /*!< Transmit data flush Request */
0343 /**
0344   * @}
0345   */
0346 
0347 /** @defgroup USART_Flags      USART Flags
0348   * @ingroup RTEMSBSPsARMSTM32H7
0349   *        Elements values convention: 0xXXXX
0350   *           - 0xXXXX  : Flag mask in the ISR register
0351   * @{
0352   */
0353 #define USART_FLAG_TXFT                     USART_ISR_TXFT          /*!< USART TXFIFO threshold flag                */
0354 #define USART_FLAG_RXFT                     USART_ISR_RXFT          /*!< USART RXFIFO threshold flag                */
0355 #define USART_FLAG_RXFF                     USART_ISR_RXFF          /*!< USART RXFIFO Full flag                     */
0356 #define USART_FLAG_TXFE                     USART_ISR_TXFE          /*!< USART TXFIFO Empty flag                    */
0357 #define USART_FLAG_REACK                    USART_ISR_REACK         /*!< USART receive enable acknowledge flag      */
0358 #define USART_FLAG_TEACK                    USART_ISR_TEACK         /*!< USART transmit enable acknowledge flag     */
0359 #define USART_FLAG_BUSY                     USART_ISR_BUSY          /*!< USART busy flag                            */
0360 #define USART_FLAG_UDR                      USART_ISR_UDR           /*!< SPI slave underrun error flag              */
0361 #define USART_FLAG_TXE                      USART_ISR_TXE_TXFNF     /*!< USART transmit data register empty         */
0362 #define USART_FLAG_TXFNF                    USART_ISR_TXE_TXFNF     /*!< USART TXFIFO not full                      */
0363 #define USART_FLAG_RTOF                     USART_ISR_RTOF          /*!< USART receiver timeout flag                */
0364 #define USART_FLAG_TC                       USART_ISR_TC            /*!< USART transmission complete                */
0365 #define USART_FLAG_RXNE                     USART_ISR_RXNE_RXFNE    /*!< USART read data register not empty         */
0366 #define USART_FLAG_RXFNE                    USART_ISR_RXNE_RXFNE    /*!< USART RXFIFO not empty                     */
0367 #define USART_FLAG_IDLE                     USART_ISR_IDLE          /*!< USART idle flag                            */
0368 #define USART_FLAG_ORE                      USART_ISR_ORE           /*!< USART overrun error                        */
0369 #define USART_FLAG_NE                       USART_ISR_NE            /*!< USART noise error                          */
0370 #define USART_FLAG_FE                       USART_ISR_FE            /*!< USART frame error                          */
0371 #define USART_FLAG_PE                       USART_ISR_PE            /*!< USART parity error                         */
0372 /**
0373   * @}
0374   */
0375 
0376 /** @defgroup USART_Interrupt_definition USART Interrupts Definition
0377   * @ingroup RTEMSBSPsARMSTM32H7
0378   *        Elements values convention: 0000ZZZZ0XXYYYYYb
0379   *           - YYYYY  : Interrupt source position in the XX register (5bits)
0380   *           - XX  : Interrupt source register (2bits)
0381   *                 - 01: CR1 register
0382   *                 - 10: CR2 register
0383   *                 - 11: CR3 register
0384   *           - ZZZZ  : Flag position in the ISR register(4bits)
0385   * @{
0386   */
0387 
0388 #define USART_IT_PE                          0x0028U     /*!< USART parity error interruption                 */
0389 #define USART_IT_TXE                         0x0727U     /*!< USART transmit data register empty interruption */
0390 #define USART_IT_TXFNF                       0x0727U     /*!< USART TX FIFO not full interruption             */
0391 #define USART_IT_TC                          0x0626U     /*!< USART transmission complete interruption        */
0392 #define USART_IT_RXNE                        0x0525U     /*!< USART read data register not empty interruption */
0393 #define USART_IT_RXFNE                       0x0525U     /*!< USART RXFIFO not empty interruption             */
0394 #define USART_IT_IDLE                        0x0424U     /*!< USART idle interruption                         */
0395 #define USART_IT_ERR                         0x0060U     /*!< USART error interruption                        */
0396 #define USART_IT_ORE                         0x0300U     /*!< USART overrun error interruption                */
0397 #define USART_IT_NE                          0x0200U     /*!< USART noise error interruption                  */
0398 #define USART_IT_FE                          0x0100U     /*!< USART frame error interruption                  */
0399 #define USART_IT_RXFF                        0x183FU     /*!< USART RXFIFO full interruption                  */
0400 #define USART_IT_TXFE                        0x173EU     /*!< USART TXFIFO empty interruption                 */
0401 #define USART_IT_RXFT                        0x1A7CU     /*!< USART RXFIFO threshold reached interruption     */
0402 #define USART_IT_TXFT                        0x1B77U     /*!< USART TXFIFO threshold reached interruption     */
0403 
0404 /**
0405   * @}
0406   */
0407 
0408 /** @defgroup USART_IT_CLEAR_Flags    USART Interruption Clear Flags
0409   * @ingroup RTEMSBSPsARMSTM32H7
0410   * @{
0411   */
0412 #define USART_CLEAR_PEF                       USART_ICR_PECF            /*!< Parity Error Clear Flag             */
0413 #define USART_CLEAR_FEF                       USART_ICR_FECF            /*!< Framing Error Clear Flag            */
0414 #define USART_CLEAR_NEF                       USART_ICR_NECF            /*!< Noise Error detected Clear Flag     */
0415 #define USART_CLEAR_OREF                      USART_ICR_ORECF           /*!< OverRun Error Clear Flag            */
0416 #define USART_CLEAR_IDLEF                     USART_ICR_IDLECF          /*!< IDLE line detected Clear Flag       */
0417 #define USART_CLEAR_TCF                       USART_ICR_TCCF            /*!< Transmission Complete Clear Flag    */
0418 #define USART_CLEAR_UDRF                      USART_ICR_UDRCF           /*!< SPI slave underrun error Clear Flag */
0419 #define USART_CLEAR_TXFECF                    USART_ICR_TXFECF          /*!< TXFIFO Empty Clear Flag             */
0420 #define USART_CLEAR_RTOF                      USART_ICR_RTOCF           /*!< USART receiver timeout clear flag  */
0421 /**
0422   * @}
0423   */
0424 
0425 /** @defgroup USART_Interruption_Mask    USART Interruption Flags Mask
0426   * @ingroup RTEMSBSPsARMSTM32H7
0427   * @{
0428   */
0429 #define USART_IT_MASK                             0x001FU     /*!< USART interruptions flags mask */
0430 #define USART_CR_MASK                             0x00E0U     /*!< USART control register mask */
0431 #define USART_CR_POS                              5U          /*!< USART control register position */
0432 #define USART_ISR_MASK                            0x1F00U     /*!< USART ISR register mask         */
0433 #define USART_ISR_POS                             8U          /*!< USART ISR register position     */
0434 /**
0435   * @}
0436   */
0437 
0438 /**
0439   * @}
0440   */
0441 
0442 /* Exported macros -----------------------------------------------------------*/
0443 /** @defgroup USART_Exported_Macros USART Exported Macros
0444   * @ingroup RTEMSBSPsARMSTM32H7
0445   * @{
0446   */
0447 
0448 /** @brief Reset USART handle state.
0449   * @param  __HANDLE__ USART handle.
0450   * @retval None
0451   */
0452 #if (USE_HAL_USART_REGISTER_CALLBACKS == 1)
0453 #define __HAL_USART_RESET_HANDLE_STATE(__HANDLE__)  do{                                            \
0454                                                         (__HANDLE__)->State = HAL_USART_STATE_RESET; \
0455                                                         (__HANDLE__)->MspInitCallback = NULL;        \
0456                                                         (__HANDLE__)->MspDeInitCallback = NULL;      \
0457                                                       } while(0U)
0458 #else
0459 #define __HAL_USART_RESET_HANDLE_STATE(__HANDLE__)  ((__HANDLE__)->State = HAL_USART_STATE_RESET)
0460 #endif /* USE_HAL_USART_REGISTER_CALLBACKS */
0461 
0462 /** @brief  Check whether the specified USART flag is set or not.
0463   * @param  __HANDLE__ specifies the USART Handle
0464   * @param  __FLAG__ specifies the flag to check.
0465   *        This parameter can be one of the following values:
0466   *            @arg @ref USART_FLAG_TXFT  TXFIFO threshold flag
0467   *            @arg @ref USART_FLAG_RXFT  RXFIFO threshold flag
0468   *            @arg @ref USART_FLAG_RXFF  RXFIFO Full flag
0469   *            @arg @ref USART_FLAG_TXFE  TXFIFO Empty flag
0470   *            @arg @ref USART_FLAG_REACK Receive enable acknowledge flag
0471   *            @arg @ref USART_FLAG_TEACK Transmit enable acknowledge flag
0472   *            @arg @ref USART_FLAG_BUSY  Busy flag
0473   *            @arg @ref USART_FLAG_UDR   SPI slave underrun error flag
0474   *            @arg @ref USART_FLAG_TXE   Transmit data register empty flag
0475   *            @arg @ref USART_FLAG_TXFNF TXFIFO not full flag
0476   *            @arg @ref USART_FLAG_TC    Transmission Complete flag
0477   *            @arg @ref USART_FLAG_RXNE  Receive data register not empty flag
0478   *            @arg @ref USART_FLAG_RXFNE RXFIFO not empty flag
0479   *            @arg @ref USART_FLAG_RTOF  Receiver Timeout flag
0480   *            @arg @ref USART_FLAG_IDLE  Idle Line detection flag
0481   *            @arg @ref USART_FLAG_ORE   OverRun Error flag
0482   *            @arg @ref USART_FLAG_NE    Noise Error flag
0483   *            @arg @ref USART_FLAG_FE    Framing Error flag
0484   *            @arg @ref USART_FLAG_PE    Parity Error flag
0485   * @retval The new state of __FLAG__ (TRUE or FALSE).
0486   */
0487 #define __HAL_USART_GET_FLAG(__HANDLE__, __FLAG__) (((__HANDLE__)->Instance->ISR & (__FLAG__)) == (__FLAG__))
0488 
0489 /** @brief  Clear the specified USART pending flag.
0490   * @param  __HANDLE__ specifies the USART Handle.
0491   * @param  __FLAG__ specifies the flag to check.
0492   *          This parameter can be any combination of the following values:
0493   *            @arg @ref USART_CLEAR_PEF      Parity Error Clear Flag
0494   *            @arg @ref USART_CLEAR_FEF      Framing Error Clear Flag
0495   *            @arg @ref USART_CLEAR_NEF      Noise detected Clear Flag
0496   *            @arg @ref USART_CLEAR_OREF     Overrun Error Clear Flag
0497   *            @arg @ref USART_CLEAR_IDLEF    IDLE line detected Clear Flag
0498   *            @arg @ref USART_CLEAR_TXFECF   TXFIFO empty clear Flag
0499   *            @arg @ref USART_CLEAR_TCF      Transmission Complete Clear Flag
0500   *            @arg @ref USART_CLEAR_RTOF     Receiver Timeout clear flag
0501   *            @arg @ref USART_CLEAR_UDRF     SPI slave underrun error Clear Flag
0502   * @retval None
0503   */
0504 #define __HAL_USART_CLEAR_FLAG(__HANDLE__, __FLAG__) ((__HANDLE__)->Instance->ICR = (__FLAG__))
0505 
0506 /** @brief  Clear the USART PE pending flag.
0507   * @param  __HANDLE__ specifies the USART Handle.
0508   * @retval None
0509   */
0510 #define __HAL_USART_CLEAR_PEFLAG(__HANDLE__)   __HAL_USART_CLEAR_FLAG((__HANDLE__), USART_CLEAR_PEF)
0511 
0512 /** @brief  Clear the USART FE pending flag.
0513   * @param  __HANDLE__ specifies the USART Handle.
0514   * @retval None
0515   */
0516 #define __HAL_USART_CLEAR_FEFLAG(__HANDLE__)   __HAL_USART_CLEAR_FLAG((__HANDLE__), USART_CLEAR_FEF)
0517 
0518 /** @brief  Clear the USART NE pending flag.
0519   * @param  __HANDLE__ specifies the USART Handle.
0520   * @retval None
0521   */
0522 #define __HAL_USART_CLEAR_NEFLAG(__HANDLE__)  __HAL_USART_CLEAR_FLAG((__HANDLE__), USART_CLEAR_NEF)
0523 
0524 /** @brief  Clear the USART ORE pending flag.
0525   * @param  __HANDLE__ specifies the USART Handle.
0526   * @retval None
0527   */
0528 #define __HAL_USART_CLEAR_OREFLAG(__HANDLE__)   __HAL_USART_CLEAR_FLAG((__HANDLE__), USART_CLEAR_OREF)
0529 
0530 /** @brief  Clear the USART IDLE pending flag.
0531   * @param  __HANDLE__ specifies the USART Handle.
0532   * @retval None
0533   */
0534 #define __HAL_USART_CLEAR_IDLEFLAG(__HANDLE__)   __HAL_USART_CLEAR_FLAG((__HANDLE__), USART_CLEAR_IDLEF)
0535 
0536 /** @brief  Clear the USART TX FIFO empty clear flag.
0537   * @param  __HANDLE__ specifies the USART Handle.
0538   * @retval None
0539   */
0540 #define __HAL_USART_CLEAR_TXFECF(__HANDLE__)   __HAL_USART_CLEAR_FLAG((__HANDLE__), USART_CLEAR_TXFECF)
0541 
0542 /** @brief  Clear SPI slave underrun error flag.
0543   * @param  __HANDLE__ specifies the USART Handle.
0544   * @retval None
0545   */
0546 #define __HAL_USART_CLEAR_UDRFLAG(__HANDLE__)   __HAL_USART_CLEAR_FLAG((__HANDLE__), USART_CLEAR_UDRF)
0547 
0548 /** @brief  Enable the specified USART interrupt.
0549   * @param  __HANDLE__ specifies the USART Handle.
0550   * @param  __INTERRUPT__ specifies the USART interrupt source to enable.
0551   *          This parameter can be one of the following values:
0552   *            @arg @ref USART_IT_RXFF  RXFIFO Full interrupt
0553   *            @arg @ref USART_IT_TXFE  TXFIFO Empty interrupt
0554   *            @arg @ref USART_IT_RXFT  RXFIFO threshold interrupt
0555   *            @arg @ref USART_IT_TXFT  TXFIFO threshold interrupt
0556   *            @arg @ref USART_IT_TXE   Transmit Data Register empty interrupt
0557   *            @arg @ref USART_IT_TXFNF TX FIFO not full interrupt
0558   *            @arg @ref USART_IT_TC    Transmission complete interrupt
0559   *            @arg @ref USART_IT_RXNE  Receive Data register not empty interrupt
0560   *            @arg @ref USART_IT_RXFNE RXFIFO not empty interrupt
0561   *            @arg @ref USART_IT_IDLE  Idle line detection interrupt
0562   *            @arg @ref USART_IT_PE    Parity Error interrupt
0563   *            @arg @ref USART_IT_ERR   Error interrupt(Frame error, noise error, overrun error)
0564   * @retval None
0565   */
0566 #define __HAL_USART_ENABLE_IT(__HANDLE__, __INTERRUPT__)\
0567   (((((__INTERRUPT__) & USART_CR_MASK) >> USART_CR_POS) == 1U)?\
0568    ((__HANDLE__)->Instance->CR1 |= (1U << ((__INTERRUPT__) & USART_IT_MASK))): \
0569    ((((__INTERRUPT__) & USART_CR_MASK) >> USART_CR_POS) == 2U)?\
0570    ((__HANDLE__)->Instance->CR2 |= (1U << ((__INTERRUPT__) & USART_IT_MASK))): \
0571    ((__HANDLE__)->Instance->CR3 |= (1U << ((__INTERRUPT__) & USART_IT_MASK))))
0572 
0573 /** @brief  Disable the specified USART interrupt.
0574   * @param  __HANDLE__ specifies the USART Handle.
0575   * @param  __INTERRUPT__ specifies the USART interrupt source to disable.
0576   *          This parameter can be one of the following values:
0577   *            @arg @ref USART_IT_RXFF  RXFIFO Full interrupt
0578   *            @arg @ref USART_IT_TXFE  TXFIFO Empty interrupt
0579   *            @arg @ref USART_IT_RXFT  RXFIFO threshold interrupt
0580   *            @arg @ref USART_IT_TXFT  TXFIFO threshold interrupt
0581   *            @arg @ref USART_IT_TXE   Transmit Data Register empty interrupt
0582   *            @arg @ref USART_IT_TXFNF TX FIFO not full interrupt
0583   *            @arg @ref USART_IT_TC    Transmission complete interrupt
0584   *            @arg @ref USART_IT_RXNE  Receive Data register not empty interrupt
0585   *            @arg @ref USART_IT_RXFNE RXFIFO not empty interrupt
0586   *            @arg @ref USART_IT_IDLE  Idle line detection interrupt
0587   *            @arg @ref USART_IT_PE    Parity Error interrupt
0588   *            @arg @ref USART_IT_ERR   Error interrupt(Frame error, noise error, overrun error)
0589   * @retval None
0590   */
0591 #define __HAL_USART_DISABLE_IT(__HANDLE__, __INTERRUPT__)\
0592   (((((__INTERRUPT__) & USART_CR_MASK) >> USART_CR_POS) == 1U)?\
0593    ((__HANDLE__)->Instance->CR1 &= ~ (1U << ((__INTERRUPT__) & USART_IT_MASK))): \
0594    ((((__INTERRUPT__) & USART_CR_MASK) >> USART_CR_POS) == 2U)?\
0595    ((__HANDLE__)->Instance->CR2 &= ~ (1U << ((__INTERRUPT__) & USART_IT_MASK))): \
0596    ((__HANDLE__)->Instance->CR3 &= ~ (1U << ((__INTERRUPT__) & USART_IT_MASK))))
0597 
0598 /** @brief  Check whether the specified USART interrupt has occurred or not.
0599   * @param  __HANDLE__ specifies the USART Handle.
0600   * @param  __INTERRUPT__ specifies the USART interrupt source to check.
0601   *          This parameter can be one of the following values:
0602   *            @arg @ref USART_IT_RXFF  RXFIFO Full interrupt
0603   *            @arg @ref USART_IT_TXFE  TXFIFO Empty interrupt
0604   *            @arg @ref USART_IT_RXFT  RXFIFO threshold interrupt
0605   *            @arg @ref USART_IT_TXFT  TXFIFO threshold interrupt
0606   *            @arg @ref USART_IT_TXE   Transmit Data Register empty interrupt
0607   *            @arg @ref USART_IT_TXFNF TX FIFO not full interrupt
0608   *            @arg @ref USART_IT_TC    Transmission complete interrupt
0609   *            @arg @ref USART_IT_RXNE  Receive Data register not empty interrupt
0610   *            @arg @ref USART_IT_RXFNE RXFIFO not empty interrupt
0611   *            @arg @ref USART_IT_IDLE  Idle line detection interrupt
0612   *            @arg @ref USART_IT_ORE   OverRun Error interrupt
0613   *            @arg @ref USART_IT_NE    Noise Error interrupt
0614   *            @arg @ref USART_IT_FE    Framing Error interrupt
0615   *            @arg @ref USART_IT_PE    Parity Error interrupt
0616   * @retval The new state of __INTERRUPT__ (SET or RESET).
0617   */
0618 #define __HAL_USART_GET_IT(__HANDLE__, __INTERRUPT__) ((((__HANDLE__)->Instance->ISR\
0619                                                          & (0x01U << (((__INTERRUPT__) & USART_ISR_MASK)>>\
0620                                                                       USART_ISR_POS))) != 0U) ? SET : RESET)
0621 
0622 /** @brief  Check whether the specified USART interrupt source is enabled or not.
0623   * @param  __HANDLE__ specifies the USART Handle.
0624   * @param  __INTERRUPT__ specifies the USART interrupt source to check.
0625   *          This parameter can be one of the following values:
0626   *            @arg @ref USART_IT_RXFF  RXFIFO Full interrupt
0627   *            @arg @ref USART_IT_TXFE  TXFIFO Empty interrupt
0628   *            @arg @ref USART_IT_RXFT  RXFIFO threshold interrupt
0629   *            @arg @ref USART_IT_TXFT  TXFIFO threshold interrupt
0630   *            @arg @ref USART_IT_TXE   Transmit Data Register empty interrupt
0631   *            @arg @ref USART_IT_TXFNF TX FIFO not full interrupt
0632   *            @arg @ref USART_IT_TC    Transmission complete interrupt
0633   *            @arg @ref USART_IT_RXNE  Receive Data register not empty interrupt
0634   *            @arg @ref USART_IT_RXFNE RXFIFO not empty interrupt
0635   *            @arg @ref USART_IT_IDLE  Idle line detection interrupt
0636   *            @arg @ref USART_IT_ORE   OverRun Error interrupt
0637   *            @arg @ref USART_IT_NE    Noise Error interrupt
0638   *            @arg @ref USART_IT_FE    Framing Error interrupt
0639   *            @arg @ref USART_IT_PE    Parity Error interrupt
0640   * @retval The new state of __INTERRUPT__ (SET or RESET).
0641   */
0642 #define __HAL_USART_GET_IT_SOURCE(__HANDLE__, __INTERRUPT__) ((((((((uint8_t)(__INTERRUPT__)) >> 0x05U) == 0x01U) ?\
0643                                                                  (__HANDLE__)->Instance->CR1 : \
0644                                                                  (((((uint8_t)(__INTERRUPT__)) >> 0x05U) == 0x02U) ?\
0645                                                                   (__HANDLE__)->Instance->CR2 : \
0646                                                                   (__HANDLE__)->Instance->CR3)) & (0x01U <<\
0647                                                                       (((uint16_t)(__INTERRUPT__)) &\
0648                                                                        USART_IT_MASK)))  != 0U) ? SET : RESET)
0649 
0650 /** @brief  Clear the specified USART ISR flag, in setting the proper ICR register flag.
0651   * @param  __HANDLE__ specifies the USART Handle.
0652   * @param  __IT_CLEAR__ specifies the interrupt clear register flag that needs to be set
0653   *                       to clear the corresponding interrupt.
0654   *          This parameter can be one of the following values:
0655   *            @arg @ref USART_CLEAR_PEF      Parity Error Clear Flag
0656   *            @arg @ref USART_CLEAR_FEF      Framing Error Clear Flag
0657   *            @arg @ref USART_CLEAR_NEF      Noise detected Clear Flag
0658   *            @arg @ref USART_CLEAR_OREF     Overrun Error Clear Flag
0659   *            @arg @ref USART_CLEAR_IDLEF    IDLE line detected Clear Flag
0660   *            @arg @ref USART_CLEAR_RTOF     Receiver timeout clear flag
0661   *            @arg @ref USART_CLEAR_TXFECF   TXFIFO empty clear Flag
0662   *            @arg @ref USART_CLEAR_TCF      Transmission Complete Clear Flag
0663   * @retval None
0664   */
0665 #define __HAL_USART_CLEAR_IT(__HANDLE__, __IT_CLEAR__) ((__HANDLE__)->Instance->ICR = (uint32_t)(__IT_CLEAR__))
0666 
0667 /** @brief  Set a specific USART request flag.
0668   * @param  __HANDLE__ specifies the USART Handle.
0669   * @param  __REQ__ specifies the request flag to set.
0670   *          This parameter can be one of the following values:
0671   *            @arg @ref USART_RXDATA_FLUSH_REQUEST Receive Data flush Request
0672   *            @arg @ref USART_TXDATA_FLUSH_REQUEST Transmit data flush Request
0673   *
0674   * @retval None
0675   */
0676 #define __HAL_USART_SEND_REQ(__HANDLE__, __REQ__)      ((__HANDLE__)->Instance->RQR |= (uint16_t)(__REQ__))
0677 
0678 /** @brief  Enable the USART one bit sample method.
0679   * @param  __HANDLE__ specifies the USART Handle.
0680   * @retval None
0681   */
0682 #define __HAL_USART_ONE_BIT_SAMPLE_ENABLE(__HANDLE__) ((__HANDLE__)->Instance->CR3|= USART_CR3_ONEBIT)
0683 
0684 /** @brief  Disable the USART one bit sample method.
0685   * @param  __HANDLE__ specifies the USART Handle.
0686   * @retval None
0687   */
0688 #define __HAL_USART_ONE_BIT_SAMPLE_DISABLE(__HANDLE__) ((__HANDLE__)->Instance->CR3 &= ~USART_CR3_ONEBIT)
0689 
0690 /** @brief  Enable USART.
0691   * @param  __HANDLE__ specifies the USART Handle.
0692   * @retval None
0693   */
0694 #define __HAL_USART_ENABLE(__HANDLE__)                 ((__HANDLE__)->Instance->CR1 |= USART_CR1_UE)
0695 
0696 /** @brief  Disable USART.
0697   * @param  __HANDLE__ specifies the USART Handle.
0698   * @retval None
0699   */
0700 #define __HAL_USART_DISABLE(__HANDLE__)                ((__HANDLE__)->Instance->CR1 &= ~USART_CR1_UE)
0701 
0702 /**
0703   * @}
0704   */
0705 
0706 /* Private macros --------------------------------------------------------*/
0707 /** @defgroup USART_Private_Macros   USART Private Macros
0708   * @ingroup RTEMSBSPsARMSTM32H7
0709   * @{
0710   */
0711 
0712 /** @brief  Get USART clock division factor from clock prescaler value.
0713   * @param  __CLOCKPRESCALER__ USART prescaler value.
0714   * @retval USART clock division factor
0715   */
0716 #define USART_GET_DIV_FACTOR(__CLOCKPRESCALER__) \
0717   (((__CLOCKPRESCALER__) == USART_PRESCALER_DIV1)   ? 1U :       \
0718    ((__CLOCKPRESCALER__) == USART_PRESCALER_DIV2)   ? 2U :       \
0719    ((__CLOCKPRESCALER__) == USART_PRESCALER_DIV4)   ? 4U :       \
0720    ((__CLOCKPRESCALER__) == USART_PRESCALER_DIV6)   ? 6U :       \
0721    ((__CLOCKPRESCALER__) == USART_PRESCALER_DIV8)   ? 8U :       \
0722    ((__CLOCKPRESCALER__) == USART_PRESCALER_DIV10)  ? 10U :      \
0723    ((__CLOCKPRESCALER__) == USART_PRESCALER_DIV12)  ? 12U :      \
0724    ((__CLOCKPRESCALER__) == USART_PRESCALER_DIV16)  ? 16U :      \
0725    ((__CLOCKPRESCALER__) == USART_PRESCALER_DIV32)  ? 32U :      \
0726    ((__CLOCKPRESCALER__) == USART_PRESCALER_DIV64)  ? 64U :      \
0727    ((__CLOCKPRESCALER__) == USART_PRESCALER_DIV128) ? 128U :     \
0728    ((__CLOCKPRESCALER__) == USART_PRESCALER_DIV256) ? 256U : 1U)
0729 
0730 /** @brief  BRR division operation to set BRR register in 8-bit oversampling mode.
0731   * @param  __PCLK__ USART clock.
0732   * @param  __BAUD__ Baud rate set by the user.
0733   * @param  __CLOCKPRESCALER__ USART prescaler value.
0734   * @retval Division result
0735   */
0736 #define USART_DIV_SAMPLING8(__PCLK__, __BAUD__, __CLOCKPRESCALER__)\
0737   (((((__PCLK__)/USART_GET_DIV_FACTOR(__CLOCKPRESCALER__))*2U)\
0738     + ((__BAUD__)/2U)) / (__BAUD__))
0739 
0740 /** @brief  Report the USART clock source.
0741   * @param  __HANDLE__ specifies the USART Handle.
0742   * @param  __CLOCKSOURCE__ output variable.
0743   * @retval the USART clocking source, written in __CLOCKSOURCE__.
0744   */
0745 #if defined(UART9) && defined(USART10)
0746 #define USART_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__)       \
0747   do {                                                         \
0748     if((__HANDLE__)->Instance == USART1)                       \
0749     {                                                          \
0750       switch(__HAL_RCC_GET_USART1_SOURCE())                    \
0751       {                                                        \
0752         case RCC_USART1CLKSOURCE_D2PCLK2:                      \
0753           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_D2PCLK2;       \
0754           break;                                               \
0755         case RCC_USART1CLKSOURCE_PLL2:                         \
0756           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_PLL2;          \
0757           break;                                               \
0758         case RCC_USART1CLKSOURCE_PLL3:                         \
0759           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_PLL3;          \
0760           break;                                               \
0761         case RCC_USART1CLKSOURCE_HSI:                          \
0762           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_HSI;           \
0763           break;                                               \
0764         case RCC_USART1CLKSOURCE_CSI:                          \
0765           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_CSI;           \
0766           break;                                               \
0767         case RCC_USART1CLKSOURCE_LSE:                          \
0768           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_LSE;           \
0769           break;                                               \
0770         default:                                               \
0771           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_UNDEFINED;     \
0772           break;                                               \
0773       }                                                        \
0774     }                                                          \
0775     else if((__HANDLE__)->Instance == USART2)                  \
0776     {                                                          \
0777       switch(__HAL_RCC_GET_USART2_SOURCE())                    \
0778       {                                                        \
0779         case RCC_USART2CLKSOURCE_D2PCLK1:                      \
0780           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_D2PCLK1;       \
0781           break;                                               \
0782         case RCC_USART2CLKSOURCE_PLL2:                         \
0783           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_PLL2;          \
0784           break;                                               \
0785         case RCC_USART2CLKSOURCE_PLL3:                         \
0786           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_PLL3;          \
0787           break;                                               \
0788         case RCC_USART2CLKSOURCE_HSI:                          \
0789           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_HSI;           \
0790           break;                                               \
0791         case RCC_USART2CLKSOURCE_CSI:                          \
0792           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_CSI;           \
0793           break;                                               \
0794         case RCC_USART2CLKSOURCE_LSE:                          \
0795           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_LSE;           \
0796           break;                                               \
0797         default:                                               \
0798           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_UNDEFINED;     \
0799           break;                                               \
0800       }                                                        \
0801     }                                                          \
0802     else if((__HANDLE__)->Instance == USART3)                  \
0803     {                                                          \
0804       switch(__HAL_RCC_GET_USART3_SOURCE())                    \
0805       {                                                        \
0806         case RCC_USART3CLKSOURCE_D2PCLK1:                      \
0807           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_D2PCLK1;       \
0808           break;                                               \
0809         case RCC_USART3CLKSOURCE_PLL2:                         \
0810           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_PLL2;          \
0811           break;                                               \
0812         case RCC_USART3CLKSOURCE_PLL3:                         \
0813           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_PLL3;          \
0814           break;                                               \
0815         case RCC_USART3CLKSOURCE_HSI:                          \
0816           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_HSI;           \
0817           break;                                               \
0818         case RCC_USART3CLKSOURCE_CSI:                          \
0819           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_CSI;           \
0820           break;                                               \
0821         case RCC_USART3CLKSOURCE_LSE:                          \
0822           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_LSE;           \
0823           break;                                               \
0824         default:                                               \
0825           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_UNDEFINED;     \
0826           break;                                               \
0827       }                                                        \
0828     }                                                          \
0829     else if((__HANDLE__)->Instance == USART6)                  \
0830     {                                                          \
0831       switch(__HAL_RCC_GET_USART6_SOURCE())                    \
0832       {                                                        \
0833         case RCC_USART6CLKSOURCE_D2PCLK2:                      \
0834           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_D2PCLK2;       \
0835           break;                                               \
0836         case RCC_USART6CLKSOURCE_PLL2:                         \
0837           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_PLL2;          \
0838           break;                                               \
0839         case RCC_USART6CLKSOURCE_PLL3:                         \
0840           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_PLL3;          \
0841           break;                                               \
0842         case RCC_USART6CLKSOURCE_HSI:                          \
0843           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_HSI;           \
0844           break;                                               \
0845         case RCC_USART6CLKSOURCE_CSI:                          \
0846           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_CSI;           \
0847           break;                                               \
0848         case RCC_USART6CLKSOURCE_LSE:                          \
0849           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_LSE;           \
0850           break;                                               \
0851         default:                                               \
0852           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_UNDEFINED;     \
0853           break;                                               \
0854       }                                                        \
0855     }                                                          \
0856     else if((__HANDLE__)->Instance == USART10)                 \
0857     {                                                          \
0858       switch(__HAL_RCC_GET_USART10_SOURCE())                   \
0859       {                                                        \
0860         case RCC_USART10CLKSOURCE_D2PCLK2:                     \
0861           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_D2PCLK2;       \
0862           break;                                               \
0863         case RCC_USART10CLKSOURCE_PLL2:                        \
0864           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_PLL2;          \
0865           break;                                               \
0866         case RCC_USART10CLKSOURCE_PLL3:                        \
0867           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_PLL3;          \
0868           break;                                               \
0869         case RCC_USART10CLKSOURCE_HSI:                         \
0870           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_HSI;           \
0871           break;                                               \
0872         case RCC_USART10CLKSOURCE_CSI:                         \
0873           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_CSI;           \
0874           break;                                               \
0875         case RCC_USART10CLKSOURCE_LSE:                         \
0876           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_LSE;           \
0877           break;                                               \
0878         default:                                               \
0879           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_UNDEFINED;     \
0880           break;                                               \
0881       }                                                        \
0882     }                                                          \
0883     else                                                       \
0884     {                                                          \
0885       (__CLOCKSOURCE__) = USART_CLOCKSOURCE_UNDEFINED;         \
0886     }                                                          \
0887   } while(0U)
0888 #else
0889 #define USART_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__)       \
0890   do {                                                         \
0891     if((__HANDLE__)->Instance == USART1)                       \
0892     {                                                          \
0893       switch(__HAL_RCC_GET_USART1_SOURCE())                    \
0894       {                                                        \
0895         case RCC_USART1CLKSOURCE_D2PCLK2:                      \
0896           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_D2PCLK2;       \
0897           break;                                               \
0898         case RCC_USART1CLKSOURCE_PLL2:                         \
0899           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_PLL2;          \
0900           break;                                               \
0901         case RCC_USART1CLKSOURCE_PLL3:                         \
0902           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_PLL3;          \
0903           break;                                               \
0904         case RCC_USART1CLKSOURCE_HSI:                          \
0905           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_HSI;           \
0906           break;                                               \
0907         case RCC_USART1CLKSOURCE_CSI:                          \
0908           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_CSI;           \
0909           break;                                               \
0910         case RCC_USART1CLKSOURCE_LSE:                          \
0911           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_LSE;           \
0912           break;                                               \
0913         default:                                               \
0914           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_UNDEFINED;     \
0915           break;                                               \
0916       }                                                        \
0917     }                                                          \
0918     else if((__HANDLE__)->Instance == USART2)                  \
0919     {                                                          \
0920       switch(__HAL_RCC_GET_USART2_SOURCE())                    \
0921       {                                                        \
0922         case RCC_USART2CLKSOURCE_D2PCLK1:                      \
0923           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_D2PCLK1;       \
0924           break;                                               \
0925         case RCC_USART2CLKSOURCE_PLL2:                         \
0926           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_PLL2;          \
0927           break;                                               \
0928         case RCC_USART2CLKSOURCE_PLL3:                         \
0929           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_PLL3;          \
0930           break;                                               \
0931         case RCC_USART2CLKSOURCE_HSI:                          \
0932           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_HSI;           \
0933           break;                                               \
0934         case RCC_USART2CLKSOURCE_CSI:                          \
0935           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_CSI;           \
0936           break;                                               \
0937         case RCC_USART2CLKSOURCE_LSE:                          \
0938           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_LSE;           \
0939           break;                                               \
0940         default:                                               \
0941           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_UNDEFINED;     \
0942           break;                                               \
0943       }                                                        \
0944     }                                                          \
0945     else if((__HANDLE__)->Instance == USART3)                  \
0946     {                                                          \
0947       switch(__HAL_RCC_GET_USART3_SOURCE())                    \
0948       {                                                        \
0949         case RCC_USART3CLKSOURCE_D2PCLK1:                      \
0950           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_D2PCLK1;       \
0951           break;                                               \
0952         case RCC_USART3CLKSOURCE_PLL2:                         \
0953           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_PLL2;          \
0954           break;                                               \
0955         case RCC_USART3CLKSOURCE_PLL3:                         \
0956           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_PLL3;          \
0957           break;                                               \
0958         case RCC_USART3CLKSOURCE_HSI:                          \
0959           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_HSI;           \
0960           break;                                               \
0961         case RCC_USART3CLKSOURCE_CSI:                          \
0962           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_CSI;           \
0963           break;                                               \
0964         case RCC_USART3CLKSOURCE_LSE:                          \
0965           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_LSE;           \
0966           break;                                               \
0967         default:                                               \
0968           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_UNDEFINED;     \
0969           break;                                               \
0970       }                                                        \
0971     }                                                          \
0972     else if((__HANDLE__)->Instance == USART6)                  \
0973     {                                                          \
0974       switch(__HAL_RCC_GET_USART6_SOURCE())                    \
0975       {                                                        \
0976         case RCC_USART6CLKSOURCE_D2PCLK2:                      \
0977           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_D2PCLK2;       \
0978           break;                                               \
0979         case RCC_USART6CLKSOURCE_PLL2:                         \
0980           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_PLL2;          \
0981           break;                                               \
0982         case RCC_USART6CLKSOURCE_PLL3:                         \
0983           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_PLL3;          \
0984           break;                                               \
0985         case RCC_USART6CLKSOURCE_HSI:                          \
0986           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_HSI;           \
0987           break;                                               \
0988         case RCC_USART6CLKSOURCE_CSI:                          \
0989           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_CSI;           \
0990           break;                                               \
0991         case RCC_USART6CLKSOURCE_LSE:                          \
0992           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_LSE;           \
0993           break;                                               \
0994         default:                                               \
0995           (__CLOCKSOURCE__) = USART_CLOCKSOURCE_UNDEFINED;     \
0996           break;                                               \
0997       }                                                        \
0998     }                                                          \
0999     else                                                       \
1000     {                                                          \
1001       (__CLOCKSOURCE__) = USART_CLOCKSOURCE_UNDEFINED;         \
1002     }                                                          \
1003   } while(0U)
1004 #endif  /* UART9 && USART10 */
1005 
1006 /** @brief  Check USART Baud rate.
1007   * @param  __BAUDRATE__ Baudrate specified by the user.
1008   *         The maximum Baud Rate is derived from the maximum clock on H7 (i.e. 100 MHz)
1009   *         divided by the smallest oversampling used on the USART (i.e. 8)
1010   * @retval SET (__BAUDRATE__ is valid) or RESET (__BAUDRATE__ is invalid)  */
1011 #define IS_USART_BAUDRATE(__BAUDRATE__) ((__BAUDRATE__) <= 12500000U)
1012 
1013 /**
1014   * @brief Ensure that USART frame number of stop bits is valid.
1015   * @param __STOPBITS__ USART frame number of stop bits.
1016   * @retval SET (__STOPBITS__ is valid) or RESET (__STOPBITS__ is invalid)
1017   */
1018 #define IS_USART_STOPBITS(__STOPBITS__) (((__STOPBITS__) == USART_STOPBITS_0_5) || \
1019                                          ((__STOPBITS__) == USART_STOPBITS_1)   || \
1020                                          ((__STOPBITS__) == USART_STOPBITS_1_5) || \
1021                                          ((__STOPBITS__) == USART_STOPBITS_2))
1022 
1023 /**
1024   * @brief Ensure that USART frame parity is valid.
1025   * @param __PARITY__ USART frame parity.
1026   * @retval SET (__PARITY__ is valid) or RESET (__PARITY__ is invalid)
1027   */
1028 #define IS_USART_PARITY(__PARITY__) (((__PARITY__) == USART_PARITY_NONE) || \
1029                                      ((__PARITY__) == USART_PARITY_EVEN) || \
1030                                      ((__PARITY__) == USART_PARITY_ODD))
1031 
1032 /**
1033   * @brief Ensure that USART communication mode is valid.
1034   * @param __MODE__ USART communication mode.
1035   * @retval SET (__MODE__ is valid) or RESET (__MODE__ is invalid)
1036   */
1037 #define IS_USART_MODE(__MODE__) ((((__MODE__) & 0xFFFFFFF3U) == 0x00U) && ((__MODE__) != 0x00U))
1038 
1039 /**
1040   * @brief Ensure that USART clock state is valid.
1041   * @param __CLOCK__ USART clock state.
1042   * @retval SET (__CLOCK__ is valid) or RESET (__CLOCK__ is invalid)
1043   */
1044 #define IS_USART_CLOCK(__CLOCK__) (((__CLOCK__) == USART_CLOCK_DISABLE) || \
1045                                    ((__CLOCK__) == USART_CLOCK_ENABLE))
1046 
1047 /**
1048   * @brief Ensure that USART frame polarity is valid.
1049   * @param __CPOL__ USART frame polarity.
1050   * @retval SET (__CPOL__ is valid) or RESET (__CPOL__ is invalid)
1051   */
1052 #define IS_USART_POLARITY(__CPOL__) (((__CPOL__) == USART_POLARITY_LOW) || ((__CPOL__) == USART_POLARITY_HIGH))
1053 
1054 /**
1055   * @brief Ensure that USART frame phase is valid.
1056   * @param __CPHA__ USART frame phase.
1057   * @retval SET (__CPHA__ is valid) or RESET (__CPHA__ is invalid)
1058   */
1059 #define IS_USART_PHASE(__CPHA__) (((__CPHA__) == USART_PHASE_1EDGE) || ((__CPHA__) == USART_PHASE_2EDGE))
1060 
1061 /**
1062   * @brief Ensure that USART frame last bit clock pulse setting is valid.
1063   * @param __LASTBIT__ USART frame last bit clock pulse setting.
1064   * @retval SET (__LASTBIT__ is valid) or RESET (__LASTBIT__ is invalid)
1065   */
1066 #define IS_USART_LASTBIT(__LASTBIT__) (((__LASTBIT__) == USART_LASTBIT_DISABLE) || \
1067                                        ((__LASTBIT__) == USART_LASTBIT_ENABLE))
1068 
1069 /**
1070   * @brief Ensure that USART request parameter is valid.
1071   * @param __PARAM__ USART request parameter.
1072   * @retval SET (__PARAM__ is valid) or RESET (__PARAM__ is invalid)
1073   */
1074 #define IS_USART_REQUEST_PARAMETER(__PARAM__) (((__PARAM__) == USART_RXDATA_FLUSH_REQUEST) || \
1075                                                ((__PARAM__) == USART_TXDATA_FLUSH_REQUEST))
1076 
1077 /**
1078   * @brief Ensure that USART Prescaler is valid.
1079   * @param __CLOCKPRESCALER__ USART Prescaler value.
1080   * @retval SET (__CLOCKPRESCALER__ is valid) or RESET (__CLOCKPRESCALER__ is invalid)
1081   */
1082 #define IS_USART_PRESCALER(__CLOCKPRESCALER__) (((__CLOCKPRESCALER__) == USART_PRESCALER_DIV1) || \
1083                                                 ((__CLOCKPRESCALER__) == USART_PRESCALER_DIV2) || \
1084                                                 ((__CLOCKPRESCALER__) == USART_PRESCALER_DIV4) || \
1085                                                 ((__CLOCKPRESCALER__) == USART_PRESCALER_DIV6) || \
1086                                                 ((__CLOCKPRESCALER__) == USART_PRESCALER_DIV8) || \
1087                                                 ((__CLOCKPRESCALER__) == USART_PRESCALER_DIV10) || \
1088                                                 ((__CLOCKPRESCALER__) == USART_PRESCALER_DIV12) || \
1089                                                 ((__CLOCKPRESCALER__) == USART_PRESCALER_DIV16) || \
1090                                                 ((__CLOCKPRESCALER__) == USART_PRESCALER_DIV32) || \
1091                                                 ((__CLOCKPRESCALER__) == USART_PRESCALER_DIV64) || \
1092                                                 ((__CLOCKPRESCALER__) == USART_PRESCALER_DIV128) || \
1093                                                 ((__CLOCKPRESCALER__) == USART_PRESCALER_DIV256))
1094 
1095 /**
1096   * @}
1097   */
1098 
1099 /* Include USART HAL Extended module */
1100 #include "stm32h7xx_hal_usart_ex.h"
1101 
1102 /* Exported functions --------------------------------------------------------*/
1103 /** @addtogroup USART_Exported_Functions USART Exported Functions
1104   * @{
1105   */
1106 
1107 /** @addtogroup USART_Exported_Functions_Group1 Initialization and de-initialization functions
1108   * @{
1109   */
1110 
1111 /* Initialization and de-initialization functions  ****************************/
1112 HAL_StatusTypeDef HAL_USART_Init(USART_HandleTypeDef *husart);
1113 HAL_StatusTypeDef HAL_USART_DeInit(USART_HandleTypeDef *husart);
1114 void HAL_USART_MspInit(USART_HandleTypeDef *husart);
1115 void HAL_USART_MspDeInit(USART_HandleTypeDef *husart);
1116 
1117 /* Callbacks Register/UnRegister functions  ***********************************/
1118 #if (USE_HAL_USART_REGISTER_CALLBACKS == 1)
1119 HAL_StatusTypeDef HAL_USART_RegisterCallback(USART_HandleTypeDef *husart, HAL_USART_CallbackIDTypeDef CallbackID,
1120                                              pUSART_CallbackTypeDef pCallback);
1121 HAL_StatusTypeDef HAL_USART_UnRegisterCallback(USART_HandleTypeDef *husart, HAL_USART_CallbackIDTypeDef CallbackID);
1122 #endif /* USE_HAL_USART_REGISTER_CALLBACKS */
1123 
1124 /**
1125   * @}
1126   */
1127 
1128 /** @addtogroup USART_Exported_Functions_Group2 IO operation functions
1129   * @{
1130   */
1131 
1132 /* IO operation functions *****************************************************/
1133 HAL_StatusTypeDef HAL_USART_Transmit(USART_HandleTypeDef *husart, const uint8_t *pTxData, uint16_t Size,
1134                                      uint32_t Timeout);
1135 HAL_StatusTypeDef HAL_USART_Receive(USART_HandleTypeDef *husart, uint8_t *pRxData, uint16_t Size, uint32_t Timeout);
1136 HAL_StatusTypeDef HAL_USART_TransmitReceive(USART_HandleTypeDef *husart, const uint8_t *pTxData, uint8_t *pRxData,
1137                                             uint16_t Size, uint32_t Timeout);
1138 HAL_StatusTypeDef HAL_USART_Transmit_IT(USART_HandleTypeDef *husart, const uint8_t *pTxData, uint16_t Size);
1139 HAL_StatusTypeDef HAL_USART_Receive_IT(USART_HandleTypeDef *husart, uint8_t *pRxData, uint16_t Size);
1140 HAL_StatusTypeDef HAL_USART_TransmitReceive_IT(USART_HandleTypeDef *husart, const uint8_t *pTxData, uint8_t *pRxData,
1141                                                uint16_t Size);
1142 HAL_StatusTypeDef HAL_USART_Transmit_DMA(USART_HandleTypeDef *husart, const uint8_t *pTxData, uint16_t Size);
1143 HAL_StatusTypeDef HAL_USART_Receive_DMA(USART_HandleTypeDef *husart, uint8_t *pRxData, uint16_t Size);
1144 HAL_StatusTypeDef HAL_USART_TransmitReceive_DMA(USART_HandleTypeDef *husart, const uint8_t *pTxData, uint8_t *pRxData,
1145                                                 uint16_t Size);
1146 HAL_StatusTypeDef HAL_USART_DMAPause(USART_HandleTypeDef *husart);
1147 HAL_StatusTypeDef HAL_USART_DMAResume(USART_HandleTypeDef *husart);
1148 HAL_StatusTypeDef HAL_USART_DMAStop(USART_HandleTypeDef *husart);
1149 /* Transfer Abort functions */
1150 HAL_StatusTypeDef HAL_USART_Abort(USART_HandleTypeDef *husart);
1151 HAL_StatusTypeDef HAL_USART_Abort_IT(USART_HandleTypeDef *husart);
1152 
1153 void HAL_USART_IRQHandler(USART_HandleTypeDef *husart);
1154 void HAL_USART_TxHalfCpltCallback(USART_HandleTypeDef *husart);
1155 void HAL_USART_TxCpltCallback(USART_HandleTypeDef *husart);
1156 void HAL_USART_RxCpltCallback(USART_HandleTypeDef *husart);
1157 void HAL_USART_RxHalfCpltCallback(USART_HandleTypeDef *husart);
1158 void HAL_USART_TxRxCpltCallback(USART_HandleTypeDef *husart);
1159 void HAL_USART_ErrorCallback(USART_HandleTypeDef *husart);
1160 void HAL_USART_AbortCpltCallback(USART_HandleTypeDef *husart);
1161 
1162 /**
1163   * @}
1164   */
1165 
1166 /** @addtogroup USART_Exported_Functions_Group4 Peripheral State and Error functions
1167   * @{
1168   */
1169 
1170 /* Peripheral State and Error functions ***************************************/
1171 HAL_USART_StateTypeDef HAL_USART_GetState(const USART_HandleTypeDef *husart);
1172 uint32_t               HAL_USART_GetError(const USART_HandleTypeDef *husart);
1173 
1174 /**
1175   * @}
1176   */
1177 
1178 /**
1179   * @}
1180   */
1181 
1182 /**
1183   * @}
1184   */
1185 
1186 /**
1187   * @}
1188   */
1189 
1190 #ifdef __cplusplus
1191 }
1192 #endif
1193 
1194 #endif /* STM32H7xx_HAL_USART_H */
1195
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.3.7 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!