野火 on CLing

STM32 GPIO 输出 — 使用 HAL 库点亮 LED 灯

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

STM32 GPIO 输出 — 使用 HAL 库点亮 LED 灯

开发板：野火 EBF STM32F103 Mini
固件库：HAL 库（STM32CubeF1）
对应例程：9-GPIO输出—使用固件库点亮LED灯
参考源码：User/main.c、User/led/bsp_led.c、User/led/bsp_led.h

GPIO（General Purpose Input/Output，通用输入输出）是 MCU 上最基础、最常用的外设，几乎所有实验都从点亮一颗 LED 开始。输出模式让我们能用代码控制引脚输出高/低电平，从而驱动 LED、蜂鸣器、继电器等。本文是整套外设教程的起点，务必吃透。

一、功能简介

本实验把开发板上的两颗 LED（LED1、LED2）对应的 GPIO 引脚配置为推挽输出模式，在主循环中轮流点亮、熄灭，实现简单的"流水灯"效果。

LED1：周期性亮 1 秒、灭 1 秒
LED2：在 LED1 熄灭后再亮 1 秒、灭 1 秒

通过这个例子，你会掌握：

HAL 工程的入口 main() 与系统时钟初始化套路；
如何用 GPIO_InitTypeDef 结构体配置一个引脚；
用 HAL_GPIO_Init() 把配置写入寄存器；
用 HAL_GPIO_WritePin() 或宏控制引脚电平。

二、硬件准备

项目	说明
开发板	野火 EBF STM32F103 Mini（主控 STM32F103xC，最高 72MHz）
LED 引脚	LED1 → PC2，LED2 → PC3（低电平点亮，即"灌电流"接法）
调试器	ST-Link V2（或兼容下载器）
软件	STM32CubeIDE / Keil MDK + 野火提供的 HAL 工程

小提示：本板 LED 为低电平点亮（共阳接法）。所以在代码里用 GPIO_PIN_RESET（0）表示亮、GPIO_PIN_SET（1）表示灭，与直观的"高电平亮"相反。

三、完整代码（带中文注释）

1. main.c（主程序）

/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "stm32f1xx.h"
#include "./led/bsp_led.h"

/**
  * @brief  主函数
  * @param  无
  * @retval 无
  */
int main(void)
{
    /* 系统时钟初始化成 72 MHz（HAL 工程的标配第一步） */
    SystemClock_Config();

    /* LED 端口初始化：把 PC2、PC3 配置成推挽输出 */
    LED_GPIO_Config();

    /* 控制 LED 灯：循环里依次翻转电平 */
    while (1)
    {
        LED1( ON );             // LED1 亮（宏 ON = GPIO_PIN_RESET = 低电平）
        HAL_Delay(1000);        // 阻塞延时 1000ms（基于 SysTick）
        LED1( OFF );            // LED1 灭

        LED2( ON );             // LED2 亮
        HAL_Delay(1000);
        LED2( OFF );            // LED2 灭
    }
}

/**
  * @brief  System Clock Configuration
  *         系统时钟配成：HSE(8M) -> PLL×9 -> 72MHz SYSCLK
  */
void SystemClock_Config(void)
{
  RCC_ClkInitTypeDef clkinitstruct = {0};
  RCC_OscInitTypeDef oscinitstruct = {0};

  /* 使能 HSE 晶振，并以 HSE 作为 PLL 的时钟源 */
  oscinitstruct.OscillatorType  = RCC_OSCILLATORTYPE_HSE;
  oscinitstruct.HSEState        = RCC_HSE_ON;
  oscinitstruct.HSEPredivValue  = RCC_HSE_PREDIV_DIV1;
  oscinitstruct.PLL.PLLState    = RCC_PLL_ON;
  oscinitstruct.PLL.PLLSource   = RCC_PLLSOURCE_HSE;
  oscinitstruct.PLL.PLLMUL      = RCC_PLL_MUL9;   // 8MHz × 9 = 72MHz
  if (HAL_RCC_OscConfig(&oscinitstruct) != HAL_OK)
  {
    while(1);                  // 时钟配置失败，卡死在此
  }

  /* 选择 PLL 作为系统时钟，并配置 AHB/APB 分频 */
  clkinitstruct.ClockType = (RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_HCLK |
                             RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2);
  clkinitstruct.SYSCLKSource   = RCC_SYSCLKSOURCE_PLLCLK;
  clkinitstruct.AHBCLKDivider  = RCC_SYSCLK_DIV1;   // HCLK = 72MHz
  clkinitstruct.APB2CLKDivider = RCC_HCLK_DIV1;     // PCLK2 = 72MHz
  clkinitstruct.APB1CLKDivider = RCC_HCLK_DIV2;     // PCLK1 = 36MHz
  if (HAL_RCC_ClockConfig(&clkinitstruct, FLASH_LATENCY_2) != HAL_OK)
  {
    while(1);
  }
}

2. bsp_led.h（LED 引脚宏定义）

#ifndef __LED_H
#define	__LED_H

#include "stm32f1xx.h"

/* 引脚定义：LED1 -> PC2，LED2 -> PC3 */
#define LED1_PIN                  GPIO_PIN_2
#define LED1_GPIO_PORT            GPIOC
#define LED1_GPIO_CLK_ENABLE()   __HAL_RCC_GPIOC_CLK_ENABLE()

#define LED2_PIN                  GPIO_PIN_3
#define LED2_GPIO_PORT            GPIOC
#define LED2_GPIO_CLK_ENABLE()   __HAL_RCC_GPIOC_CLK_ENABLE()

/* LED 亮灭宏：本板低电平点亮，故 ON=0、OFF=1 */
#define ON  GPIO_PIN_RESET
#define OFF GPIO_PIN_SET

/* 带参宏，像内联函数一样使用，底层调用 HAL 写引脚 */
#define LED1(a)  HAL_GPIO_WritePin(LED1_GPIO_PORT, LED1_PIN, a)
#define LED2(a)  HAL_GPIO_WritePin(LED2_GPIO_PORT, LED2_PIN, a)

void LED_GPIO_Config(void);

#endif /* __LED_H */

3. bsp_led.c（GPIO 初始化）

#include "./led/bsp_led.h"

/**
  * @brief  初始化控制 LED 的 IO
  */
void LED_GPIO_Config(void)
{
    /* 定义一个 GPIO_InitTypeDef 类型的结构体 */
    GPIO_InitTypeDef  GPIO_InitStruct;

    /* 开启 LED 相关的 GPIO 外设时钟（任何外设使用前必须先开时钟！） */
    LED1_GPIO_CLK_ENABLE();
    LED2_GPIO_CLK_ENABLE();

    /* 选择要控制的 GPIO 引脚 */
    GPIO_InitStruct.Pin   = LED1_PIN;

    /* 设置引脚为推挽输出 */
    GPIO_InitStruct.Mode  = GPIO_MODE_OUTPUT_PP;

    /* 设置引脚为上拉（输出模式下上拉可让空闲电平更稳定） */
    GPIO_InitStruct.Pull  = GPIO_PULLUP;

    /* 设置引脚速率为高速 */
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;

    /* 调用库函数，用上面的配置初始化 GPIO */
    HAL_GPIO_Init(LED1_GPIO_PORT, &GPIO_InitStruct);

    /* LED2 用同样的配置初始化 */
    GPIO_InitStruct.Pin = LED2_PIN;
    HAL_GPIO_Init(LED2_GPIO_PORT, &GPIO_InitStruct);
}

四、代码分段讲解

1. 为什么先开时钟？

STM32 为了省电，每个外设的时钟默认都是关闭的。使用任何 GPIO 端口前，必须先用 __HAL_RCC_GPIOC_CLK_ENABLE() 打开它的时钟，否则写寄存器不会生效。这是 STM32 初学者最容易踩的坑。

2. `GPIO_InitTypeDef` 四个关键字段

字段	作用	本例取值
`Pin`	要配置的引脚号	`GPIO_PIN_2` / `GPIO_PIN_3`
`Mode`	工作模式	`GPIO_MODE_OUTPUT_PP`（推挽输出）
`Pull`	上下拉	`GPIO_PULLUP`
`Speed`	翻转速率	`GPIO_SPEED_FREQ_HIGH`

调用 HAL_GPIO_Init() 后，HAL 会把结构体里的参数写进对应端口的 CRL/CRH 配置寄存器。

3. 推挽输出 vs 开漏输出

推挽输出（PP）：引脚可主动输出高、低电平，驱动能力强，适合直接驱动 LED。
开漏输出（OD）：只能拉低或"高阻"，需要外部上拉电阻才能输出高电平，常用于 I2C 等需要"线与"的总线（后文 I2C 章节会用到）。

4. `HAL_Delay()` 从哪来？

HAL_Delay() 依赖 SysTick 定时器（HAL 在 HAL_Init() 里已默认配置好）。它本质是阻塞延时，会占用 CPU。后续章节我们会用定时器中断实现"非阻塞"延时。

5. 宏的妙用

LED1(ON) 实际展开为 HAL_GPIO_WritePin(GPIOC, GPIO_PIN_2, GPIO_PIN_RESET)。把"硬件引脚"和"业务逻辑"解耦，换板子时只改头文件宏即可，这就是**板级支持包（BSP）**的思想。

五、实验现象

编译下载程序，开发板复位后：
- 第 1 秒：LED1 亮，LED2 灭
- 第 2 秒：LED1 灭，LED2 亮
- 如此循环，呈现交替闪烁的流水灯效果。
若 LED 不亮，先确认下载成功、开发板供电正常，再检查引脚定义是否与你的硬件一致。

六、常见问题

Q1：程序下载了但 LED 完全不亮？

检查是否调用了 LED_GPIO_Config()；
确认 GPIO 时钟已开启；
确认 LED 是低电平点亮还是高电平点亮（本板为低电平点亮，若你用的是高电平点亮板，需把 ON/OFF 宏反过来）。

Q2：LED 一直亮着不闪烁？

多半是 HAL_Delay() 没生效——确认系统时钟和 HAL_Init() 已正确初始化（本例在 SystemClock_Config 已配好 72MHz）；
也可能是编译器把死循环优化掉了（一般不会，可尝试加 volatile）。

Q3：想同时亮两颗 LED 怎么办？

直接连续调用 LED1(ON); LED2(ON); 即可；想要"呼吸灯"效果则需 PWM（见后续 TIM 章节）。

七、小结

GPIO 输出模式是 STM32 编程的"Hello World"；
“开时钟 → 配置结构体 → HAL_GPIO_Init → 控制电平” 是标准四步法，后面所有外设都遵循这个套路；
推挽输出适合直接驱动 LED；亮灭电平方向由硬件电路决定，务必结合原理图。

八、拓展应用

改造成宏定义的翻转宏：用 HAL_GPIO_TogglePin() 实现 500ms 翻转一次，比"亮-延时-灭"更简洁。
控制蜂鸣器：把 LED 引脚换成蜂鸣器引脚（参考工程 GPIO输出—蜂鸣器），注意加三极管驱动。
非阻塞闪烁：用后面学的基本定时器产生 1ms 时基，在定时器回调里累计时间翻转 LED，主循环就能腾出手做别的事。
PWM 调光：结合 TIM 的 PWM 输出，让 LED 实现渐亮渐暗的呼吸灯效果。

STM32 GPIO 输入 — 按键检测（轮询方式）

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

STM32 GPIO 输入 — 按键检测（轮询方式）

开发板：野火 EBF STM32F103 Mini
固件库：HAL 库
对应例程：10-GPIO输入—按键检测
参考源码：User/main.c、User/key/bsp_key.c、User/key/bsp_key.h、User/led/bsp_led.h

上篇我们学会了让引脚输出电平来驱动 LED，本篇反过来——让引脚读取外部电平，最常见的用途就是按键检测。按键是嵌入式系统最基本的人机交互输入。

一、功能简介

实验板上有两颗用户按键 KEY1、KEY2。程序在 while(1) 里不断轮询（主动查询）按键引脚电平：一旦检测到某颗按键被按下，就翻转对应的 LED。

KEY1 按下 → LED1 翻转（亮变灭 / 灭变亮）
KEY2 按下 → LED2 翻转

核心知识点：

把 GPIO 配置为输入模式（浮空/上拉/下拉）；
用 HAL_GPIO_ReadPin() 读取引脚电平；
理解机械按键的抖动，并用"等待释放"做简单消抖。

二、硬件准备

项目	说明
开发板	野火 EBF STM32F103 Mini
按键引脚	KEY1 → PA0（按下为高电平），KEY2 → PC13（按下为高电平）
LED 引脚	LED1 → PC2，LED2 → PC3（低电平点亮）
调试器	ST-Link V2

硬件原理：本板按键一端接地、一端接 GPIO，并外接上拉电阻。按键未按时 GPIO 被上拉为高；按下时 GPIO 直接接地变为低——但野火 Mini 的 KEY 例程里 KEY_ON 定义为 1（高电平有效），说明该板按键是"按下输出高"的接法（按键另一端接 3.3V）。接线以你的原理图为准，代码里的 KEY_ON 宏用于适配这种差异。

三、完整代码（带中文注释）

1. main.c（主程序）

