STM32L4 CubeMAX之USART

最新推荐文章于 2024-03-30 16:29:37 发布
最新推荐文章于 2024-03-30 16:29:37 发布
阅读量1.3k 收藏 3
点赞数 4
分类专栏： STM32 文章标签： 嵌入式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41478801/article/details/115230344
版权

STM32L4 CubeMX之USART

一、USART介绍

1.USART相关配置

UART的初始化主要是确定数据帧格式和双方通信的波特率，关于HAL库UART初始化结构体的定义：

// Drivers\STM32L4xx_HAL_Driver\Inc\stm32l4xx_hal_uart.h
/**
  * @brief UART Init Structure definition
  */
typedef struct
{
  uint32_t BaudRate;                  /*!< This member configures the UART communication baud rate.
                                           The baud rate register is computed using the following formula:
                                           LPUART:
                                           =======
                                              Baud Rate Register = ((256 * lpuart_ker_ckpres) / ((huart->Init.BaudRate)))
                                           where lpuart_ker_ck_pres is the UART input clock (divided by a prescaler if applicable)
                                           UART:
                                           =====
                                           - If oversampling is 16 or in LIN mode,
                                              Baud Rate Register = ((uart_ker_ckpres) / ((huart->Init.BaudRate)))
                                           - If oversampling is 8,
                                              Baud Rate Register[15:4] = ((2 * uart_ker_ckpres) / ((huart->Init.BaudRate)))[15:4]
                                              Baud Rate Register[3] =  0
                                              Baud Rate Register[2:0] =  (((2 * uart_ker_ckpres) / ((huart->Init.BaudRate)))[3:0]) >> 1
                                           where uart_ker_ck_pres is the UART input clock (divided by a prescaler if applicable) */

  uint32_t WordLength;                /*!< Specifies the number of data bits transmitted or received in a frame.
                                           This parameter can be a value of @ref UARTEx_Word_Length. */

  uint32_t StopBits;                  /*!< Specifies the number of stop bits transmitted.
                                           This parameter can be a value of @ref UART_Stop_Bits. */

  uint32_t Parity;                    /*!< Specifies the parity mode.
                                           This parameter can be a value of @ref UART_Parity
                                           @note When parity is enabled, the computed parity is inserted
                                                 at the MSB position of the transmitted data (9th bit when
                                                 the word length is set to 9 data bits; 8th bit when the
                                                 word length is set to 8 data bits). */

  uint32_t Mode;                      /*!< Specifies whether the Receive or Transmit mode is enabled or disabled.
                                           This parameter can be a value of @ref UART_Mode. */

  uint32_t HwFlowCtl;                 /*!< Specifies whether the hardware flow control mode is enabled
                                           or disabled.
                                           This parameter can be a value of @ref UART_Hardware_Flow_Control. */

  uint32_t OverSampling;              /*!< Specifies whether the Over sampling 8 is enabled or disabled, to achieve higher speed (up to f_PCLK/8).
                                           This parameter can be a value of @ref UART_Over_Sampling. */

  uint32_t OneBitSampling;            /*!< Specifies whether a single sample or three samples' majority vote is selected.
                                           Selecting the single sample method increases the receiver tolerance to clock
                                           deviations. This parameter can be a value of @ref UART_OneBit_Sampling. */

#if defined(USART_PRESC_PRESCALER)
  uint32_t ClockPrescaler;            /*!< Specifies the prescaler value used to divide the UART clock source.
                                           This parameter can be a value of @ref UART_ClockPrescaler. */
#endif /* USART_PRESC_PRESCALER */

} UART_InitTypeDef;

/** @defgroup UART_Stop_Bits   UART Number of Stop Bits
  */
#define UART_STOPBITS_0_5                    USART_CR2_STOP_0                     /*!< UART frame with 0.5 stop bit  */
#define UART_STOPBITS_1                     0x00000000U                           /*!< UART frame with 1 stop bit    */
#define UART_STOPBITS_1_5                   (USART_CR2_STOP_0 | USART_CR2_STOP_1) /*!< UART frame with 1.5 stop bits */
#define UART_STOPBITS_2                      USART_CR2_STOP_1                     /*!< UART frame with 2 stop bits   */

/** @defgroup UART_Parity  UART Parity
  */
#define UART_PARITY_NONE                    0x00000000U                        /*!< No parity   */
#define UART_PARITY_EVEN                    USART_CR1_PCE                      /*!< Even parity */
#define UART_PARITY_ODD                     (USART_CR1_PCE | USART_CR1_PS)     /*!< Odd parity  

/** @defgroup UART_Mode UART Transfer Mode
  */
#define UART_MODE_RX                        USART_CR1_RE                    /*!< RX mode        */
#define UART_MODE_TX                        USART_CR1_TE                    /*!< TX mode        */
#define UART_MODE_TX_RX                     (USART_CR1_TE |USART_CR1_RE)    /*!< RX and TX mode */

/** @defgroup UART_Hardware_Flow_Control UART Hardware Flow Control
  */
#define UART_HWCONTROL_NONE                  0x00000000U                          /*!< No hardware control       */
#define UART_HWCONTROL_RTS                   USART_CR3_RTSE                       /*!< Request To Send           */
#define UART_HWCONTROL_CTS                   USART_CR3_CTSE                       /*!< Clear To Send             */
#define UART_HWCONTROL_RTS_CTS               (USART_CR3_RTSE | USART_CR3_CTSE)    /*!< Request and Clear To Send */

