STM32 SPI读取写入W25Q64JVSSIQ

qq_429499572026-01-27 11:22

w25q64.h

c 复制代码 
#ifndef __W25Q64_H
#define __W25Q64_H

#include "main.h"
#include "spi.h"

// 引脚定义
#define W25Q64_CS_PIN        GPIO_PIN_15
#define W25Q64_CS_PORT       GPIOA

// W25Q64指令集
#define W25Q64_WRITE_ENABLE  0x06
#define W25Q64_WRITE_DISABLE 0x04
#define W25Q64_READ_STATUS1  0x05
#define W25Q64_WRITE_STATUS1 0x01
#define W25Q64_READ_DATA     0x03
#define W25Q64_PAGE_PROGRAM  0x02
#define W25Q64_SECTOR_ERASE  0x20
#define W25Q64_CHIP_ERASE    0xC7
#define W25Q64_POWER_DOWN    0xB9
#define W25Q64_RELEASE_PD    0xAB
#define W25Q64_MANUF_DEVICE_ID 0x90
#define W25Q64_JEDEC_ID      0x9F

// Flash容量参数
#define W25Q64_PAGE_SIZE     256
#define W25Q64_SECTOR_SIZE   4096
#define W25Q64_TOTAL_SIZE    (8 * 1024 * 1024)  // 8MB

// 函数声明
void W25Q64_Init(void);
uint8_t W25Q64_ReadByte(uint32_t addr);
void W25Q64_ReadBytes(uint32_t addr, uint8_t *buf, uint32_t len);
void W25Q64_WriteByte(uint32_t addr, uint8_t data);
void W25Q64_WriteBytes(uint32_t addr, uint8_t *data, uint32_t len);
void W25Q64_ModifyByte(uint32_t addr, uint8_t data);
void W25Q64_EraseSector(uint32_t sector_addr);
void W25Q64_WaitBusy(void);
uint32_t W25Q64_ReadID(void);

#endif /* __W25Q64_H */

w25q64.c

c 复制代码 
#include "w25q64.h"

// 私有函数声明
static void W25Q64_CS_Low(void);
static void W25Q64_CS_High(void);
static void W25Q64_WriteEnable(void);
static uint8_t W25Q64_ReadStatus(void);

// 初始化函数
void W25Q64_Init(void)
{
    W25Q64_CS_High();
    HAL_Delay(10);
    
    // 读取ID验证连接
    uint32_t id = W25Q64_ReadID();
    if(id == 0xEF4017)  // W25Q64JV的JEDEC ID
    {
        // 初始化成功
    }
}

// 读取单个字节
uint8_t W25Q64_ReadByte(uint32_t addr)
{
    uint8_t cmd[4] = {W25Q64_READ_DATA, (addr >> 16) & 0xFF, (addr >> 8) & 0xFF, addr & 0xFF};
    uint8_t data = 0;
    
    W25Q64_CS_Low();
    HAL_SPI_Transmit(&hspi6, cmd, 4, 100);
    HAL_SPI_Receive(&hspi6, &data, 1, 100);
    W25Q64_CS_High();
    
    return data;
}

// 读取多个字节
void W25Q64_ReadBytes(uint32_t addr, uint8_t *buf, uint32_t len)
{
    uint8_t cmd[4] = {W25Q64_READ_DATA, (addr >> 16) & 0xFF, (addr >> 8) & 0xFF, addr & 0xFF};
    
    W25Q64_CS_Low();
    HAL_SPI_Transmit(&hspi6, cmd, 4, 100);
    HAL_SPI_Receive(&hspi6, buf, len, 1000);
    W25Q64_CS_High();
}

// 写入单个字节
void W25Q64_WriteByte(uint32_t addr, uint8_t data)
{
    uint8_t cmd[5] = {W25Q64_PAGE_PROGRAM, (addr >> 16) & 0xFF, (addr >> 8) & 0xFF, addr & 0xFF, data};
    
    W25Q64_WriteEnable();
    W25Q64_CS_Low();
    HAL_SPI_Transmit(&hspi6, cmd, 5, 100);
    W25Q64_CS_High();
    W25Q64_WaitBusy();
}

