GPIO on CLing

AT32 GPIO — LED 翻转闪烁（入门第一个实验）

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

GPIO — LED 翻转闪烁

难度: ⭐（零基础入门）
固件库: AT32F403A_407_Firmware_Library V2.2.2
源文件: project/at_start_f403a/examples/gpio/led_toggle/src/main.c

这个实验是干嘛的？

如果你是第一次接触 MCU 开发，这个实验就是你的"Hello World"。

目标很简单：让开发板上的 3 个 LED 灯像跑马灯一样依次闪烁。

通过这个实验你将学会：

MCU 程序的基本结构（初始化 → 主循环）
GPIO 输出模式的概念
如何用软件控制一个引脚的高低电平

硬件准备

AT32F403A 开发板（AT-START-F403A）
USB 数据线（供电 + 下载）
不需要任何额外接线，LED 焊在板子上了

开发板上一般有 3 个 LED，分别连接在：

LED2 → PB5
LED3 → PB6
LED4 → PB4

（具体引脚请看你的开发板原理图）

完整代码

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

int main(void)
{
  /* 第一步：配置系统时钟（让 MCU 跑起来） */
  system_clock_config();

  /* 第二步：初始化开发板上的外设（LED、按键等） */
  at32_board_init();

  /* 第三步：主循环，反复执行 */
  while(1)
  {
    at32_led_toggle(LED2);   // 翻转 LED2 的状态（亮→灭 或 灭→亮）
    delay_ms(200);           // 等 200 毫秒

    at32_led_toggle(LED3);   // 翻转 LED3
    delay_ms(200);

    at32_led_toggle(LED4);   // 翻转 LED4
    delay_ms(200);
  }
}

代码逐行讲解

1. 头文件

1
2

#include "at32f403a_407_board.h"   // 板级支持包（LED、按键、串口等封装好的函数）
#include "at32f403a_407_clock.h"   // 时钟配置

这两个头文件是雅特力官方提供的"工具箱"。board.h 里面封装了 at32_led_toggle()、delay_ms() 这些方便的函数，你不用自己去操作寄存器。

2. 系统时钟初始化

`1`	`system_clock_config();`

MCU 上电后默认用内部低速时钟（8MHz），这行代码把它切换到高速时钟（比如 240MHz）。这行必须放在最前面，否则后面所有依赖时钟的功能都不正常。

3. 板级初始化

`1`	`at32_board_init();`

这行代码帮你把开发板上的 LED、按键等外设都初始化好了。具体做了什么？它内部会：

使能 GPIO 端口的时钟
把 LED 对应的引脚配置为推挽输出模式

4. 主循环

while(1)
{
    at32_led_toggle(LED2);
    delay_ms(200);
    ...
}

while(1) 是死循环，MCU 会一直在这里面转。

at32_led_toggle(LED2) 做的事情很简单：如果 LED2 当前是亮的，就灭掉；如果是灭的，就点亮。本质就是把引脚电平取反。

delay_ms(200) 等待 200 毫秒。不加延时的话，翻转太快人眼看不到闪烁（可能只看到 LED 常亮或常暗）。

如果不用封装函数，怎么自己操作 GPIO？

at32_led_toggle() 是官方帮你封装好的。如果你想知道底层怎么实现的，看 io_toggle 那个示例：

// 直接操作寄存器，把 PA1 拉高（输出 3.3V）
GPIOA->scr = GPIO_PINS_1;

// 直接操作寄存器，把 PA1 拉低（输出 0V）
GPIOA->clr = GPIO_PINS_1;

scr（Set Control Register）：写 1 拉高，写 0 无效
clr（Clear Register）：写 1 拉低，写 0 无效

这就是 GPIO 输出的最底层操作。at32_led_toggle() 内部也是类似逻辑，只是多了一步判断当前状态。

GPIO 初始化的完整写法

at32_board_init() 帮你做了 GPIO 初始化。如果你想自己配置一个新引脚，完整流程是：

void gpio_config(void)
{
  gpio_init_type gpio_init_struct;

  /* 第一步：使能 GPIO 端口时钟 */
  // 不开时钟，GPIO 寄存器无法访问！这是最常见的坑
  crm_periph_clock_enable(CRM_GPIOA_PERIPH_CLOCK, TRUE);

  /* 第二步：填充默认参数 */
  gpio_default_para_init(&gpio_init_struct);

  /* 第三步：配置参数 */
  gpio_init_struct.gpio_pins = GPIO_PINS_1;              // 选择引脚 1
  gpio_init_struct.gpio_mode = GPIO_MODE_OUTPUT;          // 输出模式
  gpio_init_struct.gpio_out_type = GPIO_OUTPUT_PUSH_PULL; // 推挽输出
  gpio_init_struct.gpio_pull = GPIO_PULL_NONE;            // 不需要上下拉
  gpio_init_struct.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER; // 强驱动

  /* 第四步：应用配置 */
  gpio_init(GPIOA, &gpio_init_struct);
}