/** @defgroup UART_Over_Sampling UART Over Sampling
  */
#define UART_OVERSAMPLING_16                0x00000000U         /*!< Oversampling by 16 */
#define UART_OVERSAMPLING_8                 USART_CR1_OVER8     /*!< Oversampling by 8  */

/** @defgroup UART_OneBit_Sampling UART One Bit Sampling Method
  */
#define UART_ONE_BIT_SAMPLE_DISABLE         0x00000000U         /*!< One-bit sampling disable */
#define UART_ONE_BIT_SAMPLE_ENABLE          USART_CR3_ONEBIT    /*!< One-bit sampling enable  */

以UART为例介绍其句柄结构体定义如下：

// Drivers\STM32L4xx_HAL_Driver\Inc\stm32l4xx_hal_uart.h
/**
  * @brief  UART handle Structure definition
  */
typedef struct __UART_HandleTypeDef
{
  USART_TypeDef            *Instance;                /*!< UART registers base address        */

  UART_InitTypeDef         Init;                     /*!< UART communication parameters      */

  UART_AdvFeatureInitTypeDef AdvancedInit;           /*!< UART Advanced Features initialization parameters */

  uint8_t                  *pTxBuffPtr;              /*!< Pointer to UART Tx transfer Buffer */

  uint16_t                 TxXferSize;               /*!< UART Tx Transfer size              */

  __IO uint16_t            TxXferCount;              /*!< UART Tx Transfer Counter           */

  uint8_t                  *pRxBuffPtr;              /*!< Pointer to UART Rx transfer Buffer */

  uint16_t                 RxXferSize;               /*!< UART Rx Transfer size              */

  __IO uint16_t            RxXferCount;              /*!< UART Rx Transfer Counter           */

  uint16_t                 Mask;                     /*!< UART Rx RDR register mask          */

#if defined(USART_CR1_FIFOEN)
  uint32_t                 FifoMode;                 /*!< Specifies if the FIFO mode is being used.
                                                          This parameter can be a value of @ref UARTEx_FIFO_mode. */

  uint16_t                 NbRxDataToProcess;        /*!< Number of data to process during RX ISR execution */

  uint16_t                 NbTxDataToProcess;        /*!< Number of data to process during TX ISR execution */
#endif /*USART_CR1_FIFOEN */

  void (*RxISR)(struct __UART_HandleTypeDef *huart); /*!< Function pointer on Rx IRQ handler   */

  void (*TxISR)(struct __UART_HandleTypeDef *huart); /*!< Function pointer on Tx IRQ handler   */

  DMA_HandleTypeDef        *hdmatx;                  /*!< UART Tx DMA Handle parameters      */

  DMA_HandleTypeDef        *hdmarx;                  /*!< UART Rx DMA Handle parameters      */

  HAL_LockTypeDef           Lock;                    /*!< Locking object                     */

  __IO HAL_UART_StateTypeDef    gState;              /*!< UART state information related to global Handle management
                                                          and also related to Tx operations.
                                                          This parameter can be a value of @ref HAL_UART_StateTypeDef */

  __IO HAL_UART_StateTypeDef    RxState;             /*!< UART state information related to Rx operations.
                                                          This parameter can be a value of @ref HAL_UART_StateTypeDef */

  __IO uint32_t                 ErrorCode;           /*!< UART Error code                    */

#if (USE_HAL_UART_REGISTER_CALLBACKS == 1)
  void (* TxHalfCpltCallback)(struct __UART_HandleTypeDef *huart);        /*!< UART Tx Half Complete Callback        */
  void (* TxCpltCallback)(struct __UART_HandleTypeDef *huart);            /*!< UART Tx Complete Callback             */
  void (* RxHalfCpltCallback)(struct __UART_HandleTypeDef *huart);        /*!< UART Rx Half Complete Callback        */
  void (* RxCpltCallback)(struct __UART_HandleTypeDef *huart);            /*!< UART Rx Complete Callback             */
  void (* ErrorCallback)(struct __UART_HandleTypeDef *huart);             /*!< UART Error Callback                   */
  void (* AbortCpltCallback)(struct __UART_HandleTypeDef *huart);         /*!< UART Abort Complete Callback          */
  void (* AbortTransmitCpltCallback)(struct __UART_HandleTypeDef *huart); /*!< UART Abort Transmit Complete Callback */
  void (* AbortReceiveCpltCallback)(struct __UART_HandleTypeDef *huart);  /*!< UART Abort Receive Complete Callback  */
  void (* WakeupCallback)(struct __UART_HandleTypeDef *huart);            /*!< UART Wakeup Callback                  */
#if defined(USART_CR1_FIFOEN)
  void (* RxFifoFullCallback)(struct __UART_HandleTypeDef *huart);        /*!< UART Rx Fifo Full Callback            */
  void (* TxFifoEmptyCallback)(struct __UART_HandleTypeDef *huart);       /*!< UART Tx Fifo Empty Callback           */
#endif /* USART_CR1_FIFOEN */

  void (* MspInitCallback)(struct __UART_HandleTypeDef *huart);           /*!< UART Msp Init callback                */
  void (* MspDeInitCallback)(struct __UART_HandleTypeDef *huart);         /*!< UART Msp DeInit callback              */
#endif  /* USE_HAL_UART_REGISTER_CALLBACKS */

} UART_HandleTypeDef;