#include "main.h"
#include "stm32f1xx.h"
#include "./led/bsp_led.h"
#include ".\key\bsp_key.h"

int main(void)
{
  /* 系统时钟初始化成 72 MHz */
  SystemClock_Config();

  /* LED 端口初始化 */
  LED_GPIO_Config();

  /* 按键端口初始化 */
  Key_GPIO_Config();

  /* 轮询按键状态，若按键按下则翻转对应的 LED */
  while(1)
  {
    /* 检测 KEY1，按下则 LED1 翻转 */
    if( Key_Scan(KEY1_GPIO_PORT, KEY1_PIN) == KEY_ON )
    {
      LED1_TOGGLE;   // 翻转 LED1（亮<->灭）
    }

    /* 检测 KEY2，按下则 LED2 翻转 */
    if( Key_Scan(KEY2_GPIO_PORT, KEY2_PIN) == KEY_ON )
    {
      LED2_TOGGLE;
    }
  }
}

/* SystemClock_Config() 同 GPIO 输出章节，此处省略，保持 72MHz 系统时钟 */

2. bsp_key.h（按键引脚定义）

#ifndef __KEY_H
#define	__KEY_H

#include "stm32f1xx.h"
#include "main.h"

/* 引脚定义 */
#define KEY1_PIN                  GPIO_PIN_0
#define KEY1_GPIO_PORT            GPIOA
#define KEY1_GPIO_CLK_ENABLE()    __HAL_RCC_GPIOA_CLK_ENABLE()

#define KEY2_PIN                  GPIO_PIN_13
#define KEY2_GPIO_PORT            GPIOC
#define KEY2_GPIO_CLK_ENABLE()    __HAL_RCC_GPIOC_CLK_ENABLE()

/* 按键按下标志宏：按下为高电平，故 KEY_ON=1、KEY_OFF=0
 * 若你的板子是"按下为低电平"，把这里改成 KEY_ON=0、KEY_OFF=1 即可 */
#define KEY_ON  1
#define KEY_OFF 0

void Key_GPIO_Config(void);
uint8_t Key_Scan(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin);

#endif /* __KEY_H */

3. bsp_key.c（按键初始化 + 扫描）

#include ".\key\bsp_key.h"

/**
  * @brief  配置按键用到的 I/O 口
  */
void Key_GPIO_Config(void)
{
    GPIO_InitTypeDef GPIO_InitStructure;

    /* 开启按键 GPIO 口的时钟 */
    KEY1_GPIO_CLK_ENABLE();
    KEY2_GPIO_CLK_ENABLE();

    /* 选择按键的引脚 */
    GPIO_InitStructure.Pin = KEY1_PIN;

    /* 设置引脚为输入模式 */
    GPIO_InitStructure.Mode = GPIO_MODE_INPUT;

    /* 设置引脚不上拉也不下拉（外部已接上拉电阻） */
    GPIO_InitStructure.Pull = GPIO_NOPULL;

    /* 用上面的结构体初始化按键 */
    HAL_GPIO_Init(KEY1_GPIO_PORT, &GPIO_InitStructure);

    /* KEY2 同理 */
    GPIO_InitStructure.Pin = KEY2_PIN;
    HAL_GPIO_Init(KEY2_GPIO_PORT, &GPIO_InitStructure);
}

/**
  * @brief   检测是否有按键按下
  * @param   GPIOx    ：端口（如 GPIOA）
  * @param   GPIO_Pin ：引脚（如 GPIO_PIN_0）
  * @retval  KEY_ON  ：按键按下； KEY_OFF：未按下
  */
uint8_t Key_Scan(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin)
{
    /* 检测是否有按键按下 */
    if( HAL_GPIO_ReadPin(GPIOx, GPIO_Pin) == KEY_ON )
    {
        /* 等待按键释放（既是消抖，也防止一次按下触发多次） */
        while( HAL_GPIO_ReadPin(GPIOx, GPIO_Pin) == KEY_ON );
        return KEY_ON;
    }
    else
        return KEY_OFF;
}

四、代码分段讲解

1. 输入模式怎么选？

GPIO 输入有 4 种常见模式：浮空输入、上拉输入、下拉输入、模拟输入。

如果外部已经有上拉/下拉电阻，可以用 GPIO_NOPULL（浮空）；
如果外部没电阻，就用 GPIO_PULLUP / GPIO_PULLDOWN 让 MCU 内部电阻帮忙，省掉外围元件。

本例按键外部已带上拉，所以用了 GPIO_NOPULL。

2. `HAL_GPIO_ReadPin()` 读的是什么？

它返回对应引脚的当前电平：GPIO_PIN_SET（高）或 GPIO_PIN_RESET（低）。内部就是读 IDR 输入数据寄存器。

3. 为什么要"等待释放"？

机械按键按下/松开瞬间，金属触点会弹跳几毫秒，导致电平快速抖动，可能被误判成多次按下。while(检测到还是按下); 这一句做了两件事：

消抖：松手后再返回，避开抖动区；
单次触发：按住不放也只生效一次，直到松开。

这是最朴素的"轮询消抖"。更专业的做法是定时器定时扫描 + 状态机，或外部中断 + 延时消抖（见 EXTI 章节）。

4. `LEDx_TOGGLE` 是怎么实现的？

它定义在 bsp_led.h 里，直接操作寄存器 ODR 异或：

`1`	`#define digitalToggle(p,i) {p->ODR ^= i;} // 输出反转状态`

比先读再写更快，也无需关心当前是亮是灭。

五、实验现象

下载程序后，反复按下 KEY1，LED1 会在亮、灭之间切换；
按下 KEY2，LED2 同步切换；
长按按键不会让 LED 连续翻转（因为等待释放逻辑），必须松手再按。

六、常见问题

Q1：按键没反应？

确认 KEY_ON 宏的电平方向与实际硬件一致（按下到底是高是低）；
确认按键 GPIO 时钟已开启；
用万用表/示波器量一下按下时引脚电平是否真的变了。

Q2：按一次 LED 闪了好几下？

说明没有消抖或消抖失效。检查 while(等待释放) 是否写对；若按键是低电平有效却配成了高电平判断，会一直进消抖等待。

Q3：轮询方式有什么缺点？

主循环被按键扫描占用，CPU 一直在空转查询，效率低下；且如果主循环里有长延时（如 HAL_Delay(1000)），按键会"漏检"。实际项目多用外部中断 + 定时器消抖。

七、小结

输入模式让 GPIO 从"发号施令"变成"收听外界"；
按键检测 = 读引脚电平 + 消抖处理，轮询是最易理解的入门方式；
KEY_ON 这类宏把"硬件电平约定"隔离在头文件，方便移植。

八、拓展应用

组合键 / 长按：在 Key_Scan 里累计按下时间，区分"短按"“长按"实现不同功能。
外部中断法：把按键引脚配置为 GPIO_MODE_IT_FALLING，在 HAL_GPIO_EXTI_Callback() 里翻转 LED，彻底解放主循环（参考 13-EXTI—外部中断）。
矩阵键盘：用行扫描+列读取，4 个 IO 就能识别 16 个按键。
旋转编码器：把按键扫描思路迁移到正交编码信号，配合 TIM 编码器接口读取旋钮方向。

STM32 USART — 串口通信与 printf 重定向

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

STM32 USART — 串口通信与 printf 重定向

开发板：野火 EBF STM32F103 Mini
固件库：HAL 库
对应例程：14-USART—串口通信 / USART1回显
参考源码：User/main.c、User/usart/bsp_debug_usart.c、User/usart/bsp_debug_usart.h、User/stm32f1xx_it.c

串口（UART/USART）是嵌入式开发中最重要的调试通道。没有屏幕的开发板，靠串口把运行日志打印到电脑上的串口助手，是定位问题的第一手段。本文带你配好 USART1，并学会用熟悉的 printf 输出信息。

一、功能简介

本例把 USART1 配置为 115200 波特率、8 位数据、无校验、1 位停止位（8-N-1），并使能接收中断：

程序启动后通过 printf 打印欢迎语；
通过自定义的 Usart_SendString() 发送字符串；
上位机串口助手发送的数据，会在 USART1_IRQHandler 中进入接收中断，实现"回显"。

核心知识点：

USART 外设的 HAL 初始化套路（UART_HandleTypeDef）；
TX/RX 引脚必须配置为复用推挽/复用输入；
用 fputc 重定向让 printf 走串口；
中断接收的基本框架。

二、硬件准备

项目	说明
开发板	野火 EBF STM32F103 Mini
串口外设	USART1
引脚	TX → PA9，RX → PA10（复用功能 AFIO）
连接方式	板载/外接 USB-TTL 转串口的 TX、RX 交叉连接
上位机	串口调试助手（如 SSCOM、Putty），波特率 115200

三、完整代码（带中文注释）

1. main.c（主程序）

#include "main.h"
#include "stm32f1xx.h"
#include "./usart/bsp_debug_usart.h"
#include "./led/bsp_led.h"

int main(void)
{
  HAL_Init();                 // 初始化 HAL 库（含 SysTick、中断分组）
  /* 配置系统时钟为 72 MHz */
  SystemClock_Config();

  /* 初始化 USART1：115200 8-N-1，中断接收 */
  DEBUG_USART_Config();

  /* 调用 printf（已重定向到串口） */
  printf("欢迎使用野火开发板\n");

  /* 自定义函数方式发送字符串 */
  Usart_SendString( (uint8_t *)"自定义函数输出：这是一个串口中断接收回显实验\n" );

  while(1)
  {
    /* 主循环空闲，真正的接收工作在中断里完成 */
  }
}

2. bsp_debug_usart.h（引脚与波特率定义）

#ifndef __DEBUG_USART_H
#define	__DEBUG_USART_H

#include "stm32f1xx.h"
#include <stdio.h>

/* 串口波特率 */
#define DEBUG_USART_BAUDRATE      115200

/* 引脚定义：USART1，TX=PA9，RX=PA10 */
#define DEBUG_USART               USART1
#define DEBUG_USART_CLK_ENABLE()  __HAL_RCC_USART1_CLK_ENABLE();

#define DEBUG_USART_RX_GPIO_PORT  GPIOA
#define DEBUG_USART_RX_GPIO_CLK_ENABLE()  __HAL_RCC_GPIOA_CLK_ENABLE()
#define DEBUG_USART_RX_PIN        GPIO_PIN_10

#define DEBUG_USART_TX_GPIO_PORT  GPIOA
#define DEBUG_USART_TX_GPIO_CLK_ENABLE()  __HAL_RCC_GPIOA_CLK_ENABLE()
#define DEBUG_USART_TX_PIN        GPIO_PIN_9

#define DEBUG_USART_IRQ           USART1_IRQn

void Usart_SendString(uint8_t *str);
void DEBUG_USART_Config(void);
int fputc(int ch, FILE *f);
int fgetc(FILE *f);
extern UART_HandleTypeDef UartHandle;

#endif /* __USART1_H */

3. bsp_debug_usart.c（配置、MSP、printf 重定向）

#include "./usart/bsp_debug_usart.h"

UART_HandleTypeDef UartHandle;

/**
  * @brief  DEBUG_USART 工作模式配置：115200 8-N-1
  */
void DEBUG_USART_Config(void)
{
  UartHandle.Instance        = DEBUG_USART;               // 选用 USART1
  UartHandle.Init.BaudRate   = DEBUG_USART_BAUDRATE;      // 波特率 115200
  UartHandle.Init.WordLength = UART_WORDLENGTH_8B;        // 8 位数据
  UartHandle.Init.StopBits   = UART_STOPBITS_1;           // 1 位停止位
  UartHandle.Init.Parity     = UART_PARITY_NONE;          // 无校验
  UartHandle.Init.HwFlowCtl  = UART_HWCONTROL_NONE;       // 无硬件流控
  UartHandle.Init.Mode       = UART_MODE_TX_RX;           // 收发全双工

  HAL_UART_Init(&UartHandle);     // 调用 HAL，它会进一步调用 HAL_UART_MspInit

  /* 使能串口接收中断（RXNE：接收寄存器非空） */
  __HAL_UART_ENABLE_IT(&UartHandle, UART_IT_RXNE);
}

/**
  * @brief  UART MSP 初始化：配置时钟、GPIO 复用、NVIC 中断
  * @note   这是 HAL 的"弱函数"钩子，HAL_UART_Init 会自动调用它
  */
void HAL_UART_MspInit(UART_HandleTypeDef *huart)
{
  GPIO_InitTypeDef  GPIO_InitStruct;

  DEBUG_USART_CLK_ENABLE();              // 开 USART1 时钟
  DEBUG_USART_RX_GPIO_CLK_ENABLE();      // 开 GPIOA 时钟
  DEBUG_USART_TX_GPIO_CLK_ENABLE();

  /* PA9 配置为复用推挽输出（TX） */
  GPIO_InitStruct.Pin   = DEBUG_USART_TX_PIN;
  GPIO_InitStruct.Mode  = GPIO_MODE_AF_PP;        // 复用推挽
  GPIO_InitStruct.Pull  = GPIO_PULLUP;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
  HAL_GPIO_Init(DEBUG_USART_TX_GPIO_PORT, &GPIO_InitStruct);

  /* PA10 配置为复用输入（RX） */
  GPIO_InitStruct.Pin   = DEBUG_USART_RX_PIN;
  GPIO_InitStruct.Mode  = GPIO_MODE_AF_INPUT;      // 复用输入
  HAL_GPIO_Init(DEBUG_USART_RX_GPIO_PORT, &GPIO_InitStruct);

  /* 配置 NVIC：抢占优先级 0，子优先级 1 */
  HAL_NVIC_SetPriority(DEBUG_USART_IRQ, 0, 1);
  HAL_NVIC_EnableIRQ(DEBUG_USART_IRQ);            // 使能 USART1 中断通道
}

