SPI-读写串行FLASH

本篇总结

使用 SPI 读写并擦除串行 FLASH（W25Q64）。

硬件平台：本例程基于 W55MH32L-EVB 开发板运行。

采购推荐：点击前往 WIZnet 官方淘宝店铺 选购 W55MH32L-EVB

为什么必须先擦除再写入

NOR Flash 的物理特性是只能把 1 改成 0，不能把 0 改回 1。想让某个字节恢复成可写状态，唯一办法就是擦除——擦除会把整片区域全部置为 0xFF。因此本例程的顺序固定为「擦除 → 写入 → 读回」，跳过擦除直接写会得到错误数据。

注意：W55MH32L-EVB 板载没有 SPI Flash

开发板上自带的存储器件只有 I2C EEPROM（AT24C16C）和 TF 卡槽（SDIO），没有焊接 W25Q 系列 SPI Flash。运行本例程需要自备一块 W25Q64 模块（或 W25Qxx 转接板），用杜邦线接到开发板的 IO 排针上。

片选控制说明

实际应用中一般不使用 SPI 硬件 NSS 信号线，而是用普通 GPIO 软件控制 PA4 电平：拉低选中 FLASH、拉高释放。这样更灵活，也便于扩展多个从设备。W25Q64 的 /CS 必须在整条指令（命令字 + 地址 + 数据）期间保持低电平，指令结束才能拉高。

void SPI_InitTest(void)
{
    GPIO_InitTypeDef GPIO_InitStructure;
    SPI_InitTypeDef  SPI_InitStructure;

    /* 开启 GPIOA 与 SPI1 时钟 */
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);

    /* PA5/SCK, PA6/MISO, PA7/MOSI: 复用推挽输出 */
    GPIO_InitStructure.GPIO_Pin   = GPIO_Pin_5 | GPIO_Pin_6 | GPIO_Pin_7;
    GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_AF_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &GPIO_InitStructure);
    GPIO_SetBits(GPIOA, GPIO_Pin_5 | GPIO_Pin_6 | GPIO_Pin_7);

    /* SPI1 参数：主模式 / 模式3 (CPOL=High, CPHA=2Edge) / 8位帧 / MSB先行 */
    SPI_InitStructure.SPI_Direction         = SPI_Direction_2Lines_FullDuplex;
    SPI_InitStructure.SPI_Mode              = SPI_Mode_Master;
    SPI_InitStructure.SPI_DataSize          = SPI_DataSize_8b;
    SPI_InitStructure.SPI_CPOL              = SPI_CPOL_High;    /* 空闲高电平 */
    SPI_InitStructure.SPI_CPHA              = SPI_CPHA_2Edge;   /* 偶数边沿采样 */
    SPI_InitStructure.SPI_NSS               = SPI_NSS_Soft;     /* 软件控制片选 */
    SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256;
    SPI_InitStructure.SPI_FirstBit          = SPI_FirstBit_MSB;
    SPI_InitStructure.SPI_CRCPolynomial     = 7;

    SPI_Init(SPI1, &SPI_InitStructure);
    SPI_Cmd(SPI1, ENABLE);

    SPI_ReadWriteByte(0xff);   /* 发起一次空传输，稳定 SPI 时序 */
}

void W25QXX_Init(void)
{
    GPIO_InitTypeDef GPIO_InitStructure;
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);

    /* PA4: 片选 CS，推挽输出，初始拉高（非选中状态） */
    GPIO_InitStructure.GPIO_Pin   = GPIO_Pin_4;
    GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_Out_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &GPIO_InitStructure);
    GPIO_SetBits(GPIOA, GPIO_Pin_4);

    W25QXX_CS = 1;                            /* 先拉高片选，不选中 FLASH */
    SPI_InitTest();                           /* 初始化 SPI1 */
    SPI_SetSpeed(SPI_BaudRatePrescaler_128);  /* 提速到 128 分频 */
    W25QXX_TYPE = W25QXX_ReadID();            /* 读取并记录芯片 ID */
}

如果你想自定义

• 改通讯速率 → 修改 SPI_SetSpeed() 的入参，如 SPI_BaudRatePrescaler_4（更高速）。W25Q64 标称最高 SCK 为 104MHz，别超规格
• 换用 SPI2 → 同步修改 GPIO 引脚（PB12-PB15）和时钟使能宏 RCC_APB1Periph_SPI2，并查阅数据手册确认引脚映射
• 改为模式 0 → 将 SPI_CPOL_High 改为 SPI_CPOL_Low、SPI_CPHA_2Edge 改为 SPI_CPHA_1Edge。模式 0 与模式 3 都能驱动 W25Q64