/** @addtogroup UART_Exported_Functions_Group1 Initialization and de-initialization functions
  */
/* Initialization and de-initialization functions  ****************************/
HAL_StatusTypeDef HAL_UART_Init(UART_HandleTypeDef *huart);
HAL_StatusTypeDef HAL_HalfDuplex_Init(UART_HandleTypeDef *huart);
HAL_StatusTypeDef HAL_LIN_Init(UART_HandleTypeDef *huart, uint32_t BreakDetectLength);
HAL_StatusTypeDef HAL_MultiProcessor_Init(UART_HandleTypeDef *huart, uint8_t Address, uint32_t WakeUpMethod);
HAL_StatusTypeDef HAL_UART_DeInit(UART_HandleTypeDef *huart);
void HAL_UART_MspInit(UART_HandleTypeDef *huart);
void HAL_UART_MspDeInit(UART_HandleTypeDef *huart);

/* Callbacks Register/UnRegister functions  ***********************************/
#if (USE_HAL_UART_REGISTER_CALLBACKS == 1)
HAL_StatusTypeDef HAL_UART_RegisterCallback(UART_HandleTypeDef *huart, HAL_UART_CallbackIDTypeDef CallbackID,
                                            pUART_CallbackTypeDef pCallback);
HAL_StatusTypeDef HAL_UART_UnRegisterCallback(UART_HandleTypeDef *huart, HAL_UART_CallbackIDTypeDef CallbackID);
#endif /* USE_HAL_UART_REGISTER_CALLBACKS */


/** @addtogroup UART_Exported_Functions_Group2 IO operation functions
  */
/* IO operation functions *****************************************************/
HAL_StatusTypeDef HAL_UART_Transmit(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout);
HAL_StatusTypeDef HAL_UART_Receive(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout);
HAL_StatusTypeDef HAL_UART_Transmit_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size);
HAL_StatusTypeDef HAL_UART_Receive_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size);
HAL_StatusTypeDef HAL_UART_Transmit_DMA(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size);
HAL_StatusTypeDef HAL_UART_Receive_DMA(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size);
HAL_StatusTypeDef HAL_UART_DMAPause(UART_HandleTypeDef *huart);
HAL_StatusTypeDef HAL_UART_DMAResume(UART_HandleTypeDef *huart);
HAL_StatusTypeDef HAL_UART_DMAStop(UART_HandleTypeDef *huart);
/* Transfer Abort functions */
HAL_StatusTypeDef HAL_UART_Abort(UART_HandleTypeDef *huart);
HAL_StatusTypeDef HAL_UART_AbortTransmit(UART_HandleTypeDef *huart);
HAL_StatusTypeDef HAL_UART_AbortReceive(UART_HandleTypeDef *huart);
HAL_StatusTypeDef HAL_UART_Abort_IT(UART_HandleTypeDef *huart);
HAL_StatusTypeDef HAL_UART_AbortTransmit_IT(UART_HandleTypeDef *huart);
HAL_StatusTypeDef HAL_UART_AbortReceive_IT(UART_HandleTypeDef *huart);

void HAL_UART_IRQHandler(UART_HandleTypeDef *huart);
void HAL_UART_TxHalfCpltCallback(UART_HandleTypeDef *huart);
void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart);
void HAL_UART_RxHalfCpltCallback(UART_HandleTypeDef *huart);
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart);
void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart);
void HAL_UART_AbortCpltCallback(UART_HandleTypeDef *huart);
void HAL_UART_AbortTransmitCpltCallback(UART_HandleTypeDef *huart);
void HAL_UART_AbortReceiveCpltCallback(UART_HandleTypeDef *huart);


/** @addtogroup UART_Exported_Functions_Group3 Peripheral Control functions
  */
/* Peripheral Control functions  ************************************************/
HAL_StatusTypeDef HAL_LIN_SendBreak(UART_HandleTypeDef *huart);
HAL_StatusTypeDef HAL_MultiProcessor_EnableMuteMode(UART_HandleTypeDef *huart);
HAL_StatusTypeDef HAL_MultiProcessor_DisableMuteMode(UART_HandleTypeDef *huart);
void HAL_MultiProcessor_EnterMuteMode(UART_HandleTypeDef *huart);
HAL_StatusTypeDef HAL_HalfDuplex_EnableTransmitter(UART_HandleTypeDef *huart);
HAL_StatusTypeDef HAL_HalfDuplex_EnableReceiver(UART_HandleTypeDef *huart);


/** @addtogroup UART_Exported_Functions_Group4 Peripheral State and Error functions
  */
/* Peripheral State and Errors functions  **************************************************/
HAL_UART_StateTypeDef HAL_UART_GetState(UART_HandleTypeDef *huart);
uint32_t              HAL_UART_GetError(UART_HandleTypeDef *huart);


/* Private functions -----------------------------------------------------------*/
/** @addtogroup UART_Private_Functions UART Private Functions
  */