关键参数解释

参数	含义	常用值
`gpio_mode`	输入/输出/复用/模拟	输出用 `GPIO_MODE_OUTPUT`
`gpio_out_type`	推挽/开漏	一般用推挽 `PUSH_PULL`
`gpio_pull`	上拉/下拉/无	输出一般不需要 `PULL_NONE`
`gpio_drive_strength`	驱动能力	驱动 LED 用 `STRONGER`

实验现象

编译、下载程序到开发板
板子上 3 个 LED 灯依次交替闪烁
每个灯亮 200ms 后切换到下一个，形成流水灯效果

如果 LED 不亮：

检查程序是否下载成功
确认 LED 引脚与代码一致（看原理图）
确认 system_clock_config() 在最前面

小结

概念	说明
GPIO	通用输入输出，MCU 最基础的外设
推挽输出	可以主动输出高电平和低电平
寄存器操作	`scr` 拉高、`clr` 拉低
封装函数	`at32_led_toggle()` 比直接操作寄存器更方便

学了 GPIO 输出能做什么？

GPIO 输出是最基础的能力，但它是一切控制的起点：

初级项目

项目	原理	难度
LED 呼吸灯	用 PWM 控制亮度渐变（配合定时器）	⭐⭐
按键控制 LED	GPIO 输入 + GPIO 输出联动	⭐
继电器控制	GPIO 驱动继电器模块，控制 220V 电器开关	⭐⭐
蜂鸣器播放音乐	不同频率的方波 = 不同音调	⭐⭐
交通灯模拟	红黄绿三色 LED 按时序切换	⭐

进阶项目

项目	原理	难度
WS2812 彩灯驱动	用 GPIO 精确时序控制可编程 LED 灯带	⭐⭐⭐
步进电机控制	GPIO 按顺序驱动电机的 4 个相位	⭐⭐⭐
LCD 并口驱动	用 GPIO 模拟 8080/6800 并行总线	⭐⭐⭐
模拟 I2C/SPI	用 GPIO 软件模拟通信时序（Bit-banging）	⭐⭐⭐

核心思路：GPIO 输出的本质就是"控制一个引脚的高低电平"。理解了这一点，你就能控制任何数字设备——LED、继电器、电机、显示屏……只要它接受高低电平信号。

下一步：学会了 GPIO 输出，接下来可以学 USART printf 重定向，用串口打印调试信息。

PUYA GPIO — GPIO 翻转输出（HAL 库）

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

GPIO — GPIO 翻转输出（HAL 库）

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

功能简介

本示例演示如何让一个 GPIO 引脚工作于推挽输出模式，并在主循环中周期性翻转其电平。GPIO（通用输入输出）是 MCU 最基础、最常用的外设，所有“点灯”“驱动继电器”“软件模拟时序”都建立在它之上。

示例中 LED 连接在 PA11（开发板丝印 LED3），程序每 250ms 翻转一次该引脚，人眼即可看到 LED 闪烁。

硬件准备

PY32F030 开发板（或 PY32F002A / F003 官方 STK 板）
板载 LED（PA11，对应 LED3）
一根 USB 数据线用于供电与下载
无需额外外接元件

提示：如果你手上的板子 LED 不在 PA11，请修改下方宏定义中的引脚即可。

完整代码

#include "main.h"

/* 把板载 LED3 映射成一组好记的宏，方便后续修改 */
#define LED_GPIO_PIN          LED3_PIN          /* LED 引脚：PA11 */
#define LED_GPIO_PORT         LED3_GPIO_PORT    /* LED 端口：GPIOA */
#define LED_GPIO_CLK_ENABLE() LED3_GPIO_CLK_ENABLE() /* 开启 GPIOA 时钟 */

/* 静态函数声明：GPIO 初始化 */
static void APP_GpioConfig(void);

int main(void)
{
  /* 1. 复位所有外设，并初始化 HAL 库与 SysTick 时基 */
  HAL_Init();

  /* 2. 配置 LED 引脚为推挽输出 */
  APP_GpioConfig();

  /* 3. 主循环：每 250ms 翻转一次 LED 电平 */
  while (1)
  {
    HAL_Delay(250);                              /* 阻塞延时 250ms */
    HAL_GPIO_TogglePin(LED_GPIO_PORT, LED_GPIO_PIN); /* 翻转引脚电平 */
  }
}

/**
  * @brief  GPIO 引脚配置函数
  */