/* 发送字符串：逐字节调用 HAL_UART_Transmit */
void Usart_SendString(uint8_t *str)
{
  unsigned int k = 0;
  do {
    HAL_UART_Transmit(&UartHandle, (uint8_t *)(str + k), 1, 1000);
    k++;
  } while(*(str + k) != '\0');
}

/* 重定向 C 库 printf 到串口：链接器会把 printf 的底层输出指向这里 */
int fputc(int ch, FILE *f)
{
  HAL_UART_Transmit(&UartHandle, (uint8_t *)&ch, 1, 1000);
  return (ch);
}

/* 重定向 C 库 scanf/getchar 到串口 */
int fgetc(FILE *f)
{
  int ch;
  HAL_UART_Receive(&UartHandle, (uint8_t *)&ch, 1, 1000);
  return (ch);
}

4. stm32f1xx_it.c（中断服务函数，节选）

#include "./usart/bsp_debug_usart.h"

/**
  * @brief  USART1 中断服务函数
  * @note   芯片发生 USART1 中断时，硬件自动跳到这里
  */
void USART1_IRQHandler(void)
{
  /* 交给 HAL 的统一中断处理入口，它会判断中断源并调用相应回调 */
  HAL_UART_IRQHandler(&UartHandle);

  /* 下面的回显逻辑通常写在回调 HAL_UART_RxCpltCallback 中：
     在接收完成回调里再次开启接收，即可实现持续回显 */
}

四、代码分段讲解

1. TX/RX 为什么要"复用"？

USART 是片上外设，并不是 GPIO 直接产生的信号。要让 PA9/PA10 输出 USART 波形，必须把引脚配置为复用功能（AF），由内部外设"接管"这两个脚。TX 用复用推挽，RX 用复用输入。

2. `HAL_UART_Init` 会触发 `HAL_UART_MspInit`

这是 HAL 库的核心设计：“通用配置"和"平台相关配置"分离。

HAL_UART_Init() 只配置 USART 本身的参数（波特率等）；
它会回调 HAL_UART_MspInit()，由你在里面开时钟、配 GPIO、配 NVIC。

好处是同一套 HAL_UART_Init 代码可以跨芯片复用，差异都收敛在 MSP 函数里。

3. printf 重定向原理

C 语言的 printf 最终会调用底层 _write/fputc 来输出一个字符。我们重写 fputc，让它把字符通过 HAL_UART_Transmit 发到串口，就能直接 printf("调试信息=%d\n", val)。注意工程需勾选 “Use MicroLIB”（Keil）或开启 -u _printf_float（GCC）以支持浮点打印。

4. 中断接收 vs 轮询接收

HAL_UART_Receive() 是阻塞轮询，CPU 干等；
开启 UART_IT_RXNE 中断后，每收到一字节硬件自动进 USART1_IRQHandler，在 HAL_UART_RxCpltCallback 回调里处理，CPU 不阻塞。回显实验就是趁这个时机把收到的字节再发回去。

五、实验现象

打开串口助手，选择正确串口号、波特率 115200、8-N-1、无流控；

开发板复位后，串口助手收到两行欢迎语：

1
2

欢迎使用野火开发板
自定义函数输出：这是一个串口中断接收回显实验

在串口助手发送区输入任意字符并发送，开发板会把相同字符回发回来（回显）。

六、常见问题

Q1：串口助手收不到任何数据？

确认波特率、数据位、停止位、校验位与代码一致（本例 115200/8/1/None）；
确认 TX/RX 交叉连接（开发板 TX 接转接板 RX，反之亦然）；
确认系统时钟真的是 72MHz——波特率由外设时钟分频得到，时钟错了波特率就偏了。

Q2：能编译但 printf 没输出？

Keil 需勾选 MicroLIB；GCC 需实现 _write 或确认 fputc 被链接；
确认 __HAL_RCC_USART1_CLK_ENABLE() 与 GPIO 时钟都已开启。

Q3：中文乱码？

串口助手编码选 GBK/UTF-8 与发送端一致；字符串里的中文以何种编码存储就选哪种。

Q4：接收会丢字节？

中断里处理太慢或没及时重新开启接收会导致溢出。正式项目建议用 DMA + 空闲中断（IDLE） 收一帧数据。

七、小结

USART 初始化 = 配句柄参数 + MSP（时钟/GPIO/NVIC）+ 使能中断；
printf 重定向是调试利器，几乎所有 STM32 工程都保留它；
“主循环空闲 + 中断处理"是相比轮询更高效的结构。

八、拓展应用

DMA + 空闲中断接收：在 HAL_UARTEx_RxEventCallback 中利用 IDLE 中断收完整帧，避免逐字节中断开销（见 15-DMA 章节的串口 DMA 用法）。
自定义日志分级：封装 log_info()/log_err() 宏，带文件名、行号、颜色，做成一个小日志库。
命令行交互：在串口上实现一个简易 Shell（解析 led on、adc read 等命令），用串口控制整个板子。
485 通信：把 USART 接 485 收发器芯片，通过 DE/RE 控制收发方向，做总线式多机通信（参考 USART—485通信）。

STM32 ADC — 独立模式单通道 + DMA 连续采集

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

STM32 ADC — 独立模式单通道 + DMA 连续采集

开发板：野火 EBF STM32F103 Mini
固件库：HAL 库
对应例程：ADC—独立模式-单通道-DMA
参考源码：User/main.c、User/adc/bsp_adc.h、User/adc/bsp_adc.c

ADC（Analog-to-Digital Converter，模数转换器）把现实世界的连续模拟电压变成 MCU 能处理的数字量。本文用 ADC1 单通道 + DMA 循环搬运，实现"不占用 CPU"的连续电压采集，是 ADC 最经典、最高效的用法之一。

一、功能简介

把开发板上的电位器（滑变电阻，接 PC1 / ADC_CHANNEL_11）电压送到 ADC1，配置为：

独立模式（非双重 ADC 协同）；
单通道（只采通道 11）；
连续转换 + 扫描关闭（采完一个通道立刻从头再来）；
DMA 循环模式：每转换完一次，DMA 自动把结果搬进 ADC_ConvertedValue 变量。

主循环只需读取这个变量、套公式算出电压、用 printf 打印即可。因 DMA 持续搬运，CPU 几乎不参与采样本体。

核心知识点：

ADC 通道、采样时间、对齐方式的概念；
DMA 如何与 ADC 联动（ Peripheral→Memory）；
电压换算公式：V = ADC值 / 4096 × 3.3。

二、硬件准备

项目	说明
开发板	野火 EBF STM32F103 Mini
ADC 外设	ADC1，通道 11（CH11 → PC1）
信号源	板载电位器（滑动变阻器），中间抽头接 PC1
调试输出	USART1（115200）打印电压值

STM32F103 的 ADC 为 12 位，转换结果范围 0 ~ 4095，参考电压一般接 3.3V。

三、完整代码（带中文注释）

1. bsp_adc.h（引脚与 DMA 通道定义）

#ifndef __BSP_ADC_H
#define	__BSP_ADC_H

#include "stm32f1xx.h"

/* ADC GPIO 宏定义：CH11 -> PC1 */
#define RHEOSTAT_ADC_GPIO_PORT         GPIOC
#define RHEOSTAT_ADC_GPIO_PIN          GPIO_PIN_1
#define RHEOSTAT_ADC_GPIO_CLK_ENABLE() __HAL_RCC_GPIOC_CLK_ENABLE()

/* ADC 序号宏定义 */
#define RHEOSTAT_ADC                  ADC1
#define RHEOSTAT_ADC_CLK_ENABLE()     __HAL_RCC_ADC1_CLK_ENABLE();
#define RHEOSTAT_ADC_CHANNEL          ADC_CHANNEL_11

/* ADC 使用的 DMA 通道：ADC1 固定对应 DMA1_Channel1 */
#define RHEOSTAT_ADC_DMA_CLK_ENABLE() __HAL_RCC_DMA1_CLK_ENABLE();
#define RHEOSTAT_ADC_DMA_STREAM       DMA1_Channel1

void Rheostat_Init(void);

#endif /* __BSP_ADC_H */

2. bsp_adc.c（GPIO、DMA、ADC 配置）

#include "./adc/bsp_adc.h"

__IO uint32_t ADC_ConvertedValue;        // DMA 搬运的目标：转换结果
DMA_HandleTypeDef hdma_adcx;
ADC_HandleTypeDef ADC_Handle;
ADC_ChannelConfTypeDef ADC_Config;

/* 第 1 步：配置 ADC 输入引脚为模拟模式 */
static void Rheostat_ADC_GPIO_Config(void)
{
  GPIO_InitTypeDef GPIO_InitStructure;

  RHEOSTAT_ADC_CLK_ENABLE();
  RHEOSTAT_ADC_GPIO_CLK_ENABLE();

  GPIO_InitStructure.Pin  = RHEOSTAT_ADC_GPIO_PIN;
  GPIO_InitStructure.Mode = GPIO_MODE_ANALOG;   // 必须设为模拟输入
  HAL_GPIO_Init(RHEOSTAT_ADC_GPIO_PORT, &GPIO_InitStructure);
}

/* 第 2 步：配置 DMA 与 ADC 工作模式 */
static void Rheostat_ADC_Mode_Config(void)
{
  /* ---- DMA 结构体参数初始化 ---- */
  RHEOSTAT_ADC_DMA_CLK_ENABLE();

  hdma_adcx.Instance               = RHEOSTAT_ADC_DMA_STREAM;    // DMA1_Channel1
  hdma_adcx.Init.Direction        = DMA_PERIPH_TO_MEMORY;       // 外设 -> 内存
  hdma_adcx.Init.PeriphInc        = DMA_PINC_DISABLE;           // 外设地址不递增（固定为 ADC_DR）
  hdma_adcx.Init.MemInc           = DMA_MINC_DISABLE;           // 这里只采 1 个变量，内存也不递增
  hdma_adcx.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD; // 外设数据 16 位（ADC 是 16 位寄存器）
  hdma_adcx.Init.MemDataAlignment    = DMA_MDATAALIGN_HALFWORD; // 内存数据 16 位
  hdma_adcx.Init.Mode             = DMA_CIRCULAR;               // 循环模式：不断搬
  hdma_adcx.Init.Priority         = DMA_PRIORITY_MEDIUM;        // 中等优先级
  HAL_DMA_Init(&hdma_adcx);

  /* 把 DMA 句柄绑到 ADC 句柄（HAL 内部用这个关联触发搬运） */
  __HAL_LINKDMA(&ADC_Handle, DMA_Handle, hdma_adcx);

  /* ---- ADC 时钟分频：PCLK2(72M)/8 = 9MHz，必须在允许范围 ---- */
  RCC_PeriphCLKInitTypeDef ADC_CLKInit;
  ADC_CLKInit.PeriphClockSelection = RCC_PERIPHCLK_ADC;
  ADC_CLKInit.AdcClockSelection    = RCC_ADCPCLK2_DIV8;         // 分频因子 8
  HAL_RCCEx_PeriphCLKConfig(&ADC_CLKInit);

  /* ---- ADC 基本参数 ---- */
  ADC_Handle.Instance               = RHEOSTAT_ADC;             // ADC1
  ADC_Handle.Init.DataAlign        = ADC_DATAALIGN_RIGHT;       // 右对齐
  ADC_Handle.Init.ScanConvMode     = DISABLE;                   // 关闭扫描（单通道不需要）
  ADC_Handle.Init.ContinuousConvMode = ENABLE;                 // 连续转换
  ADC_Handle.Init.NbrOfConversion  = 1;                        // 规则序列 1 个转换
  ADC_Handle.Init.DiscontinuousConvMode = DISABLE;
  ADC_Handle.Init.ExternalTrigConv = ADC_SOFTWARE_START;        // 软件触发
  HAL_ADC_Init(&ADC_Handle);                                    // 会回调 HAL_ADC_MspInit

  /* ---- 配置规则通道：通道 11，序列 1，采样时间 55.5 周期 ---- */
  ADC_Config.Channel      = RHEOSTAT_ADC_CHANNEL;
  ADC_Config.Rank         = 1;
  ADC_Config.SamplingTime = ADC_SAMPLETIME_55CYCLES_5;
  HAL_ADC_ConfigChannel(&ADC_Handle, &ADC_Config);

  /* 启动 ADC 的 DMA 转换：结果自动、循环地写入 ADC_ConvertedValue */
  HAL_ADC_Start_DMA(&ADC_Handle, (uint32_t*)&ADC_ConvertedValue, 1);
}