#if (USE_HAL_UART_REGISTER_CALLBACKS == 1)
void UART_InitCallbacksToDefault(UART_HandleTypeDef *huart);
#endif /* USE_HAL_UART_REGISTER_CALLBACKS */
HAL_StatusTypeDef UART_SetConfig(UART_HandleTypeDef *huart);
HAL_StatusTypeDef UART_CheckIdleState(UART_HandleTypeDef *huart);
HAL_StatusTypeDef UART_WaitOnFlagUntilTimeout(UART_HandleTypeDef *huart, uint32_t Flag, FlagStatus Status,
                                              uint32_t Tickstart, uint32_t Timeout);
void UART_AdvFeatureConfig(UART_HandleTypeDef *huart);

其中UART的API函数主要可分为如下几类

初始化/反初始化函数API函数
初始化/反初始化函数HAL_UART_Init() / HAL_UART_DeInit();
HAL_UART_MspInit() / HAL_UART_MspDeInit();
I / O 操作函数HAL_UART_Transmit() / HAL_UART_Receive();
HAL_UART_Transmit_IT() / HAL_UART_Receive_IT();
HAL_UART_Transmit_DMA() / HAL_UART_Receive_DMA();
回调函数HAL_UART_TxCpltCallback() / HAL_UART_RxCpltCallback();
HAL_UART_TxHalfCpltCallback() / HAL_UART_RxHalfCpltCallback();
HAL_UART_ErrorCallback() / HAL_UART_AbortCpltCallback();
HAL_UART_RegisterCallback() / HAL_UART_UnRegisterCallback();
控制函数UART_SetConfig() / UART_AdvFeatureConfig();
状态与错误HAL_UART_GetState() / HAL_UART_GetError();

HAL库UART函数库介绍

1、串口发送/接收函数

  • HAL_UART_Transmit();串口发送数据，使用超时管理机制
  • HAL_UART_Receive();串口接收数据，使用超时管理机制
  • HAL_UART_Transmit_IT();串口中断模式发送
  • HAL_UART_Receive_IT();串口中断模式接收
  • HAL_UART_Transmit_DMA();串口DMA模式发送
  • HAL_UART_Transmit_DMA();串口DMA模式接收

串口发送数据：

HAL_UART_Transmit(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout)

功能：串口发送指定长度的数据。如果超时没发送完成，则不再发送，返回超时标志（HAL_TIMEOUT）
参数：

  • UART_HandleTypeDef *huart UATR的别名 如 : UART_HandleTypeDef huart1; 别名就是huart1
  • *pData 需要发送的数据
  • Size 发送的字节数
  • Timeout 最大发送时间，发送数据超过该时间退出发送
举例： HAL_UART_Transmit(&huart1, (uint8_t *)HHH, 3, 0xffff);   //串口发送三个字节数据，最大传输时间0xffff

中断模式接收数据：

HAL_UART_Receive_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)

功能：串口中断接收，以中断方式接收指定长度数据。
大致过程是，设置数据存放位置，接收数据长度，然后使能串口接收中断。接收到数据时，会触发串口中断。
再然后，串口中断函数处理，直到接收到指定长度数据，而后关闭中断，进入中断接收回调函数，不再触发接收中断。(只触发一次中断)
参数：

  • UART_HandleTypeDef *huart UATR的别名 如 : UART_HandleTypeDef huart1; 别名就是huart1
  • *pData 接收到的数据存放地址
  • Size 接收的字节数
举例：    HAL_UART_Receive_IT(&huart1,(uint8_t *)&value,1);   //中断接收一个字符，存储到value中

2、串口中断函数

  • HAL_UART_IRQHandler(UART_HandleTypeDef *huart); //串口中断处理函数
  • HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart); //串口发送中断回调函数
  • HAL_UART_TxHalfCpltCallback(UART_HandleTypeDef *huart); //串口发送一半中断回调函数（用的较少）
  • HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart); //串口接收中断回调函数
  • HAL_UART_RxHalfCpltCallback(UART_HandleTypeDef *huart);//串口接收一半回调函数（用的较少）
  • HAL_UART_ErrorCallback();串口接收错误函数
    串口接收中断回调函数:
HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart);

功能：HAL库的中断进行完之后，并不会直接退出，而是会进入中断回调函数中，用户可以在其中设置代码，
串口中断接收完成之后，会进入该函数，该函数为空函数，用户需自行修改，

参数：

  • UART_HandleTypeDef *huart UATR的别名 如 : UART_HandleTypeDefhuart1; 别名就是huart1