static void APP_GpioConfig(void)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};

  LED_GPIO_CLK_ENABLE();                        /* 必须先开时钟，否则配置无效 */

  GPIO_InitStruct.Pin   = LED_GPIO_PIN;
  GPIO_InitStruct.Mode  = GPIO_MODE_OUTPUT_PP;  /* 推挽输出模式 */
  GPIO_InitStruct.Pull  = GPIO_PULLUP;          /* 启用上拉 */
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; /* 引脚翻转速度：高速 */
  HAL_GPIO_Init(LED_GPIO_PORT, &GPIO_InitStruct);
}

/**
  * @brief  错误处理：卡死在此处便于调试
  */
void APP_ErrorHandler(void)
{
  while (1)
  {
  }
}

代码分段讲解

1. 时钟使能

LED_GPIO_CLK_ENABLE() 展开为 __HAL_RCC_GPIOA_CLK_ENABLE()。在 PY32（与 STM32 一致）中，任何外设使用前都必须先开启其时钟，否则写寄存器无效。这是初学者最容易遗漏的一步。

2. 引脚模式

GPIO_MODE_OUTPUT_PP：推挽输出。输出高电平时由 VDD 驱动，输出低电平时由内部 NMOS 拉到 GND，驱动能力较强，适合直接驱动 LED。
与之相对的 GPIO_MODE_OUTPUT_OD 为开漏输出，常用于 I2C 等需要“线与”的总线。

3. 翻转与延时

HAL_GPIO_TogglePin()：读取引脚当前电平后取反再写回，是最常用的“闪烁”原语。
HAL_Delay(250)：基于 SysTick 的毫秒级阻塞延时，由 HAL_Init() 内部完成初始化。注意它是阻塞的，期间 CPU 不能做别的事（真实项目推荐用定时器中断替代）。

实验现象

板载 LED（PA11）以约 2Hz（每 250ms 一次）的频率闪烁。
用示波器/逻辑分析仪测量 PA11，可见周期为 500ms 的方波。

常见问题

下载后 LED 不闪？
- 确认引导/下载模式与复位电路正常；确认 LED 实际连接引脚与代码中 LED3_PIN 一致（不同板型可能接在 PB0 / PB1 / PA5）。
- 检查是否选择了正确的芯片型号（PY32F030x8），Flash 容量不同会导致下载失败。
编译报 LED3_PIN 未定义？
- 该宏定义在 Drivers/BSP/PY32F030xx_Start_Kit/py32f030xx_Start_Kit.h 中，确认工程已包含该 BSP 头文件。
闪烁很快/很慢？
- 直接调整 HAL_Delay() 的参数；若使用内部 HSI 且频率与工程设定不一致，实际延时会有偏差。
想用定时器非阻塞闪烁？
- 参考同系列 TIMERx 示例，用定时器更新中断翻转引脚，主循环可空出来做其他任务。

小结

GPIO 输出只需三步：开时钟 → 配置引脚模式 → 写/翻转电平。
HAL_GPIO_TogglePin() + HAL_Delay() 是最简单的闪烁模板，适合作为每个新板子的“点灯”验证程序。
推挽输出（OUTPUT_PP）适合直接驱动 LED；开漏输出（OUTPUT_OD）适合总线应用。

拓展应用

把 HAL_Delay 换成定时器中断，实现“非阻塞”多任务闪烁（如多个 LED 不同频率）。
读取按键（GPIO_INPUT + HAL_GPIO_ReadPin）实现“按键控制 LED 亮灭”。
用 GPIO_SPEED_FREQ_VERY_HIGH 配合精确延时，用单引脚“软”模拟单总线协议（如 DHT11、WS2812）。
结合 PWM（见 TIM1_PWM 示例）做 LED 呼吸灯。

AT32 — 通用 IO 口 (GPIO)

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

AT32 — 通用 IO 口 (GPIO)

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

什么是通用 IO 口 (GPIO)?

GPIO 是 MCU 与外部世界交互的最基础接口。通过配置引脚为输入或输出模式，可以读取按键状态、控制 LED、驱动继电器等。

示例列表

IO 口翻转输出 — io_toggle
LED 翻转闪烁 — led_toggle
SWJTAG 引脚重映射 — swjtag_remap

AT32 GPIO — IO 口翻转输出

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

GPIO — IO 口翻转输出

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

功能简介

本示例演示如何配置 GPIO 引脚为输出模式，并通过软件翻转引脚电平。GPIO 是 MCU 最基本的外设，几乎所有项目都会用到。

硬件准备

开发板上的 LED 灯（通常连接在 PA5、PB0、PB1 等引脚）
无需额外接线

完整代码

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

void gpio_config(void)
{
  gpio_init_type gpio_init_struct;

  /* enable the gpioa clock */
  crm_periph_clock_enable(CRM_GPIOA_PERIPH_CLOCK, TRUE);

  /* set default parameter */
  gpio_default_para_init(&gpio_init_struct);

  /* configure the gpio */
  gpio_init_struct.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
  gpio_init_struct.gpio_out_type  = GPIO_OUTPUT_PUSH_PULL;
  gpio_init_struct.gpio_mode = GPIO_MODE_OUTPUT;
  gpio_init_struct.gpio_pins = GPIO_PINS_1;
  gpio_init_struct.gpio_pull = GPIO_PULL_NONE;
  gpio_init(GPIOA, &gpio_init_struct);
}