/* 对外初始化入口 */
void Rheostat_Init(void)
{
  Rheostat_ADC_GPIO_Config();
  Rheostat_ADC_Mode_Config();
}

3. main.c（主循环读取并打印）

#include "main.h"
#include "stm32f1xx.h"
#include "./usart/bsp_debug_usart.h"
#include "./led/bsp_led.h"
#include <stdio.h>
#include "./adc/bsp_adc.h"

extern __IO uint32_t ADC_ConvertedValue;   // DMA 持续更新的转换值
float ADC_Vol;                             // 换算后的电压值

static void Delay(__IO uint32_t nCount)
{
  for(; nCount != 0; nCount--);
}

int main(void)
{
  SystemClock_Config();          // 72MHz
  DEBUG_USART_Config();          // 串口用于打印
  Rheostat_Init();               // 初始化 ADC + DMA

  while (1)
  {
    /* 把 12 位 ADC 值换算成电压：Vref = 3.3V，满量程 4096 */
    ADC_Vol = (float)ADC_ConvertedValue / 4096 * (float)3.3;
    printf("\r\n The current AD value = 0x%04X \r\n", ADC_ConvertedValue);
    printf("\r\n The current AD value = %f V \r\n", ADC_Vol);
    Delay(0x8fffff);             // 简单延时，控制台输出别太快
  }
}

四、代码分段讲解

1. 为什么引脚要设成 `GPIO_MODE_ANALOG`？

ADC 输入必须走芯片内部的模拟通路。把引脚配成模拟模式，GPIO 的数字输入缓冲会被断开，避免数字电路对微弱模拟信号产生干扰，也能降低功耗。

2. DMA 方向：外设 → 内存

ADC 转换结果固定存放在 数据寄存器 ADC_DR（外设端地址不变，所以 PeriphInc = DISABLE）。DMA 每次转换完成被触发，自动把 DR 里的 16 位值搬到 ADC_ConvertedValue。因为是循环模式，搬完又从头搬，形成"永动机"式采集。

3. `__HAL_LINKDMA` 做了什么？

它把 DMA 句柄挂到 ADC 句柄的 DMA_Handle 字段上。这样 HAL_ADC_Start_DMA() 内部才知道用哪个 DMA 通道去搬 ADC 的数据——这是 HAL 关联"外设触发 DMA"的关键一步。

4. ADC 时钟为什么分频？

F103 的 ADC 最高工作频率约 14MHz，而 PCLK2 是 72MHz，所以必须分频（RCC_ADCPCLK2_DIV8 → 9MHz）。不分频会超出规格，采样不准甚至出错。

5. 电压换算

12 位分辨率 → 最大值 4095（代码里用 4096 当分母近似满量程）。参考电压 3.3V：

`1`	`电压 V = (ADC值 / 4096) × 3.3`

五、实验现象

打开串口助手（115200），复位开发板；
串口每隔约 1 秒打印一次：当前 ADC 原始值和换算电压；
旋转电位器，电压值随之在 0 ~ 3.3V 之间连续变化，说明 DMA 在后台持续把最新采样搬进了变量。

六、常见问题

Q1：打印的电压一直是 0 或满量程不变？

确认电位器中心抽头确实接到了 PC1，且两端分别接 3.3V 和 GND；
确认 RHEOSTAT_ADC_CHANNEL 与实际引脚对应（PC1 = ADC_CHANNEL_11）。

Q2：数据剧烈跳变、不稳定？

延长采样时间（ADC_SAMPLETIME_55CYCLES_5 → 更大值）；
在信号源并联一个小电容滤波，或在软件里做滑动平均。

Q3：想同时采多个通道怎么办？

开启 ScanConvMode = ENABLE，把 NbrOfConversion 设为通道数，并让 DMA 内存递增（MemInc=ENABLE），配合一个数组接收。详见 ADC—独立模式-多通道-DMA。

七、小结

单通道连续采集 + DMA 循环，是 ADC 的"零 CPU 占用"标配；
配置顺序：开时钟 → 引脚模拟模式 → DMA 参数 → ADC 参数 → 规则通道 → Start_DMA；
DMA 把外设数据自动搬进内存，是后续 SPI、USART、DAC 等高速传输的共同基石。

八、拓展应用

多通道扫描：把电位器、温度、光照等多路信号编入规则序列，用 DMA 一次性搬进数组。
定时器触发采样：用 TIM 的 TRGO 触发 ADC，实现固定频率（如 1kHz）的等间隔采样，做简易示波器。
芯片温度采集：切换通道到内部温度传感器（ADC_CHANNEL_TEMPSENSOR），免接外部元件测芯片温（见 ADC—芯片温度）。
DMA 半传输/传输完成中断：在回调里做 FFT、求平均，搭一个低成本信号采集前端。

STM32 SPI — 读写串行 FLASH（W25Q64）

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

STM32 SPI — 读写串行 FLASH（W25Q64）

开发板：野火 EBF STM32F103 Mini
固件库：HAL 库
对应例程：16-SPI—读写串行FLASH（W25Q64）
参考源码：User/main.c、User/flash/bsp_spi_flash.h、User/flash/bsp_spi_flash.c

SPI（Serial Peripheral Interface）是一种高速、全双工、同步的硬件总线，常用于连接 Flash、LCD、传感器等。本文用 SPI1 驱动一颗 8MB 的 W25Q64 串行 Flash，完整演示"读 ID → 擦除 → 写 → 读 → 校验"的存储流程。

一、功能简介

W25Q64 通过 SPI 接收命令码 + 地址 + 数据来工作。本例实现：

初始化 SPI1（模式 0/3 兼容，本例用 CPOL=High、CPHA=2Edge，即模式 3）；
读取 Device ID 与 JEDEC ID 验证芯片；
扇区擦除（Flash 只能把 1 写成 0，擦除才把 0 还原成 1）；
页写 + 缓冲区写（自动处理跨页）；
读数据，并与写入内容比对，成功则点亮 LED2。

核心知识点：

SPI 四线（SCK/MOSI/MISO/CS）与时序（CPOL/CPHA）；
片选 CS 的软件控制；
Flash “先擦后写” 与 “页” 概念；
一个字节发送即同步接收的全双工本质。

二、硬件准备

项目	说明
开发板	野火 EBF STM32F103 Mini
SPI 外设	SPI1
引脚	SCK → PA5，MISO → PA6，MOSI → PA7，CS → PA4
器件	W25Q64（8MB，SPI 接口串行 NOR Flash）
调试输出	USART1（115200）打印 ID 与读写结果

接线要点：SPI 主机的 MOSI 接从机 MOSI，MISO 接 MISO，SCK 接 SCK，CS 由主机用任意一个 GPIO 软件拉低/拉高来选通从机。

三、完整代码（带中文注释）

1. bsp_spi_flash.h（引脚、指令、接口声明）

#ifndef __SPI_FLASH_H
#define __SPI_FLASH_H

#include "stm32f1xx.h"
#include <stdio.h>

/* W25Q64 的 JEDEC ID = 0xEF4017（厂商 0xEF / 类型 0x40 / 容量 0x17=8MB） */
#define  sFLASH_ID             0XEF4017

#define SPI_FLASH_PageSize     256        // 一页 256 字节
#define SPI_FLASH_PerWritePageSize  256

/* ---- W25Q64 指令集（部分常用） ---- */
#define W25X_WriteEnable       0x06      // 写使能
#define W25X_WriteDisable      0x04
#define W25X_ReadStatusReg     0x05      // 读状态寄存器
#define W25X_ReadData          0x03      // 读数据
#define W25X_PageProgram       0x02      // 页编程（写）
#define W25X_SectorErase       0x20      // 扇区擦除（4KB）
#define W25X_ChipErase         0xC7      // 整片擦除
#define W25X_PowerDown         0xB9      // 掉电
#define W25X_ReleasePowerDown  0xAB
#define W25X_DeviceID          0xAB      // 读 Device ID
#define W25X_JedecDeviceID     0x9F      // 读 JEDEC ID

#define WIP_Flag               0x01       // 状态寄存器 bit0：Write In Progress
#define Dummy_Byte             0xFF       // 读操作时发送的无意义填充字节

/* ---- SPI 与 GPIO 引脚定义 ---- */
#define SPIx                   SPI1
#define SPIx_CLK_ENABLE()      __HAL_RCC_SPI1_CLK_ENABLE()

#define SPIx_SCK_PIN           GPIO_PIN_5
#define SPIx_SCK_GPIO_PORT     GPIOA
#define SPIx_MISO_PIN          GPIO_PIN_6
#define SPIx_MISO_GPIO_PORT    GPIOA
#define SPIx_MOSI_PIN          GPIO_PIN_7
#define SPIx_MOSI_GPIO_PORT    GPIOA
#define FLASH_CS_PIN           GPIO_PIN_4
#define FLASH_CS_GPIO_PORT     GPIOA

/* 用寄存器直接操作 CS，速度最快 */
#define digitalHi(p,i)  {p->BSRR = i;}
#define digitalLo(p,i)  {p->BSRR = (uint32_t)i << 16;}
#define SPI_FLASH_CS_LOW()   digitalLo(FLASH_CS_GPIO_PORT, FLASH_CS_PIN)   // 选通
#define SPI_FLASH_CS_HIGH()  digitalHi(FLASH_CS_GPIO_PORT, FLASH_CS_PIN)   // 取消选通

void SPI_FLASH_Init(void);
void SPI_FLASH_SectorErase(uint32_t SectorAddr);
void SPI_FLASH_BufferWrite(uint8_t* pBuffer, uint32_t WriteAddr, uint16_t NumByteToWrite);
void SPI_FLASH_BufferRead(uint8_t* pBuffer, uint32_t ReadAddr, uint16_t NumByteToRead);
uint32_t SPI_FLASH_ReadID(void);
uint32_t SPI_FLASH_ReadDeviceID(void);
uint8_t SPI_FLASH_SendByte(uint8_t byte);
void SPI_FLASH_WriteEnable(void);
void SPI_FLASH_WaitForWriteEnd(void);
void SPI_Flash_PowerDown(void);

#endif /* __SPI_FLASH_H */

2. bsp_spi_flash.c（SPI 初始化与 Flash 驱动，节选核心）

#include "./flash/bsp_spi_flash.h"

SPI_HandleTypeDef SpiHandle;

/* MSP：开时钟 + 配 GPIO（SCK/MOSI/MISO 复用，CS 普通推挽输出） */
void HAL_SPI_MspInit(SPI_HandleTypeDef *hspi)
{
  GPIO_InitTypeDef GPIO_InitStruct;

  SPIx_SCK_GPIO_CLK_ENABLE();
  SPIx_MISO_GPIO_CLK_ENABLE();
  SPIx_MOSI_GPIO_CLK_ENABLE();
  SPIx_CS_GPIO_CLK_ENABLE();
  SPIx_CLK_ENABLE();

  GPIO_InitStruct.Pin   = SPIx_SCK_PIN;
  GPIO_InitStruct.Mode  = GPIO_MODE_AF_PP;       // 复用推挽
  GPIO_InitStruct.Pull  = GPIO_PULLUP;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
  HAL_GPIO_Init(SPIx_SCK_GPIO_PORT, &GPIO_InitStruct);

  GPIO_InitStruct.Pin = SPIx_MISO_PIN;           // MISO 同样复用
  HAL_GPIO_Init(SPIx_MISO_GPIO_PORT, &GPIO_InitStruct);

  GPIO_InitStruct.Pin = SPIx_MOSI_PIN;
  HAL_GPIO_Init(SPIx_MOSI_GPIO_PORT, &GPIO_InitStruct);

  GPIO_InitStruct.Pin  = FLASH_CS_PIN;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;     // CS 用软件普通 GPIO 控制
  HAL_GPIO_Init(FLASH_CS_GPIO_PORT, &GPIO_InitStruct);
}

/* SPI 参数配置：主模式、8 位、MSB 先行、模式 3、软件 NSS、4 分频 */
void SPI_FLASH_Init(void)
{
  SpiHandle.Instance               = SPIx;
  SpiHandle.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_4;  // 72M/4=18MHz
  SpiHandle.Init.Direction         = SPI_DIRECTION_2LINES;     // 全双工
  SpiHandle.Init.CLKPhase          = SPI_PHASE_2EDGE;          // CPHA=1
  SpiHandle.Init.CLKPolarity       = SPI_POLARITY_HIGH;        // CPOL=1（模式3）
  SpiHandle.Init.CRCCalculation    = SPI_CRCCALCULATION_DISABLE;
  SpiHandle.Init.CRCPolynomial     = 7;
  SpiHandle.Init.DataSize          = SPI_DATASIZE_8BIT;
  SpiHandle.Init.FirstBit          = SPI_FIRSTBIT_MSB;
  SpiHandle.Init.NSS               = SPI_NSS_SOFT;             // 软件管理 CS
  SpiHandle.Init.TIMode            = SPI_TIMODE_DISABLE;
  SpiHandle.Init.Mode              = SPI_MODE_MASTER;

  HAL_SPI_Init(&SpiHandle);
  __HAL_SPI_ENABLE(&SpiHandle);
}

