HC32F460 on CLing

HC32 GPIO — 通用输入输出口

Wed, 09 Sep 2026 09:00:00 +0800

GPIO — 从点亮一颗 LED 开始

这一章讲什么

GPIO 的全称是 General Purpose Input/Output，翻译过来就是「通用输入输出口」。

你可以把它理解成单片机身上的手和眼睛：

当它配置成输出，芯片就能主动往外送电（高电平 3.3V）或者拉到地（低电平 0V）——这就是「手」，能去驱动 LED、蜂鸣器、继电器。
当它配置成输入，芯片就能读外面的电压是高还是低——这就是「眼睛」，能读按键、读传感器的开关信号。

HC32F460 上，GPIO 模块在 ddl 库里叫 PORT。所以你看到的函数全是 PORT_xxx() 开头，比如 PORT_Init()、PORT_SetBits()。

给 STM32 老手的提示 如果你之前用过 STM32 标准外设库，HC32 的 PORT 模块和 GPIO_Init() 是一一对应的关系，只是换了名字：

STM32 标准库 HC32 ddl 库

GPIO_Init() PORT_Init()

GPIO_SetBits() PORT_SetBits()

GPIO_ResetBits() PORT_ResetBits()

需要自己读再写反 PORT_Toggle() 一步搞定

GPIO_ReadInputDataBit() PORT_GetBit()

RCC_APB2PeriphClockCmd() GPIO 不需要单独开时钟

STM32 标准库	HC32 ddl 库
`GPIO_Init()`	`PORT_Init()`
`GPIO_SetBits()`	`PORT_SetBits()`
`GPIO_ResetBits()`	`PORT_ResetBits()`
需要自己读再写反	`PORT_Toggle()` 一步搞定
`GPIO_ReadInputDataBit()`	`PORT_GetBit()`
`RCC_APB2PeriphClockCmd()`	GPIO 不需要单独开时钟

最后那一条很重要：HC32F460 的 GPIO 不需要手动开外设时钟。这一点和 STM32 不一样，少了一步，但也容易让人忘记「其他外设是要开时钟的」。

HC32F460 的 GPIO 长什么样

HC32F460JEUA（LQFP100 封装）一共有 8 组 PORT：

端口名	ddl 里的写法	说明
PORTA	`PortA`	常用，LED / USART 都在这
PORTB	`PortB`	QSPI / SDIOC 复用口多
PORTC	`PortC`	按键 PC13 在这
PORTD	`PortD`
PORTE	`PortE`
PORTH	`PortH`	引脚很少，常做特殊功能

每组最多 16 个引脚，在 ddl 里写成 Pin00 ~ Pin15。

所以「PA0 这个引脚」在 HC32 的代码里就写成两个参数：PortA, Pin00。

核心配置结构体

所有 GPIO 配置都塞在一个结构体 stc_port_init_t 里。最常用的三个成员：

stc_port_init_t stcPortInit;

stcPortInit.enPinMode = Pin_Mode_Out;   // 引脚模式：输出
stcPortInit.enPullUp  = Enable;         // 内部上拉电阻：使能
stcPortInit.enExInt   = Enable;         // 外部中断输入：使能

enPinMode 只有两个常用取值，非常好记：

取值	含义
`Pin_Mode_Out`	输出模式（推挽）
`Pin_Mode_In`	输入模式
`Pin_Mode_Ana`	模拟模式（给 ADC / DAC 用，把数字电路断开）

配好结构体，调一次 PORT_Init() 就生效了：

`1`	`PORT_Init(PortA, Pin00, &stcPortInit);`

一个坑：stc_port_init_t 的成员不止这三个（还有开漏、驱动能力、施密特触发等）。 C 语言里没赋值的局部结构体成员是随机垃圾值，直接用会出现「有时能跑有时不能跑」的灵异现象。所以 HC32 的示例代码里，PORT_Init() 之前一定会先来一句：
1
MEM_ZERO_STRUCT(stcPortInit);   // 整个结构体清零
这个宏是 ddl 库提供的，等价于 memset(&stcPortInit, 0, sizeof(stcPortInit))。养成习惯，每次配结构体前都清零。

读写引脚的四个函数

函数	干什么
`PORT_SetBits(port, pin)`	输出高电平（置 1）
`PORT_ResetBits(port, pin)`	输出低电平（清 0）
`PORT_Toggle(port, pin)`	翻转电平（高变低、低变高）
`PORT_GetBit(port, pin)`	读引脚电平，返回 `Set` 或 `Reset`

PORT_Toggle() 是做流水灯、做方波最省事的函数，比「读出来 → 取反 → 写回去」三步简洁得多。

本章示例

示例	学到什么
GPIO 输出：点亮并闪烁 LED	配置引脚为输出、`PORT_Toggle` 翻转电平、`Ddl_Delay1ms` 延时

开发板上的 LED 在哪

HC32F460JEUA KIT 板载三颗 LED，全部挂在 PORTA 上，而且是低电平点亮（共阳极接法）：

LED 颜色	引脚	ddl 写法	点亮条件
红	PA0	`PortA, Pin00`	输出低电平
绿	PA1	`PortA, Pin01`	输出低电平
蓝	PA2	`PortA, Pin02`	输出低电平

「低电平点亮」这件事一定要记住，它是新手最容易踩的坑：你写 PORT_SetBits() 想点灯，结果灯灭了。

SDK 里的 BSP 已经帮你封装好了，用起来不用管极性：

BSP_LED_Init();              // 初始化三颗 LED
BSP_LED_On(LED_RED);         // 点亮红灯（内部其实调的是 PORT_ResetBits）
BSP_LED_Off(LED_RED);        // 熄灭红灯
BSP_LED_Toggle(LED_GREEN);   // 翻转绿灯

BSP 文件位置：bsp/ev_hc32f460_lqfp100_v2/ev_hc32f460_lqfp100_v2.c

小结

HC32 的 GPIO 模块叫 PORT，函数是 PORT_xxx()。
引脚用「端口 + 引脚号」两个参数表示，比如 PortA, Pin00。
配置流程固定三步：清零结构体 → 填结构体 → PORT_Init()。
GPIO 不需要开外设时钟，但别的外设需要，用 PWC_FcgxPeriphClockCmd()。
开发板 LED 是低电平点亮。

HC32 GPIO 输出 — 点亮并闪烁 LED

Wed, 09 Sep 2026 09:00:00 +0800

GPIO 输出：点亮并闪烁 LED

源码路径：example/HC32F460JEUA/1.gpio/gpio_output/source/main.c

1. 功能简介

这是单片机界的「Hello World」。

程序做的事非常朴素：把开发板上的三颗 LED（红、绿、蓝）配置成输出，然后在一个 while(1) 死循环里，每隔 500 毫秒把它们的电平翻转一次。

翻转的效果就是：亮 → 灭 → 亮 → 灭…… 看起来就是三颗灯一起「闪烁」，肉眼看大概每秒闪一次（亮 0.5 秒 + 灭 0.5 秒 = 1 秒一个周期）。

学会这个例子，你就掌握了单片机最基础的能力：让一根引脚按你的意愿输出高低电平。之后的蜂鸣器、继电器、驱动 MOS 管，本质都是这一件事。

2. 硬件准备

最省事的做法：直接用 HC32F460JEUA KIT 开发板，板载三颗 LED 已经焊好，什么都不用接，烧录就能看效果。

板载 LED 接线（低电平点亮）：

      HC32F460                    LED
   ┌────────────┐
   │        PA0 ├───[ 限流电阻 ]───▶|───┐  红灯
   │        PA1 ├───[ 限流电阻 ]───▶|───┤  绿灯
   │        PA2 ├───[ 限流电阻 ]───▶|───┤  蓝灯
   │            │                       │
   └────────────┘                     3.3V

注意箭头方向：LED 正极（阳极）接 3.3V，负极（阴极）经限流电阻接到引脚。所以引脚输出低电平时，电流从 3.3V 流过 LED 到引脚，灯亮；输出高电平时两端都是高，没有压差，灯灭。

如果你想外接 LED 自己搭（比如用面包板）：

`1`	`引脚 PA0 ───[ 220Ω~1kΩ 电阻 ]───\|◀── LED ── GND`

这种接法就是高电平点亮了（引脚给高，电流流向 GND）。极性和板载相反，写代码时要留意。新手建议先用板载的，别自己折腾接线。

3. 完整代码

#include "hc32_ddl.h"                   // HC32 ddl 库总头文件，包含它就够了

/* ---------- LED 引脚定义（改这里就能换引脚，不用动下面的逻辑）---------- */
#define  LED0_PORT        (PortA)       // 红灯：PA0
#define  LED0_PIN         (Pin00)

#define  LED1_PORT        (PortA)       // 绿灯：PA1
#define  LED1_PIN         (Pin01)

#define  LED2_PORT        (PortA)       // 蓝灯：PA2
#define  LED2_PIN         (Pin02)

/* 用宏把「翻转某颗 LED」包一下，主循环里读起来更清爽 */
#define  LED0_TOGGLE()    (PORT_Toggle(LED0_PORT, LED0_PIN))
#define  LED1_TOGGLE()    (PORT_Toggle(LED1_PORT, LED1_PIN))
#define  LED2_TOGGLE()    (PORT_Toggle(LED2_PORT, LED2_PIN))

#define  DLY_MS           (500ul)       // 延时 500 毫秒，ul 表示无符号长整型常量

int32_t main(void)
{
    stc_port_init_t stcPortInit;        // GPIO 配置结构体

    /* 第一步：把结构体清零，避免没赋值的成员是随机垃圾值 */
    MEM_ZERO_STRUCT(stcPortInit);

    /* 第二步：填写配置 */
    stcPortInit.enPinMode = Pin_Mode_Out;   // 输出模式
    stcPortInit.enExInt   = Enable;         // 外部中断输入使能（输出用不到，保持默认）
    stcPortInit.enPullUp  = Enable;         // 内部上拉使能

    /* 第三步：用同一份配置，逐个初始化三颗 LED 的引脚 */
    PORT_Init(LED0_PORT, LED0_PIN, &stcPortInit);
    PORT_Init(LED1_PORT, LED1_PIN, &stcPortInit);
    PORT_Init(LED2_PORT, LED2_PIN, &stcPortInit);

    /* 先把三个引脚都拉高 —— 板载 LED 是低电平点亮，所以此时三颗灯都是灭的 */
    PORT_SetBits(LED0_PORT, LED0_PIN);
    PORT_SetBits(LED1_PORT, LED1_PIN);
    PORT_SetBits(LED2_PORT, LED2_PIN);

    while(1)
    {
        /* 翻转三颗 LED 的电平：原来灭的变亮，原来亮的变灭 */
        LED0_TOGGLE();
        LED1_TOGGLE();
        LED2_TOGGLE();

        Ddl_Delay1ms(DLY_MS);           // 死等 500 毫秒
    };
}

4. 代码分段讲解

4.1 三步配置法

HC32 配任何 GPIO 都是这个固定套路，闭着眼睛都要背下来：

1
2
3

MEM_ZERO_STRUCT(stcPortInit);          // ① 清零
stcPortInit.enPinMode = Pin_Mode_Out;  // ② 填参数
PORT_Init(LED0_PORT, LED0_PIN, &stcPortInit);  // ③ 初始化

为什么第一步要清零？ 因为 stcPortInit 是定义在栈上的局部变量，C 语言不会帮你自动清零。如果你只填了 enPinMode，剩下的成员（开漏、驱动能力……）就是内存里的随机值。运气好能跑，运气差就出诡异 bug。MEM_ZERO_STRUCT 一句解决。

4.2 三颗灯共用一份配置

注意 PORT_Init() 被调了三次，但用的都是同一个 &stcPortInit。因为三颗 LED 的配置完全一样（都是输出），没必要写三份结构体。这是个很实用的偷懒技巧。

4.3 为什么先 SetBits 拉高

`1`	`PORT_SetBits(LED0_PORT, LED0_PIN); // 拉高 = 灭灯`

板载 LED 是低电平点亮。上电后先把引脚拉高，保证三颗灯的初始状态是「灭」，这样后面第一次 Toggle 就是「点亮」，视觉上有个干净的起点。

4.4 主循环：翻转 + 延时

while(1)
{
    LED0_TOGGLE();               // 翻转
    LED1_TOGGLE();
    LED2_TOGGLE();
    Ddl_Delay1ms(DLY_MS);        // 延时 500ms
}

PORT_Toggle() 是关键。它不用管当前是高还是低，直接反过来。配上 500ms 延时，就是「亮 0.5 秒、灭 0.5 秒」的循环。

Ddl_Delay1ms() 是 ddl 库自带的毫秒级阻塞延时——CPU 在这段时间里啥也不干，纯粹空转数圈。简单例子够用，但真正的项目里不建议长时间用它（CPU 被白白浪费），后面学了定时器就该用定时器来做时间控制。

5. 实验现象

烧录后，开发板上的红、绿、蓝三颗 LED 同时闪烁，节奏是每秒一次（亮半秒、灭半秒）。

因为三颗灯完全同步翻转，看起来会是「三色一起亮、一起灭」。

6. 常见问题

Q1：烧录后灯不亮，或者一直常亮不闪？

先确认板子是不是 LQFP100_v2 版本，LED 引脚是不是 PA0/PA1/PA2。用错板子可能引脚对不上。
检查是不是烧录失败（程序没进去）。多数下载器会有下载成功提示。

Q2：我改成 PORT_ResetBits 想让灯更亮，结果灯灭了？

记住板载 LED 是低电平点亮。ResetBits（拉低）才是点亮，SetBits（拉高）是熄灭。别被函数名带偏了。

Q3：Ddl_Delay1ms 延时不准，比预期慢/快？

这个延时依赖系统时钟频率。如果你没调用时钟初始化、系统跑在默认的内部 RC 时钟上，延时就会偏。本例没调 BSP_CLK_Init()，跑在上电默认时钟，节奏大致对但不精确，做闪灯完全够用。

Q4：三颗灯我只想让一颗闪，怎么改？

把主循环里另外两句 LEDx_TOGGLE() 注释掉即可。

7. 小结

GPIO 输出三步走：清零结构体 → enPinMode = Pin_Mode_Out → PORT_Init。
PORT_SetBits 拉高、PORT_ResetBits 拉低、PORT_Toggle 翻转。
开发板 LED 低电平点亮，拉低才亮。
Ddl_Delay1ms 是简单的阻塞延时，入门够用，项目里少用。

8. 拓展应用

掌握了「控制一根引脚输出」，你已经能做出一堆小东西：

呼吸灯：把 Toggle + 固定延时改成「快速开关 + 调占空比」，就是软件 PWM，能让 LED 由暗到亮渐变。（更专业的做法是用定时器硬件 PWM，见 Timer0 章节）
交通灯：三颗灯按红→绿→黄的顺序和不同时长点亮，就是一个红绿灯模型。
蜂鸣器报警：把 LED 换成有源蜂鸣器，Toggle 就能让它「滴滴」响。
继电器控制：引脚接三极管驱动继电器，就能用单片机开关 220V 的电器（注意强电安全）。
状态指示灯：项目里最实用——用不同的闪烁频率表示「正常运行 / 出错 / 联网中」等状态。

HC32 QSPI Flash 读写 — 擦除、页写与映射读回校验

Wed, 09 Sep 2026 09:00:00 +0800

QSPI Flash 读写：擦除、页写与映射读回校验

源码路径：example/HC32F460JEUA/5.qspi/qspi_four_wire_io_fast_read/source/main.c

1. 功能简介

这个例子演示完整的外部 Flash 读写流程，也就是「给单片机外挂的硬盘存东西、再读出来核对」。

程序逻辑：

初始化 QSPI，默认配成四线快速读模式。
主循环里等你按下按键。
按键一按下，执行一整套 Flash 操作：
- 切到标准（单线）模式 → 擦除一个 4KB 扇区 → 把一句话写进去
- 切回四线模式 → 通过映射地址 0x98000000 像读数组一样把数据读回来
- 用 memcmp 对比写进去的和读出来的是否一致
- 一致亮绿灯，不一致亮红灯
地址往后挪 4KB，等你下次按键，测下一个扇区。

写进去的内容是这句话：

`1`	`char txBuffer[] = "QSPI read and write flash example: Welcome to use HDSC micro chip";`

每按一次按键，就测试一个新扇区。这样连续按下去，可以逐个扇区把整片 Flash 都验一遍——这就是 Flash 老化测试/出厂检测的雏形。

2. 硬件准备

用 HC32F460JEUA KIT 开发板，板载已经焊好了 QSPI Flash 芯片（W25Qxx 系列，8MB），六根线都接好了，无需接线。

        HC32F460                        QSPI Flash (W25Q64)
      ┌───────────┐                    ┌──────────────────┐
      │ PB14 QSPCK├───────────────────▶│ CLK              │
      │ PB1  QSNSS├───────────────────▶│ /CS   （片选）    │
      │ PB13 QSIO0├◀──────────────────▶│ DI/IO0           │
      │ PB12 QSIO1├◀──────────────────▶│ DO/IO1           │
      │ PB10 QSIO2├◀──────────────────▶│ /WP·IO2          │
      │ PB2  QSIO3├◀──────────────────▶│ /HOLD·IO3        │
      └───────────┘                    └──────────────────┘
                                          容量 8MB (0x800000)

注意 IO2、IO3 在单线 SPI 模式下是 /WP（写保护）和 /HOLD 脚，在四线模式下才变成数据线——这也是为什么四线模式需要额外配置。

还要用到：

按键 K1（PC13）：触发测试
红/绿 LED（PA0/PA1）：显示测试结果

3. 完整代码

#include "hc32_ddl.h"

/* ---------- QSPI 六根引脚定义 ---------- */
#define QSPCK_PORT   (PortB)   /* 时钟   */
#define QSPCK_PIN    (Pin14)
#define QSNSS_PORT   (PortB)   /* 片选   */
#define QSNSS_PIN    (Pin01)
#define QSIO0_PORT   (PortB)   /* 数据0  */
#define QSIO0_PIN    (Pin13)
#define QSIO1_PORT   (PortB)   /* 数据1  */
#define QSIO1_PIN    (Pin12)
#define QSIO2_PORT   (PortB)   /* 数据2  */
#define QSIO2_PIN    (Pin10)
#define QSIO3_PORT   (PortB)   /* 数据3  */
#define QSIO3_PIN    (Pin02)

/* QSPI 映射到系统地址空间的基地址 —— 读 Flash 就靠它 */
#define QSPI_BUS_ADDRESS            (0x98000000ul)

/* ---------- Flash 参数 ---------- */
#define FLASH_PAGE_SIZE             (0x100u)     /* 页 = 256 字节（写的最大单位）*/
#define FLASH_SECTOR_SIZE           (0x1000u)    /* 扇区 = 4096 字节（擦的最小单位）*/
#define FLASH_MAX_ADDR              (0x800000ul) /* 容量 8MB */
#define FLASH_DUMMY_BYTE_VALUE      (0xffu)
#define FLASH_BUSY_BIT_MASK         (0x01u)      /* 状态寄存器 bit0 = 忙碌位 */

/* ---------- Flash 标准指令码 ---------- */
#define FLASH_INSTR_WRITE_ENABLE      (0x06u)   /* 写使能 */
#define FLASH_INSTR_PAGE_PROGRAM      (0x02u)   /* 页写 */
#define FLASH_INSTR_ERASE_4KB_SECTOR  (0x20u)   /* 擦除 4KB 扇区 */
#define FLASH_INSTR_ERASE_CHIP        (0xC7u)   /* 全片擦除 */
#define FLASH_INSTR_READ_SR1          (0x05u)   /* 读状态寄存器1 */
#define FLASH_INSTR_READ_SR2          (0x35u)
#define FLASH_INSTR_READ_SR3          (0x15u)

/*==============================================================
 * QSPI 初始化
 *=============================================================*/