u16 W25QXX_ReadID(void)
{
    u16 Temp  = 0;
    W25QXX_CS = 0;                            /* 拉低片选，选中器件 */
    SPI_ReadWriteByte(0x90);                  /* 发送读 ID 命令 */
    SPI_ReadWriteByte(0x00);                  /* 24 位地址 */
    SPI_ReadWriteByte(0x00);
    SPI_ReadWriteByte(0x00);
    Temp     |= SPI_ReadWriteByte(0xFF) << 8; /* 厂商 ID: 0xEF */
    Temp     |= SPI_ReadWriteByte(0xFF);      /* 器件 ID: 0x16 */
    W25QXX_CS = 1;                            /* 拉高片选，释放器件 */
    return Temp;
}

如果你想自定义

• 换成 W25Q128 → 把 main.c 里的判断改成 W25Q128，并把 w25qxx.h 里 W25Q64_SIZE 改为 16 * 1024 * 1024
• 用 JEDEC ID → 发送 0x9F 可读回 3 字节（厂商 + 容量 + 类型），信息更全，需相应改写读取函数

void W25QXX_Erase_Sector(u32 Dst_Addr)
{
    Dst_Addr *= 4096;                          /* 扇区号 → 字节地址 */

    W25QXX_Write_Enable();                     /* 置位 WEL，允许写/擦 */
    W25QXX_Wait_Busy();

    W25QXX_CS = 0;                             /* 拉低片选 */
    SPI_ReadWriteByte(W25X_SectorErase);       /* 0x20 扇区擦除命令 */
    SPI_ReadWriteByte((u8)((Dst_Addr) >> 16)); /* 24 位地址，高字节先发 */
    SPI_ReadWriteByte((u8)((Dst_Addr) >> 8));
    SPI_ReadWriteByte((u8)Dst_Addr);
    W25QXX_CS = 1;                             /* 拉高片选，指令生效 */

    W25QXX_Wait_Busy();                        /* 等待内部擦除完成 */
}

/* 等待 BUSY 位清零：内部擦写期间状态寄存器 bit0 为 1 */
void W25QXX_Wait_Busy(void)
{
    while ((W25QXX_ReadSR() & 0x01) == 0x01);
}

/* 逐页读回整个扇区，每页 256 字节，共 16 页 */
erased = 1;
for (page = 0; page < W25QXX_SECTOR_SIZE / W25QXX_PAGE_SIZE; page++)
{
    W25QXX_Read(g_verifyBuf, TEST_ADDR + (uint32_t)page * W25QXX_PAGE_SIZE, W25QXX_PAGE_SIZE);
    for (i = 0; i < W25QXX_PAGE_SIZE; i++)
    {
        if (g_verifyBuf[i] != 0xFF)
        {
            erased = 0;
            break;
        }
    }
    if (!erased) break;
}
printf("    Erase check: %s\n", erased ? "all 0xFF, OK" : "NOT clean!");

如果你想自定义

• 换测试扇区 → 修改 TEST_ADDR。本例用 W25Q64_SIZE - W25QXX_SECTOR_SIZE，即最后一个扇区 0x7FF000（扇区号 2047），避开其他数据
• 整片擦除 → 调用 W25QXX_Erase_Chip()（命令 0xC7），但耗时较长，注意别把整片数据都清掉了
• 避免死等 → 在 W25QXX_Wait_Busy() 里加超时计数，超时则返回错误码，避免硬件异常时程序卡死