举例：   HAL_UART_RxCpltCallback(&huart1){        //用户代码          }

串口中断处理函数

HAL_UART_IRQHandler(UART_HandleTypeDef *huart);

功能：对接收到的数据进行判断和处理 判断是发送中断还是接收中断，然后进行数据的发送和接收，在中断服务函数中使用

如果接收数据，则会进行接收中断处理函数

 /* UART in mode Receiver ---------------------------------------------------*/
  if((tmp_flag != RESET) && (tmp_it_source != RESET))
  { 
    UART_Receive_IT(huart);
  }

如果发送数据，则会进行发送中断处理函数

  /* UART in mode Transmitter ------------------------------------------------*/
  if (((isrflags & USART_SR_TXE) != RESET) && ((cr1its & USART_CR1_TXEIE) != RESET))
  {
    UART_Transmit_IT(huart);
    return;
  }

3、串口查询函数

HAL_UART_GetState(); 判断UART的接收是否结束，或者发送数据是否忙碌
举例：

while(HAL_UART_GetState(&huart1) == HAL_UART_STATE_BUSY_TX)   //检测UART发送结束

二、UART使用之中断

UART通常有三种I / O方式，分别为轮询、中断和DMA，下面先以中断为例展示UART程序开发步骤。

2.1. CubeMX配置UART1

这里仅是配置UART,如配置GPIO请参考STM32之CubeL4 (GPIO+EXIT)

USART1的GPIO引脚配置（GPIO参数按默认配置即可）如下：

USART1初始化参数配置如下（默认即可）：

USART1的NVIC中断配置（包括中断优先级分组、抢占优先级、子优先级、使能中断等）如下：

由于我们的USART1只使用中断，并没有使用DMA，所以DMA不需要配置。到这里USART1的配置完成，生成代码后到KEIL MDK V5工程中继续新增用户控制逻辑和回调函数。

2.2 完成用户控制逻辑

前面已经介绍过USART HAL库的API函数，其中初始化与反初始化函数已经由CubeMX生成了，我们在用户控制逻辑中主要实现的是I / O函数与处理完成回调函数，由于这里是采用中断方式接收/发送，所以我们主要用到的HAL API如下：

// Drivers\STM32L4xx_HAL_Driver\Inc\stm32l4xx_hal_uart.h

HAL_StatusTypeDef HAL_UART_Transmit_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size););//串口中断模式发送  
HAL_StatusTypeDef HAL_UART_Receive_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size);//串口中断模式接收

void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart);//串口发送中断回调函数
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart);//串口接收中断回调函数

由上面的函数声明可知，UART接收/发送函数需要指定数据长度，当达到指定的数据长度后触发中断，但我们往往不知道将要接收到的数据长度是多少？所以我们不能依赖HAL_UART_Receive_IT直接接收一段数据，常需要在接受完成回调函数中设置接收完成标志位（常把收到回车换行符作为该段数据结束的标志），在用户控制逻辑中只有通过该标志位确定该段数据接收完成后才对其进行处理。

C标准库 I / O 重定向

#include <stdio.h>
namespace std {
  struct __FILE
  {
    int handle;
    /* Whatever you require here. If the only file you are using is */
    /* standard output using printf() for debugging, no file handling */
    /* is required. */
  };
  FILE __stdout;
  FILE __stdin;
  FILE __stderr;
  int fgetc(FILE *f)
  {
    /* Your implementation of fgetc(). */
    return 0;
  }
  int fputc(int c, FILE *stream)
  {
    /* Your implementation of fputc(). */
  }
  int ferror(FILE *stream)
  {
    /* Your implementation of ferror(). */
  }
  long int ftell(FILE *stream)
  {
    /* Your implementation of ftell(). */
  }
  int fclose(FILE *f)
  {
    /* Your implementation of fclose(). */
    return 0;
  }
  int fseek(FILE *f, long nPos, int nMode)
  {
    /* Your implementation of fseek(). */
    return 0;
  }
  int fflush(FILE *f)
  {
    /* Your implementation of fflush(). */    
    return 0;
  }
}

下面我们以实现printf打印数据到USART1为例（即重定义fputc函数）说明C标准库指定输入/输出控制终端的实现过程。重定义的fputc函数代码如下：

/* USER CODE BEGIN Includes */
#include <stdio.h>
#include <string.h>
/* USER CODE END Includes */

// Core\Src\usart.c

/* USER CODE BEGIN 0 */
//文件句柄重定向到标准库输入输出
struct __FILE
{
  int handle;
  /* Whatever you require here. If the only file you are using is */
  /* standard output using printf() for debugging, no file handling */
  /* is required. */
};

FILE __stdout;
FILE __stdin;
FILE __stderr;

//文件输出流重定向到串口USART1
int fputc(int ch, FILE *stream)
{
  /* Your implementation of fputc(). */
	HAL_UART_Transmit(&huart1,(uint8_t *)&ch,1,0xffff);
	while(__HAL_UART_GET_FLAG(&huart1, UART_FLAG_TXE) == RESET);		//等待发送结束
	return ch;
}

要发送/接收数据，一般需要相应的缓冲区暂存数据，同时需要知道数据长度，接收/发送完成标志位等元素，我们可以把这些变量组织成一个结构体变量统一管理，我们定义的数据结构如下：



// Core\Inc\main.h

/* USER CODE BEGIN Private defines */
#define USART1_TX_LEN		256
#define USART1_RX_LEN		256

typedef struct{
	uint8_t			TxBuff[USART1_TX_LEN];
	uint16_t		TxSize;
	uint8_t			Tx_end_flag;
	uint8_t			RxBuff[USART1_RX_LEN];
  	uint8_t			aRxBuff;
	uint16_t		RxSize;
	uint8_t			Rx_end_flag;
}USART_BuffTypeDef;

extern USART_BuffTypeDef usart1_buf;

/* USER CODE END Private defines */



// main.c

/* Private variables ---------------------------------------------------------*/
/* USER CODE BEGIN PV */
USART_BuffTypeDef usart1_buf;

/* USER CODE END PV */

控制逻辑代码实现：