int main(void)
{
  system_clock_config();

  gpio_config();

  while(1)
  {
    /* set pa.01 */
    GPIOA->scr = GPIO_PINS_1;
    /* reset pa.01 */
    GPIOA->clr = GPIO_PINS_1;

    /* set pa.01 */
    GPIOA->scr = GPIO_PINS_1;
    /* reset pa.01 */
    GPIOA->clr = GPIO_PINS_1;

    /* set pa.01 */
    GPIOA->scr = GPIO_PINS_1;
    /* reset pa.01 */
    GPIOA->clr = GPIO_PINS_1;

    /* set pa.01 */
    GPIOA->scr = GPIO_PINS_1;
    /* reset pa.01 */
    GPIOA->clr = GPIO_PINS_1;

    /* set pa.01 */
    GPIOA->scr = GPIO_PINS_1;
    /* reset pa.01 */
    GPIOA->clr = GPIO_PINS_1;

    /* set pa.01 */
    GPIOA->scr = GPIO_PINS_1;
    /* reset pa.01 */
    GPIOA->clr = GPIO_PINS_1;
  }
}

代码讲解

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

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

实验现象

对应 GPIO 引脚电平交替翻转
可用示波器或 LED 观察

注意事项

确认 LED 连接的引脚与代码中一致
输出模式一般选择推挽输出（Push-Pull）

AT32 GPIO — SWJTAG 引脚重映射

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

GPIO — SWJTAG 引脚重映射

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

功能简介

本示例演示如何将 SWJTAG 调试引脚（PA13/PA14）重映射为普通 GPIO 使用。注意：重映射后将无法通过 SWD 调试，需要特殊方式恢复。

硬件准备

开发板上的 LED 灯（通常连接在 PA5、PB0、PB1 等引脚）
无需额外接线

完整代码

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

void swj_dp_config(void);
void gpio_pins_toggle(gpio_type* gpio_x, uint16_t gpio_pin);

/**
  * @brief  configure the gpio of swj-dp.
  * @param  none
  * @retval none
  */
void swj_dp_config(void)
{
  gpio_init_type gpio_init_struct;

  /* configure pa13 (jtms/swdat), pa14 (jtck/swclk) and pa15 (jtdi) as output push-pull */
  gpio_init_struct.gpio_pins = GPIO_PINS_13 | GPIO_PINS_14 | GPIO_PINS_15;
  gpio_init_struct.gpio_mode = GPIO_MODE_OUTPUT;
  gpio_init_struct.gpio_pull = GPIO_PULL_NONE;
  gpio_init_struct.gpio_out_type = GPIO_OUTPUT_PUSH_PULL;
  gpio_init_struct.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
  gpio_init(GPIOA, &gpio_init_struct);

  /* configure pb3 (jtdo) and pb4 (jtrst) as output push-pull */
  gpio_init_struct.gpio_pins = GPIO_PINS_3 | GPIO_PINS_4;
  gpio_init(GPIOB, &gpio_init_struct);
}

int main(void)
{
  system_clock_config();

  at32_board_init();

  crm_periph_clock_enable(CRM_IOMUX_PERIPH_CLOCK, TRUE);
  crm_periph_clock_enable(CRM_GPIOA_PERIPH_CLOCK, TRUE);
  crm_periph_clock_enable(CRM_GPIOB_PERIPH_CLOCK, TRUE);

  swj_dp_config();

  while(1)
  {
    if(USER_BUTTON == at32_button_press())
    {
      /* disable the serial wire jtag debug port swj-dp */
      gpio_pin_remap_config(SWJTAG_MUX_100, TRUE);

      /* turn on led3 */
      at32_led_on(LED3);
    }

    /* toggle jtms/swdat pin */
    gpio_pins_toggle(GPIOA, GPIO_PINS_13);
    delay_us(200);

    /* toggle jtck/swclk pin */
    gpio_pins_toggle(GPIOA, GPIO_PINS_14);
    delay_us(200);

    /* toggle jtdi pin */
    gpio_pins_toggle(GPIOA, GPIO_PINS_15);
    delay_us(200);

    /* toggle jtdo pin */
    gpio_pins_toggle(GPIOB, GPIO_PINS_3);
    delay_us(200);

    /* toggle jtrst pin */
    gpio_pins_toggle(GPIOB, GPIO_PINS_4);
    delay_us(200);
  }
}

代码讲解

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

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

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

实验现象

对应 GPIO 引脚电平交替翻转
可用示波器或 LED 观察

注意事项