/* 向 Flash 发送 1 字节，同时读出 1 字节（SPI 全双工特性） */
uint8_t SPI_FLASH_SendByte(uint8_t byte)
{
  /* 等待发送缓冲区空 */
  while (__HAL_SPI_GET_FLAG(&SpiHandle, SPI_FLAG_TXE) == RESET);
  WRITE_REG(SpiHandle.Instance->DR, byte);        // 写入数据寄存器

  /* 等待接收缓冲区非空 */
  while (__HAL_SPI_GET_FLAG(&SpiHandle, SPI_FLAG_RXNE) == RESET);
  return READ_REG(SpiHandle.Instance->DR);        // 读出收到的数据
}

/* 读 JEDEC ID：发 0x9F 后连续收 3 字节 */
uint32_t SPI_FLASH_ReadID(void)
{
  uint32_t Temp = 0, Temp0 = 0, Temp1 = 0, Temp2 = 0;
  SPI_FLASH_CS_LOW();
  SPI_FLASH_SendByte(W25X_JedecDeviceID);
  Temp0 = SPI_FLASH_SendByte(Dummy_Byte);
  Temp1 = SPI_FLASH_SendByte(Dummy_Byte);
  Temp2 = SPI_FLASH_SendByte(Dummy_Byte);
  SPI_FLASH_CS_HIGH();
  Temp = (Temp0 << 16) | (Temp1 << 8) | Temp2;   // 组合成 24 位 ID
  return Temp;
}

/* 扇区擦除（4KB）：写使能 -> 发指令+3字节地址 -> 等待写完 */
void SPI_FLASH_SectorErase(uint32_t SectorAddr)
{
  SPI_FLASH_WriteEnable();
  SPI_FLASH_WaitForWriteEnd();

  SPI_FLASH_CS_LOW();
  SPI_FLASH_SendByte(W25X_SectorErase);
  SPI_FLASH_SendByte((SectorAddr & 0xFF0000) >> 16);  // 地址高字节
  SPI_FLASH_SendByte((SectorAddr & 0xFF00) >> 8);     // 地址中字节
  SPI_FLASH_SendByte(SectorAddr & 0xFF);              // 地址低字节
  SPI_FLASH_CS_HIGH();
  SPI_FLASH_WaitForWriteEnd();
}

/* 按页写：最多写一页 256 字节，写完等待内部编程结束 */
void SPI_FLASH_PageWrite(uint8_t* pBuffer, uint32_t WriteAddr, uint16_t NumByteToWrite)
{
  SPI_FLASH_WriteEnable();
  SPI_FLASH_CS_LOW();
  SPI_FLASH_SendByte(W25X_PageProgram);
  SPI_FLASH_SendByte((WriteAddr & 0xFF0000) >> 16);
  SPI_FLASH_SendByte((WriteAddr & 0xFF00) >> 8);
  SPI_FLASH_SendByte(WriteAddr & 0xFF);

  if (NumByteToWrite > SPI_FLASH_PerWritePageSize)
    NumByteToWrite = SPI_FLASH_PerWritePageSize;   // 超页则截断

  while (NumByteToWrite--)
    SPI_FLASH_SendByte(*pBuffer++);               // 逐字节写入

  SPI_FLASH_CS_HIGH();
  SPI_FLASH_WaitForWriteEnd();
}

/* 缓冲区写：自动拆分跨页，内部调用 PageWrite */
void SPI_FLASH_BufferWrite(uint8_t* pBuffer, uint32_t WriteAddr, uint16_t NumByteToWrite)
{
  uint8_t NumOfPage = 0, NumOfSingle = 0, Addr = 0, count = 0, temp = 0;
  Addr = WriteAddr % SPI_FLASH_PageSize;          // 起始地址在页内的偏移
  count = SPI_FLASH_PageSize - Addr;              // 当前页还能写多少
  NumOfPage = NumByteToWrite / SPI_FLASH_PageSize;
  NumOfSingle = NumByteToWrite % SPI_FLASH_PageSize;

  if (Addr == 0)                                 // 地址正好页对齐
  {
    if (NumOfPage == 0)                          // 不到一页
      SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumByteToWrite);
    else
    {
      while (NumOfPage--)                         // 整页挨个写
      {
        SPI_FLASH_PageWrite(pBuffer, WriteAddr, SPI_FLASH_PageSize);
        WriteAddr += SPI_FLASH_PageSize;
        pBuffer   += SPI_FLASH_PageSize;
      }
      if (NumOfSingle != 0)                      // 尾巴不足一页
        SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumOfSingle);
    }
  }
  else                                           // 地址未对齐
  {
    if (NumOfPage == 0)
    {
      if (NumOfSingle > count)                   // 当前页放不下，拆成两段
      {
        temp = NumOfSingle - count;
        SPI_FLASH_PageWrite(pBuffer, WriteAddr, count);
        SPI_FLASH_PageWrite(pBuffer + count, WriteAddr + count, temp);
      }
      else
        SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumByteToWrite);
    }
    else                                         // 多页情况，先填满当前页再整页写
    {
      NumByteToWrite -= count;
      NumOfPage = NumByteToWrite / SPI_FLASH_PageSize;
      NumOfSingle = NumByteToWrite % SPI_FLASH_PageSize;
      SPI_FLASH_PageWrite(pBuffer, WriteAddr, count);
      WriteAddr += count; pBuffer += count;
      while (NumOfPage--)
      {
        SPI_FLASH_PageWrite(pBuffer, WriteAddr, SPI_FLASH_PageSize);
        WriteAddr += SPI_FLASH_PageSize; pBuffer += SPI_FLASH_PageSize;
      }
      if (NumOfSingle != 0)
        SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumOfSingle);
    }
  }
}

/* 读数据：发 0x03 + 3 字节地址，随后逐字节收 */
void SPI_FLASH_BufferRead(uint8_t* pBuffer, uint32_t ReadAddr, uint16_t NumByteToRead)
{
  SPI_FLASH_CS_LOW();
  SPI_FLASH_SendByte(W25X_ReadData);
  SPI_FLASH_SendByte((ReadAddr & 0xFF0000) >> 16);
  SPI_FLASH_SendByte((ReadAddr & 0xFF00) >> 8);
  SPI_FLASH_SendByte(ReadAddr & 0xFF);
  while (NumByteToRead--)
    *pBuffer++ = SPI_FLASH_SendByte(Dummy_Byte); // 每发 1 个哑字节，收 1 个真实数据
  SPI_FLASH_CS_HIGH();
}

3. main.c（演示流程）

#include "main.h"
#include "stm32f1xx.h"
#include "./usart/bsp_debug_usart.h"
#include "./led/bsp_led.h"
#include "./flash/bsp_spi_flash.h"

uint8_t Tx_Buffer[] = "感谢您选用野火stm32开发板\r\nhttp://firestm32.taobao.com";
uint8_t Rx_Buffer[sizeof(Tx_Buffer)];

int main(void)
{
  SystemClock_Config();
  LED_GPIO_Config();
  DEBUG_USART_Config();

  printf("\r\n这是一个8M串行flash(W25Q64)实验(SPI驱动) \r\n");

  SPI_FLASH_Init();
  __IO uint32_t FlashID = SPI_FLASH_ReadID();
  printf("\r\nFlashID is 0x%X\r\n", FlashID);

  if (FlashID == sFLASH_ID)
  {
    printf("\r\n检测到SPI FLASH W25Q64 !\r\n");
    SPI_FLASH_SectorErase(0x00000);                       // 写前先擦除
    SPI_FLASH_BufferWrite(Tx_Buffer, 0x00000, sizeof(Tx_Buffer));   // 写入
    printf("\r\n写入的数据为：\r\n%s", Tx_Buffer);

    SPI_FLASH_BufferRead(Rx_Buffer, 0x00000, sizeof(Tx_Buffer));    // 读出
    printf("\r\n读出的数据为：\r\n%s", Rx_Buffer);

    if (memcmp(Tx_Buffer, Rx_Buffer, sizeof(Tx_Buffer)) == 0)
    { LED2_ON;  printf("\r\n8M串行flash(W25Q64)测试成功!\n\r"); }
    else
    { LED1_ON;  printf("\r\n8M串行flash(W25Q64)测试失败!\n\r"); }
  }
  else
  { LED1_ON;  printf("\r\n获取不到 W25Q64 ID!\n\r"); }

  SPI_Flash_PowerDown();
  while(1);
}

四、代码分段讲解

1. SPI 是"全双工移位寄存器"

主机每发送 1 个字节的同时，必然接收 1 个字节——这是 SPI 的硬件本质。SPI_FLASH_SendByte() 正是利用这一点：写 DR 发命令，读 DR 取回从机回应的数据（读操作里发的是 Dummy_Byte 0xFF，纯属为了产生时钟去"挤"出数据）。

2. 模式 3 是什么？

SPI 有 4 种模式，由 CPOL（时钟极性）和 CPHA（时钟相位）决定。W25Q64 支持模式 0 和模式 3。本例用 CPOL=High、CPHA=2Edge（模式 3）：空闲时 SCK 为高，在第二个边沿（下降沿）采样。主从双方模式必须一致。

3. 为什么 CS 用软件 GPIO 控制？

SPI_NSS_SOFT 表示片选不交给硬件 NSS 引脚，而是我们手动拉低/拉高 FLASH_CS。这样时序最灵活——每个命令前后都能精确控制 CS 的脉冲，符合 Flash 的"命令-地址-数据"帧格式。

4. Flash “先擦后写"的铁律

NOR Flash 的存储单元只能把 1 写成 0，不能直接把 0 改回 1，只有"擦除"操作（按扇区/块/整片）才能整片恢复成 1。所以写数据前必须先擦除目标扇区（本例每扇区 4KB）。未擦除就写，会导致数据错误。

5. 为什么要分页写？

W25Q64 的"页编程"一次最多写 256 字节，且地址不能跨页自动回绕。因此 BufferWrite 要计算起始地址在页内的偏移，把超过本页边界的数据拆分到下一页写——这是 Flash 驱动里最易错、也最重要的细节。

6. 写后为什么要 `WaitForWriteEnd`？

芯片内部把数据烧录进存储阵列需要时间（毫秒级）。状态寄存器 bit0（WIP）为 1 表示"正在写”。驱动每次写/擦后都轮询该位，直到归零才继续，避免下一条命令在忙时被忽略。

五、实验现象

串口打印 检测到SPI FLASH W25Q64 !，并显示 FlashID is 0xEF4017；
串口回显写入的字符串与读出的字符串完全一致；
板载 LED2 点亮，表示读写校验成功；
若 ID 不符，LED1 点亮并打印"获取不到 W25Q64 ID"。

六、常见问题

Q1：读不到正确 ID（全 0 或全 FF）？

检查 SPI 模式（CPOL/CPHA）与 Flash 是否匹配；
检查 CS 时序：每条命令前后 CS 必须正确拉低/拉高；
用逻辑分析仪抓 SCK/MOSI/MISO，确认命令码真的发出去了。

Q2：写入后读出数据不对？

八成是没擦除就写了；写前务必 SPI_FLASH_SectorErase；
或写入长度跨页但没做分页处理。

Q3：SPI 时钟太快导致通信失败？

先把 SPI_BAUDRATEPRESCALER 调大（分频更多、更慢），稳定后再提速；W25Q64 最高支持约 80MHz（双/四线更快，但本例单线 18MHz 已稳妥）。

七、小结

SPI 通信 = 配置主模式参数 + 软件控 CS + 命令/地址/数据帧；
Flash 驱动三大要点：先擦后写、分页处理、写后等忙；
利用 SPI 全双工"发即收"特性，一个 SendByte 就能完成收发。

八、拓展应用

FatFs 文件系统：在 W25Q64 上挂载 FatFs，像 U 盘一样存文件（参考 Flash FatFs文件系统移植）。
存放字库/图片：把中文字模、BMP 图存进 Flash，LCD 显示时再读出来（见液晶显示系列例程）。
SPI DMA 加速：用 DMA 代替逐字节 SendByte，大块数据搬运效率大幅提升。
四线 QSPI：换用支持 QSPI 的 MCU（如 F4/F7/H7），把 W25Q64 当运行内存（XIP）直接执行代码。

STM32 I2C — 软件模拟读写 EEPROM（AT24C02）

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

STM32 I2C — 软件模拟读写 EEPROM（AT24C02）

开发板：野火 EBF STM32F103 Mini
固件库：HAL 库
对应例程：15-I2C-读写EEPROM
参考源码：User/main.c、User/i2c/bsp_i2c_gpio.h、User/i2c/bsp_i2c_gpio.c、User/i2c/bsp_i2c_ee.c

I2C（Inter-Integrated Circuit）是一种两线制、半双工、多主从的同步总线，只需要 SCL（时钟）和 SDA（数据）两根线就能挂多个设备。EEPROM 是 I2C 最典型的从机，用来保存掉电不丢的配置参数。

本文用软件模拟 I2C（GPIO 翻转时序），而非硬件 I2C 外设。原因是：软件 I2C 时序完全可见、易调试、跨平台可移植，野火例程特意用它来把 I2C 协议讲透。

一、功能简介

