GD32 on CLing

兆易创新 (GigaDevice) GD32 MCU 示例代码库

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

GD32 MCU 示例代码库

厂商: 兆易创新 (GigaDevice)
芯片: GD32F103C8T6、GD32F303

兆易创新 GD32 系列国产 MCU，Pin-to-Pin 兼容 STM32。GD32F103 基于 Cortex-M3，GD32F30x 基于 Cortex-M4。

固件库版本一览

固件库名称	版本	芯片
GD32F30x_Firmware_Library	V3.0.3	GD32F103C8T6, GD32F303
drg_gd32f103c8t6	DRG GD-1	GD32F103C8T6, GD32F303

目录导航

左侧导航按外设模块分类，每个模块下列出所有子示例。每个示例包含功能说明、关键配置代码、源文件路径。

GD32 — BKP

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

GD32 — BKP

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

示例列表

备份数据读写 — Backup_data
入侵检测 — Tamper

GD32 — CAN 总线

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

GD32 — CAN 总线

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

什么是 CAN 总线?

CAN 是汽车和工业领域最常用的现场总线。支持多主通信、错误检测和自动重传，抗干扰能力强。

示例列表

多 CAN 通信 — communication_among_CANs
CAN 设备间通信 — communication_among_Devices
CAN 自回环 — communication_Loopback

GD32 — CTC

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

GD32 — CTC

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

示例列表

CTC GPIO 输出 — CTC_gpio
CTC LXTAL 校准 — CTC_lxtal

GD32 — DBG

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

GD32 — DBG

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

示例列表

DBG_timer1_stop — DBG_timer1_stop

GD32 — ENET

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

GD32 — ENET

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

示例列表

以太网 Telnet — Telnet

GD32 — EXMC

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

GD32 — EXMC

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

示例列表

外部 LCD — LCD
NAND Flash — NAND

GD32 — EXTI

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

GD32 — EXTI

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

什么是 EXTI?

外部中断在引脚电平变化时自动触发中断服务函数。按键检测、信号边沿捕获等场景都会用到。

示例列表

按键外部中断 — Key_external_interrupt_mode

GD32 — FWDGT

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

GD32 — FWDGT

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

示例列表

独立看门狗喂狗 — FWDGT_key

GD32 — I2C 串行总线 (I2C)

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

GD32 — I2C 串行总线 (I2C)

固件库: GD32F30x_Firmware_Library V3.0.3
示例数: 14
推荐入门: I2C_EEPROM（EEPROM 读写）

什么是 I2C 总线？

I2C（Inter-Integrated Circuit，常读作 “I-squared-C” 或 “I-two-C”）是飞利浦（现 NXP）提出的一种两线式、半双工、多主多从同步串行总线。它和 SPI 恰好形成对比：

特性	I2C	SPI
信号线	2 根（SCL、SDA）	4 根（SCK、MOSI、MISO、NSS）
拓扑	一主多从，靠地址区分	一主多从，靠片选区分
速度	标准 100K / 快速 400K / 快速+ 1M bps	可达数十 MHz
全/半双工	半双工（同一条数据线收发切换）	全双工
硬件开销	省线，适合多设备	每加一个从机多一根 NSS

一句话记忆：I2C 用最少的线（两根）挂一堆设备，每个设备有地址；SPI 用更多的线换速度。

两根信号线

SCL（Serial Clock）：时钟线，由主机产生。
SDA（Serial Data）：数据线，主从都可以在上面发数据（所以半双工）。

两根线都必须是开漏（Open-Drain）输出 + 外部上拉电阻。这是 I2C 能"多主多从"还能"线与"仲裁的硬件基础——任何设备拉低总线即生效，释放后由上拉电阻拉高。这也是为什么 GPIO 要配成 GPIO_MODE_AF_OD（复用开漏），且板上必须接 4.7kΩ 左右的上拉。

一帧数据的样子

一个典型的 I2C 写操作（以写 EEPROM 为例）：

`1`	`[START] [从机地址+W] [ACK] [寄存器地址] [ACK] [数据1] [ACK] ... [STOP]`

START（起始条件）：SCL 高电平时，SDA 由高变低。
从机地址：7 位地址 + 1 位读写方向位（0=写，1=读），共 8 位。
ACK（应答）：每传完一个字节，接收方在第 9 个时钟把 SDA 拉低表示"收到了"。没拉低就是 NACK。
STOP（停止条件）：SCL 高电平时，SDA 由低变高。

7 位地址 vs 8 位地址的坑：很多新手把 0xA0 当成"地址"。其实 0xA0 是8 位写法（含读写位），真正的 7 位地址是 0xA0 >> 1 = 0x50。库函数 i2c_master_addressing() 会自动帮你拼上读写位，所以你传 0xA0（或 0x50）都行——本例 I2CX_SLAVE_ADDRESS7 直接写成 0xA0，库会处理。入门阶段记住：见到偶数 0xA0 这种"带读写位"的写法，是 I2C 器件的常见俗写，别慌。

GD32F30x 的 I2C 资源

通常有 I2C0 / I2C1 两路。
本例用 I2C0，引脚为 PB6（SCL）/ PB7（SDA），硬件复用（RCU_AF 默认已映射，无需额外 remap）。
速率由 i2c_clock_config() 设定，常用 100000（标准）或 400000（快速）。

常用库函数速查

函数	作用
`i2c_clock_config(I2CX, speed, duty)`	设置速率（如 100000）和占空比
`i2c_mode_addr_config(I2CX, mode, fmt, addr)`	配置主/从模式、地址位数、自身地址
`i2c_enable(I2CX)` / `i2c_ack_config(I2CX, ACK)`	使能 I2C / 开启自动应答
`i2c_start_on_bus(I2CX)`	产生 START 条件
`i2c_master_addressing(I2CX, addr, dir)`	发送从机地址 + 方向（自动拼读写位）
`i2c_data_transmit(I2CX, data)`	发送一个字节
`i2c_data_receive(I2CX)`	读取一个字节
`i2c_stop_on_bus(I2CX)`	产生 STOP 条件
`i2c_flag_get(I2CX, flag)`	查询标志位（SBSEND / ADDSEND / TBE / RBNE / BTC / I2CBSY 等）

几个关键标志位

I2C_FLAG_I2CBSY：总线忙。发 START 前要确认它为 0（空闲）。
I2C_FLAG_SBSEND：起始条件已发出。
I2C_FLAG_ADDSEND：地址已发出且收到从机 ACK（地址匹配成功）。必须读/清这个标志，否则卡死。
I2C_FLAG_TBE：发送数据寄存器空，可以塞下一个字节。
I2C_FLAG_BTC：字节传输完成（一字节发完且 ACK 收到）。本例靠它判断"该发下一个了"。
I2C_FLAG_RBNE：接收数据寄存器非空，可以读走。

为什么 I2C 代码看起来那么"啰嗦"？

和 GPIO/USART 不同，官方 I2C 例程几乎都是状态机 + 超时写法（i2c_process_enum 状态：START → SEND_ADDRESS → CLEAR_ADDRESS_FLAG → TRANSMIT_DATA → STOP）。原因是 I2C 是"带应答的协议"，每一步都要等对方 ACK，且可能因为从机没接好而永久卡住。加上 timeout 计数和 i2c_bus_reset() 复位，就是为了让通信卡死时能自救。入门看 I2C_EEPROM 的 eeprom_byte_write_timeout() 就能理解这套套路。

示例列表

I2C EEPROM 读写 — I2C_EEPROM ★ 入门推荐
I2C EEPROM DMA — I2C_EEPROM_dma
I2C EEPROM 中断 — I2C_EEPROM_interrput
I2C 主机发送 — Master_transmitter
I2C 主机接收 — Master_receiver
I2C 主机接收 1 字节 — Master_receiver_one_byte
I2C 主机接收 2 字节 — Master_receiver_two_bytes
I2C 主发从收 — Master_transmitter&slave_receiver
I2C 主收从发中断 — Master_receiver&slave_transmitter_interrupt
I2C 主发从收 DMA — Master_transmitter&slave_receiver_dma
I2C 主发从收中断 — Master_transmitter&slave_receiver_interrupt
I2C 从机接收 — Slave_receiver
I2C 从机发送 — Slave_transmitter
I2C 快速模式+ 通信 — Fast_mode_plus_communication

学习路径建议

先跑通 I2C_EEPROM，理解"START → 发地址 → 等 ACK → 发寄存器地址 → 发数据 → STOP"这一整套"字节写"流程，以及配套的页写 / 顺序读 / 等待就绪逻辑。
再读 Master_transmitter / Master_receiver 看纯主机收发的最小骨架。
数据量大时升级到 I2C_EEPROM_dma 或 I2C_EEPROM_interrput，把轮询等待替换成 DMA/中断。

下一篇：I2C EEPROM 读写

GD32 — PMU

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

GD32 — PMU

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

示例列表

深度睡眠 EXTI 唤醒 — Deepsleep_wakeup_exti
深度睡眠 RTC 唤醒 — Deepsleep_wakeup_RTC
低电压检测 — Low_voltage_detector
待机 WKUP 唤醒 — Standby_wakeup_pin
待机 RTC 唤醒 — Standby_wakeup_RTC

GD32 — RCU

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

GD32 — RCU

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

示例列表

时钟输出引脚 — Ckout_pin_clock_output
复位源检测 — Reset_source_detect
系统时钟切换 — System_clock_switch

GD32 — SDIO 接口

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

GD32 — SDIO 接口

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

什么是 SDIO 接口?

SDIO 接口用于连接 SD 卡，实现大容量数据存储。配合 FatFs 文件系统可以读写文件。

示例列表

SD 卡读写 — Read_write

GD32 — SPI 同步串行总线 (SPI)

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

GD32 — SPI 同步串行总线 (SPI)

固件库: GD32F30x_Firmware_Library V3.0.3
示例数: 7
推荐入门: SPI_master_slave_fullduplex_polling（主从全双工轮询）

什么是 SPI？

SPI（Serial Peripheral Interface，串行外设接口）是 Motorola 提出的一种高速、全双工、同步串行总线。它和 I2C 一样也是"板内短距离"通信总线，但速度更快（GD32F30x 的 SPI 最高可达 30 MHz 左右，而 I2C 通常只有 400 kHz / 1 MHz），因此常被用来接 Flash、LCD 屏、SD 卡、射频模块、ADC/DAC 等需要大数据吞吐量的外设。

一句话记忆：I2C 是"省线"的总线，SPI 是"图快"的总线。

四根信号线

信号	全称	方向	说明
SCK	Serial Clock	主机 → 从机	时钟线，由主机产生，数据在时钟边沿被采样
MOSI	Master Out Slave In	主机 → 从机	主机发、从机收
MISO	Master In Slave Out	从机 → 主机	从机发、主机收
NSS / CS	Slave Select / Chip Select	主机 → 从机	片选，低电平选中某个从机

因为 MOSI 和 MISO 各走各的，所以 SPI 天然全双工——主机发一个字节的同时，从机也在回一个字节。这也是为什么 SPI 比 I2C（半双工，同一根线来回切换）快得多。

NSS 为什么重要？ 一根 SPI 总线上可以挂多个从机，它们共用 SCK/MOSI/MISO，但每个从机独占一根 NSS。主机想跟谁说话，就把谁的 NSS 拉低（其余保持高电平）。这就是为什么 SPI 叫"一主多从"却不需要像 I2C 那样给从机分配地址。

CPOL 与 CPHA（时钟极性 / 时钟相位）

SPI 没有统一的"起始位/停止位"帧格式，双方靠时钟的极性和相位对齐数据。这是新手最容易踩坑的地方：

CPOL（Clock Polarity，时钟极性）：空闲时 SCK 的电平。
- CPOL = 0：空闲为低电平
- CPOL = 1：空闲为高电平
CPHA（Clock Phase，时钟相位）：数据在第几个边沿被采样。
- CPHA = 0：在第 1 个时钟边沿采样（CPOL=0 时即上升沿）
- CPHA = 1：在第 2 个时钟边沿采样

CPOL 和 CPHA 组合出 4 种模式（模式 0~3）。主从双方必须配置成同一种模式，否则采样到的数据就是错的（典型的"乱码"来源）。最常见的模式 0 对应 CPOL=0, CPHA=0= 本库里的 SPI_CK_PL_LOW_PH_1EDGE。

还有几个需要理解的概念

主从（Master / Slave）：时钟只能由主机产生。从机永远跟着主机的 SCK 走。
帧长度（Frame Size）：通常是 8 位（一个字节），也可以配成 16 位。
波特率分频（Prescaler）：SPI 时钟 = APB 时钟 / 分频系数。从机有最高速率限制，分频要足够大。
NSS 软 / 硬（SPI_NSS_SOFT / SPI_NSS_HARD）：
- 软 NSS：片选由软件通过普通 GPIO 拉高拉低，库里用 spi_nss_internal_software_config() 或自己控制 GPIO。
- 硬 NSS：由 SPI 外设内部硬件自动管理 NSS 引脚（从机模式下尤其常用，NSS 被拉低才真正开始通信）。

GD32F30x 的 SPI 资源

GD32F30x 通常有 SPI0 / SPI1 / SPI2 三路 SPI（不同型号略有差异）。
SPI0 / SPI1 挂载在 APB2 总线（高速），SPI2 挂载在 APB1 总线（低速）。
部分 SPI 支持引脚重映射，需要在 rcu_periph_clock_enable(RCU_AF) 之后调用 gpio_pin_remap_config()。

三种数据收发方式

方式	特点	适用场景
轮询（Polling）	死等标志位，最简单但占用 CPU	教学、数据量小
中断（Interrupt）	收发完成进中断，CPU 可干别的	中等数据量
DMA	数据自动搬运，CPU 几乎不参与	大批量数据（如 LCD 刷屏、Flash 读写）

本模块入门示例 SPI_master_slave_fullduplex_polling 采用轮询方式，逻辑最直观，建议先吃透它。

常用库函数速查

函数	作用
`spi_init(SPIx, &spi_init_struct)`	按结构体初始化 SPI
`spi_enable(SPIx)` / `spi_disable(SPIx)`	使能/关闭 SPI
`spi_i2s_data_transmit(SPIx, data)`	发送一个字节/半字
`spi_i2s_data_receive(SPIx)`	读取接收数据寄存器
`spi_i2s_flag_get(SPIx, flag)`	查询标志位（TBE / RBNE 等）
`spi_nss_internal_software_config(SPIx, mode)`	软件 NSS 控制（拉高/拉低）
`spi_crc_on(SPIx)` / `spi_crc_next(SPIx)`	开启 / 触发下一次 CRC

两个关键标志位

TBE（Transmit Buffer Empty，发送缓冲空）：发送寄存器空了、可以塞下一个数据。轮询发送时 while(RESET == spi_i2s_flag_get(SPIx, SPI_FLAG_TBE)); 就是在等它。
RBNE（Receive Buffer Not Empty，接收缓冲非空）：收到了一个数据、等着被读走。轮询接收时 while(RESET == spi_i2s_flag_get(SPIx, SPI_FLAG_RBNE));。

为什么要"先发后收"都等 TBE / RBNE？ 因为 SPI 是全双工的：主机每发出去 1 位，从机也同时回 1 位。所以"发送一个字节"和"接收一个字节"天然是同一个 8 个时钟周期里完成的。主机拉低 NSS 后，每发一个字节就会从从机收一个字节，因此收发循环总是"等 TBE 发 → 等 RBNE 收"成对出现。

示例列表

SPI 主从全双工轮询 — SPI_master_slave_fullduplex_polling ★ 入门推荐
SPI 主从全双工 DMA — SPI_master_slave_fullduplex_dma
SPI 主从 NSS 硬件模式 — SPI_master_slave_fullduplex_nssp_mode
SPI 主从 TI 模式 — SPI_master_slave_fullduplex_ti_mode
SPI 主从单工 DMA — SPI_master_slave_simplex_dma
SPI 主发从收中断 — SPI_master_transmit_slave_receive_interrupt
I2S 主发从收 DMA — I2S_master_transmit_slave_receive_dma

学习路径建议

先跑通 SPI_master_slave_fullduplex_polling，理解"开时钟 → 配 GPIO（AF 复用）→ 配 SPI 参数 → 拉低 NSS → 轮询收发 → 拉高 NSS"这一整套流程。
再研究 SPI_master_slave_fullduplex_dma，把轮询换成 DMA，体会 CPU 占用率的变化。
需要接真实芯片（如 W25Q 系列 Flash、LCD）时，重点查它的模式（CPOL/CPHA）和最高速率，把分频配对。

下一篇：SPI 主从全双工轮询

GD32 — USBD

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

GD32 — USBD

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

示例列表

USB 音频 — audio
USB CDC ACM 虚拟串口 — cdc_acm
复合设备: 双 CDC — composite_dev_dual_cdc
复合设备: HID + 打印机 — composite_dev_hid_printer
自定义 HID — custom_hid
设备固件升级 (DFU) — dev_firmware_update
IAP HID — in_application_program_hid
USB CD-ROM — msc_cdrom
USB U 盘 — msc_udisk
标准 HID 键盘 — standard_hid_keyboard
USB 打印机 — usb_printer

GD32 — USBFS

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

GD32 — USBFS

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

示例列表

USB 设备模式 — USB_Device
USB 主机模式 — USB_Host

GD32 — WWDGT

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

GD32 — WWDGT

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

示例列表

窗口看门狗延迟喂狗 — WWDGT_delay_feed

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 — 定时器 (TIMER)

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

GD32 — 定时器 (TIMER)

固件库: GD32F30x_Firmware_Library V3.0.3
示例数: 13
推荐入门: TIMER1_pwmout（PWM 输出）

什么是定时器（TIMER）？

如果你把 MCU 比作一个"按节拍走路的人"，定时器就是它的节拍器。它本质上是一个从 0 开始不断加 1 的计数器，挂在某个固定频率的时钟上。数到设定值就"归零"并触发一个事件（更新中断、翻转引脚、产生 PWM 等）。

它的用途极广，几乎贯穿所有嵌入式项目：

用途	说明
精确延时 / 周期触发	替代 `delay()`，做精准定时任务
PWM 输出	调光、电机调速、舵机控制、音频
输入捕获（Input Capture）	测频率、测脉宽、测占空比
输出比较（Output Compare）	到指定时刻翻转/置位引脚
编码器接口	读取旋转编码器（电机测速）
死区/刹车	电机驱动、电源逆变（高级定时器）

一句话记忆：凡是"和时间、节奏、脉冲"有关的活，基本都交给定时器。

几个必须懂的核心概念

1. 时钟频率与分频

定时器的计数时钟来自 APB 总线，经 预分频器（PSC，Prescaler） 分频后得到实际计数频率：

`1`	`计数频率 f_cnt = 定时器输入时钟 / (PSC + 1)`

例如 GD32F30x 系统时钟 120MHz，APB2 上的 TIMER1 输入时钟也是 120MHz。若 PSC = 119，则 f_cnt = 120MHz / 120 = 1MHz，即每 1 微秒计一次数。

2. 自动重装载值（ARR，Auto-Reload / Period）

计数器从 0 数到 ARR（即 period），然后溢出归零，完成一个周期。一个 PWM 周期的时间：

`1`	`周期 T = (ARR + 1) / f_cnt`

本例里 period = 15999，所以一个周期 = 16000 / 1MHz = 16ms（约 62.5Hz）。

3. 比较值（CCR，Pulse / 占空比）

每个通道有一个比较寄存器。计数器在跑，当 计数器值 == 比较值 时，引脚按设定的极性翻转/置位。于是：

`1`	`占空比 = (CCR + 1) / (ARR + 1) （PWM 模式0/1 略有差别，但近似成立）`

CCR 越大，高电平时间越长，占空比越高。

4. PWM 模式 0 / 模式 1 与极性

PWM 模式 0：计数 < CCR 时输出无效电平（通常低），≥ CCR 时输出有效电平（高）。
PWM 模式 1：反过来。
极性（Polarity）：把"有效电平"定义成高还是低。极性一翻转，波形就上下颠倒，但占空比数值不变。

初学者只需记住：模式0/1 + 极性组合，决定"波形哪段是高"。本例用 PWM0 + 高极性，占空比 = CCR/ARR。

5. 向上 / 向下 / 中央对齐计数

向上计数（Up）：0 → ARR，最常用。
向下计数（Down）：ARR → 0。
中央对齐（Center-aligned）：0 → ARR → 0，对称波形，适合电机/电源。本例用向上计数。

GD32F30x 的定时器家族

TIMER0：高级定时器，带互补输出、死区、刹车，用于电机/逆变。
TIMER1 / TIMER2：通用定时器，PWM、输入捕获、输出比较都支持，最常用。
TIMER3~TIMER13（视型号）：更多通用/基本定时器。
每个通用定时器有 4 个通道（CH0~CH3），可独立输出不同占空比的 PWM。

常用库函数速查

函数	作用
`timer_deinit(TIMERx)`	复位定时器
`timer_init(TIMERx, &initpara)`	按结构体初始化（PSC/ARR/计数方向等）
`timer_prescaler_config()` / `timer_autoreload_value_config()`	运行时改分频 / 重装载值
`timer_channel_output_config()`	配置某通道输出（使能、极性、空闲态）
`timer_channel_output_pulse_value_config()`	设置比较值 CCR（决定占空比）
`timer_channel_output_mode_config()`	设为 PWM0/PWM1/翻转等模式
`timer_auto_reload_shadow_enable()`	开启 ARR 影子寄存器（避免更新瞬间毛刺）
`timer_enable(TIMERx)`	启动定时器

示例列表

TIMER1 PWM 输出 — TIMER1_pwmout ★ 入门推荐
TIMER1 输出比较有效 — TIMER1_ocactive
TIMER1 输出比较翻转 — TIMER1_octoggle
TIMER1 单脉冲 — TIMER1_singlepulse
TIMER1 外部触发 — TIMER1_exttrigger
TIMER2 输入捕获 — TIMER2_inputcapture
TIMER2 PWM 输入捕获 — TIMER2_pwminputcapture
TIMER0 互补信号 — TIMER0_complementarysignals
TIMER0 死区与刹车 — TIMER0_deadtime_break
TIMER0 6 步换相 — TIMER0_6-steps
TIMER0 DMA — TIMER0_dma
TIMER0 DMA 突发 — TIMER0_dma_burst
定时器级联同步 — TIMERs_cascadesynchro

学习路径建议

先吃透 TIMER1_pwmout：理解"PSC 决定频率、ARR 决定周期、CCR 决定占空比"这三件套。
再看 TIMER1_ocactive / TIMER1_octoggle 理解"输出比较"和 PWM 的关系。
需要测频率/脉宽时看 TIMER2_inputcapture；需要多路同步 PWM 看 TIMER0 系列。

下一篇：TIMER1 PWM 输出

GD32 — 模数转换器 (ADC)

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

GD32 — 模数转换器 (ADC)

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

什么是 ADC？

ADC 是 Analog-to-Digital Converter（模数转换器）的缩写。它干的事只有一件：

把一个电压值，翻译成一个整数。

MCU 的世界只有 0 和 1，它天生不认识"1.65 伏"这种连续量。而现实世界全是连续量：温度、光照、压力、声音、电池电压、旋钮位置……这些物理量经过传感器变成电压后，必须由 ADC 转成数字，程序才能处理。

打个比方：ADC 就是 MCU 的"感官神经"。GPIO 输入只能告诉你"有没有"（高/低两档），ADC 能告诉你"有多少"（几千档）。

12 位分辨率意味着什么

GD32F30x 的 ADC 是 12 位 的，也就是把参考电压范围切成 2^12 = 4096 份（0 ~ 4095）。

假设参考电压 VREF+ = 3.3V，那么：

`1`	`数字量 = 输入电压 / 3.3V × 4095`

输入电压	ADC 读数
0 V	0
0.825 V	约 1024
1.65 V	约 2048
3.3 V	4095

分辨率（能分辨的最小电压变化）：

`1`	`3.3V / 4096 ≈ 0.806 mV`

也就是说输入电压变化不到 0.8mV，ADC 读数不会变。这个精度对测电池电压、读电位器、测温度都完全够用。

反算电压的标准公式（写代码必用）：

`1`	`float voltage = (float)adc_value * 3.3f / 4095.0f;`

注意：分母到底用 4095 还是 4096 有争议。严格说满量程码 4095 对应的是 4095/4096 × VREF，工程上直接用 4095 更方便，误差不到 0.03%，可以忽略。

GD32F30x ADC 的硬件资源

项目	参数
ADC 数量	最多 3 个（ADC0 / ADC1 / ADC2）
分辨率	12 位（部分型号支持 6/8/10/12 位可配）
外部通道	16 个（ADC_CHANNEL_0 ~ 15）
内部通道	温度传感器（CH16）、内部参考电压 VREFINT（CH17）
最大采样率	约 2.6 MSPS（ADC 时钟 14MHz 时）
ADC 时钟上限	14 MHz（超频会导致精度严重下降）
触发方式	软件触发、定时器触发、外部引脚触发

ADC 时钟必须分频到 14MHz 以下

这是 ADC 最容易被忽视的一条硬约束。GD32F307 的 APB2 总线跑 120MHz，直接给 ADC 用会烧不了但精度全废。所以必须分频：

`1`	`rcu_adc_clock_config(RCU_CKADC_CKAPB2_DIV6); /* 120MHz / 6 = 20MHz */`

可选的分频系数有 DIV2 / DIV4 / DIV6 / DIV8 / DIV12 / DIV16。

官方示例用了 DIV6 得到 20MHz，其实已经略微超出 14MHz 的推荐值。追求精度的项目建议用 DIV12（10MHz） 或 DIV16（7.5MHz）。速度慢一点，读数稳定很多。

两组通道：常规组 vs 注入组

这是 ADC 里最让新手困惑的概念，但理解了就很简单。

	常规组（Routine / Regular）	注入组（Inserted / Injected）
通道数上限	16	4
优先级	低	高，可以打断常规组
数据寄存器	只有 1 个，会被覆盖	4 个独立寄存器
典型用途	常态巡检各路电压	紧急采样（如过流保护）
是否需要 DMA	多通道时强烈建议	不需要

类比理解：常规组像是普通门诊，病人按顺序排队看；注入组像是急诊，来了就插队优先处理。

关键坑点：常规组只有一个 ADC_RDATA 数据寄存器。如果你配了 4 个通道连续转换，第 2 个通道的结果会把第 1 个的覆盖掉。解决办法有两个：

一次只转一个通道，转完立刻读走（本模块的软件触发轮询示例就是这个思路，最简单）；
用 DMA 自动把每次结果搬到数组里（参考 ADC0_routine_channel_with_DMA 示例，实际项目标准做法）。

GD32 库把 STM32 里的 Regular/Injected 改叫 Routine/Inserted，所以函数名是 ADC_ROUTINE_CHANNEL 和 ADC_INSERTED_CHANNEL。看 STM32 教程时要做个心理转换。

采样时间怎么选

ADC 采样的物理过程是"给内部一个电容充电到和输入电压相等"。如果信号源内阻大（比如热敏电阻、高阻分压网络），充电就慢，采样时间必须给足，否则读数偏低。

GD32 提供 8 档采样时间：

ADC_SAMPLETIME_1POINT5     /*  1.5 个 ADC 时钟周期 */
ADC_SAMPLETIME_7POINT5     /*  7.5 —— 常用默认值 */
ADC_SAMPLETIME_13POINT5
ADC_SAMPLETIME_28POINT5
ADC_SAMPLETIME_41POINT5
ADC_SAMPLETIME_55POINT5
ADC_SAMPLETIME_71POINT5
ADC_SAMPLETIME_239POINT5   /* 239.5 —— 最慢最准 */

选择原则：

信号源类型	推荐采样时间
低阻源（运放输出、电位器 10kΩ 以下）	`7POINT5` ~ `13POINT5`
中阻源（分压电阻网络、热敏电阻）	`28POINT5` ~ `55POINT5`
内部温度传感器	至少 `239POINT5`（手册明确要求 ≥17.1μs）
高阻源 / 读数不稳	加大到 `239POINT5` 试试

总转换时间计算：

转换时间 = (采样时间 + 12.5 个周期) / ADC时钟频率

例：ADC 时钟 20MHz、采样时间 7.5
   = (7.5 + 12.5) / 20MHz = 1μs

实用经验：读数跳动大的时候，第一件事就是把采样时间加到最大档试试。这个改动一行代码，往往能解决 80% 的"ADC 不准"问题。

五种工作模式

`1`	`adc_mode_config(ADC_MODE_FREE); /* 独立模式 —— 最常用 */`

模式	含义
`ADC_MODE_FREE`	独立模式：每个 ADC 各干各的，互不影响
`ADC_DAUL_REGULAL_PARALLEL`	双 ADC 常规组并行：两个 ADC 同时采两路，采样率翻倍
`ADC_DAUL_REGULAL_FOLLOW_UP_FAST`	快速交替：交错采样，等效采样率翻倍
`ADC_DAUL_INSERTED_PARALLEL`	双 ADC 注入组并行
`ADC_DAUL_REGULAL_PARALLEL_INSERTED_PARALLEL`	常规 + 注入都并行

99% 的项目用 ADC_MODE_FREE 就够了。双 ADC 模式主要用在电机 FOC 控制（需要同一时刻采三相电流）这类高实时性场合。

必须做的两件事：使能后延时 + 校准

1
2
3

adc_enable(ADC0);
delay_1ms(1U);                    /* 等 ADC 上电稳定，手册要求至少 1μs */
adc_calibration_enable(ADC0);      /* 校准，消除内部电容偏差 */

为什么要延时？ ADC 内部有模拟电路，adc_enable() 之后需要一段稳定时间（手册标称 tSTAB ≈ 1μs）。不等就校准，校准结果不准。

为什么要校准？ 芯片制造时内部电容会有工艺偏差，校准过程让 ADC 自己测出偏差值并存起来，后续每次转换都自动补偿。跳过校准会带来几个 LSB 的固定误差，这在测精密电压时不能接受。

校准函数内部会阻塞等待校准完成，所以调用后可以直接开始转换，不用额外等待。注意：校准必须在 adc_enable() 之后做，顺序反了无效。

常用 API 速查

/* ===== 时钟 ===== */
rcu_periph_clock_enable(RCU_GPIOA);
rcu_periph_clock_enable(RCU_ADC0);
rcu_adc_clock_config(RCU_CKADC_CKAPB2_DIV6);      /* ADC 时钟分频，必做 */

/* ===== GPIO：模拟输入 ===== */
gpio_init(GPIOA, GPIO_MODE_AIN, GPIO_OSPEED_10MHZ, GPIO_PIN_1);

/* ===== ADC 基本参数 ===== */
adc_mode_config(ADC_MODE_FREE);                                    /* 独立模式 */
adc_data_alignment_config(ADC0, ADC_DATAALIGN_RIGHT);              /* 右对齐 */
adc_channel_length_config(ADC0, ADC_ROUTINE_CHANNEL, 1U);          /* 序列长度 */
adc_special_function_config(ADC0, ADC_CONTINUOUS_MODE, ENABLE);    /* 连续转换 */
adc_special_function_config(ADC0, ADC_SCAN_MODE, ENABLE);          /* 扫描模式 */

/* ===== 通道与采样时间 ===== */
adc_routine_channel_config(ADC0, 0U, ADC_CHANNEL_1, ADC_SAMPLETIME_7POINT5);
/*                              ↑序号  ↑通道号        ↑采样时间 */

/* ===== 使能与校准 ===== */
adc_enable(ADC0);
delay_1ms(1U);
adc_calibration_enable(ADC0);

/* ===== 启动转换与读值 ===== */
adc_software_trigger_enable(ADC0, ADC_ROUTINE_CHANNEL);
while(!adc_flag_get(ADC0, ADC_FLAG_EOC));                /* 等转换完成 */
adc_flag_clear(ADC0, ADC_FLAG_EOC);
uint16_t val = adc_routine_data_read(ADC0);

学习路线建议

ADC0_software_trigger_routine_channel_polling ← 从这里开始，最简单最直白，理解 ADC 完整流程
ADC0_temperature_Vref — 用内部温度传感器，不用接任何外部器件就能玩
ADC0_routine_channel_with_DMA — 学会多通道自动采集，这是实际项目的标准做法
ADC1_analog_watchdog — 硬件自动监测超限并中断，做过压/过流保护必学
ADC1_oversample_shift — 过采样提高有效位数，把 12 位提到 16 位精度
ADC0_ADC1_routine_parallel — 双 ADC 同步采样，电机控制场景

示例列表

双 ADC 并行采集 — ADC0_ADC1_routine_parallel
ADC 不连续模式 — ADC0_routine_channel_discontinuous_mode
ADC + DMA 采集 — ADC0_routine_channel_with_DMA
ADC 软件触发轮询 — ADC0_software_trigger_routine_channel_polling ← 建议从这里开始
ADC 温度 & Vref — ADC0_temperature_Vref
ADC 模拟看门狗 — ADC1_analog_watchdog
ADC 过采样 — ADC1_oversample_shift
ADC 分辨率配置 — ADC1_resolution

GD32 — 闪存控制器 (FMC)

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

GD32 — 闪存控制器 (FMC)

固件库: GD32F30x_Firmware_Library V3.0.3
示例数: 2
推荐入门: Erase_Program（Flash 擦写）

什么是 FMC？

FMC（Flash Memory Controller，闪存控制器）是 MCU 内部用来管理片上 Flash 的硬件模块。我们平时写的程序就烧录在 Flash 里；而 FMC 让你能在程序运行的过程中，自己去擦除、编程（写入）Flash 的某些区域——也就是"运行时改写 Flash"。

一句话记忆：程序住在 Flash 里，FMC 就是"管理 Flash 的物业"，负责擦除和写入。

为什么需要"运行时写 Flash"？

保存掉电不丢的配置参数、校准值、运行计数（类似 EEPROM，但用的是片内 Flash）。
实现 IAP（在应用编程）/ OTA 升级：旧程序把新程序写到 Flash 另一块，再跳转过去。
记录日志、黑匣子数据等。

Flash 的三个"反直觉"物理特性（必看！）

特性	说明	后果
只能 1→0，不能 0→1	写操作只能把位从 1 改成 0	想改写必须先"整块擦除"回到全 1（`0xFF`）
最小擦除单位 = “页”（Page）	GD32F30x 一页通常 2KB（0x800）	哪怕只想改 1 字节，也得擦掉整页（会丢同页其他数据，需先备份）
写以"字"（32 位）为单位	一次写 4 字节	半字/字节写支持情况看手册，库通常提供 `fmc_word_program`

这也是为什么所有 Flash 例程都是"先解锁 → 擦整页 → 再按字写 → 上锁“这套固定流程。

关键操作流程

解锁：Flash 上电默认"锁着”，写之前必须 fmc_unlock()（写入特定密钥序列）。
清标志：操作前清掉 END / WPERR / PGERR 等状态标志。
擦除（如需改写）：fmc_page_erase(addr) 把整页擦成 0xFF。
编程（写）：fmc_word_program(addr, data) 按字写入。
上锁：写完后 fmc_lock() 保护 Flash。

GD32F30x 的 Flash 资源

Flash 从 0x08000000 开始，前半是你的程序代码区，后面才是可自由使用的"用户数据区"。
千万不要擦写正在运行代码的页，否则程序会跑飞。例程用 0x08004000 这类靠前的空闲页做演示，你自己用时要选程序末尾之后的空闲区（查 map 文件/链接脚本）。
FMC 还支持写保护（Write Protection）、读出保护（RDP） 等安全特性（见 Write_Protection 例程）。

常用库函数速查

函数	作用
`fmc_unlock()` / `fmc_lock()`	解锁 / 上锁 Flash 控制器
`fmc_flag_clear(flag)`	清除状态标志（END / WPERR / PGERR）
`fmc_page_erase(addr)`	擦除 addr 所在的整页
`fmc_word_program(addr, data)`	在 addr 处写一个 32 位字
`fmc_halfword_program(addr, data)`	写一个 16 位半字
`fmc_state_enum`	返回值类型，`FMC_READY` / `FMC_WPERR`（写保护错）等

示例列表

Flash 擦写 — Erase_Program ★ 入门推荐
Flash 写保护 — Write_Protection

学习路径建议

先跑通 Erase_Program：理解"解锁 → 擦页 → 写字 → 上锁 → 校验"这条黄金流程。
再看 Write_Protection：了解如何给某些页加写保护，防止误擦写关键区域。

下一篇：Flash 擦写

GD32 — 实时时钟 (RTC)

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

GD32 — 实时时钟 (RTC)

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

什么是实时时钟 (RTC)?

RTC（实时时钟）提供年月日时分秒的计时功能。由独立电池供电，MCU 复位或断电后时间不丢失。

示例列表

日历演示 — Calendar_demo

GD32 — 数模转换器 (DAC)

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

GD32 — 数模转换器 (DAC)

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

什么是数模转换器 (DAC)?

DAC（数模转换器）将数字值转换为模拟电压输出。可以生成正弦波、三角波、噪声波等模拟信号。

示例列表

DAC + ADC 转换 — DAC_ADC_convert
DAC DMA 转换 — DAC_DMA_convert
DAC 外部触发 — DAC_EXTI_trigger
DAC LFSR 噪声模式 — DAC_LFSR_noise_mode
DAC 三角噪声模式 — DAC_triangle_noise_mode
DAC 独立触发 LFSR 噪声 — DACC_independent_trigger_LFSR_noise
DAC 输出电压 — DACC_output_voltage
DAC 同步触发三角噪声 — DACC_simultaneous_trigger_triangle_noise
DAC 软件触发 LFSR 噪声 — DACC_software_trigger_LFSR_noise

GD32 — 通用 IO 口 (GPIO)

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

GD32 — 通用 IO 口 (GPIO)

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

什么是 GPIO？

GPIO 是 General Purpose Input/Output（通用输入输出）的缩写。你可以把它理解成 MCU 芯片上那一排"腿"里最灵活的一类：

配成输出，它就是一个可以被程序控制的电子开关 —— 想让它输出 3.3V 就输出 3.3V，想让它输出 0V 就输出 0V。接上 LED 就能点灯，接上三极管就能驱动继电器、蜂鸣器、电机。
配成输入，它就是一个电压探测器 —— 程序随时可以读出这根引脚现在是高电平还是低电平。接上按键就能检测按下，接上传感器的开关量输出就能读状态。

一句话：GPIO 是 MCU 与外部世界打交道的最基础通道。学会了 GPIO，你才算真正"控制"了这颗芯片。

GD32 的 GPIO 长什么样

GD32F30x 的 GPIO 按"组"（Port）划分，每组最多 16 根引脚（Pin）：

端口	引脚编号	常见叫法
GPIOA	PIN_0 ~ PIN_15	PA0 ~ PA15
GPIOB	PIN_0 ~ PIN_15	PB0 ~ PB15
GPIOC / D / E / F / G	同上	PC0…、PE0…

所以我们说的 “PC0”，就是 GPIOC 这一组的第 0 根引脚。代码里写成 GPIOC + GPIO_PIN_0 两个参数。

八种工作模式（新手最容易搞混的地方）

GD32F30x 沿用了和 STM32F1 相同的 GPIO 模式命名。初始化函数只有一个：

`1`	`gpio_init(端口, 模式, 输出速度, 引脚);`

输入类模式（读电平用）：

宏	中文含义	什么时候用
`GPIO_MODE_IN_FLOATING`	浮空输入	外部电路已经有上下拉电阻了
`GPIO_MODE_IPU`	上拉输入	按键"按下接地"式接法（最常用）
`GPIO_MODE_IPD`	下拉输入	按键"按下接 VCC"式接法
`GPIO_MODE_AIN`	模拟输入	这根脚要给 ADC 采电压用

输出类模式（控制电平用）：

宏	中文含义	什么时候用
`GPIO_MODE_OUT_PP`	推挽输出	驱动 LED、普通开关量（最常用）
`GPIO_MODE_OUT_OD`	开漏输出	需要"只能拉低不能拉高"的场合
`GPIO_MODE_AF_PP`	复用推挽输出	这根脚交给外设用，如 USART_TX、PWM
`GPIO_MODE_AF_OD`	复用开漏输出	这根脚交给外设用且需开漏，如硬件 I2C

记住一条铁律：只要一根引脚不是给你自己 gpio_bit_set() 用，而是要交给 USART / SPI / TIMER 这些外设自动驱动，就必须选 GPIO_MODE_AF_xx（AF = Alternate Function，复用功能）。这是新手做串口、PWM 时最高频的错误来源。

常用 API 速查

/* 打开某组 GPIO 的时钟 —— 忘了这句，后面所有配置都无效！ */
rcu_periph_clock_enable(RCU_GPIOC);

/* 初始化引脚 */
gpio_init(GPIOC, GPIO_MODE_OUT_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_0);

/* 输出控制 */
gpio_bit_set(GPIOC, GPIO_PIN_0);            // 输出高电平
gpio_bit_reset(GPIOC, GPIO_PIN_0);          // 输出低电平
gpio_bit_write(GPIOC, GPIO_PIN_0, SET);     // 按变量写

/* 输入读取 */
gpio_input_bit_get(GPIOC, GPIO_PIN_13);     // 读某一根脚的电平
gpio_input_port_get(GPIOC);                 // 一次读整组 16 位

三个新手必踩的坑

忘开时钟：GD32 所有外设默认时钟是关闭的（省电设计）。不调用 rcu_periph_clock_enable()，gpio_init() 写进去的寄存器值会直接丢掉，现象就是"代码看着没问题但灯就是不亮"。
输出速度乱选：GPIO_OSPEED_2MHZ / 10MHZ / 50MHZ 指的是引脚电平翻转的最大速率，不是"输出多少电压"。点灯用 2MHz 就够，速度越高 EMI 噪声越大。
重映射忘开 AF 时钟：用 gpio_pin_remap_config() 做引脚重映射前，必须先 rcu_periph_clock_enable(RCU_AF)。

学习路线建议

按下面顺序看示例，难度是递增的：

先看流水灯 —— 掌握"开时钟 → 配模式 → 写电平"这个三部曲，这是所有 GD32 外设编程的通用套路。
再看按键轮询 —— 学会输入模式和软件消抖思路。
最后看调试口复用 —— 理解 JTAG 引脚被释放的原理，这是做小封装芯片项目时的实战技巧。

示例列表

调试口复用为 GPIO — Debugport_use_as_GPIO_output
按键轮询检测 — Keyboard_polling_mode
流水灯 — Running_led

GD32 — 循环冗余校验 (CRC)

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

GD32 — 循环冗余校验 (CRC)

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

什么是循环冗余校验 (CRC)?

CRC（循环冗余校验）是数据通信中最常用的错误检测方法，确保传输数据的完整性。

示例列表

CRC 计算 — CRC_calculate

GD32 — 直接存储器访问 (DMA)

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

GD32 — 直接存储器访问 (DMA)

固件库: GD32F30x_Firmware_Library V3.0.3
示例数: 3
推荐入门: Flash_to_ram（Flash → RAM）

什么是 DMA？

DMA（Direct Memory Access，直接存储器访问）可以理解为 MCU 里的一个**“自动搬运工”**。平时我们要把数据从 A 搬到 B（比如从 Flash 拷到 RAM、从 ADC 搬到数组、从数组发到 USART），都得 CPU 一条条 for 循环去读写。DMA 出现后，CPU 只要下个"指令"，剩下的成百上千字节就由 DMA 硬件自动搬完，搬完了再通知 CPU 一声。

一句话记忆：DMA = 不占用 CPU 的数据搬运器，CPU 去干计算/通信的活，搬运交给它。

没有 DMA vs 有 DMA

场景	不用 DMA	用 DMA
ADC 连续采样 1024 点	CPU 轮询/中断一个个读，忙得不可开交	DMA 自动搬进数组，CPU 去干别的
串口发 1KB 数据	CPU 一个字节一个字节等 TBE	DMA 一口气发完，发完进中断
大数组拷贝	`for` 循环占满 CPU	一条指令后台搬完

DMA 的"三要素"

配置一次 DMA 搬运，本质就是告诉它三件事：

从哪搬（源地址 / 外设地址）：periph_addr 或 memory_addr。
搬到哪（目标地址 / 内存地址）：另一个 memory_addr。
搬多少、怎么搬：
- number：总共搬多少"次"（注意是按"数据宽度"算次数）。
- periph_inc / memory_inc：搬完一个后，源/目标地址是否自动 +1（自增）。
- periph_width / memory_width：每次搬 8 位 / 16 位 / 32 位。
- direction：外设→内存、内存→外设、还是内存→内存。
- priority：多个 DMA 通道抢总线时谁优先。

三种传输方向

外设 → 内存（Peripheral to Memory）：典型如 ADC 采样值搬进数组、串口收到的数据搬进缓冲。
内存 → 外设（Memory to Peripheral）：典型如把发送数组搬给 USART/SPI 发出去。
内存 → 内存（Memory to Memory）：纯软件数据搬运，如本例的 Flash→RAM。⚠️ 注意：只有 DMA0 支持内存到内存模式。

搬运完成怎么知道？—— 中断

DMA 支持多种中断：传输完成（FTF，Full Transfer Finish）、半传输（HTF）、传输错误（ERR）等。本例用 DMA_INT_FTF：搬完 1024 字节后触发 DMA0_Channel0_IRQHandler，在函数里把 g_dmacomplete_flag 置 1，主循环 while(0 == g_dmacomplete_flag); 就解除了阻塞。

循环模式（Circular）：普通模式搬完一次就停；循环模式搬完自动从头再来，常用于 ADC 连续采样（环形缓冲）。本例 dma_circulation_disable，只搬一次。

GD32F30x 的 DMA 资源

通常有两路 DMA 控制器：DMA0 和 DMA1，每路有多个通道（CH0~CHx）。
不同外设的 DMA 请求固定映射到特定 DMA 通道（如 ADC0→DMA0_CH0、USART0_TX→DMA0_CH3 等），用时要查手册映射表。
内存到内存模式仅 DMA0 可用。

常用库函数速查

函数	作用
`dma_deinit(DMAx, CHx)`	复位 DMA 通道
`dma_init(DMAx, CHx, &init)`	按结构体配置通道
`dma_circulation_enable/disable()`	开/关循环模式
`dma_memory_to_memory_enable()`	开启内存到内存模式（仅 DMA0）
`dma_interrupt_enable(DMAx, CHx, flag)`	开启某种 DMA 中断
`dma_channel_enable(DMAx, CHx)`	启动传输
`dma_flag_get()` / `dma_interrupt_flag_clear()`	查询/清除标志

示例列表

Flash → RAM — Flash_to_ram ★ 入门推荐
RAM → RAM — Ram_to_ram
RAM → USART — Ram_to_usart

学习路径建议

先跑通 Flash_to_ram：理解"配好三要素 + 启动 + 等中断"这条最干净的 DMA 主线。
再看 Ram_to_usart：体会 DMA 如何给串口"减负"（内存→外设方向）。
需要 ADC 批量采样时，把方向换成"外设→内存"即可。

下一篇：Flash → RAM

GD32 ADC — ADC + DMA 采集

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

ADC — ADC + DMA 采集

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

功能简介

本示例演示 ADC + DMA 的组合用法。ADC 采样完成后，数据由 DMA 自动搬运到内存，CPU 完全不参与，效率极高。适合高速连续采样场景。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

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

void rcu_config(void);
void gpio_config(void);
void dma_config(void);
void adc_config(void);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    /* system clocks configuration */
    rcu_config();
    /* systick configuration */
    systick_config();
    /* GPIO configuration */
    gpio_config();
    /* configure COM port */
    gd_eval_com_init(EVAL_COM0);
    /* DMA configuration */
    dma_config();
    /* ADC configuration */
    adc_config();

    while(1){
        delay_1ms(1000);
        printf("\r\n //*******************************//");
        printf("\r\n ADC0 routine channel data = %04X", adc_value[0]);
        printf("\r\n ADC0 routine channel data = %04X", adc_value[1]);
        printf("\r\n ADC0 routine channel data = %04X", adc_value[2]);
        printf("\r\n ADC0 routine channel data = %04X\r\n", adc_value[3]);
    }
}

void rcu_config(void)
{
    /* enable GPIOA clock */
    rcu_periph_clock_enable(RCU_GPIOA);
    /* enable ADC clock */
    rcu_periph_clock_enable(RCU_ADC0);
    /* enable DMA0 clock */
    rcu_periph_clock_enable(RCU_DMA0);
    /* config ADC clock */
    rcu_adc_clock_config(RCU_CKADC_CKAPB2_DIV6);
}

void gpio_config(void)
{
    /* config the GPIO as analog mode */
    gpio_init(GPIOA, GPIO_MODE_AIN, GPIO_OSPEED_10MHZ, GPIO_PIN_0);
    gpio_init(GPIOA, GPIO_MODE_AIN, GPIO_OSPEED_10MHZ, GPIO_PIN_1);
    gpio_init(GPIOA, GPIO_MODE_AIN, GPIO_OSPEED_10MHZ, GPIO_PIN_2);
    gpio_init(GPIOA, GPIO_MODE_AIN, GPIO_OSPEED_10MHZ, GPIO_PIN_3);
}

void dma_config(void)
{
    /* ADC_DMA_channel configuration */
    dma_parameter_struct dma_data_parameter;

    /* ADC DMA_channel configuration */
    dma_deinit(DMA0, DMA_CH0);

    /* initialize DMA single data mode */
    dma_data_parameter.periph_addr  = (uint32_t)(&ADC_RDATA(ADC0));
    dma_data_parameter.periph_inc   = DMA_PERIPH_INCREASE_DISABLE;
    dma_data_parameter.memory_addr  = (uint32_t)(&adc_value);
    dma_data_parameter.memory_inc   = DMA_MEMORY_INCREASE_ENABLE;
    dma_data_parameter.periph_width = DMA_PERIPHERAL_WIDTH_16BIT;
    dma_data_parameter.memory_width = DMA_MEMORY_WIDTH_16BIT;  
    dma_data_parameter.direction    = DMA_PERIPHERAL_TO_MEMORY;
    dma_data_parameter.number       = 4;
    dma_data_parameter.priority     = DMA_PRIORITY_HIGH;
    dma_init(DMA0, DMA_CH0, &dma_data_parameter);

    dma_circulation_enable(DMA0, DMA_CH0);

    /* enable DMA channel */
    dma_channel_enable(DMA0, DMA_CH0);
}

void adc_config(void)
{
    /* ADC mode config */
    adc_mode_config(ADC_MODE_FREE); 
    /* ADC continuous function enable */
    adc_special_function_config(ADC0, ADC_CONTINUOUS_MODE, ENABLE);
    /* ADC scan function enable */
    adc_special_function_config(ADC0, ADC_SCAN_MODE, ENABLE);
    /* ADC data alignment config */
    adc_data_alignment_config(ADC0, ADC_DATAALIGN_RIGHT);

    /* ADC channel length config */
    adc_channel_length_config(ADC0, ADC_ROUTINE_CHANNEL, 4);

    /* ADC routine channel config */ 
    adc_routine_channel_config(ADC0, 0, ADC_CHANNEL_0, ADC_SAMPLETIME_55POINT5);
    adc_routine_channel_config(ADC0, 1, ADC_CHANNEL_1, ADC_SAMPLETIME_55POINT5);
    adc_routine_channel_config(ADC0, 2, ADC_CHANNEL_2, ADC_SAMPLETIME_55POINT5);
    adc_routine_channel_config(ADC0, 3, ADC_CHANNEL_3, ADC_SAMPLETIME_55POINT5);

    /* ADC trigger config */
    adc_external_trigger_source_config(ADC0, ADC_ROUTINE_CHANNEL, ADC0_1_2_EXTTRIG_ROUTINE_NONE);
    adc_external_trigger_config(ADC0, ADC_ROUTINE_CHANNEL, ENABLE);

    /* ADC DMA function enable */
    adc_dma_mode_enable(ADC0);
    /* enable ADC interface */
    adc_enable(ADC0);
    delay_1ms(1);
    /* ADC calibration and reset calibration */
    adc_calibration_enable(ADC0);

    /* ADC software trigger enable */
    adc_software_trigger_enable(ADC0, ADC_ROUTINE_CHANNEL);
}

代码讲解

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

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

ADC 配置：选择采样通道、采样时间、触发方式、数据对齐方式。采样时间越长精度越高。

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

校准：ADC 使用前必须校准，消除工艺偏差。校准期间不要操作 ADC。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

GD32 ADC — ADC 不连续模式

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

ADC — ADC 不连续模式

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

功能简介

本示例演示 ADC 模数转换器的基本用法。ADC 将模拟电压信号转换为数字值，是读取传感器数据的关键外设。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

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

void rcu_config(void);
void gpio_config(void);
void dma_config(void);
void adc_config(void);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    /* system clocks configuration */
    rcu_config();
    /* systick configuration */
    systick_config();
    /* GPIO configuration */
    gpio_config();
    /* configure COM port */
    gd_eval_com_init(EVAL_COM0);
    /* DMA configuration */
    dma_config();
    /* ADC configuration */
    adc_config();

    while(1){
        /* delay 1s */
        delay_1ms(1000);
        printf("\r\n ***********************************\r\n");
        printf("\r\n ADC0 routine channel data 0, PA0 = %04X \r\n", adc_value[0]);
        printf("\r\n ADC0 routine channel data 1, PA1 = %04X \r\n", adc_value[1]);
        printf("\r\n ADC0 routine channel data 2, PA2 = %04X \r\n", adc_value[2]);
        printf("\r\n ADC0 routine channel data 3, PA3 = %04X \r\n", adc_value[3]);
        printf("\r\n ADC0 routine channel data 4, PA4 = %04X \r\n", adc_value[4]);
        printf("\r\n ADC0 routine channel data 5, PA5 = %04X \r\n", adc_value[5]);
        printf("\r\n ADC0 routine channel data 6, PA6 = %04X \r\n", adc_value[6]);
        printf("\r\n ADC0 routine channel data 7, PA7 = %04X \r\n", adc_value[7]);
    }
}

void rcu_config(void)
{
    /* enable GPIOA clock */
    rcu_periph_clock_enable(RCU_GPIOA);
    /* enable ADC0 clock */
    rcu_periph_clock_enable(RCU_ADC0);
    /* enable DMA0 clock */
    rcu_periph_clock_enable(RCU_DMA0);
    /* config ADC clock */
    rcu_adc_clock_config(RCU_CKADC_CKAPB2_DIV4);
}

void gpio_config(void)
{
    /* config the GPIO as analog mode */
    gpio_init(GPIOA, GPIO_MODE_AIN, GPIO_OSPEED_MAX, GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3);
    gpio_init(GPIOA, GPIO_MODE_AIN, GPIO_OSPEED_MAX, GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7);
    /* config the GPIO as floating input mode, for EXTI */
    gpio_init(GPIOA, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_MAX,GPIO_PIN_11);
}

void dma_config(void)
{
    /* ADC_DMA_channel configuration */
    dma_parameter_struct dma_data_parameter;

    /* ADC DMA_channel configuration */
    dma_deinit(DMA0, DMA_CH0);

    /* initialize DMA single data mode */
    dma_data_parameter.periph_addr = (uint32_t)(&ADC_RDATA(ADC0));
    dma_data_parameter.periph_inc = DMA_PERIPH_INCREASE_DISABLE;
    dma_data_parameter.memory_addr = (uint32_t)(&adc_value);
    dma_data_parameter.memory_inc = DMA_MEMORY_INCREASE_ENABLE;
    dma_data_parameter.periph_width = DMA_PERIPHERAL_WIDTH_16BIT;
    dma_data_parameter.memory_width = DMA_MEMORY_WIDTH_16BIT;  
    dma_data_parameter.direction = DMA_PERIPHERAL_TO_MEMORY;
    dma_data_parameter.number = 8;
    dma_data_parameter.priority = DMA_PRIORITY_HIGH;
    dma_init(DMA0, DMA_CH0, &dma_data_parameter);

    dma_circulation_enable(DMA0, DMA_CH0);

    /* enable DMA channel */
    dma_channel_enable(DMA0, DMA_CH0);
}

void adc_config(void)
{
    /* ADC continuous function disable */
    adc_special_function_config(ADC0, ADC_CONTINUOUS_MODE, DISABLE);
    adc_special_function_config(ADC0, ADC_SCAN_MODE, DISABLE);
    /* ADC trigger config */
    adc_external_trigger_source_config(ADC0, ADC_ROUTINE_CHANNEL, ADC0_1_EXTTRIG_ROUTINE_EXTI_11); 
    /* ADC data alignment config */
    adc_data_alignment_config(ADC0, ADC_DATAALIGN_RIGHT);
    /* ADC mode config */
    adc_mode_config(ADC_MODE_FREE); 
    /* ADC channel length config */
    adc_channel_length_config(ADC0, ADC_ROUTINE_CHANNEL, 8);

    /* ADC DMA function enable */
    adc_dma_mode_enable(ADC0);

    /* ADC routine channel config */
    adc_routine_channel_config(ADC0, 0, ADC_CHANNEL_0, ADC_SAMPLETIME_55POINT5);
    adc_routine_channel_config(ADC0, 1, ADC_CHANNEL_1, ADC_SAMPLETIME_55POINT5);
    adc_routine_channel_config(ADC0, 2, ADC_CHANNEL_2, ADC_SAMPLETIME_55POINT5);
    adc_routine_channel_config(ADC0, 3, ADC_CHANNEL_3, ADC_SAMPLETIME_55POINT5);
    adc_routine_channel_config(ADC0, 4, ADC_CHANNEL_4, ADC_SAMPLETIME_55POINT5);
    adc_routine_channel_config(ADC0, 5, ADC_CHANNEL_5, ADC_SAMPLETIME_55POINT5);
    adc_routine_channel_config(ADC0, 6, ADC_CHANNEL_6, ADC_SAMPLETIME_55POINT5);
    adc_routine_channel_config(ADC0, 7, ADC_CHANNEL_7, ADC_SAMPLETIME_55POINT5);

    adc_external_trigger_config(ADC0, ADC_ROUTINE_CHANNEL, ENABLE);

    /* ADC discontinuous mode */
    adc_discontinuous_mode_config(ADC0, ADC_ROUTINE_CHANNEL, 3);

    /* enable ADC interface */
    adc_enable(ADC0);
    delay_1ms(1);
    /* ADC calibration and reset calibration */
    adc_calibration_enable(ADC0);
}

void exti_config(void)
{
    /* connect EXTI line to GPIO pin for routine sequence */
    gpio_exti_source_select(GPIO_PORT_SOURCE_GPIOA, GPIO_PIN_SOURCE_11);
    /* configure EXTI line for routine sequence */
    exti_init(EXTI_11, EXTI_EVENT, EXTI_TRIG_RISING);
    exti_flag_clear(EXTI_11);
}

代码讲解

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

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

ADC 配置：选择采样通道、采样时间、触发方式、数据对齐方式。采样时间越长精度越高。

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

校准：ADC 使用前必须校准，消除工艺偏差。校准期间不要操作 ADC。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

GD32 ADC — ADC 分辨率配置

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

ADC — ADC 分辨率配置

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

功能简介

本示例演示 ADC 模数转换器的基本用法。ADC 将模拟电压信号转换为数字值，是读取传感器数据的关键外设。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

#include "gd32f30x.h"
#include "systick.h"
#include <stdio.h>
#include "gd32f307c_eval.h"
#define BOARD_ADC_CHANNEL   ADC_CHANNEL_13
#define ADC_GPIO_PORT_RCU   RCU_GPIOC
#define ADC_GPIO_PORT       GPIOC
#define ADC_GPIO_PIN        GPIO_PIN_3

void rcu_config(void);
void gpio_config(void);
void adc_config(void);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    /* system clocks configuration */
    rcu_config();
    /* systick configuration */
    systick_config();  
    /* GPIO configuration */
    gpio_config();
    /* ADC configuration */
    adc_config();
    /* configures COM port */
    gd_eval_com_init(EVAL_COM0); 

    adc_software_trigger_enable(ADC1, ADC_ROUTINE_CHANNEL);

    while(1){
        adc_flag_clear(ADC1, ADC_FLAG_EOC);
        while(SET != adc_flag_get(ADC1, ADC_FLAG_EOC)){
        }
        adc_value = ADC_RDATA(ADC1);        
        printf("6B: 0x%x\r\n", adc_value);
        printf("\r\n ***********************************\r\n");
        delay_1ms(500);
    }
}

void rcu_config(void)
{
    /* enable GPIOA clock */
    rcu_periph_clock_enable(ADC_GPIO_PORT_RCU);
    /* enable ADC1 clock */
    rcu_periph_clock_enable(RCU_ADC1);
    /* config ADC clock */
    rcu_adc_clock_config(RCU_CKADC_CKAPB2_DIV4);
}

void gpio_config(void)
{
    /* config the GPIO as analog mode */
    gpio_init(ADC_GPIO_PORT, GPIO_MODE_AIN, GPIO_OSPEED_MAX, ADC_GPIO_PIN);
}

void adc_config(void)
{
    /* ADC continuous function enable */
    adc_special_function_config(ADC1, ADC_CONTINUOUS_MODE, ENABLE);
    adc_special_function_config(ADC1, ADC_SCAN_MODE, DISABLE);
    /* ADC trigger config */
    adc_external_trigger_source_config(ADC1, ADC_ROUTINE_CHANNEL, ADC0_1_2_EXTTRIG_ROUTINE_NONE); 
    /* ADC data alignment config */
    adc_data_alignment_config(ADC1, ADC_DATAALIGN_RIGHT);
    /* ADC mode config */
    adc_mode_config(ADC_MODE_FREE); 
    /* ADC channel length config */
    adc_channel_length_config(ADC1, ADC_ROUTINE_CHANNEL, 1);

    /* ADC routine channel config */
    adc_routine_channel_config(ADC1, 0, BOARD_ADC_CHANNEL, ADC_SAMPLETIME_55POINT5);
    adc_external_trigger_config(ADC1, ADC_ROUTINE_CHANNEL, ENABLE);

    /* ADC resolusion 6B */
    adc_resolution_config(ADC1, ADC_RESOLUTION_6B);  

    /* enable ADC interface */
    adc_enable(ADC1);
    delay_1ms(1);
    /* ADC calibration and reset calibration */
    adc_calibration_enable(ADC1);
}

代码讲解

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

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

ADC 配置：选择采样通道、采样时间、触发方式、数据对齐方式。采样时间越长精度越高。

校准：ADC 使用前必须校准，消除工艺偏差。校准期间不要操作 ADC。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

GD32 ADC — ADC 过采样

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

ADC — ADC 过采样

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

功能简介

本示例演示 ADC 模数转换器的基本用法。ADC 将模拟电压信号转换为数字值，是读取传感器数据的关键外设。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

#include "gd32f30x.h"
#include "systick.h"
#include <stdio.h>
#include "gd32f307c_eval.h"
#define BOARD_ADC_CHANNEL   ADC_CHANNEL_13
#define ADC_GPIO_PORT_RCU   RCU_GPIOC
#define ADC_GPIO_PORT       GPIOC
#define ADC_GPIO_PIN        GPIO_PIN_3

void rcu_config(void);
void gpio_config(void);
void adc_config(void);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    /* system clocks configuration */
    rcu_config();
    /* systick configuration */
    systick_config();
    /* GPIO configuration */
    gpio_config();
    /* ADC configuration */
    adc_config();
    /* configures COM port */
    gd_eval_com_init(EVAL_COM0); 

    adc_software_trigger_enable(ADC1, ADC_ROUTINE_CHANNEL);

    while(1){
        adc_flag_clear(ADC1, ADC_FLAG_EOC);
        while(SET != adc_flag_get(ADC1, ADC_FLAG_EOC)){
        }

        adc_value = ADC_RDATA(ADC1);
        printf("16 times sample, 4 bits shift: 0x%x\r\n", adc_value);
        delay_1ms(500);
    }
}

void rcu_config(void)
{
    /* enable GPIOA clock */
    rcu_periph_clock_enable(ADC_GPIO_PORT_RCU);
    /* enable ADC1 clock */
    rcu_periph_clock_enable(RCU_ADC1);
    /* config ADC clock */
    rcu_adc_clock_config(RCU_CKADC_CKAPB2_DIV4);
}

void gpio_config(void)
{
    /* config the GPIO as analog mode */
    gpio_init(ADC_GPIO_PORT, GPIO_MODE_AIN, GPIO_OSPEED_MAX, ADC_GPIO_PIN);
}

void adc_config(void)
{
    /* ADC continuous function enable */
    adc_special_function_config(ADC1, ADC_CONTINUOUS_MODE, ENABLE);
    adc_special_function_config(ADC1, ADC_SCAN_MODE, DISABLE);
    /* ADC trigger config */
    adc_external_trigger_source_config(ADC1, ADC_ROUTINE_CHANNEL, ADC0_1_2_EXTTRIG_ROUTINE_NONE); 
    /* ADC data alignment config */
    adc_data_alignment_config(ADC1, ADC_DATAALIGN_RIGHT);
    /* ADC mode config */
    adc_mode_config(ADC_MODE_FREE); 
    /* ADC channel length config */
    adc_channel_length_config(ADC1, ADC_ROUTINE_CHANNEL, 1);

    /* ADC routine channel config */
    adc_routine_channel_config(ADC1, 0, BOARD_ADC_CHANNEL, ADC_SAMPLETIME_55POINT5);
    adc_external_trigger_config(ADC1, ADC_ROUTINE_CHANNEL, ENABLE);

    /* 16 times sample, 4 bits shift */
    adc_oversample_mode_config(ADC1, ADC_OVERSAMPLING_ALL_CONVERT, ADC_OVERSAMPLING_SHIFT_4B, ADC_OVERSAMPLING_RATIO_MUL16);
    adc_oversample_mode_enable(ADC1);

    /* enable ADC interface */
    adc_enable(ADC1);
    delay_1ms(1);
    /* ADC calibration and reset calibration */
    adc_calibration_enable(ADC1);
}

代码讲解

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

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

ADC 配置：选择采样通道、采样时间、触发方式、数据对齐方式。采样时间越长精度越高。

校准：ADC 使用前必须校准，消除工艺偏差。校准期间不要操作 ADC。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

GD32 ADC — ADC 模拟看门狗

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

ADC — ADC 模拟看门狗

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

功能简介

本示例演示 ADC 模拟看门狗功能。当 ADC 采样值超出设定的高低阈值范围时，自动触发中断报警。常用于过压/欠压保护场景。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

#include "gd32f30x.h"
#include "systick.h"
#include <stdio.h>
#include "gd32f307c_eval.h"
#define BOARD_ADC_CHANNEL   ADC_CHANNEL_13
#define ADC_GPIO_PORT_RCU   RCU_GPIOC
#define ADC_GPIO_PORT       GPIOC
#define ADC_GPIO_PIN        GPIO_PIN_3
#define ADC_WATCHDOG_HT     0x0A00
#define ADC_WATCHDOG_LT     0x0400

void rcu_config(void);
void gpio_config(void);
void nvic_config(void);
void adc_config(void);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    /* system clocks configuration */
    rcu_config();
    /* systick configuration */
    systick_config();
    /* GPIO configuration */
    gpio_config();
    /* configure COM port */
    gd_eval_com_init(EVAL_COM0);
    /* NVIC configuration */
    nvic_config();
    /* ADC configuration */
    adc_config();

    while(1){
        delay_1ms(1000);
        adc_value = adc_routine_data_read(ADC1);
        printf("\r\n ADC1 watchdog low threshold: %04X \r\n",ADC_WATCHDOG_LT);
        printf("\r\n ADC1 watchdog hgih threshold: %04X \r\n",ADC_WATCHDOG_HT);
        printf("\r\n ADC1 routine channel data = %04X \r\n",adc_value);
        printf("\r\n ***********************************\r\n");
        if(1 == data){
            /* turn off LED2 */
            if((adc_value < ADC_WATCHDOG_HT) && (adc_value > ADC_WATCHDOG_LT)){
                data = 0;
                gd_eval_led_off(LED2);
            }
        }
    }
}

void rcu_config(void)
{
    /* enable GPIOA clock */
    rcu_periph_clock_enable(ADC_GPIO_PORT_RCU);
    /* enable ADC1 clock */
    rcu_periph_clock_enable(RCU_ADC1);
    /* config ADC clock */
    rcu_adc_clock_config(RCU_CKADC_CKAPB2_DIV4);
}

void gpio_config(void)
{
    /* configure led GPIO */
    gd_eval_led_init(LED2);
    /* config the GPIO as analog mode */
    gpio_init(ADC_GPIO_PORT, GPIO_MODE_AIN, GPIO_OSPEED_MAX, ADC_GPIO_PIN);
}

void nvic_config(void)
{
    nvic_priority_group_set(NVIC_PRIGROUP_PRE2_SUB2);
    nvic_irq_enable(ADC0_1_IRQn, 0, 0);
}

void adc_config(void)
{
    /* ADC continuous function enable */
    adc_special_function_config(ADC1, ADC_CONTINUOUS_MODE, ENABLE);
    adc_special_function_config(ADC1, ADC_SCAN_MODE, DISABLE);
    /* ADC trigger config */
    adc_external_trigger_source_config(ADC1, ADC_ROUTINE_CHANNEL, ADC0_1_2_EXTTRIG_ROUTINE_NONE); 
    /* ADC data alignment config */
    adc_data_alignment_config(ADC1, ADC_DATAALIGN_RIGHT);
    /* ADC mode config */
    adc_mode_config(ADC_MODE_FREE); 
    /* ADC channel length config */
    adc_channel_length_config(ADC1, ADC_ROUTINE_CHANNEL, 1);

    /* ADC routine channel config */
    adc_routine_channel_config(ADC1, 0, BOARD_ADC_CHANNEL, ADC_SAMPLETIME_55POINT5);

    adc_external_trigger_config(ADC1, ADC_ROUTINE_CHANNEL, ENABLE);

    /* enable ADC interface */
    adc_enable(ADC1);
    delay_1ms(1);
    /* ADC calibration and reset calibration */
    adc_calibration_enable(ADC1);

    /* ADC analog watchdog threshold config */
    adc_watchdog_threshold_config(ADC1, ADC_WATCHDOG_LT, ADC_WATCHDOG_HT);
    /* ADC analog watchdog single channel config */
    adc_watchdog_single_channel_enable(ADC1, BOARD_ADC_CHANNEL);
    /* ADC interrupt config */
    adc_interrupt_enable(ADC1, ADC_INT_WDE);

    /* ADC software trigger enable */
    adc_software_trigger_enable(ADC1, ADC_ROUTINE_CHANNEL);
}

代码讲解

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

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

ADC 配置：选择采样通道、采样时间、触发方式、数据对齐方式。采样时间越长精度越高。

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

校准：ADC 使用前必须校准，消除工艺偏差。校准期间不要操作 ADC。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

GD32 ADC — ADC 软件触发轮询

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

ADC — ADC 软件触发轮询

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

功能简介

这是 ADC 的入门第一课，也是最容易看懂的一种 ADC 用法。

程序用 ADC0 依次采集 4 路模拟电压（PA1、PA2、PA3、PA4），把结果存到 adc_value[4] 数组里，然后不停地重复。

标题里三个关键词，拆开看：

关键词	含义
软件触发	转换不是由定时器或外部信号启动的，而是我们在程序里调用一个函数手动"发令"
常规通道	用的是常规组（Routine），相对于优先级更高的注入组（Inserted）
轮询	发令之后，CPU 在 `while` 里死等标志位，等到了就读数据（不用中断、不用 DMA）

为什么先学这个？ 因为它把 ADC 的完整流程一步不省地摊开在你眼前：

`1`	`配时钟 → 配引脚 → 配 ADC → 校准 → 选通道 → 发令 → 等完成 → 读数`

后面所有更高级的用法（DMA 自动搬运、定时器触发、双 ADC 并行），都只是把上面某几步换成硬件自动完成而已。先把手动流程走通，再去理解自动化才不会一头雾水。

硬件准备

器材	说明
GD32307C-EVAL-V1.1 开发板	或任意 GD32F30x 板子
电位器（可调电阻）1~4 个	10kΩ 卧式电位器，几毛钱一个
杜邦线	接线用
调试器（GD-Link / J-Link）	需要用 Watch 窗口看变量

使用的引脚

ADC 通道	引脚
`ADC_CHANNEL_1`	PA1
`ADC_CHANNEL_2`	PA2
`ADC_CHANNEL_3`	PA3
`ADC_CHANNEL_4`	PA4

通道号和引脚号的对应关系：GD32F30x 上 ADC 通道 0~~7 对应 PA0~~PA7，通道 8~~9 对应 PB0~~PB1，通道 10~~15 对应 PC0~~PC5。所以 ADC_CHANNEL_1 = PA1，规律很好记。

电位器接线

        3.3V
         │
        ┌┴┐
        │ │  ← 电位器（10kΩ）
        │ ├──────→ PA1（中间的滑动端接 ADC 引脚）
        │ │
        └┬┘
         │
        GND

旋转旋钮，中间抽头的电压就在 0V ~ 3.3V 之间连续变化，ADC 读数在 0 ~ 4095 之间跟着变。这是验证 ADC 是否正常工作的最直观办法。

如果暂时没有电位器，也可以：

直接把引脚接 GND → 读数应该接近 0
直接把引脚接 3.3V → 读数应该接近 4095
什么都不接（悬空）→ 读数会乱跳，这是正常现象（悬空引脚电压不确定）

完整代码

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

/* 存放 4 个通道的采样结果
   __IO 是 volatile 的宏，告诉编译器"这个变量可能被意外修改，
   不要做优化"。这样调试器的 Watch 窗口才能看到实时变化 */
__IO uint16_t adc_value[4];

void rcu_config(void);
void gpio_config(void);
void adc_config(void);
uint16_t adc_channel_sample(uint8_t channel);

/*!
    \brief      主函数
    \param[in]  无
    \param[out] 无
    \retval     无
*/
int main(void)
{
    /* 1. 时钟配置：开 GPIOA、ADC0 时钟，并给 ADC 分频 */
    rcu_config();
    /* 2. SysTick 配置，为了后面 delay_1ms 能用 */
    systick_config();
    /* 3. GPIO 配置：把 4 个引脚配成模拟输入 */
    gpio_config();
    /* 4. ADC 配置：模式、对齐、触发源、使能、校准 */
    adc_config();

    while(1){
        /* 依次采集 4 个通道，每采完一个立刻存进数组
           注意：必须一个一个来，因为常规组只有一个数据寄存器 */
        adc_value[0] = adc_channel_sample(ADC_CHANNEL_1);   /* PA1 */
        adc_value[1] = adc_channel_sample(ADC_CHANNEL_2);   /* PA2 */
        adc_value[2] = adc_channel_sample(ADC_CHANNEL_3);   /* PA3 */
        adc_value[3] = adc_channel_sample(ADC_CHANNEL_4);   /* PA4 */
    }
}

/*!
    \brief      配置各个系统时钟
    \param[in]  无
    \param[out] 无
    \retval     无
*/
void rcu_config(void)
{
    /* 开 GPIOA 时钟 —— PA1~PA4 属于 GPIOA */
    rcu_periph_clock_enable(RCU_GPIOA);
    /* 开 ADC0 外设时钟 */
    rcu_periph_clock_enable(RCU_ADC0);
    /* 配置 ADC 时钟分频：APB2(120MHz) / 6 = 20MHz
       ADC 时钟不能太高，手册推荐不超过 14MHz */
    rcu_adc_clock_config(RCU_CKADC_CKAPB2_DIV6);
}

/*!
    \brief      配置 GPIO
    \param[in]  无
    \param[out] 无
    \retval     无
*/
void gpio_config(void)
{
    /* 把 PA1~PA4 全部配成 AIN（Analog IN，模拟输入）模式
       这个模式会断开引脚上的数字输入电路和上下拉电阻，
       让引脚"纯净"地把电压送给 ADC */
    gpio_init(GPIOA, GPIO_MODE_AIN, GPIO_OSPEED_10MHZ, GPIO_PIN_1);
    gpio_init(GPIOA, GPIO_MODE_AIN, GPIO_OSPEED_10MHZ, GPIO_PIN_2);
    gpio_init(GPIOA, GPIO_MODE_AIN, GPIO_OSPEED_10MHZ, GPIO_PIN_3);
    gpio_init(GPIOA, GPIO_MODE_AIN, GPIO_OSPEED_10MHZ, GPIO_PIN_4);
}

/*!
    \brief      配置 ADC 外设
    \param[in]  无
    \param[out] 无
    \retval     无
*/
void adc_config(void)
{
    /* 独立模式：ADC0 自己单独工作，不和 ADC1 联动 */
    adc_mode_config(ADC_MODE_FREE);

    /* 数据右对齐：12 位结果放在 16 位寄存器的低 12 位
       读出来直接就是 0~4095，不用移位 */
    adc_data_alignment_config(ADC0, ADC_DATAALIGN_RIGHT);

    /* 常规组序列长度设为 1：一次只转换 1 个通道
       因为常规组只有一个数据寄存器，转多个会互相覆盖 */
    adc_channel_length_config(ADC0, ADC_ROUTINE_CHANNEL, 1U);

    /* 外部触发源设为 NONE：不使用定时器/引脚触发 */
    adc_external_trigger_source_config(ADC0, ADC_ROUTINE_CHANNEL,
                                       ADC0_1_2_EXTTRIG_ROUTINE_NONE);
    /* 使能外部触发通路 —— 这句必须有！
       软件触发在硬件上也走"外部触发"这条路，
       只是触发源选成了 NONE（即 SWRCST 软件触发） */
    adc_external_trigger_config(ADC0, ADC_ROUTINE_CHANNEL, ENABLE);

    /* 使能 ADC0 */
    adc_enable(ADC0);
    /* 等 ADC 上电稳定（手册要求 tSTAB，至少 1μs，这里给 1ms 足够宽裕） */
    delay_1ms(1U);
    /* 启动校准，消除内部电容工艺偏差
       注意顺序：必须在 adc_enable 之后 */
    adc_calibration_enable(ADC0);
}

/*!
    \brief      采集指定通道的一次数据
    \param[in]  channel: 要采集的 ADC 通道号
    \param[out] 无
    \retval     该通道的 12 位转换结果（0~4095）
*/
uint16_t adc_channel_sample(uint8_t channel)
{
    /* 把要采的通道放到常规组序列的第 0 个位置，采样时间 7.5 个周期 */
    adc_routine_channel_config(ADC0, 0U, channel, ADC_SAMPLETIME_7POINT5);

    /* 发令：软件触发，启动这一次转换 */
    adc_software_trigger_enable(ADC0, ADC_ROUTINE_CHANNEL);

    /* 死等 EOC（End Of Conversion）标志置位，表示转换完成 */
    while(!adc_flag_get(ADC0, ADC_FLAG_EOC));

    /* 手动清除 EOC 标志，为下一次转换做准备 */
    adc_flag_clear(ADC0, ADC_FLAG_EOC);

    /* 读取常规组数据寄存器，返回结果 */
    return (adc_routine_data_read(ADC0));
}

代码分段讲解

第 1 段：`__IO` 到底是干什么的

`1`	`__IO uint16_t adc_value[4];`

__IO 在 GD32 头文件里定义为 volatile：

`1`	`#define __IO volatile`

为什么必须加 volatile？

编译器很"聪明"，它会做优化。看到 adc_value 这个数组被赋值之后从来没有被读取过，优化器会认为"这些赋值是没用的死代码"，直接删掉！结果就是你在调试器 Watch 窗口里看到的永远是 0。

加上 volatile 之后，等于告诉编译器：“这个变量的值可能会被程序之外的东西（调试器、中断、硬件）读写，你老老实实每次都真的去内存里存取，不许优化。”

实战规则：以下三种变量必须加 volatile：

会被中断服务函数修改，同时又在主循环里读的全局变量

映射到硬件寄存器的指针

只用于调试观察的变量（本例的情况）

忘加 volatile 导致的 bug 极其难查 —— 因为 Debug 版本（不优化）跑得好好的，一开 -O2 优化就出问题。

第 2 段：GPIO_MODE_AIN 和其他模式的本质区别

`1`	`gpio_init(GPIOA, GPIO_MODE_AIN, GPIO_OSPEED_10MHZ, GPIO_PIN_1);`

AIN = Analog IN，模拟输入模式。它跟数字输入模式（IN_FLOATING / IPU / IPD）在硬件上完全是两回事：

数字输入模式（IN_FLOATING）:
  引脚 ──┬── [施密特触发器] ── 数字输入寄存器（读 0 或 1）
         └── [上下拉电阻网络]         ← 这些电路会影响模拟电压！
         └── [ESD 保护]

模拟输入模式（AIN）:
  引脚 ──┬── [直连] ─────────── ADC 采样开关 ── 采样电容
         └── 施密特触发器已关断，上下拉已断开

关键点：AIN 模式会关掉施密特触发器和上下拉电阻。这两个东西对数字信号无害，但对模拟测量是灾难：

施密特触发器一直在耗电（漏电流），会拉偏被测电压
上下拉电阻（约 40kΩ）会和你的信号源形成分压，读数直接错

新手常见错误：配成 GPIO_MODE_IN_FLOATING 也能读到数，但读数会有偏差（尤其信号源内阻大时）。所以ADC 引脚必须配 AIN，没有例外。

至于 GPIO_OSPEED_10MHZ 这个参数在 AIN 模式下是无意义的（引脚根本不输出），填什么都行，官方填 10MHz 只是习惯。

第 3 段：为什么"软件触发"要开"外部触发"

这是本例最容易让人困惑的一处：

1
2
3

adc_external_trigger_source_config(ADC0, ADC_ROUTINE_CHANNEL,
                                   ADC0_1_2_EXTTRIG_ROUTINE_NONE);
adc_external_trigger_config(ADC0, ADC_ROUTINE_CHANNEL, ENABLE);

明明是软件触发，为什么要配"外部触发源"还要 ENABLE？

原因在硬件设计上：GD32 的 ADC 内部只有一条"触发输入"通道。这条通道可以被连接到：

触发源选项	实际含义
`ADC0_1_2_EXTTRIG_ROUTINE_T0_CH0`	定时器 0 通道 0 事件
`ADC0_1_2_EXTTRIG_ROUTINE_T2_TRGO`	定时器 2 的 TRGO 事件
`ADC0_1_2_EXTTRIG_ROUTINE_EXTI_11`	外部中断线 11
`ADC0_1_2_EXTTRIG_ROUTINE_NONE`	不接任何硬件源，改由软件位 SWRCST 触发

所以逻辑是这样的：

adc_external_trigger_source_config(..., NONE) —— 把多路选择器拨到"软件"档
adc_external_trigger_config(..., ENABLE) —— 打开触发通道的总闸（ETERC 位）

如果第 2 句不写，总闸关着，无论你怎么调 adc_software_trigger_enable() 都不会启动转换。 程序会永远卡死在 while(!adc_flag_get(ADC0, ADC_FLAG_EOC)); 这一行。

这是新手实际会踩的坑。如果你自己精简代码把这句删了，就会遇到"程序卡死、ADC 不动"的现象。

第 4 段：序列长度为什么设成 1

`1`	`adc_channel_length_config(ADC0, ADC_ROUTINE_CHANNEL, 1U);`

“序列”（Sequence）是 ADC 常规组的一个重要概念。你可以配置一个最多 16 长的转换序列，比如：

1
2
3

序列位置 0 → 通道 3
序列位置 1 → 通道 7
序列位置 2 → 通道 1

配好之后触发一次，ADC 会按序列顺序把这 3 个通道都转一遍。

但问题来了：常规组只有一个 ADC_RDATA 数据寄存器。转完通道 3 结果放进去，接着转通道 7，结果又覆盖进去…… 最后你只能读到最后一个通道的值，前面全丢了。

所以只有两条路：

方案	做法	优缺点
本例的方案	序列长度设 1，每次只转一个通道，转完立刻读走，然后改通道再转	简单直观，CPU 全程参与
DMA 方案	序列长度设 4，开启扫描模式 + DMA，DMA 在每次 EOC 时自动把结果搬到数组	CPU 零参与，效率高，但配置复杂

本例用第一种，所以序列长度必须是 1，而且 adc_routine_channel_config() 的第二个参数（序列位置）永远填 0。

实际项目里多通道采集几乎都用 DMA 方案（参考 ADC0_routine_channel_with_DMA 示例）。但先理解本例的手动版本，你才知道 DMA 到底帮你省掉了什么。

第 5 段：一次完整采样的四步

uint16_t adc_channel_sample(uint8_t channel)
{
    adc_routine_channel_config(ADC0, 0U, channel, ADC_SAMPLETIME_7POINT5);  /* ① 选通道 */
    adc_software_trigger_enable(ADC0, ADC_ROUTINE_CHANNEL);                 /* ② 发令 */
    while(!adc_flag_get(ADC0, ADC_FLAG_EOC));                               /* ③ 等完成 */
    adc_flag_clear(ADC0, ADC_FLAG_EOC);                                     /* ④ 清标志 */
    return (adc_routine_data_read(ADC0));                                   /* ⑤ 读数据 */
}

① 选通道 —— adc_routine_channel_config(ADC0, 0U, channel, ADC_SAMPLETIME_7POINT5)

四个参数：ADC 编号、序列位置（这里固定 0）、通道号、采样时间。

每次调用都重新设置一次，所以同一个函数可以采任意通道 —— 这就是函数复用的巧妙之处。

② 发令 —— adc_software_trigger_enable()

内部就是往控制寄存器的 SWRCST 位写 1。硬件看到这一位就开始干活：先接通对应引脚的采样开关给电容充电（持续 7.5 个 ADC 周期），然后断开开关做 12 次逐次逼近比较，最后把结果写进 ADC_RDATA。

③ 等完成 —— while(!adc_flag_get(ADC0, ADC_FLAG_EOC))

EOC = End Of Conversion。硬件转换完成会自动把这一位置 1。

在 20MHz ADC 时钟、7.5 采样时间下，这个等待时间是：

`1`	`(7.5 + 12.5) / 20MHz = 1 μs`

也就是说 CPU 大约白等 1 微秒，采 4 个通道总共 4 微秒。对于点灯级应用完全可以接受。

④ 清标志

有个容易忽略的细节：读 ADC_RDATA 寄存器本身也会自动清除 EOC 标志。所以理论上第④步是多余的。但显式写出来更清晰、更保险（万一你改代码把 read 挪走了呢），是好的编程习惯。

⑤ 读数据 —— adc_routine_data_read(ADC0)

返回的就是 0~4095 的原始码值。

第 6 段：主循环里数据是怎么流动的

while(1){
    adc_value[0] = adc_channel_sample(ADC_CHANNEL_1);
    adc_value[1] = adc_channel_sample(ADC_CHANNEL_2);
    adc_value[2] = adc_channel_sample(ADC_CHANNEL_3);
    adc_value[3] = adc_channel_sample(ADC_CHANNEL_4);
}

时序图（每格约 1μs）：

时间 →
│ 采PA1 │ 采PA2 │ 采PA3 │ 采PA4 │ 采PA1 │ 采PA2 │ ...
   ↓       ↓       ↓       ↓
 [0]     [1]     [2]     [3]

注意这个循环转得极快：4 次采样加上函数调用开销，一轮大约 5~10 微秒，也就是每秒刷新 10 万次以上。

这对于测量慢变化的物理量（温度、电位器位置）是巨大的浪费，而且会让读数因为噪声而抖动。实际项目应该加延时并做滤波：

while(1){
    adc_value[0] = adc_channel_sample(ADC_CHANNEL_1);
    /* ...其他通道... */
    delay_1ms(100);       /* 每 100ms 采一轮就够了 */
}

实验现象

本例程没有任何 LED 或串口输出，必须用调试器观察。

用 Keil 的 Watch 窗口看

编译下载后，点击 Debug → Start/Stop Debug Session（或按 Ctrl+F5）。
点击 Run（F5）让程序跑起来。
打开 View → Watch Windows → Watch 1。
在 Watch 窗口里输入 adc_value，回车。
展开数组，就能看到 4 个通道的实时值。
转动接在 PA1 上的电位器，adc_value[0] 的数值会跟着变化。

预期看到的数值：

电位器位置	`adc_value[0]`	对应电压
旋到底（接 GND）	0 ~ 20	约 0V
中间	约 2048	约 1.65V
旋到顶（接 3.3V）	4070 ~ 4095	约 3.3V

Keil 小技巧：勾选 View → Periodic Window Update，Watch 窗口才会在程序运行时持续刷新。不勾的话只有暂停时才更新数值，看起来像"数据不变"。

更直观的办法：加串口打印

强烈建议自己改一版加上 printf，看起来爽多了：

#include "gd32f307c_eval.h"

int main(void)
{
    rcu_config();
    systick_config();
    gpio_config();
    adc_config();
    gd_eval_com_init(EVAL_COM0);         /* 初始化调试串口 */

    while(1){
        adc_value[0] = adc_channel_sample(ADC_CHANNEL_1);
        adc_value[1] = adc_channel_sample(ADC_CHANNEL_2);
        adc_value[2] = adc_channel_sample(ADC_CHANNEL_3);
        adc_value[3] = adc_channel_sample(ADC_CHANNEL_4);

        /* 同时打印原始码值和换算后的电压（mV，避免用浮点） */
        printf("CH1=%4d(%4dmV)  CH2=%4d  CH3=%4d  CH4=%4d\r\n",
               adc_value[0], adc_value[0] * 3300 / 4095,
               adc_value[1], adc_value[2], adc_value[3]);

        delay_1ms(500);
    }
}

串口助手输出：

1
2
3

CH1=2047(1649mV)  CH2=   3  CH3=1024  CH4=4090
CH1=2531(2039mV)  CH2=   4  CH3=1023  CH4=4091
CH1=3102(2499mV)  CH2=   3  CH3=1025  CH4=4090

注意 adc_value[0] * 3300 / 4095 这个写法：先乘后除，全程整数运算，避免了浮点数的开销。这是嵌入式里换算电压的标准技巧。

小心溢出：adc_value 是 uint16_t，最大 4095，乘 3300 得到 13513500，超出了 uint16_t 范围。但因为 C 语言的整数提升规则，表达式会自动按 int（32 位）计算，所以这里是安全的。如果乘的系数更大（比如 33000），就要显式转成 uint32_t。

常见问题

Q1：程序卡死在 `while(!adc_flag_get(ADC0, ADC_FLAG_EOC));`

这是本例最高频的问题。EOC 永远不置位，说明转换根本没启动。按顺序检查：

少了 adc_external_trigger_config(ADC0, ADC_ROUTINE_CHANNEL, ENABLE); 前面详细讲过，这是触发通道的总闸。少了它软件触发无效。这是最常见的原因。
忘了 rcu_periph_clock_enable(RCU_ADC0); 外设时钟没开，所有 ADC 寄存器写进去都是无效的。
忘了 adc_enable(ADC0); ADC 没使能，硬件处于关断状态。
忘了 rcu_adc_clock_config() ADC 时钟源没配。虽然有默认值，但显式配置是好习惯。
改用了注入组的宏但 flag 还查常规组的 如果你把 ADC_ROUTINE_CHANNEL 改成了 ADC_INSERTED_CHANNEL，那 flag 也要改成 ADC_FLAG_EOIC。

Q2：读数一直是 0 或一直是 4095

读数恒为 0：

引脚没接信号，或者接到了 GND
引脚模式配错（没配成 GPIO_MODE_AIN）
通道号和引脚对不上（比如想采 PA1 但填了 ADC_CHANNEL_0）
GPIOA 时钟没开

读数恒为 4095：

输入电压超过了 VREF+（通常等于 VDDA = 3.3V）。注意 ADC 引脚绝对不能超过 VDD + 0.3V，否则会烧片！
引脚接错，接到了 3.3V

Q3：读数不停跳动，跳几十个数

这是 ADC 最典型的"精度"问题，几乎人人会遇到。按性价比从高到低排：

① 加大采样时间（改一行，立竿见影）

`1`	`adc_routine_channel_config(ADC0, 0U, channel, ADC_SAMPLETIME_239POINT5);`

信号源内阻大时（热敏电阻、高阻分压），采样电容充不满，读数就会偏低且不稳。加大采样时间是第一选择。

② 降低 ADC 时钟

`1`	`rcu_adc_clock_config(RCU_CKADC_CKAPB2_DIV12); /* 120/12 = 10MHz，符合 ≤14MHz 要求 */`

原代码用 DIV6 得到 20MHz，已经超出手册推荐值。降到 10MHz 精度会明显改善。

③ 软件滤波（最有效的手段）

最简单的多次平均：

uint16_t adc_average_sample(uint8_t channel, uint8_t times)
{
    uint32_t sum = 0;
    uint8_t i;
    for(i = 0; i < times; i++){
        sum += adc_channel_sample(channel);
    }
    return (uint16_t)(sum / times);
}

/* 使用：采 16 次取平均 */
adc_value[0] = adc_average_sample(ADC_CHANNEL_1, 16);

更抗突发干扰的去极值平均（掐头去尾法）：

uint16_t adc_filter_sample(uint8_t channel)
{
    uint16_t buf[10];
    uint16_t max = 0, min = 0xFFFF;
    uint32_t sum = 0;
    uint8_t i;

    /* 连续采 10 次 */
    for(i = 0; i < 10; i++){
        buf[i] = adc_channel_sample(channel);
        sum += buf[i];
        if(buf[i] > max) max = buf[i];      /* 记录最大值 */
        if(buf[i] < min) min = buf[i];      /* 记录最小值 */
    }
    /* 去掉一个最高分、去掉一个最低分，剩下 8 个取平均 */
    return (uint16_t)((sum - max - min) / 8);
}

这个算法能有效滤掉偶发的尖峰干扰，是工程上非常实用的一招。

④ 硬件滤波

在 ADC 引脚和 GND 之间并一个 100nF 陶瓷电容。这是最便宜也最有效的措施，几乎所有正规产品的 ADC 输入都会加这个电容。

⑤ 检查 VREF 和布线

VREF+ 引脚要接干净的 3.3V，加 100nF + 1μF 去耦电容
模拟地（VSSA）和数字地要在一点汇合（单点接地）
ADC 信号线远离时钟线、PWM 输出线、开关电源

Q4：想读芯片内部温度怎么办

内部温度传感器接在 ADC_CHANNEL_16 上，需要额外使能：

/* 使能内部温度传感器和 VREFINT 通道 */
adc_tempsensor_vrefint_enable();

/* 采集温度通道，采样时间必须给足（手册要求 ≥17.1μs） */
uint16_t temp_raw = adc_channel_sample_with_time(ADC_CHANNEL_16,
                                                 ADC_SAMPLETIME_239POINT5);

/* 换算成摄氏度
   GD32F30x 手册给的公式：
   T(°C) = (V25 - Vsense) / Avg_Slope + 25
   其中 V25 = 1.43V（25°C 时的电压），Avg_Slope = 4.3mV/°C */
float v_sense = temp_raw * 3.3f / 4095.0f;
float temperature = (1.43f - v_sense) / 0.0043f + 25.0f;
printf("chip temp = %d.%d C\r\n", (int)temperature,
       (int)(temperature * 10) % 10);

别指望它测环境温度。这个传感器测的是芯片内部结温，会比环境温度高 5~15°C（取决于芯片负载），而且不同芯片个体差异能到 ±10°C。它的正确用途是监测芯片是否过热，或者做温度变化的相对判断，不能当温度计用。

Q5：4 个通道能不能一次全采完，不要一个个来？

可以，这就是扫描模式 + DMA 的方案。核心改动：

void adc_config_dma_version(void)
{
    dma_parameter_struct dma_init_struct;

    rcu_periph_clock_enable(RCU_DMA0);

    /* --- ADC 部分：序列长度改成 4，开扫描模式和连续模式 --- */
    adc_mode_config(ADC_MODE_FREE);
    adc_data_alignment_config(ADC0, ADC_DATAALIGN_RIGHT);
    adc_channel_length_config(ADC0, ADC_ROUTINE_CHANNEL, 4U);      /* 4 个通道 */

    /* 把 4 个通道依次排进序列的 0/1/2/3 位置 */
    adc_routine_channel_config(ADC0, 0U, ADC_CHANNEL_1, ADC_SAMPLETIME_55POINT5);
    adc_routine_channel_config(ADC0, 1U, ADC_CHANNEL_2, ADC_SAMPLETIME_55POINT5);
    adc_routine_channel_config(ADC0, 2U, ADC_CHANNEL_3, ADC_SAMPLETIME_55POINT5);
    adc_routine_channel_config(ADC0, 3U, ADC_CHANNEL_4, ADC_SAMPLETIME_55POINT5);

    adc_special_function_config(ADC0, ADC_SCAN_MODE, ENABLE);        /* 扫描模式 */
    adc_special_function_config(ADC0, ADC_CONTINUOUS_MODE, ENABLE);  /* 连续转换 */

    /* --- DMA 部分：外设(ADC_RDATA) → 内存(adc_value 数组) --- */
    dma_deinit(DMA0, DMA_CH0);
    dma_init_struct.direction    = DMA_PERIPHERAL_TO_MEMORY;
    dma_init_struct.periph_addr  = (uint32_t)(&ADC_RDATA(ADC0));
    dma_init_struct.periph_inc   = DMA_PERIPH_INCREASE_DISABLE;   /* 外设地址不变 */
    dma_init_struct.periph_width = DMA_PERIPHERAL_WIDTH_16BIT;
    dma_init_struct.memory_addr  = (uint32_t)adc_value;
    dma_init_struct.memory_inc   = DMA_MEMORY_INCREASE_ENABLE;    /* 内存地址自增 */
    dma_init_struct.memory_width = DMA_MEMORY_WIDTH_16BIT;
    dma_init_struct.number       = 4U;
    dma_init_struct.priority     = DMA_PRIORITY_HIGH;
    dma_init(DMA0, DMA_CH0, &dma_init_struct);

    dma_circulation_enable(DMA0, DMA_CH0);      /* 循环模式：搬完 4 个自动回到开头 */
    dma_channel_enable(DMA0, DMA_CH0);

    adc_dma_mode_enable(ADC0);                  /* ADC 每次 EOC 自动请求 DMA */

    adc_enable(ADC0);
    delay_1ms(1U);
    adc_calibration_enable(ADC0);
    adc_software_trigger_enable(ADC0, ADC_ROUTINE_CHANNEL);   /* 只需触发一次！ */
}

/* 主循环变成这样 —— 什么都不用做，随时读数组就有最新值 */
int main(void)
{
    /* ... 初始化 ... */
    adc_config_dma_version();
    while(1){
        printf("%d %d %d %d\r\n", adc_value[0], adc_value[1],
                                  adc_value[2], adc_value[3]);
        delay_1ms(500);
    }
}

这就是实际项目的标准写法：配置一次，之后 ADC + DMA 在后台自动持续采集刷新数组，CPU 完全解放。详细讲解见本模块的 ADC0_routine_channel_with_DMA 示例。

Q6：怎么提高精度到 12 位以上？

用过采样。原理是采样 N 次求和后右移，利用噪声的随机性提高有效位数：

采 4 次求和右移 1 位 → 等效 13 位
采 16 次求和右移 2 位 → 等效 14 位
采 64 次求和右移 3 位 → 等效 15 位
采 256 次求和右移 4 位 → 等效 16 位

GD32F30x 部分型号有硬件过采样器，配置一次就自动完成，见 ADC1_oversample_shift 示例。没有硬件支持的型号可以软件实现：

/* 软件 16 倍过采样，等效 14 位精度 */
uint16_t adc_oversample_14bit(uint8_t channel)
{
    uint32_t sum = 0;
    uint8_t i;
    for(i = 0; i < 16; i++){
        sum += adc_channel_sample(channel);
    }
    return (uint16_t)(sum >> 2);      /* 求和后右移 2 位，得到 0~16383 */
}

过采样有效的前提是噪声是随机白噪声。如果是 50Hz 工频串扰这种周期性干扰，过采样帮助有限，得靠屏蔽和硬件滤波。

小结

知识点	要记住的核心
ADC 引脚模式	必须 `GPIO_MODE_AIN`，不是 `IN_FLOATING`
ADC 时钟	必须用 `rcu_adc_clock_config()` 分频，推荐 ≤14MHz
三套时钟	GPIO 时钟 + ADC 外设时钟 + ADC 时钟分频，都要配
软件触发也要开 ETERC	`adc_external_trigger_config(..., ENABLE)` 少不了
使能后必须延时再校准	`adc_enable()` → `delay` → `adc_calibration_enable()`，顺序不能错
常规组只有一个数据寄存器	多通道要么一个个手动读，要么用 DMA
`volatile`	只用于调试观察的变量必须加，否则会被优化掉
电压换算	`mV = code * 3300 / 4095`，先乘后除全整数运算
读数跳动	加大采样时间 → 降低 ADC 时钟 → 软件滤波 → 加 100nF 电容

ADC 采样七步曲：

1. rcu_periph_clock_enable(RCU_GPIOA);          /* GPIO 时钟 */
2. rcu_periph_clock_enable(RCU_ADC0);           /* ADC 时钟 */
3. rcu_adc_clock_config(RCU_CKADC_CKAPB2_DIV6); /* ADC 分频 */
4. gpio_init(..., GPIO_MODE_AIN, ...);          /* 引脚模拟输入 */
5. adc_mode_config / data_alignment / channel_length / trigger  /* 参数 */
6. adc_enable() → delay_1ms(1) → adc_calibration_enable()       /* 使能校准 */
7. channel_config → software_trigger → wait EOC → data_read     /* 采样 */

拓展应用

学会 ADC，你就能读取现实世界的连续量了。可做的项目一下子多起来：

入门级（一个电位器就能玩）

数字电压表：把 ADC 读数换算成电压，通过串口或 OLED 显示。加个电阻分压网络（比如 10:1）就能测 0~33V，做一个万用表的电压档。
旋钮调光灯：电位器读数映射到 PWM 占空比，转旋钮就能无级调节 LED 亮度。这是 ADC + TIMER 的第一个综合应用。
光照检测夜灯：光敏电阻（LDR）和固定电阻串联分压，ADC 读电压判断明暗，天黑自动开灯。
电池电量指示：分压后测锂电池电压，映射成 4 格电量图标。注意锂电池 4.2V 超过 3.3V，必须先分压。
摇杆/游戏手柄读取：双轴摇杆本质就是两个电位器，读 X/Y 两路 ADC 就能得到方向和力度。

进阶级（配合传感器和算法）

NTC 热敏电阻测温：这是最常见的低成本测温方案。ADC 读分压电压 → 算出电阻值 → 查 B 值公式或分段查表得到温度。精度可到 ±0.5°C，比内部温度传感器强得多。

  /* NTC 分压电路：3.3V — R固定(10k) — NTC — GND，ADC 接 NTC 上端 */
  float r_ntc = 10000.0f * adc_val / (4095.0f - adc_val);
  /* B 值公式：1/T = 1/T0 + (1/B) * ln(R/R0) */
  /* T0=298.15K(25°C), R0=10000Ω, B=3950 */

土壤湿度 / 水位检测：电容式或电阻式传感器输出模拟量，ADC 直接读，做自动浇花系统。
压力/称重（配合 HX711 或运放）：应变片桥式输出几毫伏，经运放放大后 ADC 采集，做电子秤。这时 12 位精度可能不够，要用过采样或外置 24 位 ADC。
多路电压巡检仪：16 路 ADC + DMA 自动扫描，做配电柜多回路电压监测。
红外测距（Sharp GP2Y0A21）：这类传感器输出的电压和距离成反比曲线，查表插值后能得到 10~80cm 的距离值，做避障小车。
气体传感器（MQ 系列）：MQ-2 烟雾、MQ-7 一氧化碳等都是模拟输出，ADC 读浓度做报警器。

信号处理级

示波器：ADC + DMA + 定时器触发实现固定采样率采集，数据传到电脑上位机画波形。GD32F307 的 2.6MSPS 采样率能做到 1MHz 带宽，足够看 I2C/UART 波形。
音频采集与 FFT 频谱：麦克风模块输出经运放偏置到 1.65V 中心，ADC 以 8kHz 采样，做 256 点 FFT 得到频谱，实现声控开关、音乐律动灯、简易调音器。
交流电流检测（互感器）：电流互感器输出正弦波，快速采样一个周期后算 RMS 有效值，做智能插座功率计量。

  /* 采一个周期(50Hz=20ms)的数据算 RMS */
  uint32_t sum_sq = 0;
  for(i = 0; i < 200; i++){                      /* 200 点，每点 100μs */
      int16_t ac = adc_channel_sample(ch) - 2048;  /* 减去 1.65V 直流偏置 */
      sum_sq += ac * ac;
      delay_us(100);
  }
  /* rms = sqrt(sum_sq / 200) */

PID 闭环控制：ADC 读反馈量（温度、转速、位置）→ PID 计算 → PWM 输出执行。这是自动控制的核心闭环，做恒温箱、电机调速、平衡车都靠这个。

工业与安全级

过压/过流保护（模拟看门狗）：不用 CPU 参与，ADC 硬件自动比较上下限，超限立刻触发中断关断输出。响应时间可以做到微秒级，比软件判断快几个数量级。见 ADC1_analog_watchdog 示例。
电机 FOC 控制：双 ADC 并行模式在 PWM 中心点同时采样三相电流，配合 Clarke/Park 变换实现磁场定向控制。这是无刷电机高性能驱动的标准方案。
4-20mA 工业信号采集：工业传感器普遍用 4-20mA 电流环（抗干扰强、可远传）。经过一个精密电阻（如 165Ω）转成 0.66~3.3V 电压后 ADC 采集。

下一步该学什么：ADC0_routine_channel_with_DMA（多通道自动采集，实际项目标准做法）→ ADC0_temperature_Vref（读内部温度和参考电压）→ TIMER1_pwmout（学会 PWM 输出，就能做 ADC 读旋钮 → PWM 调光的完整闭环了）。

GD32 ADC — ADC 温度 & Vref

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

ADC — ADC 温度 & Vref

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

功能简介

本示例利用 MCU 内置的温度传感器，通过 ADC 采集并计算芯片当前温度。无需外部传感器，非常适合学习 ADC 的基本用法。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

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

void rcu_config(void);
void dma_config(void);
void adc_config(void);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    /* configure systick */
    systick_config();
    /* system clocks configuration */
    rcu_config();
    /* DMA configuration */
    dma_config();
    /* ADC configuration */
    adc_config();
    /* USART configuration */
    gd_eval_com_init(EVAL_COM0);

    while(1){
        /* delay a time in milliseconds */
        delay_1ms(2000);

        /* value convert */
        temperature = (1.43 - adc_value[0]*3.3/4096) * 1000 / 4.3 + 25;
        vref_value = (adc_value[1] * 3.3 / 4096);

        /* value print */
        printf(" the temperature data is %2.0f degrees Celsius\r\n", temperature);
        printf(" the reference voltage data is %5.3fV \r\n", vref_value);
        printf(" \r\n");
    }
}

void rcu_config(void)
{
    /* enable ADC clock */
    rcu_periph_clock_enable(RCU_ADC0);
    /* config ADC clock */
    rcu_adc_clock_config(RCU_CKADC_CKAPB2_DIV4);
    /* enable DMA0 clock */
    rcu_periph_clock_enable(RCU_DMA0);
}

void dma_config(void)
{
    /* ADC_DMA_channel configuration */
    dma_parameter_struct dma_data_parameter;

    /* ADC DMA_channel configuration */
    dma_deinit(DMA0, DMA_CH0);

    /* initialize DMA single data mode */
    dma_data_parameter.periph_addr  = (uint32_t)(&ADC_RDATA(ADC0));
    dma_data_parameter.periph_inc   = DMA_PERIPH_INCREASE_DISABLE;
    dma_data_parameter.memory_addr  = (uint32_t)(&adc_value);
    dma_data_parameter.memory_inc   = DMA_MEMORY_INCREASE_ENABLE;
    dma_data_parameter.periph_width = DMA_PERIPHERAL_WIDTH_16BIT;
    dma_data_parameter.memory_width = DMA_MEMORY_WIDTH_16BIT;
    dma_data_parameter.direction    = DMA_PERIPHERAL_TO_MEMORY;
    dma_data_parameter.number       = 2;
    dma_data_parameter.priority     = DMA_PRIORITY_HIGH;
    dma_init(DMA0, DMA_CH0, &dma_data_parameter);

    dma_circulation_enable(DMA0, DMA_CH0);

    /* enable DMA channel */
    dma_channel_enable(DMA0, DMA_CH0);
}

void adc_config(void)
{
    /* ADC mode config */
    adc_mode_config(ADC_MODE_FREE);
    /* ADC contineous function disable */
    adc_special_function_config(ADC0, ADC_CONTINUOUS_MODE, ENABLE);
    /* ADC scan mode disable */
    adc_special_function_config(ADC0, ADC_SCAN_MODE, ENABLE);
    /* ADC data alignment config */
    adc_data_alignment_config(ADC0, ADC_DATAALIGN_RIGHT);

    /* ADC channel length config */
    adc_channel_length_config(ADC0, ADC_ROUTINE_CHANNEL, 2);
    /* ADC temperature sensor channel config */
    adc_routine_channel_config(ADC0, 0, ADC_CHANNEL_16, ADC_SAMPLETIME_239POINT5);
    /* ADC internal reference voltage channel config */
    adc_routine_channel_config(ADC0, 1, ADC_CHANNEL_17, ADC_SAMPLETIME_239POINT5);

    /* ADC trigger config */
    adc_external_trigger_source_config(ADC0, ADC_ROUTINE_CHANNEL, ADC0_1_2_EXTTRIG_ROUTINE_NONE);
    adc_external_trigger_config(ADC0, ADC_ROUTINE_CHANNEL, ENABLE);

    /* ADC temperature and Vrefint enable */
    adc_tempsensor_vrefint_enable();

    /* ADC DMA function enable */
    adc_dma_mode_enable(ADC0);
    /* enable ADC interface */
    adc_enable(ADC0);
    delay_1ms(1);
    /* ADC calibration and reset calibration */
    adc_calibration_enable(ADC0);

    /* ADC software trigger enable */
    adc_software_trigger_enable(ADC0, ADC_ROUTINE_CHANNEL);
}

代码讲解

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

ADC 配置：选择采样通道、采样时间、触发方式、数据对齐方式。采样时间越长精度越高。

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

校准：ADC 使用前必须校准，消除工艺偏差。校准期间不要操作 ADC。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

GD32 ADC — 双 ADC 并行采集

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

ADC — 双 ADC 并行采集

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

功能简介

本示例演示 ADC 模数转换器的基本用法。ADC 将模拟电压信号转换为数字值，是读取传感器数据的关键外设。

硬件准备

电位器（可调电阻）连接到 ADC 输入引脚
或使用内部温度传感器（无需额外硬件）

完整代码

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

void rcu_config(void);
void gpio_config(void);
void dma_config(void);
void timer_config(void);
void adc_config(void);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    /* system clocks configuration */
    rcu_config();
    /* systick configuration */
    systick_config();  
    /* GPIO configuration */
    gpio_config();
    /* configure COM port */
    gd_eval_com_init(EVAL_COM0);
    /* TIMER configuration */
    timer_config();
    /* DMA configuration */
    dma_config();
    /* ADC configuration */
    adc_config();

    /* enable TIMER1 */
    timer_enable(TIMER1);

    while(1){
        delay_1ms(1000);
        printf("\n ADC0: PA0, adc_value[0] = %08X \n",adc_value[0]);
        printf("\n ADC1: PA1, adc_value[1] = %08X \n",adc_value[1]);
        printf("\n ******************* \n");
    }
}

void rcu_config(void)
{
    /* enable GPIOA clock */
    rcu_periph_clock_enable(RCU_GPIOA);
    /* enable ADC0 clock */
    rcu_periph_clock_enable(RCU_ADC0);
    /* enable ADC1 clock */
    rcu_periph_clock_enable(RCU_ADC1);  
    /* enable DMA0 clock */
    rcu_periph_clock_enable(RCU_DMA0);  
    /* enable timer1 clock */
    rcu_periph_clock_enable(RCU_TIMER1);
    /* config ADC clock */
    rcu_adc_clock_config(RCU_CKADC_CKAPB2_DIV4);
}

void gpio_config(void)
{
    /* config the GPIO as analog mode */
    gpio_init(GPIOA, GPIO_MODE_AIN, GPIO_OSPEED_MAX, GPIO_PIN_0|GPIO_PIN_1);
}

void dma_config(void)
{
    /* ADC_DMA_channel configuration */
    dma_parameter_struct dma_data_parameter;

    /* ADC DMA_channel configuration */
    dma_deinit(DMA0, DMA_CH0);

    /* initialize DMA data mode */
    dma_data_parameter.periph_addr = (uint32_t)(&ADC_RDATA(ADC0));
    dma_data_parameter.periph_inc = DMA_PERIPH_INCREASE_DISABLE;
    dma_data_parameter.memory_addr = (uint32_t)(&adc_value);
    dma_data_parameter.memory_inc = DMA_MEMORY_INCREASE_ENABLE;
    dma_data_parameter.periph_width = DMA_PERIPHERAL_WIDTH_32BIT;
    dma_data_parameter.memory_width = DMA_MEMORY_WIDTH_32BIT;
    dma_data_parameter.direction = DMA_PERIPHERAL_TO_MEMORY;
    dma_data_parameter.number = 2;
    dma_data_parameter.priority = DMA_PRIORITY_HIGH;
    dma_init(DMA0, DMA_CH0, &dma_data_parameter);

    dma_circulation_enable(DMA0, DMA_CH0);

    /* enable DMA channel */
    dma_channel_enable(DMA0, DMA_CH0);
}

void timer_config(void)
{
    timer_oc_parameter_struct timer_ocintpara;
    timer_parameter_struct timer_initpara;

    /* TIMER1 configuration */
    timer_initpara.prescaler         = 8399;
    timer_initpara.alignedmode       = TIMER_COUNTER_EDGE;
    timer_initpara.counterdirection  = TIMER_COUNTER_UP;
    timer_initpara.period            = 9999;
    timer_initpara.clockdivision     = TIMER_CKDIV_DIV1;
    timer_initpara.repetitioncounter = 0;
    timer_init(TIMER1,&timer_initpara);

    timer_channel_output_struct_para_init(&timer_ocintpara);
    /* CH0 configuration in PWM mode1 */
    timer_ocintpara.ocpolarity  = TIMER_OC_POLARITY_HIGH;
    timer_ocintpara.outputstate = TIMER_CCX_ENABLE;
    timer_channel_output_config(TIMER1, TIMER_CH_1, &timer_ocintpara);

    timer_channel_output_pulse_value_config(TIMER1, TIMER_CH_1, 3999);
    timer_channel_output_mode_config(TIMER1, TIMER_CH_1, TIMER_OC_MODE_PWM1);
    timer_channel_output_shadow_config(TIMER1, TIMER_CH_1, TIMER_OC_SHADOW_DISABLE);
}

void adc_config(void)
{
    /* ADC continous function enable */
    adc_special_function_config(ADC0, ADC_SCAN_MODE, ENABLE);
    adc_special_function_config(ADC0, ADC_CONTINUOUS_MODE, DISABLE);
    adc_special_function_config(ADC1, ADC_SCAN_MODE, ENABLE);
    adc_special_function_config(ADC1, ADC_CONTINUOUS_MODE, DISABLE);
    /* ADC trigger config */
    adc_external_trigger_source_config(ADC0, ADC_ROUTINE_CHANNEL, ADC0_1_EXTTRIG_ROUTINE_T1_CH1);
    adc_external_trigger_source_config(ADC1, ADC_ROUTINE_CHANNEL, ADC0_1_2_EXTTRIG_ROUTINE_NONE);
    /* ADC data alignment config */
    adc_data_alignment_config(ADC0, ADC_DATAALIGN_RIGHT);
    adc_data_alignment_config(ADC1, ADC_DATAALIGN_RIGHT);
    /* ADC mode config */
    adc_mode_config(ADC_DAUL_ROUTINE_PARALLEL); 
    /* ADC channel length config */
    adc_channel_length_config(ADC0, ADC_ROUTINE_CHANNEL, 2);
    adc_channel_length_config(ADC1, ADC_ROUTINE_CHANNEL, 2);

    /* ADC routine channel config */
    adc_routine_channel_config(ADC0, 0, ADC_CHANNEL_0, ADC_SAMPLETIME_55POINT5);
    adc_routine_channel_config(ADC0, 1, ADC_CHANNEL_1, ADC_SAMPLETIME_55POINT5);
    adc_routine_channel_config(ADC1, 0, ADC_CHANNEL_1, ADC_SAMPLETIME_55POINT5);
    adc_routine_channel_config(ADC1, 1, ADC_CHANNEL_0, ADC_SAMPLETIME_55POINT5);

    /* ADC external trigger enable */
    adc_external_trigger_config(ADC0, ADC_ROUTINE_CHANNEL, ENABLE);
    adc_external_trigger_config(ADC1, ADC_ROUTINE_CHANNEL, ENABLE);

    /* enable ADC interface */
    adc_enable(ADC0);
    delay_1ms(1);
    /* ADC calibration and reset calibration */
    adc_calibration_enable(ADC0);
    /* enable ADC interface */
    adc_enable(ADC1);
    delay_1ms(1);
    /* ADC calibration and reset calibration */
    adc_calibration_enable(ADC1);

    /* ADC DMA function enable */
    adc_dma_mode_enable(ADC0);
}

代码讲解

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

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

ADC 配置：选择采样通道、采样时间、触发方式、数据对齐方式。采样时间越长精度越高。

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

定时器配置：设置预分频器（PSC）和重装载值（ARR），定时时间 = (PSC+1) × (ARR+1) / 时钟频率。

PWM 配置：在定时器基础上设置比较值（CCR），占空比 = CCR / (ARR+1)。CCR 越大占空比越高。

校准：ADC 使用前必须校准，消除工艺偏差。校准期间不要操作 ADC。

实验现象

串口助手打印 ADC 采样值
转动电位器时数值变化
温度传感器示例会显示芯片温度

注意事项

ADC 参考电压影响测量精度
采样时间要根据信号源阻抗选择
使用前务必校准（Calibration）

GD32 BKP — 备份数据读写

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

BKP — 备份数据读写

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

功能简介

本示例演示 BKP 的基本用法。

完整代码

#include "gd32f30x.h"
#include "gd32f307c_eval.h"
#define  BKP_DATA_REG_NUM              42

void led_config(void);
void write_backup_register(uint16_t data);
uint32_t check_backup_register(uint16_t data);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    /* led configuration and turn on all led */
    led_config();
    /* PMU lock enable */
    rcu_periph_clock_enable(RCU_PMU);
    /* BKP clock enable */
    rcu_periph_clock_enable(RCU_BKPI);
    /* enable write access to the registers in backup domain */
    pmu_backup_write_enable();
    /* confirm RCU_BDCTL_BKPRST bit is reset */
    if(RESET != (RCU_BDCTL & RCU_BDCTL_BKPRST)){
        rcu_bkp_reset_disable();
    }
    /* clear the bit flag of tamper event */
    bkp_flag_clear(BKP_FLAG_TAMPER);
    
    /* check if the POR/PDR reset flag is set */
    if(RESET != rcu_flag_get(RCU_FLAG_PORRST)){
        /* clear the RCU all reset flags */
        rcu_all_reset_flag_clear();
        /* turn on LED4 */
        gd_eval_led_on(LED4);
        
        /* check if backup data registers has been written */
        if(0x00 == check_backup_register(0x1226)){
            /* Backup data registers values are correct */
            /* turn on LED2 */
            gd_eval_led_on(LED2);
        }else{
            /* backup data registers values are not correct or they are not written*/
            /* write data to backup data registers */
            write_backup_register(0x1226);
            /* turn on LED3 */
            gd_eval_led_on(LED3);
        }
    }
    /* turn on LED5 */
    gd_eval_led_on(LED5);;
    while(1){
    }
}

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

代码讲解

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

GD32 BKP — 入侵检测

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

BKP — 入侵检测

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

功能简介

本示例演示 BKP 的基本用法。

完整代码

#include "gd32f30x.h"
#include "gd32f307c_eval.h"
#define BKP_DATA_REG_NUM              42

void led_config(void);
void nvic_config(void);
void write_backup_register(uint16_t data);
uint32_t check_backup_register(uint16_t data);
    
/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    /* led configuration and turn on all led */
    led_config();
    /* NVIC configuration */
    nvic_config();
    /* PMU lock enable */
    rcu_periph_clock_enable(RCU_PMU);
    /* BKP clock enable */
    rcu_periph_clock_enable(RCU_BKPI);
    
    /* enable write access to the registers in backup domain */
    pmu_backup_write_enable();
    /* confirm RCU_BDCTL_BKPRST bit is reset */
    if(RESET != (RCU_BDCTL & RCU_BDCTL_BKPRST)){
        rcu_bkp_reset_disable();
    }
    /* tamper pin active level set */
    bkp_tamper_active_level_set(TAMPER_PIN_ACTIVE_LOW);
    /* tamper detection disable  */
    bkp_tamper_detection_disable();
    /* disable the tamper interrupt */
    bkp_tamper_interrupt_disable();
    /* clear the bit flag of tamper event */
    bkp_flag_clear(BKP_FLAG_TAMPER);
    /* configure the tamper pin active on low level, and enable the tamper pin */
    bkp_tamper_interrupt_enable();
    /* tamper detection enable  */
    bkp_tamper_detection_enable();
    /* write data to backup DATAx registers */
    write_backup_register(0x1226);
  
    /* check if the written data are correct */
    if(0x00 == check_backup_register(0x1226)){
        /* turn on LED2 */
        gd_eval_led_on(LED2);
    }else{
        /* turn on LED3 */
        gd_eval_led_on(LED3);
    }
    while(1){
    }
}

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

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

代码讲解

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

GD32 CAN — CAN 设备间通信

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

CAN — CAN 设备间通信

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

功能简介

本示例演示 CAN 总线通信。CAN 是汽车和工业领域最常用的现场总线，支持多主通信、错误检测和自动重传。

硬件准备

CAN 收发器模块（如 TJA1050、MCP2551）
自回环测试模式下可不接外部设备

完整代码

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

void nvic_config(void);
void led_config(void);
void gpio_config(void);
ErrStatus can_networking(void);
void can_networking_init(void);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    uint8_t i = 0;
    uint32_t timeout = 0xFFFF;
    uint8_t transmit_mailbox = 0;
    
    receive_flag = RESET;
    /* configure Tamper key */
    gd_eval_key_init(KEY_TAMPER, KEY_MODE_GPIO);
    /* configure GPIO */
    gpio_config();
    /* configure USART */
    gd_eval_com_init(EVAL_COM0);
    /* configure NVIC */
    nvic_config();
    /* configure leds */
    led_config();
    /* set all leds off */
    gd_eval_led_off(LED2);
    gd_eval_led_off(LED3);
    gd_eval_led_off(LED4);
    gd_eval_led_off(LED5);
    /* initialize CAN */
    can_networking_init();
    
    /* enable CAN receive FIFO1 not empty interrupt */
    can_interrupt_enable(CANX, CAN_INT_RFNE1);
    
    /* initialize transmit message */
    can_struct_para_init(CAN_TX_MESSAGE_STRUCT, &transmit_message);
    transmit_message.tx_sfid = 0x00;
    transmit_message.tx_efid = 0xaabb;
    transmit_message.tx_ft = CAN_FT_DATA;
    transmit_message.tx_ff = CAN_FF_EXTENDED;
    transmit_message.tx_dlen = 8;
    
    transmit_message.tx_data[0] = 0xA0;
    transmit_message.tx_data[1] = 0xA1;
    transmit_message.tx_data[2] = 0xA2;
    transmit_message.tx_data[3] = 0xA3;
    transmit_message.tx_data[4] = 0xA4;
    transmit_message.tx_data[5] = 0xA5;
    transmit_message.tx_data[6] = 0xA6;
    transmit_message.tx_data[7] = 0xA7;
                
    printf("Please press the Tamper key to transmit data!\r\n");
    
    /* initialize receive message */
    can_struct_para_init(CAN_RX_MESSAGE_STRUCT, &receive_message);
    
    while(1){
        /* waiting for the Tamper key pressed */
        while(0 == gd_eval_key_state_get(KEY_TAMPER)){
            /* if transmit_number is 0x10, set it to 0x00 */
            if(transmit_number == 0x10){
                transmit_number = 0x00;
            }else{
                transmit_message.tx_data[0] = transmit_number++;
                printf("\r\n can transmit data:");
                for(i = 0; i < transmit_message.tx_dlen; i++){
                    printf(" %02x", transmit_message.tx_data[i]);
                }
                /* transmit message */
                transmit_mailbox = can_message_transmit(CANX, &transmit_message);
                /* waiting for transmit completed */
                timeout = 0xFFFF;
                while((CAN_TRANSMIT_OK != can_transmit_states(CANX, transmit_mailbox)) && (0 != timeout)){
                    timeout--;
                }
                /* waiting for Tamper key up */
                while(0 == gd_eval_key_state_get(KEY_TAMPER));
            }
        }
        if(SET == receive_flag){
            gd_eval_led_toggle(LED2);
            receive_flag = RESET;
            printf("\r\n can receive data:");
            for(i = 0; i < receive_message.rx_dlen; i++){
                printf(" %02x", receive_message.rx_data[i]);
            }
        }
    }
}

void can_networking_init(void)
{
    can_parameter_struct            can_parameter;
    can_filter_parameter_struct     can_filter;
    
    can_struct_para_init(CAN_INIT_STRUCT, &can_parameter);
    can_struct_para_init(CAN_FILTER_STRUCT, &can_filter);
    
    /* initialize CAN register */
    can_deinit(CANX);
    
    /* initialize CAN */
    can_parameter.time_triggered = DISABLE;
    can_parameter.auto_bus_off_recovery = ENABLE;
    can_parameter.auto_wake_up = DISABLE;
    can_parameter.auto_retrans = ENABLE;
    can_parameter.rec_fifo_overwrite = DISABLE;
    can_parameter.trans_fifo_order = DISABLE;
    can_parameter.working_mode = CAN_NORMAL_MODE;
    can_parameter.resync_jump_width = CAN_BT_SJW_1TQ;
    can_parameter.time_segment_1 = CAN_BT_BS1_7TQ;
    can_parameter.time_segment_2 = CAN_BT_BS2_2TQ;
    /* baudrate 1Mbps */
    can_parameter.prescaler = 6;
    can_init(CANX, &can_parameter);

    /* initialize filter */
#ifdef  DEV_CAN0_USED
    /* CAN0 filter number */
    can_filter.filter_number = 0;
#else
    /* CAN1 filter number */
    can_filter.filter_number = 15;
#endif
    /* initialize filter */    
    can_filter.filter_mode = CAN_FILTERMODE_MASK;
    can_filter.filter_bits = CAN_FILTERBITS_32BIT;
    can_filter.filter_list_high = 0x0000;
    can_filter.filter_list_low = 0x0000;
    can_filter.filter_mask_high = 0x0000;
    can_filter.filter_mask_low = 0x0000;  
    can_filter.filter_fifo_number = CAN_FIFO1;
    can_filter.filter_enable = ENABLE;
    can_filter_init(&can_filter);
}

void nvic_config(void)
{
#ifdef  DEV_CAN0_USED
    /* configure CAN0 NVIC */
    nvic_irq_enable(CAN0_RX1_IRQn,0,0);
#else
    #ifdef GD32F30X_CL
    /* configure CAN1 NVIC */
    nvic_irq_enable(CAN1_RX1_IRQn,0,0);
    #endif /* GD32F30X_CL */
#endif

}

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

void gpio_config(void)
{
    /* enable CAN clock */
    rcu_periph_clock_enable(RCU_CAN0);
    
#ifdef GD32F30X_CL
    rcu_periph_clock_enable(RCU_CAN1);
    rcu_periph_clock_enable(RCU_GPIOB);
#endif
    
    rcu_periph_clock_enable(RCU_GPIOD);
    rcu_periph_clock_enable(RCU_AF);
    
    /* configure CAN0 GPIO */
    gpio_init(GPIOD,GPIO_MODE_IPU,GPIO_OSPEED_50MHZ,GPIO_PIN_0);
    gpio_init(GPIOD,GPIO_MODE_AF_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_1);
#ifdef GD32F30X_CL
    gpio_pin_remap_config(GPIO_CAN0_FULL_REMAP,ENABLE);
#else
    gpio_pin_remap_config(GPIO_CAN_FULL_REMAP,ENABLE);
#endif /* GD32F30X_CL */
    
#ifdef GD32F30X_CL
    /* configure CAN1 GPIO */
    gpio_init(GPIOB,GPIO_MODE_IPU,GPIO_OSPEED_50MHZ,GPIO_PIN_5);
    gpio_init(GPIOB,GPIO_MODE_AF_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_6);
    gpio_pin_remap_config(GPIO_CAN1_REMAP,ENABLE);
#endif
}

代码讲解

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

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

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

实验现象

两块板子通过 CAN 总线交换数据
通信成功 LED 指示

GD32 CAN — CAN 自回环

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

CAN — CAN 自回环

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

功能简介

本示例演示 CAN 自回环测试。TX 发出的数据直接回到 RX，不需要外部 CAN 收发器，非常适合验证 CAN 配置是否正确。

硬件准备

CAN 收发器模块（如 TJA1050、MCP2551）
自回环测试模式下可不接外部设备

完整代码

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

void nvic_config(void);
void led_config(void);
ErrStatus can_loopback(void);
ErrStatus can_loopback_interrupt(void);
void can_loopback_init(void);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    /* enable CAN clock */
    rcu_periph_clock_enable(RCU_CAN0);
#ifdef GD32F30X_CL
    rcu_periph_clock_enable(RCU_CAN1);
#endif /* GD32F30X_CL */
    
    /* configure NVIC */
    nvic_config();
    
    /* configure leds */
    led_config();
    /* set all the leds off */
    gd_eval_led_off(LED2);
    gd_eval_led_off(LED3);
    gd_eval_led_off(LED4);
    gd_eval_led_off(LED5);
    /* loopback of polling */
    test_flag = can_loopback();
 
    if(SUCCESS == test_flag){
        /* loopback test is success */
        gd_eval_led_on(LED2);
        gd_eval_led_on(LED3);
    }else{
        /* loopback test is failed */
        gd_eval_led_off(LED2);
        gd_eval_led_off(LED3);
    }
    /* loopback of interrupt */
    test_flag_interrupt = can_loopback_interrupt();

    if(SUCCESS == test_flag_interrupt){
        /* interrupt loopback test is success */
        gd_eval_led_on(LED4);
        gd_eval_led_on(LED5);
    }else{
        /* interrupt loopback test is failed */
        gd_eval_led_off(LED4);
        gd_eval_led_off(LED5);
    }
    while (1);
}

void can_loopback_init(void)
{
    can_parameter_struct        can_parameter;
    can_filter_parameter_struct can_filter;
    
    can_struct_para_init(CAN_INIT_STRUCT, &can_parameter);
    can_struct_para_init(CAN_FILTER_STRUCT, &can_filter);
    
    /* initialize CAN register */
    can_deinit(CANX);
    
    /* initialize CAN */
    can_parameter.time_triggered = DISABLE;
    can_parameter.auto_bus_off_recovery = ENABLE;
    can_parameter.auto_wake_up = DISABLE;
    can_parameter.auto_retrans = ENABLE;
    can_parameter.rec_fifo_overwrite = DISABLE;
    can_parameter.trans_fifo_order = DISABLE;
    can_parameter.working_mode = CAN_LOOPBACK_MODE;
    /* configure baudrate to 125kbps */
    can_parameter.resync_jump_width = CAN_BT_SJW_1TQ;
    can_parameter.time_segment_1 = CAN_BT_BS1_7TQ;
    can_parameter.time_segment_2 = CAN_BT_BS2_2TQ;
    can_parameter.prescaler = 48;
    can_init(CANX, &can_parameter);

    /* initialize filter */
#ifdef  DEV_CAN0_USED
    /* CAN0 filter number */
    can_filter.filter_number = 0;
#else
    /* CAN1 filter number */
    can_filter.filter_number = 14;
#endif
    /* initialize filter */    
    can_filter.filter_mode = CAN_FILTERMODE_MASK;
    can_filter.filter_bits = CAN_FILTERBITS_32BIT;
    can_filter.filter_list_high = (uint16_t)(DEV_CAN_POLLING_ID << 5);
    can_filter.filter_list_low = 0x0000;
    /* ID and standard frame matched */
    can_filter.filter_mask_high = (uint16_t)(0x7FF << 5);
    can_filter.filter_mask_low = (uint16_t)(1U << 2);
    
    can_filter.filter_fifo_number = CAN_FIFO1;
    can_filter.filter_enable=ENABLE;
    can_filter_init(&can_filter);
    
    /* initialize filter */
#ifdef  DEV_CAN0_USED
    /* CAN0 filter number */
    can_filter.filter_number = 1;
#else
    /* CAN1 filter number */
    can_filter.filter_number = 15;
#endif
    /* initialize filter */
    can_filter.filter_mode = CAN_FILTERMODE_MASK;
    can_filter.filter_bits = CAN_FILTERBITS_32BIT;
    /* ID and extend frame matched */
    can_filter.filter_list_high = (uint16_t)(DEV_CAN_INTERRUPT_ID >> 13);
    can_filter.filter_list_low = (uint16_t)(((uint16_t)DEV_CAN_INTERRUPT_ID << 3) | (1U << 2));
    can_filter.filter_mask_high = (uint16_t)(0x1FFFFFFF >> 13);
    can_filter.filter_mask_low = (uint16_t)(((uint16_t)0x1FFFFFFF << 3) | (1U << 2));
    can_filter.filter_fifo_number = CAN_FIFO1;
    can_filter.filter_enable=ENABLE;
    can_filter_init(&can_filter);
}

void nvic_config(void)
{
    /* configure CAN0 NVIC */
    nvic_irq_enable(CAN0_RX1_IRQn,0,0);
#ifdef GD32F30X_CL
    /* configure CAN1 NVIC */
    nvic_irq_enable(CAN1_RX1_IRQn,0,0);
#endif /* GD32F30X_CL */
}

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

代码讲解

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

实验现象

CAN 自回环：发送的报文直接回到接收端
校验通过 LED 亮起

GD32 CAN — 多 CAN 通信

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

CAN — 多 CAN 通信

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

功能简介

本示例演示 CAN 总线通信。CAN 是汽车和工业领域最常用的现场总线，支持多主通信、错误检测和自动重传。

硬件准备

CAN 收发器模块（如 TJA1050、MCP2551）
自回环测试模式下可不接外部设备

完整代码

#include "gd32f30x.h"
#include <stdio.h>
#include "gd32f307c_eval.h"
#define CAN_BAUDRATE  1000

void nvic_config(void);
void led_config(void);
void can_gpio_config(void);
void can_config(void);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    uint8_t i = 0;
    uint32_t timeout = 0xFFFF;
    uint8_t transmit_mailbox = 0;
    
    can0_receive_flag = RESET;
    can1_receive_flag = RESET;
    can0_error_flag = RESET;
    can1_error_flag = RESET;
    
    /* configure GPIO */
    can_gpio_config();
    
    /* configure NVIC */
    nvic_config();
    
    /* configure USART */
    gd_eval_com_init(EVAL_COM0);
    
    /* configure Wakeup key or Tamper key */
    gd_eval_key_init(KEY_WAKEUP, KEY_MODE_GPIO);
    gd_eval_key_init(KEY_TAMPER, KEY_MODE_GPIO);
    
    printf("\r\nGD32F30x dual CAN test, please press Wakeup key or Tamper key to start communication!\r\n");
    /* configure leds */
    led_config();
    gd_eval_led_off(LED2);
    gd_eval_led_off(LED3);
    gd_eval_led_off(LED4);
    gd_eval_led_off(LED5);
    
    /* initialize CAN and filter */
    can_config();
    /* enable can receive FIFO0 not empty interrupt */
    can_interrupt_enable(CAN0, CAN_INT_RFNE0);
    can_interrupt_enable(CAN1, CAN_INT_RFNE0);
    
    /* initialize transmit message */
    transmit_message.tx_sfid = 0x7ab;
    transmit_message.tx_efid = 0x00;
    transmit_message.tx_ft = CAN_FT_DATA;
    transmit_message.tx_ff = CAN_FF_STANDARD;
    transmit_message.tx_dlen = 8;
    
    transmit_message.tx_data[0] = 0x00;
    transmit_message.tx_data[1] = 0xA1;
    transmit_message.tx_data[2] = 0xA2;
    transmit_message.tx_data[3] = 0xA3;
    transmit_message.tx_data[4] = 0xA4;
    transmit_message.tx_data[5] = 0xA5;
    transmit_message.tx_data[6] = 0xA6;
    transmit_message.tx_data[7] = 0xA7;

    while(1){
        /* test whether the Tamper key is pressed */
        if(0 == gd_eval_key_state_get(KEY_TAMPER)){
            transmit_message.tx_data[0] = 0x55;
            transmit_message.tx_data[1] = 0xAA;
            printf("\r\n can0 transmit data:");
            for(i = 0; i < transmit_message.tx_dlen; i++){
                printf(" %02x", transmit_message.tx_data[i]);
            }
            
            /* transmit message */
            transmit_mailbox = can_message_transmit(CAN0, &transmit_message);
            /* waiting for transmit completed */
            timeout = 0xFFFF;
            while((CAN_TRANSMIT_OK != can_transmit_states(CAN0, transmit_mailbox)) && (0 != timeout)){
                timeout--;
            }
            /* waiting for the Tamper key up */
            while(0 == gd_eval_key_state_get(KEY_TAMPER));
        }
        
#ifdef GD32F30X_CL
        /* test whether the Wakeup key is pressed */
        if(0 == gd_eval_key_state_get(KEY_WAKEUP)){
            transmit_message.tx_data[0] = 0xAA;
            transmit_message.tx_data[1] = 0x55;
            printf("\r\n can1 transmit data:");
            for(i = 0; i < transmit_message.tx_dlen; i++){
                printf(" %02x", transmit_message.tx_data[i]);
            }
            /* transmit message */
            transmit_mailbox = can_message_transmit(CAN1, &transmit_message);
            /* waiting for transmit completed */
            timeout = 0xFFFF;
            while((CAN_TRANSMIT_OK != can_transmit_states(CAN1, transmit_mailbox)) && (0 != timeout)){
                timeout--;
            }
            /* waiting for the Wakeup key up */
            while(0 == gd_eval_key_state_get(KEY_WAKEUP));
        }
#endif /* GD32F30X_CL */
        /* CAN0 receive data correctly, the received data is printed */
        if(SET == can0_receive_flag){
            can0_receive_flag = RESET;
            printf("\r\n can0 receive data:");
            for(i = 0; i < receive_message.rx_dlen; i++){
                printf(" %02x", receive_message.rx_data[i]);
            }
            gd_eval_led_toggle(LED4);
        }
        
#ifdef GD32F30X_CL
        /* CAN1 receive data correctly, the received data is printed */
        if(SET == can1_receive_flag){
            can1_receive_flag = RESET;
            gd_eval_led_toggle(LED5);
            printf("\r\n can1 receive data:");
            for(i = 0; i < receive_message.rx_dlen; i++){
                printf(" %02x", receive_message.rx_data[i]);
            }
        }
#endif /* GD32F30X_CL */
        
        /* CAN0 error */
        if(SET == can0_error_flag){
            can0_error_flag = RESET;
            printf("\r\n can0 communication error");
        }
        
#ifdef GD32F30X_CL
        /* CAN1 error */
        if(SET == can1_error_flag){
            can1_error_flag = RESET;
            printf("\r\n can1 communication error");
        }
#endif /* GD32F30X_CL */
    }
}

void can_config()
{
    can_parameter_struct            can_parameter;
    can_filter_parameter_struct     can_filter;
    can_struct_para_init(CAN_INIT_STRUCT, &can_parameter);
    can_struct_para_init(CAN_FILTER_STRUCT, &can_filter);
    /* initialize CAN register */
    can_deinit(CAN0);
#ifdef GD32F30X_CL
    can_deinit(CAN1);
#endif /* GD32F30X_CL */
    
    /* initialize CAN parameters */
    can_parameter.time_triggered = DISABLE;
    can_parameter.auto_bus_off_recovery = ENABLE;
    can_parameter.auto_wake_up = DISABLE;
    can_parameter.auto_retrans = ENABLE;
    can_parameter.rec_fifo_overwrite = DISABLE;
    can_parameter.trans_fifo_order = DISABLE;
    can_parameter.working_mode = CAN_NORMAL_MODE;
    can_parameter.resync_jump_width = CAN_BT_SJW_1TQ;
    can_parameter.time_segment_1 = CAN_BT_BS1_7TQ;
    can_parameter.time_segment_2 = CAN_BT_BS2_2TQ;
    
    /* 1MBps */
#if CAN_BAUDRATE == 1000
    can_parameter.prescaler = 6;
    /* 500KBps */
#elif CAN_BAUDRATE == 500
    can_parameter.prescaler = 12;
    /* 250KBps */
#elif CAN_BAUDRATE == 250
    can_parameter.prescaler = 24;
    /* 125KBps */
#elif CAN_BAUDRATE == 125
    can_parameter.prescaler = 48;
    /* 100KBps */
#elif  CAN_BAUDRATE == 100
    can_parameter.prescaler = 60;
    /* 50KBps */
#elif  CAN_BAUDRATE == 50
    can_parameter.prescaler = 120;
    /* 20KBps */
#elif  CAN_BAUDRATE == 20
    can_parameter.prescaler = 300;
#else
    #error "please select list can baudrate in private defines in main.c "
#endif  
    /* initialize CAN */
    can_init(CAN0, &can_parameter);
#ifdef GD32F30X_CL
    can_init(CAN1, &can_parameter);
#endif /* GD32F30X_CL */

    /* initialize filter */ 
    can_filter.filter_number=0;
    can_filter.filter_mode = CAN_FILTERMODE_MASK;
    can_filter.filter_bits = CAN_FILTERBITS_32BIT;
    can_filter.filter_list_high = 0x0000;
    can_filter.filter_list_low = 0x0000;
    can_filter.filter_mask_high = 0x0000;
    can_filter.filter_mask_low = 0x0000;
    can_filter.filter_fifo_number = CAN_FIFO0;
    can_filter.filter_enable = ENABLE;
    
    can_filter_init(&can_filter);
    
    /* CAN1 filter number */
    can_filter.filter_number = 15;
    can_filter_init(&can_filter);
}

void nvic_config(void)
{
#ifdef GD32F30X_CL
    /* configure CAN0 NVIC */
    nvic_irq_enable(CAN0_RX0_IRQn,0,0);

    /* configure CAN1 NVIC */
    nvic_irq_enable(CAN1_RX0_IRQn,1,1);
#else
    nvic_irq_enable(USBD_LP_CAN0_RX0_IRQn,0,0);
#endif /* GD32F30X_CL */
}

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

void can_gpio_config(void)
{
    /* enable CAN clock */
    rcu_periph_clock_enable(RCU_CAN0);
#ifdef GD32F30X_CL
    rcu_periph_clock_enable(RCU_CAN1);
#endif /* GD32F30X_CL */
    rcu_periph_clock_enable(RCU_GPIOB);
    rcu_periph_clock_enable(RCU_GPIOD);
    rcu_periph_clock_enable(RCU_AF);
    
    /* configure CAN0 GPIO */
    gpio_init(GPIOD,GPIO_MODE_IPU,GPIO_OSPEED_50MHZ,GPIO_PIN_0);
    gpio_init(GPIOD,GPIO_MODE_AF_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_1);
#ifdef GD32F30X_CL
    gpio_pin_remap_config(GPIO_CAN0_FULL_REMAP,ENABLE);
#else
    gpio_pin_remap_config(GPIO_CAN_FULL_REMAP,ENABLE);
#endif /* GD32F30X_CL */
    
#ifdef GD32F30X_CL
    /* configure CAN1 GPIO */
    gpio_init(GPIOB,GPIO_MODE_IPU,GPIO_OSPEED_50MHZ,GPIO_PIN_5);
    gpio_init(GPIOB,GPIO_MODE_AF_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_6);
    gpio_pin_remap_config(GPIO_CAN1_REMAP,ENABLE);
#endif /* GD32F30X_CL */
}

代码讲解

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

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

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

实验现象

两块板子通过 CAN 总线交换数据
通信成功 LED 指示

GD32 CRC — CRC 计算

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

CRC — CRC 计算

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

功能简介

本示例演示 CRC 校验计算。CRC 是数据通信中最常用的错误检测方法，发送方算出 CRC 值附在数据后面，接收方重新计算并比对。

完整代码

#include "gd32f30x.h"
#include "gd32f307c_eval.h"

int main(void)
{
    val = (uint32_t)0xabcd1234;

    /* initialize the LED2 and LED3, turn off them */
    gd_eval_led_init(LED2);
    gd_eval_led_init(LED3);
    gd_eval_led_off(LED2);
    gd_eval_led_off(LED3);
    rcu_periph_clock_enable(RCU_CRC);
    
    /* reset the CRC data register and calculate the CRC of the value */
    crc_data_register_reset();
    valcrc = crc_single_data_calculate(val);

    if(0xf7018a40 == valcrc){
        gd_eval_led_on(LED2);
        gd_eval_led_on(LED3);
    }

    while (1){
    }
}

代码讲解

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

GD32 CTC — CTC GPIO 输出

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

CTC — CTC GPIO 输出

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

功能简介

本示例演示 CTC 的基本用法。

完整代码

#include "gd32f30x.h"
#include "gd32f307c_eval.h"

void ctc_config(void);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    /* init LED2*/
    gd_eval_led_init(LED2);
    /* enable IRC48M clock */
    RCU_ADDCTL |= RCU_ADDCTL_IRC48MEN; 
    /* wait till IRC48M is ready */
    while(0 == (RCU_ADDCTL & RCU_ADDCTL_IRC48MSTB)){
    }

    /* configure PA8 as external reference signal source input with 32khz */
    rcu_periph_clock_enable(RCU_GPIOA);
    rcu_periph_clock_enable(RCU_AF);
    gpio_init(GPIOA, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_8);

    /* CTC peripheral clock enable */
    rcu_periph_clock_enable(RCU_CTC);
    /* CTC config */
    ctc_config();

    while(1){
        /* if the clock trim is OK */
        if(RESET != ctc_flag_get(CTC_FLAG_CKOK)){
            gd_eval_led_on(LED2);
        }else{
            gd_eval_led_off(LED2);
        }
    }
}

void ctc_config(void)
{
    /* config CTC reference signal source prescaler */
    ctc_refsource_prescaler_config(CTC_REFSOURCE_PSC_DIV32);
    /* select reference signal source */
    ctc_refsource_signal_select(CTC_REFSOURCE_GPIO);
    /* select reference signal source polarity */
    ctc_refsource_polarity_config(CTC_REFSOURCE_POLARITY_RISING);
    /* config hardware automatically trim mode */
    ctc_hardware_trim_mode_config(CTC_HARDWARE_TRIM_MODE_ENABLE);
    
    /* config CTC counter reload value, Fclock/Fref-1 */
    ctc_counter_reload_value_config(0xBB7F);
    /* config clock trim base limit value, Fclock/Fref*0.0012/2 */
    ctc_clock_limit_value_config(0x1D);

    /* CTC counter enable */
    ctc_counter_enable();
}

代码讲解

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

GD32 CTC — CTC LXTAL 校准

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

CTC — CTC LXTAL 校准

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

功能简介

本示例演示 CTC 的基本用法。

完整代码

#include "gd32f30x.h"
#include "gd32f307c_eval.h"

void ctc_config(void);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    /* init LED2*/
    gd_eval_led_init(LED2);

    /* enable IRC48M clock */
    RCU_ADDCTL |= RCU_ADDCTL_IRC48MEN; 
    /* wait till IRC48M is ready */
    while(0 == (RCU_ADDCTL & RCU_ADDCTL_IRC48MSTB)){
    }

    /* LXTAL clock config */
    rcu_periph_clock_enable(RCU_PMU);
    pmu_backup_write_enable();

    /* enable LXTAL clock */
    RCU_BDCTL |= RCU_BDCTL_LXTALEN;
    /* wait till LXTAL is ready */
    while(0 == (RCU_BDCTL & RCU_BDCTL_LXTALSTB)){
    }

    /* CTC peripheral clock enable */
    rcu_periph_clock_enable(RCU_CTC);
    /* CTC config */
    ctc_config();

    while(1){
        /* if the clock trim is OK */
        if(ctc_flag_get(CTC_FLAG_CKOK) != RESET){
            gd_eval_led_on(LED2);
        }else{
            gd_eval_led_off(LED2);
        }
    }
}

void ctc_config(void)
{
    /* config CTC reference signal source prescaler */
    ctc_refsource_prescaler_config(CTC_REFSOURCE_PSC_OFF);
    /* select reference signal source */
    ctc_refsource_signal_select(CTC_REFSOURCE_LXTAL);
    /* select reference signal source polarity */
    ctc_refsource_polarity_config(CTC_REFSOURCE_POLARITY_RISING);
    /* config hardware automatically trim mode */
    ctc_hardware_trim_mode_config(CTC_HARDWARE_TRIM_MODE_ENABLE);
    
    /* config CTC counter reload value, Fclock/Fref-1 */
    ctc_counter_reload_value_config(0x05B8);
    /* config clock trim base limit value, Fclock/Fref*0.0012/2 */
    ctc_clock_limit_value_config(0x0001);

    /* CTC counter enable */
    ctc_counter_enable();
}

代码讲解

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

GD32 DAC — DAC + ADC 转换

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

DAC — DAC + ADC 转换

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

功能简介

本示例演示 DAC 数模转换器的基本用法。DAC 将数字值转换为模拟电压输出，是生成模拟信号的关键外设。

完整代码

#include "gd32f30x.h"
#include "systick.h"

void rcu_config(void);
/* configure GPIO peripheral */
void gpio_config(void);
/* configure NVIC peripheral */
void nvic_config(void);
/* configure ADC peripheral */
void adc_config(void);
/* configure DAC peripheral */
void dac_config(void);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    /* configure systick */
    systick_config();

    /* configure RCU peripheral */
    rcu_config();
    /* configure GPIO peripheral */
    gpio_config();
    /* configure NVIC peripheral */
    nvic_config();
    /* configure DAC peripheral */
    dac_config();
    /* configure ADC peripheral */
    adc_config();

    while(1) {
    }
}

void rcu_config(void)
{
    /* enable GPIOA clock */
    rcu_periph_clock_enable(RCU_GPIOA);
    /* enable GPIOC clock */
    rcu_periph_clock_enable(RCU_GPIOC);
    /* enable ADC clock */
    rcu_periph_clock_enable(RCU_ADC0);
    /* enable DAC clock */
    rcu_periph_clock_enable(RCU_DAC);
}

void gpio_config(void)
{
    /* configure PC3 as ADC input */
    gpio_init(GPIOC, GPIO_MODE_AIN, GPIO_OSPEED_50MHZ, GPIO_PIN_3);

    /* configure PA4 as DAC output */
    gpio_init(GPIOA, GPIO_MODE_AIN, GPIO_OSPEED_50MHZ, GPIO_PIN_4);
}

void nvic_config(void)
{
    nvic_priority_group_set(NVIC_PRIGROUP_PRE2_SUB2);
    nvic_irq_enable(ADC0_1_IRQn, 0, 0);
}

void adc_config(void)
{
    /* ADC continuous function enable */
    adc_special_function_config(ADC0, ADC_CONTINUOUS_MODE, ENABLE);
    /* ADC data alignment config */
    adc_data_alignment_config(ADC0, ADC_DATAALIGN_RIGHT);
    /* ADC channel length config */
    adc_channel_length_config(ADC0, ADC_ROUTINE_CHANNEL, 1);
    /* ADC routine channel config */
    adc_routine_channel_config(ADC0, 0, ADC_CHANNEL_13, ADC_SAMPLETIME_55POINT5);
    /* ADC external trigger enable */
    adc_external_trigger_config(ADC0, ADC_ROUTINE_CHANNEL, ENABLE);
    /* ADC trigger config */
    adc_external_trigger_source_config(ADC0, ADC_ROUTINE_CHANNEL, ADC0_1_2_EXTTRIG_ROUTINE_NONE);

    /* enable ADC interface */
    adc_enable(ADC0);
    delay_1ms(1);
    /* ADC calibration and reset calibration */
    adc_calibration_enable(ADC0);

    /* ADC interrupt enable */
    adc_interrupt_flag_clear(ADC0, ADC_INT_FLAG_EOC);
    adc_interrupt_enable(ADC0, ADC_INT_EOC);

    /* enable ADC software trigger */
    adc_software_trigger_enable(ADC0, ADC_ROUTINE_CHANNEL);
}

void dac_config(void)
{
    /* initialize DAC */
    dac_deinit(DAC0);
    /* DAC trigger config */
    dac_trigger_source_config(DAC0, DAC_OUT0, DAC_TRIGGER_SOFTWARE);
    /* DAC trigger enable */
    dac_trigger_enable(DAC0, DAC_OUT0);
    /* DAC wave mode config */
    dac_wave_mode_config(DAC0, DAC_OUT0, DAC_WAVE_DISABLE);
    /* DAC output buffer config */
    dac_output_buffer_enable(DAC0, DAC_OUT0);

    /* DAC enable */
    dac_enable(DAC0, DAC_OUT0);
}

代码讲解

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

ADC 配置：选择采样通道、采样时间、触发方式、数据对齐方式。采样时间越长精度越高。

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

校准：ADC 使用前必须校准，消除工艺偏差。校准期间不要操作 ADC。

GD32 DAC — DAC DMA 转换

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

DAC — DAC DMA 转换

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

功能简介

本示例演示 DAC 数模转换器的基本用法。DAC 将数字值转换为模拟电压输出，是生成模拟信号的关键外设。

完整代码

#include "gd32f30x.h"
#define CONVERT_NUM          (10)
#define DAC0_R8DH_ADDRESS    (0x40007410)

void rcu_config(void);
/* configure GPIO peripheral */
void gpio_config(void);
/* configure DMA peripheral */
void dma_config(void);
/* configure DAC peripheral */
void dac_config(void);
/* configure TIMER peripheral */
void timer5_config(void);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    /* configure RCU peripheral */
    rcu_config();
    /* configure GPIO peripheral */
    gpio_config();
    /* configure DMA peripheral */
    dma_config();
    /* configure DAC peripheral */
    dac_config();
    /* configure TIMER peripheral */
    timer5_config();

    while(1) {
    }
}

void rcu_config(void)
{
    /* enable GPIOA clock */
    rcu_periph_clock_enable(RCU_GPIOA);
    /* enable DMA clock */
    rcu_periph_clock_enable(RCU_DMA1);
    /* enable DAC clock */
    rcu_periph_clock_enable(RCU_DAC);
    /* enable TIMER clock */
    rcu_periph_clock_enable(RCU_TIMER5);
}

void gpio_config(void)
{
    /* configure PA4 as DAC output */
    gpio_init(GPIOA, GPIO_MODE_AIN, GPIO_OSPEED_50MHZ, GPIO_PIN_4);
}

void dma_config(void)
{
    dma_parameter_struct dma_struct;
    /* clear all the interrupt flags */
    dma_flag_clear(DMA1, DMA_CH2, DMA_INTF_GIF);
    dma_flag_clear(DMA1, DMA_CH2, DMA_INTF_FTFIF);
    dma_flag_clear(DMA1, DMA_CH2, DMA_INTF_HTFIF);
    dma_flag_clear(DMA1, DMA_CH2, DMA_INTF_ERRIF);
    
    /* configure the DMA1 channel 2 */
    dma_struct.periph_addr  = DAC0_R8DH_ADDRESS;
    dma_struct.periph_width = DMA_PERIPHERAL_WIDTH_8BIT;
    dma_struct.memory_addr  = (uint32_t)convertarr;
    dma_struct.memory_width = DMA_MEMORY_WIDTH_8BIT;
    dma_struct.number       = CONVERT_NUM;
    dma_struct.priority     = DMA_PRIORITY_ULTRA_HIGH;
    dma_struct.periph_inc   = DMA_PERIPH_INCREASE_DISABLE;
    dma_struct.memory_inc   = DMA_MEMORY_INCREASE_ENABLE;
    dma_struct.direction    = DMA_MEMORY_TO_PERIPHERAL;
    dma_init(DMA1, DMA_CH2, &dma_struct);

    dma_circulation_enable(DMA1, DMA_CH2);
    dma_channel_enable(DMA1, DMA_CH2);
}

void dac_config(void)
{
    /* initialize DAC */
    dac_deinit(DAC0);
    /* DAC trigger config */
    dac_trigger_source_config(DAC0, DAC_OUT0, DAC_TRIGGER_T5_TRGO);
    /* DAC trigger enable */
    dac_trigger_enable(DAC0, DAC_OUT0);
    /* DAC wave mode config */
    dac_wave_mode_config(DAC0, DAC_OUT0, DAC_WAVE_DISABLE);

    /* DAC enable */
    dac_enable(DAC0, DAC_OUT0);
    /* DAC DMA function enable */
    dac_dma_enable(DAC0, DAC_OUT0);
}

void timer5_config(void)
{
    timer_parameter_struct timer_initpara;

    /* TIMER deinitialize */
    timer_deinit(TIMER5);

    /* TIMER configuration */
    timer_struct_para_init(&timer_initpara);
    timer_initpara.prescaler         = 119;
    timer_initpara.alignedmode       = TIMER_COUNTER_EDGE;
    timer_initpara.counterdirection  = TIMER_COUNTER_UP;
    timer_initpara.period            = 999;
    timer_initpara.clockdivision     = TIMER_CKDIV_DIV1;
    timer_initpara.repetitioncounter = 0;

    /* initialize TIMER init parameter struct */
    timer_init(TIMER5, &timer_initpara);

    /* TIMER master mode output trigger source: Update event */
    timer_master_output_trigger_source_select(TIMER5, TIMER_TRI_OUT_SRC_UPDATE);

    /* enable TIMER */
    timer_enable(TIMER5);
}

代码讲解

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

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

定时器配置：设置预分频器（PSC）和重装载值（ARR），定时时间 = (PSC+1) × (ARR+1) / 时钟频率。

GD32 DAC — DAC LFSR 噪声模式

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

DAC — DAC LFSR 噪声模式

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

功能简介

本示例演示 DAC 噪声波生成。利用 LFSR（线性反馈移位寄存器）生成伪噪声信号，可用于音频测试等场景。

完整代码

#include "gd32f30x.h"

void rcu_config(void);
/* configure GPIO peripheral */
void gpio_config(void);
/* configure DAC peripheral */
void dac_config(void);
/* configure TIMER peripheral */
void timer5_config(void);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    /* configure RCU peripheral */
    rcu_config();
    /* configure GPIO peripheral */
    gpio_config();
    /* configure DAC peripheral */
    dac_config();
    /* configure TIMER peripheral */
    timer5_config();

    while(1) {
    }
}

void rcu_config(void)
{
    /* enable GPIOA clock */
    rcu_periph_clock_enable(RCU_GPIOA);
    /* enable DAC clock */
    rcu_periph_clock_enable(RCU_DAC);
    /* enable TIMER clock */
    rcu_periph_clock_enable(RCU_TIMER5);
}

void gpio_config(void)
{
    /* configure PA4 as DAC output */
    gpio_init(GPIOA, GPIO_MODE_AIN, GPIO_OSPEED_50MHZ, GPIO_PIN_4);
}

void dac_config(void)
{
    /* initialize DAC */
    dac_deinit(DAC0);
    /* DAC trigger config */
    dac_trigger_source_config(DAC0, DAC_OUT0, DAC_TRIGGER_T5_TRGO);
    /* DAC trigger enable */
    dac_trigger_enable(DAC0, DAC_OUT0);
    /* DAC wave mode config */
    dac_wave_mode_config(DAC0, DAC_OUT0, DAC_WAVE_MODE_LFSR);
    dac_lfsr_noise_config(DAC0, DAC_OUT0, DAC_LFSR_BITS10_0);

    /* DAC enable */
    dac_enable(DAC0, DAC_OUT0);
    dac_data_set(DAC0, DAC_OUT0, DAC_ALIGN_12B_R, 0x7F0);
}

void timer5_config(void)
{
    timer_parameter_struct timer_initpara;

    /* TIMER deinitialize */
    timer_deinit(TIMER5);

    /* TIMER configuration */
    timer_struct_para_init(&timer_initpara);
    timer_initpara.prescaler         = 119;
    timer_initpara.alignedmode       = TIMER_COUNTER_EDGE;
    timer_initpara.counterdirection  = TIMER_COUNTER_UP;
    timer_initpara.period            = 999;
    timer_initpara.clockdivision     = TIMER_CKDIV_DIV1;
    timer_initpara.repetitioncounter = 0;

    /* initialize TIMER init parameter struct */
    timer_init(TIMER5, &timer_initpara);

    /* TIMER master mode output trigger source: Update event */
    timer_master_output_trigger_source_select(TIMER5, TIMER_TRI_OUT_SRC_UPDATE);

    /* enable TIMER */
    timer_enable(TIMER5);
}

代码讲解

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

定时器配置：设置预分频器（PSC）和重装载值（ARR），定时时间 = (PSC+1) × (ARR+1) / 时钟频率。

GD32 DAC — DAC 独立触发 LFSR 噪声

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

DAC — DAC 独立触发 LFSR 噪声

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

功能简介

本示例演示 DAC 噪声波生成。利用 LFSR（线性反馈移位寄存器）生成伪噪声信号，可用于音频测试等场景。

完整代码

#include "gd32f30x.h"

void rcu_config(void);
/* configure GPIO peripheral */
void gpio_config(void);
/* configure DAC peripheral */
void dac_config(void);
/* configure TIMER peripheral */
void timer5_config(void);
void timer6_config(void);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    /* configure RCU peripheral */
    rcu_config();
    /* configure GPIO peripheral */
    gpio_config();
    /* configure DAC peripheral */
    dac_config();
    /* configure TIMER peripheral */
    timer5_config();
    timer6_config();

    while(1) {
    }
}

void rcu_config(void)
{
    /* enable GPIOA clock */
    rcu_periph_clock_enable(RCU_GPIOA);
    /* enable DAC clock */
    rcu_periph_clock_enable(RCU_DAC);
    /* enable TIMER clock */
    rcu_periph_clock_enable(RCU_TIMER5);
    rcu_periph_clock_enable(RCU_TIMER6);
}

void gpio_config(void)
{
    /* configure PA4 and PA5 as DAC output */
    gpio_init(GPIOA, GPIO_MODE_AIN, GPIO_OSPEED_50MHZ, GPIO_PIN_4 | GPIO_PIN_5);
}

void dac_config(void)
{
    /* initialize DAC */
    dac_deinit(DAC0);
    /* DAC trigger config */
    dac_trigger_source_config(DAC0, DAC_OUT0, DAC_TRIGGER_T5_TRGO);
    dac_trigger_source_config(DAC0, DAC_OUT1, DAC_TRIGGER_T6_TRGO);
    /* DAC trigger enable */
    dac_trigger_enable(DAC0, DAC_OUT0);
    dac_trigger_enable(DAC0, DAC_OUT1);
    /* DAC wave mode config */
    dac_wave_mode_config(DAC0, DAC_OUT0, DAC_WAVE_MODE_LFSR);
    dac_lfsr_noise_config(DAC0, DAC_OUT0, DAC_LFSR_BITS9_0);
    dac_wave_mode_config(DAC0, DAC_OUT1, DAC_WAVE_MODE_LFSR);
    dac_lfsr_noise_config(DAC0, DAC_OUT1, DAC_LFSR_BITS10_0);

    /* DAC enable */
    dac_concurrent_enable(DAC0);
    dac_concurrent_data_set(DAC0, DAC_ALIGN_12B_R, 0x7F0, 0x7F0);
}

void timer5_config(void)
{
    timer_parameter_struct timer_initpara;

    /* TIMER deinitialize */
    timer_deinit(TIMER5);

    /* TIMER configuration */
    timer_struct_para_init(&timer_initpara);
    timer_initpara.prescaler         = 119;
    timer_initpara.alignedmode       = TIMER_COUNTER_EDGE;
    timer_initpara.counterdirection  = TIMER_COUNTER_UP;
    timer_initpara.period            = 999;
    timer_initpara.clockdivision     = TIMER_CKDIV_DIV1;
    timer_initpara.repetitioncounter = 0;

    /* initialize TIMER init parameter struct */
    timer_init(TIMER5, &timer_initpara);

    /* TIMER master mode output trigger source: Update event */
    timer_master_output_trigger_source_select(TIMER5, TIMER_TRI_OUT_SRC_UPDATE);

    /* enable TIMER */
    timer_enable(TIMER5);
}

void timer6_config(void)
{
    timer_parameter_struct timer_initpara;

    /* TIMER deinitialize */
    timer_deinit(TIMER6);

    /* TIMER configuration */
    timer_struct_para_init(&timer_initpara);
    timer_initpara.prescaler         = 119;
    timer_initpara.alignedmode       = TIMER_COUNTER_EDGE;
    timer_initpara.counterdirection  = TIMER_COUNTER_UP;
    timer_initpara.period            = 999;
    timer_initpara.clockdivision     = TIMER_CKDIV_DIV1;
    timer_initpara.repetitioncounter = 0;

    /* initialize TIMER init parameter struct */
    timer_init(TIMER6, &timer_initpara);

    /* TIMER master mode output trigger source: Update event */
    timer_master_output_trigger_source_select(TIMER6, TIMER_TRI_OUT_SRC_UPDATE);

    /* enable TIMER */
    timer_enable(TIMER6);
}

代码讲解

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

定时器配置：设置预分频器（PSC）和重装载值（ARR），定时时间 = (PSC+1) × (ARR+1) / 时钟频率。

GD32 DAC — DAC 软件触发 LFSR 噪声

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

DAC — DAC 软件触发 LFSR 噪声

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

功能简介

本示例演示 DAC 噪声波生成。利用 LFSR（线性反馈移位寄存器）生成伪噪声信号，可用于音频测试等场景。

完整代码

#include "gd32f30x.h"

void rcu_config(void);
/* configure GPIO peripheral */
void gpio_config(void);
/* configure DAC peripheral */
void dac_config(void);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    /* configure RCU peripheral */
    rcu_config();
    /* configure GPIO peripheral */
    gpio_config();
    /* configure DAC peripheral */
    dac_config();

    while(1) {
        /* DAC software trigger enable */
        dac_concurrent_software_trigger_enable(DAC0);
    }
}

void rcu_config(void)
{
    /* enable the clock of peripherals */
    rcu_periph_clock_enable(RCU_GPIOA);
    rcu_periph_clock_enable(RCU_DAC);
}

void gpio_config(void)
{
    /* configure PA4 and PA5 as DAC output */
    gpio_init(GPIOA, GPIO_MODE_AIN, GPIO_OSPEED_50MHZ, GPIO_PIN_4 | GPIO_PIN_5);
}

void dac_config(void)
{
    /* initialize DAC */
    dac_deinit(DAC0);
    /* DAC trigger config */
    dac_trigger_source_config(DAC0, DAC_OUT0, DAC_TRIGGER_SOFTWARE);
    dac_trigger_source_config(DAC0, DAC_OUT1, DAC_TRIGGER_SOFTWARE);
    /* DAC trigger enable */
    dac_trigger_enable(DAC0, DAC_OUT0);
    dac_trigger_enable(DAC0, DAC_OUT1);
    /* DAC wave mode config */
    dac_wave_mode_config(DAC0, DAC_OUT0, DAC_WAVE_MODE_LFSR);
    dac_lfsr_noise_config(DAC0, DAC_OUT0, DAC_LFSR_BITS9_0);
    dac_wave_mode_config(DAC0, DAC_OUT1, DAC_WAVE_MODE_LFSR);
    dac_lfsr_noise_config(DAC0, DAC_OUT1, DAC_LFSR_BITS10_0);

    /* DAC enable */
    dac_concurrent_enable(DAC0);
    dac_concurrent_data_set(DAC0, DAC_ALIGN_12B_R, 0x7F0, 0x7F0);
}

代码讲解

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

GD32 DAC — DAC 三角噪声模式

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

DAC — DAC 三角噪声模式

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

功能简介

本示例演示 DAC 输出三角波。利用 DAC 内置的三角波生成器，无需 CPU 干预即可输出三角波。

完整代码

#include "gd32f30x.h"

void rcu_config(void);
/* configure GPIO peripheral */
void gpio_config(void);
/* configure DAC peripheral */
void dac_config(void);
/* configure TIMER peripheral */
void timer5_config(void);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    /* configure RCU peripheral */
    rcu_config();
    /* configure GPIO peripheral */
    gpio_config();
    /* configure DAC peripheral */
    dac_config();
    /* configure TIMER peripheral */
    timer5_config();
    
    while(1) {
    }
}

void rcu_config(void)
{
    /* enable GPIOA clock */
    rcu_periph_clock_enable(RCU_GPIOA);
    /* enable DAC clock */
    rcu_periph_clock_enable(RCU_DAC);
    /* enable TIMER clock */
    rcu_periph_clock_enable(RCU_TIMER5);
}

void gpio_config(void)
{
    /* configure PA5 as DAC output */
    gpio_init(GPIOA, GPIO_MODE_AIN, GPIO_OSPEED_50MHZ, GPIO_PIN_5);
}

void dac_config(void)
{
    /* initialize DAC */
    dac_deinit(DAC0);
    /* DAC trigger config */
    dac_trigger_source_config(DAC0, DAC_OUT1, DAC_TRIGGER_T5_TRGO);
    /* DAC trigger enable */
    dac_trigger_enable(DAC0, DAC_OUT1);
    /* DAC wave mode config */
    dac_wave_mode_config(DAC0, DAC_OUT1, DAC_WAVE_MODE_TRIANGLE);
    dac_triangle_noise_config(DAC0, DAC_OUT1, DAC_TRIANGLE_AMPLITUDE_2047);

    /* DAC enable */
    dac_enable(DAC0, DAC_OUT1);
    dac_data_set(DAC0, DAC_OUT1, DAC_ALIGN_12B_R, 0x7F0);
}

void timer5_config(void)
{
    timer_parameter_struct timer_initpara;

    /* TIMER deinitialize */
    timer_deinit(TIMER5);

    /* TIMER configuration */
    timer_struct_para_init(&timer_initpara);
    timer_initpara.prescaler         = 119;
    timer_initpara.alignedmode       = TIMER_COUNTER_EDGE;
    timer_initpara.counterdirection  = TIMER_COUNTER_UP;
    timer_initpara.period            = 999;
    timer_initpara.clockdivision     = TIMER_CKDIV_DIV1;
    timer_initpara.repetitioncounter = 0;

    /* initialize TIMER init parameter struct */
    timer_init(TIMER5, &timer_initpara);

    /* TIMER master mode output trigger source: Update event */
    timer_master_output_trigger_source_select(TIMER5, TIMER_TRI_OUT_SRC_UPDATE);

    /* enable TIMER */
    timer_enable(TIMER5);
}

代码讲解

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

定时器配置：设置预分频器（PSC）和重装载值（ARR），定时时间 = (PSC+1) × (ARR+1) / 时钟频率。

GD32 DAC — DAC 输出电压

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

DAC — DAC 输出电压

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

功能简介

本示例演示 DAC 数模转换器的基本用法。DAC 将数字值转换为模拟电压输出，是生成模拟信号的关键外设。

完整代码

#include "gd32f30x.h"

void rcu_config(void);
/* configure GPIO peripheral */
void gpio_config(void);
/* configure DAC peripheral */
void dac_config(void);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    /* configure RCU peripheral */
    rcu_config();
    /* configure GPIO peripheral */
    gpio_config();
    /* configure DAC peripheral */
    dac_config();

    while(1) {
    }
}

void rcu_config(void)
{
    /* enable GPIOA clock */
    rcu_periph_clock_enable(RCU_GPIOA);
    /* enable DAC clock */
    rcu_periph_clock_enable(RCU_DAC);
}

void gpio_config(void)
{
    /* configure PA4 and PA5 as DAC output */
    gpio_init(GPIOA, GPIO_MODE_AIN, GPIO_OSPEED_50MHZ, GPIO_PIN_4 | GPIO_PIN_5);
}

void dac_config(void)
{
    /* initialize DAC */
    dac_deinit(DAC0);
    /* DAC trigger disable */
    dac_trigger_disable(DAC0, DAC_OUT0);
    dac_trigger_disable(DAC0, DAC_OUT1);
    /* DAC wave mode config */
    dac_wave_mode_config(DAC0, DAC_OUT0, DAC_WAVE_DISABLE);
    dac_wave_mode_config(DAC0, DAC_OUT1, DAC_WAVE_DISABLE);

    /* DAC enable */
    dac_concurrent_enable(DAC0);
    dac_concurrent_data_set(DAC0, DAC_ALIGN_12B_L, 0x7FF0, 0x1FF0);
}

代码讲解

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

GD32 DAC — DAC 同步触发三角噪声

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

DAC — DAC 同步触发三角噪声

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

功能简介

本示例演示 DAC 输出三角波。利用 DAC 内置的三角波生成器，无需 CPU 干预即可输出三角波。

完整代码

#include "gd32f30x.h"

void rcu_config(void);
/* configure GPIO peripheral */
void gpio_config(void);
/* configure DAC peripheral */
void dac_config(void);
/* configure TIMER peripheral */
void timer5_config(void);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    /* configure RCU peripheral */
    rcu_config();
    /* configure GPIO peripheral */
    gpio_config();
    /* configure DAC peripheral */
    dac_config();
    /* configure TIMER peripheral */
    timer5_config();

    while(1) {
    }
}

void rcu_config(void)
{
    /* enable GPIOA clock */
    rcu_periph_clock_enable(RCU_GPIOA);
    /* enable DAC clock */
    rcu_periph_clock_enable(RCU_DAC);
    /* enable TIMER clock */
    rcu_periph_clock_enable(RCU_TIMER5);
}

void gpio_config(void)
{
    /* configure PA4 and PA5 as DAC output */
    gpio_init(GPIOA, GPIO_MODE_AIN, GPIO_OSPEED_50MHZ, GPIO_PIN_4 | GPIO_PIN_5);
}

void dac_config(void)
{
    /* initialize DAC */
    dac_deinit(DAC0);
    /* DAC trigger config */
    dac_trigger_source_config(DAC0, DAC_OUT0, DAC_TRIGGER_T5_TRGO);
    dac_trigger_source_config(DAC0, DAC_OUT1, DAC_TRIGGER_T5_TRGO);
    /* DAC trigger enable */
    dac_trigger_enable(DAC0, DAC_OUT0);
    dac_trigger_enable(DAC0, DAC_OUT1);
    /* DAC wave mode config */
    dac_wave_mode_config(DAC0, DAC_OUT0, DAC_WAVE_MODE_TRIANGLE);
    dac_triangle_noise_config(DAC0, DAC_OUT0, DAC_TRIANGLE_AMPLITUDE_1023);
    dac_wave_mode_config(DAC0, DAC_OUT1, DAC_WAVE_MODE_TRIANGLE);
    dac_triangle_noise_config(DAC0, DAC_OUT1, DAC_TRIANGLE_AMPLITUDE_1023);

    /* DAC enable */
    dac_concurrent_enable(DAC0);
    dac_concurrent_data_set(DAC0, DAC_ALIGN_12B_R, 0x7F0, 0x1F0);
}

void timer5_config(void)
{
    timer_parameter_struct timer_initpara;

    /* TIMER deinitialize */
    timer_deinit(TIMER5);

    /* TIMER configuration */
    timer_struct_para_init(&timer_initpara);
    timer_initpara.prescaler         = 119;
    timer_initpara.alignedmode       = TIMER_COUNTER_EDGE;
    timer_initpara.counterdirection  = TIMER_COUNTER_UP;
    timer_initpara.period            = 999;
    timer_initpara.clockdivision     = TIMER_CKDIV_DIV1;
    timer_initpara.repetitioncounter = 0;

    /* initialize TIMER init parameter struct */
    timer_init(TIMER5, &timer_initpara);

    /* TIMER master mode output trigger source: Update event */
    timer_master_output_trigger_source_select(TIMER5, TIMER_TRI_OUT_SRC_UPDATE);

    /* enable TIMER */
    timer_enable(TIMER5);
}

代码讲解

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

定时器配置：设置预分频器（PSC）和重装载值（ARR），定时时间 = (PSC+1) × (ARR+1) / 时钟频率。

GD32 DAC — DAC 外部触发

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

DAC — DAC 外部触发

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

功能简介

本示例演示 DAC 数模转换器的基本用法。DAC 将数字值转换为模拟电压输出，是生成模拟信号的关键外设。

完整代码

#include "gd32f30x.h"

void rcu_config(void);
/* configure GPIO peripheral */
void gpio_config(void);
/* configure DAC peripheral */
void dac_config(void);
/* configure EXTI line */
void exti_line9_config(void);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    /* configure RCU peripheral */
    rcu_config();
    /* configure GPIO peripheral */
    gpio_config();
    /* configure DAC peripheral */
    dac_config();
    /* configure EXTI line */
    exti_line9_config();

    while (1) {
    }
}

void rcu_config(void)
{
    /* enable GPIOA clock */
    rcu_periph_clock_enable(RCU_GPIOA);
    /* enable DAC clock */
    rcu_periph_clock_enable(RCU_DAC);
    /* enable AFIO clock */
    rcu_periph_clock_enable(RCU_AF);
}

void gpio_config(void)
{
    /* configure PA4 as DAC output */
    gpio_init(GPIOA, GPIO_MODE_AIN, GPIO_OSPEED_50MHZ, GPIO_PIN_4);

    /* configure PA9 as EXTI input */
    gpio_init(GPIOA, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_9);
}

void dac_config(void)
{
    /* initialize DAC */
    dac_deinit(DAC0);
    /* DAC trigger config */
    dac_trigger_source_config(DAC0, DAC_OUT0, DAC_TRIGGER_EXTI_9);
    /* DAC trigger enable */
    dac_trigger_enable(DAC0,DAC_OUT0);
    /* DAC wave mode config */
    dac_wave_mode_config(DAC0, DAC_OUT0, DAC_WAVE_MODE_LFSR);
    dac_lfsr_noise_config(DAC0, DAC_OUT0, DAC_LFSR_BITS11_0);

    /* DAC enable */
    dac_enable(DAC0,DAC_OUT0);
    dac_data_set(DAC0, DAC_OUT0, DAC_ALIGN_12B_R, 0);
}

void exti_line9_config(void)
{
    /* connect key EXTI line to key GPIO pin */
    gpio_exti_source_select(GPIO_PORT_SOURCE_GPIOA, GPIO_PIN_SOURCE_9);

    /* configure key EXTI line */
    exti_init(EXTI_9, EXTI_EVENT, EXTI_TRIG_RISING);
    exti_flag_clear(EXTI_9);
}

代码讲解

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

GD32 DBG — DBG_timer1_stop

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

DBG — DBG_timer1_stop

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

功能简介

本示例演示 DBG 的基本用法。

完整代码

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

代码讲解

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

GD32 DMA — Flash → RAM

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

DMA — Flash → RAM

固件库: GD32F30x_Firmware_Library V3.0.3
芯片: GD32F30x（以 GD32F307 评估板为例）
源文件: GD32F30x_Firmware_Library_V3.0.3/Examples/DMA/Flash_to_ram/main.c
配套: gd32f30x_it.c 中的 DMA0_Channel0_IRQHandler（置完成标志）

功能简介

本示例演示 DMA 最纯粹的用途：把一块 Flash 上的数据，自动搬到 RAM 数组里。为了"造出"可搬运的 Flash 内容，例程先做了三件事：

擦除 Flash 的 0x08004000 起始处的若干页（擦成全 0xFF）。
编程这些 Flash 页，每 4 字节写一个固定值 0x3210ABCD。
用 DMA0 通道0（内存到内存模式）把这 0x400（1024）字节从 Flash 自动搬进 RAM 数组 g_destbuf[]。

搬运结束后，在 DMA 完成中断里把 g_dmacomplete_flag 置 1，主循环解除等待，再逐字节比对：如果 g_destbuf 里全是 0x3210ABCD，说明 DMA 搬运成功 → 4 颗 LED 全亮；否则只亮 LED2、LED4 表示出错。

为什么搬 Flash 还要先擦再写？ 因为 Flash 只能把 1 写成 0、不能把 0 直接写成 1，所以写入前必须整页擦除（擦除后全为 1，即 0xFF）。这是 Flash 的物理特性，和前面 FMC 例程一致。本例的重点其实不是 Flash 操作，而是"DMA 怎么搬"——Flash 那部分只是给 DMA 准备一个数据源。

硬件准备

GD32F30x 评估板一块（LED2/LED3/LED4/LED5 由 gd_eval_led_init 初始化）。
无需任何外部接线。本例完全是片内 Flash ↔ RAM 的搬运，下载程序即可观察 LED。
若用调试器（如 J-Link / DAP），可在搬运前后观察 g_destbuf[] 和 0x08004000 处的内容，验证搬运正确性。

⚠️ 地址安全提醒：BANK0_WRITE_START_ADDR = 0x08004000。这个地址在 Flash 靠前的"用户区"，务必确认它不在你的程序代码区，否则擦写会破坏正在运行的代码。评估板例程默认这里空闲；你自己移植时请选程序末尾之后的空闲页。

完整代码（带中文注释）

注：DMA0_Channel0_IRQHandler 在 gd32f30x_it.c 里，搬运完成后被调用，把标志位置 1。此处一并列出。

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

#define TRANSFER_NUM           0x400    /* 搬运总字节数：1024 字节 */
#define FMC_PAGE_SIZE          ((uint16_t)0x800)        /* Flash 每页 2KB */
#define BANK0_WRITE_START_ADDR ((uint32_t)0x08004000)   /* 被读/写的 Flash 起始地址 */

void rcu_config(void);
void nvic_config(void);
void led_config(void);

/* DMA 完成标志：中断里置 1，主循环里等待它 */
__IO uint32_t g_dmacomplete_flag = 0;
/* DMA 的目标缓冲区（在 RAM 里） */
uint8_t g_destbuf[TRANSFER_NUM];
/* 要写进 Flash 的固定数据 */
const uint32_t transdata = 0x3210ABCD;
fmc_state_enum fmcstatus = FMC_READY;

int main(void)
{
    uint32_t i, count;
    uint32_t *ptrd;
    uint32_t address = 0x00;
    ErrStatus access_flag = SUCCESS;
    dma_parameter_struct dma_init_struct;
    uint32_t wperror = 0;

    rcu_config();        /* 开 DMA0 时钟 */
    nvic_config();       /* 配置 DMA0 通道0 中断 */
    led_config();        /* LED 初始化 */
    fmc_unlock();        /* 解锁 Flash 控制器（写 Flash 前必须） */

    /* ---- 第 1 步：擦除 Flash 页（擦成 0xFF）---- */
    count = TRANSFER_NUM / FMC_PAGE_SIZE;   /* 1024/2048 = 0，循环会擦 2 页(0,1) */
    fmc_flag_clear(FMC_FLAG_BANK0_PGERR | FMC_FLAG_BANK0_WPERR | FMC_FLAG_BANK0_END);
    for(i = 0; i <= count; i++){
        fmcstatus = fmc_page_erase(BANK0_WRITE_START_ADDR + (FMC_PAGE_SIZE * i));
        wperror += (fmcstatus == FMC_WPERR);
        fmc_flag_clear(FMC_FLAG_BANK0_PGERR | FMC_FLAG_BANK0_WPERR | FMC_FLAG_BANK0_END);
    }
    if(wperror != 0){ while(1); }   /* 擦除出错就卡死 */
    fmc_lock();                      /* 擦完先上锁 */

    /* 校验：擦除后读出来应该全是 0xFFFFFFFF */
    ptrd = (uint32_t*)BANK0_WRITE_START_ADDR;
    count = TRANSFER_NUM / sizeof(*ptrd);   /* 按 32 位（4字节）算个数 */
    for(i = 0; i < count; i++){
        if(0xFFFFFFFF != *ptrd){
            access_flag = ERROR;
            break;
        }
        ptrd++;
    }
    if(ERROR == access_flag){ while(1); }

    /* ---- 第 2 步：编程 Flash，每 4 字节写 0x3210ABCD ---- */
    fmc_unlock();
    fmc_flag_clear(FMC_FLAG_BANK0_PGERR | FMC_FLAG_BANK0_WPERR | FMC_FLAG_BANK0_END);
    address = BANK0_WRITE_START_ADDR;
    wperror = 0;
    count = BANK0_WRITE_START_ADDR + TRANSFER_NUM;   /* 结束地址 */
    while(address < count){
        fmcstatus = fmc_word_program(address, transdata);
        address = address + 4;
        wperror += (FMC_WPERR == fmcstatus);
        fmc_flag_clear(FMC_FLAG_BANK0_PGERR | FMC_FLAG_BANK0_WPERR | FMC_FLAG_BANK0_END);
    }
    if(wperror != 0){ while(1); }
    fmc_lock();

    /* 先把 RAM 目标缓冲清零，方便后面比对 */
    memset(g_destbuf, 0, TRANSFER_NUM);

    /* ---- 第 3 步：配置并启动 DMA，把 Flash 搬到 RAM ---- */
    dma_deinit(DMA0, DMA_CH0);
    dma_init_struct.direction    = DMA_PERIPHERAL_TO_MEMORY;  /* 方向：外设(Flash)→内存(RAM) */
    dma_init_struct.memory_addr  = (uint32_t)g_destbuf;       /* 目标：RAM 数组 */
    dma_init_struct.memory_inc   = DMA_MEMORY_INCREASE_ENABLE;/* 目标地址自增 */
    dma_init_struct.memory_width = DMA_MEMORY_WIDTH_8BIT;     /* 每次搬 8 位 */
    dma_init_struct.number       = TRANSFER_NUM;              /* 共搬 1024 次 */
    dma_init_struct.periph_addr  = (uint32_t)BANK0_WRITE_START_ADDR; /* 源：Flash 地址 */
    dma_init_struct.periph_inc   = DMA_PERIPH_INCREASE_ENABLE;/* 源地址自增 */
    dma_init_struct.periph_width = DMA_PERIPHERAL_WIDTH_8BIT; /* 每次搬 8 位 */
    dma_init_struct.priority     = DMA_PRIORITY_ULTRA_HIGH;   /* 最高优先级 */
    dma_init(DMA0, DMA_CH0, &dma_init_struct);

    dma_circulation_disable(DMA0, DMA_CH0);          /* 不循环，只搬一次 */
    dma_memory_to_memory_enable(DMA0, DMA_CH0);      /* 开启内存到内存模式（仅 DMA0 支持） */
    dma_interrupt_enable(DMA0, DMA_CH0, DMA_INT_FTF);/* 搬运完成(FTF)时进中断 */
    dma_channel_enable(DMA0, DMA_CH0);               /* 启动！DMA 开始自动搬运 */

    /* 主循环在此等待 DMA 完成中断置位标志（CPU 此时是"被通知"而非死等外设） */
    while(0 == g_dmacomplete_flag);

    /* ---- 第 4 步：比对搬运结果 ---- */
    ptrd = (uint32_t *)g_destbuf;
    count = TRANSFER_NUM / sizeof(*ptrd);
    for(i = 0; i < count; i++){
        if(transdata != *ptrd){
            access_flag = ERROR;
            break;
        }
        ptrd++;
    }

    /* 搬运成功 → 4 颗 LED 全亮；失败 → 只亮 LED2、LED4 */
    if(access_flag != ERROR){
        gd_eval_led_on(LED2);
        gd_eval_led_on(LED3);
        gd_eval_led_on(LED4);
        gd_eval_led_on(LED5);
    } else {
        gd_eval_led_on(LED2);
        gd_eval_led_on(LED4);
    }

    while(1);
}

/* LED 初始化 */
void led_config(void)
{
    gd_eval_led_init(LED2);
    gd_eval_led_init(LED3);
    gd_eval_led_init(LED4);
    gd_eval_led_init(LED5);
    gd_eval_led_off(LED2);
    gd_eval_led_off(LED3);
    gd_eval_led_off(LED4);
    gd_eval_led_init(LED5);
}

/* 开 DMA0 时钟 */
void rcu_config(void)
{
    rcu_periph_clock_enable(RCU_DMA0);
}

/* 使能 DMA0 通道0 中断 */
void nvic_config(void)
{
    nvic_irq_enable(DMA0_Channel0_IRQn, 0, 0);
}

gd32f30x_it.c 中的 DMA 完成中断（搬运结束后自动调用）：

void DMA0_Channel0_IRQHandler(void)
{
    if(dma_interrupt_flag_get(DMA0, DMA_CH0, DMA_INT_FLAG_FTF)) {
        dma_interrupt_flag_clear(DMA0, DMA_CH0, DMA_INT_FLAG_FTF);  /* 清中断标志 */
        g_dmacomplete_flag = 1;   /* 通知主循环：搬运完成！ */
    }
}

代码分段讲解

1. Flash 操作：先擦、再写、再读

DMA 之前那一长串其实是"给 DMA 准备数据源"：

fmc_unlock();                       // 写 Flash 前必须解锁
fmc_page_erase(0x08004000 + i*0x800);  // 按页擦除（2048 字节/页）
...
fmc_word_program(address, 0x3210ABCD); // 每 4 字节写固定值
fmc_lock();                         // 写完上锁

TRANSFER_NUM = 0x400 = 1024 字节，每页 0x800 = 2048 字节，所以 count = 0，for(i=0; i<=0; i++) 实际擦了 2 页（i=0 和 i=1，地址 0x08004000 与 0x08004800），足够覆盖 1024 字节。
擦除后先校验是否全 0xFFFFFFFF，写之前再校验，是为了提前发现 Flash 操作异常，避免"脏数据"被 DMA 搬走。

这一部分本质就是 FMC（Flash 控制器）的用法，详见同模块的 Erase_Program 例程。本例的重点始终是 DMA，Flash 只是"造数据"。

2. DMA 配置：告诉它"从哪搬、搬到哪、搬多少"

这是全例的灵魂，对应 dma_init_struct 的字段：

字段	取值	含义
`direction`	`DMA_PERIPHERAL_TO_MEMORY`	源是"外设侧"，目标是"内存侧"（内存到内存也用这个枚举）
`periph_addr`	`0x08004000`	源地址 = Flash 起始
`periph_inc`	`ENABLE`	搬完一个字节，源地址 +1
`periph_width`	`8BIT`	每次搬 1 字节
`memory_addr`	`g_destbuf`	目标地址 = RAM 数组
`memory_inc`	`ENABLE`	搬完一个字节，目标地址 +1
`memory_width`	`8BIT`	每次搬 1 字节
`number`	`0x400`	一共搬 1024 次（共 1024 字节）
`priority`	`ULTRA_HIGH`	总线仲裁优先级最高

number 的"单位"容易踩坑：它是"传输次数"，每次搬运的字节数由 width 决定。这里 width=8bit、number=1024，所以总共搬 1024 字节。若 width 改成 32bit，则 1024 次会搬 4096 字节——要和你的缓冲区大小匹配。

3. 三种关键"开关"

1
2
3

dma_circulation_disable(DMA0, DMA_CH0);       // 普通模式：搬完一次就停
dma_memory_to_memory_enable(DMA0, DMA_CH0);   // 内存到内存模式（仅 DMA0 支持！）
dma_interrupt_enable(DMA0, DMA_CH0, DMA_INT_FTF);  // 搬完触发"全传输完成"中断

循环模式关：本例只搬一次。若开循环（如 ADC 连续采样），搬完会自动从头再来。
内存到内存开：Flash→RAM 本质是"内存到内存"。注意这是 DMA0 的专属能力，DMA1 不支持。
FTF 中断开：搬完 1024 字节后硬件自动进 DMA0_Channel0_IRQHandler。

4. 启动与"等通知"

1
2

dma_channel_enable(DMA0, DMA_CH0);   // 发令枪：DMA 开始自动搬运
while(0 == g_dmacomplete_flag);      // 等中断把标志置 1

DMA 一旦使能，硬件就在后台把 Flash 的 1024 字节逐字节搬进 g_destbuf，CPU 不用参与搬运。主循环这句 while(0 == g_dmacomplete_flag) 看起来像"死等"，但和"CPU 一个个字节轮询读 Flash"不同——这里是等中断通知，DMA 在搬的时候 CPU 本可以去干别的事（本例只是简单等待）。

5. 完成中断里做了什么？

void DMA0_Channel0_IRQHandler(void) {
    dma_interrupt_flag_clear(DMA0, DMA_CH0, DMA_INT_FLAG_FTF); // 必须清中断标志
    g_dmacomplete_flag = 1;
}

进中断第一件事清标志，否则会反复进中断。
置 g_dmacomplete_flag = 1，主循环随即跳出 while，进入最后的"比对"环节。

6. 结果比对与 LED 指示

`1`	`if(transdata != *ptrd) access_flag = ERROR; // 任一字不等于 0x3210ABCD 即判失败`

成功：4 颗 LED 全亮。
失败：只亮 LED2 + LED4（方便肉眼区分）。

实验现象

下载程序并复位后，DMA 自动把 Flash 内容搬到 RAM。
搬运成功（绝大多数情况）：LED2、LED3、LED4、LED5 全部常亮。
若失败（如 Flash 地址被程序占用、擦写异常）：仅 LED2、LED4 亮起。
用调试器查看：g_destbuf[0..1023] 全部为 0xCD 0xAB 0x10 0x32（小端，对应 0x3210ABCD）；0x08004000 处 Flash 内容与之一致。

常见问题

Q1：为什么我的板子烧进去后不亮灯 / 程序跑飞？
最可能是 0x08004000 这个 Flash 地址落在了你的代码区。擦写代码所在页会破坏正在运行的程序。请改 BANK0_WRITE_START_ADDR 到程序之后的空闲页（可用链接脚本/map 文件确认空闲区），或确认评估板例程默认该地址空闲。

Q2：DMA_PERIPHERAL_TO_MEMORY 方向用在 Flash→RAM，名字是不是搞反了？
没有反。GD32 的 DMA 结构体里"peripheral"侧和"memory"侧是逻辑角色：这里把 Flash 当作"源（peripheral 侧）"、RAM 数组当"目标（memory 侧）"，所以方向是 peripheral→memory。内存到内存搬运也复用这个枚举，关键是 dma_memory_to_memory_enable 开了。理解"谁源谁目标"即可，名字不必纠结。

Q3：内存到内存模式为什么只能用 DMA0？
这是 GD32 硬件设计限制：内存到内存的传输请求只能由 DMA0 产生。若你用 DMA1 开 dma_memory_to_memory_enable 是不会工作的。

Q4：想搬 32 位数据（比如整型数组）怎么改？
把 periph_width / memory_width 都改成 DMA_xxx_WIDTH_32BIT，同时 number 相应减半（字节数 / 4）。注意源/目标地址都要 4 字节对齐，否则可能出错。

Q5：搬运过程中 CPU 真的空闲吗？while(0==flag) 不是占着 CPU 吗？
DMA 搬运本身不占 CPU，全是硬件在做。本例主循环只是"等通知"，没干别的；真实项目里你可以把这段等待换成"去做其他任务 / 进低功耗"，等中断来了再回来处理数据，这正是 DMA 的价值。

Q6：和直接 memcpy 有什么区别？
memcpy 是 CPU 一条条指令搬，占满 CPU；DMA 是独立硬件搬，CPU 可并行。数据量越大、越频繁，DMA 优势越明显（如音频流、LCD 刷屏、ADC 连续采样）。

小结

本示例把 DMA 的"三要素 + 启动 + 中断"主线讲透：

准备数据：先用 FMC 擦除并编程 Flash，造出可被搬运的固定内容（重点在 DMA，Flash 只是数据源）。
开时钟 + 配中断：RCU_DMA0 + nvic_irq_enable(DMA0_Channel0_IRQn)。
填 DMA 三要素：源地址（Flash）、目标地址（RAM）、次数/宽度/自增。
开开关：关循环、开内存到内存、开 FTF 中断。
启动 + 等通知：dma_channel_enable 后靠中断置标志，主循环解除等待。
校验结果：比对 RAM 内容，用 LED 给出成功/失败指示。

记住 DMA = 不占 CPU 的搬运工，凡是"大块数据搬来搬去"的地方，都该想到它。

拓展应用

掌握基础 DMA 后，可以把它用到大量"数据搬运"场景：

RAM → USART（串口）：同目录 Ram_to_usart 例程，把发送数组交给 DMA 自动发出，CPU 不用死等 TBE。适合长文本/日志输出。
ADC → RAM（连续采样）：开启 ADC 的 DMA 请求 + 循环模式，ADC 每转换完一个点 DMA 自动搬进数组，实现"无 CPU 干预"的高速采样（如示波器、音频采集）。
内存 → SPI（刷屏）：驱动 SPI LCD 时，把显存数组用 DMA 发往 SPI，刷屏不再卡 CPU。
双缓冲（Ping-Pong）：配合半传输(HTF) + 全传输(FTF)中断，一块在 DMA 搬、一块 CPU 处理，实现流水线式数据流（音频、图像）。
与大数组拷贝结合：任何 for 循环批量拷贝，都可考虑用 DMA0 内存到内存替代以释放 CPU。

想把 DMA 接到"真外设"上，建议直接看同目录 Ram_to_usart，体会"内存 → 外设"方向和"减轻串口发送负担"的效果。

GD32 DMA — RAM → RAM

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

DMA — RAM → RAM

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

功能简介

本示例演示 DMA（直接存储器访问）的基本用法。DMA 可以在不占用 CPU 的情况下，在内存和外设之间搬运数据，大幅提升系统效率。

完整代码

#include "gd32f30x.h" 
#include "gd32f307c_eval.h"
#include <string.h>
#define DATANUM                  16
__IO ErrStatus transferflag1 = ERROR;
__IO ErrStatus transferflag2 = ERROR;
__IO ErrStatus transferflag3 = ERROR;
__IO ErrStatus transferflag4 = ERROR;

void destbuf_init(void);
void led_config(void);
ErrStatus uc_data_compare(uint8_t* src, uint8_t* dst, uint16_t length);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    int i = 0;
    dma_parameter_struct dma_init_struct;
    
    /* enable DMA clock */
    rcu_periph_clock_enable(RCU_DMA0);
    /* initialize LED */
    led_config();
    /* all LED off */
    gd_eval_led_off(LED2);
    gd_eval_led_off(LED3);
    gd_eval_led_off(LED4);
    gd_eval_led_off(LED5);
    
    destbuf_init();
    /* initialize DMA channel1 */
    dma_deinit(DMA0, DMA_CH1);
    
    dma_init_struct.direction = DMA_PERIPHERAL_TO_MEMORY;
    dma_init_struct.memory_addr = (uint32_t)destination_address1;
    dma_init_struct.memory_inc = DMA_MEMORY_INCREASE_ENABLE;
    dma_init_struct.memory_width = DMA_MEMORY_WIDTH_8BIT;
    dma_init_struct.number = DATANUM;
    dma_init_struct.periph_addr = (uint32_t)source_address;
    dma_init_struct.periph_inc = DMA_PERIPH_INCREASE_ENABLE;
    dma_init_struct.periph_width = DMA_PERIPHERAL_WIDTH_8BIT;
    dma_init_struct.priority = DMA_PRIORITY_ULTRA_HIGH;
    dma_init(DMA0, DMA_CH1, &dma_init_struct);
    /* configure DMA mode */
    dma_circulation_disable(DMA0, DMA_CH1);
    dma_memory_to_memory_enable(DMA0, DMA_CH1);
        
    /* initialize DMA channel2 */
    dma_deinit(DMA0, DMA_CH2);
    dma_init_struct.memory_addr = (uint32_t)destination_address2;
    dma_init(DMA0, DMA_CH2, &dma_init_struct);
    /* configure DMA mode */
    dma_circulation_disable(DMA0, DMA_CH2);
    dma_memory_to_memory_enable(DMA0, DMA_CH2);
        
    /* initialize DMA channel3 */
    dma_deinit(DMA0, DMA_CH3);
    dma_init_struct.memory_addr = (uint32_t)destination_address3;
    dma_init(DMA0, DMA_CH3, &dma_init_struct);
    /* configure DMA mode */
    dma_circulation_disable(DMA0, DMA_CH3);
    dma_memory_to_memory_enable(DMA0, DMA_CH3);
        
    /* initialize DMA channel4 */
    dma_deinit(DMA0, DMA_CH4);
    dma_init_struct.memory_addr = (uint32_t)destination_address4;
    dma_init(DMA0, DMA_CH4, &dma_init_struct);
    /* configure DMA mode */
    dma_circulation_disable(DMA0, DMA_CH4);
    dma_memory_to_memory_enable(DMA0, DMA_CH4);

    /* enable DMA channel1~channel4 */
    dma_channel_enable(DMA0, DMA_CH1);
    dma_channel_enable(DMA0, DMA_CH2);
    dma_channel_enable(DMA0, DMA_CH3);
    dma_channel_enable(DMA0, DMA_CH4);

    /* wait for DMA transfer complete */
    for(i = 0; i < 200; i++);
    /* compare the data of source_address with data of destination_address */
    transferflag1 = uc_data_compare(source_address, destination_address1, DATANUM);
    transferflag2 = uc_data_compare(source_address, destination_address2, DATANUM);
    transferflag3 = uc_data_compare(source_address, destination_address3, DATANUM);
    transferflag4 = uc_data_compare(source_address, destination_address4, DATANUM);

    /* if DMA channel1 transfer success,light LED2 */
    if(SUCCESS == transferflag1){
        gd_eval_led_on(LED2);
    }
    /* if DMA channel2 transfer success,light LED3 */
    if(SUCCESS == transferflag2){
        gd_eval_led_on(LED3);
    }
    /* if DMA channel3 transfer success,light LED4 */
    if(SUCCESS == transferflag3){
        gd_eval_led_on(LED4);
    }
    /* if DMA channel4 transfer success,light LED5 */
    if(SUCCESS == transferflag4){
        gd_eval_led_on(LED5);
    }
    
    while (1);
}

void destbuf_init(void)
{
    memset(destination_address1, 0, DATANUM);
    memset(destination_address2, 0, DATANUM);
    memset(destination_address3, 0, DATANUM);
    memset(destination_address4, 0, DATANUM);
}

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

代码讲解

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

GD32 DMA — RAM → USART

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

DMA — RAM → USART

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

功能简介

本示例演示 DMA（直接存储器访问）的基本用法。DMA 可以在不占用 CPU 的情况下，在内存和外设之间搬运数据，大幅提升系统效率。

完整代码

#include "gd32f30x.h" 
#include "gd32f307c_eval.h"
#define USART0_DATA_ADDRESS      ((uint32_t)0x40013804)
#define ARRAYNUM(arr_nanme)      (uint32_t)(sizeof(arr_nanme) / sizeof(*(arr_nanme)))

void led_config(void);
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 DMA clock */
    rcu_periph_clock_enable(RCU_DMA0);
    /* USART configure */
    gd_eval_com_init(EVAL_COM0);
    /*configure DMA interrupt*/
    nvic_config();
    /* initialize LED2 */
    led_config();   
    /* turn off LED2 */
    gd_eval_led_off(LED2);
    
    /* initialize DMA channel3 */
    dma_deinit(DMA0, DMA_CH3);
    dma_init_struct.direction = DMA_MEMORY_TO_PERIPHERAL;
    dma_init_struct.memory_addr = (uint32_t)welcome;
    dma_init_struct.memory_inc = DMA_MEMORY_INCREASE_ENABLE;
    dma_init_struct.memory_width = DMA_MEMORY_WIDTH_8BIT;
    dma_init_struct.number = ARRAYNUM(welcome);
    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);
    dma_memory_to_memory_disable(DMA0, DMA_CH3);

    /* USART DMA enable for transmission */
    usart_dma_transmit_config(USART0, USART_TRANSMIT_DMA_ENABLE);
    
    /* enable DMA transfer complete interrupt */
    dma_interrupt_enable(DMA0, DMA_CH3, DMA_INT_FTF);
    
    /* enable DMA channel3 */
    dma_channel_enable(DMA0, DMA_CH3);
   
    /* waiting for the transfer to complete*/
    while(RESET == g_transfer_complete);
    
    /* light LED2 */
    gd_eval_led_on(LED2);

    while (1);
}

void led_config(void)
{
    gd_eval_led_init (LED2);
}

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

代码讲解

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

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

GD32 ENET — 以太网 Telnet

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

ENET — 以太网 Telnet

固件库: GD32F30x_Firmware_Library V3.0.3
芯片: GD32
源文件: GD32F30x_Firmware_Library_V3.0.3/Examples/ENET/Telnet/src/main.c

功能简介

本示例演示 ENET 的基本用法。

完整代码

#include "gd32f30x.h"
#include "netconf.h"
#include "main.h"
#include "lwip/tcp.h"
#include "lwip/timeouts.h"
#include "gd32f307c_eval.h"
#include "hello_gigadevice.h"
#define SYSTEMTICK_PERIOD_MS  10
__IO uint32_t g_localtime = 0; /* for creating a time reference incremented by 10ms */

int main(void)
{
    gd_eval_com_init(EVAL_COM0);

    /* setup ethernet system(GPIOs, clocks, MAC, DMA, systick) */
    enet_system_setup();

    /* initilaize the LwIP stack */
    lwip_stack_init();

    while(1) {

#ifndef USE_ENET_INTERRUPT
        /* check if any packet received */
        if(enet_rxframe_size_get()) {
            /* process received ethernet packet */
            lwip_frame_recv();
        }
#endif /* USE_ENET_INTERRUPT */

        /* handle periodic timers for LwIP */
#ifdef TIMEOUT_CHECK_USE_LWIP
        sys_check_timeouts();

#ifdef USE_DHCP
        lwip_dhcp_address_get();
#endif /* USE_DHCP */

#else
        lwip_timeouts_check(g_localtime);
#endif /* TIMEOUT_CHECK_USE_LWIP */
    }
}

代码讲解

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

GD32 EXMC — NAND Flash

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

EXMC — NAND Flash

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

功能简介

本示例演示外部存储控制器。XMC/EXMC 可以连接并口 LCD、NAND Flash、SRAM 等外部总线设备，实现高速数据传输。

完整代码

#include "gd32f30x.h"
#include <stdio.h>
#include "gd32f307c_eval.h"
#include "exmc_nandflash.h"
#define BUFFER_SIZE                 (0x100U)
#define NAND_GD_MAKERID             (0xC8U)
#define NAND_GD_DEVICEID            (0xF1U)

int main(void)
{
    /* LED initialize */
    gd_eval_led_init(LED2);
    gd_eval_led_init(LED4);
    /* config the USART */
    gd_eval_com_init(EVAL_COM0);
    /* config the EXMC access mode */
    exmc_nandflash_init();
    /* read NAND ID */
    nand_read_id(&nand_id);

    printf("read NAND ID");
    /* print NAND ID */
    printf("\r\nNand flash ID:0x%X 0x%X 0x%X 0x%X\r\n",nand_id.maker_id,nand_id.device_id,
                                               nand_id.third_id,nand_id.fourth_id);

    if((NAND_GD_MAKERID == nand_id.maker_id) && (NAND_GD_DEVICEID == nand_id.device_id))
    {
        /* set the read and write the address */
        zone = 0;
        block = 10;
        page = 0;
        pageoffset = 1100;
        writereadaddr = ((zone * NAND_ZONE_SIZE + block) * NAND_BLOCK_SIZE + page) 
                        * NAND_PAGE_SIZE + pageoffset;

        /* whether address cross-border */
        if((writereadaddr + BUFFER_SIZE ) > NAND_MAX_ADDRESS)
        {
            printf("\r\naddress cross-border");

            /* failure, light on LED4 */
            gd_eval_led_on(LED4);
            while(1);
        }

        /* fill writebuffer with 0x00.. */
        fill_buffer_nand(txbuffer, BUFFER_SIZE , 0x00);

        /* write data to nand flash */
        status = nand_write(writereadaddr, txbuffer, BUFFER_SIZE);
        if(NAND_OK == status)
        {
            printf("\r\nwrite data successfully!");
        }
        else
        {
            printf("\r\nwrite data failure!");

            /* failure, light on LED4 */
            gd_eval_led_on(LED4);
            while(1);
        }

        /* read data from nand flash */
        status = nand_read(writereadaddr, rxbuffer, BUFFER_SIZE);
        if(NAND_OK == status)
        {
            printf("\r\nread data successfully!");
        }
        else
        {
            printf("\r\nread data failure!\n\r");

            /* failure, light on LED4 */
            gd_eval_led_on(LED4);
            while(1);
        }

        /* Read and write data comparison for equality */
        writereadstatus = 0;
        for(j = 0; j < BUFFER_SIZE; j++)
        {
            if(txbuffer[j] != rxbuffer[j])
            {
                writereadstatus++;
                break;
            }
        }

        printf("\r\nthe result to access the nand flash:");
        if (writereadstatus == 0)
        { 
            printf("\r\naccess NAND flash successfully!");

            gd_eval_led_on(LED2);
        }
        else
        { 
            printf("\r\naccess NAND flash failure!");
            
            /* failure, light on LED4 */
            gd_eval_led_on(LED4);
            while(1);
        }
        printf("\r\nprintf data to be read:\r\n");
        for(k = 0; k < BUFFER_SIZE; k ++)
        {
            printf("0x%02X ",rxbuffer[k]);
        }
    }
    else
    {
        printf("\n\rread NAND ID failure!\n\r");
        
        /* failure, light on LED4 */
        gd_eval_led_on(LED4);
        while(1);
    }

    while (1);
}

代码讲解

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

GD32 EXMC — 外部 LCD

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

EXMC — 外部 LCD

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

功能简介

本示例演示外部存储控制器。XMC/EXMC 可以连接并口 LCD、NAND Flash、SRAM 等外部总线设备，实现高速数据传输。

完整代码

#include "gd32f30x.h"
#include "exmc_lcd.h"
#include "ili9320.h"
#include "picture.h"

int main(void)
{
    uint16_t i;

    /* configure the EXMC access mode */
    exmc_lcd_init();

    /* read the LCD Controller device code:(0x8989) */
    device_code = lcd_register_read(0x0000);

    /* initialize the LCD */
    lcd_init();

    /* clear the LCD screen */
    lcd_clear(WHITE);
    
    /* draw the picture of Gigadevice logo */
    lcd_picture_draw(40,100,40+160-1,100+87-1,(uint16_t *)(picture + BMP_HEADSIZE));

    /* draw a rectangle */
    lcd_rectangle_draw(10,10,230,310,BLUE);

    /* configure char format */
    char_format.char_color = BLUE;
    char_format.bk_color = WHITE;
    char_format.direction = CHAR_DIRECTION_VERTICAL;
    char_format.font = CHAR_FONT_8_16;
    
    /* draw character on LCD screen */
    for (i = 0; i < sizeof(gd_website_string)-1; i++){
        lcd_char_display((50+8*i), 180+20, *(gd_website_string+i),char_format);
    }
    
    while(1){
    }
}

代码讲解

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

GD32 EXTI — 按键外部中断

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

EXTI — 按键外部中断

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

功能简介

本示例演示外部中断功能。当外部引脚电平发生变化时，自动触发中断服务函数。按键检测、信号边沿捕获等场景都会用到。

完整代码

#include "gd32f30x.h"
#include "gd32f307c_eval.h"

int main(void)
{
    /* initialize the LEDs and turn on LED1 */
    gd_eval_led_init(LED2);
    gd_eval_led_init(LED3);
    gd_eval_led_on(LED2);

    /* configure the tamper key */
    gd_eval_key_init(KEY_TAMPER, KEY_MODE_EXTI);

    while(1) {
    }
}

代码讲解

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

GD32 FMC — Flash 擦写

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

FMC — Flash 擦写

固件库: GD32F30x_Firmware_Library V3.0.3
芯片: GD32F30x（以 GD32F307 评估板为例）
源文件: GD32F30x_Firmware_Library_V3.0.3/Examples/FMC/Erase_Program/main.c
配套: main.h（定义 led_typedef_enum、全局 lednum 等）

功能简介

本示例演示 FMC（Flash 控制器） 最基础也最重要的两项操作：擦除（Erase） 和 编程（Program / 写） 片内 Flash，并对结果做校验。

整个流程分两步：

擦除：把 0x08004000 ~ 0x08004800 这一页 Flash 擦成全 0xFF（擦除后该页所有字节变为 0xFFFFFFFF）。
编程：把固定数据 0x01234567 逐字（每 4 字节）写入刚才擦除的那一页。
校验：
- 擦除后检查是否全为 0xFFFFFFFF；若不是 → 点亮 LED2 表示擦除失败。
- 写入后检查是否全为 0x01234567；若不是 → 点亮 LED3 表示写入失败。
- 全成功 → 点亮 LED4。

这是一个"纯片内 Flash 自操作"的例子，无需任何外部器件，下载即可观察 LED，是理解 Flash 存储机制的绝佳起点。

硬件准备

GD32F30x 评估板一块（例程用 LED2 / LED3 / LED4，gd_eval_led_init 初始化）。
无需外部接线。完全片内操作。
若用调试器，可在擦除/编程后观察 0x08004000 处内存：擦除后应为连续的 0xFFFFFFFF，编程后应为连续的 0x01234567。

⚠️ 地址安全：本例写的 0x08004000 是评估板默认空闲的 Flash 页。若你移植到自己的工程，请确认该地址不在你的程序代码区（查 .map 文件找空闲区），否则擦写会破坏正在运行的程序。

完整代码（带中文注释）

#include "gd32f30x.h"
#include "gd32f307c_eval.h"
#include "main.h"

#define FMC_PAGE_SIZE           ((uint16_t)0x800U)   /* Flash 每页 2KB */
#define FMC_WRITE_START_ADDR    ((uint32_t)0x08004000U) /* 操作起始地址 */
#define FMC_WRITE_END_ADDR      ((uint32_t)0x08004800U) /* 操作结束地址（含） */

uint32_t *ptrd;
uint32_t address = 0x00000000U;
uint32_t data0   = 0x01234567U;        /* 要写入的固定数据 */
led_typedef_enum lednum = LED4;        /* 最终状态灯，默认 LED4（成功） */

/* 要计算的页数：(0x08004800 - 0x08004000) / 0x800 = 1 页 */
uint32_t PageNum = (FMC_WRITE_END_ADDR - FMC_WRITE_START_ADDR) / FMC_PAGE_SIZE;
/* 要计算的字数：(0x800) / 4 = 512 个字（即 2048 字节） */
uint32_t WordNum = ((FMC_WRITE_END_ADDR - FMC_WRITE_START_ADDR) >> 2);

/*!
    \brief      擦除 FMC 页（从起始地址到结束地址）
*/
void fmc_erase_pages(void)
{
    uint32_t EraseCounter;

    fmc_unlock();   /* ① 解锁 Flash（写前必做） */

    /* ② 清除所有待处理标志 */
    fmc_flag_clear(FMC_FLAG_BANK0_END);
    fmc_flag_clear(FMC_FLAG_BANK0_WPERR);
    fmc_flag_clear(FMC_FLAG_BANK0_PGERR);

    /* ③ 逐页擦除 */
    for(EraseCounter = 0; EraseCounter < PageNum; EraseCounter++){
        fmc_page_erase(FMC_WRITE_START_ADDR + (FMC_PAGE_SIZE * EraseCounter));
        fmc_flag_clear(FMC_FLAG_BANK0_END);
        fmc_flag_clear(FMC_FLAG_BANK0_WPERR);
        fmc_flag_clear(FMC_FLAG_BANK0_PGERR);
    }

    fmc_lock();     /* ④ 擦完上锁 */
}

/*!
    \brief      逐字编程 FMC（把 data0 写入每一字）
*/
void fmc_program(void)
{
    fmc_unlock();   /* ① 解锁 */

    /* ② 清除标志 */
    fmc_flag_clear(FMC_FLAG_BANK0_END);
    fmc_flag_clear(FMC_FLAG_BANK0_WPERR);
    fmc_flag_clear(FMC_FLAG_BANK0_PGERR);

    address = FMC_WRITE_START_ADDR;

    /* ③ 从起始地址到结束地址，每 4 字节写一个字 */
    while(address < FMC_WRITE_END_ADDR){
        fmc_word_program(address, data0);
        address += 4;    /* Flash 按字（4字节）编程 */
        fmc_flag_clear(FMC_FLAG_BANK0_END);
        fmc_flag_clear(FMC_FLAG_BANK0_WPERR);
        fmc_flag_clear(FMC_FLAG_BANK0_PGERR);
    }

    fmc_lock();     /* ④ 写上锁 */
}

/*!
    \brief      校验擦除结果（应全为 0xFFFFFFFF）
*/
void fmc_erase_pages_check(void)
{
    uint32_t i;

    ptrd = (uint32_t *)FMC_WRITE_START_ADDR;

    for(i = 0; i < WordNum; i++){
        if(0xFFFFFFFF != (*ptrd)){   /* 有任一个字不是全 1，说明没擦干净 */
            lednum = LED2;           /* 标记擦除失败 */
            gd_eval_led_on(lednum);
            break;
        } else {
            ptrd++;
        }
    }
}

/*!
    \brief      校验编程结果（应全为 data0=0x01234567）
*/
void fmc_program_check(void)
{
    uint32_t i;

    ptrd = (uint32_t *)FMC_WRITE_START_ADDR;

    for(i = 0; i < WordNum; i++){
        if((*ptrd) != data0){        /* 有任一个字不等于写入值，说明写失败 */
            lednum = LED3;           /* 标记写入失败 */
            gd_eval_led_on(lednum);
            break;
        } else {
            ptrd++;
        }
    }
}

int main(void)
{
    /* 初始化 LED2/LED3/LED4 */
    gd_eval_led_init(LED2);
    gd_eval_led_init(LED3);
    gd_eval_led_init(LED4);

    /* 步骤1：擦除并校验；失败则点亮 LED2 */
    fmc_erase_pages();
    fmc_erase_pages_check();

    /* 步骤2：编程并校验；失败则点亮 LED3 */
    fmc_program();
    fmc_program_check();

    /* 全部成功（lednum 仍为默认 LED4）→ 点亮 LED4 */
    if(LED4 == lednum){
        gd_eval_led_on(LED4);
    }

    while(1);
}

代码分段讲解

1. 全局宏与"页数/字数"计算

#define FMC_PAGE_SIZE        0x800     // 每页 2KB
#define FMC_WRITE_START_ADDR 0x08004000
#define FMC_WRITE_END_ADDR   0x08004800
uint32_t PageNum = (0x08004800 - 0x08004000) / 0x800;  // = 1 页
uint32_t WordNum = (0x08004800 - 0x08004000) >> 2;     // = 0x200 = 512 字

操作区间是 0x08004000 ~ 0x08004800，跨度 0x800 = 2KB，正好是 1 个 Flash 页，所以擦除循环只擦 1 页。
WordNum = 512：这一页共 2048 字节，按 32 位（4 字节）字算就是 512 个字，写入/校验都按这 512 个字循环。

2. “解锁 → 清标志 → 操作 → 上锁"四步曲

擦除和编程函数结构完全对称，都遵循这条黄金流程：

fmc_unlock();                              // ① 解锁（Flash 默认锁着，不解锁写不进）
fmc_flag_clear(FMC_FLAG_BANK0_END);        // ② 清标志（避免上次残留状态干扰）
fmc_flag_clear(FMC_FLAG_BANK0_WPERR);      //    写保护错误标志
fmc_flag_clear(FMC_FLAG_BANK0_PGERR);      //    编程错误标志
/* ... 具体操作 ... */
fmc_lock();                                // ④ 上锁（写完保护 Flash）

解锁：Flash 上电后处于锁定状态，任何写操作都会被拒绝。fmc_unlock() 内部写入特定密钥序列来解锁。每次重新解锁前若已锁，需先 lock 再 unlock（例程每次操作开头都 unlock，结尾都 lock，规范）。
清标志：Flash 操作会产生 END（完成）、WPERR（写保护错）、PGERR（编程错）等状态位。操作前清一次、每次操作后也清，确保状态干净、便于判断本次结果。

3. 擦除：整页擦成 0xFF

`1`	`fmc_page_erase(FMC_WRITE_START_ADDR + 0x800 * EraseCounter);`

Flash 不能单独改某个字节，只能"整页擦除”。擦除后该页每个位都回到 1，即读出 0xFFFFFFFF。所以擦除校验就是判断"是不是全 0xFFFFFFFF"。这也是为什么想改写 Flash 必须先擦——不擦直接写，旧数据会和新数据"与"在一起出错。

4. 编程：按字写 0x01234567

while(address < FMC_WRITE_END_ADDR){
    fmc_word_program(address, data0);  // 在 address 处写一个 32 位字
    address += 4;                      // 字 = 4 字节，地址 +4
}

fmc_word_program 一次写 4 字节（一个字）。所以循环里 address += 4，从 0x08004000 一直写到 0x08004800。
写入的值是固定 0x01234567，写满整页 512 个字。
注意写入前必须确保该页已擦除（本例先擦后写，顺序正确）。

5. 两段校验：只读不写

ptrd = (uint32_t *)FMC_WRITE_START_ADDR;
for(i = 0; i < WordNum; i++){
    if(0xFFFFFFFF != *ptrd){ lednum = LED2; ... break; }
    ptrd++;
}

校验就是把 Flash 当普通内存（uint32_t * 指针）读出来比一比：擦除后应为全 0xFFFFFFFF，写之后应为全 0x01234567。读 Flash 不需要解锁，直接指针访问即可。一旦有字不符，就通过 lednum 记下是哪步失败（LED2=擦除失败，LED3=写入失败）并点亮对应灯。

6. main：两步串起来，LED4 表成功

1
2
3

fmc_erase_pages();        fmc_erase_pages_check();   // 第一步
fmc_program();            fmc_program_check();        // 第二步
if(LED4 == lednum) gd_eval_led_on(LED4);             // 都没出错才亮 LED4

lednum 初值设为 LED4（成功态）。只有擦除和写入全程无误，lednum 才保持 LED4，最后点亮 LED4；任一步出错，lednum 会被改成 LED2 或 LED3，LED4 就不会亮。这是一种简洁的"状态灯"写法。

实验现象

下载程序并复位后，Flash 自动被擦除、写入、校验。
正常情况：只有 LED4 亮（代表擦除 + 写入 + 校验全部成功）。
异常情况：
- 擦除失败 → LED2 亮（LED4 不亮）。
- 写入失败 → LED3 亮（LED4 不亮）。
用调试器查看 0x08004000：
- 擦除后：FF FF FF FF FF FF FF FF ...（全 1）。
- 写入后：67 45 23 01 67 45 23 01 ...（小端存储 0x01234567）。

常见问题

Q1：为什么一写就进 HardFault / 程序跑飞？
最常见是写到了正在运行的代码区。Flash 不能擦写当前执行代码的页。请确认 FMC_WRITE_START_ADDR 在你的程序代码范围之外（末尾空闲页）。评估板 0x08004000 默认空闲，但大工程可能代码已占满到此。

Q2：为什么擦除后某个字不是 0xFFFFFFFF？
擦除不完整通常因为：① 没有先 fmc_unlock()；② 上一次操作残留的 PGERR/WPERR 没清；③ 该页被写保护了（见 Write_Protection 例程）。先确认解锁和清标志都做了。

Q3：想改某个字节的数据，必须整页擦除吗？
是的，Flash 的最小擦除单位就是"页"（2KB）。如果某页里还存有不想丢的数据，标准做法是：先把整页读出来备份到 RAM，修改目标字节，再整页擦除、把备份写回去。这也叫"Flash 模拟 EEPROM"的惯用手法。

Q4：写入函数一定要按 4 字节（字）吗？
本例用 fmc_word_program（32 位）。库也提供 fmc_halfword_program（16 位）、fmc_byte_program（8 位，视型号支持）。但底层仍受 Flash 物理对齐约束，写之前该地址必须已擦除。

Q5：写之前一定要清 END/WPERR/PGERR 标志吗？
强烈建议清。不清的话，若之前有错误标志残留，本次操作可能立刻被判失败或卡住。例程在每次操作前后都清，是稳妥写法。

Q6：擦写 Flash 会不会很慢、影响中断？
Flash 擦除一页需要若干毫秒，写一字约几十微秒，期间 CPU 仍可运行（GD32 有 Flash 缓存/预取），但擦写期间若要从该 Flash 取指令可能等待。对时序极苛刻的中断，关键代码可放在 RAM 里执行。一般应用无需担心。

小结

本示例把 FMC 的黄金流程讲得干干净净：

算好范围：确定要操作的页数和字数（按页擦、按字写）。
解锁：fmc_unlock() 是写 Flash 的前置条件。
清标志：操作前后清 END / WPERR / PGERR。
擦页：fmc_page_erase() 把整页擦成 0xFFFFFFFF（不能只改字节）。
写字：fmc_word_program() 按 4 字节逐字写入。
上锁 + 校验：fmc_lock() 保护；用指针读回比对，LED 指示成败。

记住 Flash = “先整页擦、再按字写、写前必解锁” 这三句话，你就掌握了片内存储的底层逻辑。

拓展应用

掌握 Flash 擦写后，可以做很多"掉电不丢"的实用功能：

保存配置参数：把设备的校准值、用户设置写到指定 Flash 页，上电读取恢复；修改时按"备份→擦除→回写"流程。
IAP / OTA 升级：旧程序通过 FMC 把新固件写到另一块 Flash 区，再用跳转指令接管运行——这是绝大多数单片机远程升级的基础。
运行计数器 / 公里数：如电机累计转数、设备累计工作时间，定期写入 Flash 持久化。
黑匣子 / 日志：记录最近一次异常现场数据，掉电后仍能读取排查。
数据加密存储：配合唯一 ID 与简单加解密，把敏感参数存进 Flash。
结合 DMA：如 Flash_to_ram 例程，先把数据写进 Flash，再用 DMA 高速搬回 RAM 做处理。

想给 Flash 加保护防止误擦写，可阅读同模块 Write_Protection 例程。

GD32 FMC — Flash 写保护

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

FMC — Flash 写保护

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

功能简介

本示例演示 FMC 的基本用法。

完整代码

#include "gd32f30x.h" 
#include "gd32f307c_eval.h"
#include <stdio.h>
#define FLASH_PAGE_PROGRAM
#define WRITE_PROTECTION_DISABLE
typedef enum {FAILED = 0, PASSED = !FAILED} test_state;
#define FLASH_PAGE_SIZE ((uint16_t)0x800)
#define FMC_PAGES_PROTECTED (OB_WP_6 | OB_WP_7)
#define BANK0_WRITE_START_ADDR  ((uint32_t)0x08006000)
#define BANK0_WRITE_END_ADDR    ((uint32_t)0x08008000)

int main(void)
{
    /* initialize led on the board */
    gd_eval_led_init(LED2);
    gd_eval_led_init(LED3);

    /* unlock the flash program/erase controller */
    fmc_unlock();
    ob_unlock();

    fmc_flag_clear(FMC_FLAG_BANK0_END);
    fmc_flag_clear(FMC_FLAG_BANK0_WPERR);
    fmc_flag_clear(FMC_FLAG_BANK0_PGERR);

    /* Get pages write protection status */
    wp_value = ob_write_protection_get();

#ifdef WRITE_PROTECTION_DISABLE
    /* Get pages already write protected */
    protected_pages = ~(wp_value | FMC_PAGES_PROTECTED);
  
    /* Check if desired pages are already write protected */
    if((wp_value | (~FMC_PAGES_PROTECTED)) != 0xFFFFFFFF ){
        /* Erase all the option Bytes */
        fmc_state = ob_erase();

        fmc_flag_clear(FMC_FLAG_BANK0_END);
        fmc_flag_clear(FMC_FLAG_BANK0_WPERR);
        fmc_flag_clear(FMC_FLAG_BANK0_PGERR);

        /* Check if there is write protected pages */
        if(protected_pages != 0x0){
            /* Restore write protected pages */
            fmc_state = ob_write_protection_enable(protected_pages);
        }
        /* Generate System Reset to load the new option byte values */
        NVIC_SystemReset();
    }

#elif defined WRITE_PROTECTION_ENABLE
    /* Get current write protected pages and the new pages to be protected */
    protected_pages =  (~wp_value) | FMC_PAGES_PROTECTED; 

    /* Check if desired pages are not yet write protected */
    if(((~wp_value) & FMC_PAGES_PROTECTED )!= FMC_PAGES_PROTECTED){

        /* Erase all the option Bytes because if a program operation is 
        performed on a protected page, the Flash memory returns a 
        protection error */
        fmc_state = ob_erase();

        fmc_flag_clear(FMC_FLAG_BANK0_END);
        fmc_flag_clear(FMC_FLAG_BANK0_WPERR);
        fmc_flag_clear(FMC_FLAG_BANK0_PGERR);

        /* Enable the pages write protection */
        fmc_state = ob_write_protection_enable(protected_pages);

        /* Generate System Reset to load the new option byte values */
        NVIC_SystemReset();
    }
#endif /* WRITE_PROTECTION_DISABLE */

#ifdef FLASH_PAGE_PROGRAM
    /* Get the number of pages to be erased */
    page_num = (BANK0_WRITE_END_ADDR - BANK0_WRITE_START_ADDR) / FLASH_PAGE_SIZE;

    /* The selected pages are not write protected */
    if((wp_value & FMC_PAGES_PROTECTED) != 0x00){
        /* Clear All pending flags */
        fmc_flag_clear(FMC_FLAG_BANK0_END);
        fmc_flag_clear(FMC_FLAG_BANK0_WPERR);
        fmc_flag_clear(FMC_FLAG_BANK0_PGERR);

        /* erase the FLASH pages */
        for(erase_counter = 0; (erase_counter < page_num) && (fmc_state == FMC_READY); erase_counter++){
            fmc_state = fmc_page_erase(BANK0_WRITE_START_ADDR + (FLASH_PAGE_SIZE * erase_counter));
        }

        fmc_flag_clear(FMC_FLAG_BANK0_END);
        fmc_flag_clear(FMC_FLAG_BANK0_WPERR);
        fmc_flag_clear(FMC_FLAG_BANK0_PGERR);

        /* FLASH Half Word program of data 0x1753 at addresses defined by BANK1_WRITE_START_ADDR and BANK1_WRITE_END_ADDR */
        Address = BANK0_WRITE_START_ADDR;

        while((Address < BANK0_WRITE_END_ADDR) && (fmc_state == FMC_READY)){
            fmc_state = fmc_halfword_program(Address, data);
            Address = Address + 2;
        }

        /* Check the correctness of written data */
        Address = BANK0_WRITE_START_ADDR;

        while((Address < BANK0_WRITE_END_ADDR) && (program_state != FAILED)){
            if((*(__IO uint16_t*) Address) != data){
                program_state = FAILED;
            }
            Address += 2;
        }
        gd_eval_led_on(LED2);
    }
    else{
        /* Error to program the flash : The desired pages are write protected */
        program_state = FAILED;
        gd_eval_led_on(LED3);

    }
#endif /* FLASH_PAGE_PROGRAM */
    while(1){
    }
}

代码讲解

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

GD32 FWDGT — 独立看门狗喂狗

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

FWDGT — 独立看门狗喂狗

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

功能简介

本示例演示 FWDGT 的基本用法。

完整代码

#include "gd32f30x.h"
#include "systick.h"
#include "gd32f307c_eval.h"

int main(void)
{
    /* configure systick  */
    systick_config();

    /* configure LED  */
    gd_eval_led_init(LED2);
    gd_eval_led_init(LED3);

    /* configure the Tamper key which is used to reload FWDGT  */
    gd_eval_key_init(KEY_TAMPER, KEY_MODE_EXTI);

    delay_1ms(500);

    /* configure FWDGT counter clock: 40KHz(IRC40K) / 64 = 0.625 KHz */
    fwdgt_config(2 * 500, FWDGT_PSC_DIV64);

    /* check if the system has resumed from FWDGT reset */
    if(RESET != rcu_flag_get(RCU_FLAG_FWDGTRST)) {
        /* turn on LED3 */
        gd_eval_led_on(LED3);
        /* clear the FWDGT reset flag */
        rcu_all_reset_flag_clear();

        while(1) {
        }

    } else {
        /* turn on LED2 */
        gd_eval_led_on(LED2);
    }

    while(1) {
    }
}

代码讲解

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

GD32 GPIO — 按键轮询检测

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

GPIO — 按键轮询检测

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

功能简介

本示例演示 GPIO 的基本输出功能。GPIO（通用输入输出）是 MCU 与外部世界交互的最基础接口。

硬件准备

开发板上的 LED 灯（通常连接在 PA5、PB0、PB1 等引脚）
无需额外接线

完整代码

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

int main(void)
{
    systick_config();
    gd_eval_led_init(LED2);
    gd_eval_key_init(KEY_TAMPER,KEY_MODE_GPIO);

    while(1){
        /* check whether the button is pressed */
        if(RESET == gd_eval_key_state_get(KEY_TAMPER)){
            delay_1ms(100);

            /* check whether the button is pressed */
            if(RESET == gd_eval_key_state_get(KEY_TAMPER)){
                gd_eval_led_toggle(LED2);
            }
        }
    }
}

代码讲解

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

实验现象

对应 GPIO 引脚电平交替翻转
可用示波器或 LED 观察

注意事项

确认 LED 连接的引脚与代码中一致
输出模式一般选择推挽输出（Push-Pull）

GD32 GPIO — 调试口复用为 GPIO

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

GPIO — 调试口复用为 GPIO

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

功能简介

本示例演示 GPIO 的基本输出功能。GPIO（通用输入输出）是 MCU 与外部世界交互的最基础接口。

硬件准备

开发板上的 LED 灯（通常连接在 PA5、PB0、PB1 等引脚）
无需额外接线

完整代码

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

int main(void)
{
    systick_config();
    
    rcu_periph_clock_enable(RCU_GPIOB);
    rcu_periph_clock_enable(RCU_AF);
    
    /* SWD remap */
    gpio_pin_remap_config(GPIO_SWJ_SWDPENABLE_REMAP, ENABLE);
    /* GPIOB output */
    gpio_init(GPIOB, GPIO_MODE_OUT_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_3|GPIO_PIN_4);
    
    while(1){
        gpio_bit_set(GPIOB, GPIO_PIN_3|GPIO_PIN_4);
        delay_1ms(500);
        gpio_bit_reset(GPIOB, GPIO_PIN_3|GPIO_PIN_4);
        delay_1ms(500);
    }
}

代码讲解

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

实验现象

对应 GPIO 引脚电平交替翻转
可用示波器或 LED 观察

注意事项

确认 LED 连接的引脚与代码中一致
输出模式一般选择推挽输出（Push-Pull）

GD32 GPIO — 流水灯

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

GPIO — 流水灯

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

功能简介

这是嵌入式世界的"Hello World"。

程序让开发板上的 4 颗 LED（LED2、LED3、LED4、LED5）依次点亮、依次熄灭，形成一个循环往复的"跑马灯"效果：LED2 亮 → 1 秒后 LED3 亮同时 LED2 灭 → 1 秒后 LED4 亮同时 LED3 灭 → …… 一直循环。

别看它简单，这个例子把每一个 GD32 项目都必须做的三件事都演示完了：

配置系统节拍定时器（SysTick），这样才有能力"延时 1 秒"；
配置 GPIO 为推挽输出，这样引脚才有能力驱动 LED；
在主循环里改变引脚电平，控制外部器件。

只要你彻底看懂这一篇，后面所有外设的学习都会顺很多，因为套路完全一样。

硬件准备

器材	说明
GD32307C-EVAL-V1.1 开发板	或任意 GD32F30x 系列最小系统板
GD-Link / J-Link / ST-Link	用来下载程序
USB 线	供电

开发板上 LED 的实际接线（这份信息来自官方 readme，非常重要）：

LED 名称	引脚
LED2	PC0
LED3	PC2
LED4	PE0
LED5	PE1

不需要任何额外接线 —— LED 已经焊在板子上了，插上 USB 下载就能看效果。

如果你用的是自己画的板子或者别的最小系统板，LED 大概率不在这些脚上。别慌，往下看"常见问题"，里面有改成任意引脚的完整写法。

完整代码

#include "gd32f30x.h"          /* GD32F30x 系列芯片的总头文件，包含所有外设寄存器定义 */
#include "gd32f307c_eval.h"    /* 开发板板级支持包（BSP）：里面把 LED2~LED5 对应的引脚封装好了 */
#include "systick.h"           /* SysTick 延时函数的声明：systick_config() 和 delay_1ms() */
#include <stdio.h>

/*!
    \brief      主函数
    \param[in]  无
    \param[out] 无
    \retval     无
*/
int main(void)
{
    /* 第一步：配置 SysTick 系统节拍定时器
       作用是让 delay_1ms() 这个毫秒级延时函数能正常工作。
       没有这句，后面的 delay_1ms(1000) 会失效或时间完全不准。 */
    systick_config();

    /* 第二步：逐个初始化 4 颗 LED 对应的 GPIO 引脚
       gd_eval_led_init() 是 BSP 提供的封装函数，
       它内部帮我们做了两件事：开 GPIO 时钟 + 配成推挽输出。 */
    gd_eval_led_init(LED2);    /* PC0 */
    gd_eval_led_init(LED3);    /* PC2 */
    gd_eval_led_init(LED4);    /* PE0 */
    gd_eval_led_init(LED5);    /* PE1 */

    /* 第三步：进入主循环，永不退出 */
    while(1){
        /* 点亮 LED2，同时熄灭 LED5（上一轮最后亮的那个） */
        gd_eval_led_on(LED2);
        gd_eval_led_off(LED5);
        delay_1ms(1000);        /* 延时 1000 毫秒 = 1 秒 */

        /* 点亮 LED3，熄灭 LED2 —— 灯"往前走了一格" */
        gd_eval_led_on(LED3);
        gd_eval_led_off(LED2);
        delay_1ms(1000);

        /* 点亮 LED4，熄灭 LED3 */
        gd_eval_led_on(LED4);
        gd_eval_led_off(LED3);
        delay_1ms(1000);

        /* 点亮 LED5，熄灭 LED4 —— 走到最后一格，
           下一轮循环开头会点亮 LED2 并熄灭 LED5，首尾相接形成流水效果 */
        gd_eval_led_on(LED5);
        gd_eval_led_off(LED4);
        delay_1ms(1000);
    }
}

代码总共只有 20 多行有效语句，但每一行都有讲究。下面拆开细讲。

代码分段讲解

第 1 段：三个头文件分别管什么

1
2
3

#include "gd32f30x.h"
#include "gd32f307c_eval.h"
#include "systick.h"

新手常问：“为什么要包含这么多头文件，能不能只留一个？”

头文件	提供了什么	能不能删
`gd32f30x.h`	芯片所有寄存器地址、所有外设库函数声明（`gpio_init`、`rcu_periph_clock_enable`…）	绝对不能删，这是根
`gd32f307c_eval.h`	板级封装：`LED2` 这个枚举值、`gd_eval_led_init/on/off` 函数	可以不用，但你得自己写 GPIO 代码
`systick.h`	`systick_config()` 和 `delay_1ms()`	不用延时的话可以删

关键理解：gd32f307c_eval.c/h 不是芯片固件库的一部分，而是官方为这块特定开发板写的适配层。它把"LED2 在 PC0 上"这种板子专有的信息封装起来。所以如果你换了板子，只要改这个文件里的引脚定义，main.c 一行都不用动 —— 这就是分层设计的好处。

第 2 段：systick_config() 到底做了什么

`1`	`systick_config();`

SysTick 是 Cortex-M 内核自带的一个 24 位递减计数器。systick_config() 的典型实现是这样的：

void systick_config(void)
{
    /* SystemCoreClock 是系统主频（GD32F307 通常是 120MHz）
       除以 1000 表示"每 1 毫秒中断一次" */
    if(SysTick_Config(SystemCoreClock / 1000U)){
        /* 配置失败就死等，方便调试时发现问题 */
        while(1){
        }
    }
    /* 设置 SysTick 中断优先级为最低（0x0F），
       避免它抢占其他重要中断 */
    NVIC_SetPriority(SysTick_IRQn, 0x00U);
}

配好之后，SysTick 每毫秒触发一次中断，中断服务函数里给一个全局计数变量减 1，delay_1ms(n) 就是"把计数变量设成 n，然后死等它变成 0"。

为什么不用 for(i=0;i<1000000;i++); 这种空循环延时？ 因为空循环的实际耗时取决于编译器优化等级、主频、Flash 等待周期，换个编译选项延时就变了，完全不可控。用 SysTick 是硬件计时，准确、可移植。这是专业写法和业余写法的分水岭。

第 3 段：gd_eval_led_init() 里面藏着什么

`1`	`gd_eval_led_init(LED2);`

这一句看起来简单，但它是本例最值得深挖的地方。这个函数在 gd32f307c_eval.c 里的实现，展开后逻辑等价于：

void gd_eval_led_init(led_typedef_enum lednum)
{
    /* 步骤 A：打开这个 LED 所在 GPIO 组的时钟
       LED2 在 PC0，所以要开 RCU_GPIOC */
    rcu_periph_clock_enable(GPIO_CLK[lednum]);

    /* 步骤 B：把引脚配成推挽输出，速度 50MHz */
    gpio_init(GPIO_PORT[lednum], GPIO_MODE_OUT_PP,
              GPIO_OSPEED_50MHZ, GPIO_PIN[lednum]);

    /* 步骤 C：初始化后先输出低电平，保证一开机 LED 是熄灭状态 */
    GPIO_BC(GPIO_PORT[lednum]) = GPIO_PIN[lednum];
}

如果不用 BSP，自己手写点亮 PC0 上的 LED，完整代码是这样：

/* 1. 开 GPIOC 时钟（必做，否则后面全白干） */
rcu_periph_clock_enable(RCU_GPIOC);

/* 2. PC0 配成推挽输出 */
gpio_init(GPIOC, GPIO_MODE_OUT_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_0);

/* 3. 输出高电平 */
gpio_bit_set(GPIOC, GPIO_PIN_0);

这三行就是"GPIO 输出三部曲"，请务必背下来。GD32 上任何一个外设的配置，都逃不出"开时钟 → 配参数 → 用起来"这个模式。

第 4 段：为什么要"开一个、关一个"

1
2
3

gd_eval_led_on(LED2);
gd_eval_led_off(LED5);
delay_1ms(1000);

注意作者的写法：点亮当前灯的同时，熄灭上一颗灯。

如果只写 on 不写 off，效果就变成"灯一颗一颗累加点亮"，最后 4 颗全亮 —— 那是"跑马灯累积效果"，不是流水灯。
第一轮循环刚进来时 LED5 本来就是灭的，再 off 一次也无害，所以代码不需要特殊处理首轮。这种"多余但无害"的写法让循环体保持了完美的对称，可读性更好。

gd_eval_led_on() 内部长这样：

void gd_eval_led_on(led_typedef_enum lednum)
{
    /* GPIO_BOP 是位设置/清除寄存器，写 1 到对应位 = 该引脚输出高 */
    GPIO_BOP(GPIO_PORT[lednum]) = GPIO_PIN[lednum];
}

这里用的是 GD32 的 BOP / BC 位操作寄存器，它的好处是：一次写入只影响你指定的那一位，不需要"读出整个端口 → 改一位 → 写回"。这个操作是原子的，中断打断也不会出错。所以在实际项目中，推荐用 gpio_bit_set/reset（内部就是 BOP/BC），而不是直接操作 GPIO_OCTL 整个输出寄存器。

第 5 段：`while(1)` 不能省

1
2
3

while(1){
    ...
}

嵌入式的 main() 函数永远不能返回。如果 while(1) 写漏了，main 执行完会跳到启动文件里的一个死循环（或者更糟，跳到不可预知的地址导致 HardFault）。所有裸机程序的骨架都是：

int main(void)
{
    /* 初始化区：只执行一次 */
    while(1){
        /* 业务逻辑区：无限重复 */
    }
}

实验现象

用 Keil / GCC 编译工程，通过 GD-Link 下载到板子。
上电或按下复位键。
观察板上 4 颗 LED：

时间轴：   0s      1s      2s      3s      4s      5s
LED2(PC0)  亮 ───→ 灭      灭      灭      亮 ───→ 灭
LED3(PC2)  灭      亮 ───→ 灭      灭      灭      亮
LED4(PE0)  灭      灭      亮 ───→ 灭      灭      灭
LED5(PE1)  灭      灭      灭      亮 ───→ 灭      灭

肉眼看到的效果就是一个光点在 4 颗 LED 之间来回"跑"，每秒走一格，循环不停。

如果想让它跑得更快，把 delay_1ms(1000) 改成 delay_1ms(200)，效果会明显活泼很多，也更接近常见的流水灯灯带。

常见问题

Q1：下载成功了，但一颗灯都不亮

按这个顺序排查，90% 的问题在前两条：

引脚对不上。你的板子 LED 可能不在 PC0/PC2/PE0/PE1。用万用表量一下，或者查板子原理图，然后改 gd32f307c_eval.h 里的引脚宏。
LED 是低电平点亮的。很多板子的接法是 3.3V → 电阻 → LED → MCU 引脚，这时候引脚输出低电平才亮，输出高电平反而灭。解决办法是把 gd_eval_led_on 和 off 的行为互换，或者直接自己写：

`1`	`gpio_bit_reset(GPIOC, GPIO_PIN_0); /* 低电平点亮 */`

忘了开 GPIO 时钟。如果你没用 BSP 而是自己写的，检查有没有 rcu_periph_clock_enable(RCU_GPIOx)。
芯片没跑起来。用调试器单步，看是否卡在 HardFault_Handler 或 SystemInit 里。

Q2：灯亮了，但闪得飞快 / 完全不闪

这是 delay_1ms() 不准的典型症状，根因通常是 SysTick 配置和实际主频不匹配。

检查 system_gd32f30x.c 里的时钟配置宏，确认你选的主频（比如 __SYSTEM_CLOCK_120M_PLL_HXTAL）和板子上实际的晶振频率（GD32307C-EVAL 是 8MHz 或 25MHz）匹配。如果外部晶振起振失败，芯片会自动降频跑内部 8MHz RC，延时就会差十几倍。

在 main() 开头加一句打印验证：

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

Q3：PE0、PE1 在小封装芯片上找不到

GD32F303CBT6 这类 48 脚 LQFP 封装没有 GPIOE。这时候把 LED4/LED5 改到别的空闲引脚（比如 PB0、PB1），或者干脆只做 2 颗灯的流水灯。

Q4：能不能用 `for` 循环把重复代码简化掉？

当然可以，这也是更工程化的写法：

int main(void)
{
    /* 用数组把 4 颗灯管理起来 */
    led_typedef_enum leds[4] = {LED2, LED3, LED4, LED5};
    uint8_t i;

    systick_config();
    for(i = 0; i < 4; i++){
        gd_eval_led_init(leds[i]);
        gd_eval_led_off(leds[i]);
    }

    while(1){
        for(i = 0; i < 4; i++){
            gd_eval_led_on(leds[i]);                    /* 点亮当前灯 */
            gd_eval_led_off(leds[(i + 3) % 4]);         /* 熄灭上一颗（i-1，防负数用 +3） */
            delay_1ms(1000);
        }
    }
}

代码从 20 行缩到 10 行，而且想加到 8 颗灯只需改数组和常量。官方例程为了让新手一眼看懂流程才写成展开形式，实际项目里推荐用数组 + 循环。

Q5：`delay_1ms()` 期间 CPU 在干什么？

在死等，什么正事都没干（这叫"阻塞式延时"）。跑流水灯没问题，但如果你还要同时读按键、发串口，CPU 全被延时占住就麻烦了。

进阶做法是用 SysTick 中断 + 状态机做"非阻塞延时"：

extern volatile uint32_t g_tick;   /* 在 SysTick_Handler 里每毫秒 ++ */

int main(void)
{
    uint32_t last_time = 0;
    uint8_t  index = 0;
    /* ... 初始化 ... */
    while(1){
        /* 时间到了才切换灯，没到就直接跳过，CPU 空出来干别的 */
        if(g_tick - last_time >= 1000){
            last_time = g_tick;
            /* 切换 LED */
            index = (index + 1) % 4;
        }
        /* 这里可以放按键扫描、串口处理等其他任务，不会被延时卡住 */
    }
}

这个思路是从"点灯玩具"迈向"实际产品"的关键一步，建议学完 SysTick 中断示例后回来自己改一遍。

小结

知识点	要记住的核心
GPIO 输出三部曲	`rcu_periph_clock_enable()` → `gpio_init()` → `gpio_bit_set/reset()`
时钟必须先开	GD32 外设默认时钟关闭，不开时钟配置全部无效
推挽输出	点灯、驱动开关量用 `GPIO_MODE_OUT_PP`
位操作寄存器	`gpio_bit_set/reset` 是原子操作，比读改写整个端口安全
SysTick 延时	`systick_config()` + `delay_1ms()`，比空循环准确且可移植
BSP 分层	板子相关信息（哪个脚接哪颗灯）应该封装在 `xxx_eval.c` 里，不要写死在 main
`while(1)`	裸机 main 永不返回

核心心法：GD32 的每一个外设，配置流程都是"开时钟 → 配 GPIO → 配外设参数 → 使能外设 → 读写数据"。流水灯只用到了前三步，但这个骨架会贯穿你后面学的 USART、ADC、SPI、TIMER 全部内容。

拓展应用

学会 GPIO 输出，下面这些项目你现在就能做：

入门级（改改本例代码就行）

呼吸灯（软件版）：不用 PWM，纯靠"亮 1ms 灭 9ms"快速切换 + 逐渐改变比例，实现渐亮渐暗。理解这个再去学 PWM 会豁然开期。
摩尔斯电码发报机：把字符串编码成长短闪烁，用 LED 发 “SOS”。练习数组遍历 + 延时控制。
交通灯模型：3 颗 LED 当红黄绿，按真实时序（绿 30s → 黄 3s → 红 30s）循环，加上数字倒计时就是完整的课程设计。
蜂鸣器报警器：把 LED 换成有源蜂鸣器（引脚经三极管驱动），改变间隔就是不同的报警音效。

进阶级（需要再学一点别的外设）

8 位 LED 灯带跑马灯：8 颗 LED 接一整组 GPIO，用 gpio_port_write() 一次写 8 位，通过移位运算 1 << i 实现流水，代码优雅很多。
74HC595 级联驱动：只用 3 根 GPIO（DATA / CLOCK / LATCH）驱动 8、16、32 颗 LED。这是学习"用软件模拟时序协议"的最佳入门项目，也是理解 SPI 的前置知识。
数码管动态扫描显示：4 位共阴数码管，GPIO 快速轮流点亮每一位（每位亮 2ms），利用视觉暂留让 4 位看起来同时亮。这是 GPIO 输出 + 精确定时的经典综合应用。
步进电机四相八拍驱动：4 根 GPIO 按特定相序通电（A→AB→B→BC→C→CD→D→DA），电机就转起来了。改变相序间隔就是调速，改变顺序就是反转。
继电器控制 + 定时开关：GPIO 经光耦驱动继电器，配合 RTC 做"每天早上 7 点自动开灯"的智能插座。

实战产品级

LED 点阵屏 / WS2812 灯带：WS2812 是单总线协议，靠精确的高低电平宽度（0.35μs / 0.9μs）编码数据。用 GPIO + 精确延时（或 PWM+DMA）就能驱动任意长度的全彩灯带，做氛围灯、电竞灯效。
工业开关量采集卡：多路 GPIO 输入读传感器状态 + 多路 GPIO 输出驱动执行机构，加上 Modbus 串口通信，这就是一个最小的 PLC 模块。

下一步该学什么：看完流水灯，建议按 按键轮询（GPIO 输入） → USART Printf（学会打印调试） → TIMER PWM（真正的呼吸灯） 的顺序继续。特别是 Printf，它让你能"看见"程序内部在想什么，是效率提升最大的一个技能。

GD32 I2C — I2C EEPROM DMA

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

I2C — I2C EEPROM DMA

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

功能简介

本示例演示通过 I2C 接口读写 EEPROM（如 AT24C02）。EEPROM 是最常用的 I2C 从设备，掉电不丢失数据，适合存储配置参数。

硬件准备

AT24C02 或类似 EEPROM 模块
连接：SCL→PB10, SDA→PB11（具体引脚参考代码）
注意上拉电阻（模块通常自带）

完整代码

#include <stdio.h>
#include "gd32f30x.h"
#include "gd32f307c_eval.h"
#include "systick.h"
#include "i2c.h"
#include "at24cxx.h"

int main(void)
{
    /* configure systick */
    systick_config();

    /* configure LEDs */
    led_config();

    /* configure USART */
    gd_eval_com_init(EVAL_COM0);

    printf("I2C-24C02 configured....\n\r");

    /* configure GPIO */
    gpio_config();

    /* configure I2C */
    i2c_config();

    /* initialize EEPROM  */
    i2c_eeprom_init();

    printf("\r\nThe I2C is hardware interface ");
    printf("\r\nThe speed is %d", I2C_SPEED);

    if(I2C_OK == i2c_24c02_test()) {
        while(1) {
            /* turn off all LEDs */
            gd_eval_led_off(LED2);
            gd_eval_led_off(LED3);
            gd_eval_led_off(LED4);
            gd_eval_led_off(LED5);
            /* turn on a LED */
            led_turn_on(count % 4);
            count++;
            if(count >= 4) {
                count = 0;
            }
            delay_1ms(500);
        }
    }
    /* turn on all LEDs */
    gd_eval_led_on(LED2);
    gd_eval_led_on(LED3);
    gd_eval_led_on(LED4);
    gd_eval_led_on(LED5);

    while(1) {
    }

}

代码讲解

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

I2C 配置：设置通信速率（标准 100K / 快速 400K / 快速+ 1M）、从机地址、时钟拉伸。

实验现象

按下按键后，向 EEPROM 写入数据并读回
写入和读出的数据一致则 LED 亮起

注意事项

I2C 总线需要上拉电阻（一般 4.7K）
从机地址要与设备手册一致（注意 7 位/8 位地址的区别）
写 EEPROM 后需要等待 5ms 以上再读

GD32 I2C — I2C EEPROM 读写

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

I2C — I2C EEPROM 读写

固件库: GD32F30x_Firmware_Library V3.0.3
芯片: GD32F30x（以 GD32F307 评估板为例）
源文件: GD32F30x_Firmware_Library_V3.0.3/Examples/I2C/I2C_EEPROM/main.c
配套文件: i2c.c / i2c.h（底层驱动）、at24cxx.c / at24cxx.h（EEPROM 读写逻辑）
评估板 EEPROM: AT24C02（I2C 接口，2Kbit = 256 字节）

功能简介

本示例演示用 I2C 硬件外设 读写一颗 AT24C02 EEPROM（电可擦可编程只读存储器）。EEPROM 最大的特点是掉电不丢数据，常用来存设备配置、校准参数、运行计数等。

整个流程一句话概括：

准备好 256 字节的测试数据 i2c_buffer_write[i] = i（即 0x00~0xFF）。
通过 I2C 把这批数据写入 AT24C02（从地址 0 开始）。
再从 AT24C02 读回同样 256 字节到 i2c_buffer_read[]。
逐字节比较写入和读回是否一致，全部一致则测试通过（I2C_OK）。
测试通过 → LED2~LED5 循环流水闪烁；失败 → 4 颗 LED 全亮，表示读写出错。

本例的亮点（也是难点）是：I2C 收发全部用"状态机 + 超时"实现，每一步都等从机 ACK、带超时保护和总线复位，非常贴近真实工程的健壮写法。

硬件准备

1. 开发板 + EEPROM 模块

GD32F30x 评估板（例程按 GD32F307C EVAL 编写，LED2~LED5 由 gd_eval_led_init 初始化）。
AT24C02 模块（或板载 EEPROM）。本例 I2C 地址宏 I2CX_SLAVE_ADDRESS7 = 0xA0。

2. 接线（I2C0：PB6/PB7）

信号	MCU 引脚	接 EEPROM
SCL	PB6	EEPROM SCL
SDA	PB7	EEPROM SDA

关键：I2C 的两根线必须接上拉电阻（通常 4.7kΩ 到 3.3V）。大多数 EEPROM 模块板载了上拉，直接连即可；若自己搭电路，别忘了加上拉，否则总线拉不高、通信必失败。

3. 串口（强烈建议）

例程用 printf 打印调试信息（“AT24C02 writing…"、“test passed!"、出错字节等）。把 PA9/PA10 接到 USB 转串口，波特率 115200（评估板 gd_eval_com_init 默认）即可在串口助手查看全过程。

完整代码（带中文注释）

由于本例代码分散在 main.c、i2c.c、at24cxx.c 三个文件，下面按"从顶到底"的顺序摘出最核心、最该读懂的部分，并配上中文注释。完整工程文件请直接查看源码目录。

1) main.c —— 主流程

#include <stdio.h>
#include "gd32f30x.h"
#include "gd32f307c_eval.h"
#include "systick.h"
#include "i2c.h"
#include "at24cxx.h"

uint8_t count = 0;

void led_turn_on(uint8_t led_number);
void led_config(void);

void led_config(void)
{
    gd_eval_led_init(LED2);
    gd_eval_led_init(LED3);
    gd_eval_led_init(LED4);
    gd_eval_led_init(LED5);
    gd_eval_led_off(LED2);
    gd_eval_led_off(LED3);
    gd_eval_led_off(LED4);
    gd_eval_led_off(LED5);
}

int main(void)
{
    /* 系统滴答定时器（提供 delay_1ms 时基） */
    systick_config();
    /* LED 初始化 */
    led_config();
    /* 串口初始化（用于 printf 打印） */
    gd_eval_com_init(EVAL_COM0);

    printf("I2C-24C02 configured....\n\r");

    /* GPIO 配置：把 PB6/PB7 设成 I2C 复用开漏 */
    gpio_config();
    /* I2C 外设配置：速率 100K、自身 7 位地址、使能、开启 ACK */
    i2c_config();
    /* 初始化 EEPROM 驱动（记录器件地址 0xA0） */
    i2c_eeprom_init();

    printf("\r\nThe I2C is hardware interface ");
    printf("\r\nThe speed is %d", I2C_SPEED);

    /* 执行读写自测 */
    if(I2C_OK == i2c_24c02_test()) {
        /* 测试通过：4 颗 LED 循环流水，每 500ms 切换 */
        while(1) {
            gd_eval_led_off(LED2);
            gd_eval_led_off(LED3);
            gd_eval_led_off(LED4);
            gd_eval_led_off(LED5);
            led_turn_on(count % 4);
            count++;
            if(count >= 4) count = 0;
            delay_1ms(500);
        }
    }
    /* 测试失败：4 颗 LED 全亮，停在这里 */
    gd_eval_led_on(LED2);
    gd_eval_led_on(LED3);
    gd_eval_led_on(LED4);
    gd_eval_led_on(LED5);
    while(1) {}
}

2) i2c.h —— 关键宏定义（先记住这些）

#define I2C_SPEED               100000      /* 标准模式 100Kbps */
#define I2CX_SLAVE_ADDRESS7     0xA0        /* AT24C02 的 8 位地址写法（含读写位） */
#define I2C_PAGE_SIZE           8           /* AT24C02 每页 8 字节（页写上限） */

#define I2CX                    I2C0
#define RCU_GPIO_I2C            RCU_GPIOB
#define RCU_I2C                 RCU_I2C0
#define I2C_SCL_PORT            GPIOB
#define I2C_SDA_PORT            GPIOB
#define I2C_SCL_PIN             GPIO_PIN_6  /* PB6 = SCL */
#define I2C_SDA_PIN             GPIO_PIN_7  /* PB7 = SDA */

3) i2c.c —— GPIO 与 I2C 外设配置

void gpio_config(void)
{
    rcu_periph_clock_enable(RCU_GPIO_I2C);
    /* I2C 引脚必须是 复用开漏(AF_OD) + 外部上拉 */
    gpio_init(I2C_SCL_PORT, GPIO_MODE_AF_OD, GPIO_OSPEED_50MHZ, I2C_SCL_PIN);
    gpio_init(I2C_SDA_PORT, GPIO_MODE_AF_OD, GPIO_OSPEED_50MHZ, I2C_SDA_PIN);
}

void i2c_config(void)
{
    rcu_periph_clock_enable(RCU_I2C);
    /* 配置速率：100000 bps，占空比 2（快速模式才讲究，标准模式随意） */
    i2c_clock_config(I2CX, I2C_SPEED, I2C_DTCY_2);
    /* 配置 I2C 为主机模式、7 位地址格式、自身地址 0xA0 */
    i2c_mode_addr_config(I2CX, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, I2CX_SLAVE_ADDRESS7);
    i2c_enable(I2CX);                 /* 使能 I2C 外设 */
    i2c_ack_config(I2CX, I2C_ACK_ENABLE);  /* 开启自动应答（读多字节时必须） */
}

4) at24cxx.c —— 最核心的"状态机写一字节”

下面这个函数 eeprom_byte_write_timeout() 把 I2C 写一字节的完整协议展示得最清楚。注意它是一个 switch 状态机，timeout 防止卡死：

uint8_t eeprom_byte_write_timeout(uint8_t *p_buffer, uint8_t write_address)
{
    uint8_t  state = I2C_START;
    uint16_t timeout = 0;
    uint8_t  i2c_timeout_flag = 0;

    i2c_ack_config(I2CX, I2C_ACK_ENABLE);

    while(!(i2c_timeout_flag)) {
        switch(state) {
        case I2C_START:
            /* ① 等总线空闲（不忙）才发 START */
            while(i2c_flag_get(I2CX, I2C_FLAG_I2CBSY) && (timeout < I2C_TIME_OUT)) {
                timeout++;
            }
            if(timeout < I2C_TIME_OUT) {
                i2c_start_on_bus(I2CX);      /* 产生 START 条件 */
                timeout = 0;
                state = I2C_SEND_ADDRESS;
            } else {
                timeout = 0;
                state = I2C_START;           /* 超时：重来 */
                printf("i2c bus is busy in WRITE BYTE!\n");
            }
            break;

        case I2C_SEND_ADDRESS:
            /* ② 等 START 已发出（SBSEND） */
            while((! i2c_flag_get(I2CX, I2C_FLAG_SBSEND)) && (timeout < I2C_TIME_OUT)) {
                timeout++;
            }
            if(timeout < I2C_TIME_OUT) {
                /* 发送从机地址 + 写方向（库会自动拼读写位） */
                i2c_master_addressing(I2CX, eeprom_address, I2C_TRANSMITTER);
                timeout = 0;
                state = I2C_CLEAR_ADDRESS_FLAG;
            } else {
                timeout = 0;
                state = I2C_START;
            }
            break;

        case I2C_CLEAR_ADDRESS_FLAG:
            /* ③ 等从机回应地址 ACK（ADDSEND），然后必须清除该标志 */
            while((! i2c_flag_get(I2CX, I2C_FLAG_ADDSEND)) && (timeout < I2C_TIME_OUT)) {
                timeout++;
            }
            if(timeout < I2C_TIME_OUT) {
                i2c_flag_clear(I2CX, I2C_FLAG_ADDSEND);
                timeout = 0;
                state = I2C_TRANSMIT_DATA;
            } else {
                timeout = 0;
                state = I2C_START;
            }
            break;

        case I2C_TRANSMIT_DATA:
            /* ④ 等发送缓冲空（TBE），先发 EEPROM 内部地址（写哪个存储单元） */
            while((! i2c_flag_get(I2CX, I2C_FLAG_TBE)) && (timeout < I2C_TIME_OUT)) {
                timeout++;
            }
            if(timeout < I2C_TIME_OUT) {
                i2c_data_transmit(I2CX, write_address);  /* EEPROM 内地址 */
                timeout = 0;
            }
            /* 等字节传完（BTC），再发真正的数据字节 */
            while((!i2c_flag_get(I2CX, I2C_FLAG_BTC)) && (timeout < I2C_TIME_OUT)) {
                timeout++;
            }
            if(timeout < I2C_TIME_OUT) {
                i2c_data_transmit(I2CX, *p_buffer);      /* 实际要写的数据 */
                timeout = 0;
            }
            /* 再等 BTC，准备结束 */
            while((!i2c_flag_get(I2CX, I2C_FLAG_BTC)) && (timeout < I2C_TIME_OUT)) {
                timeout++;
            }
            if(timeout < I2C_TIME_OUT) {
                state = I2C_STOP;
                timeout = 0;
            }
            break;

        case I2C_STOP:
            /* ⑤ 发 STOP 条件，结束本次通信 */
            i2c_stop_on_bus(I2CX);
            while((I2C_CTL0(I2CX) & I2C_CTL0_STOP) && (timeout < I2C_TIME_OUT)) {
                timeout++;
            }
            if(timeout < I2C_TIME_OUT) {
                timeout = 0;
                state = I2C_END;
                i2c_timeout_flag = I2C_OK;
            }
            break;

        default:
            state = I2C_START;
            i2c_timeout_flag = I2C_OK;
            timeout = 0;
            break;
        }
    }
    return I2C_END;
}

5) at24cxx.c —— 自测函数 i2c_24c02_test()

uint8_t i2c_24c02_test(void)
{
    uint16_t i;
    uint8_t i2c_buffer_write[BUFFER_SIZE];   /* BUFFER_SIZE = 256 */
    uint8_t i2c_buffer_read[BUFFER_SIZE];

    printf("\r\nAT24C02 writing...\r\n");
    /* 准备测试数据：0,1,2,...,255 */
    for(i = 0; i < BUFFER_SIZE; i++) {
        i2c_buffer_write[i] = i;
    }
    /* 整片写入（内部做了分页写） */
    eeprom_buffer_write_timeout(i2c_buffer_write, EEP_FIRST_PAGE, BUFFER_SIZE);

    printf("AT24C02 reading...\r\n");
    /* 整片读回 */
    eeprom_buffer_read_timeout(i2c_buffer_read, EEP_FIRST_PAGE, BUFFER_SIZE);

    /* 逐字节比对 */
    for(i = 0; i < BUFFER_SIZE; i++) {
        if(i2c_buffer_read[i] != i2c_buffer_write[i]) {
            printf("Err:data read and write aren't matching.\n\r");
            return I2C_FAIL;     /* 任一字节不一致 → 失败 */
        }
    }
    printf("I2C-AT24C02 test passed!\n\r");
    return I2C_OK;               /* 全部一致 → 成功 */
}

其余 eeprom_page_write_timeout()（页写）、eeprom_buffer_write_timeout()（跨页拆分）、eeprom_buffer_read_timeout()（含"复合格式"读：先写地址再发重复 START 切到读方向）、eeprom_wait_standby_state_timeout()（等 EEPROM 写完就绪）都是在这套状态机骨架上的扩展。它们的核心套路一致：START → 地址 → 等 ACK → 数据 → STOP，只是数据段多循环几次、或读之前多发一次"重复起始（Repeated START）"。

代码分段讲解

1. I2C 引脚为什么是"复用开漏”？

1
2

gpio_init(I2C_SCL_PORT, GPIO_MODE_AF_OD, GPIO_OSPEED_50MHZ, I2C_SCL_PIN);
gpio_init(I2C_SDA_PORT, GPIO_MODE_AF_OD, GPIO_OSPEED_50MHZ, I2C_SDA_PIN);

I2C 总线是**线与（wired-AND）**结构：任何设备都能把线拉低，但只能靠上拉电阻拉高。如果用推挽输出，两个设备一个拉高一个拉低就会"短路"打架。开漏输出恰好满足"谁想拉低谁拉，否则释放由电阻拉高"，配合外部上拉电阻，这就是 I2C 能多主多从、还能仲裁的硬件基础。漏了上拉电阻 = 通信必失败，这是 I2C 头号新手坑。

2. 速率、地址、应答三件套

1
2
3

i2c_clock_config(I2CX, I2C_SPEED, I2C_DTCY_2);          // 速率 100K
i2c_mode_addr_config(I2CX, ..., I2C_ADDFORMAT_7BITS, 0xA0);  // 7 位地址
i2c_ack_config(I2CX, I2C_ACK_ENABLE);                   // 开启自动应答

I2C_SPEED = 100000：标准模式。想提速改 400000（快速模式）；EEPROM 通常都支持。
0xA0：AT24C02 的 8 位地址俗写（含读写位）。i2c_master_addressing() 会按 7 位地址格式自动处理，所以这里传 0xA0 没问题。
ACK 必须开启：读多字节时，主机每收一个字节都要回 ACK 告诉从机"继续发"，最后一个字节才回 NACK 表示"到此为止"。

3. 状态机：每一步都在"等 ACK + 防卡死"

观察 eeprom_byte_write_timeout()，整段逻辑被拆成 5 个状态：I2C_START → I2C_SEND_ADDRESS → I2C_CLEAR_ADDRESS_FLAG → I2C_TRANSMIT_DATA → I2C_STOP。每个状态里都是 while(标志未到 && timeout < I2C_TIME_OUT) 这种带超时的等待：

等 I2C_FLAG_I2CBSY 为 0 → 总线空闲才能发 START。
等 I2C_FLAG_SBSEND → START 已发出。
等 I2C_FLAG_ADDSEND → 从机回了地址 ACK；必须 i2c_flag_clear() 清掉它，不清会卡死。
等 I2C_FLAG_TBE / BTC → 数据发出去、且收到从机对数据的 ACK。

超时就 state = I2C_START 重来，必要时 i2c_bus_reset() 把总线"抖"回正常。这种写法比"裸等标志"健壮得多，是真实工程里 I2C 的标配。

为什么要"先发 EEPROM 内地址、再发数据"？ AT24C02 这类 EEPROM 在收到器件地址后，还要再收一个"你想写哪个存储单元"的字地址（0x00~0xFF），之后才是真正的数据。所以一帧里主机连续发：器件地址(写) → 字地址 → 数据。读操作更复杂：先以"写方向"发器件地址+字地址告诉它"我要读的位置"，再发一次重复 START以"读方向"访问，然后开始收数据。

4. 页写与"等待就绪"

AT24C02 内部按"页"组织，每页 8 字节（I2C_PAGE_SIZE）。一次 I2C 写操作最多连续写一页，跨页必须拆成多次（每次都要重新 START+地址）。eeprom_buffer_write_timeout() 就是做这个"按 8 字节分页、跨页拆分"的活。

而且EEPROM 写慢——发完 STOP 后它要花几毫秒把数据固化到存储阵列，这段时间里它不响应任何访问。所以每次写完后都要 eeprom_wait_standby_state_timeout()：不断发 START+地址，直到从机回 ACK 表示"我忙完了、可以再聊了"。如果你写完立刻读，读到的会是旧数据或 NACK。

5. 读回来的数据怎么验证？

i2c_24c02_test() 用 i2c_buffer_write[i]=i 造了 0~255 的递增序列，写进去再读回来逐字节比。全对返回 I2C_OK，main 里就让 LED 流水；有错立刻 I2C_FAIL、LED 全亮。串口还会把出错的具体字节打印出来，方便排查。

实验现象

串口输出（115200 波特）：

I2C-24C02 configured....
The I2C is hardware interface
The speed is 100000
AT24C02 writing...
AT24C02 reading...
I2C-AT24C02 test passed!

LED 行为：
- 测试通过 → LED2、LED3、LED4、LED5 以 500ms 间隔循环流水闪烁。
- 测试失败（读写不一致）→ 4 颗 LED 全部常亮，程序停在末尾死循环。
若把接线拔掉或地址写错，串口会打出 i2c bus is busy ... / 各种 timeout 信息，最终触发失败分支。

常见问题

Q1：串口没任何输出 / 一直打 “i2c bus is busy”？
99% 是物理接线或上拉问题。检查：① PB6/PB7 是否真正接到了 EEPROM 的 SCL/SDA；② 总线上是否接了上拉电阻（4.7kΩ 到 3.3V）；③ EEPROM 供电是否正常。总线拉不高，I2C 永远判"忙"。

Q2：为什么 I2C 地址写成 0xA0 而不是 0x50？
0xA0 是 8 位写法（7 位地址 0x50 左移 1 位 = 0xA0，最低位是读写方向位）。AT24C02 的数据手册里器件地址常直接给成 0xA0（写）/ 0xA1（读）这种"含读写位"的写法。GD32 库函数 i2c_master_addressing() 会按你给的格式自动拼方向位，传 0xA0 即可，不必自己再移位。

Q3：为什么写完要等那么久才能读？
EEPROM 内部是"浮栅"工艺，写/擦要毫秒级时间。写完后它处于"忙"状态，期间不响应 I2C 访问。例程里的 eeprom_wait_standby_state_timeout() 就是反复探测它"忙完没有"。如果你自己写代码，记得写后延时 5~10ms 或轮询 ACK 再读。

Q4：可以一次写超过 8 字节吗？
不能在一次 I2C 连续写里超过一页（AT24C02 是 8 字节/页）。超过会从页首"回卷"覆盖。例程的 eeprom_buffer_write_timeout() 已替你按 8 字节分页、跨页拆分处理，所以传 256 字节也没问题。

Q5：为什么代码里那么多 timeout 和 i2c_bus_reset？
因为 I2C 是带应答的协议，从机没接好 / 总线被拉死时若"裸等标志"会永久卡住。带超时 + 总线复位是工业级写法，保证"卡了能恢复"。初学可先忽略 timeout 细节，重点理解状态机的 5 步顺序。

Q6：我想换成 AT24C04 / AT24C128 等更大容量怎么办？
主要改两点：① 器件地址（大容量页结构不同，字地址可能是 2 字节）；② I2C_PAGE_SIZE（页大小随型号变，如 AT24C64 是 32 字节）。地址格式（7 位/10 位）和页写逻辑要对照对应手册调整。

小结

本示例把 I2C 最核心的"主机写从机"协议完整走了一遍，记住这条主线：

开时钟 + 配 GPIO（AF_OD + 上拉）：SCL/PB6、SDA/PB7，千万别忘上拉电阻。
配 I2C 外设：速率、7 位地址、使能、开启 ACK。
通信五步状态机：START → 发地址(等 ACK) → 发字地址 → 发数据 → STOP，每步都等标志 + 防超时。
EEPROM 特有两件事：按页写（≤8 字节/页，跨页拆分）、写后等"就绪"再读。
验证：写进去什么、读回来什么，逐字节比对，用 LED / 串口给出结果。

I2C 比 SPI “省线但啰嗦”，吃透了 EEPROM 这一例，你基本就掌握了所有 I2C 从器件的读写套路。

拓展应用

掌握了 I2C EEPROM 读写后，可以延伸至大量 I2C 从设备：

存配置参数：把设备的校准值、用户设置写入 EEPROM，掉电不丢，上电读取恢复。
其它 I2C 传感器：如温湿度 SHT30、气压 BMP280、IMU MPU6050、光照 BH1750——它们的读写同样是"START → 地址 → 寄存器地址 → 数据/读回"这套协议，只是寄存器定义不同。
RTC 时钟芯片（PCF8563 / DS3231）：I2C 读时间、设闹钟。
I/O 扩展芯片（PCF8574 / MCP23017）：用 I2C 扩展 GPIO 口，省 MCU 引脚。
OLED 显示屏（SSD1306 的 I2C 版本）：用 I2C 刷小屏。
升级为 DMA / 中断：数据量大时改用同目录 I2C_EEPROM_dma / I2C_EEPROM_interrput，把轮询等待换成 DMA 或中断，释放 CPU。
多从机挂载：同一组 PB6/PB7 上可并挂多个 I2C 器件（EEPROM + 传感器 + RTC），靠各自不同地址区分，体现 I2C “两根线挂一片设备"的优势。

想看更简洁的纯主机收发骨架，可阅读同目录的 Master_transmitter / Master_receiver 例程。

GD32 I2C — I2C EEPROM 中断

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

I2C — I2C EEPROM 中断

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

功能简介

本示例演示通过 I2C 接口读写 EEPROM（如 AT24C02）。EEPROM 是最常用的 I2C 从设备，掉电不丢失数据，适合存储配置参数。

硬件准备

AT24C02 或类似 EEPROM 模块
连接：SCL→PB10, SDA→PB11（具体引脚参考代码）
注意上拉电阻（模块通常自带）

完整代码

#include <stdio.h>
#include "gd32f30x.h"
#include "gd32f307c_eval.h"
#include "systick.h"
#include "i2c.h"
#include "at24cxx.h"

int main(void)
{
    /* configure systick */
    systick_config();

    /* configure LEDs */
    led_config();

    /* configure USART */
    gd_eval_com_init(EVAL_COM0);

    printf("I2C-24C02 configured....\n\r");

    /* configure the NVIC */
    i2c_nvic_config();

    /* configure GPIO */
    gpio_config();

    /* configure I2C */
    i2c_config();

    /* initialize EEPROM  */
    i2c_eeprom_init();

    printf("\r\nThe I2C is hardware interface ");
    printf("\r\nThe speed is %d", I2C_SPEED);

    if(I2C_OK == i2c_24c02_test()) {
        while(1) {
            /* turn off all LEDs */
            gd_eval_led_off(LED2);
            gd_eval_led_off(LED3);
            gd_eval_led_off(LED4);
            gd_eval_led_off(LED5);
            /* turn on a LED */
            led_turn_on(count % 4);
            count++;
            if(count >= 4) {
                count = 0;
            }
            delay_1ms(500);
        }
    }
    /* turn on all LEDs */
    gd_eval_led_on(LED2);
    gd_eval_led_on(LED3);
    gd_eval_led_on(LED4);
    gd_eval_led_on(LED5);

    while(1) {
    }

}

void i2c_nvic_config(void)
{
    nvic_priority_group_set(NVIC_PRIGROUP_PRE1_SUB3);
    nvic_irq_enable(I2C0_EV_IRQn, 0, 2);
    nvic_irq_enable(I2C0_ER_IRQn, 0, 1);
}

代码讲解

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

I2C 配置：设置通信速率（标准 100K / 快速 400K / 快速+ 1M）、从机地址、时钟拉伸。

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

实验现象

按下按键后，向 EEPROM 写入数据并读回
写入和读出的数据一致则 LED 亮起

注意事项

I2C 总线需要上拉电阻（一般 4.7K）
从机地址要与设备手册一致（注意 7 位/8 位地址的区别）
写 EEPROM 后需要等待 5ms 以上再读

GD32 I2C — I2C Fast-mode+ 通信

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

I2C — I2C Fast-mode+ 通信

固件库: GD32F30x_Firmware_Library V3.0.3
芯片: GD32
源文件: GD32F30x_Firmware_Library_V3.0.3/Examples/I2C/Fast_mode_ plus_communication/main.c

功能简介

本示例演示 I2C 总线通信。I2C 只需两根线（SCL+SDA）就能连接多个设备，是最常用的低速通信总线。

硬件准备

I2C 从设备（如 EEPROM、传感器模块）
SCL/SDA 线上需要 4.7K 上拉电阻

完整代码

#include "gd32f30x.h"
#include <stdio.h>
#include "gd32f307c_eval.h"
#define I2C0_SLAVE_ADDRESS7    0x82
#define I2C1_SLAVE_ADDRESS7    0x72

void rcu_config(void);
void gpio_config(void);
void i2c_config(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)
{
    uint8_t i;

    /* initialize led */
    gd_eval_led_init(LED2);
    gd_eval_led_init(LED3);
    /* configure RCU */
    rcu_config();
    /* configure GPIO */
    gpio_config();
    /* configure I2C */
    i2c_config();

    for(i = 0; i < 16; i++) {
        i2c_transmitter[i] = i + 0x80;
    }
    /* wait until I2C bus is idle */
    while(i2c_flag_get(I2C0, I2C_FLAG_I2CBSY));
    /* send a start condition to I2C bus */
    i2c_start_on_bus(I2C0);
    /* wait until SBSEND bit is set */
    while(!i2c_flag_get(I2C0, I2C_FLAG_SBSEND));
    /* send slave address to I2C bus */
    i2c_master_addressing(I2C0, I2C1_SLAVE_ADDRESS7, I2C_RECEIVER);
    /* wait until ADDSEND bit is set */
    while(!i2c_flag_get(I2C0, I2C_FLAG_ADDSEND));
    /* clear ADDSEND bit */
    i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND);
    /* wait until ADDSEND bit is set */
    while(!i2c_flag_get(I2C1, I2C_FLAG_ADDSEND));
    /* clear ADDSEND bit */
    i2c_flag_clear(I2C1, I2C_FLAG_ADDSEND);

    for(i = 0; i < 15; i++) {
        /* send a data byte */
        i2c_data_transmit(I2C1, i2c_transmitter[i]);
        /* wait until the transmission data register is empty */
        while(!i2c_flag_get(I2C1, I2C_FLAG_TBE));
        /* wait until the RBNE bit is set */
        while(!i2c_flag_get(I2C0, I2C_FLAG_RBNE));
        /* read a data from I2C_DATA */
        i2c_receiver[i] = i2c_data_receive(I2C0);
    }
    /* send a NACK for the last data byte */
    i2c_ack_config(I2C0, I2C_ACK_DISABLE);
    /* send a data byte */
    i2c_data_transmit(I2C1, i2c_transmitter[i]);
    /* wait until the transmission data register is empty */
    while(!i2c_flag_get(I2C1, I2C_FLAG_TBE));
    /* the master doesn't acknowledge for the last byte */
    while(!i2c_flag_get(I2C1, I2C_FLAG_AERR));
    /* send a stop condition to I2C bus */
    i2c_stop_on_bus(I2C0);
    while(I2C_CTL0(I2C0) & 0x0200);
    i2c_receiver[i] = i2c_data_receive(I2C0);
    i2c_ack_config(I2C0, I2C_ACK_ENABLE);
    /* clear the bit of AE */
    i2c_flag_clear(I2C1, I2C_FLAG_AERR);

    /* compare the transmit buffer and the receive buffer */
    state = memory_compare(i2c_transmitter, i2c_receiver, 16);
    /* if success, LED2 and LED3 are on */
    if(SUCCESS == state) {
        gd_eval_led_on(LED2);
        gd_eval_led_on(LED3);
    } else {
        /* if failed, LED2 and LED3 are off */
        gd_eval_led_off(LED2);
        gd_eval_led_off(LED3);
    }
    while(1) {
    }
}

void rcu_config(void)
{
    /* enable GPIOB clock */
    rcu_periph_clock_enable(RCU_GPIOB);
    /* enable I2C1 clock */
    rcu_periph_clock_enable(RCU_I2C1);
    /* enable I2C0 clock */
    rcu_periph_clock_enable(RCU_I2C0);
}

void gpio_config(void)
{
    /* connect PB6 to I2C0_SCL */
    /* connect PB7 to I2C0_SDA */
    /* connect PB10 to I2C1_SCL */
    /* connect PB11 to I2C1_SDA */
    gpio_init(GPIOB, GPIO_MODE_AF_OD, GPIO_OSPEED_50MHZ, GPIO_PIN_6 | GPIO_PIN_7 | GPIO_PIN_10 | GPIO_PIN_11);
}

void i2c_config(void)
{
    /* I2C clock configure */
    i2c_clock_config(I2C0, 1000000, I2C_DTCY_16_9);
    /* I2C address configure */
    i2c_mode_addr_config(I2C0, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, I2C0_SLAVE_ADDRESS7);
    /* enable I2C0 */
    i2c_enable(I2C0);
    /* enable acknowledge */
    i2c_ack_config(I2C0, I2C_ACK_ENABLE);
    i2c_clock_config(I2C1, 1000000, I2C_DTCY_16_9);
    /* I2C address configure */
    i2c_mode_addr_config(I2C1, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, I2C1_SLAVE_ADDRESS7);
    /* enable I2C1 */
    i2c_enable(I2C1);
    /* enable acknowledge */
    i2c_ack_config(I2C1, I2C_ACK_ENABLE);
}

代码讲解

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

I2C 配置：设置通信速率（标准 100K / 快速 400K / 快速+ 1M）、从机地址、时钟拉伸。

实验现象

主机和从机完成数据收发
校验通过 LED 指示成功

注意事项

I2C 总线需要上拉电阻（一般 4.7K）
从机地址要与设备手册一致（注意 7 位/8 位地址的区别）
写 EEPROM 后需要等待 5ms 以上再读

GD32 I2C — I2C 从机发送

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

I2C — I2C 从机发送

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

功能简介

本示例演示 I2C 总线通信。I2C 只需两根线（SCL+SDA）就能连接多个设备，是最常用的低速通信总线。

硬件准备

I2C 从设备（如 EEPROM、传感器模块）
SCL/SDA 线上需要 4.7K 上拉电阻

完整代码

#include "gd32f30x.h"
#define I2C_10BIT_ADDRESS      0
#define I2C0_OWN_ADDRESS7      0x82
#define I2C0_SLAVE_ADDRESS7    0x72
#define I2C0_OWN_ADDRESS10     0x0322

void rcu_config(void);
void gpio_config(void);
void i2c_config(void);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    uint8_t i;

    /* cofigure RCU */
    rcu_config();
    /* cofigure GPIO */
    gpio_config();
    /* cofigure I2C */
    i2c_config();

    for(i = 0; i < 16; i++) {
        i2c_transmitter[i] = i + 0x80;
    }

#if I2C_10BIT_ADDRESS
    /* wait until ADDSEND bit is set */
    while(!i2c_flag_get(I2C0, I2C_FLAG_ADDSEND));
    /* clear ADDSEND bit */
    i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND);
    /* wait until ADDSEND bit is set */
    while(!i2c_flag_get(I2C0, I2C_FLAG_ADDSEND));
    /* clear ADDSEND bit */
    i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND);
#else
    /* wait until ADDSEND bit is set */
    while(!i2c_flag_get(I2C0, I2C_FLAG_ADDSEND));
    /* clear ADDSEND bit */
    i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND);
#endif
    /* wait until the transmission data register is empty */
    while(!i2c_flag_get(I2C0, I2C_FLAG_TBE));

    for(i = 0; i < 16; i++) {
        /* send a data byte */
        i2c_data_transmit(I2C0, i2c_transmitter[i]);
        /* wait until the transmission data register is empty */
        while(!i2c_flag_get(I2C0, I2C_FLAG_TBE));
    }
    /* the master doesn't acknowledge for the last byte */
    while(!i2c_flag_get(I2C0, I2C_FLAG_AERR));
    /* clear the bit of AERR */
    i2c_flag_clear(I2C0, I2C_FLAG_AERR);

    while(1) {
    }
}

void rcu_config(void)
{
    /* enable GPIOB clock */
    rcu_periph_clock_enable(RCU_GPIOB);
    /* enable I2C0 clock */
    rcu_periph_clock_enable(RCU_I2C0);
}

void gpio_config(void)
{
    /* connect PB6 to I2C0_SCL */
    /* connect PB7 to I2C0_SDA */
    gpio_init(GPIOB, GPIO_MODE_AF_OD, GPIO_OSPEED_50MHZ, GPIO_PIN_6 | GPIO_PIN_7);
}

void i2c_config(void)
{
    /* cofigure I2C clock */
    i2c_clock_config(I2C0, 400000, I2C_DTCY_2);
    /* cofigure I2C address */
#if I2C_10BIT_ADDRESS
    i2c_mode_addr_config(I2C0, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_10BITS, I2C0_OWN_ADDRESS10);
#else
    i2c_mode_addr_config(I2C0, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, I2C0_OWN_ADDRESS7);
#endif
    /* enable I2C0 */
    i2c_enable(I2C0);
    /* enable acknowledge */
    i2c_ack_config(I2C0, I2C_ACK_ENABLE);
}

代码讲解

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

I2C 配置：设置通信速率（标准 100K / 快速 400K / 快速+ 1M）、从机地址、时钟拉伸。

实验现象

主机和从机完成数据收发
校验通过 LED 指示成功

注意事项

I2C 总线需要上拉电阻（一般 4.7K）
从机地址要与设备手册一致（注意 7 位/8 位地址的区别）
写 EEPROM 后需要等待 5ms 以上再读

GD32 I2C — I2C 从机接收

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

I2C — I2C 从机接收

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

功能简介

本示例演示 I2C 总线通信。I2C 只需两根线（SCL+SDA）就能连接多个设备，是最常用的低速通信总线。

硬件准备

I2C 从设备（如 EEPROM、传感器模块）
SCL/SDA 线上需要 4.7K 上拉电阻

完整代码

#include "gd32f30x.h"
#define I2C0_OWN_ADDRESS7      0x82

void rcu_config(void);
void gpio_config(void);
void i2c_config(void);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    uint8_t i;

    /* cofigure RCU */
    rcu_config();
    /* cofigure GPIO */
    gpio_config();
    /* cofigure I2C */
    i2c_config();

    i = 0;
    /* wait until ADDSEND bit is set */
    while(!i2c_flag_get(I2C0, I2C_FLAG_ADDSEND));
    /* clear ADDSEND bit */
    i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND);
    for(i = 0; i < 16; i++) {
        /* wait until the RBNE bit is set */
        while(!i2c_flag_get(I2C0, I2C_FLAG_RBNE));

        /* read a data byte from I2C_DATA */
        i2c_receiver[i] = i2c_data_receive(I2C0);
    }
    /* wait until the STPDET bit is set */
    while(!i2c_flag_get(I2C0, I2C_FLAG_STPDET));
    /* clear the STPDET bit */
    i2c_enable(I2C0);

    while(1) {
    }
}

void rcu_config(void)
{
    /* enable GPIOB clock */
    rcu_periph_clock_enable(RCU_GPIOB);
    /* enable I2C0 clock */
    rcu_periph_clock_enable(RCU_I2C0);
}

void gpio_config(void)
{
    /* connect PB6 to I2C0_SCL */
    /* connect PB7 to I2C0_SDA */
    gpio_init(GPIOB, GPIO_MODE_AF_OD, GPIO_OSPEED_50MHZ, GPIO_PIN_6 | GPIO_PIN_7);
}

void i2c_config(void)
{
    /* cofigure I2C clock */
    i2c_clock_config(I2C0, 100000, I2C_DTCY_2);
    /* cofigure I2C address */
    i2c_mode_addr_config(I2C0, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, I2C0_OWN_ADDRESS7);
    /* enable I2C0 */
    i2c_enable(I2C0);
    /* enable acknowledge */
    i2c_ack_config(I2C0, I2C_ACK_ENABLE);
}

代码讲解

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

I2C 配置：设置通信速率（标准 100K / 快速 400K / 快速+ 1M）、从机地址、时钟拉伸。

实验现象

主机和从机完成数据收发
校验通过 LED 指示成功

注意事项

I2C 总线需要上拉电阻（一般 4.7K）
从机地址要与设备手册一致（注意 7 位/8 位地址的区别）
写 EEPROM 后需要等待 5ms 以上再读

GD32 I2C — I2C 主发从收

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

I2C — I2C 主发从收

固件库: GD32F30x_Firmware_Library V3.0.3
芯片: GD32
源文件: GD32F30x_Firmware_Library_V3.0.3/Examples/I2C/Master_transmitter&slave_receiver/main.c

功能简介

本示例演示 I2C 总线通信。I2C 只需两根线（SCL+SDA）就能连接多个设备，是最常用的低速通信总线。

硬件准备

I2C 从设备（如 EEPROM、传感器模块）
SCL/SDA 线上需要 4.7K 上拉电阻

完整代码

#include "gd32f30x.h"
#include <stdio.h>
#include "gd32f307c_eval.h"
#define I2C0_SLAVE_ADDRESS7    0x82
#define I2C1_SLAVE_ADDRESS7    0x72

void rcu_config(void);
void gpio_config(void);
void i2c_config(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)
{
    uint8_t i;
    gd_eval_led_init(LED2);
    gd_eval_led_init(LED3);
    rcu_config();
    gpio_config();
    i2c_config();

    for(i = 0; i < 16; i++) {
        i2c_transmitter[i] = i + 0x80;
    }

    /* wait until I2C bus is idle */
    while(i2c_flag_get(I2C0, I2C_FLAG_I2CBSY));

    /* send a start condition to I2C bus */
    i2c_start_on_bus(I2C0);

    /* wait until SBSEND bit is set */
    while(!i2c_flag_get(I2C0, I2C_FLAG_SBSEND));

    /* send slave address to I2C bus*/
    i2c_master_addressing(I2C0, I2C1_SLAVE_ADDRESS7, I2C_TRANSMITTER);

    /* wait until ADDSEND bit is set*/
    while(!i2c_flag_get(I2C0, I2C_FLAG_ADDSEND));
    while(!i2c_flag_get(I2C1, I2C_FLAG_ADDSEND));
    /* clear ADDSEND bit */
    i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND);
    i2c_flag_clear(I2C1, I2C_FLAG_ADDSEND);
    for(i = 0; i < 16; i++) {
        /* send a data byte */
        i2c_data_transmit(I2C0, i2c_transmitter[i]);
        /* wait until the transmission data register is empty*/
        while(!i2c_flag_get(I2C0, I2C_FLAG_TBE));
        /* wait until the RBNE bit is set */
        while(!i2c_flag_get(I2C1, I2C_FLAG_RBNE));
        /* read a data from I2C_DATA */
        i2c_receiver[i] = i2c_data_receive(I2C1);
    }
    /* send a stop condition to I2C bus*/
    i2c_stop_on_bus(I2C0);
    /* wait until stop condition generate */
    while(I2C_CTL0(I2C0) & 0x0200);
    while(!i2c_flag_get(I2C1, I2C_FLAG_STPDET));
    /* clear the STPDET bit */
    i2c_enable(I2C1);
    state = memory_compare(i2c_transmitter, i2c_receiver, 16);
    if(SUCCESS == state) {
        gd_eval_led_on(LED2);
        gd_eval_led_on(LED3);
    } else {
        gd_eval_led_off(LED2);
        gd_eval_led_off(LED3);
    }
    while(1);
}

void rcu_config(void)
{
    /* enable GPIOB clock */
    rcu_periph_clock_enable(RCU_GPIOB);
    /* enable I2C1 clock */
    rcu_periph_clock_enable(RCU_I2C1);
    /* enable I2C0 clock */
    rcu_periph_clock_enable(RCU_I2C0);
}

void gpio_config(void)
{
    /* connect PB6 to I2C0_SCL */
    /* connect PB7 to I2C0_SDA */
    /* connect PB10 to I2C1_SCL */
    /* connect PB11 to I2C1_SDA */
    gpio_init(GPIOB, GPIO_MODE_AF_OD, GPIO_OSPEED_50MHZ, GPIO_PIN_6 | GPIO_PIN_7 | GPIO_PIN_10 | GPIO_PIN_11);
}

void i2c_config(void)
{
    /* configure I2C0 clock */
    i2c_clock_config(I2C0, 100000, I2C_DTCY_2);
    /* configure I2C0 address */
    i2c_mode_addr_config(I2C0, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, I2C0_SLAVE_ADDRESS7);
    /* enable I2C0 */
    i2c_enable(I2C0);
    /* enable acknowledge */
    i2c_ack_config(I2C0, I2C_ACK_ENABLE);
    /* configure I2C1 clock */
    i2c_clock_config(I2C1, 100000, I2C_DTCY_2);
    /* configure I2C1 address */
    i2c_mode_addr_config(I2C1, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, I2C1_SLAVE_ADDRESS7);
    /* enable I2C1 */
    i2c_enable(I2C1);
    /* enable acknowledge */
    i2c_ack_config(I2C1, I2C_ACK_ENABLE);
}

代码讲解

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

I2C 配置：设置通信速率（标准 100K / 快速 400K / 快速+ 1M）、从机地址、时钟拉伸。

实验现象

主机和从机完成数据收发
校验通过 LED 指示成功

注意事项

I2C 总线需要上拉电阻（一般 4.7K）
从机地址要与设备手册一致（注意 7 位/8 位地址的区别）
写 EEPROM 后需要等待 5ms 以上再读

GD32 I2C — I2C 主发从收 DMA

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

I2C — I2C 主发从收 DMA

固件库: GD32F30x_Firmware_Library V3.0.3
芯片: GD32
源文件: GD32F30x_Firmware_Library_V3.0.3/Examples/I2C/Master_transmitter&slave_receiver_dma/main.c

功能简介

本示例演示 I2C + DMA 通信。大数据量传输时，DMA 可以大幅降低 CPU 负载。

硬件准备

I2C 从设备（如 EEPROM、传感器模块）
SCL/SDA 线上需要 4.7K 上拉电阻

完整代码

#include "gd32f30x.h"
#include <stdio.h>
#include "gd32f307c_eval.h"
#define I2C0_SLAVE_ADDRESS7      0x82
#define I2C1_SLAVE_ADDRESS7      0x72
#define ARRAYNUM(arr_nanme)      (uint32_t)(sizeof(arr_nanme) / sizeof(*(arr_nanme)))
#define I2C0_DATA_ADDRESS        0x40005410
#define I2C1_DATA_ADDRESS        0x40005810
#define BUFFER_SIZE              (ARRAYNUM(i2c0_buff_tx)-1)

void rcu_config(void);
void gpio_config(void);
void i2c_config(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)
{
    dma_parameter_struct dma_init_struct;

    gd_eval_led_init(LED2);
    gd_eval_led_init(LED3);
    rcu_config();
    gpio_config();
    i2c_config();

    /* initialize DMA channel4 */
    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)i2c1_buff_rx;
    dma_init_struct.memory_inc = DMA_MEMORY_INCREASE_ENABLE;
    dma_init_struct.memory_width = DMA_MEMORY_WIDTH_8BIT;
    dma_init_struct.number = BUFFER_SIZE;
    dma_init_struct.periph_addr = I2C1_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);

    /* initialize DMA channel5 */
    dma_deinit(DMA0, DMA_CH5);
    dma_init_struct.direction = DMA_MEMORY_TO_PERIPHERAL;
    dma_init_struct.memory_addr = (uint32_t)i2c0_buff_tx;
    dma_init_struct.periph_addr = I2C0_DATA_ADDRESS;
    dma_init_struct.priority = DMA_PRIORITY_HIGH;
    dma_init(DMA0, DMA_CH5, &dma_init_struct);

    /* wait until I2C bus is idle */
    while(i2c_flag_get(I2C0, I2C_FLAG_I2CBSY));

    /* send a start condition to I2C bus */
    i2c_start_on_bus(I2C0);

    /* wait until SBSEND bit is set */
    while(!i2c_flag_get(I2C0, I2C_FLAG_SBSEND));

    /* send slave address to I2C bus*/
    i2c_master_addressing(I2C0, I2C1_SLAVE_ADDRESS7, I2C_TRANSMITTER);

    /* wait until ADDSEND bit is set*/
    while(!i2c_flag_get(I2C1, I2C_FLAG_ADDSEND));
    while(!i2c_flag_get(I2C0, I2C_FLAG_ADDSEND));
    /* clear ADDSEND bit */
    i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND);
    i2c_flag_clear(I2C1, I2C_FLAG_ADDSEND);

    /* enable I2C1 DMA */
    i2c_dma_config(I2C1, I2C_DMA_ON);
    /* enable I2C0 DMA */
    i2c_dma_config(I2C0, I2C_DMA_ON);
    /* enable DMA0 channel4 */
    dma_channel_enable(DMA0, DMA_CH4);
    /* enable DMA0 channel5 */
    dma_channel_enable(DMA0, DMA_CH5);

    /* DMA0 channel4 full transfer finish flag */
    while(!dma_flag_get(DMA0, DMA_CH4, DMA_FLAG_FTF));
    /* DMA0 channel5 full transfer finish flag */
    while(!dma_flag_get(DMA0, DMA_CH5, DMA_FLAG_FTF));

    /* send a stop condition to I2C bus*/
    i2c_stop_on_bus(I2C0);
    /* wait until stop condition generate */
    while(I2C_CTL0(I2C0) & 0x0200);
    while(!i2c_flag_get(I2C1, I2C_FLAG_STPDET));
    /* clear the STPDET bit */
    i2c_enable(I2C1);
    state = memory_compare(i2c0_buff_tx, i2c1_buff_rx, BUFFER_SIZE);
    if(SUCCESS == state) {
        gd_eval_led_on(LED2);
        gd_eval_led_on(LED3);
    } else {
        gd_eval_led_off(LED2);
        gd_eval_led_off(LED3);
    }
    while(1) {
    }
}

void rcu_config(void)
{
    /* enable GPIOB clock */
    rcu_periph_clock_enable(RCU_GPIOB);
    /* enable I2C1 clock */
    rcu_periph_clock_enable(RCU_I2C1);
    /* enable I2C0 clock */
    rcu_periph_clock_enable(RCU_I2C0);
    /* enable DMA0 clock */
    rcu_periph_clock_enable(RCU_DMA0);
}

void gpio_config(void)
{
    /* connect PB6 to I2C0_SCL */
    /* connect PB7 to I2C0_SDA */
    /* connect PB10 to I2C1_SCL */
    /* connect PB11 to I2C1_SDA */
    gpio_init(GPIOB, GPIO_MODE_AF_OD, GPIO_OSPEED_50MHZ, GPIO_PIN_6 | GPIO_PIN_7 | GPIO_PIN_10 | GPIO_PIN_11);
}

void i2c_config(void)
{
    /* configure I2C0 clock */
    i2c_clock_config(I2C0, 100000, I2C_DTCY_2);
    /* configure I2C0 address */
    i2c_mode_addr_config(I2C0, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, I2C0_SLAVE_ADDRESS7);
    /* enable I2C0 */
    i2c_enable(I2C0);
    /* enable acknowledge */
    i2c_ack_config(I2C0, I2C_ACK_ENABLE);
    /* configure I2C1 clock */
    i2c_clock_config(I2C1, 100000, I2C_DTCY_2);
    /* configure I2C1 address */
    i2c_mode_addr_config(I2C1, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, I2C1_SLAVE_ADDRESS7);
    /* enable I2C1 */
    i2c_enable(I2C1);
    /* enable acknowledge */
    i2c_ack_config(I2C1, I2C_ACK_ENABLE);
}

代码讲解

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

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

I2C 配置：设置通信速率（标准 100K / 快速 400K / 快速+ 1M）、从机地址、时钟拉伸。

实验现象

主机和从机完成数据收发
校验通过 LED 指示成功

注意事项

I2C 总线需要上拉电阻（一般 4.7K）
从机地址要与设备手册一致（注意 7 位/8 位地址的区别）
写 EEPROM 后需要等待 5ms 以上再读

GD32 I2C — I2C 主发从收中断

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

I2C — I2C 主发从收中断

固件库: GD32F30x_Firmware_Library V3.0.3
芯片: GD32
源文件: GD32F30x_Firmware_Library_V3.0.3/Examples/I2C/Master_transmitter&slave_receiver_interrupt/main.c

功能简介

本示例演示 I2C 中断方式通信。每完成一个字节触发中断，CPU 在中断中处理后续操作，效率更高。

硬件准备

I2C 从设备（如 EEPROM、传感器模块）
SCL/SDA 线上需要 4.7K 上拉电阻

完整代码

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

void rcu_config(void);
void gpio_config(void);
void i2c_config(void);
void i2c_nvic_config(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)
{
    uint8_t i;

    /* initialize LED2, LED3, as the transfer instruction */
    gd_eval_led_init(LED2);
    gd_eval_led_init(LED3);
    rcu_config();
    gpio_config();
    i2c_config();
    i2c_nvic_config();

    for(i = 0; i < 16; i++) {
        i2c_buffer_transmitter[i] = i + 0x80;
    }
    /* initialize i2c_txbuffer, i2c_rxbuffer, I2C_nBytes and status */
    i2c_txbuffer = i2c_buffer_transmitter;
    i2c_rxbuffer = i2c_buffer_receiver;
    I2C_nBytes = 16;
    status = ERROR;

    /* enable the I2C0 interrupt */
    i2c_interrupt_enable(I2C0, I2C_INT_ERR);
    i2c_interrupt_enable(I2C0, I2C_INT_BUF);
    i2c_interrupt_enable(I2C0, I2C_INT_EV);
    /* enable the I2C1 interrupt */
    i2c_interrupt_enable(I2C1, I2C_INT_ERR);
    i2c_interrupt_enable(I2C1, I2C_INT_BUF);
    i2c_interrupt_enable(I2C1, I2C_INT_EV);

    /* the master waits until the I2C bus is idle */
    while(i2c_flag_get(I2C0, I2C_FLAG_I2CBSY));

    /* the master sends a start condition to I2C bus */
    i2c_start_on_bus(I2C0);

    while((I2C_nBytes > 0));
    while(SUCCESS != status);
    /* if the transfer is successfully completed, LED2 and LED3 is on */
    state = memory_compare(i2c_buffer_transmitter, i2c_buffer_receiver, 16);
    if(SUCCESS == state) {
        /* if success, LED2 and LED3 are on */
        gd_eval_led_on(LED2);
        gd_eval_led_on(LED3);
    } else {
        /* if failed, LED2 and LED3 are off */
        gd_eval_led_off(LED2);
        gd_eval_led_off(LED3);
    }
    while(1) {
    }
}

void rcu_config(void)
{
    /* enable GPIOB clock */
    rcu_periph_clock_enable(RCU_GPIOB);
    /* enable I2C1 clock */
    rcu_periph_clock_enable(RCU_I2C1);
    /* enable I2C0 clock */
    rcu_periph_clock_enable(RCU_I2C0);
}

void gpio_config(void)
{
    /* connect PB6 to I2C0_SCL */
    /* connect PB7 to I2C0_SDA */
    /* connect PB10 to I2C1_SCL */
    /* connect PB11 to I2C1_SDA */
    gpio_init(GPIOB, GPIO_MODE_AF_OD, GPIO_OSPEED_50MHZ, GPIO_PIN_6 | GPIO_PIN_7 | GPIO_PIN_10 | GPIO_PIN_11);
}

void i2c_config(void)
{
    /* configure I2C clock */
    i2c_clock_config(I2C0, 100000, I2C_DTCY_2);
    /* configure I2C address */
    i2c_mode_addr_config(I2C0, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, I2C0_SLAVE_ADDRESS7);
    /* enable I2C0 */
    i2c_enable(I2C0);
    /* enable acknowledge */
    i2c_ack_config(I2C0, I2C_ACK_ENABLE);
    i2c_clock_config(I2C1, 100000, I2C_DTCY_2);
    /* configure I2C address */
    i2c_mode_addr_config(I2C1, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, I2C1_SLAVE_ADDRESS7);
    /* enable I2C1 */
    i2c_enable(I2C1);
    /* enable acknowledge */
    i2c_ack_config(I2C1, I2C_ACK_ENABLE);
}

void i2c_nvic_config(void)
{
    nvic_priority_group_set(NVIC_PRIGROUP_PRE1_SUB3);
    nvic_irq_enable(I2C0_EV_IRQn, 0, 3);
    nvic_irq_enable(I2C1_EV_IRQn, 0, 4);
    nvic_irq_enable(I2C0_ER_IRQn, 0, 2);
    nvic_irq_enable(I2C1_ER_IRQn, 0, 1);
}

代码讲解

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

I2C 配置：设置通信速率（标准 100K / 快速 400K / 快速+ 1M）、从机地址、时钟拉伸。

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

实验现象

主机和从机完成数据收发
校验通过 LED 指示成功

注意事项

I2C 总线需要上拉电阻（一般 4.7K）
从机地址要与设备手册一致（注意 7 位/8 位地址的区别）
写 EEPROM 后需要等待 5ms 以上再读

GD32 I2C — I2C 主机发送

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

I2C — I2C 主机发送

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

功能简介

本示例演示 I2C 总线通信。I2C 只需两根线（SCL+SDA）就能连接多个设备，是最常用的低速通信总线。

硬件准备

I2C 从设备（如 EEPROM、传感器模块）
SCL/SDA 线上需要 4.7K 上拉电阻

完整代码

#include "gd32f30x.h"
#define I2C0_OWN_ADDRESS7      0x72
#define I2C0_SLAVE_ADDRESS7    0x82

void rcu_config(void);
void gpio_config(void);
void i2c_config(void);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    uint8_t i;

    /* cofigure RCU */
    rcu_config();
    /* cofigure GPIO */
    gpio_config();
    /* cofigure I2C */
    i2c_config();

    for(i = 0; i < 16; i++) {
        i2c_transmitter[i] = i + 0x80;
    }

    /* wait until I2C bus is idle */
    while(i2c_flag_get(I2C0, I2C_FLAG_I2CBSY));
    /* send a start condition to I2C bus */
    i2c_start_on_bus(I2C0);
    /* wait until SBSEND bit is set */
    while(!i2c_flag_get(I2C0, I2C_FLAG_SBSEND));
    /* send slave address to I2C bus */
    i2c_master_addressing(I2C0, I2C0_SLAVE_ADDRESS7, I2C_TRANSMITTER);
    /* wait until ADDSEND bit is set */
    while(!i2c_flag_get(I2C0, I2C_FLAG_ADDSEND));
    /* clear ADDSEND bit */
    i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND);
    /* wait until the transmit data buffer is empty */
    while(!i2c_flag_get(I2C0, I2C_FLAG_TBE));

    for(i = 0; i < 16; i++) {
        /* data transmission */
        i2c_data_transmit(I2C0, i2c_transmitter[i]);
        /* wait until the TBE bit is set */
        while(!i2c_flag_get(I2C0, I2C_FLAG_TBE));
    }
    /* send a stop condition to I2C bus */
    i2c_stop_on_bus(I2C0);
    /* wait until stop condition generate */
    while(I2C_CTL0(I2C0) & 0x0200);

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

void rcu_config(void)
{
    /* enable GPIOB clock */
    rcu_periph_clock_enable(RCU_GPIOB);
    /* enable I2C0 clock */
    rcu_periph_clock_enable(RCU_I2C0);
}

void gpio_config(void)
{
    /* connect PB6 to I2C0_SCL */
    /* connect PB7 to I2C0_SDA */
    gpio_init(GPIOB, GPIO_MODE_AF_OD, GPIO_OSPEED_50MHZ, GPIO_PIN_6 | GPIO_PIN_7);
}

void i2c_config(void)
{
    /* cofigure I2C clock */
    i2c_clock_config(I2C0, 100000, I2C_DTCY_2);
    /* cofigure I2C address */
    i2c_mode_addr_config(I2C0, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, I2C0_OWN_ADDRESS7);
    /* enable I2C0 */
    i2c_enable(I2C0);
    /* enable acknowledge */
    i2c_ack_config(I2C0, I2C_ACK_ENABLE);
}

代码讲解

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

I2C 配置：设置通信速率（标准 100K / 快速 400K / 快速+ 1M）、从机地址、时钟拉伸。

实验现象

主机和从机完成数据收发
校验通过 LED 指示成功

注意事项

I2C 总线需要上拉电阻（一般 4.7K）
从机地址要与设备手册一致（注意 7 位/8 位地址的区别）
写 EEPROM 后需要等待 5ms 以上再读

GD32 I2C — I2C 主机接收

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

I2C — I2C 主机接收

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

功能简介

本示例演示 I2C 总线通信。I2C 只需两根线（SCL+SDA）就能连接多个设备，是最常用的低速通信总线。

硬件准备

I2C 从设备（如 EEPROM、传感器模块）
SCL/SDA 线上需要 4.7K 上拉电阻

完整代码

#include "gd32f30x.h"
#define I2C_10BIT_ADDRESS      0
#define I2C0_OWN_ADDRESS7      0x72
#define I2C0_SLAVE_ADDRESS7    0x82
#define I2C0_SLAVE_ADDRESS10   0x0322

void rcu_config(void);
void gpio_config(void);
void i2c_config(void);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    uint8_t i;
#if I2C_10BIT_ADDRESS
    uint8_t slave10_first_byte, slave10_second_byte;
#endif

    /* configure RCU  */
    rcu_config();
    /* configure GPIO */
    gpio_config();
    /* configure I2C */
    i2c_config();

    /* wait until I2C bus is idle */
    while(i2c_flag_get(I2C0, I2C_FLAG_I2CBSY));
    /* send a start condition to I2C bus */
    i2c_start_on_bus(I2C0);
    /* wait until SBSEND bit is set */
    while(!i2c_flag_get(I2C0, I2C_FLAG_SBSEND));

#if I2C_10BIT_ADDRESS
    slave10_first_byte = (0xF0) | (uint8_t)((I2C0_SLAVE_ADDRESS10 & 0x0300) >> 7);
    /* send slave address first byte to I2C bus */
    i2c_master_addressing(I2C0, slave10_first_byte, I2C_TRANSMITTER);
    /* wait until ADD10SEND bit is set */
    while(!i2c_flag_get(I2C0, I2C_FLAG_ADD10SEND));
    /* the second byte contains the remaining 8 bits of the 10-bit address */
    slave10_second_byte = (uint8_t)(I2C0_SLAVE_ADDRESS10 & 0x00FF);
    /* send slave address 2nd byte to I2C bus */
    i2c_master_addressing(I2C0, slave10_second_byte, I2C_TRANSMITTER);
    /* wait until ADDSEND bit is set */
    while(!i2c_flag_get(I2C0, I2C_FLAG_ADDSEND));
    /* clear ADDSEND bit */
    i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND);
    /* send a start condition to I2C bus */
    i2c_start_on_bus(I2C0);
    /* wait until SBSEND bit is set */
    while(!i2c_flag_get(I2C0, I2C_FLAG_SBSEND));
    /* send slave address first byte to I2C bus */
    i2c_master_addressing(I2C0, slave10_first_byte, I2C_RECEIVER);
#else
    /* send slave address to I2C bus */
    i2c_master_addressing(I2C0, I2C0_SLAVE_ADDRESS7, I2C_RECEIVER);
#endif
    /* wait until ADDSEND bit is set */
    while(!i2c_flag_get(I2C0, I2C_FLAG_ADDSEND));
    /* clear ADDSEND bit */
    i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND);

    for(i = 0; i < 16; i++) {
        if(13 == i) {
            /* wait until the second last data byte is received into the shift register */
            while(!i2c_flag_get(I2C0, I2C_FLAG_BTC));
            /* disable acknowledge */
            i2c_ack_config(I2C0, I2C_ACK_DISABLE);
        }
        /* wait until the RBNE bit is set */
        while(!i2c_flag_get(I2C0, I2C_FLAG_RBNE));
        /* read a data from I2C_DATA */
        i2c_receiver[i] = i2c_data_receive(I2C0);
    }
    /* send a stop condition to I2C bus */
    i2c_stop_on_bus(I2C0);
    /* wait until stop condition generate */
    while(I2C_CTL0(I2C0) & 0x0200);
    /* enable acknowledge */
    i2c_ack_config(I2C0, I2C_ACK_ENABLE);

    while(1) {
    }
}

void rcu_config(void)
{
    /* enable GPIOB clock */
    rcu_periph_clock_enable(RCU_GPIOB);
    /* enable I2C0 clock */
    rcu_periph_clock_enable(RCU_I2C0);
}

void gpio_config(void)
{
    /* connect PB6 to I2C0_SCL */
    /* connect PB7 to I2C0_SDA */
    gpio_init(GPIOB, GPIO_MODE_AF_OD, GPIO_OSPEED_50MHZ, GPIO_PIN_6 | GPIO_PIN_7);
}

void i2c_config(void)
{
    /* configure I2C clock */
    i2c_clock_config(I2C0, 400000, I2C_DTCY_2);
    /* configure I2C address */
    i2c_mode_addr_config(I2C0, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, I2C0_OWN_ADDRESS7);
    /* enable I2C0 */
    i2c_enable(I2C0);
    /* enable acknowledge */
    i2c_ack_config(I2C0, I2C_ACK_ENABLE);
}

代码讲解

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

I2C 配置：设置通信速率（标准 100K / 快速 400K / 快速+ 1M）、从机地址、时钟拉伸。

实验现象

主机和从机完成数据收发
校验通过 LED 指示成功

注意事项

I2C 总线需要上拉电阻（一般 4.7K）
从机地址要与设备手册一致（注意 7 位/8 位地址的区别）
写 EEPROM 后需要等待 5ms 以上再读

GD32 I2C — I2C 主机接收 1 字节

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

I2C — I2C 主机接收 1 字节

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

功能简介

本示例演示 I2C 总线通信。I2C 只需两根线（SCL+SDA）就能连接多个设备，是最常用的低速通信总线。

硬件准备

I2C 从设备（如 EEPROM、传感器模块）
SCL/SDA 线上需要 4.7K 上拉电阻

完整代码

#include "gd32f30x.h"
#define I2C0_SLAVE_ADDRESS7    0x72
#define I2C1_SLAVE_ADDRESS7    0x82

void rcu_config(void);
void gpio_config(void);
void i2c_config(void);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    uint8_t i;

    /* cofigure RCU */
    rcu_config();
    /* cofigure GPIO */
    gpio_config();
    /* cofigure I2C */
    i2c_config();

    i = 0;
    /* wait until I2C bus is idle */
    while(i2c_flag_get(I2C0, I2C_FLAG_I2CBSY));
    /* send a start condition to I2C bus */
    i2c_start_on_bus(I2C0);
    /* wait until SBSEND bit is set */
    while(!i2c_flag_get(I2C0, I2C_FLAG_SBSEND));
    /* send slave address to I2C bus */
    i2c_master_addressing(I2C0, I2C1_SLAVE_ADDRESS7, I2C_RECEIVER);
    /* wait until ADDSEND bit is set */
    while(!i2c_flag_get(I2C0, I2C_FLAG_ADDSEND));

    /* N=1,reset ACKEN bit before clearing ADDRSEND bit */
    i2c_ack_config(I2C0, I2C_ACK_DISABLE);
    /* clear ADDSEND bit */
    i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND);
    /* N=1,send stop condition after clearing ADDRSEND bit */
    i2c_stop_on_bus(I2C0);
    /* wait until the RBNE bit is set */
    while(!i2c_flag_get(I2C0, I2C_FLAG_RBNE));
    /* read a data from I2C_DATA */
    i2c_receiver[i++] = i2c_data_receive(I2C0);
    /* wait until stop condition generate */
    while(I2C_CTL0(I2C0) & 0x0200);
    /* Enable Acknowledge */
    i2c_ack_config(I2C0, I2C_ACK_ENABLE);

    while(1) {
    }
}

void rcu_config(void)
{
    /* enable GPIOB clock */
    rcu_periph_clock_enable(RCU_GPIOB);
    /* enable I2C0 clock */
    rcu_periph_clock_enable(RCU_I2C0);
}

void gpio_config(void)
{
    /* connect PB6 to I2C0_SCL */
    /* connect PB7 to I2C0_SDA */
    gpio_init(GPIOB, GPIO_MODE_AF_OD, GPIO_OSPEED_50MHZ, GPIO_PIN_6 | GPIO_PIN_7);
}

void i2c_config(void)
{
    /* cofigure I2C clock */
    i2c_clock_config(I2C0, 100000, I2C_DTCY_2);
    /* cofigure I2C address */
    i2c_mode_addr_config(I2C0, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, I2C0_SLAVE_ADDRESS7);
    /* enable I2C0 */
    i2c_enable(I2C0);
    /* enable acknowledge */
    i2c_ack_config(I2C0, I2C_ACK_ENABLE);
}

代码讲解

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

I2C 配置：设置通信速率（标准 100K / 快速 400K / 快速+ 1M）、从机地址、时钟拉伸。

实验现象

主机和从机完成数据收发
校验通过 LED 指示成功

注意事项

I2C 总线需要上拉电阻（一般 4.7K）
从机地址要与设备手册一致（注意 7 位/8 位地址的区别）
写 EEPROM 后需要等待 5ms 以上再读

GD32 I2C — I2C 主机接收 2 字节

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

I2C — I2C 主机接收 2 字节

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

功能简介

本示例演示 I2C 总线通信。I2C 只需两根线（SCL+SDA）就能连接多个设备，是最常用的低速通信总线。

硬件准备

I2C 从设备（如 EEPROM、传感器模块）
SCL/SDA 线上需要 4.7K 上拉电阻

完整代码

#include "gd32f30x.h"
#define I2C0_OWN_ADDRESS7      0x72
#define I2C0_SLAVE_ADDRESS7    0x82

void rcu_config(void);
void gpio_config(void);
void i2c_config(void);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    uint8_t i;

    /* cofigure RCU */
    rcu_config();
    /* cofigure GPIO */
    gpio_config();
    /* cofigure I2C */
    i2c_config();

    i = 0;
    /* send a NACK for the next data byte which will be received into the shift register */
    i2c_ackpos_config(I2C0, I2C_ACKPOS_NEXT);
    /* wait until I2C bus is idle */
    while(i2c_flag_get(I2C0, I2C_FLAG_I2CBSY));
    /* send a start condition to I2C bus */
    i2c_start_on_bus(I2C0);
    /* wait until SBSEND bit is set */
    while(!i2c_flag_get(I2C0, I2C_FLAG_SBSEND));
    /* send slave address to I2C bus */
    i2c_master_addressing(I2C0, I2C0_SLAVE_ADDRESS7, I2C_RECEIVER);
    /* disable ACK before clearing ADDSEND bit */
    i2c_ack_config(I2C0, I2C_ACK_DISABLE);
    /* wait until ADDSEND bit is set */
    while(!i2c_flag_get(I2C0, I2C_FLAG_ADDSEND));
    /* clear ADDSEND bit */
    i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND);
    /* Wait until the last data byte is received into the shift register */
    while(!i2c_flag_get(I2C0, I2C_FLAG_BTC));
    /* wait until the RBNE bit is set */
    while(!i2c_flag_get(I2C0, I2C_FLAG_RBNE));

    /* read a data from I2C_DATA */
    i2c_receiver[i++] = i2c_data_receive(I2C0);
    /* wait until the RBNE bit is set */
    while(!i2c_flag_get(I2C0, I2C_FLAG_RBNE));
    /* read a data from I2C_DATA */
    i2c_receiver[i++] = i2c_data_receive(I2C0);
    /* send a stop condition */
    i2c_stop_on_bus(I2C0);
    /* wait until stop condition generate */
    while(I2C_CTL0(I2C0) & 0x0200);
    i2c_ackpos_config(I2C0, I2C_ACKPOS_CURRENT);
    /* enable acknowledge */
    i2c_ack_config(I2C0, I2C_ACK_ENABLE);

    while(1) {
    }
}

void rcu_config(void)
{
    /* enable GPIOB clock */
    rcu_periph_clock_enable(RCU_GPIOB);
    /* enable I2C0 clock */
    rcu_periph_clock_enable(RCU_I2C0);
}

void gpio_config(void)
{
    /* connect PB6 to I2C0_SCL */
    /* connect PB7 to I2C0_SDA */
    gpio_init(GPIOB, GPIO_MODE_AF_OD, GPIO_OSPEED_50MHZ, GPIO_PIN_6 | GPIO_PIN_7);
}

void i2c_config(void)
{
    /* cofigure I2C clock */
    i2c_clock_config(I2C0, 100000, I2C_DTCY_2);
    /* cofigure I2C address */
    i2c_mode_addr_config(I2C0, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, I2C0_OWN_ADDRESS7);
    /* enable I2C0 */
    i2c_enable(I2C0);
    /* enable acknowledge */
    i2c_ack_config(I2C0, I2C_ACK_ENABLE);
}

代码讲解

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

I2C 配置：设置通信速率（标准 100K / 快速 400K / 快速+ 1M）、从机地址、时钟拉伸。

实验现象

主机和从机完成数据收发
校验通过 LED 指示成功

注意事项

I2C 总线需要上拉电阻（一般 4.7K）
从机地址要与设备手册一致（注意 7 位/8 位地址的区别）
写 EEPROM 后需要等待 5ms 以上再读

GD32 I2C — I2C 主收从发中断

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

I2C — I2C 主收从发中断

固件库: GD32F30x_Firmware_Library V3.0.3
芯片: GD32
源文件: GD32F30x_Firmware_Library_V3.0.3/Examples/I2C/Master_receiver&slave_transmitter_interrupt/main.c

功能简介

本示例演示 I2C 中断方式通信。每完成一个字节触发中断，CPU 在中断中处理后续操作，效率更高。

硬件准备

I2C 从设备（如 EEPROM、传感器模块）
SCL/SDA 线上需要 4.7K 上拉电阻

完整代码

#include "gd32f30x.h"
#include "I2C_IE.h"
#include "gd32f307c_eval.h"

void rcu_config(void);
void gpio_config(void);
void i2c_config(void);
void i2c_nvic_config(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)
{
    uint8_t i;

    /* initialize LED2, LED3, as the transfer instruction */
    gd_eval_led_init(LED2);
    gd_eval_led_init(LED3);
    rcu_config();
    gpio_config();
    i2c_config();
    i2c_nvic_config();

    for(i = 0; i < 16; i++) {
        i2c_buffer_transmitter[i] = i + 0x80;
    }
    /* initialize i2c_txbuffer, i2c_rxbuffer, I2C_nBytes and status */
    i2c_txbuffer = i2c_buffer_transmitter;
    i2c_rxbuffer = i2c_buffer_receiver;
    I2C_nBytes = 16;
    status = ERROR;

    /* enable the I2C0 interrupt */
    i2c_interrupt_enable(I2C0, I2C_INT_ERR);
    i2c_interrupt_enable(I2C0, I2C_INT_BUF);
    i2c_interrupt_enable(I2C0, I2C_INT_EV);
    /* enable the I2C1 interrupt */
    i2c_interrupt_enable(I2C1, I2C_INT_ERR);
    i2c_interrupt_enable(I2C1, I2C_INT_BUF);
    i2c_interrupt_enable(I2C1, I2C_INT_EV);

    if(2 == I2C_nBytes) {
        /* send ACK for the next byte */
        i2c_ackpos_config(I2C0, I2C_ACKPOS_NEXT);
    }
    /* the master waits until the I2C bus is idle */
    while(i2c_flag_get(I2C0, I2C_FLAG_I2CBSY));
    /* the master sends a start condition to I2C bus */
    i2c_start_on_bus(I2C0);

    while(I2C_nBytes > 0);
    while(SUCCESS != status);
    /* if the transfer is successfully completed, LED2 and LED3 is on */
    state = memory_compare(i2c_buffer_transmitter, i2c_buffer_receiver, 16);
    if(SUCCESS == state) {
        /* if success, LED2 and LED3 are on */
        gd_eval_led_on(LED2);
        gd_eval_led_on(LED3);
    } else {
        /* if failed, LED2 and LED3 are off */
        gd_eval_led_off(LED2);
        gd_eval_led_off(LED3);
    }
    while(1)
    {}
}

void rcu_config(void)
{
    /* enable GPIOB clock */
    rcu_periph_clock_enable(RCU_GPIOB);
    /* enable I2C1 clock */
    rcu_periph_clock_enable(RCU_I2C1);
    /* enable I2C0 clock */
    rcu_periph_clock_enable(RCU_I2C0);
}

void gpio_config(void)
{
    /* connect PB6 to I2C0_SCL */
    /* connect PB7 to I2C0_SDA */
    /* connect PB10 to I2C1_SCL */
    /* connect PB11 to I2C1_SDA */
    gpio_init(GPIOB, GPIO_MODE_AF_OD, GPIO_OSPEED_50MHZ, GPIO_PIN_6 | GPIO_PIN_7 | GPIO_PIN_10 | GPIO_PIN_11);
}

void i2c_config(void)
{
    /* configure I2C clock */
    i2c_clock_config(I2C0, 100000, I2C_DTCY_2);
    /* configure I2C address */
    i2c_mode_addr_config(I2C0, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, I2C0_SLAVE_ADDRESS7);
    /* enable I2C0 */
    i2c_enable(I2C0);
    /* enable acknowledge */
    i2c_ack_config(I2C0, I2C_ACK_ENABLE);
    i2c_clock_config(I2C1, 100000, I2C_DTCY_2);
    /* I2C address configure */
    i2c_mode_addr_config(I2C1, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, I2C1_SLAVE_ADDRESS7);
    /* enable I2C1 */
    i2c_enable(I2C1);
    /* enable acknowledge */
    i2c_ack_config(I2C1, I2C_ACK_ENABLE);
}

void i2c_nvic_config(void)
{
    nvic_priority_group_set(NVIC_PRIGROUP_PRE1_SUB3);
    nvic_irq_enable(I2C0_EV_IRQn, 0, 3);
    nvic_irq_enable(I2C1_EV_IRQn, 0, 4);
    nvic_irq_enable(I2C0_ER_IRQn, 0, 2);
    nvic_irq_enable(I2C1_ER_IRQn, 0, 1);
}

代码讲解

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

I2C 配置：设置通信速率（标准 100K / 快速 400K / 快速+ 1M）、从机地址、时钟拉伸。

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

实验现象

主机和从机完成数据收发
校验通过 LED 指示成功

注意事项

I2C 总线需要上拉电阻（一般 4.7K）
从机地址要与设备手册一致（注意 7 位/8 位地址的区别）
写 EEPROM 后需要等待 5ms 以上再读

GD32 PMU — 待机 RTC 唤醒

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

PMU — 待机 RTC 唤醒

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

功能简介

本示例演示 PMU 的基本用法。

完整代码

#include "gd32f30x.h"
#include "gd32f307c_eval.h"
#include "systick.h"
#include "main.h"

void led_config(void);
void rtc_configuration(void);

/* software delay to prevent the impact of Vcore fluctuations.
   It is strongly recommended to include it to avoid issues caused by self-removal. */
static void _soft_delay_(uint32_t time)
{
    __IO uint32_t i;
    for(i=0; i<time*10; i++){
    }
}

int main(void)
{
    systick_config();
    /* LED configuration and turn on all LEDs */
    led_config();
    gd_eval_led_on(LED2);
    gd_eval_led_on(LED3);
    gd_eval_led_on(LED4);
    gd_eval_led_on(LED5);
    /* delay 2s */
    delay_1ms(2000);
    /* enable PMU clock */
    rcu_periph_clock_enable(RCU_PMU);
    /* configure RTC */
    rtc_configuration();

    /* The following is to prevent Vcore fluctuations caused by frequency switching. 
       It is strongly recommended to include it to avoid issues caused by self-removal. */
    _soft_delay_(0x50);
    rcu_ahb_clock_config(RCU_AHB_CKSYS_DIV2);
    _soft_delay_(0x50);
    rcu_ahb_clock_config(RCU_AHB_CKSYS_DIV4);
    _soft_delay_(0x50);
    rcu_ahb_clock_config(RCU_AHB_CKSYS_DIV8);
    _soft_delay_(0x50);
    rcu_ahb_clock_config(RCU_AHB_CKSYS_DIV16);
    _soft_delay_(0x50);
    rcu_system_clock_source_config(RCU_CKSYSSRC_IRC8M);
    _soft_delay_(200);
    rcu_ahb_clock_config(RCU_AHB_CKSYS_DIV1);

    /* PMU enters standby mode */
    pmu_to_standbymode();

    while(1) {
    }
}

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

代码讲解

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

GD32 PMU — 待机 WKUP 唤醒

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

PMU — 待机 WKUP 唤醒

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

功能简介

本示例演示 PMU 的基本用法。

完整代码

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

void led_config(void);

/* software delay to prevent the impact of Vcore fluctuations.
   It is strongly recommended to include it to avoid issues caused by self-removal. */
static void _soft_delay_(uint32_t time)
{
    __IO uint32_t i;
    for(i=0; i<time*10; i++){
    }
}

int main(void)
{
    /* enable clock */
    rcu_periph_clock_enable(RCU_PMU);
    /* LED configuration and turn on all LEDs */
    led_config();
    gd_eval_led_on(LED2);
    gd_eval_led_on(LED4);
    gd_eval_led_on(LED3);
    gd_eval_led_on(LED5);
    /* tamper key configuration */
    gd_eval_key_init(KEY_TAMPER, KEY_MODE_GPIO);
    /* enable wakeup pin */
    pmu_wakeup_pin_enable();
    /* press tamper key to enter standby mode and use wakeup key to wakeup mcu */
    while(1) {
        if(RESET == gpio_input_bit_get(TAMPER_KEY_GPIO_PORT, TAMPER_KEY_PIN)) {
            /* The following is to prevent Vcore fluctuations caused by frequency switching. 
               It is strongly recommended to include it to avoid issues caused by self-removal. */
            _soft_delay_(0x50);
            rcu_ahb_clock_config(RCU_AHB_CKSYS_DIV2);
            _soft_delay_(0x50);
            rcu_ahb_clock_config(RCU_AHB_CKSYS_DIV4);
            _soft_delay_(0x50);
            rcu_ahb_clock_config(RCU_AHB_CKSYS_DIV8);
            _soft_delay_(0x50);
            rcu_ahb_clock_config(RCU_AHB_CKSYS_DIV16);
            _soft_delay_(0x50);
            rcu_system_clock_source_config(RCU_CKSYSSRC_IRC8M);
            _soft_delay_(200);
            rcu_ahb_clock_config(RCU_AHB_CKSYS_DIV1);

            pmu_to_standbymode();
        }
    }
}

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

代码讲解

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

GD32 PMU — 低电压检测

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

PMU — 低电压检测

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

功能简介

本示例演示 PMU 的基本用法。

完整代码

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

int main(void)
{
    /* NVIC configuration */
    nvic_priority_group_set(NVIC_PRIGROUP_PRE0_SUB4);
    nvic_irq_enable(LVD_IRQn,0,0);
    /* enable clock */
    rcu_periph_clock_enable(RCU_PMU);
    /* initialize LED2 */
    gd_eval_led_init(LED2);
    /* turn on LED2*/
    gd_eval_led_on(LED2);
    /* EXTI_16 configuration */
    exti_init(EXTI_16, EXTI_INTERRUPT, EXTI_TRIG_BOTH);
    /* configure the LVD threshold to 2.9v */
    pmu_lvd_select(PMU_LVDT_7);
    /* enable lvd */
    pmu_lvd_enable();

    while(1){
    }
}

代码讲解

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

GD32 PMU — 深度睡眠 EXTI 唤醒

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

PMU — 深度睡眠 EXTI 唤醒

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

功能简介

本示例演示 PMU 的基本用法。

完整代码

#include "gd32f30x.h"
#include "gd32f307c_eval.h"
#include "systick.h"
#include "main.h"

void led_config(void);

/* software delay to prevent the impact of Vcore fluctuations.
   It is strongly recommended to include it to avoid issues caused by self-removal. */
static void _soft_delay_(uint32_t time)
{
    __IO uint32_t i;
    for(i=0; i<time*10; i++){
    }
}

int main(void)
{
    /* systick configuration */
    systick_config();
    /* LED configuration */
    led_config();
    /* enable clock */
    rcu_periph_clock_enable(RCU_PMU);
    /* wakeup key configuration */
    gd_eval_key_init(KEY_WAKEUP, KEY_MODE_GPIO);
    /* tamper key EXTI configuration */
    gd_eval_key_init(KEY_TAMPER, KEY_MODE_EXTI);
    /* press wakeup key to enter deepsleep mode and use tamper key to generate a exti interrupt to wakeup mcu */
    while(1){
        if(RESET == gpio_input_bit_get(WAKEUP_KEY_GPIO_PORT, WAKEUP_KEY_PIN)){
            /* The following is to prevent Vcore fluctuations caused by frequency switching. 
               It is strongly recommended to include it to avoid issues caused by self-removal. */
            _soft_delay_(0x50);
            rcu_ahb_clock_config(RCU_AHB_CKSYS_DIV2);
            _soft_delay_(0x50);
            rcu_ahb_clock_config(RCU_AHB_CKSYS_DIV4);
            _soft_delay_(0x50);
            rcu_ahb_clock_config(RCU_AHB_CKSYS_DIV8);
            _soft_delay_(0x50);
            rcu_ahb_clock_config(RCU_AHB_CKSYS_DIV16);
            _soft_delay_(0x50);
            rcu_system_clock_source_config(RCU_CKSYSSRC_IRC8M);
            _soft_delay_(200);
            rcu_ahb_clock_config(RCU_AHB_CKSYS_DIV1);

            pmu_to_deepsleepmode(PMU_LDO_LOWPOWER, PMU_LOWDRIVER_DISABLE, WFI_CMD);
        }
    }
}

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

代码讲解

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

GD32 PMU — 深度睡眠 RTC 唤醒

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

PMU — 深度睡眠 RTC 唤醒

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

功能简介

本示例演示 PMU 的基本用法。

完整代码

#include "gd32f30x.h"
#include "gd32f307c_eval.h"
#include "systick.h"
#include "main.h"

void led_config(void);
void nvic_configuration(void);
void rtc_configuration(void);
void fwdgt_configuration(void);

/* software delay to prevent the impact of Vcore fluctuations.
   It is strongly recommended to include it to avoid issues caused by self-removal. */
static void _soft_delay_(uint32_t time)
{
    __IO uint32_t i;
    for(i=0; i<time*10; i++){
    }
}

int main(void)
{
    /* nvic configuration */
    nvic_configuration();
    /* LED configuration */
    led_config();
    /* systick configuration */
    systick_config();
    gd_eval_led_on(LED5);
    delay_1ms(2000U);
    gd_eval_led_off(LED5);
    /* RTC configuration */
    rtc_configuration();
    /* FWDGT configuration */
    fwdgt_configuration();

    while(1){
        delay_1ms(50U);
        /* The following is to prevent Vcore fluctuations caused by frequency switching. 
           It is strongly recommended to include it to avoid issues caused by self-removal. */
        _soft_delay_(0x50);
        rcu_ahb_clock_config(RCU_AHB_CKSYS_DIV2);
        _soft_delay_(0x50);
        rcu_ahb_clock_config(RCU_AHB_CKSYS_DIV4);
        _soft_delay_(0x50);
        rcu_ahb_clock_config(RCU_AHB_CKSYS_DIV8);
        _soft_delay_(0x50);
        rcu_ahb_clock_config(RCU_AHB_CKSYS_DIV16);
        _soft_delay_(0x50);
        rcu_system_clock_source_config(RCU_CKSYSSRC_IRC8M);
        _soft_delay_(200);
        rcu_ahb_clock_config(RCU_AHB_CKSYS_DIV1);

        /* PMU enters deepsleep mode */
        pmu_to_deepsleepmode(PMU_LDO_LOWPOWER, PMU_LOWDRIVER_DISABLE, WFI_CMD);
        gd_eval_led_toggle(LED2);
    }
}

void led_config(void)
{
    gd_eval_led_init(LED2);
    gd_eval_led_init(LED5);
}

代码讲解

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

GD32 RCU — 复位源检测

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

RCU — 复位源检测

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

功能简介

本示例演示 RCU 的基本用法。

完整代码

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

代码讲解

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

GD32 RCU — 时钟输出引脚

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

RCU — 时钟输出引脚

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

功能简介

本示例演示 RCU 的基本用法。

完整代码

#include "gd32f30x.h"
#include "gd32f307c_eval.h"
#include <stdio.h>
typedef enum {

void all_led_init(void);
void all_led_off(void);
void clock_output_select(uint8_t seq);
void clock_output_config(void);

extern uint8_t g_button_press_flag;

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    uint8_t func_seq = 0;

    /* initialize the USART */
    gd_eval_com_init(EVAL_COM0);

    printf("\r\n /=========== Gigadevice Clock output Demo ===========/ \r\n");
    printf("press tamper key to select clock output source \r\n");

    /* initialize the LEDs */
    all_led_init();
    /* initialize the clock output */
    clock_output_config();
    /* initialize the tamper key */
    gd_eval_key_init(KEY_TAMPER, KEY_MODE_EXTI);

    while(1) {
        if(1 == g_button_press_flag) {
            /* if the button is pressed */
            g_button_press_flag = 0;
            /* control the led */
            all_led_off();
            gd_eval_led_on((led_typedef_enum)func_seq);
            /* select the clock output mode */
            clock_output_select(func_seq);
            g_button_press_flag = 0;

            func_seq++;
            func_seq %= 3;
        }
    }
}

void clock_output_config(void)
{
    /* peripheral clock enable */
    rcu_periph_clock_enable(RCU_GPIOA);
    rcu_periph_clock_enable(RCU_GPIOC);

    rcu_osci_on(RCU_IRC8M);
    if(ERROR == rcu_osci_stab_wait(RCU_IRC8M)) {
        printf("RCU_IRC8M rcu_osci_stab_wait timeout! \r\n");
        while(1);
    }

    /* configure clock output pin */
    gpio_init(GPIOA, GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_8);
}

void all_led_init(void)
{
    gd_eval_led_init(LED2);
    gd_eval_led_init(LED3);
    gd_eval_led_init(LED4);
}

代码讲解

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

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

GD32 RCU — 系统时钟切换

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

RCU — 系统时钟切换

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

功能简介

本示例演示 RCU 的基本用法。

完整代码

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

int main(void)
{
    gd_eval_com_init(EVAL_COM0);
    printf("\r\nCK_SYS switch test demo\r\n");

    /* disable the USART */
    usart_disable(EVAL_COM0);

    /* switch system clock to 36MHz by HXTAL */
    switch_system_clock_to_36m_hxtal();
    gd_eval_com_init(EVAL_COM0);

    /* print out the clock frequency of system */
    printf("\r\nCK_SYS is %d", rcu_clock_freq_get(CK_SYS));
    _delay(1000);

    /* switch system clock to 72MHz by IRC8M */
    switch_system_clock_to_72m_irc8m();
    gd_eval_com_init(EVAL_COM0);

    /* print out the clock frequency of system */
    printf("\r\nCK_SYS is %d", rcu_clock_freq_get(CK_SYS));
    while(1){
    }
}

代码讲解

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

GD32 RTC — 日历演示

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

RTC — 日历演示

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

功能简介

本示例演示 RTC 日历功能。RTC 可以提供年月日时分秒的实时时钟，即使 MCU 复位也不影响时间（只要有电池供电）。

完整代码

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

int main(void)
{
    /* COM0 config */
    gd_eval_com_init(EVAL_COM0);

    /* NVIC config */
    nvic_configuration();

    /* enable PMU and BKPI clocks */
    rcu_periph_clock_enable(RCU_BKPI);
    rcu_periph_clock_enable(RCU_PMU);

    /* allow access to BKP domain */
    pmu_backup_write_enable();
    if(RESET != (RCU_BDCTL & RCU_BDCTL_BKPRST)) {
        rcu_bkp_reset_disable();
    }

    printf( "\r\n This is a RTC demo...... \r\n" );

    /* get RTC clock entry selection */
    RTCSRC_FLAG = GET_BITS(RCU_BDCTL, 8, 9);

    if ((0xA5A5 != bkp_read_data(BKP_DATA_0)) || (0x00 == RTCSRC_FLAG)){
        /* backup data register value is not correct or not yet programmed
        or RTC clock source is not configured (when the first time the program 
        is executed or data in RCU_BDCTL is lost due to Vbat feeding) */
        printf("\r\nThis is a RTC demo!\r\n");
        printf("\r\n\n RTC not yet configured....");

        /* RTC configuration */
        rtc_configuration();

        printf("\r\n RTC configured....");

        /* adjust time by values entred by the user on the hyperterminal */
        time_adjust();

        bkp_write_data(BKP_DATA_0, 0xA5A5);
    }else{
        /* check if the power on reset flag is set */
        if (rcu_flag_get(RCU_FLAG_PORRST) != RESET){
            printf("\r\n\n Power On Reset occurred....");
        }else if (rcu_flag_get(RCU_FLAG_SWRST) != RESET){
            /* check if the pin reset flag is set */
            printf("\r\n\n External Reset occurred....");
        }

        /* allow access to BKP domain */
        rcu_periph_clock_enable(RCU_PMU);
        pmu_backup_write_enable();

        printf("\r\n No need to configure RTC....");
        /* wait for RTC registers synchronization */
        rtc_register_sync_wait();

        /* enable the RTC second */
        rtc_interrupt_enable(RTC_INT_SECOND);

        /* wait until last write operation on RTC registers has finished */
        rtc_lwoff_wait();
    }

#ifdef RTCCLOCKOUTPUT_ENABLE
    /* enable PMU and BKPI clocks */
    rcu_periph_clock_enable(RCU_BKPI);
    rcu_periph_clock_enable(RCU_PMU);
    /* allow access to BKP domain */
    pmu_backup_write_enable();

    /* disable the tamper pin */
    bkp_tamper_detection_disable();

    /* enable RTC clock output on tamper Pin */
    bkp_rtc_calibration_output_enable();
#endif

    /* clear reset flags */
    rcu_all_reset_flag_clear();

    /* display time in infinite loop */
    time_show();

    while (1){
    }
}

代码讲解

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

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

校准：ADC 使用前必须校准，消除工艺偏差。校准期间不要操作 ADC。

GD32 SDIO — SD 卡读写

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

SDIO — SD 卡读写

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

功能简介

本示例演示 SD 卡读写操作。通过 SDIO 或 SPI 接口访问 SD 卡，实现大容量数据存储。配合 FatFs 文件系统可以读写文件。

完整代码


void nvic_config(void);
sd_error_enum sd_io_init(void);
void card_info_get(void);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    sd_error_enum sd_error;
    uint16_t i = 5;
#ifdef DATA_PRINT
    uint8_t *pdata;
#endif /* DATA_PRINT */
    
    /* configure the NVIC, USART and LED */
    nvic_config();
    gd_eval_com_init(EVAL_COM1);
    gd_eval_led_init(LED2);
    gd_eval_led_init(LED3);
    gd_eval_led_init(LED4);
    gd_eval_led_init(LED5);
    
    /* turn off all the LEDs */
    gd_eval_led_off(LED2);
    gd_eval_led_off(LED3);
    gd_eval_led_off(LED4);
    gd_eval_led_off(LED5);
    
    /* initialize the card */
    do{
        sd_error = sd_io_init();
    }while((SD_OK != sd_error) && (--i));
    
    if(i){
        printf("\r\n Card init success!\r\n");
    }else{
        printf("\r\n Card init failed!\r\n");
        /* turn on LED2, LED4 and turn off LED3, LED5 */
        gd_eval_led_on(LED2);
        gd_eval_led_on(LED4);
        gd_eval_led_off(LED3);
        gd_eval_led_off(LED5);
        while (1){
        }
    }
    
    /* get the information of the card and print it out by USART */
    card_info_get();
    
    /* init the write buffer */
    for(i=0; i<512; i++){
        buf_write[i] = i;
    }
    
    printf("\r\n\r\n Card test:");
    
    /* single block operation test */
    sd_error = sd_block_write(buf_write, 100*512, 512);
    if(SD_OK != sd_error){
        printf("\r\n Block write fail!");
        /* turn on LED2, LED4 and turn off LED3, LED5 */
        gd_eval_led_on(LED2);
        gd_eval_led_on(LED4);
        gd_eval_led_off(LED3);
        gd_eval_led_off(LED5);
        while (1){
        }
    }else{
        printf("\r\n Block write success!");
    }
    sd_error = sd_block_read(buf_read, 100*512, 512);
    if(SD_OK != sd_error){
        printf("\r\n Block read fail!");
        /* turn on LED2, LED4 and turn off LED3, LED5 */
        gd_eval_led_on(LED2);
        gd_eval_led_on(LED4);
        gd_eval_led_off(LED3);
        gd_eval_led_off(LED5);
        while (1){
        }
    }else{
        printf("\r\n Block read success!");
#ifdef DATA_PRINT
        pdata = (uint8_t *)buf_read;
        /* print data by USART */
        printf("\r\n");
        for(i = 0; i < 128; i++){
            printf(" %3d %3d %3d %3d ", *pdata, *(pdata+1), *(pdata+2), *(pdata+3));
            pdata += 4;
            if(0 == (i + 1) % 4){
                printf("\r\n");
            }
        }
#endif /* DATA_PRINT */
    }
    
    /* lock and unlock operation test */
    if(SD_CCC_LOCK_CARD & sd_cardinfo.card_csd.ccc){
        /* lock the card */
        sd_error = sd_lock_unlock(SD_LOCK);
        if(SD_OK != sd_error){
            printf("\r\n Lock failed!");
            /* turn on LED2, LED4 and turn off LED3, LED5 */
            gd_eval_led_on(LED2);
            gd_eval_led_on(LED4);
            gd_eval_led_off(LED3);
            gd_eval_led_off(LED5);
            while (1){
            }
        }else{
            printf("\r\n The card is locked!");
        }
        sd_error = sd_erase(100*512, 101*512);
        if(SD_OK != sd_error){
            printf("\r\n Erase failed!");
        }else{
            printf("\r\n Erase success!");
        }
        
        /* unlock the card */
        sd_error = sd_lock_unlock(SD_UNLOCK);
        if(SD_OK != sd_error){
            printf("\r\n Unlock failed!");
            /* turn on LED2, LED4 and turn off LED3, LED5 */
            gd_eval_led_on(LED2);
            gd_eval_led_on(LED4);
            gd_eval_led_off(LED3);
            gd_eval_led_off(LED5);
            while (1){
            }
        }else{
            printf("\r\n The card is unlocked!");
        }
        sd_error = sd_erase(100*512, 101*512);
        if(SD_OK != sd_error){
            printf("\r\n Erase failed!");
        }else{
            printf("\r\n Erase success!");
        }
        
        sd_error = sd_block_read(buf_read, 100*512, 512);
        if(SD_OK != sd_error){
            printf("\r\n Block read fail!");
            /* turn on LED2, LED4 and turn off LED3, LED5 */
            gd_eval_led_on(LED2);
            gd_eval_led_on(LED4);
            gd_eval_led_off(LED3);
            gd_eval_led_off(LED5);
            while (1){
            }
        }else{
            printf("\r\n Block read success!");
#ifdef DATA_PRINT
        pdata = (uint8_t *)buf_read;
        /* print data by USART */
        printf("\r\n");
        for(i = 0; i < 128; i++){
            printf(" %3d %3d %3d %3d ", *pdata, *(pdata+1), *(pdata+2), *(pdata+3));
            pdata += 4;
            if(0 == (i + 1) % 4){
                printf("\r\n");
            }
        }
#endif /* DATA_PRINT */
        }
    }
    
    /* multiple blocks operation test */
    sd_error = sd_multiblocks_write(buf_write, 200*512, 512, 3);
    if(SD_OK != sd_error){
        printf("\r\n Multiple block write fail!");
        /* turn on LED2, LED4 and turn off LED3, LED5 */
        gd_eval_led_on(LED2);
        gd_eval_led_on(LED4);
        gd_eval_led_off(LED3);
        gd_eval_led_off(LED5);
        while (1){
        }
    }else{
        printf("\r\n Multiple block write success!");
    }
    sd_error = sd_multiblocks_read(buf_read, 200*512, 512, 3);
    if(SD_OK != sd_error){
        printf("\r\n Multiple block read fail!");
        /* turn on LED2, LED4 and turn off LED3, LED5 */
        gd_eval_led_on(LED2);
        gd_eval_led_on(LED4);
        gd_eval_led_off(LED3);
        gd_eval_led_off(LED5);
        while (1){
        }
    }else{
        printf("\r\n Multiple block read success!");
#ifdef DATA_PRINT
        pdata = (uint8_t *)buf_read;
        /* print data by USART */
        printf("\r\n");
        for(i = 0; i < 512; i++){
            printf(" %3d %3d %3d %3d ", *pdata, *(pdata+1), *(pdata+2), *(pdata+3));
            pdata += 4;
            if(0 == (i + 1) % 4){
                printf("\r\n");
            }
        }
#endif /* DATA_PRINT */
    }
    
    /* turn on all the LEDs */
    gd_eval_led_on(LED2);
    gd_eval_led_on(LED3);
    gd_eval_led_on(LED4);
    gd_eval_led_on(LED5);
    while (1){
    }
}

void nvic_config(void)
{
    nvic_priority_group_set(NVIC_PRIGROUP_PRE1_SUB3);
    nvic_irq_enable(SDIO_IRQn, 0, 0);
}

int main(void)
{
    while (1){
    }
}

代码讲解

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

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

GD32 SPI — I2S 主发从收 DMA

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

SPI — I2S 主发从收 DMA

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

功能简介

本示例演示 SPI 总线通信。SPI 是高速同步串行接口，常用于连接 Flash、LCD、传感器等外设。

硬件准备

需要主机和从机两块板子，或使用回环连接（MOSI→MISO）

完整代码

#include "gd32f30x.h"
#include "gd32f307c_eval.h"
#define arraysize         10

void rcu_config(void);
void gpio_config(void);
void dma_config(void);
void spi_config(void);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    /* init led2 */
    gd_eval_led_init(LED2);

    /* peripheral clock enable */
    rcu_config();
    /* GPIO config */
    gpio_config();
    /* DMA config */
    dma_config();
    /* SPI config */
    spi_config();

    /* SPI enable */
    i2s_enable(SPI2);
    i2s_enable(SPI1);

    /* DMA channel enable */
    dma_channel_enable(DMA0,DMA_CH4);
    dma_channel_enable(DMA1,DMA_CH0);

    /* SPI DMA enable */
    spi_dma_enable(SPI2, SPI_DMA_RECEIVE);
    spi_dma_enable(SPI1, SPI_DMA_TRANSMIT);

    /* wait DMA transmit complete */
    while(!dma_flag_get(DMA0, DMA_CH4, DMA_INTF_FTFIF));
    while(!dma_flag_get(DMA1, DMA_CH0, DMA_INTF_FTFIF));

    /* compare receive data with send data */
    if(memory_compare(spi2_receive_array, spi1_send_array, arraysize))
        gd_eval_led_on(LED2);
    else
        gd_eval_led_off(LED2);

    while(1);
}

void rcu_config(void)
{
#ifdef GD32F30X_CL
    rcu_pll2_config(RCU_PLL2_MUL8);
    rcu_osci_on(RCU_PLL2_CK);
    while((RCU_CTL & RCU_CTL_PLL2STB) == 0)
    {
    }
    rcu_i2s1_clock_config(RCU_I2S1SRC_CKPLL2_MUL2);
    rcu_i2s2_clock_config(RCU_I2S2SRC_CKPLL2_MUL2);
#endif

    rcu_periph_clock_enable(RCU_SPI1);
    rcu_periph_clock_enable(RCU_SPI2);
    rcu_periph_clock_enable(RCU_GPIOA);
    rcu_periph_clock_enable(RCU_GPIOB);
    rcu_periph_clock_enable(RCU_DMA0);
    rcu_periph_clock_enable(RCU_DMA1);
}

void gpio_config(void)
{
    /* I2S1 GPIO config: I2S1_WS/PB12, I2S1_CK/PB13, I2S_SD/PB15 */
    gpio_init(GPIOB, GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_12 | GPIO_PIN_13 |GPIO_PIN_15);

    /* I2S2 GPIO config: I2S2_WS/PA15, I2S2_CK/PB3, I2S2_SD/PB5 */
    gpio_init(GPIOB, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_3 | GPIO_PIN_5);
    gpio_init(GPIOA, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_15);
}

void dma_config(void)
{
    dma_parameter_struct dma_init_struct;
    
    /* SPI1 transmit dma config: DMA0,DMA_CH4  */
    dma_deinit(DMA0, DMA_CH4);
    dma_init_struct.periph_addr  = (uint32_t)&SPI_DATA(SPI1);
    dma_init_struct.memory_addr  = (uint32_t)spi1_send_array;
    dma_init_struct.direction    = DMA_MEMORY_TO_PERIPHERAL;
    dma_init_struct.memory_width = DMA_MEMORY_WIDTH_8BIT;
    dma_init_struct.periph_width = DMA_PERIPHERAL_WIDTH_8BIT;
    dma_init_struct.priority     = DMA_PRIORITY_LOW;
    dma_init_struct.number       = arraysize;
    dma_init_struct.periph_inc   = DMA_PERIPH_INCREASE_DISABLE;
    dma_init_struct.memory_inc   = DMA_MEMORY_INCREASE_ENABLE;
    dma_init(DMA0, DMA_CH4, &dma_init_struct);
    /* configure DMA mode */
    dma_circulation_disable(DMA0, DMA_CH4);
    dma_memory_to_memory_disable(DMA0, DMA_CH4);

    /* SPI2 receive dma config: DMA1-DMA_CH0 */
    dma_deinit(DMA1, DMA_CH0);
    dma_init_struct.periph_addr  = (uint32_t)&SPI_DATA(SPI2);
    dma_init_struct.memory_addr  = (uint32_t)spi2_receive_array;
    dma_init_struct.direction    = DMA_PERIPHERAL_TO_MEMORY;
    dma_init_struct.priority     = DMA_PRIORITY_HIGH;
    dma_init(DMA1, DMA_CH0, &dma_init_struct);
    /* configure DMA mode */
    dma_circulation_disable(DMA1, DMA_CH0);
    dma_memory_to_memory_disable(DMA1, DMA_CH0);
}

void spi_config(void)
{
    spi_i2s_deinit(SPI1);
    spi_i2s_deinit(SPI2);

    i2s_init(SPI1, I2S_MODE_MASTERTX, I2S_STD_PHILIPS, I2S_CKPL_LOW);
    i2s_psc_config(SPI1, I2S_AUDIOSAMPLE_11K, I2S_FRAMEFORMAT_DT16B_CH16B, I2S_MCKOUT_DISABLE);
    
    i2s_init(SPI2, I2S_MODE_SLAVERX, I2S_STD_PHILIPS, I2S_CKPL_LOW);
    i2s_psc_config(SPI2, I2S_AUDIOSAMPLE_11K, I2S_FRAMEFORMAT_DT16B_CH16B, I2S_MCKOUT_DISABLE);
}

代码讲解

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

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

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

实验现象

主机和从机互相交换数据
数据校验通过则 LED 指示成功

注意事项

CPOL 和 CPHA 必须主机从机一致
片选（CS）信号要手动拉低选中从机
时钟频率不能超过从设备的最大速率

GD32 SPI — SPI 主从 NSS 硬件模式

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

SPI — SPI 主从 NSS 硬件模式

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

功能简介

本示例演示 SPI 全双工通信。主机和从机可以同时收发数据，速度比 I2C 快得多。适合高速数据传输场景。

硬件准备

需要主机和从机两块板子，或使用回环连接（MOSI→MISO）

完整代码

#include "gd32f30x.h"
#include "gd32f307c_eval.h"
#define arraysize         10

void rcu_config(void);
void gpio_config(void);
void dma_config(void);
void spi_config(void);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    /* init led2 and led3 */
    gd_eval_led_init(LED2);
    gd_eval_led_init(LED3);

    /* peripheral clock enable */
    rcu_config();
    /* GPIO config */
    gpio_config();
    /* DMA config */
    dma_config();
    /* SPI config */
    spi_config();

    /* SPI NSSP mode enable */
    spi_nssp_mode_enable(SPI0);
    spi_nss_output_enable(SPI0);

    /* SPI enable */
    spi_enable(SPI2);
    spi_enable(SPI0);

    /* DMA channel enable */
    dma_channel_enable(DMA0,DMA_CH1);
    dma_channel_enable(DMA0,DMA_CH2);
    dma_channel_enable(DMA1,DMA_CH0);
    dma_channel_enable(DMA1,DMA_CH1);

    /* SPI DMA enable */
    spi_dma_enable(SPI2, SPI_DMA_TRANSMIT);
    spi_dma_enable(SPI2, SPI_DMA_RECEIVE);
    spi_dma_enable(SPI0, SPI_DMA_TRANSMIT);
    spi_dma_enable(SPI0, SPI_DMA_RECEIVE);

    /* wait dma transmit complete */
    while(!dma_flag_get(DMA0,DMA_CH2,DMA_FLAG_FTF));
    while(!dma_flag_get(DMA1,DMA_CH1,DMA_FLAG_FTF));
    while(!dma_flag_get(DMA1,DMA_CH0,DMA_FLAG_FTF));
    while(!dma_flag_get(DMA0,DMA_CH1,DMA_FLAG_FTF));

    /* compare receive data with send data */
    if(memory_compare(spi2_receive_array, spi0_send_array, arraysize))
        gd_eval_led_on(LED2);
    else
        gd_eval_led_off(LED2);
    if(memory_compare(spi0_receive_array, spi2_send_array, arraysize))
        gd_eval_led_on(LED3);
    else
        gd_eval_led_off(LED3);

    while(1);
}

void rcu_config(void)
{
    rcu_periph_clock_enable(RCU_GPIOA);
    rcu_periph_clock_enable(RCU_GPIOB);
    rcu_periph_clock_enable(RCU_GPIOC);
    rcu_periph_clock_enable(RCU_DMA0);
    rcu_periph_clock_enable(RCU_DMA1);
    rcu_periph_clock_enable(RCU_SPI0);
    rcu_periph_clock_enable(RCU_SPI2);
    rcu_periph_clock_enable(RCU_AF);
}

void gpio_config(void)
{
    /* JTAG-DP disabled and SW-DP enabled, so SPI0 can use PB3 and PB4 */
    gpio_pin_remap_config(GPIO_SWJ_SWDPENABLE_REMAP,ENABLE);

    gpio_pin_remap_config(GPIO_SPI0_REMAP, ENABLE);
    /* SPI0 GPIO config: NSS/PA15, SCK/PB3, MOSI/PB5 */
    gpio_init(GPIOA, GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_15);
    gpio_init(GPIOB, GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_3 | GPIO_PIN_5);
    /* SPI0 GPIO config: MISO/PB4 */
    gpio_init(GPIOB, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_4);
    
    gpio_pin_remap_config(GPIO_SPI2_REMAP, ENABLE);
    /* SPI2 GPIO config: NSS/PA4 */
    gpio_init(GPIOA, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_4);
    /* SPI2 GPIO config: SCK/PC10, MOSI/PC12 */
    gpio_init(GPIOC, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_10 |GPIO_PIN_12);
    /* SPI2 GPIO config: MISO/PC11 */
    gpio_init(GPIOC, GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_11);
}

void dma_config(void)
{
    dma_parameter_struct dma_init_struct;
    
    /* SPI0 transmit dma config:DMA0-DMA_CH2  */
    dma_deinit(DMA0, DMA_CH2);
    dma_init_struct.periph_addr  = (uint32_t)&SPI_DATA(SPI0);
    dma_init_struct.memory_addr  = (uint32_t)spi0_send_array;
    dma_init_struct.direction    = DMA_MEMORY_TO_PERIPHERAL;
    dma_init_struct.memory_width = DMA_MEMORY_WIDTH_8BIT;
    dma_init_struct.periph_width = DMA_PERIPHERAL_WIDTH_8BIT;
    dma_init_struct.priority     = DMA_PRIORITY_LOW;
    dma_init_struct.number       = arraysize;
    dma_init_struct.periph_inc   = DMA_PERIPH_INCREASE_DISABLE;
    dma_init_struct.memory_inc   = DMA_MEMORY_INCREASE_ENABLE;
    dma_init(DMA0, DMA_CH2, &dma_init_struct);
    /* configure DMA mode */
    dma_circulation_disable(DMA0, DMA_CH2);
    dma_memory_to_memory_disable(DMA0, DMA_CH2);

    /* SPI0 receive dma config:DMA0-DMA_CH1  */
    dma_deinit(DMA0, DMA_CH1);
    dma_init_struct.periph_addr  = (uint32_t)&SPI_DATA(SPI0);
    dma_init_struct.memory_addr  = (uint32_t)spi0_receive_array;
    dma_init_struct.direction    = DMA_PERIPHERAL_TO_MEMORY;
    dma_init_struct.priority     = DMA_PRIORITY_HIGH;
    dma_init(DMA0, DMA_CH1, &dma_init_struct);
    /* configure DMA mode */
    dma_circulation_disable(DMA0, DMA_CH1);
    dma_memory_to_memory_disable(DMA0, DMA_CH1);

    /* SPI2 transmit dma config:DMA1,DMA_CH1  */
    dma_deinit(DMA1, DMA_CH1);
    dma_init_struct.periph_addr  = (uint32_t)&SPI_DATA(SPI2);
    dma_init_struct.memory_addr  = (uint32_t)spi2_send_array;
    dma_init_struct.direction    = DMA_MEMORY_TO_PERIPHERAL;
    dma_init_struct.priority     = DMA_PRIORITY_MEDIUM;
    dma_init(DMA1, DMA_CH1, &dma_init_struct);
    /* configure DMA mode */
    dma_circulation_disable(DMA1, DMA_CH1);
    dma_memory_to_memory_disable(DMA1, DMA_CH1);

    /* SPI2 receive dma config:DMA1,DMA_CH0  */
    dma_deinit(DMA1, DMA_CH0);
    dma_init_struct.periph_addr  = (uint32_t)&SPI_DATA(SPI2);
    dma_init_struct.memory_addr  = (uint32_t)spi2_receive_array;
    dma_init_struct.direction    = DMA_PERIPHERAL_TO_MEMORY;
    dma_init_struct.priority     = DMA_PRIORITY_ULTRA_HIGH;
    dma_init(DMA1, DMA_CH0, &dma_init_struct);
    /* configure DMA mode */
    dma_circulation_disable(DMA1, DMA_CH0);
    dma_memory_to_memory_disable(DMA1, DMA_CH0);
}

void spi_config(void)
{
    spi_parameter_struct spi_init_struct;

    /* SPI0 parameter config */
    spi_init_struct.trans_mode           = SPI_TRANSMODE_FULLDUPLEX;
    spi_init_struct.device_mode          = SPI_MASTER;
    spi_init_struct.frame_size           = SPI_FRAMESIZE_8BIT;
    spi_init_struct.clock_polarity_phase = SPI_CK_PL_HIGH_PH_1EDGE;
    spi_init_struct.nss                  = SPI_NSS_HARD;
    spi_init_struct.prescale             = SPI_PSC_256;
    spi_init_struct.endian               = SPI_ENDIAN_MSB;
    spi_init(SPI0, &spi_init_struct);

    /* SPI2 parameter config */
    spi_init_struct.device_mode = SPI_SLAVE;
    spi_init_struct.nss         = SPI_NSS_HARD;
    spi_init(SPI2, &spi_init_struct);
}

代码讲解

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

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

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

实验现象

主机和从机互相交换数据
数据校验通过则 LED 指示成功

注意事项

CPOL 和 CPHA 必须主机从机一致
片选（CS）信号要手动拉低选中从机
时钟频率不能超过从设备的最大速率

GD32 SPI — SPI 主从 TI 模式

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

SPI — SPI 主从 TI 模式

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

功能简介

本示例演示 SPI 全双工通信。主机和从机可以同时收发数据，速度比 I2C 快得多。适合高速数据传输场景。

硬件准备

需要主机和从机两块板子，或使用回环连接（MOSI→MISO）

完整代码

#include "gd32f30x.h"
#include "gd32f307c_eval.h"
#define arraysize         10

void rcu_config(void);
void gpio_config(void);
void dma_config(void);
void spi_config(void);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    /* init led2 and led3 */
    gd_eval_led_init(LED2);
    gd_eval_led_init(LED3);

    /* peripheral clock enable */
    rcu_config();
    /* GPIO config */
    gpio_config();
    /* DMA config */
    dma_config();
    /* SPI config */
    spi_config();
    
    /* SPI ti mode enable */
    spi_ti_mode_enable(SPI2);
    spi_ti_mode_enable(SPI0);

    /* SPI enable */
    spi_enable(SPI2);
    spi_enable(SPI0);

    /* DMA channel enable */
    dma_channel_enable(DMA0, DMA_CH1);
    dma_channel_enable(DMA0, DMA_CH2);
    dma_channel_enable(DMA1, DMA_CH0);
    dma_channel_enable(DMA1, DMA_CH1);

    /* SPI DMA enable */
    spi_dma_enable(SPI2, SPI_DMA_TRANSMIT);
    spi_dma_enable(SPI2, SPI_DMA_RECEIVE);
    spi_dma_enable(SPI0, SPI_DMA_TRANSMIT);
    spi_dma_enable(SPI0, SPI_DMA_RECEIVE);

    /* wait dma transmit complete */
    while(!dma_flag_get(DMA0,DMA_CH2,DMA_INTF_FTFIF));
    while(!dma_flag_get(DMA1,DMA_CH1,DMA_INTF_FTFIF));
    while(!dma_flag_get(DMA1,DMA_CH0,DMA_INTF_FTFIF));
    while(!dma_flag_get(DMA0,DMA_CH1,DMA_INTF_FTFIF));

    /* compare receive data with send data */
    if(memory_compare(spi2_receive_array, spi0_send_array, arraysize))
        gd_eval_led_on(LED2);
    else
        gd_eval_led_off(LED2);
    if(memory_compare(spi0_receive_array, spi2_send_array, arraysize))
        gd_eval_led_on(LED3);
    else
        gd_eval_led_off(LED3);

    while(1);
}

void rcu_config(void)
{
    rcu_periph_clock_enable(RCU_GPIOA);
    rcu_periph_clock_enable(RCU_GPIOB);
    rcu_periph_clock_enable(RCU_GPIOC);
    rcu_periph_clock_enable(RCU_DMA0);
    rcu_periph_clock_enable(RCU_DMA1);
    rcu_periph_clock_enable(RCU_SPI0);
    rcu_periph_clock_enable(RCU_SPI2);
    rcu_periph_clock_enable(RCU_AF);
}

void gpio_config(void)
{
    /* JTAG-DP disabled and SW-DP enabled, so SPI0 can use PB3 and PB4 */
    gpio_pin_remap_config(GPIO_SWJ_SWDPENABLE_REMAP,ENABLE);

    gpio_pin_remap_config(GPIO_SPI0_REMAP, ENABLE);
    /* SPI0 GPIO config: NSS/PA15, SCK/PB3, MOSI/PB5 */
    gpio_init(GPIOA, GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_15);
    gpio_init(GPIOB, GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_3 | GPIO_PIN_5);
    /* SPI0 GPIO config: MISO/PB4 */
    gpio_init(GPIOB, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_4);
    
    gpio_pin_remap_config(GPIO_SPI2_REMAP, ENABLE);
    /* SPI2 GPIO config: NSS/PA4 */
    gpio_init(GPIOA, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_4);
    /* SPI2 GPIO config: SCK/PC10, MOSI/PC12 */
    gpio_init(GPIOC, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_10 |GPIO_PIN_12);
    /* SPI2 GPIO config: MISO/PC11 */
    gpio_init(GPIOC, GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_11);
}

void dma_config(void)
{
    dma_parameter_struct dma_init_struct;
    
    /* SPI0 transmit dma config:DMA0-DMA_CH2  */
    dma_deinit(DMA0, DMA_CH2);
    dma_init_struct.periph_addr  = (uint32_t)&SPI_DATA(SPI0);
    dma_init_struct.memory_addr  = (uint32_t)spi0_send_array;
    dma_init_struct.direction    = DMA_MEMORY_TO_PERIPHERAL;
    dma_init_struct.memory_width = DMA_MEMORY_WIDTH_8BIT;
    dma_init_struct.periph_width = DMA_PERIPHERAL_WIDTH_8BIT;
    dma_init_struct.priority     = DMA_PRIORITY_LOW;
    dma_init_struct.number       = arraysize;
    dma_init_struct.periph_inc   = DMA_PERIPH_INCREASE_DISABLE;
    dma_init_struct.memory_inc   = DMA_MEMORY_INCREASE_ENABLE;
    dma_init(DMA0, DMA_CH2, &dma_init_struct);
    /* configure DMA mode */
    dma_circulation_disable(DMA0, DMA_CH2);
    dma_memory_to_memory_disable(DMA0, DMA_CH2);

    /* SPI0 receive dma config:DMA0-DMA_CH1  */
    dma_deinit(DMA0, DMA_CH1);
    dma_init_struct.periph_addr  = (uint32_t)&SPI_DATA(SPI0);
    dma_init_struct.memory_addr  = (uint32_t)spi0_receive_array;
    dma_init_struct.direction    = DMA_PERIPHERAL_TO_MEMORY;
    dma_init_struct.priority     = DMA_PRIORITY_HIGH;
    dma_init(DMA0, DMA_CH1, &dma_init_struct);
    /* configure DMA mode */
    dma_circulation_disable(DMA0, DMA_CH1);
    dma_memory_to_memory_disable(DMA0, DMA_CH1);

    /* SPI2 transmit dma config:DMA1,DMA_CH1  */
    dma_deinit(DMA1, DMA_CH1);
    dma_init_struct.periph_addr  = (uint32_t)&SPI_DATA(SPI2);
    dma_init_struct.memory_addr  = (uint32_t)spi2_send_array;
    dma_init_struct.direction    = DMA_MEMORY_TO_PERIPHERAL;
    dma_init_struct.priority     = DMA_PRIORITY_MEDIUM;
    dma_init(DMA1, DMA_CH1, &dma_init_struct);
    /* configure DMA mode */
    dma_circulation_disable(DMA1, DMA_CH1);
    dma_memory_to_memory_disable(DMA1, DMA_CH1);

    /* SPI2 receive dma config:DMA1,DMA_CH0  */
    dma_deinit(DMA1, DMA_CH0);
    dma_init_struct.periph_addr  = (uint32_t)&SPI_DATA(SPI2);
    dma_init_struct.memory_addr  = (uint32_t)spi2_receive_array;
    dma_init_struct.direction    = DMA_PERIPHERAL_TO_MEMORY;
    dma_init_struct.priority     = DMA_PRIORITY_ULTRA_HIGH;
    dma_init(DMA1, DMA_CH0, &dma_init_struct);
    /* configure DMA mode */
    dma_circulation_disable(DMA1, DMA_CH0);
    dma_memory_to_memory_disable(DMA1, DMA_CH0);
}

void spi_config(void)
{
    spi_parameter_struct spi_init_struct;

    /* SPI0 parameter config */
    spi_init_struct.trans_mode           = SPI_TRANSMODE_FULLDUPLEX;
    spi_init_struct.device_mode          = SPI_MASTER;
    spi_init_struct.frame_size           = SPI_FRAMESIZE_8BIT;
    spi_init_struct.clock_polarity_phase = SPI_CK_PL_HIGH_PH_2EDGE;
    spi_init_struct.nss                  = SPI_NSS_HARD;
    spi_init_struct.prescale             = SPI_PSC_16;
    spi_init_struct.endian               = SPI_ENDIAN_MSB;
    spi_init(SPI0, &spi_init_struct);

    /* SPI2 parameter config */
    spi_init_struct.trans_mode  = SPI_TRANSMODE_FULLDUPLEX;
    spi_init_struct.device_mode = SPI_SLAVE;
    spi_init_struct.nss         = SPI_NSS_HARD;
    spi_init_struct.prescale    = SPI_PSC_16;
    spi_init(SPI2, &spi_init_struct);
}

代码讲解

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

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

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

实验现象

主机和从机互相交换数据
数据校验通过则 LED 指示成功

注意事项

CPOL 和 CPHA 必须主机从机一致
片选（CS）信号要手动拉低选中从机
时钟频率不能超过从设备的最大速率

GD32 SPI — SPI 主从单工 DMA

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

SPI — SPI 主从单工 DMA

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

功能简介

本示例演示 SPI 总线通信。SPI 是高速同步串行接口，常用于连接 Flash、LCD、传感器等外设。

硬件准备

需要主机和从机两块板子，或使用回环连接（MOSI→MISO）

完整代码

#include "gd32f30x.h"
#include "gd32f307c_eval.h"
#define SLVAE_TRAMSMIT_MASTER_RECEIVE
#define ARRAYSIZE                  10
#define SET_SPI0_NSS_HIGH          gpio_bit_set(GPIOA,GPIO_PIN_3);
#define SET_SPI0_NSS_LOW           gpio_bit_reset(GPIOA,GPIO_PIN_3);

void rcu_config(void);
void gpio_config(void);
void dma_config(void);
void spi_config(void);
ErrStatus memory_compare(uint8_t *src, uint8_t *dst, uint8_t length);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    /* initialize the LEDs */
    gd_eval_led_init(LED2);
    gd_eval_led_init(LED3);

    /* enable peripheral clock */
    rcu_config();
    /* configure GPIO */
    gpio_config();
    /* configure DMA */
    dma_config();
    /* configure SPI */
    spi_config();

    SET_SPI0_NSS_HIGH

#ifdef MASTER_TRAMSMIT_SLVAE_RECEIVE
    /* enable DMA channel */
    /* SPI0_Tx DMA channel */
    dma_channel_enable(DMA0, DMA_CH2);
    /* SPI2_Rx DMA channel */
    dma_channel_enable(DMA1, DMA_CH0);

    /* enable SPI DMA */
    spi_dma_enable(SPI2, SPI_DMA_RECEIVE);
    spi_dma_enable(SPI0, SPI_DMA_TRANSMIT);
#endif /* master send and slave receive */

#ifdef SLVAE_TRAMSMIT_MASTER_RECEIVE
    /* enable DMA channel */
    /* SPI0_Rx DMA channel */
    dma_channel_enable(DMA0, DMA_CH1);
    /* SPI2_Tx DMA channel */
    dma_channel_enable(DMA1, DMA_CH1);

    /* enable SPI DMA */
    spi_dma_enable(SPI2, SPI_DMA_TRANSMIT);
    spi_dma_enable(SPI0, SPI_DMA_RECEIVE);
#endif /* slave send and master receive */
    SET_SPI0_NSS_LOW

    /* enable SPI */
    spi_enable(SPI2);
    spi_enable(SPI0);

#ifdef MASTER_TRAMSMIT_SLVAE_RECEIVE
    /* wait DMA transmit completed */
    while(!dma_flag_get(DMA0, DMA_CH2, DMA_FLAG_FTF)) {
    }
    while(!dma_flag_get(DMA1, DMA_CH0, DMA_FLAG_FTF)) {
    }

    /* compare receive data with send data */
    if(ERROR != memory_compare(spi2_receive_array, spi0_send_array, ARRAYSIZE)) {
        gd_eval_led_on(LED2);
    } else {
        gd_eval_led_off(LED2);
    }
#endif /* master send and slave receive */

#ifdef SLVAE_TRAMSMIT_MASTER_RECEIVE
    /* wait DMA transmit complete */
    while(!dma_flag_get(DMA1, DMA_CH1, DMA_FLAG_FTF)) {
    }
    while(!dma_flag_get(DMA0, DMA_CH1, DMA_FLAG_FTF)) {
    }

    /* compare receive data with send data */
    if(ERROR != memory_compare(spi0_receive_array, spi2_send_array, ARRAYSIZE)) {
        gd_eval_led_on(LED3);
    } else {
        gd_eval_led_off(LED3);
    }
#endif /* slave send and master receive */

    SET_SPI0_NSS_HIGH

    /* disable SPI */
    spi_disable(SPI0);
    spi_disable(SPI2);

    while(1) {
    }
}

void rcu_config(void)
{
    rcu_periph_clock_enable(RCU_GPIOA);
    rcu_periph_clock_enable(RCU_GPIOC);
    rcu_periph_clock_enable(RCU_DMA0);
    rcu_periph_clock_enable(RCU_DMA1);
    rcu_periph_clock_enable(RCU_SPI0);
    rcu_periph_clock_enable(RCU_SPI2);
    rcu_periph_clock_enable(RCU_AF);
}

void gpio_config(void)
{
    /* SPI0 GPIO config: SCK/PA5, MISO/PA6, MOSI/PA7 */
    gpio_init(GPIOA, GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_5 | GPIO_PIN_7);
    gpio_init(GPIOA, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_6);
    /* PA3 as NSS */
    gpio_init(GPIOA, GPIO_MODE_OUT_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_3);

    gpio_pin_remap_config(GPIO_SPI2_REMAP, ENABLE);
    /* SPI2 GPIO config: NSS/PA4, SCK/PC10, MISO/PC11, MOSI/PC12 */
    gpio_init(GPIOC, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_10 | GPIO_PIN_12);
    gpio_init(GPIOC, GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_11);
    gpio_init(GPIOA, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_4);
}

void dma_config(void)
{
    dma_parameter_struct dma_init_struct;
    dma_struct_para_init(&dma_init_struct);

    /* configure SPI0 transmit DMA: DMA_CH2 */
    dma_deinit(DMA0, DMA_CH2);
    dma_init_struct.periph_addr  = (uint32_t)&SPI_DATA(SPI0);
    dma_init_struct.memory_addr  = (uint32_t)spi0_send_array;
    dma_init_struct.direction    = DMA_MEMORY_TO_PERIPHERAL;
    dma_init_struct.memory_width = DMA_MEMORY_WIDTH_8BIT;
    dma_init_struct.periph_width = DMA_PERIPHERAL_WIDTH_16BIT;
    dma_init_struct.priority     = DMA_PRIORITY_LOW;
    dma_init_struct.number       = ARRAYSIZE;
    dma_init_struct.periph_inc   = DMA_PERIPH_INCREASE_DISABLE;
    dma_init_struct.memory_inc   = DMA_MEMORY_INCREASE_ENABLE;
    dma_init(DMA0, DMA_CH2, &dma_init_struct);
    /* configure DMA mode */
    dma_circulation_disable(DMA0, DMA_CH2);
    dma_memory_to_memory_disable(DMA0, DMA_CH2);

    /* configure SPI0 receive DMA: DMA_CH1 */
    dma_deinit(DMA0, DMA_CH1);
    dma_init_struct.periph_addr  = (uint32_t)&SPI_DATA(SPI0);
    dma_init_struct.memory_addr  = (uint32_t)spi0_receive_array;
    dma_init_struct.direction    = DMA_PERIPHERAL_TO_MEMORY;
    dma_init_struct.priority     = DMA_PRIORITY_HIGH;
    dma_init(DMA0, DMA_CH1, &dma_init_struct);
    /* configure DMA mode */
    dma_circulation_disable(DMA0, DMA_CH1);
    dma_memory_to_memory_disable(DMA0, DMA_CH1);

    /* SPI2 transmit dma config:DMA1,DMA_CH1  */
    dma_deinit(DMA1, DMA_CH1);
    dma_init_struct.periph_addr  = (uint32_t)&SPI_DATA(SPI2);
    dma_init_struct.memory_addr  = (uint32_t)spi2_send_array;
    dma_init_struct.direction    = DMA_MEMORY_TO_PERIPHERAL;
    dma_init_struct.priority     = DMA_PRIORITY_MEDIUM;
    dma_init(DMA1, DMA_CH1, &dma_init_struct);
    /* configure DMA mode */
    dma_circulation_disable(DMA1, DMA_CH1);
    dma_memory_to_memory_disable(DMA1, DMA_CH1);

    /* SPI2 receive dma config:DMA1,DMA_CH0  */
    dma_deinit(DMA1, DMA_CH0);
    dma_init_struct.periph_addr  = (uint32_t)&SPI_DATA(SPI2);
    dma_init_struct.memory_addr  = (uint32_t)spi2_receive_array;
    dma_init_struct.direction    = DMA_PERIPHERAL_TO_MEMORY;
    dma_init_struct.priority     = DMA_PRIORITY_ULTRA_HIGH;
    dma_init(DMA1, DMA_CH0, &dma_init_struct);
    /* configure DMA mode */
    dma_circulation_disable(DMA1, DMA_CH0);
    dma_memory_to_memory_disable(DMA1, DMA_CH0);
}

void spi_config(void)
{
    spi_parameter_struct spi_init_struct;
    /* deinitialize SPI and the parameters */
    spi_i2s_deinit(SPI0);
    spi_i2s_deinit(SPI2);
    spi_struct_para_init(&spi_init_struct);

    /* configure SPI0 parameter */
#ifdef MASTER_TRAMSMIT_SLVAE_RECEIVE
    spi_init_struct.trans_mode           = SPI_TRANSMODE_FULLDUPLEX;
#endif /* master send and slave receive */
#ifdef SLVAE_TRAMSMIT_MASTER_RECEIVE
    spi_init_struct.trans_mode           = SPI_TRANSMODE_RECEIVEONLY;
#endif /* slave send and master receive */
    spi_init_struct.device_mode          = SPI_MASTER;
    spi_init_struct.frame_size           = SPI_FRAMESIZE_8BIT;
    spi_init_struct.clock_polarity_phase = SPI_CK_PL_HIGH_PH_2EDGE;
    spi_init_struct.nss                  = SPI_NSS_SOFT;
    spi_init_struct.prescale             = SPI_PSC_256;
    spi_init_struct.endian               = SPI_ENDIAN_MSB;
    spi_init(SPI0, &spi_init_struct);

    /* configure SPI2 parameter */
#ifdef MASTER_TRAMSMIT_SLVAE_RECEIVE
    spi_init_struct.trans_mode           = SPI_TRANSMODE_RECEIVEONLY;
#endif /* master send and slave receive */
#ifdef SLVAE_TRAMSMIT_MASTER_RECEIVE
    spi_init_struct.trans_mode           = SPI_TRANSMODE_FULLDUPLEX;
#endif /* slave send and master receive */
    spi_init_struct.device_mode          = SPI_SLAVE;
    spi_init(SPI2, &spi_init_struct);
}

代码讲解

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

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

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

实验现象

主机和从机互相交换数据
数据校验通过则 LED 指示成功

注意事项

CPOL 和 CPHA 必须主机从机一致
片选（CS）信号要手动拉低选中从机
时钟频率不能超过从设备的最大速率

GD32 SPI — SPI 主从全双工 DMA

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

SPI — SPI 主从全双工 DMA

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

功能简介

本示例演示 SPI 全双工通信。主机和从机可以同时收发数据，速度比 I2C 快得多。适合高速数据传输场景。

硬件准备

需要主机和从机两块板子，或使用回环连接（MOSI→MISO）

完整代码

#include "gd32f30x.h"
#include "gd32f307c_eval.h"
#define SPI_CRC_ENABLE             1
#define ARRAYSIZE                  10
#define SET_SPI0_NSS_HIGH          gpio_bit_set(GPIOA,GPIO_PIN_3);
#define SET_SPI0_NSS_LOW           gpio_bit_reset(GPIOA,GPIO_PIN_3);

void rcu_config(void);
void gpio_config(void);
void dma_config(void);
void spi_config(void);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    /* init led2 and led3 */
    gd_eval_led_init(LED2);
    gd_eval_led_init(LED3);

    /* peripheral clock enable */
    rcu_config();
    /* GPIO config */
    gpio_config();
    /* DMA config */
    dma_config();
    /* SPI config */
    spi_config();

    SET_SPI0_NSS_HIGH

    /* SPI enable */
    spi_enable(SPI2);
    spi_enable(SPI0);

    /* DMA channel enable */
    dma_channel_enable(DMA0, DMA_CH1);
    dma_channel_enable(DMA0, DMA_CH2);
    dma_channel_enable(DMA1, DMA_CH0);
    dma_channel_enable(DMA1, DMA_CH1);

    SET_SPI0_NSS_LOW

    /* SPI DMA enable */
    spi_dma_enable(SPI2, SPI_DMA_TRANSMIT);
    spi_dma_enable(SPI2, SPI_DMA_RECEIVE);
    spi_dma_enable(SPI0, SPI_DMA_TRANSMIT);
    spi_dma_enable(SPI0, SPI_DMA_RECEIVE);

    /* wait dma transmit complete */
    while(!dma_flag_get(DMA0,DMA_CH2, DMA_FLAG_FTF)) {
    }
    while(!dma_flag_get(DMA1,DMA_CH1, DMA_FLAG_FTF)) {
    }
    while(!dma_flag_get(DMA1,DMA_CH0, DMA_FLAG_FTF)) {
    }
    while(!dma_flag_get(DMA0,DMA_CH1, DMA_FLAG_FTF)) {
    }

    SET_SPI0_NSS_HIGH

#if SPI_CRC_ENABLE
    /* check the CRC error status  */
    if(SET != spi_i2s_flag_get(SPI0, SPI_FLAG_CRCERR)) {
        gd_eval_led_on(LED2);
    } else {
        gd_eval_led_off(LED2);
    }

    if(SET != spi_i2s_flag_get(SPI2, SPI_FLAG_CRCERR)) {
        gd_eval_led_on(LED3);
    } else {
        gd_eval_led_off(LED3);
    }
#else
    /* compare receive data with send data */
    if(memory_compare(spi2_receive_array, spi0_send_array, ARRAYSIZE))
        gd_eval_led_on(LED2);
    else
        gd_eval_led_off(LED2);
    if(memory_compare(spi0_receive_array, spi2_send_array, ARRAYSIZE))
        gd_eval_led_on(LED3);
    else
        gd_eval_led_off(LED3);
#endif /* enable CRC function */

    while(1);
}

void rcu_config(void)
{
    rcu_periph_clock_enable(RCU_GPIOA);
    rcu_periph_clock_enable(RCU_GPIOC);
    rcu_periph_clock_enable(RCU_DMA0);
    rcu_periph_clock_enable(RCU_DMA1);
    rcu_periph_clock_enable(RCU_SPI0);
    rcu_periph_clock_enable(RCU_SPI2);
    rcu_periph_clock_enable(RCU_AF);
}

void gpio_config(void)
{
    /* SPI0 GPIO config: SCK/PA5, MISO/PA6, MOSI/PA7 */
    gpio_init(GPIOA, GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_5 | GPIO_PIN_7);
    gpio_init(GPIOA, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_6);
    /* PA3 as NSS */
    gpio_init(GPIOA, GPIO_MODE_OUT_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_3);

    gpio_pin_remap_config(GPIO_SPI2_REMAP, ENABLE);
    /* SPI2 GPIO config: NSS/PA4, SCK/PC10, MISO/PC11, MOSI/PC12 */
    gpio_init(GPIOC, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_10 | GPIO_PIN_12);
    gpio_init(GPIOC, GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_11);
    gpio_init(GPIOA, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_4);
}

void dma_config(void)
{
    dma_parameter_struct dma_init_struct;
    
    /* SPI0 transmit dma config:DMA0-DMA_CH2  */
    dma_deinit(DMA0, DMA_CH2);
    dma_init_struct.periph_addr  = (uint32_t)&SPI_DATA(SPI0);
    dma_init_struct.memory_addr  = (uint32_t)spi0_send_array;
    dma_init_struct.direction    = DMA_MEMORY_TO_PERIPHERAL;
    dma_init_struct.memory_width = DMA_MEMORY_WIDTH_8BIT;
    dma_init_struct.periph_width = DMA_PERIPHERAL_WIDTH_8BIT;
    dma_init_struct.priority     = DMA_PRIORITY_LOW;
    dma_init_struct.number       = ARRAYSIZE;
    dma_init_struct.periph_inc   = DMA_PERIPH_INCREASE_DISABLE;
    dma_init_struct.memory_inc   = DMA_MEMORY_INCREASE_ENABLE;
    dma_init(DMA0, DMA_CH2, &dma_init_struct);
    /* configure DMA mode */
    dma_circulation_disable(DMA0, DMA_CH2);
    dma_memory_to_memory_disable(DMA0, DMA_CH2);

    /* SPI0 receive dma config:DMA0-DMA_CH1  */
    dma_deinit(DMA0, DMA_CH1);
    dma_init_struct.periph_addr  = (uint32_t)&SPI_DATA(SPI0);
    dma_init_struct.memory_addr  = (uint32_t)spi0_receive_array;
    dma_init_struct.direction    = DMA_PERIPHERAL_TO_MEMORY;
    dma_init_struct.priority     = DMA_PRIORITY_HIGH;
    dma_init(DMA0, DMA_CH1, &dma_init_struct);
    /* configure DMA mode */
    dma_circulation_disable(DMA0, DMA_CH1);
    dma_memory_to_memory_disable(DMA0, DMA_CH1);

    /* SPI2 transmit dma config:DMA1,DMA_CH1  */
    dma_deinit(DMA1, DMA_CH1);
    dma_init_struct.periph_addr  = (uint32_t)&SPI_DATA(SPI2);
    dma_init_struct.memory_addr  = (uint32_t)spi2_send_array;
    dma_init_struct.direction    = DMA_MEMORY_TO_PERIPHERAL;
    dma_init_struct.priority     = DMA_PRIORITY_MEDIUM;
    dma_init(DMA1, DMA_CH1, &dma_init_struct);
    /* configure DMA mode */
    dma_circulation_disable(DMA1, DMA_CH1);
    dma_memory_to_memory_disable(DMA1, DMA_CH1);

    /* SPI2 receive dma config:DMA1,DMA_CH0  */
    dma_deinit(DMA1, DMA_CH0);
    dma_init_struct.periph_addr  = (uint32_t)&SPI_DATA(SPI2);
    dma_init_struct.memory_addr  = (uint32_t)spi2_receive_array;
    dma_init_struct.direction    = DMA_PERIPHERAL_TO_MEMORY;
    dma_init_struct.priority     = DMA_PRIORITY_ULTRA_HIGH;

    dma_init(DMA1, DMA_CH0, &dma_init_struct);
    /* configure DMA mode */
    dma_circulation_disable(DMA1, DMA_CH0);
    dma_memory_to_memory_disable(DMA1, DMA_CH0);
}

void spi_config(void)
{
    spi_parameter_struct spi_init_struct;

    /* SPI0 parameter config */
    spi_init_struct.trans_mode           = SPI_TRANSMODE_FULLDUPLEX;
    spi_init_struct.device_mode          = SPI_MASTER;
    spi_init_struct.frame_size           = SPI_FRAMESIZE_8BIT;
    spi_init_struct.clock_polarity_phase = SPI_CK_PL_LOW_PH_2EDGE;
    spi_init_struct.nss                  = SPI_NSS_SOFT;
    spi_init_struct.prescale             = SPI_PSC_256;
    spi_init_struct.endian               = SPI_ENDIAN_MSB;
    spi_init(SPI0, &spi_init_struct);

    /* SPI2 parameter config */
    spi_init_struct.device_mode = SPI_SLAVE;
    spi_init_struct.nss         = SPI_NSS_HARD;
    spi_init(SPI2, &spi_init_struct);
}

代码讲解

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

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

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

实验现象

主机和从机互相交换数据
数据校验通过则 LED 指示成功

注意事项

CPOL 和 CPHA 必须主机从机一致
片选（CS）信号要手动拉低选中从机
时钟频率不能超过从设备的最大速率