USART on CLing

PUYA USART — 串口轮询收发与 printf 重定向（HAL 库）

Tue, 08 Sep 2026 14:52:21 +0800

USART — 串口轮询收发与 printf 重定向（HAL 库）

固件库: PY32F0xx_Firmware V1.5.0
芯片: PY32F030
源文件: PUYA/PY32F0xx_Firmware_V1.5.0/Projects/PY32F030-STK/Example/USART/USART_HyperTerminal_Polling/Src/main.c
串口重定向: Drivers/BSP/PY32F030xx_Start_Kit/py32f030xx_Start_Kit.c（_write / __io_putchar）

功能简介

USART（通用同步异步收发器）即常说的“串口”，是 MCU 与电脑/模块通信、打印调试信息最常用的通道。本示例做两件事：

轮询收发：串口先发送欢迎语，再用 HAL_UART_Receive 阻塞等待接收 12 字节，收到后原样回显，最后发结束语、点亮 LED。
printf 重定向（本库特色）：BSP 里已实现 _write / __io_putchar，把 C 库 printf 重定向到 USART2，于是在 ADC 等示例里能直接 printf("adc:%u\r\n", val) 打印。

任务要求的 “UART_Printf（printf 重定向）”在 PUYA 固件里不是独立示例，而是由 BSP_USART_Config() + _write 统一提供。下面先讲官方轮询示例，再专门讲 printf 重定向怎么用。

硬件准备

USB 转串口模块（CH340 / CP2102 等）
接线：开发板 PA2(TX) → 模块 RX，PA3(RX) → 模块 TX，共地
电脑端串口助手（SSCOM / XCOM / PuTTY），波特率 115200-8-N-1

完整代码（官方轮询示例）

#include "main.h"

#define COUNTOF(__BUFFER__)     (sizeof(__BUFFER__) / sizeof(*(__BUFFER__)))
#define TXSTARTMESSAGESIZE      (COUNTOF(aTxStartMessage) - 1)
#define TXENDMESSAGESIZE        (COUNTOF(aTxEndMessage) - 1)

UART_HandleTypeDef UartHandle;
uint8_t aTxStartMessage[] = "\r\n UART Hyperterminal communication based on Polling\r\n Enter 12 characters using keyboard :\r\n";
uint8_t aTxEndMessage[]   = "\r\n Example Finished\r\n";
uint8_t aRxBuffer[12]      = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};

int main(void)
{
  HAL_Init();
  BSP_LED_Init(LED_GREEN);

  /* 串口参数：USART2，115200，8 位，1 停止位，无校验，无流控，收发全开 */
  UartHandle.Instance           = USART2;
  UartHandle.Init.BaudRate      = 115200;
  UartHandle.Init.WordLength    = UART_WORDLENGTH_8B;
  UartHandle.Init.StopBits      = UART_STOPBITS_1;
  UartHandle.Init.Parity        = UART_PARITY_NONE;
  UartHandle.Init.HwFlowCtl     = UART_HWCONTROL_NONE;
  UartHandle.Init.Mode          = UART_MODE_TX_RX;
  UartHandle.Init.OverSampling  = UART_OVERSAMPLING_16;
  UartHandle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
  HAL_UART_Init(&UartHandle);

  /* 1) 发送欢迎语 */
  if (HAL_UART_Transmit(&UartHandle, aTxStartMessage, TXSTARTMESSAGESIZE, 5000) != HAL_OK)
    APP_ErrorHandler();

  /* 2) 阻塞接收 12 字节（串口助手输入 12 个字符） */
  if (HAL_UART_Receive(&UartHandle, aRxBuffer, 12, 5000) != HAL_OK)
    APP_ErrorHandler();

  /* 3) 把收到的 12 字节原样回显 */
  if (HAL_UART_Transmit(&UartHandle, aRxBuffer, 12, 5000) != HAL_OK)
    APP_ErrorHandler();

  /* 4) 发送结束语 */
  if (HAL_UART_Transmit(&UartHandle, aTxEndMessage, TXENDMESSAGESIZE, 5000) != HAL_OK)
    APP_ErrorHandler();

  BSP_LED_On(LED_GREEN);   /* 成功：绿灯常亮 */
  while (1) {}
}

printf 重定向（重点）

py32f030xx_Start_Kit.c 中已实现如下重定向，使得任意示例调用 DEBUG_USART_Config() 后即可使用 printf：

/* printf 最终调用到这里，把每个字符从 USART2 发出 */
int __io_putchar(int ch)
{
  /* 阻塞等待发送数据寄存器空，再写 1 字节 */
  while (!(DEBUG_USART->ISR & USART_ISR_TXE));
  DEBUG_USART->TDR = (ch & 0xFF);
  return ch;
}

/* C 库 write 系统调用：把整个缓冲区逐个字符送出 */
int _write(int file, char *ptr, int len)
{
  int i;
  for (i = 0; i < len; i++)
  {
    __io_putchar(*ptr++);
  }
  return len;
}

使用步骤

在 main() 里调用 DEBUG_USART_Config();（它内部配置 PA2/PA3 为 USART2、115200-8-N-1 并使能时钟）。
工程需勾选 Use MicroLIB（Keil）或链接 libc（GCC/iar），否则 _write 不生效。
之后即可：
1

printf("系统启动 ok，温度=%d℃\r\n", temp);
注意：重定向版是阻塞发送，仅适合调试打印；高吞吐场景请用 HAL_UART_Transmit_DMA 或中断。

代码分段讲解

波特率与时钟：USART2 挂在 APB1，时钟来自 HSI/PLL；波特率 115200 需系统时钟足够且分频匹配，否则乱码。
轮询发送 HAL_UART_Transmit：内部等 TXE 标志直到整帧发完或超时，简单但占用 CPU。
轮询接收 HAL_UART_Receive：阻塞直到收满指定长度或超时；若串口助手发的字节数不足，会一直等（超时 5000ms 后报错）。
重定向原理：C 库的 printf → fputc/_write → __io_putchar → 写 USART 的 TDR，从而形成“打印即串口输出”。

实验现象

串口助手收到欢迎语，提示输入 12 个字符；
输入 12 个字符后，开发板原样回显，再发“Example Finished”，绿灯常亮。

常见问题

串口助手全是乱码？
- 波特率必须与代码一致（115200）；系统时钟（HSI/PLL）设置要匹配库里 DEBUG_USART 的时钟来源。
- 确认 printf 工程勾选了 MicroLIB / 正确链接 libc。
printf 没输出？
- 忘记调用 DEBUG_USART_Config()；或引脚不是 PA2/PA3（被改过需同步改 BSP）。
- 确认 HAL_UART_MODULE_ENABLED 宏已开（否则 printf 重定向分支被编译掉）。
HAL_UART_Receive 卡住？
- 它要收满 12 字节才返回；串口助手发的字符数不够或没勾选“发送新行”都会超时。教学建议先固定长度，或用中断/不定长（见 USART_HyperTerminal_IT）。
TX/RX 接反？
- 必须交叉：板 TX → 模块 RX，板 RX → 模块 TX，并共地。

小结

串口配置三要素：波特率、数据格式（8-N-1）、时钟来源。
轮询收发最简单但阻塞 CPU；正式项目用中断/DMA。
通过 _write/__io_putchar 重定向 printf，是最高效的调试打印手段。

拓展应用

用 printf 打印变量/状态，做在线调试，替代单步。
升级为 HAL_UART_Transmit_IT/DMA 做高吞吐日志或命令解析。
接收中断 + 环形缓冲实现“串口命令行”（解析 AT 指令等）。
双 USART：一个接调试、一个接 WiFi/BLE 模块。

AT32 USART — printf 重定向到串口（嵌入式调试神器）

Tue, 08 Sep 2026 14:56:00 +0800

USART — printf 重定向到串口

难度: ⭐（入门必学）
固件库: AT32F403A_407_Firmware_Library V2.2.2
源文件: project/at_start_f403a/examples/usart/printf/src/main.c

这个实验是干嘛的？

做嵌入式开发，最头疼的就是"程序跑起来了，但不知道里面发生了什么"。

在电脑上编程，你可以用 print() 打印变量值来调试。MCU 没有屏幕怎么办？

答案是：用串口把 printf 的输出发到电脑上。

这个实验教你把 C 语言的 printf 函数"重定向"到 USART 串口。之后你就可以在代码任意位置写 printf("温度=%d", temp)，电脑串口助手就能看到输出。

这是嵌入式开发最常用、最实用的调试手段，没有之一。

硬件准备

你需要一个 USB 转串口模块（几块钱一个）：

模块类型	价格	说明
CH340	~3 块	最便宜，够用
CP2102	~5 块	稳定
FT232	~10 块	贵但好用

接线方式（3 根线）：

开发板          USB转串口模块
  TX  ─────────→  RX
  RX  ←─────────  TX
  GND ──────────  GND

注意：TX 接 RX，RX 接 TX，要交叉！GND 必须共地。

串口助手软件

电脑端需要一个串口助手来查看输出：

软件	平台	推荐度
SSCOM	Windows	⭐⭐⭐ 简单好用
XCOM	Windows	⭐⭐⭐ 功能全
MobaXterm	Windows	⭐⭐⭐ 自带串口
minicom	Linux	⭐⭐

打开串口助手，选择正确的 COM 口（设备管理器里看），设置：

波特率：115200
数据位：8
停止位：1
校验位：None

完整代码

#include "at32f403a_407_board.h"
#include "at32f403a_407_clock.h"

/* volatile 修饰，告诉编译器这个变量可能被中断修改，不要优化掉 */
__IO uint32_t time_cnt = 0;

int main(void)
{
  /* 第一步：系统时钟初始化 */
  system_clock_config();

  /* 第二步：板级初始化（LED、按键等） */
  at32_board_init();

  /* 第三步：串口初始化，波特率 115200 */
  uart_print_init(115200);

  /* 第四步：用 printf 打印一条启动消息 */
  printf("usart printf example: retarget the c library printf function to the usart\r\n");

  /* 第五步：主循环，每秒打印一次计数器 */
  while(1)
  {
    printf("usart printf counter: %u\r\n", time_cnt++);
    delay_sec(1);   // 等 1 秒
  }
}

代码逐行讲解

1. 头文件

1
2

#include "at32f403a_407_board.h"   // 板级支持包，包含 uart_print_init() 等
#include "at32f403a_407_clock.h"   // 时钟配置

2. 全局变量

`1`	`__IO uint32_t time_cnt = 0;`

__IO 是 volatile 的宏定义，表示这个变量可能被意外修改（比如中断里），编译器不要做优化
如果不加 __IO，编译器可能把 time_cnt++ 优化掉，你就看不到计数器变化了

3. 串口初始化

`1`	`uart_print_init(115200);`

这行代码做了两件事：

配置 USART1：设置波特率 115200、8 数据位、无校验、1 停止位
重定向 printf：把 printf 的输出接到 USART1 的发送引脚

波特率 115200 意味着每秒可以传输约 11520 个字节（每个字节 10 bit），足够打印调试信息了。

4. printf 输出

`1`	`printf("usart printf counter: %u\r\n", time_cnt++);`

%u — 无符号整数格式
\r\n — 回车换行（串口助手需要这个才能正确显示）
time_cnt++ — 先打印值，再自增

5. 延时

`1`	`delay_sec(1); // 等 1 秒`

如果不加延时，printf 会以 MCU 的速度疯狂输出，串口助手会收到一大堆数据。

printf 重定向的原理（进阶）

uart_print_init() 内部做了什么？其实很简单：

在 C 标准库里，printf 最终会调用一个叫 fputc 的函数来输出每个字符。我们只需要重写这个函数，让它把字符发到串口：

// 这段代码在 at32f403a_407_board.c 里，你不用自己写
int fputc(int ch, FILE *f)
{
  // 把字符 ch 通过 USART1 发出去
  usart_data_transmit(USART1, (uint16_t)ch);
  // 等待发送完成
  while(usart_flag_get(USART1, USART_TDC_FLAG) == RESET);
  return ch;
}

这就是"重定向"的全部秘密：替换 fputc，把输出目标从屏幕改成串口。

常用 printf 格式

printf("十进制: %d\n", 123);          // 十进制: 123
printf("十六进制: 0x%X\n", 0xFF);     // 十六进制: 0xFF
printf("浮点数: %.2f\n", 3.14);       // 浮点数: 3.14
printf("字符串: %s\n", "hello");      // 字符串: hello
printf("温度=%d, 湿度=%d\n", 25, 60); // 同时打印多个变量

实验现象

编译、下载程序
打开串口助手，选择正确的 COM 口，波特率 115200
应该看到：

usart printf example: retarget the c library printf function to the usart
usart printf counter: 0
usart printf counter: 1
usart printf counter: 2
...

每秒打印一行，计数器递增。

常见问题

Q: 串口助手收不到数据？

检查 COM 口是否选对（设备管理器里看）
波特率是否 115200
TX/RX 是否交叉连接
GND 是否共地
程序是否下载成功

Q: 收到乱码？

波特率不匹配！代码里是 115200，串口助手也要设 115200
如果时钟配置不对，实际波特率会偏移，也会乱码

Q: 只能用 USART1 吗？

uart_print_init() 默认用 USART1
如果想用其他串口（如 USART2），需要自己修改 fputc 函数

小结

概念	说明
USART	通用同步异步收发器，最常用的串行通信接口
波特率	每秒传输的 bit 数，双方必须一致
printf 重定向	替换 `fputc`，让 printf 输出到串口
`\r\n`	回车换行，串口助手显示必需

学了串口能做什么？

串口是嵌入式开发的"万能接口"——调试、通信、联网都靠它：

调试与监控

用途	说明
变量监控	`printf("温度=%d\n", temp)` 实时查看传感器数据
状态打印	程序跑到哪一步了、有没有进中断、错误码是什么
性能测量	打印代码执行时间，找出性能瓶颈
日志系统	带时间戳的运行日志，出问题后可以回溯

通信与控制

项目	原理	难度
串口控制 LED	电脑发指令控制板子上的灯（“on”/“off”）	⭐
上位机通信	MCU 通过串口把数据发到电脑 Python/C# 程序	⭐⭐
蓝牙透传	接 HC-05 蓝牙模块，手机就能控制 MCU	⭐⭐
WiFi 联网	接 ESP8266 模块，MCU 通过串口发 AT 指令联网	⭐⭐⭐
GPS 定位	接 GPS 模块，解析 NMEA 协议获取经纬度	⭐⭐⭐
RS485 总线	多设备联网通信（工业 Modbus 协议）	⭐⭐⭐
CAN 转串口	汽车/工业设备数据采集	⭐⭐⭐

实际应用场景

智能家居：MCU + ESP8266 + 串口 → 手机远程控制家电
工业采集：MCU + RS485 + 串口 → 采集温湿度传感器数据上传
无人机：MCU + GPS + 串口 → 获取位置信息
调试一切：无论做什么项目，串口 printf 都是你的"眼睛"

核心思路：串口就是 MCU 的"嘴巴"和"耳朵"。能说（printf 发数据）能听（接收指令），就能和电脑、手机、其他设备对话。

下一步：学会了串口打印，接下来可以学 ADC 采样，用 printf 把 ADC 采样值打印出来。

AT32 — 串口 (USART)

Tue, 08 Sep 2026 14:52:21 +0800

AT32 — 串口 (USART)

固件库: AT32F403A_407_Firmware_Library V2.2.2
示例数: 13

什么是串口 (USART)?

USART 是最常用的串行通信接口。通过 TX/RX 两根线就能实现 MCU 与电脑、MCU 与 MCU 之间的数据通信。

示例列表

半双工通信 — half_duplex
硬件流控 (RTS/CTS) — hw_flow_control
空闲中断接收不定长数据 — idle_detection
中断收发 — interrupt
红外 IrDA 模式 — irda
轮询收发 — polling
printf 重定向到串口 — printf
静默模式 — receiver_mute
RS485 通信 — rs485
智能卡模式 — smartcard
同步模式 — synchronous
DMA 中断收发 — transfer_by_dma_interrupt
DMA 轮询收发 — transfer_by_dma_polling

AT32 USART — DMA 轮询收发

Tue, 08 Sep 2026 14:52:21 +0800

USART — DMA 轮询收发

固件库: AT32F403A_407_Firmware_Library V2.2.2
芯片: AT32
源文件: AT32/AT32F403A_407_Firmware_Library_V2.2.2/project/at_start_f403a/examples/usart/transfer_by_dma_polling/src/main.c

功能简介

本示例演示串口轮询收发。CPU 不断检查标志位来判断是否收到数据或是否可以发送。简单直接，但会占用 CPU 时间。

硬件准备

USB 转串口模块（如 CH340、CP2102）
连接：开发板 TX → 模块 RX，开发板 RX → 模块 TX，共地
电脑端打开串口助手（如 SSCOM、XCOM），波特率与代码一致

完整代码

#include "at32f403a_407_board.h"
#include "at32f403a_407_clock.h"
#define COUNTOF(a)                       (sizeof(a) / sizeof(*(a)))
#define USART2_TX_BUFFER_SIZE            (COUNTOF(usart2_tx_buffer) - 1)
#define USART3_TX_BUFFER_SIZE            (COUNTOF(usart3_tx_buffer) - 1)

int main(void)
{
  system_clock_config();
  at32_board_init();
  usart_configuration();
  dma_configuration();

  /* wait dma transmission complete */
  while((dma_flag_get(DMA1_FDT1_FLAG) == RESET) || (dma_flag_get(DMA1_FDT2_FLAG) == RESET) || \
        (dma_flag_get(DMA1_FDT3_FLAG) == RESET) || (dma_flag_get(DMA1_FDT4_FLAG) == RESET));

  while(1)
  {
    /* compare data buffer */
    if(buffer_compare(usart2_tx_buffer, usart3_rx_buffer, USART2_TX_BUFFER_SIZE) && \
       buffer_compare(usart3_tx_buffer, usart2_rx_buffer, USART3_TX_BUFFER_SIZE))
    {
      at32_led_toggle(LED2);
      at32_led_toggle(LED3);
      at32_led_toggle(LED4);
      delay_sec(1);
    }
  }
}

代码讲解

系统时钟初始化：配置 MCU 的主频和时钟树。不同芯片的时钟配置不同，一般由工具生成。

板级初始化：初始化开发板上的 LED、按键等基础外设。

延时：使用系统延时函数控制 LED 翻转间隔。

实验现象

串口助手收到开发板发送的数据
发送数据后开发板原样返回（回显）

注意事项

串口助手波特率必须与代码一致
检查 TX/RX 是否交叉连接
共地是必须的

AT32 USART — DMA 中断收发

Tue, 08 Sep 2026 14:52:21 +0800

USART — DMA 中断收发

固件库: AT32F403A_407_Firmware_Library V2.2.2
芯片: AT32
源文件: AT32/AT32F403A_407_Firmware_Library_V2.2.2/project/at_start_f403a/examples/usart/transfer_by_dma_interrupt/src/main.c

功能简介

本示例演示串口中断收发。当收到数据或发送完成时，硬件自动触发中断，CPU 不需要轮询等待。效率更高，是实际项目中最常用的方式。

硬件准备

USB 转串口模块（如 CH340、CP2102）
连接：开发板 TX → 模块 RX，开发板 RX → 模块 TX，共地
电脑端打开串口助手（如 SSCOM、XCOM），波特率与代码一致

完整代码

#include "at32f403a_407_board.h"
#include "at32f403a_407_clock.h"
#define COUNTOF(a)                       (sizeof(a) / sizeof(*(a)))
#define USART2_TX_BUFFER_SIZE            (COUNTOF(usart2_tx_buffer) - 1)
#define USART3_TX_BUFFER_SIZE            (COUNTOF(usart3_tx_buffer) - 1)

int main(void)
{
  system_clock_config();
  at32_board_init();
  nvic_priority_group_config(NVIC_PRIORITY_GROUP_4);
  usart_configuration();
  dma_configuration();

  /* wait dma transmission complete */
  while((usart2_tx_dma_status == 0) || (usart2_rx_dma_status == 0) || (usart3_tx_dma_status == 0) || (usart3_rx_dma_status == 0));

  while(1)
  {
    /* compare data buffer */
    if(buffer_compare(usart2_tx_buffer, usart3_rx_buffer, USART2_TX_BUFFER_SIZE) && \
       buffer_compare(usart3_tx_buffer, usart2_rx_buffer, USART3_TX_BUFFER_SIZE))
    {
      at32_led_toggle(LED2);
      at32_led_toggle(LED3);
      at32_led_toggle(LED4);
      delay_sec(1);
    }
  }
}

代码讲解

系统时钟初始化：配置 MCU 的主频和时钟树。不同芯片的时钟配置不同，一般由工具生成。

板级初始化：初始化开发板上的 LED、按键等基础外设。

中断优先级配置：NVIC 设置中断的抢占优先级和子优先级。数字越小优先级越高。

延时：使用系统延时函数控制 LED 翻转间隔。

实验现象