板上 AT24C02 是一颗 2Kbit（256 字节）的 I2C EEPROM。程序逻辑如下：

第一次运行（或未检测到数据标志）：写入一个 0xCD 标志，并把 7 个 小数 和 7 个 整数 存进去；
之后每次复位：检测到标志，从 EEPROM 读出之前存的数据，打印到串口验证"掉电不丢"。

核心知识点：

I2C 的起始/停止/应答（ACK/NACK）时序如何用 GPIO 拼出来；
AT24C02 的设备地址与页写限制（每页 8 字节）；
写后必须等待 EEPROM 内部写周期完成才能继续访问。

二、硬件准备

项目	说明
开发板	野火 EBF STM32F103 Mini
I2C 引脚	SCL → PA2，SDA → PA3（普通 GPIO，开漏输出）
从机	AT24C02，设备地址 `0xA0`（写）/ `0xA1`（读）
调试输出	USART1（115200）

AT24C02 地址 1 0 1 0 A2 A1 A0 R/W，板上 A2/A1/A0 接地 → 1010000，左移 1 位加 R/W 位 → 写 0xA0、读 0xA1。

三、完整代码（带中文注释）

1. bsp_i2c_gpio.h（引脚与宏）

#ifndef _BSP_I2C_GPIO_H
#define _BSP_I2C_GPIO_H

#include <inttypes.h>

#define EEPROM_I2C_WR   0   /* 写控制 bit */
#define EEPROM_I2C_RD   1   /* 读控制 bit */

/* 只需改这 4 行，就能把 I2C 搬到任意 GPIO */
#define I2Cx_SDA_GPIO_CLK_ENABLE()   __HAL_RCC_GPIOA_CLK_ENABLE()
#define I2Cx_SCL_GPIO_CLK_ENABLE()   __HAL_RCC_GPIOA_CLK_ENABLE()

#define EEPROM_GPIO_PORT_I2C   GPIOA
#define EEPROM_I2C_SCL_PIN     GPIO_PIN_2   /* 时钟线 */
#define EEPROM_I2C_SDA_PIN     GPIO_PIN_3   /* 数据线 */

/* 直接操作寄存器翻转 IO（比库函数快，满足 I2C 时序） */
#define EEPROM_I2C_SCL_1()  EEPROM_GPIO_PORT_I2C->BSRR = EEPROM_I2C_SCL_PIN
#define EEPROM_I2C_SCL_0()  EEPROM_GPIO_PORT_I2C->BRR  = EEPROM_I2C_SCL_PIN
#define EEPROM_I2C_SDA_1()  EEPROM_GPIO_PORT_I2C->BSRR = EEPROM_I2C_SDA_PIN
#define EEPROM_I2C_SDA_0()  EEPROM_GPIO_PORT_I2C->BRR  = EEPROM_I2C_SDA_PIN
#define EEPROM_I2C_SDA_READ()  ((EEPROM_GPIO_PORT_I2C->IDR & EEPROM_I2C_SDA_PIN) != 0)

void i2c_CfgGpio(void);
void i2c_Start(void);
void i2c_Stop(void);
void i2c_SendByte(uint8_t _ucByte);
uint8_t i2c_ReadByte(void);
uint8_t i2c_WaitAck(void);
void i2c_Ack(void);
void i2c_NAck(void);

#endif

2. bsp_i2c_gpio.c（时序模拟核心，节选）

#include "bsp_i2c_gpio.h"
#include "stm32f1xx.h"

/* 简单延时：循环 10 次约产生 200KHz 的 SCL（72MHz 主频下经验值） */
static void i2c_Delay(void)
{
  uint8_t i;
  for (i = 0; i < 10; i++);
}

/* 起始信号：SCL 高时，SDA 出现下降沿 */
void i2c_Start(void)
{
  EEPROM_I2C_SDA_1();
  EEPROM_I2C_SCL_1();
  i2c_Delay();
  EEPROM_I2C_SDA_0();
  i2c_Delay();
  EEPROM_I2C_SCL_0();   // 拉低 SCL，准备发数据
  i2c_Delay();
}

/* 停止信号：SCL 高时，SDA 出现上升沿 */
void i2c_Stop(void)
{
  EEPROM_I2C_SDA_0();
  EEPROM_I2C_SCL_1();
  i2c_Delay();
  EEPROM_I2C_SDA_1();
}

/* 发送 1 字节（高位先发） */
void i2c_SendByte(uint8_t _ucByte)
{
  uint8_t i;
  for (i = 0; i < 8; i++)
  {
    if (_ucByte & 0x80)
      EEPROM_I2C_SDA_1();
    else
      EEPROM_I2C_SDA_0();
    i2c_Delay();
    EEPROM_I2C_SCL_1();   // 上升沿锁存
    i2c_Delay();
    EEPROM_I2C_SCL_0();
    if (i == 7)
      EEPROM_I2C_SDA_1(); // 第 8 位发完释放 SDA 总线
    _ucByte <<= 1;
    i2c_Delay();
  }
}

/* 读取 1 字节 */
uint8_t i2c_ReadByte(void)
{
  uint8_t i, value = 0;
  for (i = 0; i < 8; i++)
  {
    value <<= 1;
    EEPROM_I2C_SCL_1();
    i2c_Delay();
    if (EEPROM_I2C_SDA_READ())
      value++;
    EEPROM_I2C_SCL_0();
    i2c_Delay();
  }
  return value;
}

/* 等待从机应答：第 9 个时钟读 SDA，0=有应答 */
uint8_t i2c_WaitAck(void)
{
  uint8_t re;
  EEPROM_I2C_SDA_1();   // 释放 SDA，交由从机拉低
  i2c_Delay();
  EEPROM_I2C_SCL_1();
  i2c_Delay();
  if (EEPROM_I2C_SDA_READ())
    re = 1;             // 没拉低 => 无应答
  else
    re = 0;
  EEPROM_I2C_SCL_0();
  i2c_Delay();
  return re;
}

/* 主机发 ACK（拉低 SDA 一个时钟） */
void i2c_Ack(void)
{
  EEPROM_I2C_SDA_0();
  i2c_Delay();
  EEPROM_I2C_SCL_1();
  i2c_Delay();
  EEPROM_I2C_SCL_0();
  i2c_Delay();
  EEPROM_I2C_SDA_1();
}

/* 主机发 NACK（最后 1 字节后通知从机"别再发了"） */
void i2c_NAck(void)
{
  EEPROM_I2C_SDA_1();
  i2c_Delay();
  EEPROM_I2C_SCL_1();
  i2c_Delay();
  EEPROM_I2C_SCL_0();
  i2c_Delay();
}

/* 配置 GPIO 为开漏输出，并先发一个停止信号复位总线 */
void i2c_CfgGpio(void)
{
  GPIO_InitTypeDef GPIO_InitStruct;
  I2Cx_SCL_GPIO_CLK_ENABLE();
  I2Cx_SDA_GPIO_CLK_ENABLE();

  GPIO_InitStruct.Pin   = EEPROM_I2C_SCL_PIN | EEPROM_I2C_SDA_PIN;
  GPIO_InitStruct.Mode  = GPIO_MODE_OUTPUT_OD;   // 开漏输出
  GPIO_InitStruct.Pull  = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
  HAL_GPIO_Init(EEPROM_GPIO_PORT_I2C, &GPIO_InitStruct);

  i2c_Stop();   // 复位 I2C 总线上所有设备到待机态
}

3. bsp_i2c_ee.c（EEPROM 读写，节选）

#include "bsp_i2c_ee.h"
#include "bsp_i2c_gpio.h"

#define EEPROM_DEV_ADDR   0xA0   /* 设备地址（写） */
#define EEPROM_PAGE_SIZE  8      /* 24C02 每页 8 字节 */
#define EEPROM_SIZE       256

/* 随机读取：先写地址，再重复起始读数据 */
uint8_t ee_ReadBytes(uint8_t *_pReadBuf, uint16_t _usAddress, uint16_t _usSize)
{
  uint16_t i;
  i2c_Start();
  i2c_SendByte(EEPROM_DEV_ADDR | EEPROM_I2C_WR);   // 写指令+地址
  if (i2c_WaitAck() != 0) goto cmd_fail;
  i2c_SendByte((uint8_t)_usAddress);               // 发送存储地址
  if (i2c_WaitAck() != 0) goto cmd_fail;

  i2c_Start();                                      // 重复起始条件
  i2c_SendByte(EEPROM_DEV_ADDR | EEPROM_I2C_RD);   // 改为读指令
  if (i2c_WaitAck() != 0) goto cmd_fail;

  for (i = 0; i < _usSize; i++)
  {
    _pReadBuf[i] = i2c_ReadByte();
    if (i != _usSize - 1)
      i2c_Ack();      // 中间字节回 ACK，让从机继续发
    else
      i2c_NAck();     // 最后一字节回 NACK，结束
  }
  i2c_Stop();
  return 1;
cmd_fail:
  i2c_Stop();
  return 0;
}

/* 页写：跨页时自动拆分，写后等待内部写周期结束 */
uint8_t ee_WriteBytes(uint8_t *_pWriteBuf, uint16_t _usAddress, uint16_t _usSize)
{
  uint16_t i, m, usAddr = _usAddress;
  for (i = 0; i < _usSize; i++)
  {
    /* 每页首地址或第 0 字节：重新起始 + 等上次写完成 */
    if ((i == 0) || (usAddr & (EEPROM_PAGE_SIZE - 1)) == 0)
    {
      i2c_Stop();
      for (m = 0; m < 1000; m++)        // 轮询等待 EEPROM 就绪
      {
        i2c_Start();
        i2c_SendByte(EEPROM_DEV_ADDR | EEPROM_I2C_WR);
        if (i2c_WaitAck() == 0) break;  // 有应答说明内部写已完成
      }
      if (m == 1000) goto cmd_fail;
      i2c_SendByte((uint8_t)usAddr);    // 发送当前存储地址
      if (i2c_WaitAck() != 0) goto cmd_fail;
    }
    i2c_SendByte(_pWriteBuf[i]);        // 写 1 字节
    if (i2c_WaitAck() != 0) goto cmd_fail;
    usAddr++;
  }
  i2c_Stop();
  /* 等待最后一次 EEPROM 内部写操作结束 */
  while (ee_CheckDevice(EEPROM_DEV_ADDR) != 0);
  return 1;
cmd_fail:
  i2c_Stop();
  return 0;
}

4. main.c（掉电保存演示）

#include "main.h"
#include "stm32f1xx.h"
#include "./usart/bsp_debug_usart.h"
#include "./led/bsp_led.h"
#include "./i2c/bsp_i2c_ee.h"

uint8_t cal_flag = 0;
int int_bufffer[7] = {0};
long double double_buffer[7] = {0};

#define DOUBLE_ADDR  10
#define LONGINT_ADDR 70

int main(void)
{
  HAL_Init();
  SystemClock_Config();
  DEBUG_USART_Config();
  printf("\r\n 这是一个EEPROM 读写小数和长整数实验 \r\n");

  i2c_CfgGpio();                    // 初始化 I2C GPIO（开漏）

  ee_ReadBytes(&cal_flag, 0, 1);    // 读 0 地址的标志位
  if (cal_flag != 0xCD)             // 没写过
  {
    printf("没有检测到数据标志，即将写入\r\n");
    cal_flag = 0xCD;
    ee_WriteBytes(&cal_flag, 0, 1);
    for (int k = 0; k < 7; k++)
    {
      double_buffer[k] = k + 0.1;
      int_bufffer[k]   = k * 500 + 1;
    }
    ee_WriteBytes((void*)double_buffer, DOUBLE_ADDR, sizeof(double_buffer));
    ee_WriteBytes((void*)int_bufffer,   LONGINT_ADDR, sizeof(int_bufffer));
    printf("已写入，请复位开发板读取验证\r\n");
  }
  else                               // 已写过
  {
    printf("检测到数据标志，读出数据：\r\n");
    ee_ReadBytes((void*)double_buffer, DOUBLE_ADDR,  sizeof(double_buffer));
    ee_ReadBytes((void*)int_bufffer,   LONGINT_ADDR, sizeof(int_bufffer));
    for (int k = 0; k < 7; k++)
      printf("小数=%LF 整数=%d\r\n", double_buffer[k], int_bufffer[k]);
  }
  while (1);
}

四、代码分段讲解

1. 为什么用软件 I2C？

STM32 的硬件 I2C 外设历史上"坑"较多，而软件模拟用两根 GPIO 翻转电平就能拼出时序，逻辑完全透明、易于用示波器对照学习。理解了软件 I2C，再看硬件 I2C 寄存器就轻松了。

2. 开漏输出 + 上拉电阻

I2C 总线要求 SDA/SCL 是**开漏（OD）**结构，并外接上拉电阻。开漏意味着引脚只能拉低或"释放"（靠上拉变高），这样多设备才能"线与"——谁拉低谁说了算，避免总线冲突。所以 i2c_CfgGpio 把引脚配成 GPIO_MODE_OUTPUT_OD。

3. 起始/停止信号的定义