USART_BuffTypeDef结构定义在main.h中，初始化结构体变量usart1_buf在main.c中，usart1_buf作为全局变量，在系统启动时默认初始化为0，所以这里可以省略赋初值。
接下来完成接收/发送回调函数的编写，在接收回调函数中把回车换行符/r或/n作为一段数据的结束标志符，检测到结束标识符则结束标志置位，否则将该字符存放到接收数据缓冲区内；在发送回调函数中返回已发送数据段的字符总数，最后清空发送缓冲区和标志位，两个回调函数的实现代码如下：

// Core\Src\usart.c

/* USER CODE BEGIN 1 */
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
if(huart->Instance == USART1)
  {
		if(usart1_buf.aRxBuff == '\n' || usart1_buf.aRxBuff == '\r')
		{
			usart1_buf.Rx_end_flag = 1;
			usart1_buf.RxBuff[usart1_buf.RxSize] = '\0';
		}
		else
		{
			usart1_buf.RxBuff[usart1_buf.RxSize] = usart1_buf.aRxBuff;
			usart1_buf.RxSize++;
		}
		HAL_UART_Receive_IT(huart, &usart1_buf.aRxBuff, 1);
	}
}

void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
{
	if(huart->Instance == USART1)
    {
	    if(usart1_buf.Tx_end_flag == 0)
			{	
				printf("\r\n\r\n发送完成，已发送字符个数为：%d\r\n",usart1_buf.TxSize);		  
				usart1_buf.TxSize = 0;
				usart1_buf.Tx_end_flag = 1;
				memset(usart1_buf.TxBuff,0,usart1_buf.TxSize);//清除发送BUFF里的数据	
			}
		}
}


// main.c
int main(void)
{
 /***** 这里省去 ****/
  /* USER CODE BEGIN 2 */
	
	if(HAL_UART_Receive_IT(&huart1, &usart1_buf.aRxBuff, 1) != HAL_OK) //必须添加
	{
		Error_Handler();
	}	
	
  /* USER CODE END 2 */
/* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
		if(usart1_buf.Rx_end_flag == 1)
		{
				printf("\r\n\r\n接收到的字符个数为：%d\r\n接收到的数据为：\r\n",usart1_buf.RxSize);
				usart1_buf.TxSize = usart1_buf.RxSize;
				usart1_buf.Tx_end_flag = 0;
			if(HAL_UART_Transmit_IT(&huart1, usart1_buf.RxBuff, usart1_buf.RxSize) != HAL_OK)
				{
					Error_Handler();
				}
			usart1_buf.RxSize = 0;
			usart1_buf.Rx_end_flag = 0;
			memset(usart1_buf.RxBuff,0,usart1_buf.RxSize);//清除接受BUFF里的数据			
		}
		
			HAL_Delay(10);		
		
  }
  /* USER CODE END 3 */
}

上面出现了汉字字符，程序对英文字符的支持是最好的，汉字字符需要注意编码问题，KEIL MDK选择ARM Compiler V6编译器若要使汉字能正常显示，需要选择GB2312编码，但对于该编码AC6编译器会给出字符编码的警告信息，忽略即可。

在程序中使用了C语言的函数sprintf / memset / strlen，因此需要在头文件中包含相应的头文件，同时把main.c中包含的头文件转移到main.h中了。

到这里USART1 Interrupt工程就完成了，编译无错误（有几个跟汉字字符编码相关的警告可忽略），这里我使用的是STM32L431RCT6开发板烧写程序之后，运行结果跟预期一致（注意需要选择波特率115200，勾选发送新行以便添加回车换行符）：

代码连接

总结一下UART接收中断

因为中断接收函数只能触发一次接收中断，所以我们需要在中断回调函数中再调用一次中断接收函数

具体流程：
1、初始化串口

2、在main中第一次调用接收中断函数

3、进入接收中断，接收完数据 进入中断回调函数

4、修改HAL_UART_RxCpltCallback中断回调函数，处理接收的数据，

5 回调函数中要调用一次HAL_UART_Receive_IT函数，使得程序可以重新触发接收中断

HAL_UART_Receive_IT(中断接收函数) -> USART2_IRQHandler(void)(中断服务函数) -> HAL_UART_IRQHandler(UART_HandleTypeDef *huart)(中断处理函数) -> UART_Receive_IT(UART_HandleTypeDef *huart) (接收函数) -> HAL_UART_RxCpltCallback(huart)(中断回调函数)

HAL_UART_RxCpltCallback函数就是用户要重写在main.c里的回调函数。

更新printf打印中文出现警告的解决办法

1.最近开发的项目工程一般都是用AC6编译器，好处是编译速度快，优化等级高，但是AC6对于中文支持不好，项目文件目录一定不要有中文路径，否则不能使用gotodef跳转功能。
2.如果项目内有大量使用printf打印中文字符串，则AC6编译过程会弹出警告信息，虽然不影响使用，但是十分烦人。

3.解决办法 可以填入 -Wno-invalid-source-encoding 将该警告信息屏蔽。

以上

参考文献：
文献链接
文献连接