void QspiFlash_Init(void)
{
    stc_qspi_init_t stcQspiInit;
    MEM_ZERO_STRUCT(stcQspiInit);

    /* 开 QSPI 外设时钟 */
    PWC_Fcg1PeriphClockCmd(PWC_FCG1_PERIPH_QSPI, Enable);

    /* 六根引脚全部复用为 QSPI 功能 */
    PORT_SetFunc(QSPCK_PORT, QSPCK_PIN, Func_Qspi, Disable);
    PORT_SetFunc(QSNSS_PORT, QSNSS_PIN, Func_Qspi, Disable);
    PORT_SetFunc(QSIO0_PORT, QSIO0_PIN, Func_Qspi, Disable);
    PORT_SetFunc(QSIO1_PORT, QSIO1_PIN, Func_Qspi, Disable);
    PORT_SetFunc(QSIO2_PORT, QSIO2_PIN, Func_Qspi, Disable);
    PORT_SetFunc(QSIO3_PORT, QSIO3_PIN, Func_Qspi, Disable);

    /* ---------- 填 QSPI 配置 ---------- */
    stcQspiInit.enClkDiv            = QspiHclkDiv3;      /* QSPI 时钟 = HCLK/3 */
    stcQspiInit.enSpiMode           = QspiSpiMode3;      /* SPI 模式 3 */
    stcQspiInit.enBusCommMode       = QspiBusModeRomAccess; /* ROM 映射访问模式 */
    stcQspiInit.enPrefetchMode      = QspiPrefetchStopComplete;
    stcQspiInit.enPrefetchFuncEn    = Disable;           /* 预取功能关闭 */
    stcQspiInit.enQssnValidExtendTime  = QspiQssnValidExtendSck32;
    stcQspiInit.enQssnIntervalTime     = QspiQssnIntervalQsck8;
    stcQspiInit.enQsckDutyCorr         = QspiQsckDutyCorrHalfHclk;
    stcQspiInit.enVirtualPeriod         = QspiVirtualPeriodQsck6; /* 空周期(dummy) */
    stcQspiInit.enWpPinLevel            = QspiWpPinOutputHigh;    /* WP 脚输出高 */
    stcQspiInit.enQssnSetupDelayTime    = QspiQssnSetupDelay1Dot5Qsck;
    stcQspiInit.enQssnHoldDelayTime     = QspiQssnHoldDelay1Dot5Qsck;
    stcQspiInit.enFourByteAddrReadEn    = Disable;       /* 用 3 字节地址 */
    stcQspiInit.enAddrWidth             = QspiAddressByteThree;

    /* 通信协议：读用四线 IO，指令/地址/接收都走扩展 SPI */
    stcQspiInit.stcCommProtocol.enReadMode           = QspiReadModeFourWiresIO;
    stcQspiInit.stcCommProtocol.enTransInstrProtocol = QspiProtocolExtendSpi;
    stcQspiInit.stcCommProtocol.enTransAddrProtocol  = QspiProtocolExtendSpi;
    stcQspiInit.stcCommProtocol.enReceProtocol       = QspiProtocolExtendSpi;

    /* ROM 访问时硬件自动发的读指令 */
    stcQspiInit.u8RomAccessInstr = QSPI_3BINSTR_FOUR_WIRES_IO_READ;

    QSPI_Init(&stcQspiInit);
}

/*==============================================================
 * 写使能 —— 每次写/擦之前必须发一次
 *=============================================================*/
void QspiFlash_WriteEnable(void)
{
    QSPI_EnterDirectCommMode();                            /* 进直通模式 */
    QSPI_WriteDirectCommValue(FLASH_INSTR_WRITE_ENABLE);   /* 发 0x06 */
    QSPI_ExitDirectCommMode();                             /* 退出 */
}

/*==============================================================
 * 等待 Flash 内部操作完成（轮询忙碌位）
 *=============================================================*/
en_result_t QspiFlash_WaitForWriteEnd(void)
{
    en_result_t enRet = Ok;
    uint8_t  u8Status = 0u;
    uint32_t u32Timeout;
    stc_clk_freq_t stcClkFreq;

    /* 用系统时钟频率算一个超时上限，防止死等 */
    CLK_GetClockFreq(&stcClkFreq);
    u32Timeout = stcClkFreq.sysclkFreq / 1000u;

    QSPI_EnterDirectCommMode();
    QSPI_WriteDirectCommValue(FLASH_INSTR_READ_SR1);   /* 发读状态寄存器1指令 */
    do
    {
        u8Status = QSPI_ReadDirectCommValue();         /* 不停读回状态 */
        u32Timeout--;
    } while ((u32Timeout != 0u) &&
             ((u8Status & FLASH_BUSY_BIT_MASK) == FLASH_BUSY_BIT_MASK)); /* bit0=1 表示忙 */

    if (FLASH_BUSY_BIT_MASK == u8Status)
    {
        enRet = ErrorTimeout;      /* 超时了还在忙 → 报超时 */
    }
    QSPI_ExitDirectCommMode();

    return enRet;
}

/*==============================================================
 * 页写：往指定地址写最多 256 字节
 *=============================================================*/
en_result_t QspiFlash_WritePage(uint32_t u32Addr, const uint8_t pData[], uint16_t len)
{
    en_result_t enRet = Ok;
    uint16_t u16Index = 0u;

    /* 参数合法性检查：地址越界 / 空指针 / 超过一页 */
    if ((u32Addr > FLASH_MAX_ADDR) || (NULL == pData) || (len > FLASH_PAGE_SIZE))
    {
        enRet = Error;
    }
    else
    {
        QspiFlash_WriteEnable();                  /* ① 写使能 */

        QSPI_EnterDirectCommMode();               /* ② 进直通模式 */
        QSPI_WriteDirectCommValue(FLASH_INSTR_PAGE_PROGRAM);          /* 页写指令 0x02 */
        /* ③ 发 3 字节地址，从高位到低位 */
        QSPI_WriteDirectCommValue((uint8_t)((u32Addr & 0xFF0000ul) >> 16));
        QSPI_WriteDirectCommValue((uint8_t)((u32Addr & 0xFF00u) >> 8));
        QSPI_WriteDirectCommValue((uint8_t)(u32Addr & 0xFFu));
        /* ④ 逐字节发数据 */
        while (len--)
        {
            QSPI_WriteDirectCommValue(pData[u16Index]);
            u16Index++;
        }
        QSPI_ExitDirectCommMode();                /* ⑤ 退出直通模式，Flash 开始内部编程 */

        enRet = QspiFlash_WaitForWriteEnd();      /* ⑥ 等它写完 */
    }

    return enRet;
}

/*==============================================================
 * 擦除一个 4KB 扇区
 *=============================================================*/
en_result_t QspiFlash_Erase4KbSector(uint32_t u32Addr)
{
    en_result_t enRet = Ok;

    if (u32Addr >= FLASH_MAX_ADDR)
    {
        enRet = Error;
    }
    else
    {
        QspiFlash_WriteEnable();                  /* 擦除也要先写使能 */

        QSPI_EnterDirectCommMode();
        QSPI_WriteDirectCommValue(FLASH_INSTR_ERASE_4KB_SECTOR);   /* 0x20 */
        QSPI_WriteDirectCommValue((uint8_t)((u32Addr & 0xFF0000ul) >> 16));
        QSPI_WriteDirectCommValue((uint8_t)((u32Addr & 0xFF00u) >> 8));
        QSPI_WriteDirectCommValue((uint8_t)(u32Addr & 0xFFu));
        QSPI_ExitDirectCommMode();

        enRet = QspiFlash_WaitForWriteEnd();      /* 擦除比写更慢，一定要等 */
    }

    return enRet;
}

/*==============================================================
 * 全片擦除（慎用，几十秒级别）
 *=============================================================*/
void QspiFlash_EraseChip(void)
{
    QspiFlash_WriteEnable();
    QSPI_EnterDirectCommMode();
    QSPI_WriteDirectCommValue(FLASH_INSTR_ERASE_CHIP);   /* 0xC7 */
    QSPI_ExitDirectCommMode();
    QspiFlash_WaitForWriteEnd();
}

/*==============================================================
 * 读状态寄存器
 *=============================================================*/
uint8_t QspiFlash_ReadStatusRegister(uint8_t u8Reg)
{
    uint8_t regSta = 0u;

    QSPI_EnterDirectCommMode();
    QSPI_WriteDirectCommValue(u8Reg);          /* 发读状态指令 */
    regSta = QSPI_ReadDirectCommValue();       /* 读回一个字节 */
    QSPI_ExitDirectCommMode();

    return regSta;
}

/*==============================================================
 * 主函数
 *=============================================================*/
int32_t main(void)
{
    uint32_t flashAddr = 0u;          /* 当前测试的 Flash 地址 */
    uint8_t *pFlashReadAddr;          /* 指向映射地址的指针 */
    uint16_t bufferLen = 0u;
    char txBuffer[] = "QSPI read and write flash example: Welcome to use HDSC micro chip";
    stc_qspi_comm_protocol_t stcQspiCommProtocol;

    MEM_ZERO_STRUCT(stcQspiCommProtocol);

    /* BSP 初始化 */
    BSP_CLK_Init();
    BSP_LED_Init();
    BSP_KEY_Init();       /* 按键中断，按下后 u8GlobalKey = 1 */

    QspiFlash_Init();     /* QSPI 初始化 */

    bufferLen = (uint16_t)sizeof(txBuffer);   /* 要写的字节数（含结束符）*/

    while (1)
    {
        if (u8GlobalKey == 1)        /* 检测到按键按下 */
        {
            BSP_LED_Off(LED_RED);    /* 先熄灭两个指示灯 */
            BSP_LED_Off(LED_GREEN);

            /* ===== ① 切到标准（单线）模式，准备做写操作 ===== */
            stcQspiCommProtocol.enReadMode = QspiReadModeStandard;
            QSPI_CommProtocolConfig(&stcQspiCommProtocol);

            /* ===== ② 擦除这个扇区（先擦后写铁律）===== */
            QspiFlash_Erase4KbSector(flashAddr);

            /* ===== ③ 把字符串写进去 ===== */
            QspiFlash_WritePage(flashAddr, (uint8_t*)&txBuffer[0], bufferLen);

            /* ===== ④ 切回四线快速读模式 ===== */
            stcQspiCommProtocol.enReadMode = QspiReadModeFourWiresIO;
            QSPI_CommProtocolConfig(&stcQspiCommProtocol);

            /* ===== ⑤ 关键：算出映射地址，用指针直接读！===== */
            pFlashReadAddr = (uint8_t *)((uint32_t)QSPI_BUS_ADDRESS + flashAddr);

            /* ===== ⑥ 校验：内存里的原文 vs Flash 里读回来的 ===== */
            if (memcmp(txBuffer, pFlashReadAddr, (uint32_t)bufferLen) != 0)
            {
                BSP_LED_On(LED_RED);      /* 不一致 → 红灯：失败 */
            }
            else
            {
                BSP_LED_On(LED_GREEN);   /* 一致 → 绿灯：成功 */
            }

            /* ===== ⑦ 地址往后挪一个扇区，下次按键测下一块 ===== */
            flashAddr += FLASH_SECTOR_SIZE;
            if (flashAddr >= FLASH_MAX_ADDR)
            {
                flashAddr = 0u;          /* 到顶了从头再来 */
            }

            u8GlobalKey = 0;             /* 清按键标志 */
        }
    }
}

4. 代码分段讲解

4.1 最精彩的一行：映射读

1
2

pFlashReadAddr = (uint8_t *)((uint32_t)QSPI_BUS_ADDRESS + flashAddr);
memcmp(txBuffer, pFlashReadAddr, bufferLen);

这两行是整个例子的灵魂，也是 QSPI 相对普通 SPI 的最大优势。

memcmp 直接把 pFlashReadAddr 当普通内存指针来读——没有任何「发指令、等数据」的代码。因为 QSPI 配在了 ROM 映射模式，硬件在后台自动完成了发送四线读指令、接收数据的全过程。

对程序员来说，8MB 的外部 Flash 就变成了从 0x98000000 开始的一个大数组。想读哪里读哪里，*p、p[i]、memcpy、strcmp 全都能直接用。

4.2 为什么写之前要切成标准模式

1
2

stcQspiCommProtocol.enReadMode = QspiReadModeStandard;   // 写之前切单线
QSPI_CommProtocolConfig(&stcQspiCommProtocol);

原因：四线模式下 IO2/IO3 被当成数据线，但在单线 SPI 模式下它们是 /WP（写保护）和 /HOLD 脚。写操作的指令序列（写使能、页写）是标准单线 SPI 协议，切成标准模式最稳妥、兼容性最好。

写完之后再切回四线，享受读的高速。这个「写用单线、读用四线」的切换是 QSPI Flash 的常规操作。

4.3 三字节地址的拆分

1
2
3

QSPI_WriteDirectCommValue((uint8_t)((u32Addr & 0xFF0000ul) >> 16));  // 高字节
QSPI_WriteDirectCommValue((uint8_t)((u32Addr & 0xFF00u) >> 8));      // 中字节
QSPI_WriteDirectCommValue((uint8_t)(u32Addr & 0xFFu));               // 低字节

Flash 指令要求地址按字节、从高位到低位依次发送。3 字节地址能表示 2²⁴ = 16MB，够用 8MB 的 Flash。

容量超过 16MB 的 Flash（如 W25Q256，32MB）就需要 4 字节地址模式，代码里的 enFourByteAddrReadEn 就是控制这个的。

4.4 忙碌等待与超时保护

u32Timeout = stcClkFreq.sysclkFreq / 1000u;   // 算个超时上限
do {
    u8Status = QSPI_ReadDirectCommValue();
    u32Timeout--;
} while ((u32Timeout != 0u) && ((u8Status & FLASH_BUSY_BIT_MASK) == FLASH_BUSY_BIT_MASK));

这里体现了工程化的思维：等待忙碌位清零，但不能无限等。万一 Flash 坏了或者没接好，忙碌位永远是 1，无超时保护的话程序就死在这儿了。

加了 u32Timeout 计数，等太久就返回 ErrorTimeout，让上层知道出了问题。所有等待硬件的循环都应该有超时保护，这是嵌入式代码健壮性的基本要求。

4.5 写操作的六步固定流程

看 QspiFlash_WritePage 的结构，Flash 写入永远是这六步：

① 写使能 (0x06)
② 进直通模式
③ 发页写指令 (0x02) + 3 字节地址
④ 逐字节发数据
⑤ 退出直通模式（此时 Flash 开始内部编程）
⑥ 轮询忙碌位，等编程完成

擦除也一样，只是第③步换成擦除指令、没有第④步。记住这个骨架，任何 SPI Flash 的驱动你都能自己写出来。

4.6 参数检查是好习惯

if ((u32Addr > FLASH_MAX_ADDR) || (NULL == pData) || (len > FLASH_PAGE_SIZE))
{
    enRet = Error;
}

三个检查分别防：地址越界、空指针、超过一页。这就是「防御式编程」——外部 Flash 操作出错很难查（数据默默写错了，现象要很久才暴露），提前挡住非法参数能省下大量调试时间。

5. 实验现象

上电后两个 LED 都不亮，程序在主循环等按键。
按一下 K1：红绿灯先熄灭（表示开始测试），随后
- 绿灯亮 → 这个扇区读写校验通过 ✓
- 红灯亮 → 校验失败 ✗
再按一下 K1：测试下一个 4KB 扇区，地址自动 +0x1000。
一直按下去，会把整片 8MB Flash 逐扇区测完，然后地址回绕到 0 重新开始。

正常情况应该每次都是绿灯。

6. 常见问题

Q1：一直是红灯（校验失败）？ 按顺序排查：

擦除是不是没成功？ Flash 必须先擦后写。可以先用 QspiFlash_ReadStatusRegister(0x05) 读状态确认操作正常。
写入长度超过 256 字节了吗？ 例子里字符串是 66 字节，没问题。但你换成更长的数据就会超页，WritePage 会直接返回 Error，数据根本没写进去。
QSPI 时钟太快？ 试着把 enClkDiv 从 QspiHclkDiv3 改大（如 QspiHclkDiv4），降速能排除信号质量问题。
空周期（dummy cycle）配错？ 四线快速读需要一定的空周期让 Flash 准备数据。enVirtualPeriod 配少了会读到垃圾。不同型号 Flash 要求的空周期数不同，查芯片手册。

Q2：读回来全是 0xFF？

0xFF 是 Flash 擦除后的初始值。说明擦除成功了但写入失败了。重点查写使能有没有发、页写指令和地址对不对。

Q3：读回来全是 0x00 或随机值？

说明读的链路有问题。检查 QSPI 六根引脚复用配全了没（尤其 IO2/IO3，漏配就是四线模式失败的典型原因）。
检查映射基地址 0x98000000 是否写对。

Q4：程序卡在 WaitForWriteEnd 里？

Flash 没响应，忙碌位读不到。检查片选（QSNSS/PB1）和时钟（QSPCK/PB14）的连接。
好消息是代码有超时保护，最终会返回 ErrorTimeout 而不是真死机。

Q5：为什么擦除比写慢那么多？

Flash 物理特性决定的。擦除一个 4KB 扇区典型 50~300ms，页写只要 1~3ms。所以能避免擦除就避免——这也是「日志式写入」（每次往新地址追加，不覆盖旧数据）在 Flash 上很流行的原因。

Q6：能不能不擦除直接改一个字节？

不能。Flash 写入只能把 1 变 0，不能把 0 变 1。想改必须整个 4KB 扇区先擦除。标准做法：读出 4KB → 内存里改 → 擦除 → 写回。

7. 小结

QSPI 的杀手级能力是 ROM 映射：Flash 变成 0x98000000 开始的大数组，用指针直接读。
写用标准（单线）模式，读用四线模式，中间用 QSPI_CommProtocolConfig 切换。
Flash 写入六步骨架：写使能 → 进直通 → 发指令+地址 → 发数据 → 退直通 → 等完成。
铁律：先擦后写、擦 4KB 为单位、写 ≤ 256 字节/页。
所有等硬件的循环都要有超时保护。
校验用 memcmp，这是验证存储器最直接的方法。

8. 拓展应用

有了 8MB 外部 Flash，能做的事一下子多了很多：

中文字库存储：完整的 GB2312 汉字点阵字库约 260KB，内部 Flash 装不下但外部 Flash 轻松容纳。配合 LCD 就能显示任意汉字（见 SPI LCD 章节）。
图片 / 图标资源：GUI 界面的位图、开机 Logo、动画帧全放外部 Flash，靠映射地址直接读，LCD_DrawBitmap((uint16_t*)0x98010000, ...) 一行显示。
数据记录仪 / 黑匣子：传感器数据按时间顺序追加写入 Flash，断电不丢。8MB 能存几十万条记录。工业设备的运行日志都这么做。
音频播放：把 WAV / ADPCM 音频存进 Flash，配合 DAC 或 I2S 播放语音提示、报警音。
OTA 固件升级：新固件先通过串口/WiFi 下载到外部 Flash 暂存，校验通过后再搬到内部 Flash 覆盖旧程序。这是所有联网设备升级的标准方案，外部 Flash 是必备的「中转站」。
参数掉电保存：设备的配置参数（校准值、用户设置）存 Flash，比 EEPROM 容量大得多。注意做磨损均衡（轮流写不同扇区），因为 Flash 擦写寿命约 10 万次。
文件系统：移植 LittleFS 或 FatFS 到外部 Flash 上，就能像操作电脑硬盘一样 fopen/fwrite 管理文件，代码组织清爽很多。
XIP（就地执行）：高级玩法——把部分代码放外部 Flash 直接运行，突破内部 Flash 容量限制。

HC32 SD 卡读写 — 擦除、写入与读回校验

Wed, 09 Sep 2026 09:00:00 +0800

SD 卡读写：擦除、写入与读回校验

源码路径：example/HC32F460JEUA/6.sdioc/sd_multi_write_multi_read_4bit_50mhz/source/main.c

1. 功能简介

这个例子做的是一次完整的 SD 卡读写自检，就像出厂测试程序一样，一步步验证卡到底能不能正常用。

程序流程（上电自动跑一遍，不需要按键）：

初始化 SD 卡：4 线总线 + 50MHz 高速模式。
擦除从第 0 个扇区开始的 4 个扇区。
读回来检查擦除结果：擦除后的数据应该全是 0xFFFFFFFF 或 0x00000000（不同卡的擦除填充值不同）。如果不是，说明擦除没成功。
写入数据：往这 4 个扇区写入 0、1、2、3……递增的数字（这种「有规律的数据」最容易看出错在哪）。
再读回来。
用 memcmp 比对写进去的和读出来的。
全部通过亮绿灯，任何一步失败亮红灯，然后进死循环。