起始：SCL 为高时，SDA 由高变低；
停止：SCL 为高时，SDA 由低变高。
数据位必须在 SCL 低电平时改变，在 SCL 高电平时保持稳定（主机在 SCL 上升沿采样）。这正是 i2c_SendByte 里"先摆数据、再拉高 SCL、再拉低"的由来。

4. ACK/NACK 应答

每传完 1 字节，接收方要在第 9 个时钟把 SDA 拉低表示"收到"（ACK）。读操作时，主机作为接收方：中间字节发 ACK 让从机继续发，最后一字节发 NACK 告诉从机"到此为止"。

5. AT24C02 的页写陷阱

24C02 每页只有 8 字节，且一次页写不能跨页（跨页会回绕覆盖）。所以 ee_WriteBytes 在遇到"页首地址"时重新发起始+地址，把数据按页切片写入。这是 I2C EEPROM 驱动最容易出错的地方。

6. 写后为什么要等？

主机把数据送到 EEPROM 后，EEPROM 要在内部把数据烧录进存储阵列（约几毫秒）。这段时间内它对总线寻址无应答。ee_WriteBytes 用 ee_CheckDevice 轮询应答，直到 EEPROM 响应，才认为写入完成——否则下一条命令会失败。

五、实验现象

第一次上电，串口打印"没有检测到数据标志，即将写入"；写完后提示"请复位开发板读取验证"；
按下复位键（不断电也可），串口打印出之前写入的 7 个小数和整数，证明数据已掉电保存；
即使断开电源再上电，数据依然存在（EEPROM 特性）。

六、常见问题

Q1：读写一直失败、检测不到设备？

确认 SDA/SCL 外接了上拉电阻（开发板一般已焊好），且 GPIO 配置为开漏；
确认设备地址 0xA0 与板上 A2/A1/A0 电平一致；
用示波器看 SCL 是否有波形，确认 i2c_Delay 延时合理（太快超出从机响应能力）。

Q2：写入后读出数据错乱？

多半是跨页没处理或写后没等忙；务必保留页拆分与 ee_CheckDevice 等待逻辑；
注意 AT24C02 容量仅 256 字节，地址别越界。

Q3：软件 I2C 和硬件 I2C 怎么选？

学习/移植/调试选软件 I2C；追求速率（400kHz/1MHz 快速模式）和 CPU 解放选硬件 I2C + DMA。

七、小结

I2C 是两线、多设备、半双工总线，靠地址寻址区分从机；
软件 I2C 用 GPIO 翻转拼出起始/停止/应答时序，是理解协议的最佳路径；
EEPROM 驱动要点：页写不跨页、写后等忙、读前发地址再重复起始。

八、拓展应用

保存用户配置：把屏幕亮度、通信参数等存进 EEPROM，上电自动恢复。
传感器标定系数：把零点/增益标定数据存 EEPROM，避免每次上电重新标定。
多从机总线：在同一条 I2C 上挂温湿度传感器（如 SHT30）、RTC（如 PCF8563）、OLED，用不同地址分时访问。
硬件 I2C + 中断/DMA：把软件模拟换成 HAL_I2C_Mem_Write/Read，提升速率并释放 CPU（参考后续硬件 I2C 进阶）。

STM32 TIM — 基本定时器定时（1ms 中断）

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

STM32 TIM — 基本定时器定时（1ms 中断）

开发板：野火 EBF STM32F103 Mini
固件库：HAL 库
对应例程：TIM—基本定时器定时
参考源码：User/main.c、User/tim/bsp_basic_tim.c、User/tim/bsp_basic_tim.h

定时器（TIMER）是 MCU 的"心脏节拍器"。STM32F103 有基本定时器（TIM6/7）、通用定时器（TIM2~5）、高级定时器（TIM1/8）。本文用最基础的 TIM6 产生 1ms 中断，在中断里累计毫秒数，主循环据此每 1 秒翻转一次 LED——这是后续所有"精确计时"应用的地基。

一、功能简介

把 TIM6 配置为 1ms 触发一次更新（溢出）中断；
每次中断在 HAL_TIM_PeriodElapsedCallback 回调里把全局 time 加 1；
主循环检测 time == 1000（即 1 秒到），清零并翻转 LED1。

效果：LED1 每 1 秒翻转一次，主循环完全不阻塞，可以并行做别的事。

核心知识点：

定时器时基：预分频（PSC）与自动重装载（ARR）如何决定溢出周期；
更新中断 + NVIC 配置；
HAL 的定时器回调机制。

二、硬件准备

项目	说明
开发板	野火 EBF STM32F103 Mini
定时器	TIM6（基本定时器，无外部引脚）
时钟源	内部时钟，挂载在 APB1（36MHz）
指示	LED1 → PC2
调试输出	USART1（115200）

TIM6/7 是纯定时用途的基本定时器，没有输入捕获/输出比较/PWM，只有时基单元和 update 中断，最适合做"系统滴答"。本例也可切换到 TIM7（bsp_basic_tim.h 里改宏即可）。

三、完整代码（带中文注释）

1. bsp_basic_tim.h（参数与宏）

#ifndef __BASIC_TIM_H
#define	__BASIC_TIM_H

#include "stm32f1xx.h"

/* 定时器预分频：实际时钟 = 72MHz / (BASIC_TIMx_PRESCALER + 1) */
#define BASIC_TIMx_PRESCALER   71
/* 自动重装载值：计数到该值产生更新中断 */
#define BASIC_TIMx_PERIOD      1000

#define USE_TIM6

#ifdef  USE_TIM6
#define BASIC_TIMx                  TIM6
#define BASIC_TIM_RCC_CLK_ENABLE()  __HAL_RCC_TIM6_CLK_ENABLE()
#define BASIC_TIM_IRQ               TIM6_IRQn
#else
#define BASIC_TIMx                  TIM7
#define BASIC_TIM_RCC_CLK_ENABLE()  __HAL_RCC_TIM7_CLK_ENABLE()
#define BASIC_TIM_IRQ               TIM7_IRQn
#endif

void BASIC_TIMx_Init(void);

#endif /* __BASIC_TIM_H */

2. bsp_basic_tim.c（定时器初始化与回调）

#include "./tim/bsp_basic_tim.h"

extern volatile uint32_t time;     // 主循环与中断共享的毫秒计数
TIM_HandleTypeDef htimx;

/* MSP：开 TIM 时钟 + 配 NVIC 中断优先级 */
void HAL_TIM_Base_MspInit(TIM_HandleTypeDef* htim_base)
{
  BASIC_TIM_RCC_CLK_ENABLE();                 // 开 TIM6 时钟
  HAL_NVIC_SetPriority(BASIC_TIM_IRQ, 1, 0); // 抢占优先级 1
  HAL_NVIC_EnableIRQ(BASIC_TIM_IRQ);          // 使能 TIM6 中断
}

/* 时基配置：1ms 溢出一次 */
void BASIC_TIMx_Init(void)
{
  TIM_MasterConfigTypeDef sMasterConfig;

  htimx.Instance               = BASIC_TIMx;
  htimx.Init.Prescaler        = BASIC_TIMx_PRESCALER;  // 71
  htimx.Init.CounterMode       = TIM_COUNTERMODE_UP;   // 向上计数
  htimx.Init.Period            = BASIC_TIMx_PERIOD;    // 1000
  HAL_TIM_Base_Init(&htimx);                         // 触发 HAL_TIM_Base_MspInit

  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  sMasterConfig.MasterSlaveMode     = TIM_MASTERSLAVEMODE_DISABLE;
  HAL_TIMEx_MasterConfigSynchronization(&htimx, &sMasterConfig);
}

/* 更新（溢出）中断回调：每进一次 +1ms */
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
  time++;
}

3. main.c（启动定时器 + 主循环判断）

#include "main.h"
#include "stm32f1xx.h"
#include "./usart/bsp_debug_usart.h"
#include "./led/bsp_led.h"
#include "./tim/bsp_basic_tim.h"

volatile uint32_t time = 0;   // ms 计时变量（全局，被中断修改）
extern TIM_HandleTypeDef htimx;

int main(void)
{
  SystemClock_Config();       // 72MHz
  DEBUG_USART_Config();
  LED_GPIO_Config();

  BASIC_TIMx_Init();          // 初始化 TIM6（1ms）
  HAL_TIM_Base_Start_IT(&htimx);   // 以中断方式启动定时器

  printf("\r\n 这是TIM—基本定时器定时 \r\n");

  while(1)
  {
    if (time == 1000)        // 累计 1000 次 = 1 秒
    {
      time = 0;
      LED1_TOGGLE;           // 翻转 LED1
    }
  }
}

四、代码分段讲解

1. 溢出周期怎么算？

定时器时钟来自 APB1，经倍频后 TIM6 实际时钟为 72MHz（F103 中 APB1 定时器时钟 = PCLK1×2 = 72M）。溢出时间公式：

1
2
3

溢出周期 T = (PSC + 1) × (ARR + 1) / TIM_CLK
           = (71 + 1) × (1000 + 1) / 72,000,000
           ≈ 1.000 ms

Prescaler = 71：72M 先 ÷72 → 计数频率 1MHz（每计数 1 次 = 1µs）；
Period = 1000：计满 1000 次 → 1ms 到，产生更新中断。（注：ARR=1000 实际计 1001 个边沿，误差极小，工程上直接用 1000 即可。）

2. `HAL_TIM_Base_Start_IT` 做了什么？

它启动计数器，并使能更新中断（UIE）。当计数器从 ARR 溢出归零时，硬件置更新标志、触发中断，跳进 TIM6_IRQHandler。

3. 中断怎么进到回调的？

stm32f1xx_it.c 里的 TIM6_IRQHandler 调用 HAL_TIM_IRQHandler(&htimx)，后者清标志并调用 HAL_TIM_PeriodElapsedCallback。我们把累加逻辑写在这个弱函数里，就实现了"每 1ms 自增"。这就是 HAL 的回调式中断编程，无需自己写清标志等寄存器操作。

4. 为什么 `time` 要加 `volatile`？

time 在中断里被修改、在主循环里被读取。加 volatile 告诉编译器"它可能随时被意外修改"，禁止把它的读取优化进寄存器缓存，否则主循环可能永远读不到最新值。

5. 与 `HAL_Delay` 的区别

HAL_Delay 也基于 SysTick 1ms 滴答，但它是阻塞的；本例用 TIM 中断做出非阻塞计时框架，主循环随时能响应别的任务，是更专业的写法。

五、实验现象

下载程序，串口打印提示语；
板载 LED1 每 1 秒翻转一次（亮 1 秒、灭 1 秒）；
与主循环 while(1) 轮询延时不同，此时若在主循环里加别的任务，LED 翻转节奏依然精准。

六、常见问题

Q1：LED 不闪或闪烁频率不对？

确认 HAL_TIM_Base_Start_IT 已调用（只 Init 不 Start 不会计数）；
检查 Prescaler/Period 计算是否与系统时钟匹配（系统须为 72MHz）；
确认 NVIC 中断已使能（HAL_NVIC_EnableIRQ）。

Q2：进入中断后卡死/反复进中断？

回调里不要做耗时操作；长时间占用中断会影响系统；
若用轮询清标志方式，记得在中断里清 UPDATE 标志，否则会连续触发。

Q3：想做更长时间定时（如 1 分钟）？

不要在中断里设超大 ARR，而是让 time 累计——每 1000 次（1 秒）在主循环判断换算，或再加一层 second 计数。

七、小结

基本定时器 = 预分频 + 自动重装载，决定溢出周期；
定时流程：开时钟 → 配时基 → 配 NVIC → Start_IT → 在回调里处理逻辑；
volatile 全局变量 + 中断回调，是构建非阻塞"时间片"系统的标准范式。

八、拓展应用

多路软定时：用 time 派生出 second、minute，或做一个 SoftTimer 数组，实现多个独立周期任务（如 100ms 采样、500ms 刷屏）。
精准延时函数：基于 time 实现 delay_ms_nonblock() 替代阻塞延时。
通用定时器进阶：TIM2~5 支持输入捕获（测频率/脉宽）和 PWM 输出（调光/电机），见 TIM—通用定时器-输入捕获 与 PWM 章节。
RTOS 时基：在 TIM 中断里调用 xTaskIncrementTick（FreeRTOS），把定时器变成操作系统的心跳。

STM32 DMA — 直接存储区访问（存储器到存储器）

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

STM32 DMA — 直接存储区访问（存储器到存储器）

开发板：野火 EBF STM32F103 Mini
固件库：HAL 库
对应例程：15-DMA—直接存储区访问 / DMA—存储器到存储器模式（并补充"存储器到外设"思路）
参考源码：User/main.c（存储器到存储器）

DMA（Direct Memory Access，直接存储器访问）允许外设与内存、内存与内存之间直接搬运数据，全程无需 CPU 参与。CPU 只需"下发搬运指令"，搬运由 DMA 控制器在后台完成，大幅解放内核。本文从最直观的"内存→内存"搬运入手，再延伸到"内存→外设"。

一、功能简介

例程准备两个数组：

源数组 aSRC_Const_Buffer：32 个 32 位常量（已初始化）；
目标数组 aDST_Buffer：32 个 32 位空位。