串口助手收到开发板发送的数据
发送数据后开发板原样返回（回显）

注意事项

串口助手波特率必须与代码一致
检查 TX/RX 是否交叉连接
共地是必须的

AT32 USART — RS485 通信

Tue, 08 Sep 2026 14:52:21 +0800

USART — RS485 通信

固件库: AT32F403A_407_Firmware_Library V2.2.2
芯片: AT32
源文件: AT32/AT32F403A_407_Firmware_Library_V2.2.2/project/at_start_f403a/examples/usart/rs485/src/main.c

功能简介

本示例演示 RS485 通信。RS485 是工业现场最常用的总线标准，支持多设备、长距离通信。关键点是收发方向控制。

硬件准备

USB 转串口模块（如 CH340、CP2102）
连接：开发板 TX → 模块 RX，开发板 RX → 模块 TX，共地
电脑端打开串口助手（如 SSCOM、XCOM），波特率与代码一致

完整代码

#include "at32f403a_407_board.h"
#include "at32f403a_407_clock.h"
#define RS485_BAUDRATE                       9600
#define RS485_BUFFER_SIZE                    128

static void rs485_config(void)
{
  gpio_init_type gpio_init_struct;

  /* enable the uart2 and gpio clock */
  crm_periph_clock_enable(CRM_USART2_PERIPH_CLOCK, TRUE);
  crm_periph_clock_enable(CRM_GPIOA_PERIPH_CLOCK, TRUE);

  gpio_default_para_init(&gpio_init_struct);

  /* configure the uart2 tx,rx,de pin */
  gpio_init_struct.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
  gpio_init_struct.gpio_out_type  = GPIO_OUTPUT_PUSH_PULL;
  gpio_init_struct.gpio_mode = GPIO_MODE_MUX;
  gpio_init_struct.gpio_pins = GPIO_PINS_2;
  gpio_init_struct.gpio_pull = GPIO_PULL_NONE;
  gpio_init(GPIOA, &gpio_init_struct);

  gpio_init_struct.gpio_pins = GPIO_PINS_3;
  gpio_init_struct.gpio_mode = GPIO_MODE_INPUT;
  gpio_init_struct.gpio_pull = GPIO_PULL_UP;
  gpio_init(GPIOA, &gpio_init_struct);

  gpio_init_struct.gpio_pins = GPIO_PINS_1;
  gpio_init_struct.gpio_mode = GPIO_MODE_OUTPUT;
  gpio_init_struct.gpio_out_type  = GPIO_OUTPUT_PUSH_PULL;
  gpio_init(GPIOA, &gpio_init_struct);

  gpio_bits_reset(GPIOA, GPIO_PINS_1);

  /* configure uart2 param */
  usart_init(USART2, RS485_BAUDRATE, USART_DATA_8BITS, USART_STOP_1_BIT);

  usart_flag_clear(USART2, USART_RDBF_FLAG);
  usart_interrupt_enable(USART2, USART_RDBF_INT, TRUE);

  usart_receiver_enable(USART2, TRUE);
  usart_transmitter_enable(USART2, TRUE);
  usart_enable(USART2, TRUE);

  nvic_irq_enable(USART2_IRQn, 1, 0);
}

int main(void)
{
  char str[]="start test..\r\n";
  u8 len = 0;

  system_clock_config();
  at32_board_init();
  nvic_priority_group_config(NVIC_PRIORITY_GROUP_4);

  rs485_config();

  len = sizeof(str);
  rs485_send_data((u8*)str, len);
  while(1)
  {
    if(usart_flag_get(USART2, USART_IDLEF_FLAG) != RESET)
    {
      usart_data_receive(USART2);
      usart_interrupt_enable(USART2, USART_RDBF_INT, FALSE);
      rs485_send_data(rs485_buffer_rx, rs485_buffer_rx_cnt);
      rs485_buffer_rx_cnt = 0;
      usart_interrupt_enable(USART2, USART_RDBF_INT, TRUE);
    }
  }
}

代码讲解

系统时钟初始化：配置 MCU 的主频和时钟树。不同芯片的时钟配置不同，一般由工具生成。

板级初始化：初始化开发板上的 LED、按键等基础外设。

GPIO 配置：设置引脚为输出/输入模式，选择推挽/开漏输出，配置上拉/下拉。

中断优先级配置：NVIC 设置中断的抢占优先级和子优先级。数字越小优先级越高。

实验现象

串口助手收到开发板发送的数据
发送数据后开发板原样返回（回显）

注意事项

串口助手波特率必须与代码一致
检查 TX/RX 是否交叉连接
共地是必须的

AT32 USART — 半双工通信

Tue, 08 Sep 2026 14:52:21 +0800

USART — 半双工通信

固件库: AT32F403A_407_Firmware_Library V2.2.2
芯片: AT32
源文件: AT32/AT32F403A_407_Firmware_Library_V2.2.2/project/at_start_f403a/examples/usart/half_duplex/src/main.c

功能简介

本示例演示串口半双工通信。同一根线上交替收发数据，节省一根线。常见于 RS485 总线。

硬件准备

USB 转串口模块（如 CH340、CP2102）
连接：开发板 TX → 模块 RX，开发板 RX → 模块 TX，共地
电脑端打开串口助手（如 SSCOM、XCOM），波特率与代码一致

完整代码

#include "at32f403a_407_board.h"
#include "at32f403a_407_clock.h"
#define COUNTOF(a)                       (sizeof(a) / sizeof(*(a)))
#define USART2_TX_BUFFER_SIZE            (COUNTOF(usart2_tx_buffer) - 1)
#define USART3_TX_BUFFER_SIZE            (COUNTOF(usart3_tx_buffer) - 1)

int main(void)
{
  system_clock_config();
  at32_board_init();
  usart_configuration();

  /* usart2 transmit and usart3 receive */
  data_count = USART2_TX_BUFFER_SIZE;
  while(data_count)
  {
    while(usart_flag_get(USART2, USART_TDBE_FLAG) == RESET);
    usart_data_transmit(USART2, usart2_tx_buffer[USART2_TX_BUFFER_SIZE-data_count]);
    while(usart_flag_get(USART3, USART_RDBF_FLAG) == RESET);
    usart3_rx_buffer[USART2_TX_BUFFER_SIZE-data_count] = usart_data_receive(USART3);
    data_count--;
  }

  /* usart3 transmit and usart2 receive */
  data_count = USART3_TX_BUFFER_SIZE;
  while(data_count)
  {
    while(usart_flag_get(USART3, USART_TDBE_FLAG) == RESET);
    usart_data_transmit(USART3, usart3_tx_buffer[USART3_TX_BUFFER_SIZE-data_count]);
    while(usart_flag_get(USART2, USART_RDBF_FLAG) == RESET);
    usart2_rx_buffer[USART3_TX_BUFFER_SIZE-data_count] = usart_data_receive(USART2);
    data_count--;
  }

  while(1)
  {
    /* compare data buffer */
    if(buffer_compare(usart2_tx_buffer, usart3_rx_buffer, USART2_TX_BUFFER_SIZE) && \
       buffer_compare(usart3_tx_buffer, usart2_rx_buffer, USART3_TX_BUFFER_SIZE))
    {
      at32_led_toggle(LED2);
      at32_led_toggle(LED3);
      at32_led_toggle(LED4);
      delay_sec(1);
    }
  }
}

代码讲解

系统时钟初始化：配置 MCU 的主频和时钟树。不同芯片的时钟配置不同，一般由工具生成。

板级初始化：初始化开发板上的 LED、按键等基础外设。

延时：使用系统延时函数控制 LED 翻转间隔。

实验现象

串口助手收到开发板发送的数据
发送数据后开发板原样返回（回显）

注意事项

串口助手波特率必须与代码一致
检查 TX/RX 是否交叉连接
共地是必须的

AT32 USART — 红外 IrDA 模式

Tue, 08 Sep 2026 14:52:21 +0800

USART — 红外 IrDA 模式

固件库: AT32F403A_407_Firmware_Library V2.2.2
芯片: AT32
源文件: AT32/AT32F403A_407_Firmware_Library_V2.2.2/project/at_start_f403a/examples/usart/irda/src/main.c

功能简介

本示例演示 USART 串口通信。串口是最基本的通信接口，几乎每个嵌入式项目都会用到。

硬件准备

USB 转串口模块（如 CH340、CP2102）
连接：开发板 TX → 模块 RX，开发板 RX → 模块 TX，共地
电脑端打开串口助手（如 SSCOM、XCOM），波特率与代码一致

完整代码

#include "at32f403a_407_board.h"
#include "at32f403a_407_clock.h"

int main(void)
{
  system_clock_config();
  at32_board_init();
  at32_led_off(LED2);
  at32_led_off(LED3);
  at32_led_off(LED4);
  usart_configuration();

#if defined(TRANSMIT)
  while(usart_flag_get(USART2, USART_TDBE_FLAG) == RESET);
  usart_data_transmit(USART2, 0x55);
  at32_led_on(LED4);
#endif

#if defined(RECEIVE)
  while(usart_flag_get(USART2, USART_RDBF_FLAG) == RESET);
  if(usart_data_receive(USART2) == 0x55)
  {
    at32_led_on(LED4);
  }
#endif

  while(1)
  {
  }
}

代码讲解

系统时钟初始化：配置 MCU 的主频和时钟树。不同芯片的时钟配置不同，一般由工具生成。

板级初始化：初始化开发板上的 LED、按键等基础外设。

实验现象

串口助手收到开发板发送的数据
发送数据后开发板原样返回（回显）

注意事项

串口助手波特率必须与代码一致
检查 TX/RX 是否交叉连接
共地是必须的

AT32 USART — 静默模式

Tue, 08 Sep 2026 14:52:21 +0800

USART — 静默模式

固件库: AT32F403A_407_Firmware_Library V2.2.2
芯片: AT32
源文件: AT32/AT32F403A_407_Firmware_Library_V2.2.2/project/at_start_f403a/examples/usart/receiver_mute/src/main.c

功能简介

本示例演示 USART 串口通信。串口是最基本的通信接口，几乎每个嵌入式项目都会用到。

硬件准备

USB 转串口模块（如 CH340、CP2102）
连接：开发板 TX → 模块 RX，开发板 RX → 模块 TX，共地
电脑端打开串口助手（如 SSCOM、XCOM），波特率与代码一致

完整代码

#include "at32f403a_407_board.h"
#include "at32f403a_407_clock.h"
#define BUFFER_SIZE                      7
#define MATCH_ID_VAL                     0x81
#define ERROR_ID_VAL                     0x82
#define DATA1_VAL                        0x7F
#define DATA2_VAL                        0x7A
#define DATA3_VAL                        0x7B
#define DATA4_VAL                        0x7C

int main(void)
{
  system_clock_config();
  at32_board_init();
  usart_configuration();

  /* usart2 transmit data */
  while(tx_counter < BUFFER_SIZE)
  {
    while(usart_flag_get(USART2, USART_TDBE_FLAG) == RESET);
    usart_data_transmit(USART2, usart2_tx_buffer[tx_counter++]);
  }

  /* wait usart2 data transmission complete */
  while(usart_flag_get(USART2, USART_TDC_FLAG) == RESET);

  while(1)
  {
    if((usart3_rx_buffer[0] == MATCH_ID_VAL) && (usart3_rx_buffer[1] == DATA2_VAL) && \
      (usart3_rx_buffer[2] == MATCH_ID_VAL) && (usart3_rx_buffer[3] == DATA4_VAL))
    {
      at32_led_toggle(LED2);
      at32_led_toggle(LED3);
      at32_led_toggle(LED4);
      delay_sec(1);
    }
  }
}

代码讲解

系统时钟初始化：配置 MCU 的主频和时钟树。不同芯片的时钟配置不同，一般由工具生成。

板级初始化：初始化开发板上的 LED、按键等基础外设。

延时：使用系统延时函数控制 LED 翻转间隔。

实验现象

串口助手收到开发板发送的数据
发送数据后开发板原样返回（回显）

注意事项

串口助手波特率必须与代码一致
检查 TX/RX 是否交叉连接
共地是必须的

AT32 USART — 空闲中断接收不定长数据

Tue, 08 Sep 2026 14:52:21 +0800

USART — 空闲中断接收不定长数据

固件库: AT32F403A_407_Firmware_Library V2.2.2
芯片: AT32
源文件: AT32/AT32F403A_407_Firmware_Library_V2.2.2/project/at_start_f403a/examples/usart/idle_detection/src/main.c

功能简介

本示例演示利用串口空闲中断接收不定长数据。当一帧数据传输完毕、总线空闲时自动触发中断。这是 Modbus、自定义协议等场景的标准做法。

硬件准备

USB 转串口模块（如 CH340、CP2102）
连接：开发板 TX → 模块 RX，开发板 RX → 模块 TX，共地
电脑端打开串口助手（如 SSCOM、XCOM），波特率与代码一致

完整代码

#include "at32f403a_407_board.h"
#include "at32f403a_407_clock.h"

int main(void)
{
  system_clock_config();
  at32_board_init();
  at32_led_off(LED2);
  at32_led_off(LED3);
  at32_led_off(LED4);
  usart_configuration();

  /* transmit a data */
  while(usart_flag_get(USART2, USART_TDBE_FLAG) == RESET);
  usart_data_transmit(USART2, 0x55);

  /* receive a data from the tx pin */
  while(usart_flag_get(USART2, USART_RDBF_FLAG) == RESET);
  usart_data_receive(USART2);

  while(1)
  {
  }
}

代码讲解

系统时钟初始化：配置 MCU 的主频和时钟树。不同芯片的时钟配置不同，一般由工具生成。

板级初始化：初始化开发板上的 LED、按键等基础外设。

实验现象

串口助手收到开发板发送的数据
发送数据后开发板原样返回（回显）

注意事项

串口助手波特率必须与代码一致
检查 TX/RX 是否交叉连接
共地是必须的

AT32 USART — 轮询收发

Tue, 08 Sep 2026 14:52:21 +0800

USART — 轮询收发

固件库: AT32F403A_407_Firmware_Library V2.2.2
芯片: AT32
源文件: AT32/AT32F403A_407_Firmware_Library_V2.2.2/project/at_start_f403a/examples/usart/polling/src/main.c

功能简介

本示例演示串口轮询收发。CPU 不断检查标志位来判断是否收到数据或是否可以发送。简单直接，但会占用 CPU 时间。

硬件准备

USB 转串口模块（如 CH340、CP2102）
连接：开发板 TX → 模块 RX，开发板 RX → 模块 TX，共地
电脑端打开串口助手（如 SSCOM、XCOM），波特率与代码一致

完整代码

#include "at32f403a_407_board.h"
#include "at32f403a_407_clock.h"
#define COUNTOF(a)                       (sizeof(a) / sizeof(*(a)))
#define USART2_TX_BUFFER_SIZE            (COUNTOF(usart2_tx_buffer) - 1)
#define USART3_TX_BUFFER_SIZE            (COUNTOF(usart3_tx_buffer) - 1)

int main(void)
{
  system_clock_config();
  at32_board_init();
  usart_configuration();

  /* wait until end of transmission from usart2 to usart3 */
  while(usart3_rx_counter < usart2_tx_buffer_size)
  {
    while(usart_flag_get(USART2, USART_TDBE_FLAG) == RESET);
    usart_data_transmit(USART2, usart2_tx_buffer[usart2_tx_counter++]);

    while(usart_flag_get(USART3, USART_RDBF_FLAG) == RESET);
    usart3_rx_buffer[usart3_rx_counter++] = usart_data_receive(USART3);
  }

  /* wait until end of transmission from usart3 to usart2 */
  while(usart2_rx_counter < usart3_tx_buffer_size)
  {
    while(usart_flag_get(USART3, USART_TDBE_FLAG) == RESET);
    usart_data_transmit(USART3, usart3_tx_buffer[usart3_tx_counter++]);

    while(usart_flag_get(USART2, USART_RDBF_FLAG) == RESET);
    usart2_rx_buffer[usart2_rx_counter++] = usart_data_receive(USART2);
  }

  while(1)
  {
    /* compare data buffer */
    if(buffer_compare(usart2_tx_buffer, usart3_rx_buffer, USART2_TX_BUFFER_SIZE) && \
       buffer_compare(usart3_tx_buffer, usart2_rx_buffer, USART3_TX_BUFFER_SIZE))
    {
      at32_led_toggle(LED2);
      at32_led_toggle(LED3);
      at32_led_toggle(LED4);
      delay_sec(1);
    }
  }
}

代码讲解

系统时钟初始化：配置 MCU 的主频和时钟树。不同芯片的时钟配置不同，一般由工具生成。

板级初始化：初始化开发板上的 LED、按键等基础外设。

延时：使用系统延时函数控制 LED 翻转间隔。

实验现象

串口助手收到开发板发送的数据
发送数据后开发板原样返回（回显）

注意事项

串口助手波特率必须与代码一致
检查 TX/RX 是否交叉连接
共地是必须的

AT32 USART — 同步模式

Tue, 08 Sep 2026 14:52:21 +0800

USART — 同步模式

固件库: AT32F403A_407_Firmware_Library V2.2.2
芯片: AT32
源文件: AT32/AT32F403A_407_Firmware_Library_V2.2.2/project/at_start_f403a/examples/usart/synchronous/src/main.c

功能简介

本示例演示 USART 串口通信。串口是最基本的通信接口，几乎每个嵌入式项目都会用到。

硬件准备

USB 转串口模块（如 CH340、CP2102）
连接：开发板 TX → 模块 RX，开发板 RX → 模块 TX，共地
电脑端打开串口助手（如 SSCOM、XCOM），波特率与代码一致

完整代码

#include "at32f403a_407_board.h"
#include "at32f403a_407_clock.h"
#define COUNTOF(a)                       (sizeof(a) / sizeof(*(a)))
#define USART2_TX_BUFFER_SIZE            (COUNTOF(usart2_tx_buffer) - 1)
#define SPI2_TX_BUFFER_SIZE              (COUNTOF(spi2_tx_buffer) - 1)
#define DYMMY_BYTE                       0x00

int main(void)
{
  system_clock_config();
  at32_board_init();
  usart_spi_configuration();

  /* wait until end of transmission from usart2 to spi2 */
  while(spi2_rx_counter < usart2_tx_buffer_size)
  {
    /* usart transmit data */
    while(usart_flag_get(USART2, USART_TDBE_FLAG) == RESET);
    usart_data_transmit(USART2, usart2_tx_buffer[usart2_tx_counter++]);

    /* wait until spi receive data */
    while(spi_i2s_flag_get(SPI2, SPI_I2S_RDBF_FLAG) == RESET);
    spi2_rx_buffer[spi2_rx_counter++] = spi_i2s_data_receive(SPI2);

    /* wait until usart receive data, and clear dummy byte in data register */
    while(usart_flag_get(USART2, USART_RDBF_FLAG) == RESET);
    usart_data_receive(USART2);
  }

  /* wait until end of transmission from spi2 to usart2 */
  while(usart2_rx_counter < spi2_tx_buffer_size)
  {
    /* spi put transmit data in data register */
    while(spi_i2s_flag_get(SPI2, SPI_I2S_TDBE_FLAG) == RESET);
    spi_i2s_data_transmit(SPI2, spi2_tx_buffer[spi2_tx_counter++]);

    /* usart transmit a dummy byte to generate clock to slave */
    while(usart_flag_get(USART2, USART_TDBE_FLAG) == RESET);
    usart_data_transmit(USART2, DYMMY_BYTE);

    /* wait until usart receive data */
    while(usart_flag_get(USART2, USART_RDBF_FLAG) == RESET);
    usart2_rx_buffer[usart2_rx_counter++] = usart_data_receive(USART2);
  }

  while(1)
  {
    /* compare data buffer */
    if(buffer_compare(usart2_tx_buffer, spi2_rx_buffer, USART2_TX_BUFFER_SIZE) && \
       buffer_compare(spi2_tx_buffer, usart2_rx_buffer, SPI2_TX_BUFFER_SIZE))
    {
      at32_led_toggle(LED2);
      at32_led_toggle(LED3);
      at32_led_toggle(LED4);
      delay_sec(1);
    }
  }
}

代码讲解

系统时钟初始化：配置 MCU 的主频和时钟树。不同芯片的时钟配置不同，一般由工具生成。

板级初始化：初始化开发板上的 LED、按键等基础外设。

SPI 配置：设置主/从模式、时钟极性（CPOL）、时钟相位（CPHA）、分频系数。主机和从机的 CPOL/CPHA 必须一致。

延时：使用系统延时函数控制 LED 翻转间隔。

实验现象

串口助手收到开发板发送的数据
发送数据后开发板原样返回（回显）

注意事项

串口助手波特率必须与代码一致
检查 TX/RX 是否交叉连接
共地是必须的

AT32 USART — 硬件流控 (RTS/CTS)

Tue, 08 Sep 2026 14:52:21 +0800

USART — 硬件流控 (RTS/CTS)