警告：重映射 SWJTAG 引脚后，SWD 调试接口将不可用！恢复方法：拉 BOOT0 高电平进入 ISP 模式，擦除芯片后重新烧录。

CIU32 — 通用 IO 口 (GPIO)

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

CIU32 — 通用 IO 口 (GPIO)

固件库: CIU32F003_STDLib V1.0.3
示例数: 1

什么是通用 IO 口 (GPIO)?

GPIO 是 MCU 与外部世界交互的最基础接口。通过配置引脚为输入或输出模式，可以读取按键状态、控制 LED、驱动继电器等。

示例列表

GPIO 翻转输出 — GPIO_Toggle

CIU32 GPIO — GPIO 翻转输出

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

GPIO — GPIO 翻转输出

固件库: CIU32F003_STDLib V1.0.3
芯片: CIU32
源文件: CIU32/CIU32F003_STDLib_V1.0.3/Projects/GPIO/GPIO_Toggle/Source/main.c

功能简介

本示例演示如何配置 GPIO 引脚为输出模式，并通过软件翻转引脚电平。GPIO 是 MCU 最基本的外设，几乎所有项目都会用到。

硬件准备

开发板上的 LED 灯（通常连接在 PA5、PB0、PB1 等引脚）
无需额外接线

完整代码

#include "main.h"

int main(void)
{      
    /* ϵͳʱ */
    system_clock_config(); 

    /* Systickʼ */
    std_delay_init();

    /* GPIOʼ */
    gpio_init();

    while(1)
    {
        std_gpio_toggle_pin(LED_GPIO_PORT,LED_PIN);
        std_delayms(300);
    }
}

代码讲解

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

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

实验现象

对应 GPIO 引脚电平交替翻转
可用示波器或 LED 观察

注意事项

确认 LED 连接的引脚与代码中一致
输出模式一般选择推挽输出（Push-Pull）

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 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，它让你能"看见"程序内部在想什么，是效率提升最大的一个技能。

PUYA — 通用 IO 口 (GPIO)

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

PUYA — 通用 IO 口 (GPIO)

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

什么是通用 IO 口 (GPIO)?

GPIO 是 MCU 与外部世界交互的最基础接口。通过配置引脚为输入或输出模式，可以读取按键状态、控制 LED、驱动继电器等。

示例列表

GPIO_FastIO — GPIO_FastIO
GPIO 翻转输出 — GPIO_Toggle

PUYA — 通用 IO 口 (GPIO)

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

PUYA — 通用 IO 口 (GPIO)

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

什么是通用 IO 口 (GPIO)?

GPIO 是 MCU 与外部世界交互的最基础接口。通过配置引脚为输入或输出模式，可以读取按键状态、控制 LED、驱动继电器等。

示例列表

GPIO_FastIO — GPIO_FastIO
GPIO 翻转输出 — GPIO_Toggle

重点推荐：GPIO 翻转输出已整理为完整教学文档（功能简介→代码→讲解→实验现象→常见问题→小结→拓展），入门首选。

PUYA — 通用 IO 口 (GPIO)

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

PUYA — 通用 IO 口 (GPIO)

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

什么是通用 IO 口 (GPIO)?

GPIO 是 MCU 与外部世界交互的最基础接口。通过配置引脚为输入或输出模式，可以读取按键状态、控制 LED、驱动继电器等。

示例列表

GPIO 翻转输出 — GPIO_Toggle

PUYA — 通用 IO 口 (GPIO)

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

PUYA — 通用 IO 口 (GPIO)

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

什么是通用 IO 口 (GPIO)?

GPIO 是 MCU 与外部世界交互的最基础接口。通过配置引脚为输入或输出模式，可以读取按键状态、控制 LED、驱动继电器等。

示例列表

GPIO_FastIO — GPIO_FastIO
GPIO 翻转输出 — GPIO_Toggle

PUYA GPIO — GPIO 翻转输出

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

GPIO — GPIO 翻转输出

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

功能简介

本示例演示如何配置 GPIO 引脚为输出模式，并通过软件翻转引脚电平。GPIO 是 MCU 最基本的外设，几乎所有项目都会用到。

硬件准备

开发板上的 LED 灯（通常连接在 PA5、PB0、PB1 等引脚）
无需额外接线

完整代码

#include "main.h"
#define LED_GPIO_PIN                 LED3_PIN
#define LED_GPIO_PORT                LED3_GPIO_PORT
#define LED_GPIO_CLK_ENABLE()        LED3_GPIO_CLK_ENABLE()

代码讲解

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

实验现象

对应 GPIO 引脚电平交替翻转
可用示波器或 LED 观察

注意事项

确认 LED 连接的引脚与代码中一致
输出模式一般选择推挽输出（Push-Pull）

PUYA GPIO — GPIO 翻转输出

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