只要看到绿灯，就说明「SD 卡插好了、驱动没问题、读写都正常」。这是玩 SD 卡的第一步——先把底层通道验通，再谈上面的文件系统。

2. 硬件准备

用 HC32F460JEUA KIT 开发板，板载有 TF 卡（microSD）卡座，插卡即用。

        HC32F460                          TF / SD 卡座
      ┌───────────┐                     ┌──────────────┐
      │ PB15  CK  ├────────────────────▶│ CLK          │
      │ PA6   CMD ├◀───────────────────▶│ CMD          │
      │ PB4   D0  ├◀───────────────────▶│ DAT0         │
      │ PA8   D1  ├◀───────────────────▶│ DAT1         │
      │ PA9   D2  ├◀───────────────────▶│ DAT2         │
      │ PB5   D3  ├◀───────────────────▶│ DAT3 / CS    │
      │ PH2   CD  ├◀────────────────────│ 卡检测（可选）│
      └───────────┘                     └──────────────┘
                                            3.3V 供电

准备工作：

一张 TF / microSD 卡（建议 8GB 或 16GB 的正品卡，容量太大或杂牌卡容易初始化失败）。
卡插到底、听到「咔」的一声。

⚠️ 重要警告 这个程序会擦除并覆写 SD 卡第 0~3 号扇区！ **第 0 号扇区就是 MBR（主引导记录），存着分区表。**覆写它等于把卡「格式化坏了」——插到电脑上会提示「需要格式化」。 千万别用存着重要资料的卡跑这个例子！ 用一张空白的测试卡。测完想恢复正常使用，在电脑上重新格式化一次就好。

3. 完整代码

#include "sd_card.h"              // SD 卡驱动库（内部已包含 hc32_ddl.h）

/* ---------- SDIOC 引脚定义 ---------- */
#define SDIOC_CD_PORT    (PortH)  /* 卡检测（本例未启用）*/
#define SDIOC_CD_PIN     (Pin02)

#define SDIOC_CK_PORT    (PortB)  /* 时钟 */
#define SDIOC_CK_PIN     (Pin15)

#define SDIOC_CMD_PORT   (PortA)  /* 命令线 */
#define SDIOC_CMD_PIN    (Pin06)

#define SDIOC_D0_PORT    (PortB)  /* 数据线 0 */
#define SDIOC_D0_PIN     (Pin04)
#define SDIOC_D1_PORT    (PortA)  /* 数据线 1 */
#define SDIOC_D1_PIN     (Pin08)
#define SDIOC_D2_PORT    (PortA)  /* 数据线 2 */
#define SDIOC_D2_PIN     (Pin09)
#define SDIOC_D3_PORT    (PortB)  /* 数据线 3 */
#define SDIOC_D3_PIN     (Pin05)

/* 测试范围：从第 0 个扇区开始，共 4 个扇区 */
#define SD_SECTOR_START  (0u)
#define SD_SECTOR_COUNT  (4u)

/* 用 SDIOC 单元 1 */
#define SDIOC_UNIT       (M4_SDIOC1)

/*==============================================================
 * 把 7 根引脚全部复用为 SDIO 功能
 *=============================================================*/
static en_result_t SdiocInitPins(void)
{
    PORT_SetFunc(SDIOC_D0_PORT,  SDIOC_D0_PIN,  Func_Sdio, Disable);
    PORT_SetFunc(SDIOC_D1_PORT,  SDIOC_D1_PIN,  Func_Sdio, Disable);
    PORT_SetFunc(SDIOC_D2_PORT,  SDIOC_D2_PIN,  Func_Sdio, Disable);
    PORT_SetFunc(SDIOC_D3_PORT,  SDIOC_D3_PIN,  Func_Sdio, Disable);
//  PORT_SetFunc(SDIOC_CD_PORT,  SDIOC_CD_PIN,  Func_Sdio, Disable);  /* 卡检测未用 */
    PORT_SetFunc(SDIOC_CK_PORT,  SDIOC_CK_PIN,  Func_Sdio, Disable);
    PORT_SetFunc(SDIOC_CMD_PORT, SDIOC_CMD_PIN, Func_Sdio, Disable);

    return Ok;
}

/*==============================================================
 * 主函数
 *=============================================================*/
int32_t main(void)
{
    uint32_t i;
    en_result_t enTestResult = Ok;                 /* 测试结果累积标志 */

    static stc_sd_handle_t stcSdhandle;            /* SD 卡句柄 */

    /* 写缓冲区：512 个 uint32_t = 2048 字节 = 正好 4 个扇区（4×512）*/
    static uint32_t au32WriteBlocks[512];
    /* 读缓冲区：和写缓冲区一样大 */
    static uint32_t au32ReadBlocks[ARRAY_SZ(au32WriteBlocks)];

    /* SD 卡初始化配置：4 线、50MHz、高速模式、不用 DMA */
    stc_sdcard_init_t stcCardInitCfg =
    {
        SdiocBusWidth4Bit,       /* 4 位总线宽度 */
        SdiocClk50M,             /* 50MHz 时钟 */
        SdiocHighSpeedMode,      /* 高速模式 */
        NULL,                    /* DMA 配置为空 → 用轮询方式传输 */
    };

    /* 准备写入的数据：填 0,1,2,3,... 递增值，方便看出错在哪一位 */
    for (i = 0u; i < ARRAY_SZ(au32WriteBlocks); i++)
    {
        au32WriteBlocks[i] = i;
    }

    MEM_ZERO_STRUCT(au32ReadBlocks);      /* 读缓冲区清零 */

    /* BSP 初始化 */
    BSP_CLK_Init();
    BSP_LED_Init();

    /* 关掉 JTAG 调试脚复用（TDI/TDO/TRST 和 SDIOC 引脚有冲突）*/
    PORT_DebugPortSetting(TDI, Disable);
    PORT_DebugPortSetting(TDO_SWO, Disable);
    PORT_DebugPortSetting(TRST, Disable);

    SdiocInitPins();                       /* 配置 SDIOC 引脚 */

    /* ===== ① 初始化 SD 卡 ===== */
    stcSdhandle.SDIOCx = SDIOC_UNIT;
    if (Ok != SDCARD_Init(&stcSdhandle, &stcCardInitCfg))
    {
        enTestResult = Error;
    }

    /* ===== ② 擦除 4 个扇区（超时给 20000）===== */
    if (Ok != SDCARD_Erase(&stcSdhandle, SD_SECTOR_START, SD_SECTOR_COUNT, 20000u))
    {
        enTestResult = Error;
    }

    /* ===== ③ 读回来，验证擦除是否真的成功 ===== */
    if (Ok != SDCARD_ReadBlocks(&stcSdhandle, SD_SECTOR_START, SD_SECTOR_COUNT,
                                (uint8_t *)au32ReadBlocks, 2000u))
    {
        enTestResult = Error;
    }

    /* 擦除后每个字应该是全 F 或全 0（不同卡的填充值不一样，两种都算合格）*/
    for (i = 0u; i < ARRAY_SZ(au32WriteBlocks); i++)
    {
        if ((au32ReadBlocks[i] != 0xFFFFFFFFul) &&
            (au32ReadBlocks[i] != 0x00000000ul))
        {
            enTestResult = Error;
            break;
        }
    }

    /* ===== ④ 写入数据 ===== */
    if (Ok != SDCARD_WriteBlocks(&stcSdhandle, SD_SECTOR_START, SD_SECTOR_COUNT,
                                 (uint8_t *)au32WriteBlocks, 2000u))
    {
        enTestResult = Error;
    }

    /* ===== ⑤ 再读回来 ===== */
    if (Ok != SDCARD_ReadBlocks(&stcSdhandle, SD_SECTOR_START, SD_SECTOR_COUNT,
                                (uint8_t *)au32ReadBlocks, 20000u))
    {
        enTestResult = Error;
    }

    /* ===== ⑥ 比对写进去的和读出来的 ===== */
    if (0 != memcmp(au32WriteBlocks, au32ReadBlocks, sizeof(au32ReadBlocks)))
    {
        enTestResult = Error;
    }

    /* ===== ⑦ 用 LED 显示最终结果 ===== */
    if (Ok == enTestResult)
    {
        BSP_LED_On(LED_GREEN);    /* 全部通过 → 绿灯 */
    }
    else
    {
        BSP_LED_On(LED_RED);      /* 有任何一步失败 → 红灯 */
    }

    while (1)
    {
        /* 测完就停在这里 */
    }
}

4. 代码分段讲解

4.1 缓冲区大小和扇区数必须严格对应

1
2

static uint32_t au32WriteBlocks[512];   // 512 × 4 字节 = 2048 字节
#define SD_SECTOR_COUNT   (4u)          // 4 × 512 字节 = 2048 字节  ✓ 相等

这是 SD 卡编程的第一要点。SD 卡按 512 字节扇区读写，你要读 4 个扇区，缓冲区就必须至少有 4×512 = 2048 字节。

这里 uint32_t[512] 刚好是 2048 字节，完美对应。

如果你改成读 8 个扇区却不改数组大小，SDCARD_ReadBlocks 会往数组外面写 2048 字节——栈/内存直接被踩坏，程序表现会极其诡异（随机崩溃、其他变量莫名变化）。这种 bug 非常难查，所以两个数字一定要一起改。

安全的写法是让扇区数从数组大小推导出来：

`1`	`#define SD_SECTOR_COUNT (sizeof(au32WriteBlocks) / 512u)`

4.2 为什么要关掉 JTAG 调试脚

1
2
3

PORT_DebugPortSetting(TDI, Disable);
PORT_DebugPortSetting(TDO_SWO, Disable);
PORT_DebugPortSetting(TRST, Disable);

芯片刚上电时，一部分引脚默认是 JTAG 调试功能（TDI、TDO、TRST）。而 SDIOC 用到的 PA8、PA9、PB4 这些引脚，正好和 JTAG 脚有复用冲突。

不关掉的话，你 PORT_SetFunc 设成 SDIO 功能也不生效——引脚还被 JTAG 占着。这就是「代码看着完全正确但外设死活不工作」的又一个经典原因。

注意关掉这些脚会影响 JTAG 调试（SWD 调试不受影响，因为 SWD 只用 SWCLK/SWDIO）。所以正常用 SWD 下载调试没问题。

4.3 错误累积的写法

en_result_t enTestResult = Ok;

if (Ok != SDCARD_Init(...))  { enTestResult = Error; }
if (Ok != SDCARD_Erase(...)) { enTestResult = Error; }
...
if (Ok == enTestResult) { 绿灯 } else { 红灯 }

注意这里的设计：每一步失败都只是标记一下，不立刻退出，最后统一看结果。

好处是不管中间哪一步出错，最终都会有明确的 LED 指示。缺点是初始化失败后还会继续跑后面的读写（这些必然也失败），有点浪费。

工程实践中更常见的写法是失败立即返回（early return），或者用 goto error_handler 跳到统一的错误处理。这样逻辑更清晰、也不会在坏状态下继续操作硬件。

4.4 擦除后的验证很有讲究

if ((au32ReadBlocks[i] != 0xFFFFFFFFul) &&
    (au32ReadBlocks[i] != 0x00000000ul))
{
    enTestResult = Error;
}

为什么要接受两种值？因为 SD 卡擦除后的填充值不是统一标准——有的卡擦成全 1（0xFF），有的卡擦成全 0（0x00）。这取决于卡内部控制器的实现。

所以代码宽容地认为「全 F 或全 0 都算擦干净了」。这是很实用的兼容性处理，说明写代码的人真正踩过不同品牌卡的坑。

4.5 用递增数据做测试的妙处

for (i = 0u; i < ARRAY_SZ(au32WriteBlocks); i++)
{
    au32WriteBlocks[i] = i;      // 0, 1, 2, 3, 4, ...
}

为什么不用随机数、不用全 0？因为递增序列是最好的调试数据：

如果读回来的是 0,1,2,3,... 但从中间某处开始错乱，你一眼就能看出错在第几个字。
如果整体偏移了（读回来是 128,129,130...），说明起始扇区算错了。
如果每 128 个字重复一次，说明扇区边界处理有问题。

用全 0 或全 F 就完全看不出这些规律。测试存储器一定要用有规律但不重复的数据，这是个很实用的技巧。

4.6 超时参数为什么不一样

SDCARD_Erase(..., 20000u);       // 擦除给 20000
SDCARD_ReadBlocks(..., 2000u);   // 读给 2000
SDCARD_WriteBlocks(..., 2000u);  // 写给 2000
SDCARD_ReadBlocks(..., 20000u);  // 这次读又给 20000

因为不同操作耗时差异很大：擦除 » 写 > 读。擦除是 SD 卡最慢的操作，超时必须给得宽松，否则明明在正常工作却被判超时失败。

（代码里两次读的超时值不一致，属于示例的随意之处，实际用统一给足即可。）

4.7 `ARRAY_SZ` 和 `MEM_ZERO_STRUCT`

这两个是 ddl 库的实用宏：

1
2

ARRAY_SZ(arr)          // 求数组元素个数 = sizeof(arr)/sizeof(arr[0])
MEM_ZERO_STRUCT(x)     // 把 x 清零 = memset(&x, 0, sizeof(x))

用 ARRAY_SZ 而不是写死 512，是好习惯——以后改数组大小，循环次数自动跟着变，不会漏改。

5. 实验现象

插好 TF 卡，上电或复位：

绿灯亮 → 全部测试通过 ✓（初始化 OK、擦除 OK、写入 OK、读回数据完全一致）
红灯亮 → 某一步失败 ✗

程序跑完就停在 while(1)，灯的状态保持不变。想再测一次就按复位键。

测试完成后，这张卡的第 0~3 扇区已经被写成递增数据了。插到电脑上会提示「需要格式化」——这是正常的，因为 MBR 被覆盖了。重新格式化即可恢复。

6. 常见问题

Q1：一直红灯，怎么定位到底哪一步失败？ 最有效的办法是加串口打印。先初始化串口，然后：

DDL_PrintfInit(BSP_PRINTF_DEVICE, BSP_PRINTF_BAUDRATE, BSP_PRINTF_PortInit);

if (Ok != SDCARD_Init(&stcSdhandle, &stcCardInitCfg))
{
    printf("SDCARD_Init failed!\r\n");
    enTestResult = Error;
}
if (Ok != SDCARD_Erase(...))
{
    printf("Erase failed!\r\n");
    enTestResult = Error;
}
// ... 每一步都加

这样串口助手里直接告诉你卡在哪儿。这就是串口章节说的「打印大法」的实战价值。

Q2：SDCARD_Init 就失败了？ 最常见，按顺序查：

卡插到底了吗？ 听到「咔」声才算到位。
PORT_DebugPortSetting 三行写了吗？ 漏了 JTAG 会占着 PA8/PA9 等引脚。
换张卡试试。 杂牌卡、容量特别大（64GB 以上 SDXC）的卡兼容性差，初始化协议可能不支持。建议用 8GB/16GB 正品 Class10 卡。
降速试试：把 SdiocClk50M 改成更低的时钟、SdiocHighSpeedMode 改成 SdiocNormalSpeedMode。50MHz 对信号质量要求高，杜邦线飞线基本跑不起来。
先用 1 线模式：SdiocBusWidth4Bit 改成 SdiocBusWidth1Bit。能通说明是 D1/D2/D3 那几根线的问题。

Q3：初始化过了，但擦除或读写失败？

超时给太小了。 试着把超时参数加大 10 倍。
降低时钟频率。速度越快越容易出错。
检查 D1/D2/D3 三根线（只有 4 线模式才用到它们，1 线模式下不影响初始化但影响读写）。

Q4：memcmp 比对失败，但读写函数都返回 Ok？

说明数据传输过程中出错了（信号质量问题）。降低时钟频率是第一手段。
也检查缓冲区大小和扇区数是否匹配（见 4.1）。

Q5：我的卡插上后电脑不认了！

这是预期行为，因为程序覆写了第 0 扇区（MBR）。在电脑上重新格式化即可恢复。
想避免破坏文件系统，把 SD_SECTOR_START 改成一个很大的值（比如 100000u），去测卡的中后段区域，就不会碰到 MBR 和文件系统的关键结构了。

Q6：怎么让读写更快？

用 DMA 版本。把 stcCardInitCfg 最后那个 NULL 换成 DMA 配置，CPU 就不用参与搬数据了。SDK 里有现成的 sd_multi_write_multi_read_4bit_dma_50mhz 示例。
一次多读几个扇区。读 100 个扇区比读 100 次单扇区快得多（命令开销省下来了）。

7. 小结

SD 卡按 512 字节扇区读写，缓冲区大小和扇区数必须严格对应，否则内存越界。
用 SDCARD_Init / Erase / WriteBlocks / ReadBlocks 四个函数，每个都带超时参数（擦除要给大）。
必须先关 JTAG 调试脚复用（PORT_DebugPortSetting），否则引脚被占用。
擦除后的值可能是全 F 或全 0，两种都要当成正常。
测存储器用递增数据，最容易定位错在哪。
出问题按这个顺序试：降时钟 → 换 1 线 → 换卡 → 加串口打印定位。
本例会覆写第 0 扇区（MBR），用测试卡，别用有重要数据的卡。

8. 拓展应用

底层通道验通之后，SD 卡真正的威力才开始：

移植 FatFS 文件系统（最重要的下一步）把 SDCARD_ReadBlocks / WriteBlocks 接到 FatFS 的 disk_read / disk_write 接口上，你就能这样写代码：
1 2 3

f_open(&file, "data.csv", FA_WRITE | FA_CREATE_ALWAYS); f_printf(&file, "%d,%d\r\n", time, temperature); f_close(&file);
生成的文件电脑能直接打开！ 这是 SD 卡最大的价值所在——数据不再是裸扇区，而是人能看懂的文件。
数据记录仪 / 数据采集器 传感器数据按时间戳存成 CSV 文件，拔卡插电脑，Excel 直接打开画曲线。温湿度记录、电池测试、振动监测都这么做。
黑匣子 / 运行日志 设备运行状态、错误码持续写入日志文件。出故障了把卡拔出来分析，比接串口盯着看实用得多。
音频播放器 WAV 文件存卡里，用 FatFS 读出 PCM 数据送给 DAC 或 I2S 功放，就是个音乐播放器。语音提示、报警音同理。
图片 / 界面资源加载 GUI 的图片、字库、皮肤存在卡里，需要时读出来显示。好处是改素材不用重新编译固件，换张卡就换了界面。
固件升级（OTA / 卡升级） 把新固件 .bin 放到卡里，设备上电时 Bootloader 检测到有升级文件就自动更新。这是工业设备最省事的升级方式——现场维护人员只需要插张卡。
配置文件 设备参数写成卡里的 config.txt，用户用记事本改改就能配置设备，不用专门做上位机软件。非常适合小批量产品。
摄像头存图 接个 OV2640 摄像头，拍照存成 JPG 到卡里，做个简易行车记录仪或监控。

HC32 SPI LCD 显示 — 文字输出与全屏刷色

Wed, 09 Sep 2026 09:00:00 +0800

SPI LCD 显示：文字输出与全屏刷色

源码路径：example/HC32F460JEUA/7.spi LCD/LCD 1.14inch/source/main.c 驱动库：midware/ST7789 1.14inch/tftlcd.c / tftlcd.h

1. 功能简介

这个例子让单片机在彩屏上「说话」，分两部分：

开机时显示四行文字信息（相当于一个开机画面）：

Boring_TECH
TFTLCD TEST 240*135
HC32F460
2022/6/20

然后进入主循环，做两件事循环往复：

三颗 LED 一起翻转
全屏刷成黑色 → 等 500ms → 全屏刷成青色，不断交替

全屏刷色看起来简单，其实是个很有用的性能测试：屏幕能多快刷完一整屏，直接决定了你以后做动画、做实时曲线会不会卡。240×240 个像素 = 57600 个像素 × 2 字节 = 115KB 数据，全靠 SPI 一个字节一个字节送过去。

学会这个例子，你就有了「显示」这个能力——之后所有的数据、菜单、曲线都能画到屏上。

2. 硬件准备