固件库: AT32F403A_407_Firmware_Library V2.2.2
芯片: AT32
源文件: AT32/AT32F403A_407_Firmware_Library_V2.2.2/project/at_start_f403a/examples/usart/hw_flow_control/src/main.c

功能简介

本示例演示 USART 串口通信。串口是最基本的通信接口，几乎每个嵌入式项目都会用到。

硬件准备

USB 转串口模块（如 CH340、CP2102）
连接：开发板 TX → 模块 RX，开发板 RX → 模块 TX，共地
电脑端打开串口助手（如 SSCOM、XCOM），波特率与代码一致

完整代码

#include "at32f403a_407_board.h"
#include "at32f403a_407_clock.h"
#define BUFFER_SIZE                      16

int main(void)
{
  system_clock_config();
  at32_board_init();
  usart_configuration();

  /* receive a string (BUFFER_SIZE bytes) from the hyperterminal */
  data_count = BUFFER_SIZE;
  while(data_count)
  {
    while(usart_flag_get(USART2, USART_RDBF_FLAG) == RESET);
    rx_buffer[BUFFER_SIZE-data_count] = usart_data_receive(USART2);
    data_count--;
  }

  /* send a buffer from usart to hyperterminal */
  data_count = BUFFER_SIZE;
  while(data_count)
  {
    while(usart_flag_get(USART2, USART_TDBE_FLAG) == RESET);
    usart_data_transmit(USART2, rx_buffer[BUFFER_SIZE-data_count]);
    data_count--;
  }

  while(1)
  {
    at32_led_toggle(LED2);
    at32_led_toggle(LED3);
    at32_led_toggle(LED4);
    delay_sec(1);
  }
}

代码讲解

系统时钟初始化：配置 MCU 的主频和时钟树。不同芯片的时钟配置不同，一般由工具生成。

板级初始化：初始化开发板上的 LED、按键等基础外设。

延时：使用系统延时函数控制 LED 翻转间隔。

实验现象

串口助手收到开发板发送的数据
发送数据后开发板原样返回（回显）

注意事项

串口助手波特率必须与代码一致
检查 TX/RX 是否交叉连接
共地是必须的

AT32 USART — 智能卡模式

Tue, 08 Sep 2026 14:52:21 +0800

USART — 智能卡模式

固件库: AT32F403A_407_Firmware_Library V2.2.2
芯片: AT32
源文件: AT32/AT32F403A_407_Firmware_Library_V2.2.2/project/at_start_f403a/examples/usart/smartcard/src/main.c

功能简介

本示例演示 USART 串口通信。串口是最基本的通信接口，几乎每个嵌入式项目都会用到。

硬件准备

USB 转串口模块（如 CH340、CP2102）
连接：开发板 TX → 模块 RX，开发板 RX → 模块 TX，共地
电脑端打开串口助手（如 SSCOM、XCOM），波特率与代码一致

完整代码

#include "at32f403a_407_board.h"
#include "at32f403a_407_clock.h"
#include "smartcard_config.h"
#define T0_PROTOCOL                      0x00  /* t0 protocol */
#define SETUP_LENGTH                     20
#define HIST_LENGTH                      20
#define SC_RECEIVE_TIMEOUT               0xA000  /* direction to reader */
#define SC_USART_DIV_VAL                 20      /* ISO 7816-3 protocol: SC_CLOCK_FREQ(PCLK/(2*USART_DIV_VAL)) is between 1 and 5 MHz */
#define SC_F_DIV_D                       372     /* ISO 7816-3 protocol: F/D = 372 */
typedef struct

int main(void)
{
  uint32_t index = 0;
  system_clock_config();
  at32_board_init();
  usart_configuration();

  /* loop while no smartcard is detected */
  while(card_inserted == 0)
  {
  }

  /* read smartcard atr response */
  for(index = 0; index < 40; index++, counter = 0)
  {
    while((usart_flag_get(SC_USART, USART_RDBF_FLAG) == RESET) && (counter != SC_RECEIVE_TIMEOUT))
    {
      counter++;
    }

    if(counter != SC_RECEIVE_TIMEOUT)
    {
      dst_buffer[index] = usart_data_receive(SC_USART);
    }
  }

  /* decode atr */
  card_protocol = sc_response_decode(dst_buffer);

  /* test if the inserted card is iso7816-3 t=0 compatible */
  if(card_protocol == 0)
  {
    /* inserted card is iso7816-3 t=0 compatible */
    atr_decode_status = SUCCESS;
  }
  else
  {
    /* inserted smartcard is not iso7816-3 t=0 compatible */
    atr_decode_status = ERROR;
  }

  /* judge whether the result is correct */
  if(atr_decode_status == SUCCESS)
  {
    /* trun on the led */
    at32_led_on(LED2);
    at32_led_on(LED3);
    at32_led_on(LED4);
  }

  while(1)
  {
  }
}

代码讲解

系统时钟初始化：配置 MCU 的主频和时钟树。不同芯片的时钟配置不同，一般由工具生成。

板级初始化：初始化开发板上的 LED、按键等基础外设。

实验现象

串口助手收到开发板发送的数据
发送数据后开发板原样返回（回显）

注意事项

串口助手波特率必须与代码一致
检查 TX/RX 是否交叉连接
共地是必须的

AT32 USART — 中断收发

Tue, 08 Sep 2026 14:52:21 +0800

USART — 中断收发

固件库: AT32F403A_407_Firmware_Library V2.2.2
芯片: AT32
源文件: AT32/AT32F403A_407_Firmware_Library_V2.2.2/project/at_start_f403a/examples/usart/interrupt/src/main.c

功能简介

本示例演示串口中断收发。当收到数据或发送完成时，硬件自动触发中断，CPU 不需要轮询等待。效率更高，是实际项目中最常用的方式。

硬件准备

USB 转串口模块（如 CH340、CP2102）
连接：开发板 TX → 模块 RX，开发板 RX → 模块 TX，共地
电脑端打开串口助手（如 SSCOM、XCOM），波特率与代码一致

完整代码

#include "at32f403a_407_board.h"
#include "at32f403a_407_clock.h"
#define COUNTOF(a)                       (sizeof(a) / sizeof(*(a)))
#define USART2_TX_BUFFER_SIZE            (COUNTOF(usart2_tx_buffer) - 1)
#define USART3_TX_BUFFER_SIZE            (COUNTOF(usart3_tx_buffer) - 1)

int main(void)
{
  system_clock_config();
  at32_board_init();
  usart_configuration();

  /* wait until end of transmission from usart2 to usart3 */
  while(usart3_rx_counter < usart2_tx_buffer_size);

  /* wait until end of transmission from usart3 to usart2 */
  while(usart2_rx_counter < usart3_tx_buffer_size);

  while(1)
  {
    /* compare data buffer */
    if(buffer_compare(usart2_tx_buffer, usart3_rx_buffer, USART2_TX_BUFFER_SIZE) && \
       buffer_compare(usart3_tx_buffer, usart2_rx_buffer, USART3_TX_BUFFER_SIZE))
    {
      at32_led_toggle(LED2);
      at32_led_toggle(LED3);
      at32_led_toggle(LED4);
      delay_sec(1);
    }
  }
}

代码讲解

系统时钟初始化：配置 MCU 的主频和时钟树。不同芯片的时钟配置不同，一般由工具生成。

板级初始化：初始化开发板上的 LED、按键等基础外设。

延时：使用系统延时函数控制 LED 翻转间隔。

实验现象

串口助手收到开发板发送的数据
发送数据后开发板原样返回（回显）

注意事项

串口助手波特率必须与代码一致
检查 TX/RX 是否交叉连接
共地是必须的

GD32 — 串口 (USART)

Tue, 08 Sep 2026 14:52:21 +0800

GD32 — 串口 (USART)

固件库: GD32F30x_Firmware_Library V3.0.3 示例数: 8

什么是 USART？

USART 全称 Universal Synchronous/Asynchronous Receiver/Transmitter（通用同步/异步收发器）。名字很长，但它干的事非常朴素：

用两根线，把一串字节从这头搬到那头。

TX（Transmit）—— 发送线，我说话
RX（Receive）—— 接收线，我听话
再加一根 GND 共地作为电压参考

三根线就能让 MCU 和电脑、MCU 和另一颗 MCU、MCU 和 4G 模块 / GPS / 蓝牙模块聊天。

UART 和 USART 的区别？ 多的那个 S 是 Synchronous（同步）。USART 除了普通异步模式，还支持带独立时钟线的同步模式。但日常 99% 的场合我们都只用异步模式，所以口语里 UART 和 USART 基本混着叫，不用纠结。

为什么串口是嵌入式第一调试工具

初学者最痛苦的事：程序跑飞了，但完全不知道它跑到哪一步、变量值是多少。

学会串口 + printf 之后，你可以在代码任意位置插一句：

`1`	`printf("进入了中断，adc值=%d, 状态=%d\r\n", adc_val, state);`

程序内部的一切立刻变得看得见。这就是为什么几乎所有嵌入式教程都把串口排在点灯之后的第二课 —— 它是效率提升最大的一个技能，学会之后你的调试速度会翻好几倍。

异步通信的核心：波特率与帧格式

波特率（Baudrate）

因为异步模式没有时钟线，收发双方只能靠"事先约定好每一位持续多久"来同步。这个约定就是波特率。

115200 表示每秒传 115200 个二进制位，即每一位持续 1/115200 ≈ 8.68μs。

波特率不一致会怎样？ 收到的全是乱码（比如 锟斤拷、ÿÿÿ）。这是串口调试第一大坑，看到乱码先查波特率。

常用波特率：9600（老设备、GPS 常用）、115200（调试标配）、460800 / 921600（高速传输）。

一帧数据的组成

1
2

空闲(高) │ 起始位 │ D0 D1 D2 D3 D4 D5 D6 D7 │ 校验位 │ 停止位 │ 空闲(高)
         └─ 0 ─┘  └──── 8 位数据(先发低位) ────┘  └可选┘  └─ 1 ─┘

最常见的配置叫 115200-8-N-1，含义是：

项	值	说明
波特率	115200	每秒 115200 位
数据位	8	一次传一个字节
校验位	N (None)	不校验
停止位	1	1 位停止

GD32 库里对应的配置函数：

usart_baudrate_set(USART0, 115200U);                        /* 波特率 */
usart_word_length_set(USART0, USART_WL_8BIT);               /* 8 位数据 */
usart_parity_config(USART0, USART_PM_NONE);                 /* 无校验 */
usart_stop_bit_set(USART0, USART_STB_1BIT);                 /* 1 位停止位 */

注意：usart_deinit() 复位后的默认值就是 8-N-1，所以官方 Printf 例程连这三句都省了，只设了波特率。

GD32F30x 有几个串口？引脚在哪？

GD32F30x 系列最多提供 5 个串口，其中 USART0/1/2 支持全部功能，UART3/4 功能简化（不支持同步模式、智能卡等）。

外设	默认 TX	默认 RX	总线	备注
USART0	PA9	PA10	APB2	最常用作调试口
USART1	PA2	PA3	APB1
USART2	PB10	PB11	APB1
UART3	PC10	PC11	APB1	功能简化
UART4	PC12	PD2	APB1	功能简化

重映射：通过 gpio_pin_remap_config() 可以把串口挪到别的引脚，比如 GPIO_USART0_REMAP 能把 USART0 从 PA9/PA10 换到 PB6/PB7。这在引脚资源紧张的小封装项目里很实用。

三种收发方式，怎么选？

这是本模块 8 个示例真正想教你的东西。

1. 轮询（Polling）—— 最简单，CPU 全程死等

1
2

usart_data_transmit(USART0, ch);
while(RESET == usart_flag_get(USART0, USART_FLAG_TBE));   /* 死等发完 */

优点：代码 2 行，绝对可靠，调试打印首选。
缺点：发 1 个字节要等 ~87μs（115200 下），发 100 字节 CPU 就白等 8.7ms 什么也干不了。
适用：printf 调试、开机打印版本号、低频率少量数据。

2. 中断（Interrupt）—— 数据来了才通知 CPU

`1`	`usart_interrupt_enable(USART0, USART_INT_RBNE); /* 收到一个字节就进中断 */`

优点：CPU 平时可以干别的，来数据了才被"叫醒"，接收不会漏字节。
缺点：每个字节都要进一次中断，115200 下每 87μs 一次中断，高波特率大数据量时中断开销明显。
适用：接收不定长命令帧（配合 IDLE 空闲中断判断帧结束）、接收模块返回的 AT 指令响应。

3. DMA —— 硬件搬数据，CPU 完全不参与

1
2

dma_init(DMA0, DMA_CH3, &dma_init_struct);
usart_dma_transmit_config(USART0, USART_TRANSMIT_DMA_ENABLE);

优点：发 1KB 数据 CPU 只需配置一次，剩下全交给 DMA 硬件，效率天花板。
缺点：配置复杂，要理解通道、方向、地址自增等概念。
适用：大数据量传输（传图片、传日志文件）、高波特率场景、实时性要求高的系统。

推荐学习顺序：Printf（轮询） → Transmitter&receiver_interrupt（中断） → IDLE_receive_interrupt（不定长帧） → DMA_transmitter&receiver（DMA）。这条线走完，串口就算彻底掌握了。

关键标志位（必须理解）

标志位	全称	含义	用在哪
`USART_FLAG_TBE`	Transmit Buffer Empty	发送缓冲区空了，可以塞下一个字节	发送轮询
`USART_FLAG_TC`	Transmission Complete	最后一位真的送出线了	需要精确知道"发完了"时用（如 RS485 切方向）
`USART_FLAG_RBNE`	Read Buffer Not Empty	收到了一个字节，快来取	接收轮询/中断
`USART_FLAG_IDLE`	Idle Line Detected	总线空闲了（一帧结束）	不定长数据接收
`USART_FLAG_ORERR`	Overrun Error	上一个字节还没取走又来新的，丢数据了	错误处理

TBE 和 TC 的区别是新手高频疑问：USART 内部有"发送缓冲寄存器"和"移位寄存器"两级。TBE 置位只说明缓冲寄存器空了（数据已挪到移位寄存器），此时线上还在发。真要等到彻底发完，必须等 TC。做 RS485 半双工时如果用 TBE 就切换方向，最后一个字节会被截断。

常用 API 速查

/* 时钟 */
rcu_periph_clock_enable(RCU_GPIOA);
rcu_periph_clock_enable(RCU_USART0);

/* GPIO：TX 必须复用推挽，RX 浮空输入或上拉输入 */
gpio_init(GPIOA, GPIO_MODE_AF_PP,       GPIO_OSPEED_50MHZ, GPIO_PIN_9);   /* TX */
gpio_init(GPIOA, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_10);  /* RX */

/* 参数 */
usart_deinit(USART0);                                    /* 先复位到已知状态 */
usart_baudrate_set(USART0, 115200U);
usart_receive_config(USART0,  USART_RECEIVE_ENABLE);
usart_transmit_config(USART0, USART_TRANSMIT_ENABLE);
usart_enable(USART0);

/* 收发 */
usart_data_transmit(USART0, 'A');
uint16_t ch = usart_data_receive(USART0);

/* 标志与中断 */
usart_flag_get(USART0, USART_FLAG_TBE);
usart_interrupt_enable(USART0, USART_INT_RBNE);

示例列表

DMA 收发 — DMA_transmitter&receiver
DMA 中断收发 — DMA_transmitter&receiver_interrupt
半双工收发 — Half_duplex_transmitter&receiver
空闲中断接收 — IDLE_receive_interrupt
printf 重定向 — Printf ← 建议从这里开始
接收超时 — Receiver_timeout
同步模式 — Synchronous
中断收发 — Transmitter&receiver_interrupt

GD32 USART — DMA 收发

Tue, 08 Sep 2026 14:52:21 +0800

USART — DMA 收发

固件库: GD32F30x_Firmware_Library V3.0.3
芯片: GD32
源文件: GD32F30x_Firmware_Library_V3.0.3/Examples/USART/DMA_transmitter&receiver/main.c

功能简介

本示例演示串口 DMA 收发。数据搬运完全由 DMA 硬件完成，CPU 只需在搬运完成后收到通知。适合大数据量、高速通信场景。

硬件准备

USB 转串口模块（如 CH340、CP2102）
连接：开发板 TX → 模块 RX，开发板 RX → 模块 TX，共地
电脑端打开串口助手（如 SSCOM、XCOM），波特率与代码一致

完整代码

#include "gd32f30x.h"
#include <stdio.h>
#include "gd32f307c_eval.h"
#define ARRAYNUM(arr_name)     (uint32_t)(sizeof(arr_name) / sizeof(*(arr_name)))
#define USART0_DATA_ADDRESS    ((uint32_t)&USART_DATA(USART0))

int main(void)
{
    dma_parameter_struct dma_init_struct;
    /* enable DMA0 */
    rcu_periph_clock_enable(RCU_DMA0);
    /* initialize USART */
    gd_eval_com_init(EVAL_COM0);
    /* deinitialize DMA channel3(USART0 tx) */
    dma_deinit(DMA0, DMA_CH3);
    dma_struct_para_init(&dma_init_struct);
    dma_init_struct.direction = DMA_MEMORY_TO_PERIPHERAL;
    dma_init_struct.memory_addr = (uint32_t)txbuffer;
    dma_init_struct.memory_inc = DMA_MEMORY_INCREASE_ENABLE;
    dma_init_struct.memory_width = DMA_MEMORY_WIDTH_8BIT;
    dma_init_struct.number = ARRAYNUM(txbuffer);
    dma_init_struct.periph_addr = USART0_DATA_ADDRESS;
    dma_init_struct.periph_inc = DMA_PERIPH_INCREASE_DISABLE;
    dma_init_struct.periph_width = DMA_PERIPHERAL_WIDTH_8BIT;
    dma_init_struct.priority = DMA_PRIORITY_ULTRA_HIGH;
    dma_init(DMA0, DMA_CH3, &dma_init_struct);
    /* configure DMA mode */
    dma_circulation_disable(DMA0, DMA_CH3);   
    /* enable DMA channel3 */
    dma_channel_enable(DMA0, DMA_CH3);
    
    /* enable USART DMA for transmission */
    usart_dma_transmit_config(USART0, USART_TRANSMIT_DMA_ENABLE);

     /* wait DMA channel transfer complete */
    while(RESET == dma_flag_get(DMA0, DMA_CH3, DMA_INTF_FTFIF)){
    }

    while(1){
        /* deinitialize DMA channel4 (USART0 rx) */
        dma_deinit(DMA0, DMA_CH4);
        usart_flag_clear(USART0, USART_FLAG_RBNE);
        usart_dma_receive_config(USART0, USART_RECEIVE_DMA_ENABLE);
        dma_struct_para_init(&dma_init_struct);
        dma_init_struct.direction = DMA_PERIPHERAL_TO_MEMORY;
        dma_init_struct.memory_addr = (uint32_t)rxbuffer;
        dma_init_struct.memory_inc = DMA_MEMORY_INCREASE_ENABLE;
        dma_init_struct.memory_width = DMA_MEMORY_WIDTH_8BIT;
        dma_init_struct.number = 10;
        dma_init_struct.periph_addr = USART0_DATA_ADDRESS;
        dma_init_struct.periph_inc = DMA_PERIPH_INCREASE_DISABLE;
        dma_init_struct.periph_width = DMA_PERIPHERAL_WIDTH_8BIT;
        dma_init_struct.priority = DMA_PRIORITY_ULTRA_HIGH;
        dma_init(DMA0, DMA_CH4, &dma_init_struct);
        /* configure DMA mode */
        dma_circulation_disable(DMA0, DMA_CH4); 
        /* enable DMA channel4 */
        dma_channel_enable(DMA0, DMA_CH4);

        /* wait DMA channel transfer complete */
        while(RESET == dma_flag_get(DMA0, DMA_CH4, DMA_INTF_FTFIF)){
        }
        
        usart_dma_receive_config(USART0, USART_RECEIVE_DMA_DISABLE);
        printf("\n\r%s\n\r", rxbuffer);
    }
}

代码讲解

printf 输出：通过串口打印调试信息。需要先调用 uart_print_init 完成重定向。

DMA 配置：设置源地址、目标地址、传输方向、数据宽度。DMA 搬运数据不占用 CPU。

实验现象

串口助手收到开发板发送的数据
发送数据后开发板原样返回（回显）

注意事项

串口助手波特率必须与代码一致
检查 TX/RX 是否交叉连接
共地是必须的

GD32 USART — DMA 中断收发

Tue, 08 Sep 2026 14:52:21 +0800

USART — DMA 中断收发

固件库: GD32F30x_Firmware_Library V3.0.3
芯片: GD32
源文件: GD32F30x_Firmware_Library_V3.0.3/Examples/USART/DMA_transmitter&receiver_interrupt/main.c

功能简介

本示例演示串口中断收发。当收到数据或发送完成时，硬件自动触发中断，CPU 不需要轮询等待。效率更高，是实际项目中最常用的方式。