GPIO — GPIO 翻转输出

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

功能简介

本示例演示如何配置 GPIO 引脚为输出模式，并通过软件翻转引脚电平。GPIO 是 MCU 最基本的外设，几乎所有项目都会用到。

硬件准备

开发板上的 LED 灯（通常连接在 PA5、PB0、PB1 等引脚）
无需额外接线

完整代码

#include "main.h"
#define LED_GPIO_PIN                 LED3_PIN
#define LED_GPIO_PORT                LED3_GPIO_PORT
#define LED_GPIO_CLK_ENABLE()        LED3_GPIO_CLK_ENABLE()

代码讲解

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

实验现象

对应 GPIO 引脚电平交替翻转
可用示波器或 LED 观察

注意事项

确认 LED 连接的引脚与代码中一致
输出模式一般选择推挽输出（Push-Pull）

PUYA GPIO — GPIO 翻转输出

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

GPIO — GPIO 翻转输出

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

功能简介

本示例演示如何配置 GPIO 引脚为输出模式，并通过软件翻转引脚电平。GPIO 是 MCU 最基本的外设，几乎所有项目都会用到。

硬件准备

开发板上的 LED 灯（通常连接在 PA5、PB0、PB1 等引脚）
无需额外接线

完整代码

#include "main.h"
#define LED_GPIO_PIN                 LED3_PIN
#define LED_GPIO_PORT                LED3_GPIO_PORT
#define LED_GPIO_CLK_ENABLE()        LED3_GPIO_CLK_ENABLE()

代码讲解

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

实验现象

对应 GPIO 引脚电平交替翻转
可用示波器或 LED 观察

注意事项

确认 LED 连接的引脚与代码中一致
输出模式一般选择推挽输出（Push-Pull）

PUYA GPIO — GPIO 翻转输出（LL 库）

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

GPIO — GPIO 翻转输出（LL 库）

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

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

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

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

功能简介

本示例与 HAL 版功能完全相同：让一个 GPIO 引脚工作于输出模式，主循环里周期性翻转电平，板载 LED（PA11，丝印 LED3）闪烁。区别只在于底层 API 用的是 LL 库而非 HAL 库。

通过这一最简单示例，可以直观体会 HAL 与 LL 的写法差异：

HAL 用 HAL_GPIO_Init() 传一个 GPIO_InitTypeDef 结构体完成配置；
LL 直接调用 LL_GPIO_SetPinMode() 一行设置模式，更接近“操作寄存器”，代码更短、依赖更少。

硬件准备

PY32F030 开发板（或 PY32F002A / F003 官方 STK 板）
板载 LED（PA11，对应 LED3）
一根 USB 数据线用于供电与下载
无需额外外接元件

提示：若你手上板子的 LED 不在 PA11，修改下方 LED3_PIN 相关宏即可。

完整代码

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

/* 把板载 LED3 映射成一组好记的宏，方便后续修改 */
#define LED_GPIO_PIN                   LED3_PIN
#define LED_GPIO_PORT                  LED3_GPIO_PORT
#define LED_GPIO_CLK_ENABLE()          LED3_GPIO_CLK_ENABLE()

/* 函数声明 */
static void APP_SystemClockConfig(void);
static void APP_GpioConfig(void);

int main(void)
{
  /* 1. 配置系统时钟（LL 版需要手动配时钟，HAL 在 HAL_Init 里代劳了部分） */
  APP_SystemClockConfig();

  /* 2. 配置 LED 引脚为输出 */
  APP_GpioConfig();

  /* 3. 先熄灭 LED（输出高电平，低电平点亮，取决于硬件） */
  LL_GPIO_SetOutputPin(LED_GPIO_PORT, LED_GPIO_PIN);

  /* 4. 主循环：每 100ms 翻转一次 */
  while (1)
  {
    LL_mDelay(100);                                   /* LL 自带的毫秒延时 */
    LL_GPIO_TogglePin(LED_GPIO_PORT, LED_GPIO_PIN);   /* 翻转引脚电平 */
  }
}

/**
  * @brief  系统时钟配置
  */
static void APP_SystemClockConfig(void)
{
  /* 使能 HSI 并等待就绪 */
  LL_RCC_HSI_Enable();
  while (LL_RCC_HSI_IsReady() != 1) {}

  /* AHB 不分频 */
  LL_RCC_SetAHBPrescaler(LL_RCC_SYSCLK_DIV_1);

  /* 选 HSISYS 作为系统时钟源 */
  LL_RCC_SetSysClkSource(LL_RCC_SYS_CLKSOURCE_HSISYS);
  while (LL_RCC_GetSysClkSource() != LL_RCC_SYS_CLKSOURCE_STATUS_HSISYS) {}

  /* APB1 不分频，并初始化 1ms 时基与系统时钟全局变量 */
  LL_RCC_SetAPB1Prescaler(LL_RCC_APB1_DIV_1);
  LL_Init1msTick(8000000);
  LL_SetSystemCoreClock(8000000);
}