需要一块 ST7789 驱动的 1.14 寸 TFT 彩屏（240×135 分辨率），共 8 根线。

      HC32F460                        ST7789 LCD 模块
    ┌───────────┐                   ┌──────────────────┐
    │ PB6  SCK  ├──────────────────▶│ SCL / SCK  时钟   │
    │ PB7  MOSI ├──────────────────▶│ SDA / MOSI 数据   │
    │ PB8  DC   ├──────────────────▶│ DC   命令/数据选择 │
    │ PB9  RST  ├──────────────────▶│ RES  复位         │
    │ PB3  PWR  ├──────────────────▶│ BLK  背光         │
    │      3.3V ├──────────────────▶│ VCC              │
    │      GND  ├──────────────────▶│ GND              │
    └───────────┘                   └──────────────────┘

接线要点：

线	类型	注意
SCK (PB6)	SPI3 复用	时钟
MOSI (PB7)	SPI3 复用	只发不收，所以不用接 MISO
DC (PB8)	普通 GPIO	接错必花屏，最关键的一根
RST (PB9)	普通 GPIO	不接屏可能初始化不了
PWR/BLK (PB3)	普通 GPIO	不接屏是黑的，你会以为程序坏了
VCC	电源	必须 3.3V！接 5V 会烧屏
GND	地	必须共地

⚠️ 三个必踩的坑

VCC 一定接 3.3V，绝不能接 5V。这类小屏没有电平转换和稳压，5V 直接烧。

背光（BLK/PWR）没接或没点亮 → 屏一片漆黑。很多人以为程序没跑起来，其实内容画上去了只是看不见。

杜邦线要短。SPI 跑得快，线长了信号劣化会花屏。10cm 以内为宜。

板载 LED（PA0/PA1/PA2）用来指示程序在运行。

3. 完整代码

#include "hc32_ddl.h"
#include "tftlcd.h"                 // LCD 驱动库头文件

char str[50] = {0};                 // 备用字符串缓冲区（本例未使用）
uint8_t t;

int32_t main(void)
{
    /* ===== BSP 初始化 ===== */
    BSP_CLK_Init();                 // 系统时钟
    BSP_LED_Init();                 // LED
    BSP_KEY_Init();                 // 按键

    /* ===== LCD 初始化 ===== */
    LCD_Init();                     // 一句搞定：SPI 初始化 + 屏复位 + 寄存器配置 + 开背光

    LCD_Clear(BLACK);               // 整屏清成黑色

    /* ===== 设置画笔和背景色 ===== */
    BACK_COLOR  = BLACK;            // 背景色：黑
    POINT_COLOR = CYAN;             // 画笔色：青（文字就是这个颜色）

    /* ===== 显示四行文字 =====
     * 参数：(x起点, y起点, 显示区宽, 显示区高, 字体大小, 字符串)
     */
    LCD_ShowString(0,  0,  160, 12, 12, "Boring_TECH");
    LCD_ShowString(0,  15, 160, 12, 12, "TFTLCD TEST 240*135");
    LCD_ShowString(0,  30, 160, 16, 12, "HC32F460");
    LCD_ShowString(0,  45, 160, 12, 12, "2022/6/20");

    while (1)
    {
        /* 三颗 LED 一起翻转，指示程序在跑 */
        BSP_LED_Toggle(LED_RED);
        BSP_LED_Toggle(LED_GREEN);
        BSP_LED_Toggle(LED_BLUE);

        /* 全屏刷成黑色（会把上面的文字覆盖掉）*/
        LCD_Fill(0, 0, 240, 240, BLACK);

        Ddl_Delay1ms(500);          // 等 500 毫秒

        /* 全屏刷成青色 */
        LCD_Fill(0, 0, 240, 240, CYAN);
    }
}

4. 代码分段讲解

4.1 `LCD_Init()` 一句话干了一大堆事

`1`	`LCD_Init();`

这一行是驱动库封装的成果。它内部依次完成了：

开 SPI3 外设时钟：PWC_Fcg1PeriphClockCmd(PWC_FCG1_PERIPH_SPI3, Enable)
配置 SCK/MOSI 引脚复用为 Func_Spi3_Sck / Func_Spi3_Mosi
配置 DC/RST/PWR 三个引脚为普通 GPIO 输出
初始化 SPI3：三线模式、主机模式、时钟极性/相位、速度
硬件复位屏幕：LCD_RST(0) → 延时 → LCD_RST(1) → 延时
发送一长串 ST7789 初始化命令：设置像素格式（RGB565）、显示方向、伽马校正、电压参数、退出睡眠、开显示……
打开背光：LCD_PWR(1)

第 6 步那一串命令有几十行，都是 ST7789 数据手册里规定的固定套路。这也是为什么大家都用现成驱动库——这些寄存器值抄手册/例程就行，自己推没有意义。

想看细节就去读 midware/ST7789 1.14inch/tftlcd.c。

4.2 颜色变量：一次设置，全局生效

1
2

BACK_COLOR  = BLACK;    // 背景色
POINT_COLOR = CYAN;     // 前景色（画笔）

这是两个全局变量，在 tftlcd.h 里 extern 声明。

LCD_ShowString、LCD_ShowChar、LCD_Draw_Point、LCD_DrawLine 这些函数内部会读这两个变量来决定用什么颜色。所以你不用给每个函数传颜色参数——设一次，后面画的东西都是这个色。

想换颜色就直接改：

POINT_COLOR = RED;
LCD_ShowString(0, 60, 160, 12, 12, "Warning!");   // 这行就是红字了
POINT_COLOR = GREEN;
LCD_ShowString(0, 75, 160, 12, 12, "OK");         // 这行是绿字

BACK_COLOR 的作用是文字的背景——显示字符时，字的笔画用 POINT_COLOR，笔画之外的空白填 BACK_COLOR。设成和屏幕底色一致，字看起来就是「透明背景」的。

4.3 `LCD_ShowString` 的五个参数

LCD_ShowString(0, 15, 160, 12, 12, "TFTLCD TEST 240*135");
//             │  │   │    │   │   └── 要显示的字符串
//             │  │   │    │   └────── 字体大小（12 = 12 号字，还可选 16、24）
//             │  │   │    └────────── 显示区域高度
//             │  │   └─────────────── 显示区域宽度（超过就自动换行）
//             │  └─────────────────── 起点 y 坐标（第 15 行像素）
//             └────────────────────── 起点 x 坐标（第 0 列像素）

坐标原点 (0,0) 在屏幕左上角，x 向右增大，y 向下增大。这和数学里的坐标系 y 轴方向相反，是所有显示设备的惯例。

四行文字的 y 坐标是 0、15、30、45，间隔 15 像素——正好比 12 号字高一点，行与行之间有 3 像素间隙，不会挤在一起。这就是「行距」的手工计算。

字体大小可选 12 / 16 / 24，取决于驱动库里存了哪几套字模。字号越大越清晰但占屏幕越多。

4.4 `LCD_Fill` 全屏刷色

`1`	`LCD_Fill(0, 0, 240, 240, BLACK); // (左上x, 左上y, 右下x, 右下y, 颜色)`

把一个矩形区域填成纯色。这里给的是 (0,0) 到 (240,240)，也就是整屏。

LCD_Fill 的内部实现值得了解：

1
2

① LCD_Address_Set(x1, y1, x2, y2)   ← 先告诉屏「接下来写的像素填到这个矩形里」
② 循环 (x2-x1)×(y2-y1) 次，每次发 2 字节颜色值

关键在第①步：ST7789 有个窗口机制。你设好窗口后，连续发像素数据，屏会自动从窗口左上角开始逐行填，填满自动换行，不需要你每个像素都指定坐标。这让批量刷屏效率很高。

为什么全屏刷色是性能测试？ 240×240 = 57600 个像素，每个 2 字节，共 115200 字节要通过 SPI 送出去。如果 SPI 跑 20MHz，理论上要 115200×8/20000000 ≈ 46ms。你能明显看到刷屏的过程（尤其从上往下扫的感觉），这就是刷新率的直观体现。

想让它快起来，就要用 DMA——驱动库已经预留了 DMA 配置（M4_DMA1、DmaCh1），开启后 CPU 只需要启动传输，剩下的搬运硬件自己干。

4.5 注意：文字会被覆盖

LCD_ShowString(...);          // 开机显示的四行文字

while (1)
{
    LCD_Fill(0, 0, 240, 240, BLACK);   // ← 全屏刷黑，文字被盖掉了！
    ...
}

主循环第一次 LCD_Fill 就把开机文字全覆盖了。所以你只能在上电瞬间看到那四行字，之后就是纯粹的黑青交替。

如果想让文字一直留着，把 LCD_ShowString 也搬进循环里，在每次 Fill 之后重画：

while (1)
{
    LCD_Fill(0, 0, 240, 240, BLACK);
    LCD_ShowString(0, 0, 160, 12, 12, "HC32F460");   // 刷完重画文字
    Ddl_Delay1ms(500);
    LCD_Fill(0, 0, 240, 240, CYAN);
    LCD_ShowString(0, 0, 160, 12, 12, "HC32F460");
    Ddl_Delay1ms(500);
}

顺便提一个显示编程的经典问题：闪烁（Flicker）。「全屏擦掉 → 重画」这种做法，如果刷新频繁，人眼会看到明显闪烁。专业做法是只重画变化的区域（比如只擦掉数字那一小块再重写），或者用双缓冲（在内存里画好整帧再一次性送屏）。做仪表、做动画时这点很重要。

4.6 只刷了一次却看到交替？

细看代码会发现：黑色刷完后 Ddl_Delay1ms(500)，但青色刷完后没有延时，直接进入下一轮循环刷黑。

所以实际节奏是：黑色停留 500ms，青色只停留一瞬间（刷屏本身耗时 + 循环开销）。视觉上会是「黑得久、青色一闪」。

想让两个颜色停留时间一样，在青色后面也补一句延时：

1
2

LCD_Fill(0, 0, 240, 240, CYAN);
Ddl_Delay1ms(500);        // 补上这句

这属于原示例的小瑕疵，正好可以拿来当练手的第一个改动。

5. 实验现象

上电瞬间：屏幕清黑，随后左上角出现四行青色文字：
1 2 3 4

Boring_TECH TFTLCD TEST 240*135 HC32F460 2022/6/20
紧接着进入主循环，文字被覆盖，屏幕开始黑 ↔ 青交替刷新（黑色停留约 0.5 秒，青色一闪而过）。
三颗 LED 同步闪烁。

如果你想仔细看那四行字，可以在 while(1) 前面加一句 Ddl_Delay1ms(3000); 让它多停 3 秒。

6. 常见问题

Q1：屏幕全黑，什么都没有？ 按顺序排查（这是最常见的问题）：

背光接了吗？亮了吗？ PWR/BLK 引脚（PB3）没接或没拉高，屏就是黑的。先确认背光亮不亮——用手机摄像头对着屏看，或者在暗处看有没有微光。背光亮但没内容，是另一类问题。
VCC 是 3.3V 吗？ 电压不对屏不工作（接 5V 还可能烧掉）。
GND 共地了吗？

Q2：背光亮了，但屏幕白屏 / 花屏 / 显示乱码条纹？

DC 脚（PB8）接对了吗？ 这是头号原因。DC 错了，屏会把数据当命令执行，结果完全混乱。
RST 脚（PB9）接了吗？ 没复位，屏内部寄存器状态不确定。
SPI 时钟太快？ 试着在 tftlcd.c 里降低 SPI 分频，速度慢下来往往就好了。
杜邦线太长？ 换短线（10cm 内），或者插紧一点。SPI 高速信号对连线质量很敏感。

Q3：显示的内容是「躺着」的 / 上下颠倒 / 左右镜像？

改 tftlcd.h 里的 USE_HORIZONTAL 宏。0、1 是竖屏，2、3 是横屏，四个值对应四个旋转方向，一个个试，总有一个对。

Q4：文字显示不全，或者跑到屏幕外面了？

检查坐标和屏幕分辨率。1.14 寸屏横屏是 240×135，y 坐标超过 135 就看不见了。
LCD_ShowString 的「宽度」参数决定什么时候换行，给太小会提前换行导致文字断开。

Q5：屏幕边缘有几像素的杂色/偏移？

ST7789 屏有「显示偏移」参数需要按具体模块调整。不同厂家的 1.14 寸模块偏移量可能不同（比如需要 x 偏移 40、y 偏移 53）。在 tftlcd.c 的 LCD_Address_Set 里加上偏移量修正。

Q6：刷屏太慢，做动画很卡？

提高 SPI 时钟（在信号质量允许的范围内）。
用 DMA：驱动库预留了 DMA 配置，开启后刷屏速度能提升数倍。
只刷变化区域，不要整屏重画。比如显示时间只需要重画那几个数字所占的小矩形。

Q7：想显示中文怎么办？

驱动库自带的字模只有 ASCII 字符。显示中文需要汉字字库。两个方案：
1. 用取模软件把要用的几个汉字做成数组存进程序（适合固定文字，如「温度」「湿度」）。
2. 把完整 GB2312 字库（约 260KB）存到外部 QSPI Flash 或 SD 卡里，需要时按区位码算出偏移读点阵数据（适合要显示任意汉字的场合）。这就是 QSPI/SD 卡章节和本章的联动应用。

7. 小结

LCD_Init() 一句话完成 SPI 配置、屏复位、寄存器初始化、开背光。
DC 脚区分命令和数据，是驱动 LCD 的核心；接错必花屏。
背光不开屏就是黑的，排查显示问题先看背光。
VCC 必须 3.3V，接 5V 烧屏。
POINT_COLOR / BACK_COLOR 是全局颜色变量，设一次全局生效。
坐标原点在左上角，y 向下增大。
USE_HORIZONTAL 宏控制屏幕旋转方向。
全屏刷色要传 115KB 数据，想快就上 DMA；想不闪就只刷变化区域。

8. 拓展应用

有了屏幕，你的项目一下就从「玩具」变成「产品」了：

数字仪表盘 显示温度、湿度、电压、电流的实时数值。配合 LCD_ShowNum 和大号字体，做一个电子温湿度计、万用表显示屏。
实时波形 / 曲线图 每采一个数据点就 LCD_Draw_ColorPoint 画一个点，横轴不断右移——就是简易示波器、心率曲线、温度趋势图。配合 LCD_DrawLine 连线更平滑。
菜单界面 + 按键导航 结合按键中断章节：上下键移动光标（用 LCD_Fill 画高亮条），确认键进入子菜单。这就是所有带屏设备的操作逻辑，工业仪表、3D 打印机面板都是这么做的。
图片 / 开机 Logo 显示 用取模软件把 BMP/PNG 转成 RGB565 数组，LCD_Show_Image 显示出来。图片数据大的话存到 QSPI Flash（映射地址直接读）或 SD 卡里，不占程序空间。
中文界面 GB2312 字库存外部 Flash / SD 卡，实现任意汉字显示。这是做中文产品界面的必经之路。
游戏贪吃蛇、俄罗斯方块、打砖块——240×240 的分辨率玩这些完全够。屏 + 按键就是一台掌机。
时钟 / 天气站 RTC 提供时间、传感器提供温湿度、WiFi 模块（串口通信）抓天气数据，全显示在屏上。这是最经典的综合练手项目，能把前面所有章节串起来。
上移到 GUI 框架 掌握了底层画点画线，下一步可以移植 LVGL（轻量级图形库）。它能做出带动画、按钮、滑块、图表的现代化界面。LVGL 只需要你提供一个「把一块缓冲区刷到屏上」的回调函数——也就是本章的 LCD_Fill / LCD_Address_Set 能力。本章学的就是 LVGL 的地基。

综合项目建议：把七章内容串成一个「数据记录仪」—— 按键启动/停止记录 → Timer0 定时触发采样 → 数据存到 SD 卡 CSV 文件 → LCD 实时显示曲线和状态 → 串口输出调试日志 → 字库放 QSPI Flash → GPIO LED 指示运行状态。做完这个，你就是一个能独立开发嵌入式产品的工程师了。

HC32 Timer0 定时中断 — 双通道周期翻转 LED

Wed, 09 Sep 2026 09:00:00 +0800

Timer0 定时中断：双通道周期翻转 LED

源码路径：example/HC32F460JEUA/3.timer0/BaseTimer/source/main.c

1. 功能简介

上一个 GPIO 例子里，我们用 Ddl_Delay1ms(500) 死等 500 毫秒来闪灯。这么做 CPU 在等待期间什么也干不了，纯属浪费。

这个例子换个高级做法：用 Timer0 定时器来控制时间。定时器自己在后台数数，数到设定值就触发一次中断，在中断函数里翻转 LED。整个过程 CPU 不用等待，可以去干别的事——时间到了定时器自然会「叫」它。

具体做了什么：

ChannelA（A 通道）：用异步模式（外部 32.768kHz 晶振），定时约 0.5 秒，中断里翻转绿灯。
ChannelB（B 通道）：用同步模式（内部 PCLK1 时钟），定时约 0.5 秒，中断里翻转蓝灯。

两个通道独立运行，各自闪各自的灯，演示 Timer0 两种时钟模式可以同时工作。

顺便说 PWM：如果把「翻转 LED」改成「翻转一个输出引脚」，Timer0 定时中断产生的就是一个固定频率的方波——这就是软件方波/软件 PWM 的雏形。真正的硬件 PWM（占空比可调、不占 CPU）要用 TimerA/TimerB，思路一脉相承。

2. 硬件准备

用 HC32F460JEUA KIT 开发板，板载 LED，无需接线。

绿灯：PA1（ChannelA 控制）
蓝灯：PA2（ChannelB 控制）

异步模式用到外部 32.768kHz 晶振（XTAL32）。开发板通常已经焊好这颗表晶。如果你用的是自制板、没焊 XTAL32，那 A 通道会不工作（数数没时钟源），此时只有蓝灯闪。

   HC32F460 开发板
 ┌───────────────────┐
 │  PA1 ──▶ 绿灯      │  ← Timer0 ChannelA（异步 XTAL32）翻转
 │  PA2 ──▶ 蓝灯      │  ← Timer0 ChannelB（同步 PCLK1）翻转
 │                   │
 │  XTAL32 (32.768k) │  ← 异步模式的时钟源，板载表晶
 └───────────────────┘

3. 完整代码

#include "hc32_ddl.h"

/* Timer0 单元和中断源定义 */
#define TMR_UNIT       (M4_TMR02)          // 用 Timer0 的第 2 个单元
#define TMR_INI_GCMA   (INT_TMR02_GCMA)    // A 通道比较匹配中断源
#define TMR_INI_GCMB   (INT_TMR02_GCMB)    // B 通道比较匹配中断源

/* 开 Timer0_2 外设时钟的宏 */
#define ENABLE_TMR0()  (PWC_Fcg2PeriphClockCmd(PWC_FCG2_PERIPH_TIM02, Enable))

__IO uint16_t u16cmp = 0u;   // __IO = volatile，防编译器把它优化掉
__IO uint16_t u16cnt = 0u;

/* ---------- A 通道中断回调：翻转绿灯 ---------- */
void Timer0A_CallBack(void)
{
    BSP_LED_Toggle(LED_GREEN);
}

/* ---------- B 通道中断回调：翻转蓝灯 ---------- */
void Timer0B_CallBack(void)
{
    BSP_LED_Toggle(LED_BLUE);
}