硬件准备

USB 转串口模块（如 CH340、CP2102）
连接：开发板 TX → 模块 RX，开发板 RX → 模块 TX，共地
电脑端打开串口助手（如 SSCOM、XCOM），波特率与代码一致

完整代码

#include "gd32f30x.h"
#include <stdio.h>
#include "gd32f307c_eval.h"
#define ARRAYNUM(arr_name)     (uint32_t)(sizeof(arr_name) / sizeof(*(arr_name)))
#define USART0_DATA_ADDRESS    ((uint32_t)&USART_DATA(USART0))
__IO FlagStatus g_transfer_complete = RESET;

void nvic_config(void);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    dma_parameter_struct dma_init_struct;
    /* enable DMA0 */
    rcu_periph_clock_enable(RCU_DMA0);
    /* initialize USART */
    gd_eval_com_init(EVAL_COM0);
    /*configure DMA0 interrupt*/
    nvic_config();
    
    /* deinitialize DMA channel3(USART0 tx) */
    dma_deinit(DMA0, DMA_CH3);
    dma_struct_para_init(&dma_init_struct);

    dma_init_struct.direction = DMA_MEMORY_TO_PERIPHERAL;
    dma_init_struct.memory_addr = (uint32_t)txbuffer;
    dma_init_struct.memory_inc = DMA_MEMORY_INCREASE_ENABLE;
    dma_init_struct.memory_width = DMA_MEMORY_WIDTH_8BIT;
    dma_init_struct.number = ARRAYNUM(txbuffer);
    dma_init_struct.periph_addr = USART0_DATA_ADDRESS;
    dma_init_struct.periph_inc = DMA_PERIPH_INCREASE_DISABLE;
    dma_init_struct.periph_width = DMA_PERIPHERAL_WIDTH_8BIT;
    dma_init_struct.priority = DMA_PRIORITY_ULTRA_HIGH;
    dma_init(DMA0, DMA_CH3, &dma_init_struct);

    /* deinitialize DMA channel4 (USART0 rx) */
    dma_deinit(DMA0, DMA_CH4);
    dma_struct_para_init(&dma_init_struct);

    dma_init_struct.direction = DMA_PERIPHERAL_TO_MEMORY;
    dma_init_struct.memory_addr = (uint32_t)rxbuffer;
    dma_init_struct.memory_inc = DMA_MEMORY_INCREASE_ENABLE;
    dma_init_struct.memory_width = DMA_MEMORY_WIDTH_8BIT;
    dma_init_struct.number = 10;
    dma_init_struct.periph_addr = USART0_DATA_ADDRESS;
    dma_init_struct.periph_inc = DMA_PERIPH_INCREASE_DISABLE;
    dma_init_struct.periph_width = DMA_PERIPHERAL_WIDTH_8BIT;
    dma_init_struct.priority = DMA_PRIORITY_ULTRA_HIGH;
    dma_init(DMA0, DMA_CH4, &dma_init_struct);

    /* configure DMA mode */
    dma_circulation_disable(DMA0, DMA_CH3);
    dma_memory_to_memory_disable(DMA0, DMA_CH3);
    dma_circulation_disable(DMA0, DMA_CH4);
    dma_memory_to_memory_disable(DMA0, DMA_CH4);
    
    /* enable USART DMA for reception */
    usart_dma_receive_config(USART0, USART_RECEIVE_DMA_ENABLE);
    /* enable DMA0 channel4 transfer complete interrupt */
    dma_interrupt_enable(DMA0, DMA_CH4, DMA_INT_FTF);
    /* enable DMA0 channel4 */
    dma_channel_enable(DMA0, DMA_CH4);
    /* enable USART DMA for transmission */
    usart_dma_transmit_config(USART0, USART_TRANSMIT_DMA_ENABLE);
    /* enable DMA0 channel3 transfer complete interrupt */
    dma_interrupt_enable(DMA0, DMA_CH3, DMA_INT_FTF);
    /* enable DMA0 channel3 */
    dma_channel_enable(DMA0, DMA_CH3);
    
    /* waiting for the transfer to complete*/
    while(RESET == g_transfer_complete){
    }
    
    g_transfer_complete = RESET;

    /* waiting for the transfer to complete*/
    while(RESET == g_transfer_complete){
    }

    printf("\n\r%s\n\r", rxbuffer);

    while(1){
    }
}

void nvic_config(void)
{
    nvic_irq_enable(DMA0_Channel3_IRQn, 0, 0);
    nvic_irq_enable(DMA0_Channel4_IRQn, 0, 1);
}

代码讲解

printf 输出：通过串口打印调试信息。需要先调用 uart_print_init 完成重定向。

DMA 配置：设置源地址、目标地址、传输方向、数据宽度。DMA 搬运数据不占用 CPU。

中断优先级配置：NVIC 设置中断的抢占优先级和子优先级。数字越小优先级越高。

实验现象

串口助手收到开发板发送的数据
发送数据后开发板原样返回（回显）

注意事项

串口助手波特率必须与代码一致
检查 TX/RX 是否交叉连接
共地是必须的

GD32 USART — printf 重定向

Tue, 08 Sep 2026 14:52:21 +0800

USART — printf 重定向

固件库: GD32F30x_Firmware_Library V3.0.3 芯片: GD32F307 (GD32307C-EVAL-V1.1 开发板) 源文件: GD32F30x_Firmware_Library_V3.0.3/Examples/USART/Printf/main.c

功能简介

这个例程要解决一个非常朴素但极其重要的问题：让 MCU “说话”。

在电脑上写 C 程序，一句 printf("hello") 就能在黑窗口看到字。但在 MCU 上，printf 默认不知道该把字符送到哪里去 —— 芯片上既没有屏幕也没有控制台。

本例程做的事就是把 printf 的出口"接"到串口 USART0 上。接好之后，你在代码里写的每一句 printf，都会通过 PA9 引脚以 115200 波特率发出去，被电脑上的串口助手接收并显示。

这项技能的价值有多大？ 打个比方：不会 printf 之前，调试程序就像闭着眼睛在黑屋里找东西，只能靠"灯亮不亮"猜；学会 printf 之后，屋里的灯打开了，你能直接看到每个变量的值、程序走到了哪一行、中断进了几次。

程序运行后只做一件事：打印一句 a usart transmit test example!，然后进入死循环。看起来平淡无奇，但重点全在"怎么接通"的那几行配置上。

硬件准备

器材	说明
GD32307C-EVAL-V1.1 开发板	或任意 GD32F30x 系列板子
USB 转串口模块	CH340、CP2102、FT232 任选，几块钱一个
杜邦线 3 根	接 TX / RX / GND
电脑串口助手	SSCOM、XCOM、Putty、VOFA+ 均可

接线（新手最容易错的地方）

    GD32 开发板                    USB 转串口模块
  ┌──────────────┐               ┌──────────────┐
  │  PA9  (TX) ──┼───────────────┼──→ RX        │
  │  PA10 (RX) ──┼───────────────┼──← TX        │
  │  GND       ──┼───────────────┼─── GND       │
  └──────────────┘               └──────┬───────┘
                                        │ USB
                                     ┌──▼──┐
                                     │ 电脑 │
                                     └─────┘

必须记住的两条规则：

TX 接 RX，RX 接 TX（交叉接）。想想两个人打电话，你的嘴要对着对方的耳朵。TX 接 TX 是两个人都在说话，谁也听不见。
GND 必须接！ 串口靠"电压高低"传数据，而"高"和"低"是相对于地的。不共地就没有共同的电压参考，通信必然失败或极不稳定。

偷懒技巧：GD32307C-EVAL 板子上有一个自带的 USB 转串口芯片，把跳线帽按丝印插好就能直接用板上的 USB 口通信，不用外接模块。查一下你板子的原理图看有没有这个便利。

串口助手设置

参数	值
波特率	115200
数据位	8
停止位	1
校验位	None
流控	无

完整代码

第一部分：main.c

#include "gd32f30x.h"          /* 芯片总头文件 */
#include "gd32f307c_eval.h"    /* 开发板 BSP */
#include <stdio.h>             /* printf 的声明就在这里 */

/*!
    \brief      主函数
    \param[in]  无
    \param[out] 无
    \retval     无
*/
int main(void)
{
    /* ===== 第 1 步：打开 GPIOA 的时钟 =====
       USART0 的 TX/RX 默认在 PA9/PA10 上，所以要开 GPIOA */
    rcu_periph_clock_enable(RCU_GPIOA);

    /* ===== 第 2 步：打开 USART0 的时钟 =====
       GPIO 时钟和外设时钟是两套独立的开关，必须都打开 */
    rcu_periph_clock_enable(RCU_USART0);

    /* ===== 第 3 步：把 PA9 配成"复用推挽输出"，交给 USART0 当 TX 用 =====
       注意是 AF_PP 而不是 OUT_PP！
       AF = Alternate Function，意思是"这根脚不听我的，听外设的" */
    gpio_init(GPIOA, GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_9);

    /* ===== 第 4 步：把 PA10 配成"浮空输入"，交给 USART0 当 RX 用 =====
       接收脚是被动听电平，所以配输入模式 */
    gpio_init(GPIOA, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_10);

    /* ===== 第 5 步：配置 USART0 参数 ===== */
    usart_deinit(USART0);                                     /* 先复位到默认状态（8-N-1） */
    usart_baudrate_set(USART0, 115200U);                      /* 波特率 115200 */
    usart_receive_config(USART0, USART_RECEIVE_ENABLE);       /* 使能接收器 */
    usart_transmit_config(USART0, USART_TRANSMIT_ENABLE);     /* 使能发送器 */
    usart_enable(USART0);                                     /* 总开关：使能 USART0 */

    /* ===== 第 6 步：直接用 printf 打印 =====
       \n 换行，\r 回车。串口助手里要两个都有才会正确换行到行首 */
    printf("\n\ra usart transmit test example!\n\r");

    /* 打印完就在这里死循环，什么也不做 */
    while(1);
}

第二部分：真正的"魔法"—— fputc 重写

上面的 main.c 里其实少了最关键的一块拼图。 printf 凭什么就知道要往 USART0 送数据？

秘密在 gd32f307c_eval.c 文件的末尾，官方 BSP 里已经帮你写好了这一段：

/* 重定向 C 库函数 printf 到串口，重定向后可使用 printf 函数 */
int fputc(int ch, FILE *f)
{
    /* 把这一个字符塞进 USART0 的发送数据寄存器 */
    usart_data_transmit(EVAL_COM0, (uint8_t)ch);

    /* 死等：一直查询 TBE 标志，直到发送缓冲区空出来
       说明这个字符已经被硬件接走了，可以返回处理下一个字符 */
    while(RESET == usart_flag_get(EVAL_COM0, USART_FLAG_TBE));

    return ch;
}

就这 3 行，是整个例程的灵魂所在。 下面详细解释它的原理。

代码分段讲解

第 1 段：printf 重定向的原理（本篇最重要的部分）

C 标准库的 printf 内部并不是一个整体，它是分层的：

你的代码:  printf("value = %d\r\n", 100);
              │
              ▼
       ┌──────────────────────────────┐
       │  printf 格式化引擎（库里已实现） │
       │  负责解析 %d %s %f，          │
       │  把参数转成字符串               │
       │  → "value = 100\r\n"         │
       └──────────────┬───────────────┘
                      │ 逐个字符调用
                      ▼
       ┌──────────────────────────────┐
       │  fputc(int ch, FILE *f)      │  ← 这是"底层出口"
       │  库里只留了个空壳（弱定义），      │     我们要自己实现！
       │  需要用户告诉它"送到哪儿去"       │
       └──────────────┬───────────────┘
                      │ 我们的实现
                      ▼
       ┌──────────────────────────────┐
       │  usart_data_transmit()       │
       │  → PA9 引脚 → 串口线 → 电脑    │
       └──────────────────────────────┘

核心理解：printf 负责"把复杂的格式化字符串变成一串普通字符"，fputc 负责"把一个字符送出去"。前者标准库已经写好了（那部分逻辑跟硬件无关），后者必须由我们提供（因为只有我们知道板子上用哪个串口）。

这个设计叫重定向（Retargeting），是 C 标准库为嵌入式预留的钩子。

第 2 段：为什么 TX 用 AF_PP，RX 用 IN_FLOATING

1
2

gpio_init(GPIOA, GPIO_MODE_AF_PP,       GPIO_OSPEED_50MHZ, GPIO_PIN_9);   /* TX */
gpio_init(GPIOA, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_10);  /* RX */

这是新手第二大坑（第一大是忘开时钟）。

PA9 (TX) 为什么必须是 GPIO_MODE_AF_PP？

如果配成普通的 GPIO_MODE_OUT_PP，那这根引脚的电平就由你的程序通过 gpio_bit_set() 控制。但我们希望它由 USART0 外设硬件自动按波特率翻转 —— 每秒 11 万多次，程序哪来得及一位一位地写？

AF_PP 就是告诉 GPIO 控制器："这根脚的控制权我交出去了，谁申请谁用"。USART0 使能后自动接管 PA9，按 115200 的时序精确输出每一位。

记住这条：任何要交给外设自动驱动的输出引脚，都必须配 AF 模式。 做 PWM 输出、SPI 时钟、I2C 都是同理。

PA10 (RX) 为什么是输入模式？

接收是"听"，引脚被动感知外部电平变化，所以是输入。IN_FLOATING（浮空）适用于对方（USB 转串口模块）已经在主动驱动这根线的场合。

用 GPIO_MODE_IPU（上拉输入）也可以，而且更保险 —— 万一线断了或对方掉电，上拉能保证引脚是稳定的高电平（串口空闲态是高），不会因为浮空乱跳而产生假的起始位。实际项目推荐用 GPIO_MODE_IPU。

第 3 段：usart_deinit() 为什么要先调用

1
2

usart_deinit(USART0);
usart_baudrate_set(USART0, 115200U);

usart_deinit() 是"把 USART0 的所有寄存器恢复到芯片复位后的初始值"。

为什么要这一步？ 两个原因：

保证起点干净。如果程序之前用过 USART0（比如 Bootloader 用过、或者你反复初始化），寄存器里可能残留旧配置。deinit 相当于"格式化"。
拿到已知的默认值。复位后 USART 的默认配置正好是 8 位数据、无校验、1 位停止位，也就是最常用的 8-N-1。所以官方例程里连 usart_word_length_set()、usart_parity_config()、usart_stop_bit_set() 都不用写了 —— deinit 之后它们已经是我们想要的值。

如果你需要非标准配置（比如 9 位数据 + 偶校验），就要在 deinit 之后显式设置：

usart_deinit(USART0);
usart_baudrate_set(USART0, 115200U);
usart_word_length_set(USART0, USART_WL_9BIT);      /* 9 位数据 */
usart_parity_config(USART0, USART_PM_EVEN);        /* 偶校验 */
usart_stop_bit_set(USART0, USART_STB_1BIT);        /* 1 位停止 */

第 4 段：发送/接收/总使能，三个开关的关系

1
2
3

usart_receive_config(USART0,  USART_RECEIVE_ENABLE);    /* 接收器开关 */
usart_transmit_config(USART0, USART_TRANSMIT_ENABLE);   /* 发送器开关 */
usart_enable(USART0);                                   /* 外设总开关 */

可以理解成一个带三个开关的收音机：

usart_transmit_config → “喇叭"开关（REN 位）
usart_receive_config → “麦克风"开关（TEN 位）
usart_enable → 整机"电源"开关（UEN 位）

电源不开，喇叭和麦克风开了也没用。所以 usart_enable() 必须调用，而且习惯上放在最后。

如果你的项目只需要打印（不接收），可以只开发送省点功耗：

1
2

usart_transmit_config(USART0, USART_TRANSMIT_ENABLE);
usart_enable(USART0);

第 5 段：`\n` 和 `\r` 到底该写哪个

`1`	`printf("\n\ra usart transmit test example!\n\r");`

这是个历史遗留的坑：

转义符	名字	ASCII	作用（源自打字机）
`\n`	LF (Line Feed)	0x0A	换行：纸往上滚一行，但打字头横向位置不变
`\r`	CR (Carriage Return)	0x0D	回车：打字头回到行首，但不换行

所以：

只发 \n → 有些串口助手里会看到"阶梯状"输出（每行开头越来越靠右）
只发 \r → 后面的字会把前面的字覆盖掉，永远显示在第一行
发 \r\n 两个 → 才是标准的"回到行首 + 换到下一行”

实际写法建议统一用 "\r\n"（先回车再换行，符合 Windows/串口通用惯例）。本例程写成 "\n\r" 顺序反了，虽然大部分串口助手都能正确处理，但不是标准写法。

第 6 段：fputc 里 `while(TBE)` 的位置很讲究

int fputc(int ch, FILE *f)
{
    usart_data_transmit(EVAL_COM0, (uint8_t)ch);                  /* 先塞数据 */
    while(RESET == usart_flag_get(EVAL_COM0, USART_FLAG_TBE));    /* 后等标志 */
    return ch;
}

注意顺序是"先发后等”，不是"先等后发"。 为什么这样也能工作？

USART 内部有两级寄存器：

1
2
3

    你写入 ──→ [发送数据寄存器 TDATA] ──→ [移位寄存器] ──→ TX 引脚
                        ↑                      ↑
                   TBE 标志监控这里      TC 标志监控这里

复位后 TDATA 是空的，TBE 本来就是 1，所以第一次直接写入没问题。
写入后硬件立即把数据挪到移位寄存器，TBE 重新置 1。
我们 while 等的就是这个"挪走了"的信号，等到之后就可以放心返回，让 printf 送下一个字符。

这种写法的效率其实相当不错：CPU 等待的只是"从 TDATA 挪到移位寄存器"这一小段时间，而不是等整个字节 8.68μs × 10 位全部发完。移位寄存器在慢慢发的同时，CPU 已经可以准备下一个字符了 —— 相当于一个 1 字节深的流水线。

注意 USART_FLAG_TBE 和 USART_FLAG_TC 的区别。如果你做 RS485 通信，发完要立刻把收发芯片切回接收方向，这时必须等 TC（Transmission Complete，最后一位真的离开引脚了），用 TBE 会把最后一个字节截断。这是 RS485 项目的经典 bug。

实验现象

按上面的接线图接好 3 根线。
编译下载程序。
电脑上打开串口助手，选对 COM 口，波特率设 115200，点击"打开串口"。
按开发板上的复位键。

串口助手窗口会立刻显示：

`1`	`a usart transmit test example!`

注意：这句话只在复位/上电时打印一次。如果你打开串口助手之前板子已经跑起来了，是看不到的 —— 按一下复位键就有了。

想看到持续输出？改成这样

#include "systick.h"

int main(void)
{
    uint32_t counter = 0;

    systick_config();                   /* 别忘了配 SysTick，delay_1ms 才能用 */
    /* ...... 上面那些 USART 配置照抄 ...... */

    while(1){
        printf("usart printf counter: %d\r\n", counter++);
        delay_1ms(1000);                /* 每秒打印一次 */
    }
}

串口助手会每秒多一行：

usart printf counter: 0
usart printf counter: 1
usart printf counter: 2
...

看到数字持续增长，说明程序在正常跑 —— 这也是一种最简单的"程序心跳"监控手段。

常见问题

Q1：串口助手一个字都收不到

按顺序排查：

COM 口选错了。打开设备管理器 → 端口(COM 和 LPT)，确认 CH340 是 COM 几。多个串口设备时很容易选错。
TX/RX 没交叉。把两根线互换试试，这是最常见的问题。
忘了共地。GND 必须接，不接可能偶尔收到几个乱码字符。
打开串口助手后没复位。程序只打印一次，错过就没了。
驱动没装好。CH340 在某些 Windows 上需要手动装驱动，设备管理器里有黄色感叹号就是这个问题。
fputc 没有被编译进去。检查工程里有没有把 gd32f307c_eval.c 加进编译列表。如果没有，printf 会链接到库里的空实现，什么都不输出。

Q2：收到的全是乱码（`锟斤拷`、`ÿÿ`、`�` 这类）

几乎 100% 是波特率不匹配。

串口助手波特率改成 115200，逐一试试 9600 / 38400 / 115200，如果某个波特率下能看到部分正常字符，说明主频有偏差。
实际主频和 SystemCoreClock 不一致。波特率是由外设时钟分频得到的，如果外部晶振起振失败，芯片自动跑内部 8MHz RC，实际波特率就全错了。加一句验证：

`1`	`printf("SystemCoreClock = %d\r\n", SystemCoreClock);`

如果这句本身就是乱码，那说明确实是时钟问题。改用调试器看 SystemCoreClock 变量的值，GD32F307 应该是 120000000。

晶振频率宏配错了。检查 gd32f30x.h 里的 HXTAL_VALUE 是否和板子上实际的晶振一致（EVAL 板常见 8MHz 或 25MHz）。晶振是 8MHz 但宏写 25MHz，波特率会差 3 倍多。

Q3：程序卡死在 printf 那一行