/**
  * @brief  GPIO 引脚配置
  */
static void APP_GpioConfig(void)
{
  /* 必须先开时钟，否则配置无效（LL 不会自动帮你开） */
  LED_GPIO_CLK_ENABLE();

  /* 一行设置引脚为输出模式，复位后默认就是推挽、低速、无上下拉 */
  LL_GPIO_SetPinMode(LED_GPIO_PORT, LED_GPIO_PIN, LL_GPIO_MODE_OUTPUT);

  /* 下面这些都是“复位默认值”，注释掉也能工作，写出来便于理解
  LL_GPIO_SetPinOutputType(LED_GPIO_PORT, LED_GPIO_PIN, LL_GPIO_OUTPUT_PUSHPULL);
  LL_GPIO_SetPinSpeed(LED_GPIO_PORT, LED_GPIO_PIN, LL_GPIO_SPEED_FREQ_LOW);
  LL_GPIO_SetPinPull(LED_GPIO_PORT, LED_GPIO_PIN, LL_GPIO_PULL_NO);
  */
}

/**
  * @brief  错误处理：卡死在此处便于调试
  */
void APP_ErrorHandler(void)
{
  while (1) {}
}

代码分段讲解

1. LL 没有“统一初始化入口”

HAL 版第一行是 HAL_Init()，它顺手初始化了 HAL 库、SysTick、中断优先级等。LL 版没有这个总入口，所以你需要自己调用 APP_SystemClockConfig() 把系统时钟配好，否则 LL_mDelay() 的时基是错的。

2. 时钟使能：LL 更“裸”

HAL：__HAL_RCC_GPIOA_CLK_ENABLE()（由 LED_GPIO_CLK_ENABLE() 宏展开）。
LL：LED_GPIO_CLK_ENABLE() 这个宏本身两版都用，但它的底层就是直接写 RCC 寄存器。关键点：LL 不会在初始化时自动开时钟，忘记开时钟是 LL 初学者最常见的 bug。

3. 引脚配置：结构体 vs 直接函数

HAL：HAL_GPIO_Init() 接收 GPIO_InitTypeDef，一次设置 Pin/Mode/Pull/Speed。
LL：LL_GPIO_SetPinMode() 单功能函数，一行只做一件事。优点是不需要构造结构体、代码更短；缺点是多个属性要分多行写（不过多数属性复位值就是你要的）。

4. 翻转与延时

LL_GPIO_TogglePin() 与 HAL_GPIO_TogglePin() 语义一致，都是读-反-写。
LL_mDelay(100) 对应 HAL 的 HAL_Delay(100)，都是基于 SysTick 的阻塞毫秒延时。注意 LL 版延时前必须先调 LL_Init1msTick() 设定正确的 tick 频率（在 APP_SystemClockConfig 里已做）。

实验现象

板载 LED（PA11）以约 5Hz（每 100ms 一次）的频率闪烁，比 HAL 版（250ms）更快。
用示波器/逻辑分析仪测量 PA11，可见周期约 200ms 的方波。

常见问题

LED 不闪 / 闪得很怪？
- 先确认 APP_SystemClockConfig() 里 LL_Init1msTick() 的参数和 LL_SetSystemCoreClock() 与实际 HSI 频率一致（本例 8MHz）。参数不对，LL_mDelay 时序会整体偏移。
- 确认 LED 实际引脚与 LED3_PIN 一致。
编译报 LL_GPIO_xxx 未定义？
- LL 函数分散在 stm32py32..._ll_gpio.h 等头文件中，确认工程已包含 py32f030xx_ll_Start_Kit.h 以及对应的 LL 驱动头。
想改成非阻塞闪烁？
- 同 HAL 版思路，用 TIM 更新中断翻转引脚；LL 里对应 LL_TIM_xxx 系列函数（见 TIM1_PWM_Init 示例）。

小结

LL 版 GPIO 输出三步依然是：开时钟 → 设模式 → 翻转/写电平，但全部由 LL_GPIO_* / LL_RCC_* 直接操作完成。
与 HAL 的最大区别：LL 没有 HAL_Init() 这种“一站式”初始化，系统时钟、LL_mDelay 时基都要自己配。
代码更短、编译体积更小、对寄存器行为更透明——这是 LL 的核心价值。

拓展应用

把 LL_mDelay 换成 TIM 中断，做多 LED 不同频率非阻塞闪烁。
配合 LL_GPIO_SetPinOutputType() 把引脚设为开漏（LL_GPIO_OUTPUT_OPENDRAIN），驱动需要线与的总线设备。
用 LL_GPIO_ReadInputPort() 读取按键，实现按键控制 LED（LL 版 GPIO_INPUT 思路同 HAL）。
结合 TIM1_PWM_Init 示例，用 LL_TIM_OC_SetCompareCHx() 做呼吸灯。