// 写入多个字节（注意：不能跨页写入）
void W25Q64_WriteBytes(uint32_t addr, uint8_t *data, uint32_t len)
{
    // 确保不跨页写入
    uint32_t page_remain = W25Q64_PAGE_SIZE - (addr % W25Q64_PAGE_SIZE);
    uint32_t write_len = (len > page_remain) ? page_remain : len;
    
    uint8_t *cmd = (uint8_t*)malloc(write_len + 4);
    if(cmd == NULL) return;
    
    cmd[0] = W25Q64_PAGE_PROGRAM;
    cmd[1] = (addr >> 16) & 0xFF;
    cmd[2] = (addr >> 8) & 0xFF;
    cmd[3] = addr & 0xFF;
    memcpy(&cmd[4], data, write_len);
    
    W25Q64_WriteEnable();
    W25Q64_CS_Low();
    HAL_SPI_Transmit(&hspi6, cmd, write_len + 4, 1000);
    W25Q64_CS_High();
    W25Q64_WaitBusy();
    
    free(cmd);
    
    // 如果还有数据需要写入，递归调用
    if(len > write_len)
    {
    		
        W25Q64_WriteBytes(addr + write_len, data + write_len, len - write_len);
    }
}

// 修改指定地址的字节（先擦除后写入）
void W25Q64_ModifyByte(uint32_t addr, uint8_t data)
{
    // 计算所在扇区
    uint32_t sector_addr = addr - (addr % W25Q64_SECTOR_SIZE);
    uint8_t sector_buffer[W25Q64_SECTOR_SIZE];
    
    // 1. 读取整个扇区
    W25Q64_ReadBytes(sector_addr, sector_buffer, W25Q64_SECTOR_SIZE);
    
    // 2. 修改指定字节
    sector_buffer[addr - sector_addr] = data;
    
    // 3. 擦除扇区
    W25Q64_EraseSector(sector_addr);
    
    // 4. 重新写入整个扇区
    // 分页写入，每次写入一页（256字节）
    for(uint32_t i = 0; i < W25Q64_SECTOR_SIZE; i += W25Q64_PAGE_SIZE)
    {
        W25Q64_WriteBytes(sector_addr + i, &sector_buffer[i], W25Q64_PAGE_SIZE);
    }
}

// 擦除扇区（4KB）
void W25Q64_EraseSector(uint32_t sector_addr)
{
    uint8_t cmd[4] = {W25Q64_SECTOR_ERASE, (sector_addr >> 16) & 0xFF, (sector_addr >> 8) & 0xFF, sector_addr & 0xFF};
    
    W25Q64_WriteEnable();
    W25Q64_CS_Low();
    HAL_SPI_Transmit(&hspi6, cmd, 4, 100);
    W25Q64_CS_High();
    W25Q64_WaitBusy();
}

// 等待Flash操作完成
void W25Q64_WaitBusy(void)
{
    while(W25Q64_ReadStatus() & 0x01)
    {
        HAL_Delay(1);
    }
}

// 读取JEDEC ID
uint32_t W25Q64_ReadID(void)
{
    uint8_t cmd = W25Q64_JEDEC_ID;
    uint8_t id_data[3];
    
    W25Q64_CS_Low();
    HAL_SPI_Transmit(&hspi6, &cmd, 1, 100);
    HAL_SPI_Receive(&hspi6, id_data, 3, 100);
    W25Q64_CS_High();
    
    return (id_data[0] << 16) | (id_data[1] << 8) | id_data[2];
}

// 私有函数实现
static void W25Q64_CS_Low(void)
{
    HAL_GPIO_WritePin(W25Q64_CS_PORT, W25Q64_CS_PIN, GPIO_PIN_RESET);
}

static void W25Q64_CS_High(void)
{
    HAL_GPIO_WritePin(W25Q64_CS_PORT, W25Q64_CS_PIN, GPIO_PIN_SET);
}

static void W25Q64_WriteEnable(void)
{
    uint8_t cmd = W25Q64_WRITE_ENABLE;
    
    W25Q64_CS_Low();
    HAL_SPI_Transmit(&hspi6, &cmd, 1, 100);
    W25Q64_CS_High();
}

static uint8_t W25Q64_ReadStatus(void)
{
    uint8_t cmd = W25Q64_READ_STATUS1;
    uint8_t status;
    
    W25Q64_CS_Low();
    HAL_SPI_Transmit(&hspi6, &cmd, 1, 100);
    HAL_SPI_Receive(&hspi6, &status, 1, 100);
    W25Q64_CS_High();
    
    return status;
}

使用例程