用调试器单步，如果卡在 fputc 的 while(TBE) 循环里出不来，说明 USART 硬件没真正工作：

忘了 usart_enable(USART0)。总开关没开，TBE 永远不会置位。
忘了 rcu_periph_clock_enable(RCU_USART0)。外设时钟没开，寄存器写不进去。
用了 EVAL_COM0 但它不是 USART0。检查 gd32f307c_eval.h 里 EVAL_COM0 的定义，跟你 main 里配置的串口要一致。这是"配了 USART0 但 fputc 往 USART1 写"的经典错配。

Q4：`printf("%f", 3.14)` 打不出小数

浮点打印需要额外的库支持，两种解决办法：

Keil MDK：勾选 Options for Target → Target → Use MicroLIB。MicroLIB 是精简版 C 库，体积小且默认支持基本浮点格式化。
不用浮点 printf（推荐，省 Flash 也省时间）：

float temp = 25.63f;
/* 手动拆成整数部分和小数部分 */
printf("temp = %d.%02d\r\n", (int)temp, (int)(temp * 100) % 100);
/* 输出：temp = 25.63 */

嵌入式里浮点 printf 会额外链接几 KB 代码，而且执行慢，能避免就避免。

Q5：为什么有的教程写 `fputc`，有的写 `_write` 或 `__io_putchar`？

这取决于你用的工具链的 C 库实现：

工具链 / C 库	需要重写的函数
Keil MDK + ARMCC / MicroLIB	`int fputc(int ch, FILE *f)`
GCC + newlib (标准)	`int _write(int fd, char *ptr, int len)`
GCC + newlib-nano	`int __io_putchar(int ch)`（配合 `#define PUTCHAR_PROTOTYPE`）
IAR	`size_t __write(int handle, const unsigned char *buf, size_t size)`

GCC 下的通用写法：

int _write(int fd, char *ptr, int len)
{
    int i;
    for(i = 0; i < len; i++){
        usart_data_transmit(USART0, (uint8_t)ptr[i]);
        while(RESET == usart_flag_get(USART0, USART_FLAG_TBE));
    }
    return len;
}

Q6：printf 太慢，影响程序实时性怎么办

printf 是阻塞式的，一句 50 个字符的打印在 115200 下要占用 CPU 约 4.3ms。在中断服务函数或高实时性循环里频繁 printf 会严重拖慢系统。

三个优化方向：

提高波特率。改成 921600 能快 8 倍，现代 USB 转串口芯片都支持。代码只改一个数字。
改用 DMA 发送。把要打印的内容先写入缓冲区，然后让 DMA 后台慢慢发，CPU 立刻返回。参考本模块的 DMA_transmitter&receiver 示例。
正式版本关掉打印。用宏开关一键屏蔽所有调试输出：

#define DEBUG_ENABLE   1

#if DEBUG_ENABLE
    #define DBG_LOG(fmt, ...)   printf("[%s:%d] " fmt "\r\n", \
                                       __func__, __LINE__, ##__VA_ARGS__)
#else
    #define DBG_LOG(fmt, ...)   ((void)0)     /* 发布版本编译后完全消失，零开销 */
#endif

/* 使用 */
DBG_LOG("adc value = %d", adc_val);
/* 输出：[main:42] adc value = 2048 */

这个 DBG_LOG 宏自动带上函数名和行号，是实际项目里非常好用的调试工具，强烈建议抄进你自己的工程模板。

小结

知识点	要记住的核心
printf 重定向原理	库负责格式化，你负责实现 `fputc` 把单个字符送出去
TX 引脚模式	必须 `GPIO_MODE_AF_PP`，交给外设驱动
RX 引脚模式	`GPIO_MODE_IN_FLOATING` 或更保险的 `GPIO_MODE_IPU`
两套时钟	GPIO 时钟 + USART 时钟，都要开
deinit 的意义	复位到干净状态，且默认就是 8-N-1
三个使能开关	发送器、接收器、外设总开关，缺一不可
`\r\n`	回车 + 换行都要发，顺序推荐 `\r\n`
TBE vs TC	TBE 是缓冲区空，TC 是真正发完；RS485 切方向必须用 TC
乱码 = 波特率	看到乱码第一反应查波特率和主频配置

USART0 配置五步曲（背下来，以后写串口不用查手册）：

rcu_periph_clock_enable(RCU_GPIOA);                    /* 1. GPIO 时钟 */
rcu_periph_clock_enable(RCU_USART0);                   /* 2. USART 时钟 */
gpio_init(GPIOA, GPIO_MODE_AF_PP, ..., GPIO_PIN_9);    /* 3. TX 复用推挽 */
gpio_init(GPIOA, GPIO_MODE_IPU,   ..., GPIO_PIN_10);   /* 4. RX 上拉输入 */
usart_deinit(USART0);                                  /* 5. 参数 + 使能 */
usart_baudrate_set(USART0, 115200U);
usart_transmit_config(USART0, USART_TRANSMIT_ENABLE);
usart_receive_config(USART0, USART_RECEIVE_ENABLE);
usart_enable(USART0);

拓展应用

printf 通了之后，你的能力会发生质变。下面这些项目都建立在串口之上：

入门级（现在就能做）

串口监控台：把 ADC 采样值、按键状态、定时器计数值全部实时打印出来，做一个"MCU 状态仪表盘"。这是排查任何 bug 的第一手段。
参数打印式调试法：在每个函数入口打印 printf("enter %s\r\n", __func__)，程序跑飞时看最后打印的是哪个函数，立刻定位问题范围。
开机自检报告：上电依次检测 Flash、外部 RAM、EEPROM、传感器，把每一项的 OK/FAIL 打印成一份漂亮的启动日志。产品级设备都有这个。

进阶级（配合中断接收）

串口命令行（Shell）：接收电脑发来的命令字符串，解析后执行。比如输入 led on 就点灯，adc read 就返回采样值，help 列出所有命令。这是嵌入式项目里最实用的一个功能，让你不用重新编译就能测试各个模块。
上位机通信协议：设计自己的数据帧（如 帧头 0xAA + 长度 + 命令 + 数据 + CRC16 + 帧尾），配合 C# / Python / Qt 写的上位机软件做双向通信。这是绝大多数电子产品的标准架构。
串口 Bootloader（IAP）：通过串口接收新的固件 bin 文件，写入 Flash 后跳转执行，实现"不用拆机、不用下载器就能升级程序"。结合本站的 FMC 擦写示例就能做出来。
AT 指令驱动模块：用串口驱动 ESP8266 WiFi 模块、SIM800 4G 模块、HC-05 蓝牙模块。发 AT+CWJAP="ssid","pwd" 就能联网，是 IoT 项目的必经之路。

数据分析级

VOFA+ / SerialPlot 实时波形显示：用固定格式打印数据（如 printf("%f,%f\r\n", a, b)），上位机自动画成实时曲线。调 PID 参数时看着曲线整理超调和振荡，比盲调效率高 10 倍。
数据记录仪：把传感器数据按 CSV 格式打印（printf("%d,%d,%d\r\n", t, temp, humi)），串口助手保存成文件后直接用 Excel 打开画图分析。
GPS 数据解析：GPS 模块通过串口不断吐出 NMEA 格式语句（$GPGGA,...），解析后就能得到经纬度、海拔、卫星数，做定位记录仪、车载追踪器。

工业实战级

Modbus RTU 从站：在串口上实现 Modbus 协议，你的板子立刻能被任何工业组态软件（如组态王、WinCC）识别和读写。这是工控行业的通用语言。
RS485 多机总线：加一颗 MAX485 芯片把 TTL 电平转成差分信号，通信距离从 1 米延长到 1200 米，还能挂 32 个节点组成总线网络。注意发送完必须等 TC 标志再切换方向。
产品出厂测试治具：通过串口下发测试指令，自动完成各项功能检测并输出报告，一台治具测几千台产品。

下一步该学什么：Transmitter&receiver_interrupt（学会中断接收，让 MCU 能"听"）→ IDLE_receive_interrupt（处理不定长数据帧，这是实际项目最常用的接收方案）→ DMA_transmitter&receiver（高效大数据传输）。

GD32 USART — 半双工收发

Tue, 08 Sep 2026 14:52:21 +0800

USART — 半双工收发

固件库: GD32F30x_Firmware_Library V3.0.3
芯片: GD32
源文件: GD32F30x_Firmware_Library_V3.0.3/Examples/USART/Half_duplex_transmitter&receiver/main.c

功能简介

本示例演示串口半双工通信。同一根线上交替收发数据，节省一根线。常见于 RS485 总线。

硬件准备

USB 转串口模块（如 CH340、CP2102）
连接：开发板 TX → 模块 RX，开发板 RX → 模块 TX，共地
电脑端打开串口助手（如 SSCOM、XCOM），波特率与代码一致

完整代码

#include "gd32f30x.h"
#include "gd32f307c_eval.h"
#define ARRAYNUM(arr_nanme)      (uint32_t)(sizeof(arr_nanme) / sizeof(*(arr_nanme)))
#define TRANSMIT_SIZE0           (ARRAYNUM(transmitter_buffer0) - 1)
#define TRANSMIT_SIZE1           (ARRAYNUM(transmitter_buffer1) - 1)

int main(void)
{
    gd_eval_led_init(LED2);
    gd_eval_led_init(LED3);
    
    /* enable USART and GPIOA clock */
    rcu_periph_clock_enable(RCU_GPIOA);
    rcu_periph_clock_enable(RCU_USART0);
    rcu_periph_clock_enable(RCU_USART1);

    /* configure USART0 Tx as alternate function open-drain */
    gpio_init(GPIOA, GPIO_MODE_AF_OD, GPIO_OSPEED_50MHZ, GPIO_PIN_9);
    /* configure USART1 Tx as alternate function open-drain */
    gpio_init(GPIOA, GPIO_MODE_AF_OD, GPIO_OSPEED_50MHZ, GPIO_PIN_2);
    
    /* USART0 and USART1 baudrate configuration */
    usart_baudrate_set(USART0, 115200);
    usart_baudrate_set(USART1, 115200);

    /* enable USART0 half duplex mode*/
    usart_halfduplex_enable(USART0);
    /* enable USART1 half duplex mode*/
    usart_halfduplex_enable(USART1);

    /* configure USART transmitter */
    usart_transmit_config(USART0, USART_TRANSMIT_ENABLE);
    usart_transmit_config(USART1, USART_TRANSMIT_DISABLE);

    /* configure USART receiver */
    usart_receive_config(USART0, USART_RECEIVE_DISABLE);
    usart_receive_config(USART1, USART_RECEIVE_ENABLE);

    /* enable USART */
    usart_enable(USART0);
    usart_enable(USART1);

    /* clear the USART1 data register */
    usart_data_receive(USART1);

    /* USART0 transmit and USART1 receive */
    while(transfersize0--) {
        /* wait until end of transmit */
        while(RESET == usart_flag_get(USART0, USART_FLAG_TBE)) {
        }
        usart_data_transmit(USART0, transmitter_buffer0[txcount0++]);
 
        while(RESET == usart_flag_get(USART1, USART_FLAG_RBNE)) {
        }
        /* store the received byte in the receiver_buffer1 */
        receiver_buffer1[rxcount0++] = usart_data_receive(USART1);
    }

    /* configure USART transmitter */
    usart_transmit_config(USART0, USART_TRANSMIT_DISABLE);
    usart_transmit_config(USART1, USART_TRANSMIT_ENABLE);

    /* configure USART receiver */
    usart_receive_config(USART0, USART_RECEIVE_ENABLE);
    usart_receive_config(USART1, USART_RECEIVE_DISABLE);

    /* clear the USART0 data register */
    usart_data_receive(USART0);

    /* USART1 transmit and USART0 receive */
    while(transfersize1--) {
        /* wait until end of transmit */
        while(RESET == usart_flag_get(USART1, USART_FLAG_TBE)) {
        }
        usart_data_transmit(USART1, transmitter_buffer1[txcount1++]);

        while(RESET == usart_flag_get(USART0,USART_FLAG_RBNE)) {
        }
        /* store the received byte in the receiver_buffer0 */
        receiver_buffer0[rxcount1++] = usart_data_receive(USART0);
    }

    /* compare the received data with the send ones */
    state1 = memory_compare(transmitter_buffer0, receiver_buffer1, TRANSMIT_SIZE0);
    state2 = memory_compare(transmitter_buffer1, receiver_buffer0, TRANSMIT_SIZE1);
    if(SUCCESS == state1) {
        /* if the data transmitted from USART0 and received by USART1 are the same */
        gd_eval_led_on(LED2);
    }else {
        /* if the data transmitted from USART0 and received by USART1 are not the same */
        gd_eval_led_off(LED2);
    }
    if(SUCCESS == state2) {
        /* if the data transmitted from USART1 and received by USART0 are the same */
        gd_eval_led_on(LED3);
    }else {
        /* if the data transmitted from USART1 and received by USART0 are not the same */
        gd_eval_led_off(LED3);
    }
    while(1) {
    }
}

代码讲解

GPIO 配置：设置引脚为输出/输入模式，选择推挽/开漏输出，配置上拉/下拉。

实验现象

串口助手收到开发板发送的数据
发送数据后开发板原样返回（回显）

注意事项

串口助手波特率必须与代码一致
检查 TX/RX 是否交叉连接
共地是必须的

GD32 USART — 接收超时

Tue, 08 Sep 2026 14:52:21 +0800

USART — 接收超时

固件库: GD32F30x_Firmware_Library V3.0.3
芯片: GD32
源文件: GD32F30x_Firmware_Library_V3.0.3/Examples/USART/Receiver_timeout/main.c

功能简介

本示例演示 USART 串口通信。串口是最基本的通信接口，几乎每个嵌入式项目都会用到。

硬件准备

USB 转串口模块（如 CH340、CP2102）
连接：开发板 TX → 模块 RX，开发板 RX → 模块 TX，共地
电脑端打开串口助手（如 SSCOM、XCOM），波特率与代码一致

完整代码

#include "gd32f30x.h"
#include <stdio.h>
#include "gd32f307c_eval.h"

void nvic_config(void);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    uint32_t i = 0, j = 0;
    nvic_config();
    gd_eval_com_init(EVAL_COM0);
    printf("a usart receive timeout test example!");
    
    while(1){
        if(0 == rxcount){
            /* enable the USART receive interrupt */
            usart_interrupt_enable(USART0, USART_INT_RBNE);
        }else{
            /* enable the USART receive timeout and configure the time of timeout */
            usart_receiver_timeout_enable(USART0);
            usart_receiver_timeout_threshold_config(USART0, 115200*3);

            while(RESET == usart_flag_get(USART0, USART_FLAG_RT));
            for(i=0; i<rxcount; i++){ 
                txbuffer[i] = rxbuffer[j++];
            } 
            /* disable the USART receive interrupt and enable the USART transmit interrupt */
            usart_interrupt_disable(USART0, USART_INT_RBNE);
            usart_interrupt_enable(USART0, USART_INT_TBE);
            
            while(txcount < rxcount);
            usart_flag_clear(USART0, USART_FLAG_RT);
            txcount = 0;
            rxcount = 0; 
            i = 0;
            j = 0;
        }
    }
}

void nvic_config(void)
{
    nvic_irq_enable(USART0_IRQn, 0, 1);
}

代码讲解

printf 输出：通过串口打印调试信息。需要先调用 uart_print_init 完成重定向。

中断优先级配置：NVIC 设置中断的抢占优先级和子优先级。数字越小优先级越高。

实验现象

串口助手收到开发板发送的数据
发送数据后开发板原样返回（回显）

注意事项

串口助手波特率必须与代码一致
检查 TX/RX 是否交叉连接
共地是必须的

GD32 USART — 空闲中断接收

Tue, 08 Sep 2026 14:52:21 +0800

USART — 空闲中断接收

固件库: GD32F30x_Firmware_Library V3.0.3
芯片: GD32
源文件: GD32F30x_Firmware_Library_V3.0.3/Examples/USART/IDLE_receive_interrupt/main.c

功能简介

本示例演示串口中断收发。当收到数据或发送完成时，硬件自动触发中断，CPU 不需要轮询等待。效率更高，是实际项目中最常用的方式。

硬件准备

USB 转串口模块（如 CH340、CP2102）
连接：开发板 TX → 模块 RX，开发板 RX → 模块 TX，共地
电脑端打开串口助手（如 SSCOM、XCOM），波特率与代码一致

完整代码

#include "gd32f30x.h"
#include <stdio.h>
#include "gd32f307c_eval.h"
#define USART0_RDATA_ADDRESS      ((uint32_t)&USART_DATA(USART0))

void dma_config(void);
void usart_config(void);
void nvic_config(void);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    gd_eval_led_init(LED2);
    gd_eval_led_on(LED2);
    nvic_config();
    
    /* initialize DMA */
    dma_config();
    
    /* initialize USART */
    usart_config();

    usart_interrupt_enable(USART0, USART_INT_IDLE);
    printf("\n\rPlease send data less than 256 bytes:\n\r");

    /* wait the data is received and send to the hyperterminal */
    while(1) {
        if(1 == receive_flag) {
            for(tx_count = 0; tx_count < rx_count; tx_count++) {
                while(RESET == usart_flag_get(USART0, USART_FLAG_TBE)) {
                }
                usart_data_transmit(USART0, rxbuffer[tx_count]);
            }
            receive_flag = 0;
        }
    }
}

void dma_config(void)
{
    dma_parameter_struct dma_init_struct;
    
    rcu_periph_clock_enable(RCU_DMA0);
    
    /* deinitialize DMA channel4 (USART0 rx) */
    dma_deinit(DMA0, DMA_CH4);
    dma_init_struct.direction = DMA_PERIPHERAL_TO_MEMORY;
    dma_init_struct.memory_addr = (uint32_t)rxbuffer;
    dma_init_struct.memory_inc = DMA_MEMORY_INCREASE_ENABLE;
    dma_init_struct.memory_width = DMA_MEMORY_WIDTH_8BIT;
    dma_init_struct.number = 256;
    dma_init_struct.periph_addr = USART0_RDATA_ADDRESS;
    dma_init_struct.periph_inc = DMA_PERIPH_INCREASE_DISABLE;
    dma_init_struct.periph_width = DMA_PERIPHERAL_WIDTH_8BIT;
    dma_init_struct.priority = DMA_PRIORITY_ULTRA_HIGH;
    dma_init(DMA0, DMA_CH4, &dma_init_struct);
    /* configure DMA mode */
    dma_circulation_disable(DMA0, DMA_CH4);
    /* enable DMA channel4 */
    dma_channel_enable(DMA0, DMA_CH4);
}

void usart_config(void)
{
    /* enable GPIO clock */
    rcu_periph_clock_enable(RCU_GPIOA);

    /* enable USART clock */
    rcu_periph_clock_enable(RCU_USART0);
    
    /* connect port to USARTx_Tx */
    gpio_init(GPIOA, GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_9);

    /* connect port to USARTx_Rx */
    gpio_init(GPIOA, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_10);

    /* configure USART */
    usart_deinit(USART0);
    usart_baudrate_set(USART0, 115200U);
    usart_receive_config(USART0, USART_RECEIVE_ENABLE);
    usart_transmit_config(USART0, USART_TRANSMIT_ENABLE);
    usart_dma_receive_config(USART0, USART_RECEIVE_DMA_ENABLE);
    usart_enable(USART0);
}

void nvic_config(void)
{
    nvic_irq_enable(USART0_IRQn, 0, 0);
}

代码讲解

printf 输出：通过串口打印调试信息。需要先调用 uart_print_init 完成重定向。

GPIO 配置：设置引脚为输出/输入模式，选择推挽/开漏输出，配置上拉/下拉。

DMA 配置：设置源地址、目标地址、传输方向、数据宽度。DMA 搬运数据不占用 CPU。

中断优先级配置：NVIC 设置中断的抢占优先级和子优先级。数字越小优先级越高。

实验现象

串口助手收到开发板发送的数据
发送数据后开发板原样返回（回显）

注意事项

串口助手波特率必须与代码一致
检查 TX/RX 是否交叉连接
共地是必须的

GD32 USART — 同步模式

Tue, 08 Sep 2026 14:52:21 +0800

USART — 同步模式

固件库: GD32F30x_Firmware_Library V3.0.3
芯片: GD32
源文件: GD32F30x_Firmware_Library_V3.0.3/Examples/USART/Synchronous/main.c

功能简介

本示例演示 USART 串口通信。串口是最基本的通信接口，几乎每个嵌入式项目都会用到。

硬件准备

USB 转串口模块（如 CH340、CP2102）
连接：开发板 TX → 模块 RX，开发板 RX → 模块 TX，共地
电脑端打开串口助手（如 SSCOM、XCOM），波特率与代码一致

完整代码

#include "gd32f30x.h"
#include "gd32f307c_eval.h"
#include <stdio.h>
#define txbuffer_size1   (countof(txbuffer1) - 1)
#define txbuffer_size2   (countof(txbuffer2) - 1)
#define DYMMY_BYTE       0x00
#define countof(a)       (sizeof(a) / sizeof(*(a)))