int32_t main(void)
{
    stc_tim0_base_init_t stcTimerCfg;      // Timer0 基础配置结构体
    stc_irq_regi_conf_t  stcIrqRegiConf;   // 中断注册配置结构体
    stc_port_init_t      stcPortInit;

    uint32_t u32Pclk1;
    stc_clk_freq_t stcClkTmp;
    uint32_t u32tmp;

    /* 三个结构体都先清零 */
    MEM_ZERO_STRUCT(stcTimerCfg);
    MEM_ZERO_STRUCT(stcIrqRegiConf);
    MEM_ZERO_STRUCT(stcPortInit);

    BSP_CLK_Init();          // 系统时钟初始化
    BSP_LED_Init();          // LED 初始化

    /* 读取当前 PCLK1 频率（同步模式算比较值要用）*/
    CLK_GetClockFreq(&stcClkTmp);
    u32Pclk1 = stcClkTmp.pclk1Freq;

    CLK_Xtal32Cmd(Enable);   // 使能外部 32.768kHz 晶振（异步模式的时钟源）

    ENABLE_TMR0();           // 开 Timer0 外设时钟

    /* ========== 配置 A 通道：异步模式，XTAL32 时钟 ========== */
    stcTimerCfg.Tim0_CounterMode      = Tim0_Async;      // 异步
    stcTimerCfg.Tim0_AsyncClockSource = Tim0_XTAL32;     // 用 32.768kHz 晶振
    stcTimerCfg.Tim0_ClockDivision    = Tim0_ClkDiv4;    // 4 分频
    /* 比较值：32000/4/2-1，定时约 0.5 秒 */
    stcTimerCfg.Tim0_CmpValue         = (uint16_t)(32000u/4u/2u - 1u);
    TIMER0_BaseInit(TMR_UNIT, Tim0_ChannelA, &stcTimerCfg);

    TIMER0_IntCmd(TMR_UNIT, Tim0_ChannelA, Enable);      // 使能 A 通道中断

    /* --- 注册 A 通道中断（HC32 特色四件套）--- */
    stcIrqRegiConf.enIRQn      = Int001_IRQn;            // 用向量号 1
    stcIrqRegiConf.enIntSrc    = TMR_INI_GCMA;           // 中断源 = A 通道比较匹配
    stcIrqRegiConf.pfnCallback = &Timer0A_CallBack;      // 绑定回调
    enIrqRegistration(&stcIrqRegiConf);                  // 注册
    NVIC_ClearPendingIRQ(stcIrqRegiConf.enIRQn);         // 清挂起
    NVIC_SetPriority(stcIrqRegiConf.enIRQn, DDL_IRQ_PRIORITY_15);  // 优先级
    NVIC_EnableIRQ(stcIrqRegiConf.enIRQn);               // 使能 NVIC

    /* ========== 配置 B 通道：同步模式，PCLK1 时钟 ========== */
    stcTimerCfg.Tim0_CounterMode      = Tim0_Sync;       // 同步
    stcTimerCfg.Tim0_SyncClockSource  = Tim0_Pclk1;      // 用 PCLK1
    stcTimerCfg.Tim0_ClockDivision    = Tim0_ClkDiv1024; // 1024 分频
    /* 比较值：PCLK1/1024/2-1，定时约 0.5 秒 */
    stcTimerCfg.Tim0_CmpValue         = (uint16_t)(u32Pclk1/1024ul/2ul - 1ul);
    TIMER0_BaseInit(TMR_UNIT, Tim0_ChannelB, &stcTimerCfg);

    TIMER0_IntCmd(TMR_UNIT, Tim0_ChannelB, Enable);

    /* --- 注册 B 通道中断 --- */
    stcIrqRegiConf.enIRQn      = Int002_IRQn;            // 换个向量号 2
    stcIrqRegiConf.enIntSrc    = TMR_INI_GCMB;           // 中断源 = B 通道
    stcIrqRegiConf.pfnCallback = &Timer0B_CallBack;
    enIrqRegistration(&stcIrqRegiConf);
    NVIC_ClearPendingIRQ(stcIrqRegiConf.enIRQn);
    NVIC_SetPriority(stcIrqRegiConf.enIRQn, DDL_IRQ_PRIORITY_15);
    NVIC_EnableIRQ(stcIrqRegiConf.enIRQn);

    /* ========== 启动两个通道 ========== */
    TIMER0_Cmd(TMR_UNIT, Tim0_ChannelA, Enable);
    TIMER0_Cmd(TMR_UNIT, Tim0_ChannelB, Enable);

    while(1)
    {
        /* 读 B 通道计数值（同步模式可直接读）*/
        u16cnt = TIMER0_GetCntReg(TMR_UNIT, Tim0_ChannelB);
        u16cmp = TIMER0_GetCntReg(TMR_UNIT, Tim0_ChannelB);

        /* 读 A 通道计数值（异步模式要先停再读，读完再开）*/
        TIMER0_Cmd(TMR_UNIT, Tim0_ChannelA, Disable);
        u16cnt = TIMER0_GetCntReg(TMR_UNIT, Tim0_ChannelA);
        u16cmp = TIMER0_GetCntReg(TMR_UNIT, Tim0_ChannelA);
        TIMER0_Cmd(TMR_UNIT, Tim0_ChannelA, Enable);

        /* 简单空转延时 */
        u32tmp = 0xFFFFFul;
        while(u32tmp--){ ; }
    }
}

4. 代码分段讲解

4.1 中断回调放在最前面

1
2

void Timer0A_CallBack(void) { BSP_LED_Toggle(LED_GREEN); }
void Timer0B_CallBack(void) { BSP_LED_Toggle(LED_BLUE); }

这两个函数就是「闹钟响了要做的事」。Timer0 A 通道数到点了 → 系统自动调用 Timer0A_CallBack → 翻转绿灯。B 通道同理翻转蓝灯。

中断回调里要尽量短、尽量快——只翻转个 LED 这种轻活可以，别在里面写 printf、delay 这种耗时操作，否则会拖累整个系统响应。

4.2 A 通道：异步模式

stcTimerCfg.Tim0_CounterMode      = Tim0_Async;
stcTimerCfg.Tim0_AsyncClockSource = Tim0_XTAL32;   // 32.768kHz 晶振
stcTimerCfg.Tim0_ClockDivision    = Tim0_ClkDiv4;
stcTimerCfg.Tim0_CmpValue         = (uint16_t)(32000u/4u/2u - 1u);

异步模式用外部低速晶振数数。比较值 32000/4/2-1 = 3999：

32000 是晶振频率（约 32.768k，代码取整算）
/4 是分频
/2 是因为「翻转」需要两次中断才完成一个亮灭周期，所以半周期用 0.5 秒
-1 是因为从 0 数起，数到 3999 其实是 4000 个数

用异步模式前必须先 CLK_Xtal32Cmd(Enable) 把这颗晶振打开。

4.3 B 通道：同步模式

stcTimerCfg.Tim0_CounterMode     = Tim0_Sync;
stcTimerCfg.Tim0_SyncClockSource = Tim0_Pclk1;
stcTimerCfg.Tim0_ClockDivision   = Tim0_ClkDiv1024;
stcTimerCfg.Tim0_CmpValue        = (uint16_t)(u32Pclk1/1024ul/2ul - 1ul);

同步模式用内部 PCLK1（频率比 32k 高得多，所以要 1024 大分频才不至于溢出）。比较值这次是动态算的——先用 CLK_GetClockFreq() 读出当前 PCLK1 的实际频率，再套公式。这样即使换了时钟配置，定时时间也能自动保持 0.5 秒，比写死一个数字更稳。

4.4 中断注册——HC32 的独特之处

stcIrqRegiConf.enIRQn      = Int001_IRQn;       // A 用向量 1
stcIrqRegiConf.enIntSrc    = TMR_INI_GCMA;      // 绑定 A 通道中断源
stcIrqRegiConf.pfnCallback = &Timer0A_CallBack; // 绑定回调
enIrqRegistration(&stcIrqRegiConf);
NVIC_ClearPendingIRQ(...);
NVIC_SetPriority(..., DDL_IRQ_PRIORITY_15);     // 15 是最低优先级
NVIC_EnableIRQ(...);

这是 HC32 和 STM32 最大的不同。STM32 中断函数名固定；HC32 要你手动把中断源绑到某个向量号。注意 A 用 Int001_IRQn、B 用 Int002_IRQn——两个中断必须用不同的向量号，否则会互相冲突。

流程口诀：注册 → 清挂起 → 设优先级 → 使能 NVIC，四步一个都不能少。

4.5 主循环里读计数值的小细节

/* 异步通道要先停再读 */
TIMER0_Cmd(TMR_UNIT, Tim0_ChannelA, Disable);
u16cnt = TIMER0_GetCntReg(TMR_UNIT, Tim0_ChannelA);
TIMER0_Cmd(TMR_UNIT, Tim0_ChannelA, Enable);

主循环读计数值只是为了演示怎么读。异步模式有个坑：因为它用的是和 CPU 不同步的外部时钟，直接读计数寄存器可能读到「正在变化中」的错误值，所以要先停计数、读完再启动。同步模式没这问题，可以直接读。

5. 实验现象

烧录后：

绿灯每约 1 秒闪一次（A 通道异步定时驱动）。
蓝灯每约 1 秒闪一次（B 通道同步定时驱动）。

两个灯独立闪烁。和 GPIO 例子肉眼看着类似，但本质完全不同：这里 CPU 没有死等延时，闪灯完全由定时器中断驱动，CPU 主循环是空闲的（可以拿去做别的事）。

如果你的板子没有 XTAL32 晶振，绿灯不会闪，只有蓝灯闪。

6. 常见问题

Q1：绿灯不闪，只有蓝灯闪？

异步模式依赖外部 32.768kHz 晶振。板子没焊 XTAL32、或 CLK_Xtal32Cmd(Enable) 没生效，A 通道就没时钟数不了数。

Q2：两个灯都不闪？

检查 PWC_Fcg2PeriphClockCmd(PWC_FCG2_PERIPH_TIM02, Enable) 时钟开了没。
检查中断注册是不是漏了某一步（尤其 NVIC_EnableIRQ）。

Q3：中断进不去 / 回调不执行？

A、B 两个通道的向量号是不是用了不同的（Int001 和 Int002）？用了同一个会冲突。
enIntSrc 是不是填对了（A 用 GCMA，B 用 GCMB）？

Q4：闪的频率不对，不是 1 秒？

同步模式的比较值依赖 PCLK1 频率。如果 BSP_CLK_Init() 没调、或 CLK_GetClockFreq 读的值不对，算出来的比较值就偏。

Q5：__IO 是什么？能删吗？

__IO 就是 volatile。它告诉编译器「这个变量随时可能被中断改动，不要优化」。中断和主循环共享的变量都要加，删了可能出诡异 bug。

7. 小结

Timer0 定时中断 = 让定时器在后台数数，数到点自动触发中断，CPU 不用死等。
两种模式：异步（XTAL32，省电）、同步（PCLK1，高速），可同时跑。
定时时间靠比较值 + 分频算，公式：(比较值+1)×分频÷频率。
HC32 中断要手动注册，多个中断用不同向量号。
中断和主循环共享的变量记得加 __IO（volatile）。

8. 拓展应用

定时器是几乎所有正经项目的时间基准：

精确定时任务：每 1 秒采集温度、每 100ms 读一次传感器——把 Toggle 换成你的任务函数即可。
软件定时器框架：用一个定时器中断产生 1ms「滴答」，在中断里给多个计数器 +1，就能同时管理几十个不同周期的任务（这就是 RTOS 系统节拍 SysTick 的思想）。
按键消抖 / 扫描：每 10ms 定时扫描一次按键状态，比在主循环里瞎测稳得多。
产生方波 / 简易 PWM：在中断里翻转引脚就是方波发生器；想要占空比可调的真 PWM，进阶到 TimerA/TimerB。
超时检测：启动定时器，若在规定时间内没等到某事件（如串口没收到回复），就判定超时——通信协议里非常常用。
低功耗唤醒：异步模式 + XTAL32 能在 CPU 睡眠时继续计时，定时把系统唤醒，做省电的间歇采集设备。

HC32 按键中断 — 按下触发回调

Wed, 09 Sep 2026 09:00:00 +0800

按键中断：按下触发回调

源码路径：example/HC32F460JEUA/4.key/source/main.c BSP 实现：bsp/ev_hc32f460_lqfp100_v2/ev_hc32f460_lqfp100_v2.c

1. 功能简介

这个例子让单片机能感知按键被按下，而且用的是最专业的方式——外部中断。

「中断」这个词听着高深，其实特别好理解。打个比方：

轮询就像你在等快递，每隔十秒就跑到门口看一眼「来了吗？来了吗？」——什么正事都干不了。
中断就像你留了个门铃，你安心在屋里干活，快递到了会按铃通知你，你放下手里的活去开门，开完门回来继续干。

按键中断就是给引脚装了个「门铃」：平时 CPU 该干啥干啥，一旦你按下按键（引脚电平从高变低），硬件立刻打断 CPU，跳到你写好的回调函数里执行，处理完再回到原来的地方继续。

这个例子的完整链路是：按下 PC13 → 触发 EXINT13 下降沿中断 → 执行 Key_Callback → 置标志位 u8GlobalKey = 1 → 主循环发现标志位，做出反应。

2. 硬件准备

用 HC32F460JEUA KIT 开发板，板载按键 K1 接在 PC13，无需接线。

        3.3V
          │
         ┌┴┐  芯片内部上拉电阻（代码里 enPullUp = Enable 打开）
         └┬┘
          │
   PC13 ──┤                 没按：读到高电平 (3.3V)
          │                 按下：读到低电平 (0V)
         ─┴─  按键 K1
          │
         GND

如果要自己外接按键（面包板）：

1
2
3

   PC13 ──┬── 按键 ── GND
          │
       （内部上拉已开，不用外接电阻）

只要两根线：引脚 → 按键 → GND。上拉靠芯片内部的，省一个电阻。

常见错误：把按键接到 3.3V（按下拉高）。那样「没按」时引脚是悬空的，读到的电平完全随机，程序会乱触发。按键一定接 GND，配合上拉使用。

3. 完整代码

3.1 main.c

#include "hc32_ddl.h"

/* 按键引脚定义 */
#define  KEYIN_PORT    (PortC)
#define  KEYIN0_PIN    (Pin13)

char del = 0;              // 主循环里随便加加，防止空循环被优化掉

int32_t main(void)
{
    BSP_CLK_Init();        // 系统时钟初始化

    BSP_LED_Init();        // LED 初始化（用来显示按键效果）

    /* 关掉 TDI/TDO 调试脚复用，避免和其他功能引脚冲突 */
    PORT_DebugPortSetting(TDI, Disable);
    PORT_DebugPortSetting(TDO_SWO, Disable);

    /* 初始化串口打印（这样中断里可以 printf 观察）*/
    DDL_PrintfInit(BSP_PRINTF_DEVICE, BSP_PRINTF_BAUDRATE, BSP_PRINTF_PortInit);

    /* 按键初始化 —— 关键的一句，内部完成了 EXINT 全部配置 */
    BSP_KEY_Init();

    /* 启动按键扫描 */
    KEYSCAN_Start();

    while(1)
    {
        /* 主循环：可以在这里检查 u8GlobalKey 标志做出反应 */
        /* 例如：
        if (u8GlobalKey == 1)
        {
            BSP_LED_On(LED_RED);
            u8GlobalKey = 0;      // 处理完记得清零
        }
        */
        del++;
    }
}

main.c 看着很短，因为真正的活都在 BSP_KEY_Init() 里干了。想学明白，必须看它的实现。

3.2 BSP 里的按键中断实现（核心）

uint8_t u8GlobalKey;       // 全局标志位：按键被按下时置 1

/* ---------- 按键中断回调函数 ---------- */
void Key_Callback(void)
{
    /* 先确认真的是 EXINT 通道 13 触发的 */
    if (Set == EXINT_IrqFlgGet(ExtiCh13))
    {
        /* 死等按键松开：既确认了按下，又天然完成了消抖 */
        while (Reset == PORT_GetBit(KEYIN_PORT, KEYIN0_PIN))
        {
            u8GlobalKey = 1;       // 置标志位，通知主循环
        }

        /* 【必须】清中断标志，不清会反复进中断出不来 */
        EXINT_IrqFlgClr(ExtiCh13);
    }
}

/* ---------- 按键初始化 ---------- */
void BSP_KEY_Init(void)
{
    stc_exint_config_t  stcExtiConfig;     // 外部中断配置
    stc_irq_regi_conf_t stcIrqRegiConf;    // 中断注册配置
    stc_port_init_t     stcPortInit;       // 引脚配置

    /* 三个结构体全部清零 */
    MEM_ZERO_STRUCT(stcExtiConfig);
    MEM_ZERO_STRUCT(stcIrqRegiConf);
    MEM_ZERO_STRUCT(stcPortInit);

    /* ===== ① 配置外部中断通道 13 ===== */
    stcExtiConfig.enExitCh   = ExtiCh13;          // 用通道 13（对应 Pin13）
    stcExtiConfig.enFilterEn = Enable;            // 开硬件滤波（消抖！）
    stcExtiConfig.enFltClk   = Pclk3Div8;         // 滤波时钟 = PCLK3/8
    stcExtiConfig.enExtiLvl   = ExIntFallingEdge; // 下降沿触发 = 按下瞬间
    EXINT_Init(&stcExtiConfig);

    /* ===== ② 配置 PC13 引脚 ===== */
    MEM_ZERO_STRUCT(stcPortInit);
    stcPortInit.enExInt  = Enable;   // 【关键】允许该引脚的电平变化送给 EXINT
    stcPortInit.enPullUp = Enable;   // 开内部上拉（没按时是高电平）
    PORT_Init(KEYIN_PORT, KEYIN0_PIN, &stcPortInit);

    /* ===== ③ 注册中断（HC32 四件套）===== */
    stcIrqRegiConf.enIntSrc    = INT_PORT_EIRQ13;   // 中断源：外部中断13
    stcIrqRegiConf.enIRQn      = Int000_IRQn;       // 绑到向量号 0
    stcIrqRegiConf.pfnCallback = &Key_Callback;     // 绑定回调函数
    enIrqRegistration(&stcIrqRegiConf);             // 注册

    NVIC_ClearPendingIRQ(stcIrqRegiConf.enIRQn);    // 清挂起
    NVIC_SetPriority(stcIrqRegiConf.enIRQn, DDL_IRQ_PRIORITY_DEFAULT); // 优先级
    NVIC_EnableIRQ(stcIrqRegiConf.enIRQn);          // 使能 NVIC

    KEYSCAN_Start();     // 启动按键扫描
}

4. 代码分段讲解

4.1 EXINT 通道号 = 引脚号

`1`	`stcExtiConfig.enExitCh = ExtiCh13; // 因为按键在 PC13`

记住这个绑定关系：ExtiChNN 只能用于任意端口的 PinNN。按键在 PC13，所以必须用 ExtiCh13，用别的通道收不到信号。

副作用是：PA13、PB13、PC13 这些「同号引脚」只能有一个用作外部中断，它们共享通道 13。设计电路时要注意别撞车。

4.2 硬件滤波——一行代码搞定消抖

1
2

stcExtiConfig.enFilterEn = Enable;
stcExtiConfig.enFltClk   = Pclk3Div8;

这两行是 HC32 的贴心之处。开启后，EXINT 模块内部的数字滤波器会把宽度太窄的毛刺直接过滤掉，只有稳定持续的电平变化才算真触发。

按键触点弹跳产生的那些几十微秒的尖峰，就在这里被吃掉了。相比在软件里写 delay(10) 消抖，硬件滤波不占 CPU 时间，更优雅。

Pclk3Div8 是滤波采样时钟，分频越大滤波时间越长、能滤掉更宽的毛刺，但响应也越慢。默认值一般够用。

4.3 `enExInt = Enable` 是命门

1
2

stcPortInit.enExInt  = Enable;   // 千万不能漏
stcPortInit.enPullUp = Enable;

初学者最容易漏的就是 enExInt。它相当于给引脚和 EXINT 模块之间接上一根线。EXINT 那边配得再完美，这根线没接，中断永远不会来。

enPullUp = Enable 打开内部上拉，保证没按键时引脚是稳定的高电平。这样才有「按下 → 高变低 → 下降沿」这个过程。

注意这里没有设置 enPinMode，因为清零后默认就是输入模式（Pin_Mode_In 对应 0），符合按键需求。

4.4 回调里的「等待释放」写法

while (Reset == PORT_GetBit(KEYIN_PORT, KEYIN0_PIN))
{
    u8GlobalKey = 1;
}

这个 while 的意思是：只要引脚还是低电平（按键还按着），就一直循环。松手了才跳出来。

好处是天然把整个抖动过程包住了，只会产生一次「按下」事件。缺点是它是阻塞的——你按着不放，CPU 就一直卡在中断里出不来。

这是可以改进的地方。工程实践中，中断回调应当尽量短，标准做法是：
1
2
3
4
5
6
7
8
void Key_Callback(void)
{
    if (Set == EXINT_IrqFlgGet(ExtiCh13))
    {
        u8GlobalKey = 1;          // 只置个标志，立刻返回
        EXINT_IrqFlgClr(ExtiCh13);
    }
}
然后在主循环里检查标志、做消抖确认、执行具体动作。这样中断响应快、不阻塞。

4.5 中断和主循环的协作：标志位模式

这是嵌入式最经典的设计模式：

中断回调（快）：            主循环（慢，可以慢慢干）：
  u8GlobalKey = 1;    ──▶     if (u8GlobalKey == 1) {
  清标志，立刻返回                 干正事（点灯/存数据/printf）
                                   u8GlobalKey = 0;   // 处理完清零
                                }