莫莫伽！
关注
  • 4
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
STM32之CubeL4（一）---HAL详解与CubeMX使用（GPIO + EXIT示例）
流云
08-30 1万+
一、HAL库与STD库对比 之前使用STM32系列芯片都是基于STD（Standard Peripheral Libraries）标准外设库，标准外设库将相关寄存器以结构体的形式组织起来，使用库函数操作外设有点轻度面向对象编程的感觉，比寄存器操作方便不少。但在不同芯片上使用标准外设库开发的程序可移植性比较差，换个芯片常需要重新做大量的开发工作，为了解决这个问题，ST推出了全新的HAL（Hardwa...
基于STM32F427的USART+DMA轮询接收
05-16
基于STM32F427的USART+DMA轮询接收程序，直接存储器访问 (DMA) 用于在外设与存储器之间以及存储器与存储器之间提供高速数据传输。可以在无需任何 CPU 操作的情况下通过 DMA 快速移动数据。这样节省的 CPU 资源可供...
Keil.STM32L4xx_DFP.2.5.0.pack
04-15
Version: 2.5.0 (2020-10-21) Keil.STM32L4xx_DFP.2.5.0.pack Download Updated Pack to STM32Cube_FW_L4 Firmware Package version V1.16.0 using HAL Drivers V1.12.0 Package Description (pdsc): Added global define USE_HAL_DRIVER to the component ::Device:STM32Cube HAL:Common. Device support: Aligned devices with CubeMX DB. CMSIS Flash Algorithm: Removed targets (STM32L4xx_512, STM32L4xx_256) from STM32L4Rx Flash Algorithm project. Added source code for: STM32L476G-Disco QSPI, STM32L4P5G-DK OSPI, STM32L4P5G-DK PSRAM STM32L4R9I-DK PSRAM, STM32L4R9I-DK OSPI1 and STM32L4R9I-EVAL OSPI. Added PSRAM external Loader support for STM32L4R9I-Disco. Fixed STM32L4P5 1M internal flash Loader sector erase with DBANK mode. Fixed STM32L4xx 512K and 128K internal flash Loader sector erase. CMSIS-Driver: MCI: Replaced empty delay loops with _NOP(). Added handling for separate SD and MMC HAL layers. Added busy signal handling after CMDREND interrupt. SPI: Corrected PowerControl function (to return error if Initialize was not called, to abort active transfer if power off was requested). Updated GetDataCount function to give accurate count. Corrected Uninitialize function (to power off the peripheral if it is powered). USART: Added Driver_USART6 (uses LPUART1). Corrected GetTxCount/GetRxCount implementation. USBD: Removed include of stm32l4xx_hal_pcd.h header. Corrected documentation of STM32CubeMx configuration. Updated Boards Examples: Migrated CubeMX projects to V6.0.1. Changed variant selection to "MDK-Plus" where possible. Updated all USB Host/Device examples with user templates from MDK-Middleware v7.11.1.
cubeMAX_IIC_Printf_USART.zip
12-10
有三种实现方式，资源内是中断和DMA方式，稍作修改，把函数后缀删掉，函数参数列表内加入Timeout，就变成了轮询方式。直接打开.sln文件 或者打开.project也可以的。
嵌入式作业3——STM32L431RCT6芯片型号标识信息以及片内Flash区和片内RAM区的大小、地址范围
最新发布
H_Y67的博客
03-30 1147
通过以ARM Cortex-M4为核心的STM32L4系列MCU，由该MCU的存储器映像、中断源与硬件最小系统构建出一种通用嵌入式计算机（AHL-STM32L431）。本博客主要介绍STM32L4系列MCU的型号信息以及该芯片的Flash区和RAM区的存储器映像。
stm32g070使用USART实现printf打印功能
09-26
stm32g070使用USART实现printf打印功能
STM32CubeMx+HAL库：USART串口收发数据的三种方式
枫-琳的博客
01-22 4017
手把手教你STM32CubeMx+HAL库实现USART串口收发数据，带有练习！！
STM32CubeMX教程9 USART/UART 异步通信
lc_guo的博客
12-26 2188
使用STM32CubeMX软件配置STM32F407开发板USART1与PC进行异步通信（阻塞传输方式、中断传输方式）
[UART简单驱动介绍] 代码现成的加了注释看的清楚
狗狗天地
09-08 4494
定义通用串口结构 typedef volatile struct{  vu16 BR;  //baudrate register, 16bit valid, 装入时钟   vu16 EMPTY1; //保留16位 ARM是32位寄存器只用到16位  vu16 TxBUFR;  //传输寄存器  vu16 EMPTY2;  vu16 RxBUFR;  //接收寄存器  vu16 EMPTY3;   
CubeMX 图形配置工具 (UART) H743
denghuajing的博客
02-28 6565
本文分两部分 1.图形操作步骤 2.自动生成代码结构分析 一：使用CubeMX 配STM32H743 串口模块LPUSART 1.使能调试口，以免使用SWD下载需要手动复位 2.配置 时钟树 ，基础配置。配置480MHz 3.配置串口模块 4.配置NVIC中断控制器 5.串口中断函数 6.Project 设置 设置项目名称和路径，IDE 7.生成代码 二。HAL库生成代码解析 1.1 main.c 用户自己增加的代码，必须放在 USER CODE相应的位置，负责再次使用CubeMX的时候会
STM32基础教程（CubeMX）—— 串口通信（USART协议）
weixin_43718316的博客
08-13 4022
串口通信原理 串口通信    通过单一数据线进行数据传输的通信方式，另外还有并行通信的方式。串口通信一次只能发送一个字符，包括起始位、数据位、校验位和停止位。 单工、半双工、全双工、异步、同步 单工：数据只能单向传输。 半双工：数据可以双向传输，但是不能同时发送。 全双工：数据可以双向传输，且可以同时发送。 异步（Universal）：通信双方的时钟不一样时的通信。 同步（Synchronous）：通信双方的时钟一样时的通信。 UART和USART UART（通用异步收发器）和USART（通用同步异步
STM32Cube MX学习二【uart串口通信】
weixin_48426161的博客
07-05 2330
本次选用的是引脚9和10进行串口的通讯因此使用的为uart1，配置如上图所示。 并且将自己的uart中断进行使能，对enable打勾。 重定义printf函数 需要在usart.c文件中添以下的代码进行对stdio.h进行重定向。 首先在头部添加 接着添加重定向代码 1.功能函数使用方法 阻塞发送 本次的使用过程中使用的是串口1 并且定义了一个要发送的数据的数组为 在第1个参数中传入我们使用的串口的地址： 在第2个参数中传入我们要发送数据的首地址： 在第3个参数中传入我们使用的数据的大小，通过sizeo
STM32L151C8-USART1+USART3 -20190813-1347.zip
08-15
STM32L151C8-USART1+USART3 在原有LED例程的基础上，添加了USART1和USART3的支持。 并在开发板上调试通过。
Keil.STM32L4xx_DFP.2.5.0.pack(STM32L4xx系列官方固件库驱动库板级支持包for Keil MDK 5)直接运行即可加载
03-21
Version: 2.5.0 (2020-10-21) Keil.STM32L4xx_DFP.2.5.0.pack Updated Pack to STM32Cube_FW_L4 Firmware Package version V1.16.0 using HAL Drivers V1.12.0 Package Description (pdsc): Added global define ...
CUBEMX 配置USART
weixin_46564335的博客
03-19 1024
if(RXBuffer[USART_RX_LEN-1] == 0x0A && RXBuffer[USART_RX_LEN-2] == 0x0D )//判断结束位。4.最后一定要把RXBuffer清零，RX LEN重新置零，然后再一次开启接收中断，方便下一次接收。
【STM32CubeMX】串口通讯USART串口中断配置
weixin_63135906的博客
01-18 7526
STM32F103 串口通讯USART1串口中断配置，逻辑分析仪抓取实际波形 使用CubeMX生成 串口收发数据，完成对LED灯的控制
STM32CubeMAX——USART
火红色祥云
06-03 1685
STM32CubeMAX——USART 硬件：正点原子STM32H743IIT6
STM32CubeMX学习笔记（6）——USART串口使用
热门推荐
Leung的博客
01-15 2万+
一、USART简介 通用同步异步收发器（Universal Synchronous Asynchronous Receiver and Transmitter）是一个串行通信设备，可以灵活地与外部设备进行全双工数据交换。有别于 USART 还有一个 UART（Universal Asynchronous Receiver and Transmitter），它是在 USART 基础上裁剪掉了同步通信功能，只有异步通信。简单区分同步和异步就是看通信时需不需要对外提供时钟输出，我们平时用的串口通信基本都是 UA
【STM32+cubemx】0004 HAL库开发：uart串口的轮询和中断使用
小白白学电子
10-31 3594
本节我们来学习异步串口uart的使用，包括轮询方式和中断方式。 本节我们使用轮询和中断两种方式，来实现计算机向单片机发送数据，单片机处理之后再将数据返回。 1）cubemx生成代码 首先还是在cubemx中生成代码，选择器件、设置SYS（调试接口）、设置RCC（外部晶振时钟源）这几个步骤和前一节一样（也可以复制前面闪灯的工程，在上面修改）。 然后设置串口引脚，这里我们选择uart1，异步串口，选完后，已经使用的串口引脚PA9和PA10会变成绿色；然后选择开启串口全局中断： 之后，和上一节一
stm32f103c8t6usart.c
11-22
stm32f103c8t6usart.c是一个C语言编写的文件，用于驱动STM32F103C8T6微控制器上的USART（通用同步/异步收发器）功能。该文件实现了USART的初始化、发送和接收功能。 在初始化部分，该文件首先配置了系统时钟和GPIO引脚，然后配置USART的波特率、数据位、停止位、校验位等参数。接下来，通过STM32的寄存器设置来使能USART模块，并将相应的引脚配置为USART的功能。 在发送函数中，通过轮询的方式检测USART的发送缓冲是否为空，并将待发送的数据写入寄存器。如果发送缓冲为空，则将数据从应用程序的缓冲区复制到USART的发送缓冲区。 在接收函数中，同样使用轮询的方式检测USART的接收缓冲是否非空，并将接收到的数据从寄存器中读取。然后，将数据从USART的接收缓冲区复制到应用程序的缓冲区中，以供后续处理。 此外，stm32f103c8t6usart.c文件可能还包含了一些其他辅助函数，用于计算波特率等参数，或者处理接收到的数据。这些辅助函数可以更好地支持USART的功能。 总之，stm32f103c8t6usart.c文件是一个用于驱动STM32F103C8T6微控制器上USART功能的C语言文件。通过该文件的初始化、发送和接收函数，可以实现USART的配置和使用，以满足特定应用程序的通信需求。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值