void usart_config(void);
void spi_config(void);
void led_init(void);
ErrStatus memory_compare(uint8_t* src, uint8_t* dst, uint16_t length);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    /* initialize leds */
    led_init();
    /* turn off LED2~5 */
    gd_eval_led_off(LED2);
    gd_eval_led_off(LED3);
    gd_eval_led_off(LED4);
    gd_eval_led_off(LED5);

    /* configure USART */
    usart_config();

    /* configure SPI */
    spi_config();
    
    while(data_read2--){
        while(RESET == usart_flag_get(USART0, USART_FLAG_TBE)){
        }
        /* write one byte in the USART0 data register */
        usart_data_transmit(USART0, txbuffer1[tx_counter1++]);
        /* wait until end of transmit */
        while(RESET == usart_flag_get(USART0, USART_FLAG_TC)){
        }
        /* wait the byte is entirely received by SPI0 */  
        while(RESET == spi_i2s_flag_get(SPI0, SPI_FLAG_RBNE)){
        }
        /* store the received byte in the rxbuffer2 */
        rxbuffer2[rx_counter2++] = spi_i2s_data_receive(SPI0);
    }

    /* clear the USART0 data register */
    usart_data_receive(USART0);

    while(data_read1--){
        /* wait until end of transmit */
        while(RESET == spi_i2s_flag_get(SPI0, SPI_FLAG_TBE)){
        }
        /* write one byte in the SPI0 transmit data register */
        spi_i2s_data_transmit(SPI0, txbuffer2[tx_counter2++]);

        /* send a dummy byte to generate clock to slave */ 
        usart_data_transmit(USART0, DYMMY_BYTE);
        /* wait until end of transmit */
        while(RESET == usart_flag_get(USART0, USART_FLAG_TC)){
        }
        /* wait the byte is entirely received by USART0 */
        while(RESET == usart_flag_get(USART0, USART_FLAG_RBNE)){
        }
        /* store the received byte in the rxbuffer1 */
        rxbuffer1[rx_counter1++] = usart_data_receive(USART0);
    }
  
    /* check the received data with the send ones */
    state1 = memory_compare(txbuffer1, rxbuffer2, txbuffer_size1);
    state2 = memory_compare(txbuffer2, rxbuffer1, txbuffer_size2);
    
    if(SUCCESS == state1){
        /* if the data transmitted from USART0 and received by SPI0 are the same */
        gd_eval_led_on(LED2);
        gd_eval_led_on(LED4);
    }else{
        /* if the data transmitted from USART0 and received by SPI0 are not the same */
        gd_eval_led_off(LED2);
        gd_eval_led_off(LED4);
    }
    if(SUCCESS == state2){
        /* if the data transmitted from SPI0 and received by USART0 are the same */
        gd_eval_led_on(LED3);
        gd_eval_led_on(LED5);
    }else{
        /* if the data transmitted from SPI0 and received by USART0 are not the same */
        gd_eval_led_off(LED3);
        gd_eval_led_off(LED5);
    }
    while(1){
    }
}

void usart_config(void)
{
    rcu_periph_clock_enable(RCU_GPIOA);
    rcu_periph_clock_enable(RCU_USART0);
    rcu_periph_clock_enable(RCU_AF);
    /* configure USART Tx as alternate function push-pull */
    gpio_init(GPIOA,GPIO_MODE_AF_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_9|GPIO_PIN_8);
    gpio_init(GPIOA,GPIO_MODE_IN_FLOATING,GPIO_OSPEED_50MHZ,GPIO_PIN_10);
    /* configure USART synchronous mode */
    usart_synchronous_clock_enable(USART0);
    usart_synchronous_clock_config(USART0, USART_CLEN_EN, USART_CPH_2CK, USART_CPL_HIGH);
    
    usart_baudrate_set(USART0, 115200);
    /* configure USART transmitter */
    usart_transmit_config(USART0, USART_TRANSMIT_ENABLE);
    /* configure USART receiver */
    usart_receive_config(USART0, USART_RECEIVE_ENABLE);
    /* enable USART */
    usart_enable(USART0);
}

void spi_config(void)
{
    spi_parameter_struct spi_init_parameter;
    rcu_periph_clock_enable(RCU_GPIOA);
    rcu_periph_clock_enable(RCU_SPI0);
    rcu_periph_clock_enable(RCU_AF);
    
    spi_i2s_deinit(SPI0);
    
    gpio_init(GPIOA, GPIO_MODE_AF_PP, GPIO_OSPEED_10MHZ, GPIO_PIN_5 | GPIO_PIN_6);
    gpio_init(GPIOA, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_10MHZ, GPIO_PIN_7);
    /* configure SPI0 */
    spi_init_parameter.device_mode = SPI_SLAVE;
    spi_init_parameter.trans_mode = SPI_TRANSMODE_FULLDUPLEX;
    spi_init_parameter.frame_size = SPI_FRAMESIZE_8BIT;
    spi_init_parameter.nss = SPI_NSS_SOFT;
    spi_init_parameter.endian = SPI_ENDIAN_LSB;
    spi_init_parameter.clock_polarity_phase = SPI_CK_PL_HIGH_PH_2EDGE;
    spi_init_parameter.prescale = SPI_PSC_32;
    spi_init(SPI0, &spi_init_parameter);

    /* SPI0 enable */
    spi_enable(SPI0);
}

void led_init(void)
{
    gd_eval_led_init(LED2);
    gd_eval_led_init(LED3);
    gd_eval_led_init(LED4);
    gd_eval_led_init(LED5);
}

代码讲解

GPIO 配置：设置引脚为输出/输入模式，选择推挽/开漏输出，配置上拉/下拉。

SPI 配置：设置主/从模式、时钟极性（CPOL）、时钟相位（CPHA）、分频系数。主机和从机的 CPOL/CPHA 必须一致。

实验现象

串口助手收到开发板发送的数据
发送数据后开发板原样返回（回显）

注意事项

串口助手波特率必须与代码一致
检查 TX/RX 是否交叉连接
共地是必须的

GD32 USART — 中断收发

Tue, 08 Sep 2026 14:52:21 +0800

USART — 中断收发

固件库: GD32F30x_Firmware_Library V3.0.3
芯片: GD32
源文件: GD32F30x_Firmware_Library_V3.0.3/Examples/USART/Transmitter&receiver_interrupt/main.c

功能简介

本示例演示串口中断收发。当收到数据或发送完成时，硬件自动触发中断，CPU 不需要轮询等待。效率更高，是实际项目中最常用的方式。

硬件准备

USB 转串口模块（如 CH340、CP2102）
连接：开发板 TX → 模块 RX，开发板 RX → 模块 TX，共地
电脑端打开串口助手（如 SSCOM、XCOM），波特率与代码一致

完整代码

#include "gd32f30x.h"
#include <stdio.h>
#include "gd32f307c_eval.h"
#define ARRAYNUM(arr_nanme)      (uint32_t)(sizeof(arr_nanme) / sizeof(*(arr_nanme)))
#define TRANSMIT_SIZE            (ARRAYNUM(txbuffer) - 1)

int main(void)
{
    /* USART interrupt configuration */
    nvic_irq_enable(USART0_IRQn, 0, 0);
    /* configure COM1 */
    gd_eval_com_init(EVAL_COM0);
    /* enable USART TBE interrupt */  
    usart_interrupt_enable(USART0, USART_INT_TBE);
    
    /* wait until USART send the transmitter_buffer */
    while(txcount < tx_size);
    
    while(RESET == usart_flag_get(USART0, USART_FLAG_TC));
    
    usart_interrupt_enable(USART0, USART_INT_RBNE);
    
    /* wait until USART receive the receiver_buffer */
    while(rxcount < rx_size) {
    }

    if(rxcount == rx_size) {
        printf("\n\rUSART receive successfully!\n\r");
    }

    while (1);
}

代码讲解

printf 输出：通过串口打印调试信息。需要先调用 uart_print_init 完成重定向。

中断优先级配置：NVIC 设置中断的抢占优先级和子优先级。数字越小优先级越高。

实验现象

串口助手收到开发板发送的数据
发送数据后开发板原样返回（回显）

注意事项

串口助手波特率必须与代码一致
检查 TX/RX 是否交叉连接
共地是必须的

PUYA — 串口 (USART)

Tue, 08 Sep 2026 14:52:21 +0800

PUYA — 串口 (USART)

固件库: PY32F002B_Firmware V1.2.1
示例数: 4

什么是串口 (USART)?

USART 是最常用的串行通信接口。通过 TX/RX 两根线就能实现 MCU 与电脑、MCU 与 MCU 之间的数据通信。

示例列表

USART_HyperTerminal_AutoBaund_IT — USART_HyperTerminal_AutoBaund_IT
USART_HyperTerminal_IndefiniteLengthData_IT — USART_HyperTerminal_IndefiniteLengthData_IT
USART_HyperTerminal_IT — USART_HyperTerminal_IT
USART_HyperTerminal_Polling — USART_HyperTerminal_Polling

PUYA — 串口 (USART)

Tue, 08 Sep 2026 14:52:21 +0800

PUYA — 串口 (USART)

固件库: PY32F0xx_Firmware V1.5.0
示例数: 5

什么是串口 (USART)?

USART 是最常用的串行通信接口。通过 TX/RX 两根线就能实现 MCU 与电脑、MCU 与 MCU 之间的数据通信。

示例列表

USART_HyperTerminal_AutoBaund_IT — USART_HyperTerminal_AutoBaund_IT
USART_HyperTerminal_DMA — USART_HyperTerminal_DMA
USART_HyperTerminal_IndefiniteLengthData_IT — USART_HyperTerminal_IndefiniteLengthData_IT
USART_HyperTerminal_IT — USART_HyperTerminal_IT
USART_HyperTerminal_Polling — USART_HyperTerminal_Polling

重点推荐：USART 轮询收发与 printf 重定向已整理为完整教学文档，并专门讲解如何把 printf 重定向到串口。

PUYA — 串口 (USART)

Tue, 08 Sep 2026 14:52:21 +0800

PUYA — 串口 (USART)

固件库: PY32F403_Firmware V1.4.5
示例数: 4

什么是串口 (USART)?

USART 是最常用的串行通信接口。通过 TX/RX 两根线就能实现 MCU 与电脑、MCU 与 MCU 之间的数据通信。

示例列表

USART_HyperTerminal_AutoBaund_IT — USART_HyperTerminal_AutoBaund_IT
USART_HyperTerminal_DMA — USART_HyperTerminal_DMA
USART_HyperTerminal_IT — USART_HyperTerminal_IT
USART_HyperTerminal_Polling — USART_HyperTerminal_Polling

PUYA — 串口 (USART)

Tue, 08 Sep 2026 14:52:21 +0800

PUYA — 串口 (USART)

固件库: PY32L020_Firmware V1.2.1
示例数: 4

什么是串口 (USART)?

USART 是最常用的串行通信接口。通过 TX/RX 两根线就能实现 MCU 与电脑、MCU 与 MCU 之间的数据通信。

示例列表

USART_HyperTerminal_AutoBaund_IT — USART_HyperTerminal_AutoBaund_IT
USART_HyperTerminal_IndefiniteLengthData_IT — USART_HyperTerminal_IndefiniteLengthData_IT
USART_HyperTerminal_IT — USART_HyperTerminal_IT
USART_HyperTerminal_Polling — USART_HyperTerminal_Polling

PUYA USART — USART_HyperTerminal_AutoBaund_IT

Tue, 08 Sep 2026 14:52:21 +0800

USART — USART_HyperTerminal_AutoBaund_IT

固件库: PY32F002B_Firmware V1.2.1
芯片: PUYA
源文件: PUYA/PY32F002B_Firmware_V1.2.1/Projects/PY32F002B-STK/Example/USART/USART_HyperTerminal_AutoBaund_IT/Src/main.c

功能简介

本示例演示 USART 串口通信。串口是最基本的通信接口，几乎每个嵌入式项目都会用到。

硬件准备

USB 转串口模块（如 CH340、CP2102）
连接：开发板 TX → 模块 RX，开发板 RX → 模块 TX，共地
电脑端打开串口助手（如 SSCOM、XCOM），波特率与代码一致

完整代码

1
2

#include "main.h"
#define AUTO_BAUD_MODE0    /*Automatic Baud detection mode selection, measuring

代码讲解

代码结构清晰，主要包含外设初始化配置和主循环中的功能逻辑。请结合注释理解每一步的含义。

实验现象

串口助手收到开发板发送的数据
发送数据后开发板原样返回（回显）

注意事项

串口助手波特率必须与代码一致
检查 TX/RX 是否交叉连接
共地是必须的

PUYA USART — USART_HyperTerminal_AutoBaund_IT

Tue, 08 Sep 2026 14:52:21 +0800

USART — USART_HyperTerminal_AutoBaund_IT

固件库: PY32F0xx_Firmware V1.5.0
芯片: PUYA
源文件: PUYA/PY32F0xx_Firmware_V1.5.0/Projects/PY32F030-STK/Example/USART/USART_HyperTerminal_AutoBaund_IT/Src/main.c

功能简介

本示例演示 USART 串口通信。串口是最基本的通信接口，几乎每个嵌入式项目都会用到。

硬件准备

USB 转串口模块（如 CH340、CP2102）
连接：开发板 TX → 模块 RX，开发板 RX → 模块 TX，共地
电脑端打开串口助手（如 SSCOM、XCOM），波特率与代码一致

完整代码

1
2

#include "main.h"
#define AUTO_BAUD_MODE0    /* Automatic baud rate detection mode selection, measuring from the start bit;

代码讲解

代码结构清晰，主要包含外设初始化配置和主循环中的功能逻辑。请结合注释理解每一步的含义。

实验现象

串口助手收到开发板发送的数据
发送数据后开发板原样返回（回显）

注意事项

串口助手波特率必须与代码一致
检查 TX/RX 是否交叉连接
共地是必须的

PUYA USART — USART_HyperTerminal_AutoBaund_IT

Tue, 08 Sep 2026 14:52:21 +0800

USART — USART_HyperTerminal_AutoBaund_IT

固件库: PY32F403_Firmware V1.4.5
芯片: PUYA
源文件: PUYA/PY32F403_Firmware_V1.4.5/Projects/PY32F403-STK/Example/USART/USART_HyperTerminal_AutoBaund_IT/Src/main.c

功能简介

本示例演示 USART 串口通信。串口是最基本的通信接口，几乎每个嵌入式项目都会用到。

硬件准备

USB 转串口模块（如 CH340、CP2102）
连接：开发板 TX → 模块 RX，开发板 RX → 模块 TX，共地
电脑端打开串口助手（如 SSCOM、XCOM），波特率与代码一致

完整代码

1
2

#include "main.h"
#define AUTO_BAUD_MODE0    /* Automatic baud rate detection mode selection, measuring from the start bit;

代码讲解

代码结构清晰，主要包含外设初始化配置和主循环中的功能逻辑。请结合注释理解每一步的含义。

实验现象

串口助手收到开发板发送的数据
发送数据后开发板原样返回（回显）

注意事项

串口助手波特率必须与代码一致
检查 TX/RX 是否交叉连接
共地是必须的

PUYA USART — USART_HyperTerminal_AutoBaund_IT

Tue, 08 Sep 2026 14:52:21 +0800

USART — USART_HyperTerminal_AutoBaund_IT

固件库: PY32L020_Firmware V1.2.1
芯片: PUYA
源文件: PUYA/PY32L020_Firmware_V1.2.1/Projects/PY32L020-STK/Example/USART/USART_HyperTerminal_AutoBaund_IT/Src/main.c

功能简介

本示例演示 USART 串口通信。串口是最基本的通信接口，几乎每个嵌入式项目都会用到。

硬件准备

USB 转串口模块（如 CH340、CP2102）
连接：开发板 TX → 模块 RX，开发板 RX → 模块 TX，共地
电脑端打开串口助手（如 SSCOM、XCOM），波特率与代码一致

完整代码

1
2

#include "main.h"
#define AUTO_BAUD_MODE0    /*Automatic Baud detection mode selection, measuring

代码讲解

代码结构清晰，主要包含外设初始化配置和主循环中的功能逻辑。请结合注释理解每一步的含义。

实验现象

串口助手收到开发板发送的数据
发送数据后开发板原样返回（回显）

注意事项

串口助手波特率必须与代码一致
检查 TX/RX 是否交叉连接
共地是必须的

PUYA USART — USART_HyperTerminal_DMA

Tue, 08 Sep 2026 14:52:21 +0800

USART — USART_HyperTerminal_DMA

固件库: PY32F0xx_Firmware V1.5.0
芯片: PUYA
源文件: PUYA/PY32F0xx_Firmware_V1.5.0/Projects/PY32F030-STK/Example/USART/USART_HyperTerminal_DMA/Src/main.c

功能简介

本示例演示串口 DMA 收发。数据搬运完全由 DMA 硬件完成，CPU 只需在搬运完成后收到通知。适合大数据量、高速通信场景。

硬件准备

USB 转串口模块（如 CH340、CP2102）
连接：开发板 TX → 模块 RX，开发板 RX → 模块 TX，共地
电脑端打开串口助手（如 SSCOM、XCOM），波特率与代码一致

完整代码

#include "main.h"
#define COUNTOF(__BUFFER__)   (sizeof(__BUFFER__) / sizeof(*(__BUFFER__)))
#define TXSTARTMESSAGESIZE    (COUNTOF(aTxStartMessage) - 1)
#define TXENDMESSAGESIZE      (COUNTOF(aTxEndMessage) - 1)

int main(void)
{
  /* Reset of all peripherals, Initializes the Systick */
  HAL_Init();

  /* Configure LED */
  BSP_LED_Init(LED_GREEN);

  /* Initialize USART2 */
  UartHandle.Instance          = USART2;
  UartHandle.Init.BaudRate     = 115200;
  UartHandle.Init.WordLength   = UART_WORDLENGTH_8B;
  UartHandle.Init.StopBits     = UART_STOPBITS_1;
  UartHandle.Init.Parity       = UART_PARITY_NONE;
  UartHandle.Init.HwFlowCtl    = UART_HWCONTROL_NONE;
  UartHandle.Init.Mode         = UART_MODE_TX_RX;
  UartHandle.Init.OverSampling = UART_OVERSAMPLING_16;
  UartHandle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
  HAL_UART_Init(&UartHandle);
    
  /* Start the transmission process */
  if(HAL_UART_Transmit_DMA(&UartHandle, (uint8_t*)aTxStartMessage, TXSTARTMESSAGESIZE)!= HAL_OK)
  {
    /* Transfer error in transmission process */
    APP_ErrorHandler();
  }

  /* Put UART peripheral in reception process */
  if (HAL_UART_Receive_DMA(&UartHandle, (uint8_t *)aRxBuffer, 12) != HAL_OK)
  {
    /* Transfer error in reception process */
    APP_ErrorHandler();
  }

  /* Wait for the end of the transfer */
  while (HAL_UART_GetState(&UartHandle) != HAL_UART_STATE_READY)
  {
  }

  /* Send the received Buffer */
  if (HAL_UART_Transmit_DMA(&UartHandle, (uint8_t *)aRxBuffer, 12) != HAL_OK)
  {
    /* Transfer error in transmission process */
    APP_ErrorHandler();
  }

  /* Wait for the end of the transfer */
  while (HAL_UART_GetState(&UartHandle) != HAL_UART_STATE_READY)
  {
  }

  /* Send the End Message */
  if(HAL_UART_Transmit_DMA(&UartHandle, (uint8_t*)aTxEndMessage, TXENDMESSAGESIZE)!= HAL_OK)
  {
    /* Transfer error in transmission process */
    APP_ErrorHandler();
  }

  /* Wait for the end of the transfer */
  while (HAL_UART_GetState(&UartHandle) != HAL_UART_STATE_READY)
  {
  }

  /* Turn on LED if test passes then enter infinite loop */
  BSP_LED_On(LED_GREEN);
  
  /* Infinite loop */
  while (1)
  {

  }
}

代码讲解

板级初始化：初始化开发板上的 LED、按键等基础外设。

实验现象

串口助手收到开发板发送的数据
发送数据后开发板原样返回（回显）

注意事项

串口助手波特率必须与代码一致
检查 TX/RX 是否交叉连接
共地是必须的

PUYA USART — USART_HyperTerminal_DMA

Tue, 08 Sep 2026 14:52:21 +0800

USART — USART_HyperTerminal_DMA

固件库: PY32F403_Firmware V1.4.5
芯片: PUYA
源文件: PUYA/PY32F403_Firmware_V1.4.5/Projects/PY32F403-STK/Example/USART/USART_HyperTerminal_DMA/Src/main.c

功能简介

本示例演示串口 DMA 收发。数据搬运完全由 DMA 硬件完成，CPU 只需在搬运完成后收到通知。适合大数据量、高速通信场景。