void W25QXX_Write(u8 *pBuffer, u32 WriteAddr, u16 NumByteToWrite)
{
    u32 secpos;                                                    /* 扇区号 */
    u16 secoff;                                                    /* 扇区内偏移 */
    u16 secremain;                                                 /* 扇区剩余空间 */
    u16 i;
    u8 *W25QXX_BUF;
    W25QXX_BUF = W25QXX_BUFFER;                                    /* 指向 4KB 扇区缓冲 */
    secpos     = WriteAddr / 4096;
    secoff     = WriteAddr % 4096;
    secremain  = 4096 - secoff;

    if (NumByteToWrite <= secremain) secremain = NumByteToWrite;    /* 不超过 4096 字节 */

    while (1)
    {
        W25QXX_Read(W25QXX_BUF, secpos * 4096, 4096);              /* 读出整个扇区 */

        for (i = 0; i < secremain; i++)                            /* 校验待写区域 */
        {
            if (W25QXX_BUF[secoff + i] != 0XFF) break;             /* 不干净 → 需要擦除 */
        }

        if (i < secremain)                                         /* 需要擦除 */
        {
            W25QXX_Erase_Sector(secpos);                           /* 擦掉这个扇区 */
            for (i = 0; i < secremain; i++)                        /* 把新数据合并进缓冲 */
            {
                W25QXX_BUF[i + secoff] = pBuffer[i];
            }
            W25QXX_Write_NoCheck(W25QXX_BUF, secpos * 4096, 4096); /* 整扇区回写 */
        }
        else
            W25QXX_Write_NoCheck(pBuffer, WriteAddr, secremain);   /* 已擦除，直接写 */

        if (NumByteToWrite == secremain)
            break;                                                 /* 写入结束 */
        else                                                       /* 没写完，跨扇区 */
        {
            secpos++;                                              /* 扇区号 +1 */
            secoff = 0;                                            /* 偏移归零 */

            pBuffer        += secremain;                           /* 指针偏移 */
            WriteAddr      += secremain;                           /* 写地址偏移 */
            NumByteToWrite -= secremain;                           /* 剩余字节数递减 */
            if (NumByteToWrite > 4096)
                secremain = 4096;                                  /* 下一个扇区仍写不完 */
            else
                secremain = NumByteToWrite;                        /* 下一个扇区可以写完 */
        }
    };
}

const u8 TEXT_Buffer[] = {"WIZnet W55MH32 SPI W25Q64 TEST"};
#define SIZE sizeof(TEXT_Buffer)

/* 测试地址：W25Q64 最后一个 4K 扇区（8M - 4K = 0x7FF000） */
#define TEST_ADDR   (W25Q64_SIZE - W25QXX_SECTOR_SIZE)
#define TEST_SECTOR (TEST_ADDR / W25QXX_SECTOR_SIZE)

int main(void)
{
    W25QXX_Init();

    /* 读芯片 ID，确认 W25Q64 已连接 */
    while ((id = W25QXX_ReadID()) != W25Q64)
    {
        printf("W25Q64 Check Failed!\n");
        printf("Read ID: 0x%04X\n", (unsigned int)id);
        delay_ms(1000);
    }
    printf("W25Q64 Ready! ID: 0x%04X\n", (unsigned int)id);

    while (1)
    {
        round++;
        printf("\n---------- Round %u ----------\n", (unsigned int)round);

        /* [1] 擦除测试扇区，并逐页校验是否全为 0xFF */
        printf("[1] Erase sector %u (0x%06lX) ... ", (unsigned int)TEST_SECTOR, (unsigned long)TEST_ADDR);
        W25QXX_Erase_Sector(TEST_SECTOR);
        printf("Done\n");
        /* ... 擦除校验循环见步骤3 ... */

        /* [2] 写入测试字符串 */
        printf("[2] Write %u bytes ... ", (unsigned int)SIZE);
        W25QXX_Write((u8 *)TEXT_Buffer, TEST_ADDR, SIZE);
        printf("Done\n");

        /* [3] 读回数据 */
        printf("[3] Read %u bytes ... ", (unsigned int)SIZE);
        W25QXX_Read(datatemp, TEST_ADDR, SIZE);
        printf("Done\n");
        printf("    Data: %s\n", (char *)datatemp);

        /* [4] 逐字节比对 */
        errCnt = 0;
        for (i = 0; i < SIZE; i++)
        {
            if (datatemp[i] != TEXT_Buffer[i]) errCnt++;
        }
        printf("[4] Compare: %s\n", (errCnt == 0) ? "PASS" : "FAIL");

        delay_ms(3000);
    }
}

如果你想自定义

• 改写入内容 → 修改 TEXT_Buffer。SIZE 是 sizeof，会连结尾的 '\0' 一起写入，这样读回来能直接用 %s 打印
• 写入超过 256 字节 → W25QXX_Write() 会自动分页、跨扇区，直接传长数据即可；底层 W25QXX_Write_NoCheck() 负责按 256 字节切页
• 省 RAM → 驱动里 W25QXX_BUFFER[4096] 是跨扇区回写用的扇区缓冲，若只用 W25QXX_Write_NoCheck() 且保证目标区已擦除，可省掉它

int fputc(int c, FILE *f)
{
    if (c == '\n')
        SER_PutChar('\r');         // 补回车，确保串口工具正确换行
    return (SER_PutChar(c));
}

int SER_PutChar(int ch)
{
    while (!USART_GetFlagStatus(USART_TEST, USART_FLAG_TC));
    USART_SendData(USART_TEST, (uint8_t)ch);
    return ch;
}