PUYA GPIO — GPIO_FastIO

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

GPIO — GPIO_FastIO

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

功能简介

本示例演示 GPIO 的基本输出功能。GPIO（通用输入输出）是 MCU 与外部世界交互的最基础接口。

硬件准备

开发板上的 LED 灯（通常连接在 PA5、PB0、PB1 等引脚）
无需额外接线

完整代码

1
2

#include "main.h"
#define APP_GpioToggle()  {GPIOA->BSRR = u32High;\

代码讲解

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

实验现象

对应 GPIO 引脚电平交替翻转
可用示波器或 LED 观察

注意事项

确认 LED 连接的引脚与代码中一致
输出模式一般选择推挽输出（Push-Pull）

PUYA GPIO — GPIO_FastIO

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

GPIO — GPIO_FastIO

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

功能简介

本示例演示 GPIO 的基本输出功能。GPIO（通用输入输出）是 MCU 与外部世界交互的最基础接口。

硬件准备

开发板上的 LED 灯（通常连接在 PA5、PB0、PB1 等引脚）
无需额外接线

完整代码

1
2

#include "main.h"
#define APP_GpioToggle()  {GPIOA->BSRR = u32High;\

代码讲解

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

实验现象

对应 GPIO 引脚电平交替翻转
可用示波器或 LED 观察

注意事项

确认 LED 连接的引脚与代码中一致
输出模式一般选择推挽输出（Push-Pull）

PUYA GPIO — GPIO_FastIO

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

GPIO — GPIO_FastIO

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

功能简介

本示例演示 GPIO 的基本输出功能。GPIO（通用输入输出）是 MCU 与外部世界交互的最基础接口。

硬件准备

开发板上的 LED 灯（通常连接在 PA5、PB0、PB1 等引脚）
无需额外接线

完整代码

1
2

#include "main.h"
#define APP_GpioToggle()  {GPIOA->BSRR = u32High;\

代码讲解

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

实验现象

对应 GPIO 引脚电平交替翻转
可用示波器或 LED 观察

注意事项

确认 LED 连接的引脚与代码中一致
输出模式一般选择推挽输出（Push-Pull）

GPIO on CLing

AT32 GPIO — LED 翻转闪烁（入门第一个实验）

GPIO — LED 翻转闪烁

这个实验是干嘛的？

硬件准备

完整代码

代码逐行讲解

1. 头文件

2. 系统时钟初始化

3. 板级初始化

4. 主循环

如果不用封装函数，怎么自己操作 GPIO？

GPIO 初始化的完整写法

关键参数解释

实验现象

小结

学了 GPIO 输出能做什么？

初级项目

进阶项目

PUYA GPIO — GPIO 翻转输出（HAL 库）

GPIO — GPIO 翻转输出（HAL 库）

功能简介

硬件准备

完整代码

代码分段讲解

1. 时钟使能

2. 引脚模式

3. 翻转与延时

实验现象

常见问题

小结

拓展应用

AT32 — 通用 IO 口 (GPIO)

AT32 — 通用 IO 口 (GPIO)

什么是 通用 IO 口 (GPIO)?

示例列表

AT32 GPIO — IO 口翻转输出

GPIO — IO 口翻转输出

功能简介

硬件准备

完整代码

代码讲解

实验现象

注意事项

AT32 GPIO — SWJTAG 引脚重映射

GPIO — SWJTAG 引脚重映射

功能简介

硬件准备

完整代码

代码讲解

实验现象

注意事项

CIU32 — 通用 IO 口 (GPIO)

CIU32 — 通用 IO 口 (GPIO)

什么是 通用 IO 口 (GPIO)?

示例列表

CIU32 GPIO — GPIO 翻转输出

GPIO — GPIO 翻转输出

功能简介

硬件准备

完整代码

代码讲解

实验现象

注意事项

GD32 — 通用 IO 口 (GPIO)

GD32 — 通用 IO 口 (GPIO)

什么是 GPIO？

GD32 的 GPIO 长什么样

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

常用 API 速查

三个新手必踩的坑

学习路线建议

示例列表

GD32 GPIO — 按键轮询检测

GPIO — 按键轮询检测

功能简介

硬件准备

完整代码

代码讲解

实验现象

什么是通用 IO 口 (GPIO)?

什么是通用 IO 口 (GPIO)?

第 5 段：`while(1)` 不能省

Q4：能不能用 `for` 循环把重复代码简化掉？

Q5：`delay_1ms()` 期间 CPU 在干什么？

什么是通用 IO 口 (GPIO)?

什么是通用 IO 口 (GPIO)?

什么是通用 IO 口 (GPIO)?

什么是通用 IO 口 (GPIO)?