硬件准备

USB 转串口模块（如 CH340、CP2102）
连接：开发板 TX → 模块 RX，开发板 RX → 模块 TX，共地
电脑端打开串口助手（如 SSCOM、XCOM），波特率与代码一致

完整代码

#include "main.h"
#define COUNTOF(__BUFFER__)   (sizeof(__BUFFER__) / sizeof(*(__BUFFER__)))
#define TXSTARTMESSAGESIZE    (COUNTOF(aTxStartMessage) - 1)
#define TXENDMESSAGESIZE      (COUNTOF(aTxEndMessage) - 1)

代码讲解

代码结构清晰，主要包含外设初始化配置和主循环中的功能逻辑。请结合注释理解每一步的含义。

实验现象

串口助手收到开发板发送的数据
发送数据后开发板原样返回（回显）

注意事项

串口助手波特率必须与代码一致
检查 TX/RX 是否交叉连接
共地是必须的

PUYA USART — USART_HyperTerminal_IndefiniteLengthData_IT

Tue, 08 Sep 2026 14:52:21 +0800

USART — USART_HyperTerminal_IndefiniteLengthData_IT

固件库: PY32F002B_Firmware V1.2.1
芯片: PUYA
源文件: PUYA/PY32F002B_Firmware_V1.2.1/Projects/PY32F002B-STK/Example/USART/USART_HyperTerminal_IndefiniteLengthData_IT/Src/main.c

功能简介

本示例演示 USART 串口通信。串口是最基本的通信接口，几乎每个嵌入式项目都会用到。

硬件准备

USB 转串口模块（如 CH340、CP2102）
连接：开发板 TX → 模块 RX，开发板 RX → 模块 TX，共地
电脑端打开串口助手（如 SSCOM、XCOM），波特率与代码一致

完整代码

#include "main.h"

int main(void)
{
  /* Reset of all peripherals, Initializes the Systick */
  HAL_Init();
  
  /* Configure LED */
  BSP_LED_Init(LED_GREEN);
  
  /* Initialize USART */
  UartHandle.Instance          = USART1;
  UartHandle.Init.BaudRate     = 115200;
  UartHandle.Init.WordLength   = UART_WORDLENGTH_8B;
  UartHandle.Init.StopBits     = UART_STOPBITS_1;
  UartHandle.Init.Parity       = UART_PARITY_NONE;
  UartHandle.Init.HwFlowCtl    = UART_HWCONTROL_NONE;
  UartHandle.Init.Mode         = UART_MODE_TX_RX;
  UartHandle.Init.OverSampling = UART_OVERSAMPLING_16;
  UartHandle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
  HAL_UART_Init(&UartHandle);

  /* Enable RXNE interrupt */
  __HAL_UART_ENABLE_IT(&UartHandle, UART_IT_RXNE);

  while (1)
  {

  }
}

代码讲解

板级初始化：初始化开发板上的 LED、按键等基础外设。

实验现象

串口助手收到开发板发送的数据
发送数据后开发板原样返回（回显）

注意事项

串口助手波特率必须与代码一致
检查 TX/RX 是否交叉连接
共地是必须的

PUYA USART — USART_HyperTerminal_IndefiniteLengthData_IT

Tue, 08 Sep 2026 14:52:21 +0800

USART — USART_HyperTerminal_IndefiniteLengthData_IT

固件库: PY32F0xx_Firmware V1.5.0
芯片: PUYA
源文件: PUYA/PY32F0xx_Firmware_V1.5.0/Projects/PY32F030-STK/Example/USART/USART_HyperTerminal_IndefiniteLengthData_IT/Src/main.c

功能简介

本示例演示 USART 串口通信。串口是最基本的通信接口，几乎每个嵌入式项目都会用到。

硬件准备

USB 转串口模块（如 CH340、CP2102）
连接：开发板 TX → 模块 RX，开发板 RX → 模块 TX，共地
电脑端打开串口助手（如 SSCOM、XCOM），波特率与代码一致

完整代码

#include "main.h"

int main(void)
{
  /* Reset of all peripherals, Initializes the Systick */
  HAL_Init();
  
  /* Configure LED */
  BSP_LED_Init(LED_GREEN);
  
  /* Initialize USART */
  UartHandle.Instance          = USART2;
  UartHandle.Init.BaudRate     = 115200;
  UartHandle.Init.WordLength   = UART_WORDLENGTH_8B;
  UartHandle.Init.StopBits     = UART_STOPBITS_1;
  UartHandle.Init.Parity       = UART_PARITY_NONE;
  UartHandle.Init.HwFlowCtl    = UART_HWCONTROL_NONE;
  UartHandle.Init.Mode         = UART_MODE_TX_RX;
  UartHandle.Init.OverSampling = UART_OVERSAMPLING_16;
  UartHandle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
  HAL_UART_Init(&UartHandle);

  /* Enable RXNE interrupt */
  __HAL_UART_ENABLE_IT(&UartHandle, UART_IT_RXNE);

  /* Infinite loop */
  while (1)
  {
  }
}

代码讲解

板级初始化：初始化开发板上的 LED、按键等基础外设。

实验现象

串口助手收到开发板发送的数据
发送数据后开发板原样返回（回显）

注意事项

串口助手波特率必须与代码一致
检查 TX/RX 是否交叉连接
共地是必须的

PUYA USART — USART_HyperTerminal_IndefiniteLengthData_IT

Tue, 08 Sep 2026 14:52:21 +0800

USART — USART_HyperTerminal_IndefiniteLengthData_IT

固件库: PY32L020_Firmware V1.2.1
芯片: PUYA
源文件: PUYA/PY32L020_Firmware_V1.2.1/Projects/PY32L020-STK/Example/USART/USART_HyperTerminal_IndefiniteLengthData_IT/Src/main.c

功能简介

本示例演示 USART 串口通信。串口是最基本的通信接口，几乎每个嵌入式项目都会用到。

硬件准备

USB 转串口模块（如 CH340、CP2102）
连接：开发板 TX → 模块 RX，开发板 RX → 模块 TX，共地
电脑端打开串口助手（如 SSCOM、XCOM），波特率与代码一致

完整代码

#include "main.h"

int main(void)
{
  /* Reset of all peripherals, Initializes the Systick */
  HAL_Init();
  
  /* Configure LED */
  BSP_LED_Init(LED_GREEN);
  
  /* Initialize USART */
  UartHandle.Instance          = USART1;
  UartHandle.Init.BaudRate     = 115200;
  UartHandle.Init.WordLength   = UART_WORDLENGTH_8B;
  UartHandle.Init.StopBits     = UART_STOPBITS_1;
  UartHandle.Init.Parity       = UART_PARITY_NONE;
  UartHandle.Init.HwFlowCtl    = UART_HWCONTROL_NONE;
  UartHandle.Init.Mode         = UART_MODE_TX_RX;
  UartHandle.Init.OverSampling = UART_OVERSAMPLING_16;
  UartHandle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
  HAL_UART_Init(&UartHandle);

  /* Enable RXNE interrupt */
  __HAL_UART_ENABLE_IT(&UartHandle, UART_IT_RXNE);

  while (1)
  {

  }
}

代码讲解

板级初始化：初始化开发板上的 LED、按键等基础外设。

实验现象

串口助手收到开发板发送的数据
发送数据后开发板原样返回（回显）

注意事项

串口助手波特率必须与代码一致
检查 TX/RX 是否交叉连接
共地是必须的

PUYA USART — USART_HyperTerminal_IT

Tue, 08 Sep 2026 14:52:21 +0800

USART — USART_HyperTerminal_IT

固件库: PY32F002B_Firmware V1.2.1
芯片: PUYA
源文件: PUYA/PY32F002B_Firmware_V1.2.1/Projects/PY32F002B-STK/Example/USART/USART_HyperTerminal_IT/Src/main.c

功能简介

本示例演示 USART 串口通信。串口是最基本的通信接口，几乎每个嵌入式项目都会用到。

硬件准备

USB 转串口模块（如 CH340、CP2102）
连接：开发板 TX → 模块 RX，开发板 RX → 模块 TX，共地
电脑端打开串口助手（如 SSCOM、XCOM），波特率与代码一致

完整代码

#include "main.h"
#define COUNTOF(__BUFFER__)   (sizeof(__BUFFER__) / sizeof(*(__BUFFER__)))
#define TXSTARTMESSAGESIZE    (COUNTOF(aTxStartMessage) - 1)
#define TXENDMESSAGESIZE      (COUNTOF(aTxEndMessage) - 1)

int main(void)
{
  /* Reset of all peripherals, Initializes the Systick. */
  HAL_Init();
  
  /* Configure LED */
  BSP_LED_Init(LED_GREEN);
  
  /* USART initialization */
  UartHandle.Instance          = USART1;
  UartHandle.Init.BaudRate     = 115200;
  UartHandle.Init.WordLength   = UART_WORDLENGTH_8B;
  UartHandle.Init.StopBits     = UART_STOPBITS_1;
  UartHandle.Init.Parity       = UART_PARITY_NONE;
  UartHandle.Init.HwFlowCtl    = UART_HWCONTROL_NONE;
  UartHandle.Init.Mode         = UART_MODE_TX_RX;
  UartHandle.Init.OverSampling = UART_OVERSAMPLING_16;
  UartHandle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
  HAL_UART_Init(&UartHandle);
  
  /* Start the transmission process */
  if(HAL_UART_Transmit_IT(&UartHandle, (uint8_t*)aTxStartMessage, TXSTARTMESSAGESIZE)!= HAL_OK)
  {
    /* Transfer error in transmission process */
    APP_ErrorHandler();
  }

  /* Put UART peripheral in reception process */
  if(HAL_UART_Receive_IT(&UartHandle, (uint8_t *)aRxBuffer, 12) != HAL_OK)
  {
    /* Transfer error in reception process */
    APP_ErrorHandler();
  }

  /* Wait for the end of the transfer */
  while (HAL_UART_GetState(&UartHandle) != HAL_UART_STATE_READY)
  {
  }

  /* Send the received Buffer */
  if(HAL_UART_Transmit_IT(&UartHandle, (uint8_t*)aRxBuffer, 12)!= HAL_OK)
  {
    /* Transfer error in transmission process */
    APP_ErrorHandler();
  }

  /* Wait for the end of the transfer */
  while (HAL_UART_GetState(&UartHandle) != HAL_UART_STATE_READY)
  {
  }

  /* Send the End Message */
  if(HAL_UART_Transmit_IT(&UartHandle, (uint8_t*)aTxEndMessage, TXENDMESSAGESIZE)!= HAL_OK)
  {
    /* Transfer error in transmission process */
    APP_ErrorHandler();
  }

  /* Wait for the end of the transfer */
  while (HAL_UART_GetState(&UartHandle) != HAL_UART_STATE_READY)
  {
  }
  
  /* Turn on LED if test passes then enter infinite loop */
  BSP_LED_On(LED_GREEN);
  
  /* Infinite loop */
  while (1)
  {

  }
}

代码讲解

板级初始化：初始化开发板上的 LED、按键等基础外设。

实验现象

串口助手收到开发板发送的数据
发送数据后开发板原样返回（回显）

注意事项

串口助手波特率必须与代码一致
检查 TX/RX 是否交叉连接
共地是必须的

PUYA USART — USART_HyperTerminal_IT

Tue, 08 Sep 2026 14:52:21 +0800

USART — USART_HyperTerminal_IT

固件库: PY32F0xx_Firmware V1.5.0
芯片: PUYA
源文件: PUYA/PY32F0xx_Firmware_V1.5.0/Projects/PY32F030-STK/Example/USART/USART_HyperTerminal_IT/Src/main.c

功能简介

本示例演示 USART 串口通信。串口是最基本的通信接口，几乎每个嵌入式项目都会用到。

硬件准备

USB 转串口模块（如 CH340、CP2102）
连接：开发板 TX → 模块 RX，开发板 RX → 模块 TX，共地
电脑端打开串口助手（如 SSCOM、XCOM），波特率与代码一致

完整代码

#include "main.h"
#define COUNTOF(__BUFFER__)   (sizeof(__BUFFER__) / sizeof(*(__BUFFER__)))
#define TXSTARTMESSAGESIZE    (COUNTOF(aTxStartMessage) - 1)
#define TXENDMESSAGESIZE      (COUNTOF(aTxEndMessage) - 1)

int main(void)
{
  /* Reset of all peripherals, Initializes the Systick */
  HAL_Init();
  
  /* Configure LED */
  BSP_LED_Init(LED_GREEN);
  
  /* Initialize USART */
  UartHandle.Instance          = USART2;
  UartHandle.Init.BaudRate     = 115200;
  UartHandle.Init.WordLength   = UART_WORDLENGTH_8B;
  UartHandle.Init.StopBits     = UART_STOPBITS_1;
  UartHandle.Init.Parity       = UART_PARITY_NONE;
  UartHandle.Init.HwFlowCtl    = UART_HWCONTROL_NONE;
  UartHandle.Init.Mode         = UART_MODE_TX_RX;
  UartHandle.Init.OverSampling = UART_OVERSAMPLING_16;
  UartHandle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
  HAL_UART_Init(&UartHandle);

  /* Start the transmission process */
  if(HAL_UART_Transmit_IT(&UartHandle, (uint8_t*)aTxStartMessage, TXSTARTMESSAGESIZE)!= HAL_OK)
  {
    /* Transfer error in transmission process */
    APP_ErrorHandler();
  }

  /* Put UART peripheral in reception process */
  if(HAL_UART_Receive_IT(&UartHandle, (uint8_t *)aRxBuffer, 12) != HAL_OK)
  {
    /* Transfer error in reception process */
    APP_ErrorHandler();
  }

  /* Wait for the end of the transfer */
  while (HAL_UART_GetState(&UartHandle) != HAL_UART_STATE_READY)
  {
  }

  /* Send the received Buffer */
  if(HAL_UART_Transmit_IT(&UartHandle, (uint8_t*)aRxBuffer, 12)!= HAL_OK)
  {
    /* Transfer error in transmission process */
    APP_ErrorHandler();
  }

  /* Wait for the end of the transfer */
  while (HAL_UART_GetState(&UartHandle) != HAL_UART_STATE_READY)
  {
  }

  /* Send the End Message */
  if(HAL_UART_Transmit_IT(&UartHandle, (uint8_t*)aTxEndMessage, TXENDMESSAGESIZE)!= HAL_OK)
  {
    /* Transfer error in transmission process */
    APP_ErrorHandler();
  }

  /* Wait for the end of the transfer */
  while (HAL_UART_GetState(&UartHandle) != HAL_UART_STATE_READY)
  {
  }

  /* Turn on LED if test passes then enter infinite loop */
  BSP_LED_On(LED_GREEN);

  /* Infinite loop */
  while (1)
  {
  }
}

代码讲解

板级初始化：初始化开发板上的 LED、按键等基础外设。

实验现象

串口助手收到开发板发送的数据
发送数据后开发板原样返回（回显）

注意事项

串口助手波特率必须与代码一致
检查 TX/RX 是否交叉连接
共地是必须的

PUYA USART — USART_HyperTerminal_IT

Tue, 08 Sep 2026 14:52:21 +0800

USART — USART_HyperTerminal_IT

固件库: PY32F403_Firmware V1.4.5
芯片: PUYA
源文件: PUYA/PY32F403_Firmware_V1.4.5/Projects/PY32F403-STK/Example/USART/USART_HyperTerminal_IT/Src/main.c

功能简介

本示例演示 USART 串口通信。串口是最基本的通信接口，几乎每个嵌入式项目都会用到。

硬件准备

USB 转串口模块（如 CH340、CP2102）
连接：开发板 TX → 模块 RX，开发板 RX → 模块 TX，共地
电脑端打开串口助手（如 SSCOM、XCOM），波特率与代码一致

完整代码

#include "main.h"
#define COUNTOF(__BUFFER__)   (sizeof(__BUFFER__) / sizeof(*(__BUFFER__)))
#define TXSTARTMESSAGESIZE    (COUNTOF(aTxStartMessage) - 1)
#define TXENDMESSAGESIZE      (COUNTOF(aTxEndMessage) - 1)

代码讲解

代码结构清晰，主要包含外设初始化配置和主循环中的功能逻辑。请结合注释理解每一步的含义。

实验现象

串口助手收到开发板发送的数据
发送数据后开发板原样返回（回显）

注意事项

串口助手波特率必须与代码一致
检查 TX/RX 是否交叉连接
共地是必须的

PUYA USART — USART_HyperTerminal_IT

Tue, 08 Sep 2026 14:52:21 +0800

USART — USART_HyperTerminal_IT

固件库: PY32L020_Firmware V1.2.1
芯片: PUYA
源文件: PUYA/PY32L020_Firmware_V1.2.1/Projects/PY32L020-STK/Example/USART/USART_HyperTerminal_IT/Src/main.c

功能简介

本示例演示 USART 串口通信。串口是最基本的通信接口，几乎每个嵌入式项目都会用到。

硬件准备

USB 转串口模块（如 CH340、CP2102）
连接：开发板 TX → 模块 RX，开发板 RX → 模块 TX，共地
电脑端打开串口助手（如 SSCOM、XCOM），波特率与代码一致

完整代码

#include "main.h"
#define COUNTOF(__BUFFER__)   (sizeof(__BUFFER__) / sizeof(*(__BUFFER__)))
#define TXSTARTMESSAGESIZE    (COUNTOF(aTxStartMessage) - 1)
#define TXENDMESSAGESIZE      (COUNTOF(aTxEndMessage) - 1)

int main(void)
{
  /* Reset of all peripherals, Initializes the Systick. */
  HAL_Init();
  
  /* Configure LED */
  BSP_LED_Init(LED_GREEN);
  
  /* USART initialization */
  UartHandle.Instance          = USART1;
  UartHandle.Init.BaudRate     = 115200;
  UartHandle.Init.WordLength   = UART_WORDLENGTH_8B;
  UartHandle.Init.StopBits     = UART_STOPBITS_1;
  UartHandle.Init.Parity       = UART_PARITY_NONE;
  UartHandle.Init.HwFlowCtl    = UART_HWCONTROL_NONE;
  UartHandle.Init.Mode         = UART_MODE_TX_RX;
  UartHandle.Init.OverSampling = UART_OVERSAMPLING_16;
  UartHandle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
  HAL_UART_Init(&UartHandle);
  
  /* Start the transmission process */
  if(HAL_UART_Transmit_IT(&UartHandle, (uint8_t*)aTxStartMessage, TXSTARTMESSAGESIZE)!= HAL_OK)
  {
    /* Transfer error in transmission process */
    APP_ErrorHandler();
  }

  /* Put UART peripheral in reception process */
  if(HAL_UART_Receive_IT(&UartHandle, (uint8_t *)aRxBuffer, 12) != HAL_OK)
  {
    /* Transfer error in reception process */
    APP_ErrorHandler();
  }

  /* Wait for the end of the transfer */
  while (HAL_UART_GetState(&UartHandle) != HAL_UART_STATE_READY)
  {
  }

  /* Send the received Buffer */
  if(HAL_UART_Transmit_IT(&UartHandle, (uint8_t*)aRxBuffer, 12)!= HAL_OK)
  {
    /* Transfer error in transmission process */
    APP_ErrorHandler();
  }

  /* Wait for the end of the transfer */
  while (HAL_UART_GetState(&UartHandle) != HAL_UART_STATE_READY)
  {
  }

  /* Send the End Message */
  if(HAL_UART_Transmit_IT(&UartHandle, (uint8_t*)aTxEndMessage, TXENDMESSAGESIZE)!= HAL_OK)
  {
    /* Transfer error in transmission process */
    APP_ErrorHandler();
  }

  /* Wait for the end of the transfer */
  while (HAL_UART_GetState(&UartHandle) != HAL_UART_STATE_READY)
  {
  }
  
  /* Turn on LED if test passes then enter infinite loop */
  BSP_LED_On(LED_GREEN);
  
  /* Infinite loop */
  while (1)
  {

  }
}

代码讲解

板级初始化：初始化开发板上的 LED、按键等基础外设。

实验现象

串口助手收到开发板发送的数据
发送数据后开发板原样返回（回显）

注意事项

串口助手波特率必须与代码一致
检查 TX/RX 是否交叉连接
共地是必须的

PUYA USART — USART_HyperTerminal_Polling

Tue, 08 Sep 2026 14:52:21 +0800

USART — USART_HyperTerminal_Polling

固件库: PY32F002B_Firmware V1.2.1
芯片: PUYA
源文件: PUYA/PY32F002B_Firmware_V1.2.1/Projects/PY32F002B-STK/Example/USART/USART_HyperTerminal_Polling/Src/main.c

功能简介

本示例演示串口轮询收发。CPU 不断检查标志位来判断是否收到数据或是否可以发送。简单直接，但会占用 CPU 时间。

硬件准备

USB 转串口模块（如 CH340、CP2102）
连接：开发板 TX → 模块 RX，开发板 RX → 模块 TX，共地
电脑端打开串口助手（如 SSCOM、XCOM），波特率与代码一致