c 复制代码 
#include "w25q64.h"

// 测试函数
void main(void)
{
    uint8_t read_data;
    uint8_t write_data = 0xAA;
    uint32_t test_addr = 0x000000;  // 测试地址
    
    // 1. 初始化
    W25Q64_Init();
    
    // 2. 写入单个字节
    W25Q64_WriteByte(test_addr, write_data);
    HAL_Delay(10);
    
    // 3. 读取单个字节
    read_data = W25Q64_ReadByte(test_addr);
    if(read_data == write_data)
    {
        // 写入成功
    }
    
    // 4. 批量写入测试
    uint8_t write_buffer[256];
    uint8_t read_buffer[256];
    
    for(int i = 0; i < 256; i++)
    {
        write_buffer[i] = i;
    }
    
    W25Q64_WriteBytes(0x1000, write_buffer, 256);
    HAL_Delay(10);
    
    // 5. 批量读取测试
    W25Q64_ReadBytes(0x1000, read_buffer, 256);
    
    // 6. 修改指定地址的数据
    W25Q64_ModifyByte(0x2000, 0x55);
    
    // 7. 擦除扇区测试
    W25Q64_EraseSector(0x3000);
}

CubeMX配置要点

  1. SPI6配置：
    · Mode: Full-Duplex Master
    · Hardware NSS Signal: Disable
    · Prescaler: 根据HCLK频率调整（建议≤50MHz）
  2. GPIO配置：
    · PA15: GPIO_Output（CS引脚）
    · PB3: SPI6_SCK
    · PB4: SPI6_MISO
    · PB5: SPI6_MOSI
  3. 时钟配置：
    · 确保SPI时钟不超过W25Q64的最大频率（104MHz）

注意事项

  1. 写操作前必须擦除：Flash只能从1变为0，所以写前需要擦除（变为0xFF）
  2. 擦除最小单位：4KB扇区
  3. 写操作跨页处理：页大小为256字节，跨页时需要分页写入
  4. 修改函数效率：W25Q64_ModifyByte会擦除整个扇区，频繁修改时应考虑缓存机制

这个驱动提供了基本的读写和修改功能，可以根据需要扩展更多功能（如整片擦除、快速读取等）。

相关推荐
悠哉悠哉愿意4 天前
【单片机学习笔记】串口、超声波、NE555的同时使用
笔记·单片机·学习
Lester_11015 天前
STM32霍尔传感器输入口设置为复用功能输入口时，还能用GPIO函数直接读取IO的状态吗
stm32·单片机·嵌入式硬件·电机控制
LCG元5 天前
低功耗显示方案：STM32L0驱动OLED，动态波形绘制与优化
stm32·嵌入式硬件·信息可视化
三佛科技-187366133975 天前
120W小体积碳化硅电源方案（LP8841SC极简方案12V10A/24V5A输出）
单片机·嵌入式硬件
z20348315205 天前
STM32F103系列单片机定时器介绍（二）
stm32·单片机·嵌入式硬件
古译汉书5 天前
【IoT死磕系列】Day 7：只传8字节怎么控机械臂？学习工业控制 CANopen 的“对象字典”（附企业级源码）
数据结构·stm32·物联网·http
Alaso_shuang5 天前
STM32 核心输入、输出模式
stm32·单片机·嵌入式硬件
脚后跟5 天前
AI助力嵌入式物联网项目全栈开发
嵌入式硬件·物联网·ai编程
2501_918126915 天前
stm32死锁是怎么实现的
stm32·单片机·嵌入式硬件·学习·个人开发
z20348315205 天前
STM32F103系列单片机定时器介绍（一）
stm32·单片机
热门推荐
01GitHub 镜像站点02OpenClaw 使用和管理 MCP 完全指南03OpenClaw + 飞书（Feishu）环境搭建指南04【OpenClaw 本地实战 Ep.3】突破瓶颈：强制修改 openclaw.json 解锁 32k 上下文记忆05Claude Code + GLM4.7 避坑指南：解决 Unable to connect to Anthropic services06OpenClaw优化飞书API 额度已耗尽问题07小黑课堂计算机二级WPSoffice题库软件下载安装教程（2026年3月最新版）08Clawdbot部署教程：解决‘gateway token missing’授权问题的完整步骤09Window 10部署openclaw报错node.exe : npm error code 12810OpenClaw大龙虾机器人完整安装教程