原则：中断里只做「记录事件」这一件事，具体处理留给主循环。

重要提示：这种被中断修改、被主循环读取的变量，应当声明为 volatile：
1
volatile uint8_t u8GlobalKey;
否则编译器可能认为「主循环里没人改这个变量」而把它优化成常量，导致 if 永远不成立。SDK 的 BSP 里没加，属于可以改进的点，实际项目里建议加上。

4.6 `EXINT_IrqFlgClr` 不能忘

`1`	`EXINT_IrqFlgClr(ExtiCh13);`

外部中断的头号 bug 就是忘记清标志。硬件中断标志置位后不清，CPU 一退出中断就发现「标志还在，还有中断要处理」，于是立刻又跳进来——程序死循环在中断里，主循环再也执行不到，看起来就像「按一下按键程序就卡死了」。

5. 实验现象

原版例子里主循环的处理代码是注释掉的，所以直接烧录看不到明显现象（只有 del++ 在空转）。

想看到效果，把主循环改成这样：

while(1)
{
    if (u8GlobalKey == 1)
    {
        BSP_LED_Toggle(LED_RED);   // 每按一次，红灯翻转
        u8GlobalKey = 0;           // 清标志，等下一次按键
    }
}

改完后的现象：每按一次 K1（PC13），红灯亮灭切换一次。按一下亮，再按一下灭。

如果加上串口打印，还能在串口助手里看到每次按键的记录。

6. 常见问题

Q1：按键完全没反应，中断进不去？ 按这个顺序查：

stcPortInit.enExInt = Enable 写了吗？（头号原因）
EXINT 通道号和引脚号匹配吗？（PC13 必须用 ExtiCh13）
enIntSrc 填的是 INT_PORT_EIRQ13 吗？
NVIC_EnableIRQ() 调了吗？
按键真的接在 PC13、真的接到 GND 吗？

Q2：按一下按键程序就卡死了？

十有八九是忘了 EXINT_IrqFlgClr()，程序困在中断里反复进出。
也可能是回调里的 while 等待释放，你按着没松手。

Q3：按一下，程序却响应了好几次？

消抖没生效。检查 enFilterEn = Enable 是否配上。
也可以在主循环处理时再加一层软件确认（延时 10ms 后再读一次电平）。

Q4：主循环里的 if (u8GlobalKey == 1) 永远不成立？

变量没加 volatile，被编译器优化了。改成 volatile uint8_t u8GlobalKey;。
或者忘了在处理完后 u8GlobalKey = 0，导致只响应第一次（其实是一直成立，看着像没反应）。

Q5：按住不放，LED 疯狂闪？

说明触发方式配成了 ExIntLowLevel（低电平触发），按着就一直触发。改成 ExIntFallingEdge。

Q6：中断里能不能用 printf？

能用，但不推荐。printf 通过串口一个字符一个字符地发，非常慢（几百微秒到几毫秒），会严重拖累中断响应。调试时临时用可以，正式代码里请置标志位、到主循环去打印。

7. 小结

按键中断链路：按下 → 下降沿 → EXINT 触发 → 回调 → 置标志 → 主循环处理。
ExtiChNN 通道号必须和 PinNN 引脚号对应。
引脚配置里 enExInt = Enable 是命门，漏了必不通。
硬件滤波一行搞定消抖，比软件延时优雅。
回调里必须 EXINT_IrqFlgClr()，否则卡死在中断。
中断里只置标志，重活交给主循环；共享变量加 volatile。

8. 拓展应用

按键 + 中断是人机交互的基础，能玩出很多东西：

多按键菜单系统：三四个按键（上/下/确认/返回）配合 LCD，就是一套完整的菜单界面，工业设备的操作面板都是这么做的。
长按 / 短按 / 双击识别：用 ExIntBothEdge 双边沿触发，配合定时器测量按下的时长——短按 < 500ms 是一个功能，长按 > 2s 是另一个功能（比如长按关机）。
组合键：同时按住两个键触发特殊操作（如恢复出厂设置）。
旋转编码器：两个引脚的相位差信号，用外部中断捕捉，就能做出音量旋钮那样的调节器。
外部传感器触发：把按键换成红外对管、霍尔开关、震动传感器——任何输出开关信号的传感器都能用同样的外部中断方式接入，做门磁报警、转速计数、计步器。
低功耗唤醒：外部中断能把睡眠中的 MCU 唤醒。做电池供电的设备时，平时深度睡眠，按一下按键才醒来工作，能把待机功耗降到微安级。
紧急停止：安全相关的输入必须用中断而不是轮询——因为中断响应是微秒级的，绝不会漏掉信号。

HC32 串口轮询 — 收发数据与 printf 打印

Wed, 09 Sep 2026 09:00:00 +0800

串口轮询：收发数据与 printf 打印

源码路径：example/HC32F460JEUA/2.usart/uart_polling/source/main.c

1. 功能简介

这个例子做两件事：

回显（Echo）：你在电脑串口助手里发一个字符，单片机原样发回来。发 A 收到 A，发 hello 收到 hello。这是验证串口通不通的经典测试。
printf 打印：程序启动时会往串口打印一句 test，证明 printf 已经被成功「接」到串口上了。

「轮询」是什么意思？就是 CPU 不停地去问：「有数据来了吗？有数据来了吗？」——问到了就处理。这和「中断」相对（中断是数据来了主动通知 CPU）。轮询最简单直观，适合入门；缺点是 CPU 一直在原地打转问，干不了别的事。

学会这个例子，你就拥有了串口调试能力——以后任何程序都能用 printf 把内部状态打到电脑上看，这是嵌入式开发最基本的生存技能。

2. 硬件准备

用 HC32F460JEUA KIT 开发板，板载有 USB 转串口，一根 USB 线搞定，不用额外接线。

   电脑                          HC32F460 开发板
 ┌───────┐   USB线    ┌──────────────────────────┐
 │       │◀─────────▶│ USB口 ─ CH340等转串口芯片 │
 │ 串口  │            │            │              │
 │ 助手  │            │      ┌─────┴─────┐        │
 └───────┘            │      │ PA15 (TX) │──发──▶ │
                      │      │ PA10 (RX) │◀─收──  │
                      │      └───────────┘        │
                      └──────────────────────────┘

如果你的板子没有板载转串口芯片，就要外接一个 USB-TTL 模块（如 CH340、CP2102），接法是交叉连：

   USB-TTL 模块          HC32F460
      TX  ───────────────  PA10 (RX)     模块的发，接单片机的收
      RX  ───────────────  PA15 (TX)     模块的收，接单片机的发
      GND ───────────────  GND           共地！必须接，否则不通

两个新手必踩的坑：

TX 接 RX，RX 接 TX（交叉），不是 TX 接 TX。想想「我的嘴对着你的耳朵」。

一定要共地（GND 相连），否则没有共同参考电平，通信必失败。

电脑端准备一个串口助手软件（如 sscom、友善串口助手、或 VSCode 串口插件），波特率设 115200。

3. 完整代码

#include "hc32_ddl.h"
#include "stdio.h"                       // 用 printf 必须包含

/* ---------- 串口参数定义 ---------- */
#define USART_CH          (M4_USART2)    // 用 USART2
#define USART_BAUDRATE    (115200ul)     // 波特率 115200

/* RX 引脚：PA10，复用为 USART2 的接收 */
#define USART_RX_PORT     (PortA)
#define USART_RX_PIN      (Pin10)
#define USART_RX_FUNC     (Func_Usart2_Rx)

/* TX 引脚：PA15，复用为 USART2 的发送 */
#define USART_TX_PORT     (PortA)
#define USART_TX_PIN      (Pin15)
#define USART_TX_FUNC     (Func_Usart2_Tx)

/* ---------- 串口接收错误处理 ---------- */
static void UsartRxErrProcess(void)
{
    /* 帧错误：清掉标志 */
    if (Set == USART_GetStatus(USART_CH, UsartFrameErr))
        USART_ClearStatus(USART_CH, UsartFrameErr);
    /* 校验错误：清掉标志 */
    if (Set == USART_GetStatus(USART_CH, UsartParityErr))
        USART_ClearStatus(USART_CH, UsartParityErr);
    /* 溢出错误（没及时读，新数据把旧的冲了）：清掉标志 */
    if (Set == USART_GetStatus(USART_CH, UsartOverrunErr))
        USART_ClearStatus(USART_CH, UsartOverrunErr);
}

/* ---------- 关键：重定向 fputc，让 printf 走串口 ---------- */
int fputc(int ch, FILE *f)
{
    USART_SendData(M4_USART2, (uint8_t)ch);                   // 发一个字节
    while(Reset == USART_GetStatus(M4_USART2, UsartTxEmpty)); // 等它发完
    return ch;
}

int32_t main(void)
{
    uint16_t u16RxData;
    en_result_t enRet = Ok;

    /* 要开的 USART 时钟（这里一次把 USART1~4 都开了）*/
    uint32_t u32Fcg1Periph = PWC_FCG1_PERIPH_USART1 | PWC_FCG1_PERIPH_USART2 |
                             PWC_FCG1_PERIPH_USART3 | PWC_FCG1_PERIPH_USART4;

    /* 串口初始化参数：8 数据位、1 停止位、无校验 —— 即 8-N-1 */
    const stc_usart_uart_init_t stcInitCfg = {
        UsartIntClkCkNoOutput,   // 时钟不从引脚输出
        UsartClkDiv_1,           // 时钟不分频
        UsartDataBits8,          // 8 位数据
        UsartDataLsbFirst,       // 低位先发
        UsartOneStopBit,         // 1 位停止位
        UsartParityNone,         // 无校验
        UsartSampleBit8,         // 8 倍采样
        UsartStartBitFallEdge,   // 起始位下降沿检测
        UsartRtsEnable,
    };

    BSP_CLK_Init();              // 系统时钟初始化（波特率算得准就靠它）
    BSP_LED_Init();              // LED 初始化

    /* 关掉 TDI/TDO 调试脚的复用（因为它们可能和串口引脚冲突）*/
    PORT_DebugPortSetting(TDI, Disable);
    PORT_DebugPortSetting(TDO_SWO, Disable);

    /* 开 USART 外设时钟 */
    PWC_Fcg1PeriphClockCmd(u32Fcg1Periph, Enable);

    /* 引脚复用为串口功能 */
    PORT_SetFunc(USART_RX_PORT, USART_RX_PIN, USART_RX_FUNC, Disable);
    PORT_SetFunc(USART_TX_PORT, USART_TX_PIN, USART_TX_FUNC, Disable);

    /* 初始化 UART，失败就卡死（方便发现问题）*/
    enRet = USART_UART_Init(USART_CH, &stcInitCfg);
    if (enRet != Ok) { while (1){} }

    /* 设置波特率，失败也卡死 */
    enRet = USART_SetBaudrate(USART_CH, USART_BAUDRATE);
    if (enRet != Ok) { while (1){} }

    /* 使能收发 */
    USART_FuncCmd(USART_CH, UsartRx, Enable);
    USART_FuncCmd(USART_CH, UsartTx, Enable);

    BSP_LED_On(LED_RED);         // 点红灯表示初始化完成
    printf("test");              // 用 printf 打印，验证重定向成功

    while (1)
    {
        /* 轮询：接收缓冲区非空 = 有新数据来了 */
        if (Set == USART_GetStatus(USART_CH, UsartRxNoEmpty))
        {
            u16RxData = USART_RecData(USART_CH);   // 读出这个字节

            /* 等发送缓冲区空了，再把它发回去（回显）*/
            while (Reset == USART_GetStatus(USART_CH, UsartTxEmpty)){}
            USART_SendData(USART_CH, u16RxData);
        }

        UsartRxErrProcess();     // 顺手处理可能的接收错误
    }
}

4. 代码分段讲解

4.1 `fputc` 重定向——printf 能用的秘密

int fputc(int ch, FILE *f)
{
    USART_SendData(M4_USART2, (uint8_t)ch);
    while(Reset == USART_GetStatus(M4_USART2, UsartTxEmpty));
    return ch;
}

这是整个例子里最值得记住的一段。

C 语言的 printf 底层最终会一个字符一个字符地调用 fputc() 把内容「打」出去。默认情况下 fputc 不知道该往哪打（单片机又没显示器）。我们只要自己重写一个 fputc，在里面写「把这个字符从串口发出去」，printf 就自动改道走串口了。

从此以后，printf("温度 = %d\n", temp); 打印的内容就会出现在电脑串口助手里。这就是嵌入式调试的「打印大法」。

Keil (MDK) 环境下用这个方法，通常还要在工程里勾选 Use MicroLIB（微库），否则 printf 会很大甚至链接不过。

4.2 初始化结构体 = 串口参数

const stc_usart_uart_init_t stcInitCfg = {
    ...
    UsartDataBits8,      // 8 位数据
    ...
    UsartOneStopBit,     // 1 位停止位
    UsartParityNone,     // 无校验
    ...
};

这几行就是把「8-N-1」翻译成代码。要和串口助手那头设的一模一样。

4.3 波特率单独设

`1`	`USART_SetBaudrate(USART_CH, 115200ul);`

注意波特率不在初始化结构体里，而是单独一个函数设置。它内部会根据当前系统时钟频率算出分频系数，所以前面 BSP_CLK_Init() 必须先调，否则算出来的波特率是错的（→ 乱码）。

4.4 主循环：轮询回显

if (Set == USART_GetStatus(USART_CH, UsartRxNoEmpty))  // 收到数据了吗？
{
    u16RxData = USART_RecData(USART_CH);               // 读出来
    while (Reset == USART_GetStatus(USART_CH, UsartTxEmpty)){}  // 等能发
    USART_SendData(USART_CH, u16RxData);               // 原样发回
}

这就是「轮询」的精髓：CPU 在 while(1) 里反复检查 UsartRxNoEmpty 标志。一旦有数据，就读出来再发回去，形成回显。

4.5 错误处理别漏

UsartRxErrProcess() 检查三种错误（帧错误、校验错误、溢出错误）并清除标志。溢出错误（Overrun）尤其重要：如果数据来得太快、CPU 没及时读走，新数据会把旧数据冲掉并置位溢出标志，不清的话串口可能就卡住不再收了。

5. 实验现象

上电后，红灯亮（初始化完成的标志）。
电脑串口助手里立刻收到一行 test（printf 打印的）。
你在串口助手里发送任意字符，会原样收到同样的字符（回显）。发 123 收 123。

6. 常见问题

Q1：串口助手全是乱码 锟斤拷？ 最经典的问题，按顺序排查：

串口助手波特率是不是 115200？（第一嫌疑）
数据位/停止位/校验是不是 8-N-1？
代码里 BSP_CLK_Init() 调了没？没调时钟没对，波特率就是错的。

Q2：什么都收不到？

串口助手选的 COM 口对不对？（设备管理器里看 CH340 是哪个 COM）
外接 USB-TTL 的话，TX/RX 交叉了吗？GND 接了吗？
红灯亮了吗？没亮说明初始化就卡住了（可能 USART_UART_Init 返回失败，被 while(1) 困住）。

Q3：printf 打印的中文乱码？

串口助手的编码要和源文件编码一致（一般选 GBK 或 UTF-8 试试）。英文一般不会乱。

Q4：能发但收不到回显？

检查 RX 引脚（PA10）复用配了没、接线对不对。发得出去说明 TX 没问题，收不到就是 RX 那条链路的事。

Q5：printf 打印很卡、或者程序变得很大编不过？

Keil 里勾上 Use MicroLIB。

7. 小结

串口轮询 = CPU 反复查 UsartRxNoEmpty 标志，有数据就处理。
配置顺序：开时钟 → 配引脚复用 → USART_UART_Init → USART_SetBaudrate → 使能收发。
重写 fputc 就能让 printf 走串口，这是头号调试技能。
乱码找波特率，收不到找接线和 COM 口。
别忘处理接收错误（尤其溢出）。

8. 拓展应用

串口是通往无数项目的大门：

调试打印：任何项目都能用 printf 输出变量、状态、日志。学会它，你的开发效率翻倍。
上位机通信：单片机采集数据（温度、电流），通过串口发给电脑上的 Python/C# 程序画曲线、存数据库。
蓝牙 / WiFi 模块：HC-05 蓝牙、ESP8266 WiFi 这类模块都是串口通信的，学会串口就能用手机/网络远程控制单片机。
GPS 模块：GPS 定位模块输出的 NMEA 数据也是走串口，接进来解析就能做定位设备。
多机通信：两块单片机用串口互联，一主一从传数据。
命令行控制：做一个简单的串口命令解析器，在串口助手里敲 led on、led off 就能控制设备，非常适合调试和演示。

下一步建议：把轮询升级成中断接收，CPU 就不用死等了，可以边收数据边干别的事。原理和「按键中断」那章相通。

华大半导体 (HDSC / XHSC) HC32 MCU 示例代码库

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

HC32 MCU 示例代码库

厂商: 华大半导体 (HDSC / XHSC)
芯片: HC32F460

华大半导体 HC32F460 系列，基于 Cortex-M4 内核，主频 200MHz，工业级。

固件库版本一览

固件库名称	版本	芯片
HC32F460 Demo SDK	—	HC32F460

HC32 用的是 ddl 库（Device Driver Library），不是 STM32 那套标准外设库。函数命名风格是 PORT_xxx()、USART_xxx()、TIMER0_xxx()，配置全部通过 stc_xxx_t 结构体完成。两个和 STM32 最不一样的地方：

GPIO 不用开外设时钟，但其他外设都要 PWC_FcgxPeriphClockCmd()。

中断要手动注册：用 enIrqRegistration() 把「中断源」绑到「向量号」和「回调函数」上。

学习路线

建议按顺序阅读，由易到难，前面是后面的基础：

顺序	外设	学什么	难度
1	GPIO	点亮 LED，控制引脚高低电平	★
2	USART	串口收发 + printf 调试打印	★★
3	Timer0	定时中断，不再用死等延时	★★
4	KEY	按键输入 + 外部中断 + 消抖	★★
5	QSPI	外扩 Flash，映射地址直接读	★★★
6	SDIOC	SD 卡读写，GB 级存储	★★★
7	SPI LCD	彩屏显示文字与图形	★★★

前四章是必修基础（GPIO / 串口 / 定时器 / 中断），几乎所有项目都用得上。后三章是外设扩展（存储 + 显示），做完整产品时按需取用。

目录导航

左侧导航按外设模块分类。每个外设目录下有：

_index.md：该外设的原理讲解、寄存器概念、配置套路、引脚表
示例页：完整代码（带详细中文注释）+ 逐段讲解 + 实验现象 + 常见问题 + 拓展应用

所有代码都来自官方 HC32F460 Demo SDK 的 example/HC32F460JEUA/ 目录，每篇文档开头标注了对应的源码路径。

HC32 USART — 串口通信

Wed, 09 Sep 2026 09:00:00 +0800

USART — 让单片机开口说话

这一章讲什么

串口（UART / USART）是嵌入式里用得最多、最重要的通信方式，没有之一。

它的作用可以用一句话概括：让单片机和电脑（或另一个单片机）互相发送文字/数据。

为什么重要？因为它是你的调试神器。单片机没有屏幕、没有键盘，程序跑到哪一步了、变量值是多少，你怎么知道？就靠串口：单片机通过 printf 把信息发到电脑，你在电脑的串口助手里就能看到。这比「用 LED 闪几下猜状态」高效一百倍。

UART：异步串口，只用 TX（发）、RX（收）两根线，最常用。
USART：多了个同步模式（带时钟线），HC32 的模块叫 USART，但我们平时 99% 用的是它的 UART 功能。

串口通信的四要素

两个设备想用串口对上话，必须约定好四个参数，双方完全一致才能通信，否则收到的全是乱码：

参数	含义	常用值
波特率	每秒传多少个位（bit），即传输速度	9600、115200
数据位	一次传几位有效数据	8 位
停止位	每帧数据后面加几位「结束标志」	1 位
校验位	用来检错的额外位	无校验（None）

最常见的组合叫 115200-8-N-1：波特率 115200，8 位数据，无校验（N），1 位停止位。本例用的就是这个。

新手最常踩的坑：串口助手看到一堆乱码 锟斤拷 —— 十有八九是波特率设错了。单片机代码里是 115200，串口助手也必须选 115200。

HC32F460 的 USART 长什么样