完整代码

#include "main.h"
#define COUNTOF(__BUFFER__)   (sizeof(__BUFFER__) / sizeof(*(__BUFFER__)))
#define TXSTARTMESSAGESIZE    (COUNTOF(aTxStartMessage) - 1)
#define TXENDMESSAGESIZE      (COUNTOF(aTxEndMessage) - 1)

int main(void)
{
  /* Reset of all peripherals, Initializes the Systick. */
  HAL_Init();
  
  /* Configure LED */
  BSP_LED_Init(LED_GREEN);
  
  /* USART initialization */
  UartHandle.Instance          = USART1;
  UartHandle.Init.BaudRate     = 115200;
  UartHandle.Init.WordLength   = UART_WORDLENGTH_8B;
  UartHandle.Init.StopBits     = UART_STOPBITS_1;
  UartHandle.Init.Parity       = UART_PARITY_NONE;
  UartHandle.Init.HwFlowCtl    = UART_HWCONTROL_NONE;
  UartHandle.Init.Mode         = UART_MODE_TX_RX;
  UartHandle.Init.OverSampling = UART_OVERSAMPLING_16;
  UartHandle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
  HAL_UART_Init(&UartHandle);

  /* Start the transmission process */
  if(HAL_UART_Transmit(&UartHandle, (uint8_t*)aTxStartMessage, TXSTARTMESSAGESIZE, 5000)!= HAL_OK)
  {
    /* Transfer error in transmission process */
    APP_ErrorHandler();
  }

  /* Put UART peripheral in reception process */
  if(HAL_UART_Receive(&UartHandle, (uint8_t *)aRxBuffer, 12, 5000) != HAL_OK)
  {
    /* Transfer error in reception process */
    APP_ErrorHandler();
  }

  /* Send the received Buffer */
  if(HAL_UART_Transmit(&UartHandle, (uint8_t*)aRxBuffer, 12, 5000)!= HAL_OK)
  {
    /* Transfer error in transmission process */
    APP_ErrorHandler();
  }

  /* Send the End Message */
  if(HAL_UART_Transmit(&UartHandle, (uint8_t*)aTxEndMessage, TXENDMESSAGESIZE, 5000)!= HAL_OK)
  {
    /* Transfer error in transmission process */
    APP_ErrorHandler();
  }

  /* Turn on LED if test passes then enter infinite loop */
  BSP_LED_On(LED_GREEN);
  
  /* Infinite loop */
  while (1)
  {

  }
}

代码讲解

板级初始化：初始化开发板上的 LED、按键等基础外设。

实验现象

串口助手收到开发板发送的数据
发送数据后开发板原样返回（回显）

注意事项

串口助手波特率必须与代码一致
检查 TX/RX 是否交叉连接
共地是必须的

PUYA USART — USART_HyperTerminal_Polling

Tue, 08 Sep 2026 14:52:21 +0800

USART — USART_HyperTerminal_Polling

固件库: PY32F403_Firmware V1.4.5
芯片: PUYA
源文件: PUYA/PY32F403_Firmware_V1.4.5/Projects/PY32F403-STK/Example/USART/USART_HyperTerminal_Polling/Src/main.c

功能简介

本示例演示串口轮询收发。CPU 不断检查标志位来判断是否收到数据或是否可以发送。简单直接，但会占用 CPU 时间。

硬件准备

USB 转串口模块（如 CH340、CP2102）
连接：开发板 TX → 模块 RX，开发板 RX → 模块 TX，共地
电脑端打开串口助手（如 SSCOM、XCOM），波特率与代码一致

完整代码

#include "main.h"
#define COUNTOF(__BUFFER__)   (sizeof(__BUFFER__) / sizeof(*(__BUFFER__)))
#define TXSTARTMESSAGESIZE    (COUNTOF(aTxStartMessage) - 1)
#define TXENDMESSAGESIZE      (COUNTOF(aTxEndMessage) - 1)

代码讲解

代码结构清晰，主要包含外设初始化配置和主循环中的功能逻辑。请结合注释理解每一步的含义。

实验现象

串口助手收到开发板发送的数据
发送数据后开发板原样返回（回显）

注意事项

串口助手波特率必须与代码一致
检查 TX/RX 是否交叉连接
共地是必须的

PUYA USART — USART_HyperTerminal_Polling

Tue, 08 Sep 2026 14:52:21 +0800

USART — USART_HyperTerminal_Polling

固件库: PY32L020_Firmware V1.2.1
芯片: PUYA
源文件: PUYA/PY32L020_Firmware_V1.2.1/Projects/PY32L020-STK/Example/USART/USART_HyperTerminal_Polling/Src/main.c

功能简介

本示例演示串口轮询收发。CPU 不断检查标志位来判断是否收到数据或是否可以发送。简单直接，但会占用 CPU 时间。

硬件准备

USB 转串口模块（如 CH340、CP2102）
连接：开发板 TX → 模块 RX，开发板 RX → 模块 TX，共地
电脑端打开串口助手（如 SSCOM、XCOM），波特率与代码一致

完整代码

#include "main.h"
#define COUNTOF(__BUFFER__)   (sizeof(__BUFFER__) / sizeof(*(__BUFFER__)))
#define TXSTARTMESSAGESIZE    (COUNTOF(aTxStartMessage) - 1)
#define TXENDMESSAGESIZE      (COUNTOF(aTxEndMessage) - 1)

int main(void)
{
  /* Reset of all peripherals, Initializes the Systick. */
  HAL_Init();
  
  /* Configure LED */
  BSP_LED_Init(LED_GREEN);
  
  /* USART initialization */
  UartHandle.Instance          = USART1;
  UartHandle.Init.BaudRate     = 115200;
  UartHandle.Init.WordLength   = UART_WORDLENGTH_8B;
  UartHandle.Init.StopBits     = UART_STOPBITS_1;
  UartHandle.Init.Parity       = UART_PARITY_NONE;
  UartHandle.Init.HwFlowCtl    = UART_HWCONTROL_NONE;
  UartHandle.Init.Mode         = UART_MODE_TX_RX;
  UartHandle.Init.OverSampling = UART_OVERSAMPLING_16;
  UartHandle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
  HAL_UART_Init(&UartHandle);

  /* Start the transmission process */
  if(HAL_UART_Transmit(&UartHandle, (uint8_t*)aTxStartMessage, TXSTARTMESSAGESIZE, 5000)!= HAL_OK)
  {
    /* Transfer error in transmission process */
    APP_ErrorHandler();
  }

  /* Put UART peripheral in reception process */
  if(HAL_UART_Receive(&UartHandle, (uint8_t *)aRxBuffer, 12, 5000) != HAL_OK)
  {
    /* Transfer error in reception process */
    APP_ErrorHandler();
  }

  /* Send the received Buffer */
  if(HAL_UART_Transmit(&UartHandle, (uint8_t*)aRxBuffer, 12, 5000)!= HAL_OK)
  {
    /* Transfer error in transmission process */
    APP_ErrorHandler();
  }

  /* Send the End Message */
  if(HAL_UART_Transmit(&UartHandle, (uint8_t*)aTxEndMessage, TXENDMESSAGESIZE, 5000)!= HAL_OK)
  {
    /* Transfer error in transmission process */
    APP_ErrorHandler();
  }

  /* Turn on LED if test passes then enter infinite loop */
  BSP_LED_On(LED_GREEN);
  
  /* Infinite loop */
  while (1)
  {

  }
}

代码讲解

板级初始化：初始化开发板上的 LED、按键等基础外设。

实验现象

串口助手收到开发板发送的数据
发送数据后开发板原样返回（回显）

注意事项

串口助手波特率必须与代码一致
检查 TX/RX 是否交叉连接
共地是必须的

PUYA USART — 串口轮询收发（LL 库）

Tue, 08 Sep 2026 14:52:21 +0800

USART — 串口轮询收发（LL 库）

HAL vs LL：PUYA 固件库提供 HAL 和 LL 两套 API。

HAL 库：封装度高，可移植性强，适合快速开发

LL 库：接近寄存器操作，代码精简效率高，适合性能敏感场景本文使用 LL 库版本。

固件库: PY32F0xx_Firmware V1.5.0
芯片: PY32F030（PY32F002A / F003 同库可参考）
源文件: PUYA/PY32F0xx_Firmware_V1.5.0/Projects/PY32F030-STK/Example_LL/USART/USART_HyperTerminal_Polling_Init/Src/main.c

功能简介

本示例实现串口“超级终端”式的轮询（Polling）通信：上电后先向电脑发送一段欢迎语，再接收你从键盘敲入的 12 个字符，原样回传，最后点亮 LED 表示测试通过。

与 HAL 版（用 HAL_UART_Transmit / HAL_UART_Receive 一行搞定）不同，LL 版没有封装好的“发 N 字节”函数，需要你自己用 LL_USART_TransmitData8() 逐字节发送，并用 LL_USART_IsActiveFlag_TXE() / LL_USART_IsActiveFlag_RXNE() 轮询标志位。这正是 LL 的典型特征：给你最底层的积木，组合方式由你决定。

硬件准备

PY32F030 开发板
USB 转串口线（或板载 ST-Link VCP），连接到 USART1 的 TX(PA2) / RX(PA3)
电脑端串口助手（如 PuTTY、串口调试助手），波特率 9600 / 8N1
板载绿 LED（用于测试通过指示）

完整代码

#include "main.h"
#include "py32f030xx_ll_Start_Kit.h"

#define COUNTOF(__BUFFER__)   (sizeof(__BUFFER__) / sizeof(*(__BUFFER__)))
#define TXSTARTMESSAGESIZE    (COUNTOF(aTxStartMessage) - 1)
#define TXENDMESSAGESIZE      (COUNTOF(aTxEndMessage) - 1)

uint8_t aRxBuffer[12] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
uint8_t aTxStartMessage[] = "\n\r USART Hyperterminal communication based on polling \n\r Enter 12 characters using keyboard :\n\r";
uint8_t aTxEndMessage[] = "\n\r Example Finished\n\r";

uint8_t *TxBuff = NULL;
__IO uint16_t TxCount = 0;
uint8_t *RxBuff = NULL;
__IO uint16_t RxCount = 0;

static void APP_SystemClockConfig(void);
static void APP_ConfigUsart(USART_TypeDef *USARTx);
static void APP_UsartTransmit(USART_TypeDef *USARTx, uint8_t *pData, uint16_t Size);
static void APP_UsartReceive(USART_TypeDef *USARTx, uint8_t *pData, uint16_t Size);

int main(void)
{
  APP_SystemClockConfig();

  BSP_LED_Init(LED_GREEN);          /* 初始化 LED，用于测试通过指示 */

  APP_ConfigUsart(USART1);          /* 配置 USART1：PA2/PA3，9600-8N1 */

  /* 发送欢迎语 */
  APP_UsartTransmit(USART1, (uint8_t*)aTxStartMessage, TXSTARTMESSAGESIZE);
  /* 接收 12 字节 */
  APP_UsartReceive(USART1, (uint8_t *)aRxBuffer, 12);
  /* 回传接收到的数据 */
  APP_UsartTransmit(USART1, (uint8_t*)aRxBuffer, 12);
  /* 发送结束语 */
  APP_UsartTransmit(USART1, (uint8_t*)aTxEndMessage, TXENDMESSAGESIZE);

  BSP_LED_On(LED_GREEN);            /* 测试通过，亮灯 */
  while (1) {}
}

/**
  * @brief  系统时钟配置（LL 版，手动配 HSI + 时基）
  */
static void APP_SystemClockConfig(void)
{
  LL_RCC_HSI_Enable();
  while (LL_RCC_HSI_IsReady() != 1) {}
  LL_RCC_SetAHBPrescaler(LL_RCC_SYSCLK_DIV_1);
  LL_RCC_SetSysClkSource(LL_RCC_SYS_CLKSOURCE_HSISYS);
  while (LL_RCC_GetSysClkSource() != LL_RCC_SYS_CLKSOURCE_STATUS_HSISYS) {}
  LL_RCC_SetAPB1Prescaler(LL_RCC_APB1_DIV_1);
  LL_Init1msTick(8000000);
  LL_SetSystemCoreClock(8000000);
}

/**
  * @brief  USART 配置：GPIO 复用 + 波特率等参数
  */
static void APP_ConfigUsart(USART_TypeDef *USARTx)
{
  if (USARTx == USART1)
  {
    LL_IOP_GRP1_EnableClock(LL_IOP_GRP1_PERIPH_GPIOA);          /* 开 GPIOA 时钟 */
    LL_APB1_GRP2_EnableClock(LL_APB1_GRP2_PERIPH_USART1);       /* 开 USART1 时钟 */

    LL_GPIO_InitTypeDef GPIO_InitStruct = {0};
    GPIO_InitStruct.Pin        = LL_GPIO_PIN_2;                 /* PA2 = TX */
    GPIO_InitStruct.Mode       = LL_GPIO_MODE_ALTERNATE;        /* 复用功能 */
    GPIO_InitStruct.Speed      = LL_GPIO_SPEED_FREQ_VERY_HIGH;
    GPIO_InitStruct.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
    GPIO_InitStruct.Pull       = LL_GPIO_PULL_UP;
    GPIO_InitStruct.Alternate  = LL_GPIO_AF1_USART1;            /* 复用为 USART1 */
    LL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    GPIO_InitStruct.Pin = LL_GPIO_PIN_3;                       /* PA3 = RX */
    LL_GPIO_Init(GPIOA, &GPIO_InitStruct);
  }
  /* 若用 USART2，结构类似，复用 AF4，此处略 */

  /* USART 参数 */
  LL_USART_InitTypeDef USART_InitStruct = {0};
  USART_InitStruct.BaudRate            = 9600;
  USART_InitStruct.DataWidth           = LL_USART_DATAWIDTH_8B;
  USART_InitStruct.StopBits            = LL_USART_STOPBITS_1;
  USART_InitStruct.Parity              = LL_USART_PARITY_NONE;
  USART_InitStruct.TransferDirection   = LL_USART_DIRECTION_TX_RX;
  USART_InitStruct.HardwareFlowControl = LL_USART_HWCONTROL_NONE;
  USART_InitStruct.OverSampling        = LL_USART_OVERSAMPLING_16;
  LL_USART_Init(USARTx, &USART_InitStruct);

  LL_USART_ConfigAsyncMode(USARTx);     /* 配置为全双工异步模式 */
  LL_USART_Enable(USARTx);              /* 使能 USART 模块 */
}

/**
  * @brief  LL 轮询发送：逐字节等待 TXE 后写入
  */
static void APP_UsartTransmit(USART_TypeDef *USARTx, uint8_t *pData, uint16_t Size)
{
  TxBuff  = pData;
  TxCount = Size;
  while (TxCount > 0)
  {
    while (LL_USART_IsActiveFlag_TXE(USARTx) != 1);   /* 等待发送数据寄存器空 */
    LL_USART_TransmitData8(USARTx, *TxBuff);          /* 写入一个字节 */
    TxBuff++;
    TxCount--;
  }
  while (LL_USART_IsActiveFlag_TC(USARTx) != 1);      /* 等待发送完成 */
}

/**
  * @brief  LL 轮询接收：逐字节等待 RXNE 后读取
  */
static void APP_UsartReceive(USART_TypeDef *USARTx, uint8_t *pData, uint16_t Size)
{
  RxBuff  = pData;
  RxCount = Size;
  while (RxCount > 0)
  {
    while (LL_USART_IsActiveFlag_RXNE(USARTx) != 1);  /* 等待接收数据寄存器非空 */
    *RxBuff = LL_USART_ReceiveData8(USARTx);          /* 读出一个字节 */
    RxBuff++;
    RxCount--;
  }
}

void APP_ErrorHandler(void)
{
  while (1) {}
}

代码分段讲解

1. 时钟与 GPIO 复用

LL 里 GPIO 和 USART 的时钟分属不同的“组”：GPIO 在 LL_IOP_GRP1，USART1 在 LL_APB1_GRP2。这和 HAL 的 __HAL_RCC_xxx_CLK_ENABLE() 宏对应，但名字更直白地反映了总线分组。PA2/PA3 要设为 LL_GPIO_MODE_ALTERNATE 并指定 Alternate = LL_GPIO_AF1_USART1，才能把引脚接到 USART1。

2. 参数配置：结构体 + Init

LL 的 LL_USART_Init() 同样接收结构体，这一点和 HAL 的 UART_InitTypeDef 很像——LL 并不是完全不用结构体，而是把“一次性参数”用结构体批量写入，把“运行时动作”拆成独立函数。

3. 发送：手动轮询 TXE

HAL 一句 HAL_UART_Transmit() 内部帮你做了“等待 TXE→写 DR→等待 TC”的循环；LL 把这段循环直接暴露给你：

1
2

while (LL_USART_IsActiveFlag_TXE(USARTx) != 1);  /* 等空 */
LL_USART_TransmitData8(USARTx, byte);            /* 写一字节 */

好处是你可以精确控制发送节奏、插入其它操作，甚至做“发送一半去干别的事”这类 HAL 难以表达的逻辑。

4. 接收：手动轮询 RXNE

同理，接收就是等 RXNE（接收寄存器非空）后 LL_USART_ReceiveData8() 读一个字节。注意 LL 没有“超时”概念，若对方不发数据，这里的 while 会永远等下去——真实项目务必加超时或改用中断/DMA。

实验现象

打开串口助手（9600 / 8N1），复位开发板。
先收到欢迎语：USART Hyperterminal communication based on polling ... Enter 12 characters ...。
在串口助手输入恰好 12 个字符并发送，开发板原样回传这 12 个字符。
最后收到 Example Finished，板载绿 LED 点亮，表示流程成功。

常见问题

串口助手收不到任何字符？
- 确认 TX/RX 交叉连接（板子 TX 接 USB 转串口的 RX）。
- 确认波特率 9600、8 位数据、1 停止位、无校验、无流控，与代码一致。
- 确认 APP_SystemClockConfig() 里系统时钟确实是 8MHz（LL_Init1msTick(8000000)），否则波特率实际值会偏离。
输入不足 12 字符程序就“卡住”？
- LL 轮询接收没有超时，必须收满 12 字节才继续。这是示例故意为之；真实项目建议加超时或改用中断。
想重定向 printf？
- LL 版需要自己实现 _write() / fputc() 并在里面调用 LL_USART_TransmitData8()；HAL 版则常配合 HAL_UART_Transmit 做重定向（参见 HAL 版文档）。

小结

LL 串口收发 = 结构体配参数 + 独立函数做动作 + 手动轮询标志位。
相比 HAL_UART_Transmit/Receive，LL 代码更长，但每一步都看得见、改得动，没有隐藏的超时/状态机。
性能敏感或资源紧张时，LL 能省下 HAL 那一层封装开销。

拓展应用

给轮询接收加超时计数，避免“永远等待”。
改用 LL_USART_EnableIT_RXNE() + 中断回调函数，实现不阻塞的串口接收（参考 USART_HyperTerminal_IT_Init）。
用 DMA 搬运大量数据（参考 USART_HyperTerminal_DMA_Init），CPU 几乎零参与。
把发送函数封装成 printf 风格的可变参数函数，方便打日志。

USART on CLing

PUYA USART — 串口轮询收发与 printf 重定向（HAL 库）

USART — 串口轮询收发与 printf 重定向（HAL 库）

功能简介

硬件准备

完整代码（官方轮询示例）

printf 重定向（重点）

使用步骤

代码分段讲解

实验现象

常见问题

小结

拓展应用

AT32 USART — printf 重定向到串口（嵌入式调试神器）

USART — printf 重定向到串口

这个实验是干嘛的？

硬件准备

串口助手软件

完整代码

代码逐行讲解

1. 头文件

2. 全局变量

3. 串口初始化

4. printf 输出

5. 延时

printf 重定向的原理（进阶）

常用 printf 格式

实验现象

常见问题

Q: 串口助手收不到数据？

Q: 收到乱码？

Q: 只能用 USART1 吗？

小结

学了串口能做什么？

调试与监控

通信与控制

实际应用场景

AT32 — 串口 (USART)

AT32 — 串口 (USART)

什么是 串口 (USART)?

示例列表

AT32 USART — DMA 轮询收发

USART — DMA 轮询收发

功能简介

硬件准备

完整代码

代码讲解

实验现象

注意事项

AT32 USART — DMA 中断收发

USART — DMA 中断收发

功能简介

硬件准备

完整代码

代码讲解

实验现象

注意事项

AT32 USART — RS485 通信

USART — RS485 通信

功能简介

硬件准备

完整代码

代码讲解

实验现象

注意事项

AT32 USART — 半双工通信

USART — 半双工通信

功能简介

硬件准备

完整代码

代码讲解

实验现象

注意事项

AT32 USART — 红外 IrDA 模式

USART — 红外 IrDA 模式

功能简介

硬件准备

完整代码

代码讲解

实验现象

什么是串口 (USART)?