用 DMA 把源数组整块搬到目标数组，搬运完成后比较两数组是否一致：一致则点亮 LED2（成功），否则点亮 LED1（失败）。

核心知识点：

DMA 的方向、地址递增、数据宽度、传输模式、优先级；
STM32F1 的 DMA 通道与触发源（存储器到存储器必须用 DMA1）；
用标志位轮询传输完成。

二、硬件准备

项目	说明
开发板	野火 EBF STM32F103 Mini
DMA 控制器	DMA1（F103 仅 1 个 DMA 控制器，7 个通道）
本例通道	DMA1_Channel6（软件触发，M2M 模式专用）
指示	LED1 → PC2（失败）、LED2 → PC3（成功）

存储器到存储器（M2M）模式是 DMA 的特例：它不依赖外设硬件请求，而是软件触发一次就自动连续搬完，非常适合做 memcpy 加速。

三、完整代码（带中文注释）

1. main.c（M2M 搬运 + 校验）

#include "main.h"
#include "stm32f1xx.h"
#include "./led/bsp_led.h"

/* 存储器到存储器传输必须使用 DMA1 */
DMA_HandleTypeDef DMA_Handle;

#define DMA_STREAM          DMA1_Channel6
#define DMA_STREAM_CLOCK()  __HAL_RCC_DMA1_CLK_ENABLE();
#define BUFFER_SIZE         32

/* 源数据：常量数组（放在 Flash，DMA 把它读进 SRAM） */
const uint32_t aSRC_Const_Buffer[BUFFER_SIZE] = {
  0x01020304,0x05060708,0x090A0B0C,0x0D0E0F10,
  0x11121314,0x15161718,0x191A1B1C,0x1D1E1F20,
  0x21222324,0x25262728,0x292A2B2C,0x2D2E2F30,
  0x31323334,0x35363738,0x393A3B3C,0x3D3E3F40,
  0x41424344,0x45464748,0x494A4B4C,0x4D4E4F50,
  0x51525354,0x55565758,0x595A5B5C,0x5D5E5F60,
  0x61626364,0x65666768,0x696A6B6C,0x6D6E6F70,
  0x71727374,0x75767778,0x797A7B7C,0x7D7E7F80};

/* 目标数组：等待被填充 */
uint32_t aDST_Buffer[BUFFER_SIZE];

static void DMA_Config(void);
uint8_t Buffercmp(const uint32_t* pBuffer, uint32_t* pBuffer1, uint16_t BufferLength);

int main(void)
{
  uint8_t TransferStatus;
  SystemClock_Config();
  LED_GPIO_Config();

  DMA_Config();    // 配置并启动 DMA 搬运

  /* 轮询等待 DMA 传输完成标志（TCIF6） */
  while(__HAL_DMA_GET_FLAG(&DMA_Handle, DMA_FLAG_TC6) == RESET)
  {
  }

  /* 比较源与目标是否一致 */
  TransferStatus = Buffercmp(aSRC_Const_Buffer, aDST_Buffer, BUFFER_SIZE);
  if (TransferStatus == 0)
    LED1_ON;       // 不一致 => 失败灯
  else
    LED2_ON;       // 一致 => 成功灯

  while (1);
}

/* DMA 配置：存储器 -> 存储器 */
static void DMA_Config(void)
{
  HAL_StatusTypeDef DMA_status = HAL_ERROR;
  DMA_STREAM_CLOCK();

  DMA_Handle.Instance                 = DMA_STREAM;                 // DMA1_Channel6
  DMA_Handle.Init.Direction          = DMA_MEMORY_TO_MEMORY;        // 存储器到存储器
  DMA_Handle.Init.PeriphInc          = DMA_PINC_ENABLE;             // 外设(源)地址递增
  DMA_Handle.Init.MemInc             = DMA_MINC_ENABLE;             // 内存(目标)地址递增
  DMA_Handle.Init.PeriphDataAlignment= DMA_PDATAALIGN_WORD;         // 源数据 32 位
  DMA_Handle.Init.MemDataAlignment   = DMA_MDATAALIGN_WORD;         // 目标数据 32 位
  DMA_Handle.Init.Mode               = DMA_NORMAL;                 // 普通模式（一次）
  DMA_Handle.Init.Priority           = DMA_PRIORITY_MEDIUM;         // 中等优先级
  HAL_DMA_Init(&DMA_Handle);

  /* 启动传输：源地址 -> 目标地址，共 BUFFER_SIZE 个数据项 */
  DMA_status = HAL_DMA_Start(&DMA_Handle,
                             (uint32_t)aSRC_Const_Buffer,
                             (uint32_t)aDST_Buffer,
                             BUFFER_SIZE);
  if (DMA_status != HAL_OK)
  {
    while (1)   // 启动失败，闪烁报警
    {
      LED1_ON; Delay(0xFFFFFF); LED1_TOGGLE; Delay(0xFFFFFF);
    }
  }
}

/* 比较两个数组是否完全一致 */
uint8_t Buffercmp(const uint32_t* pBuffer, uint32_t* pBuffer1, uint16_t BufferLength)
{
  while(BufferLength--)
  {
    if(*pBuffer != *pBuffer1) return 0;   // 有差异立即返回 0
    pBuffer++;   pBuffer1++;
  }
  return 1;   // 全部相等返回 1
}

四、代码分段讲解

1. DMA 到底省了什么？

普通 for 循环拷贝数组，每个字节都要 CPU 取指、读源、写目标——CPU 全程被占。DMA 接管总线后，CPU 在 HAL_DMA_Start 之后就可以去干别的事（本例只是 while 等标志，实际项目里可以并行运算）。对大块数据 / 高速外设（ADC、SPI、USART、LCD）而言，DMA 是性能关键。

2. 四个关键配置

字段	本例	含义
`Direction`	`DMA_MEMORY_TO_MEMORY`	存储器→存储器（软件触发）
`PeriphInc` / `MemInc`	`ENABLE`	源、目标地址都递增（否则会反复写同一格）
`PeriphDataAlignment` / `MemDataAlignment`	`WORD`(32位)	数据宽度要一致，避免错位
`Mode`	`DMA_NORMAL`	普通模式：搬完一次就停（对比循环 `DMA_CIRCULAR`）

注意：这里"Periph"一方是源数组，在 M2M 模式下 HAL 把源/目标统称为外设/内存，只需保证两者都递增、宽度相同即可。

3. 通道与触发源

F103 的 DMA1 有 7 个通道，每个通道固定对应某些外设请求（如 ADC1→CH1、SPI1→CH3、USART1_TX→CH4）。只有 DMA1 支持 M2M 软件触发，所以本例用 DMA1_Channel6。换成"内存→USART"时，就要选 USART 对应的专属通道，并由外设硬件触发。

4. 传输完成怎么知道？

__HAL_DMA_GET_FLAG(&DMA_Handle, DMA_FLAG_TC6) 读取传输完成标志（TCIF）。本例用轮询等待；实际中更常用传输完成中断（DMA_IT_TC），在 HAL_DMA_XferCpltCallback 里接着处理，彻底不阻塞 CPU。

5. 补充：存储器到外设（如 USART 发大报）

野火例程还有"DMA—存储器到外设模式"：把 Direction 设为 DMA_MEMORY_TO_PERIPH，把外设地址填成 &USART1->DR，源填发送缓冲区，再 HAL_UART_Transmit_DMA()。这样 CPU 一次性把几百字节交给 DMA，串口慢慢发、CPU 同时翻转 LED——直观展示了"DMA 让 CPU 腾出手"。

五、实验现象

下载程序，DMA 把 32 个常量从源数组搬进目标数组；
比较两数组完全一致 → LED2 点亮（成功灯）；
若把源/目标数据宽度设错（比如一方 WORD 一方 BYTE），拷贝错位导致比较失败 → LED1 点亮。

六、常见问题

Q1：传输后数据错位/不一致？

检查源和目标数据宽度是否一致（都 WORD 或都 HALFWORD）；
检查 PeriphInc/MemInc 是否都 ENABLE（单地址重复写会出错）。

Q2：DMA 一直不完成（标志位不来）？

M2M 模式确认用的是 DMA1；
确认 HAL_DMA_Start 返回的 DMA_status == HAL_OK，且传输长度不为 0。

Q3：为什么我的外设 DMA 没动？

外设 DMA 需要对应的专属通道和外设硬件触发，不能随便选通道；
外设自身要先使能（如 USART 要先 HAL_UART_Init）。

Q4：NORMAL 和 CIRCULAR 怎么选？

单次传输（如发一帧数据）用 NORMAL；
连续流（如 ADC 持续采集、DAC 持续输出波形）用 CIRCULAR，搬完自动从头再来。

七、小结

DMA 是"数据搬运工"，让 CPU 从繁琐的拷数据中解放；
M2M 配置要点：方向 M2M、双端递增、宽度一致、软件触发；
掌握 DMA 后，ADC、SPI、USART、DAC 等高速外设才能真正发挥性能。

八、拓展应用

大数组 memcpy 加速：把 for 循环拷贝换成 DMA M2M，批量搬运 SRAM/Flash 数据更快。
ADC + DMA 连续采样：如本博客 ADC 章节，DMA 把转换结果循环搬进数组，零 CPU 占用。
USART/SPI 大块发送：用 HAL_UART_Transmit_DMA / HAL_SPI_Transmit_DMA，发送几百 KB 时 CPU 仍可并行处理。
双缓冲（Double Buffer）：配合 DMA 半传输中断，实现"一边 DMA 填半区、CPU 处理另半区"的无缝流水线，适合音频、图像流。

野火 on CLing

STM32 GPIO 输出 — 使用 HAL 库点亮 LED 灯

STM32 GPIO 输出 — 使用 HAL 库点亮 LED 灯

一、功能简介

二、硬件准备

三、完整代码（带中文注释）

1. main.c（主程序）

2. bsp_led.h（LED 引脚宏定义）

3. bsp_led.c（GPIO 初始化）

四、代码分段讲解

1. 为什么先开时钟？

2. GPIO_InitTypeDef 四个关键字段

3. 推挽输出 vs 开漏输出

4. HAL_Delay() 从哪来？

5. 宏的妙用

五、实验现象

六、常见问题

七、小结

八、拓展应用

STM32 GPIO 输入 — 按键检测（轮询方式）

STM32 GPIO 输入 — 按键检测（轮询方式）

一、功能简介

二、硬件准备

三、完整代码（带中文注释）

1. main.c（主程序）

2. bsp_key.h（按键引脚定义）

3. bsp_key.c（按键初始化 + 扫描）

四、代码分段讲解

1. 输入模式怎么选？

2. HAL_GPIO_ReadPin() 读的是什么？

3. 为什么要"等待释放"？

4. LEDx_TOGGLE 是怎么实现的？

五、实验现象

六、常见问题

七、小结

八、拓展应用

STM32 USART — 串口通信与 printf 重定向

STM32 USART — 串口通信与 printf 重定向

一、功能简介

二、硬件准备

三、完整代码（带中文注释）

1. main.c（主程序）

2. bsp_debug_usart.h（引脚与波特率定义）

3. bsp_debug_usart.c（配置、MSP、printf 重定向）

4. stm32f1xx_it.c（中断服务函数，节选）

四、代码分段讲解

1. TX/RX 为什么要"复用"？

2. HAL_UART_Init 会触发 HAL_UART_MspInit

3. printf 重定向原理

4. 中断接收 vs 轮询接收

五、实验现象

六、常见问题

七、小结

八、拓展应用

STM32 ADC — 独立模式单通道 + DMA 连续采集

STM32 ADC — 独立模式单通道 + DMA 连续采集

一、功能简介

二、硬件准备

三、完整代码（带中文注释）

1. bsp_adc.h（引脚与 DMA 通道定义）

2. bsp_adc.c（GPIO、DMA、ADC 配置）

3. main.c（主循环读取并打印）

四、代码分段讲解

1. 为什么引脚要设成 GPIO_MODE_ANALOG？

2. DMA 方向：外设 → 内存

3. __HAL_LINKDMA 做了什么？

4. ADC 时钟为什么分频？

5. 电压换算

五、实验现象

六、常见问题

七、小结

八、拓展应用

STM32 SPI — 读写串行 FLASH（W25Q64）

STM32 SPI — 读写串行 FLASH（W25Q64）

一、功能简介

二、硬件准备

三、完整代码（带中文注释）

1. bsp_spi_flash.h（引脚、指令、接口声明）

2. bsp_spi_flash.c（SPI 初始化与 Flash 驱动，节选核心）

3. main.c（演示流程）

2. `GPIO_InitTypeDef` 四个关键字段

4. `HAL_Delay()` 从哪来？

2. `HAL_GPIO_ReadPin()` 读的是什么？

4. `LEDx_TOGGLE` 是怎么实现的？

2. `HAL_UART_Init` 会触发 `HAL_UART_MspInit`

1. 为什么引脚要设成 `GPIO_MODE_ANALOG`？

3. `__HAL_LINKDMA` 做了什么？

6. 写后为什么要 `WaitForWriteEnd`？

2. `HAL_TIM_Base_Start_IT` 做了什么？

4. 为什么 `time` 要加 `volatile`？

5. 与 `HAL_Delay` 的区别