HC32F460 一共有 4 个 USART 单元，在 ddl 里的名字是：

单元	ddl 写法
USART1	`M4_USART1`
USART2	`M4_USART2`
USART3	`M4_USART3`
USART4	`M4_USART4`

开发板默认用 USART2 做调试打印口（TX = PA15，RX = PA10），和板载的 USB 转串口芯片相连，插上 USB 就能在电脑上看到。

配置流程（比 GPIO 多几步）

USART 比 GPIO 复杂，因为它要开时钟、配引脚复用、设波特率。标准流程：

/* ① 开外设时钟（USART 必须开，这点和 GPIO 不同！）*/
PWC_Fcg1PeriphClockCmd(PWC_FCG1_PERIPH_USART2, Enable);

/* ② 把引脚设成 USART 复用功能 */
PORT_SetFunc(PortA, Pin10, Func_Usart2_Rx, Disable);   // RX
PORT_SetFunc(PortA, Pin15, Func_Usart2_Tx, Disable);   // TX

/* ③ 填初始化结构体（数据位/停止位/校验等）并初始化 */
USART_UART_Init(M4_USART2, &stcInitCfg);

/* ④ 单独设置波特率 */
USART_SetBaudrate(M4_USART2, 115200ul);

/* ⑤ 使能收发功能 */
USART_FuncCmd(M4_USART2, UsartRx, Enable);
USART_FuncCmd(M4_USART2, UsartTx, Enable);

对比 GPIO 你会发现最大的区别：外设时钟必须手动开。这是 HC32（以及大多数 MCU）的通用规则——除了 GPIO，几乎所有外设用之前都要先 PWC_FcgxPeriphClockCmd() 开时钟，忘了开就是「代码看着没错但外设死活不工作」。

收发数据的核心函数

函数	作用
`USART_SendData(ch, data)`	发送一个字节
`USART_RecData(ch)`	读取一个接收到的字节
`USART_GetStatus(ch, flag)`	查询状态标志（收到没？发完没？出错没？）
`USART_ClearStatus(ch, flag)`	清除状态标志

常用状态标志：

标志	含义
`UsartRxNoEmpty`	接收缓冲区非空（有新数据可读）
`UsartTxEmpty`	发送缓冲区空（可以发下一个字节了）
`UsartFrameErr` / `UsartParityErr` / `UsartOverrunErr`	各类接收错误

本章示例

示例	学到什么
串口轮询：收发与 printf 打印	轮询方式收发字节、`fputc` 重定向让 `printf` 走串口、错误处理

小结

串口是单片机的「嘴巴和耳朵」，更是头号调试工具。
通信四要素：波特率、数据位、停止位、校验位，双方必须一致。
乱码基本都是波特率没对齐。
HC32 有 4 个 USART，开发板调试口是 USART2。
USART 必须先开外设时钟，还要配引脚复用。

HC32 Timer0 — 基础定时器

Wed, 09 Sep 2026 09:00:00 +0800

Timer0 — 单片机的秒表和闹钟

这一章讲什么

定时器（Timer）是单片机里最有用的外设之一。你可以把它想象成一个能自动数数的计数器 + 闹钟：

它接一个时钟源，每来一个时钟脉冲就 +1，自动数数，完全不占用 CPU。
你给它设一个「目标值」（比较值 CmpValue），数到这个值时它就「闹铃」——触发一次中断，或者翻转一个信号。

有了它，你就能做很多精确定时的事：每隔 1 秒采一次温度、每隔 20 毫秒扫描一次按键、生成固定频率的方波……而且 CPU 不用像 Ddl_Delay1ms 那样傻等，可以去干别的活，时间到了定时器自然会通知它。

关于 PWM 的说明 HC32F460 里能直接输出 PWM 波形的是 TimerA / TimerB / Timer4/6 这些高级定时器。 Timer0 是「基础定时器」，它的强项是精确定时和产生周期性中断，本身没有独立的 PWM 输出引脚。不过定时器的思想是相通的：Timer0 产生固定周期的中断、在中断里翻转引脚，本质就是一个「软件方波发生器」，理解了它，再学硬件 PWM 就水到渠成。本章示例就演示 Timer0 最经典的用法——定时中断。

Timer0 的两种计数模式

这是 Timer0 最需要理解的概念。它有两种工作模式：

模式	ddl 写法	时钟源	特点
同步模式	`Tim0_Sync`	内部时钟 PCLK1	频率高、精度高，跟着系统时钟走
异步模式	`Tim0_Async`	外部低速晶振 XTAL32（32.768kHz）	频率低、超省电，可在低功耗下工作

同步（Sync）：用芯片内部的高速时钟 PCLK1 来数数。适合需要较高频率、较高精度的定时。
异步（Async）：用外部 32.768kHz 的低速晶振（就是钟表用的那种表晶）来数数。频率低但极省电，适合待机、RTC 类的慢速定时。

Timer0 有两个独立通道 ChannelA 和 ChannelB，可以分别配成不同模式——本章示例就把 A 通道配成异步、B 通道配成同步，同时跑。

定时周期怎么算

这是新手最关心的：「我想要 0.5 秒定时一次，比较值该填多少？」

公式很简单：

`1`	`定时时间 = (比较值 CmpValue + 1) × 分频系数 ÷ 时钟频率`

反过来求比较值：

`1`	`CmpValue = 时钟频率 ÷ 分频系数 × 定时时间 − 1`

举个例子（示例代码里 A 通道的算法）：

时钟源：XTAL32 = 32000 Hz（代码里按 32000 算）
分频：÷4
想要 0.5 秒翻转一次（即半个周期 0.5s）

`1`	`CmpValue = 32000 / 4 / 2 - 1 = 3999`

代码里写成 (uint16_t)(32000u/4u/2u - 1u)，数到 3999 就中断一次，正好 0.5 秒，翻转一次 LED → 1 秒一个亮灭周期。

分频（ClockDivision） 的作用：时钟太快、16 位计数器（最大 65535）数不过来时，先把时钟「除慢」。可选 Tim0_ClkDiv1（不分频）到 Tim0_ClkDiv1024（÷1024）等。

配置流程

Timer0 定时中断的标准套路：

/* ① 开 Timer0 外设时钟 */
PWC_Fcg2PeriphClockCmd(PWC_FCG2_PERIPH_TIM02, Enable);

/* ② 填基础配置：模式、时钟源、分频、比较值 */
stcTimerCfg.Tim0_CounterMode      = Tim0_Sync;
stcTimerCfg.Tim0_SyncClockSource  = Tim0_Pclk1;
stcTimerCfg.Tim0_ClockDivision    = Tim0_ClkDiv1024;
stcTimerCfg.Tim0_CmpValue         = 算出来的值;
TIMER0_BaseInit(M4_TMR02, Tim0_ChannelB, &stcTimerCfg);

/* ③ 使能通道中断 */
TIMER0_IntCmd(M4_TMR02, Tim0_ChannelB, Enable);

/* ④ 注册中断回调 + 配 NVIC（见下）*/
...

/* ⑤ 启动计数 */
TIMER0_Cmd(M4_TMR02, Tim0_ChannelB, Enable);

HC32 的中断注册机制（重点）

这是 HC32 和 STM32 差别最大的地方，务必理解。

STM32 的中断函数名是固定的（如 TIM2_IRQHandler），你直接写这个函数就行。

HC32F460 不一样：它有一批「可编程中断向量」（Int000_IRQn ~ Int031_IRQn 等），你需要手动把「某个中断源」绑定到「某个向量号」，并指定回调函数。这个绑定动作用 enIrqRegistration() 完成：

stc_irq_regi_conf_t stcIrqRegiConf;

stcIrqRegiConf.enIRQn      = Int001_IRQn;        // 用哪个向量号
stcIrqRegiConf.enIntSrc    = INT_TMR02_GCMA;     // 中断源：Timer0_2 通道A比较匹配
stcIrqRegiConf.pfnCallback = &Timer0A_CallBack;  // 中断发生时调用哪个函数
enIrqRegistration(&stcIrqRegiConf);              // 完成绑定

NVIC_ClearPendingIRQ(stcIrqRegiConf.enIRQn);              // 清挂起
NVIC_SetPriority(stcIrqRegiConf.enIRQn, DDL_IRQ_PRIORITY_15);  // 设优先级
NVIC_EnableIRQ(stcIrqRegiConf.enIRQn);                   // 使能 NVIC

记住这四件套：注册（enIrqRegistration）→ 清挂起 → 设优先级 → 使能 NVIC。以后所有需要中断的外设（定时器、按键、串口中断）都是这个流程，只是 enIntSrc 换成对应的中断源。

本章示例

示例	学到什么
Timer0 定时中断：双通道定时翻转 LED	同步/异步双模式、比较值计算、`enIrqRegistration` 中断注册、中断回调

小结

Timer0 是基础定时器，强项是精确定时和周期中断（PWM 输出要用 TimerA/B）。
两种模式：同步（PCLK1，高速高精度）、异步（XTAL32，低速省电）。
定时时间 = (比较值+1) × 分频 ÷ 时钟频率。
用之前先 PWC_Fcg2PeriphClockCmd 开时钟。
HC32 中断要手动注册：enIrqRegistration → 清挂起 → 设优先级 → 使能 NVIC。

HC32 KEY — 按键与外部中断

Wed, 09 Sep 2026 09:00:00 +0800

KEY — 让单片机听你的指挥

这一章讲什么

前面几章单片机都在「自说自话」（闪灯、发串口）。这一章开始，它要听你的了。

按键是最简单、最常见的输入设备。原理朴素到不能再朴素：

   3.3V
     │
    ┌┴┐ 上拉电阻（通常用芯片内部的）
    └┬┘
     ├──────▶ 单片机引脚（PC13）
     │
    ─┴─  按键（按下时导通）
     │
    GND

没按：引脚被上拉电阻拉到 3.3V → 读到高电平。
按下：按键把引脚直接连到 GND → 读到低电平。

所以「读按键」= 读这个引脚是高还是低。

两种读按键的方式

方式	做法	优点	缺点
轮询	主循环里反复 `PORT_GetBit()` 查电平	简单直观	CPU 一直在查，浪费；循环里有耗时操作就可能漏按
中断	配置引脚为外部中断，按下自动触发回调	CPU 不用查，响应快、不漏按	配置稍复杂

本章重点讲中断方式，因为它是实际项目里的标准做法。

EXINT——HC32 的外部中断模块

HC32F460 里管「引脚电平变化触发中断」的模块叫 EXINT（External Interrupt，外部中断）。

它有 16 个通道：ExtiCh00 ~ ExtiCh15。

关键规则：通道号和引脚编号是绑定的——ExtiCh13 只能用于任意端口的 Pin13（PA13、PB13、PC13…… 选一个）。开发板的按键接在 PC13，所以用 ExtiCh13。

这和 STM32 的 EXTI 线路机制几乎一模一样：EXTI13 只能接 PA13/PB13/PC13 中的一个。有 STM32 基础的话，这里可以直接迁移理解。

触发方式（边沿选择）

stcExtiConfig.enExtiLvl 决定「什么时候算触发」：

取值	含义	什么时候用
`ExIntFallingEdge`	下降沿（高→低）	按键按下的瞬间（最常用）
`ExIntRisingEdge`	上升沿（低→高）	按键松开的瞬间
`ExIntBothEdge`	双边沿（按下和松开都触发）	需要测按下时长时
`ExIntLowLevel`	低电平（只要是低就一直触发）	慎用，会疯狂进中断

上拉输入的按键，「按下」就是高变低，所以选 ExIntFallingEdge。

按键抖动与消抖（重要概念）

按键是机械开关。你按一下，金属触点在接触瞬间会**弹跳（Bounce）**几下，电平在几毫秒内高低乱跳：

理想：  ─────┐
             └──────────

现实：  ─────┐ ┌┐ ┌─┐
             └─┘└─┘ └────    ← 这几毫秒内可能触发好几次中断！

如果不处理，你按一下按键，程序可能认为你按了 3 下、5 下。这就是按键抖动。

消抖（Debounce）的三种做法：

硬件滤波（HC32 自带，最省事） EXINT 模块内置数字滤波器，把宽度小于滤波周期的毛刺直接吃掉：

1
2

stcExtiConfig.enFilterEn = Enable;      // 使能滤波
stcExtiConfig.enFltClk   = Pclk3Div8;   // 滤波时钟 = PCLK3/8

软件延时：检测到按下后 delay(10ms) 再确认一次电平。简单但阻塞。
等待释放：进中断后死等按键松开，天然把整个抖动过程包进去。SDK 的 BSP 就用这招。

HC32 的好处是硬件滤波开一行就行，大部分场景够用。

配置流程

按键中断的完整套路（和 Timer0 中断注册流程一致）：

/* ① 配置 EXINT 通道：通道号、滤波、触发边沿 */
stcExtiConfig.enExitCh   = ExtiCh13;
stcExtiConfig.enFilterEn = Enable;
stcExtiConfig.enFltClk   = Pclk3Div8;
stcExtiConfig.enExtiLvl  = ExIntFallingEdge;
EXINT_Init(&stcExtiConfig);

/* ② 配置引脚：使能外部中断输入 + 上拉 */
stcPortInit.enExInt  = Enable;
stcPortInit.enPullUp = Enable;
PORT_Init(PortC, Pin13, &stcPortInit);

/* ③ 注册中断（HC32 四件套）*/
stcIrqRegiConf.enIntSrc    = INT_PORT_EIRQ13;
stcIrqRegiConf.enIRQn      = Int000_IRQn;
stcIrqRegiConf.pfnCallback = &Key_Callback;
enIrqRegistration(&stcIrqRegiConf);
NVIC_ClearPendingIRQ(stcIrqRegiConf.enIRQn);
NVIC_SetPriority(stcIrqRegiConf.enIRQn, DDL_IRQ_PRIORITY_DEFAULT);
NVIC_EnableIRQ(stcIrqRegiConf.enIRQn);

注意第 ② 步：stcPortInit.enExInt = Enable 这一行是必须的——它告诉引脚「你的电平变化要送给 EXINT 模块」。忘了它，EXINT 配得再对也收不到信号。

中断标志必须手动清

void Key_Callback(void)
{
    if (Set == EXINT_IrqFlgGet(ExtiCh13))   // 确认真的是这个通道触发的
    {
        /* ... 你的处理 ... */
        EXINT_IrqFlgClr(ExtiCh13);          // 清标志！不清会反复进中断
    }
}

EXINT_IrqFlgClr() 千万不能忘。中断标志不清，硬件会认为「还有中断没处理」，一出中断立刻又进来，程序就死在中断里出不去了。这是外部中断的头号 bug。

本章示例

示例	学到什么
按键中断：按下触发回调	EXINT 配置、硬件滤波消抖、中断标志清除、`volatile` 标志位与主循环协作

开发板按键在哪

按键	引脚	ddl 写法	EXINT 通道	中断源
K1	PC13	`PortC, Pin13`	`ExtiCh13`	`INT_PORT_EIRQ13`

SDK 的 BSP 已封装好：调一次 BSP_KEY_Init() 就完成上面所有配置，按下按键后全局变量 u8GlobalKey 会被置 1。

BSP 文件位置：bsp/ev_hc32f460_lqfp100_v2/ev_hc32f460_lqfp100_v2.c

小结

按键接法：上拉 + 按下接地，所以「按下 = 低电平」。
HC32 外部中断模块叫 EXINT，16 个通道，通道号绑定引脚号（ExtiCh13 ↔ PinXX13）。
按下用 ExIntFallingEdge（下降沿）。
机械按键会抖动，必须消抖；HC32 有硬件滤波，一行搞定。
引脚配置里 enExInt = Enable 不能漏。
中断回调里 EXINT_IrqFlgClr() 不能漏。

HC32 QSPI — 四线串行 Flash 接口

Wed, 09 Sep 2026 09:00:00 +0800

QSPI — 给单片机外挂一块硬盘

这一章讲什么

单片机内部的 Flash 容量有限（HC32F460 是 512KB），如果你要存字库、图片、音频、大量数据日志，一下就不够用了。

解决办法：外挂一颗串行 Flash 芯片（最常见的是 W25Q64、W25Q128 这类，容量 8MB / 16MB，便宜且好买）。

而 QSPI（Queued/Quad SPI）就是连接这颗外部 Flash 的高速接口。

从 SPI 到 QSPI：多开几条车道

普通 SPI 传数据只有一根数据线（MOSI 发、MISO 收），像单车道公路。

QSPI 把数据线扩展到四根（IO0~IO3），四根线同时并行传，速度直接翻 4 倍——像四车道高速公路。

   普通 SPI（单线）：            QSPI（四线）：
   ┌─────┐   SCK  ┌──────┐     ┌─────┐   QSCK  ┌──────┐
   │     ├────────▶      │     │     ├─────────▶      │
   │ MCU │   MOSI │Flash │     │ MCU │   IO0   │Flash │
   │     ├────────▶      │     │     ├◀───────▶│      │
   │     │   MISO │      │     │     │   IO1   │      │
   │     │◀────────      │     │     ├◀───────▶│      │
   │     │   CS   │      │     │     │   IO2   │      │
   │     ├────────▶      │     │     ├◀───────▶│      │
   └─────┘        └──────┘     │     │   IO3   │      │
                               │     ├◀───────▶│      │
                               │     │   QSNSS │      │
                               │     ├─────────▶      │
                               └─────┘         └──────┘

HC32F460 的 QSPI 支持三种读模式，按速度从慢到快：

模式	ddl 写法	数据线数	说明
标准模式	`QspiReadModeStandard`	1 线	兼容性最好，写操作用它
双线模式	`QspiReadModeTwoWiresIO`	2 线	中等
四线模式	`QspiReadModeFourWiresIO`	4 线	最快，读操作用它

QSPI 最强的功能：ROM 映射访问

这是 QSPI 最爽的地方，也是它和普通 SPI 的本质区别。

普通 SPI 读 Flash：要发指令、发地址、再一个个字节读回来，写一堆代码。

QSPI 的 ROM 映射模式：把外部 Flash 直接「贴」到单片机的地址空间上。HC32F460 的映射基地址是：

`1`	`#define QSPI_BUS_ADDRESS (0x98000000ul)`

配好之后，你想读 Flash 里第 0 个字节，直接这样：

1
2

uint8_t *p = (uint8_t *)0x98000000;   // 指向 Flash 起始地址
uint8_t data = *p;                     // 像读普通内存一样直接读！

不需要发指令、不需要等待——硬件在后台自动帮你发送读指令、拉取数据。你就像读一个普通数组一样读 8MB 的 Flash。

这个能力太有用了：字库、图片资源可以直接用指针访问，甚至可以直接在外部 Flash 上运行代码（XIP，Execute In Place）。

两种工作模式：ROM 访问 vs 直通

模式	用途
ROM 访问模式 `QspiBusModeRomAccess`	读数据。映射到 0x98000000，像内存一样读
直通模式 `QSPI_EnterDirectCommMode()`	写数据、发指令。手动一个字节一个字节地发

为什么写要用直通模式？因为 Flash 的写入不是简单地「往地址里塞数据」，它需要一套指令序列（先写使能、再发页写指令、发地址、发数据、等待完成）。这些必须手动控制，所以要进直通模式。

直通模式的使用套路固定三步：

1
2
3

QSPI_EnterDirectCommMode();              // ① 进入直通模式
QSPI_WriteDirectCommValue(0x06);         // ② 发字节（这里是写使能指令）
QSPI_ExitDirectCommMode();               // ③ 退出直通模式

读回一个字节用 QSPI_ReadDirectCommValue()。

必须懂的 Flash 常识

外部 Flash（NOR Flash）有几个「反直觉」的特性，不理解就写不对代码：

1. 写之前必须先擦除

Flash 的物理特性是：擦除是把位变成 1，写入只能把 1 变成 0，不能把 0 变回 1。

所以你想改一个已经写过的地方，必须先擦除（全变 1）再写。直接覆盖写会得到错误数据。

2. 擦除的最小单位是「扇区」，不是字节

`1`	`#define FLASH_SECTOR_SIZE (0x1000u) // 4096 字节 = 4KB`

你想改 1 个字节，也必须把整个 4KB 扇区全擦掉。这就是 Flash 编程最麻烦的地方——想改一个字节，标准流程是：读出整个 4KB → 在内存里改那个字节 → 擦除这 4KB → 写回去。

3. 写入的最大单位是「页」

