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）直接执行代码。

W25Q64 on CLing

STM32 SPI — 读写串行 FLASH（W25Q64）

STM32 SPI — 读写串行 FLASH（W25Q64）

一、功能简介

二、硬件准备

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

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

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

3. main.c（演示流程）

四、代码分段讲解

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

2. 模式 3 是什么？

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

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

5. 为什么要分页写？

6. 写后为什么要 WaitForWriteEnd？

五、实验现象

六、常见问题

七、小结

八、拓展应用

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