`1`	`#define FLASH_PAGE_SIZE (0x100u) // 256 字节`

一条页写指令最多写 256 字节，而且不能跨页边界。要写更多数据，得拆成多次页写。

4. 每次写/擦之前要「写使能」

Flash 默认是写保护的，防止误操作。每条写/擦指令前都要先发一次写使能指令（0x06）。而且写使能是一次性的，执行完一条写操作就自动失效，下次写还得再发。

5. 写/擦需要时间，必须等待完成

Flash 内部编程需要毫秒级时间。发完写指令后要不断读状态寄存器，直到「忙碌位（Busy）」变 0 才算完成。这就是代码里 WaitForWriteEnd() 干的事。

常用 Flash 指令表

这些指令是 NOR Flash 的行业标准（W25Qxx / GD25Qxx / MX25L 都通用）：

指令码	名称	作用
`0x06`	Write Enable	写使能（写/擦之前必发）
`0x02`	Page Program	页写（最多 256 字节）
`0x20`	Sector Erase	擦除 4KB 扇区
`0xC7`	Chip Erase	全片擦除（慎用，很慢）
`0x05`	Read Status Reg 1	读状态寄存器 1（含 Busy 位）
`0x35`	Read Status Reg 2	读状态寄存器 2
`0x15`	Read Status Reg 3	读状态寄存器 3

状态寄存器 1 的第 0 位（bit0）是 Busy 位：为 1 表示 Flash 正忙，为 0 表示空闲。

`1`	`#define FLASH_BUSY_BIT_MASK (0x01u)`

本章示例

示例	学到什么
QSPI Flash 读写：擦除、页写、映射读回校验	QSPI 初始化、直通模式发指令、扇区擦除、页写、ROM 映射读、`memcmp` 校验

开发板 QSPI 引脚

信号	引脚	作用
QSPCK	PB14	时钟
QSNSS	PB1	片选（低有效）
QSIO0	PB13	数据线 0
QSIO1	PB12	数据线 1
QSIO2	PB10	数据线 2
QSIO3	PB2	数据线 3

引脚复用统一用 Func_Qspi：

`1`	`PORT_SetFunc(PortB, Pin14, Func_Qspi, Disable); // 六根线都这样配`

小结

QSPI = 四线 SPI，比普通 SPI 快 4 倍，专门接外部串行 Flash。
杀手级功能：ROM 映射——Flash 映射到 0x98000000，用指针直接读。
读用 ROM 映射模式，写用直通模式（因为写要发指令序列）。
Flash 四条铁律：先擦后写、擦以 4KB 扇区为单位、写以 256B 页为单位、写前要写使能、写后要等完成。
指令码是行业标准：0x06 写使能、0x02 页写、0x20 扇区擦除、0x05 读状态。

HC32 SDIOC — SD 卡接口

Wed, 09 Sep 2026 09:00:00 +0800

SDIOC — 给单片机插一张存储卡

这一章讲什么

上一章的 QSPI Flash 是焊死在板子上的，容量 8MB 左右。如果你要存几个 GB 的数据，或者希望把存储介质拔下来插到电脑上看，那就该用 SD 卡 / TF 卡了。

SDIOC（SD Input/Output Controller）就是 HC32F460 里专门驱动 SD 卡的硬件控制器。

SD 卡的好处很直白：

容量大：几 GB 到几十 GB，随便买。
可插拔：数据存好了，卡拔下来插电脑读，超方便。
有文件系统：配合 FatFS 就能直接读写 .txt、.csv、.wav 文件，电脑也认。

代价是：SD 卡的协议比 SPI Flash 复杂得多（初始化要走一整套握手流程），好在 ddl 库把这些都封装好了。

SDIOC 的引脚

SD 卡通信需要 CLK + CMD + 数据线 三类信号：

信号	引脚	作用
CK（时钟）	PB15	主机给卡的时钟
CMD（命令）	PA6	双向，发命令、收响应
D0	PB4	数据线 0
D1	PA8	数据线 1
D2	PA9	数据线 2
D3	PB5	数据线 3
CD（检测）	PH2	检测卡有没有插入（可选）

引脚复用统一用 Func_Sdio：

`1`	`PORT_SetFunc(PortB, Pin15, Func_Sdio, Disable); // 每根线都这样配`

HC32F460 有两个 SDIOC 单元：M4_SDIOC1、M4_SDIOC2。

总线宽度：1 线还是 4 线

总线宽度	ddl 写法	数据线	速度
1 位	`SdiocBusWidth1Bit`	只用 D0	慢，但省引脚
4 位	`SdiocBusWidth4Bit`	D0~D3 一起用	快 4 倍，推荐

和 QSPI 一个道理——多开几条车道就快几倍。4 线模式是标准做法。

时钟频率与速度模式

1
2

SdiocClk50M              // 50MHz 时钟
SdiocHighSpeedMode       // 高速模式

模式	最高时钟	理论带宽（4 线）
普通速度 `SdiocNormalSpeedMode`	25MHz	~12.5 MB/s
高速 `SdiocHighSpeedMode`	50MHz	~25 MB/s

高速 + 4 线是性能最优组合，本章示例用的就是这个。

实际速度还受卡本身速度等级（Class 10、U1、U3）限制。买卡别买山寨的，杂牌卡不仅慢，还容易初始化失败。

核心概念：SD 卡按「扇区」读写

这是 SD 卡最重要的概念，理解了它才能写对代码。

SD 卡的最小读写单位是一个「块」（Block），也叫「扇区」（Sector），固定 512 字节。

你不能只读一个字节，也不能只写 100 字节。所有操作都是「从第 N 个扇区开始，读/写 M 个扇区」。

   SD 卡内部（就是一长串 512 字节的格子）
   ┌────────┬────────┬────────┬────────┬─────
   │ 扇区0  │ 扇区1  │ 扇区2  │ 扇区3  │ ...
   │ 512B   │ 512B   │ 512B   │ 512B   │
   └────────┴────────┴────────┴────────┴─────
     ↑
     地址 = 扇区号（不是字节地址！）

所以数据缓冲区的大小必须是 512 的整数倍：

1
2

static uint32_t au32WriteBlocks[512];   // 512 个 uint32_t = 2048 字节 = 4 个扇区
#define SD_SECTOR_COUNT   (4u)          // 正好对应 4 个扇区

这个对应关系必须严格匹配，不匹配就会读写越界，是新手最容易出错的地方。

对比一下三种存储器的操作单位，很好记：

存储器读单位写单位擦除单位

SPI Flash (QSPI) 任意字节 ≤256B 页 4KB 扇区

SD 卡 512B 扇区 512B 扇区 512B 扇区

内部 EEPROM 任意字节任意字节 —

SDCARD 驱动库接口

ddl 库在 SDIOC 之上封装了一层 SDCARD_xxx 函数（在 sd_card.h 里），用起来很简单：

函数	作用
`SDCARD_Init(&handle, &cfg)`	初始化 SD 卡（内部完成一整套上电握手、识别容量）
`SDCARD_ReadBlocks(&handle, 起始扇区, 扇区数, 缓冲区, 超时)`	读多个扇区
`SDCARD_WriteBlocks(&handle, 起始扇区, 扇区数, 缓冲区, 超时)`	写多个扇区
`SDCARD_Erase(&handle, 起始扇区, 扇区数, 超时)`	擦除多个扇区

注意每个函数最后都有个超时参数（单位是内部循环次数/毫秒量级）。SD 卡操作可能很慢（尤其擦除），超时给太小会误判失败。示例里擦除给 20000、读写给 2000~20000。

初始化用两个结构体：

stc_sd_handle_t stcSdhandle;                 // 卡句柄，保存卡的信息和状态
stcSdhandle.SDIOCx = M4_SDIOC1;              // 指定用哪个 SDIOC 单元

stc_sdcard_init_t stcCardInitCfg = {
    SdiocBusWidth4Bit,        // 4 线
    SdiocClk50M,              // 50MHz
    SdiocHighSpeedMode,       // 高速
    NULL,                     // DMA 配置（NULL = 不用 DMA，走轮询）
};

SDCARD_Init(&stcSdhandle, &stcCardInitCfg);

最后那个 NULL 就是 DMA 配置。传 NULL 表示用 CPU 轮询搬数据；传 DMA 配置结构体就变成 DMA 传输（CPU 不参与搬运，效率高得多，适合大数据量）。SDK 里有对应的 DMA 版本示例。

本章示例

示例	学到什么
SD 卡读写：擦除、写入、读回校验	SDIOC 引脚配置、4 线高速初始化、扇区读写、擦除后数据验证、`memcmp` 校验

小结

SDIOC 是 HC32F460 驱动 SD/TF 卡的硬件控制器，有两个单元。
引脚：CK + CMD + D0~D3（4 线），复用为 Func_Sdio。
4 线 + 高速（50MHz） 是性能最优组合。
SD 卡按 512 字节扇区读写，缓冲区大小必须是 512 的整数倍，且和扇区数严格对应。
用 SDCARD_Init / ReadBlocks / WriteBlocks / Erase 四个函数即可，每个都带超时参数。
传 NULL 走轮询，传 DMA 配置走 DMA（大数据量首选）。

HC32 SPI LCD — 彩屏显示

Wed, 09 Sep 2026 09:00:00 +0800

SPI LCD — 让单片机有一块屏

这一章讲什么

到现在为止，我们和单片机交流的方式还很原始：看 LED 闪几下、在电脑串口助手里看文字。

这一章给它装上一块彩色屏幕。有了屏，单片机就能显示数字、文字、曲线、图片，做出真正像「产品」的东西。

用的屏是 ST7789 驱动的 TFT 彩屏（0.96 寸或 1.14 寸），通过 SPI 接口连接。这类小彩屏在电子市场几块钱一片，是最流行的入门显示方案。

SPI 是什么

SPI（Serial Peripheral Interface，串行外设接口）是一种高速同步串行通信协议。它有四根标准信号线：

信号	全称	作用
SCK	Serial Clock	时钟，主机产生
MOSI	Master Out Slave In	主机发 → 从机收
MISO	Master In Slave Out	从机发 → 主机收
CS / NSS	Chip Select	片选，低有效

驱动 LCD 有个特点：数据只需要单向流动（往屏上写，不需要读回来）。所以 MISO 可以省掉，只用 SCK + MOSI，这就叫 SPI 三线模式。

HC32F460 有 4 个 SPI 单元（M4_SPI1 ~ M4_SPI4），本章用的是 SPI3。

LCD 除了 SPI 还要三根控制线

这是驱动 LCD 和驱动普通 SPI 设备最大的区别。除了 SCK/MOSI，还必须有三根 GPIO 控制线：

控制线	全称	作用
DC	Data/Command	最关键：区分现在发的是「命令」还是「数据」
RST	Reset	硬件复位，上电时必须拉低再拉高一次
PWR / BLK	Power / Backlight	背光开关（不开背光屏是黑的！）

DC 脚为什么最关键

LCD 屏内部有个控制器（ST7789），它要接收两类东西：

命令：告诉屏「接下来要设置显示窗口了」、「开始写像素了」、「进入睡眠」
数据：具体的参数值、像素颜色值

问题是：SPI 只有一根数据线，怎么让屏知道刚发过去的这个字节是命令还是数据？

答案就是 DC 脚：

1
2

   DC = 0 (低电平)  →  这个字节是【命令】
   DC = 1 (高电平)  →  这个字节是【数据】

驱动库里就是这么用的：

#define LCD_DC(n)  (n ? PORT_SetBits(LCD_DC_GPIO_Port, LCD_DC_Pin)   \
                      : PORT_ResetBits(LCD_DC_GPIO_Port, LCD_DC_Pin))

/* 发命令 */
LCD_DC(0);  SPI_发送(0x2A);

/* 发数据 */
LCD_DC(1);  SPI_发送(0x00);

新手最常见的「屏白屏/花屏」问题，很多就是 DC 脚接错或者时序不对。

RGB565 颜色格式

屏是 16 位色的，一个像素用 2 个字节（16 位）表示颜色，格式叫 RGB565：

1
2
3

   位:  15 14 13 12 11 | 10 9 8 7 6 5 | 4 3 2 1 0
        ├─── R (5位) ──┤├─── G (6位) ─┤├─ B (5位) ┤
             红 32级         绿 64级        蓝 32级

红占 5 位（32 个等级）
绿占 6 位（64 个等级，人眼对绿色最敏感，所以多给一位）
蓝占 5 位（32 个等级）

一共 2¹⁶ = 65536 种颜色。

驱动库预定义了常用颜色：

#define WHITE     0xFFFF     // 全 1 = 白
#define BLACK     0x0000     // 全 0 = 黑
#define RED       0xF800     // 高 5 位全 1 = 纯红
#define GREEN     0x07E0     // 中 6 位全 1 = 纯绿
#define BLUE      0x001F     // 低 5 位全 1 = 纯蓝
#define YELLOW    0xFFE0     // 红+绿 = 黄
#define MAGENTA   0xF81F     // 红+蓝 = 品红
#define CYAN      0x7FFF     // 青
#define BRED      0XF81F
#define GRED      0XFFE0
#define GBLUE     0X07FF

自己算一个颜色的公式：

1
2

uint16_t color = ((R & 0xF8) << 8) | ((G & 0xFC) << 3) | (B >> 3);
// R,G,B 是 0~255 的常规值

比如橙色 RGB(255,128,0)：((255&0xF8)<<8) | ((128&0xFC)<<3) | (0>>3) = 0xFC00。

横屏与竖屏

驱动库用一个宏控制屏幕方向：

`1`	`#define USE_HORIZONTAL 2 // 0 或 1 = 竖屏；2 或 3 = 横屏`

方向不同，宽高定义也跟着变：

#if USE_HORIZONTAL==0 || USE_HORIZONTAL==1
  #define LCD_Width  135      // 竖屏
  #define LCD_Height 240
#else
  #define LCD_Width  240      // 横屏
  #define LCD_Height 240
#endif

1.14 寸屏的物理分辨率是 240×135。改这个宏时，屏幕内容会跟着旋转 90°。如果你发现显示内容是躺着的，改这个宏就对了。

驱动库提供的绘图函数

tftlcd.h 里已经封装好了一整套绘图 API，拿来就能用：

函数	作用
`LCD_Init()`	初始化屏（内含 SPI 初始化、复位、寄存器配置）
`LCD_Clear(color)`	整屏填充某个颜色（清屏）
`LCD_Fill(x1,y1,x2,y2,color)`	填充一个矩形区域
`LCD_Draw_Point(x,y)`	用当前画笔色画一个点
`LCD_Draw_ColorPoint(x,y,color)`	画一个指定颜色的点
`LCD_DrawLine(x1,y1,x2,y2)`	画线
`LCD_DrawRectangle(x1,y1,x2,y2)`	画矩形框
`LCD_Draw_Circle(x0,y0,r)`	画圆
`LCD_ShowChar(x,y,chr,size)`	显示一个字符
`LCD_ShowString(x,y,w,h,size,p)`	显示字符串
`LCD_ShowNum(x,y,num,len,size)`	显示数字
`LCD_Show_Image(x,y,w,h,p)`	显示图片（位图数据）
`LCD_DisplayOn()` / `LCD_DisplayOff()`	开/关显示
`LCD_Address_Set(x1,y1,x2,y2)`	设置写入窗口（底层函数）

还有两个全局颜色变量：

1
2

extern uint16_t POINT_COLOR;   // 画笔颜色（前景色）
extern uint16_t BACK_COLOR;    // 背景颜色

LCD_ShowString、LCD_Draw_Point 这些函数会用这两个变量。想换字的颜色，改 POINT_COLOR 就行，不用给每个函数传参。

本章示例

示例	学到什么
SPI LCD 显示：文字与全屏刷色	`LCD_Init` 初始化、`LCD_ShowString` 显示文字、`LCD_Fill` 刷屏、颜色变量用法

开发板 LCD 接线

信号	引脚	类型	说明
SCK	PB6	SPI3 复用 `Func_Spi3_Sck`	时钟
MOSI	PB7	SPI3 复用 `Func_Spi3_Mosi`	数据（单向）
DC	PB8	普通 GPIO 输出	命令/数据选择
RST	PB9	普通 GPIO 输出	硬件复位
PWR	PB3	普通 GPIO 输出	背光/电源

注意区别：SCK/MOSI 要配成 SPI 复用功能，DC/RST/PWR 是普通 GPIO 输出。

驱动库还支持用 DMA 传输像素数据（M4_DMA1，TX 用 DmaCh1），刷屏速度能提升很多。

小结

LCD 用 SPI 三线模式（只要 SCK + MOSI，不需要 MISO）。
除 SPI 外必须有三根 GPIO：DC（命令/数据）、RST（复位）、PWR（背光）。
DC = 0 发命令，DC = 1 发数据，这是驱动 LCD 的核心机制。
颜色是 RGB565（红5 + 绿6 + 蓝5 = 16 位），共 65536 色。
USE_HORIZONTAL 宏控制横屏/竖屏。
驱动库已封装好画点、线、圆、文字、图片的完整 API，直接调用即可。

存储器	读单位	写单位	擦除单位
SPI Flash (QSPI)	任意字节	≤256B 页	4KB 扇区
SD 卡	512B 扇区	512B 扇区	512B 扇区
内部 EEPROM	任意字节	任意字节	—

HC32F460 on CLing

HC32 GPIO — 通用输入输出口

GPIO — 从点亮一颗 LED 开始

这一章讲什么

HC32F460 的 GPIO 长什么样

核心配置结构体

读写引脚的四个函数

本章示例

开发板上的 LED 在哪

小结

HC32 GPIO 输出 — 点亮并闪烁 LED

GPIO 输出：点亮并闪烁 LED

1. 功能简介

2. 硬件准备

3. 完整代码

4. 代码分段讲解

4.1 三步配置法

4.2 三颗灯共用一份配置

4.3 为什么先 SetBits 拉高

4.4 主循环：翻转 + 延时

5. 实验现象

6. 常见问题

7. 小结

8. 拓展应用

HC32 QSPI Flash 读写 — 擦除、页写与映射读回校验

QSPI Flash 读写：擦除、页写与映射读回校验

1. 功能简介

2. 硬件准备

3. 完整代码

4. 代码分段讲解

4.1 最精彩的一行：映射读

4.2 为什么写之前要切成标准模式

4.3 三字节地址的拆分

4.4 忙碌等待与超时保护

4.5 写操作的六步固定流程

4.6 参数检查是好习惯

5. 实验现象

6. 常见问题

7. 小结

8. 拓展应用

HC32 SD 卡读写 — 擦除、写入与读回校验

SD 卡读写：擦除、写入与读回校验

1. 功能简介

2. 硬件准备

3. 完整代码

4. 代码分段讲解

4.1 缓冲区大小和扇区数必须严格对应

4.2 为什么要关掉 JTAG 调试脚

4.3 错误累积的写法

4.4 擦除后的验证很有讲究

4.5 用递增数据做测试的妙处

4.6 超时参数为什么不一样

4.7 ARRAY_SZ 和 MEM_ZERO_STRUCT

5. 实验现象

6. 常见问题

7. 小结

8. 拓展应用

HC32 SPI LCD 显示 — 文字输出与全屏刷色

SPI LCD 显示：文字输出与全屏刷色

1. 功能简介

2. 硬件准备

3. 完整代码

4. 代码分段讲解

4.1 LCD_Init() 一句话干了一大堆事

4.2 颜色变量：一次设置，全局生效

4.3 LCD_ShowString 的五个参数

4.4 LCD_Fill 全屏刷色

4.5 注意：文字会被覆盖

4.6 只刷了一次却看到交替？

5. 实验现象

6. 常见问题

7. 小结

8. 拓展应用

HC32 Timer0 定时中断 — 双通道周期翻转 LED

Timer0 定时中断：双通道周期翻转 LED

1. 功能简介

2. 硬件准备

3. 完整代码

4. 代码分段讲解

4.1 中断回调放在最前面

4.7 `ARRAY_SZ` 和 `MEM_ZERO_STRUCT`

4.1 `LCD_Init()` 一句话干了一大堆事

4.3 `LCD_ShowString` 的五个参数

4.4 `LCD_Fill` 全屏刷色

4.3 `enExInt = Enable` 是命门

4.6 `EXINT_IrqFlgClr` 不能忘

4.1 `fputc` 重定向——printf 能用的秘密