STM32驱动W25X64存储器

发布时间：2025-05-19 09:30

购买可擦除的USB驱动器存储敏感数据。 #生活技巧# #紧急应对技巧# #个人隐私保护#

W25X64 是华邦公司推出的大容量

SPI FLASH 产品，W25X64 的容量为 64Mbit(8M)，该系列还有 W25Q80/16/32 等。W25X16,W25X32,W25X64分别有8192,16384,32768个可编程页,每页256字节,用扇区擦除指令每次可以擦除16页,用块擦除指令每次可以擦除256页,用整片擦除指令既可以擦除整个芯片,W25X16,W25X32,W25X64分别有512,1024,2048个可擦除扇区,或者32,64,128个可擦除的块

W25Q64 的擦写周期多达 10W 次，具有 20 年的数据保存期限，支持电压为 2.7~3.6V，
W25Q64 支持标准的 SPI，还支持双输出/四输出的 SPI，最大 SPI 时钟可以到 80Mhz（双输出
时相当于 160Mhz，四输出时相当于 320M）

引脚一般如下

其中CS DO SIO VCC GND都是SPI通讯引脚

HOLD是防误操作引脚,该脚为低时,忽略一切外部指令

wp为保护引脚,该脚为低,数据无法擦除修改

对W25X64的写入读出都伴随着指令,指令集如下

有一个很重要的寄存器是状态寄存器,在对flash写入的时候一定要对状态寄存器查看一下

busy:只读,当flash内部正在进行操作的时候,这一位自动变为1,当该位为1的时候,除了读状态指令,不响应任何指令

wel:写保护位,只读,当芯片处于写保护状态的时候,该位为0,所以当要对芯片进行操作的时候一定要查看这一位,否则无法写入,该位在掉电后,写禁能,页编程,扇区擦除,芯片擦除以及写状态寄存器特定值之后会变为0,执行写使能命令之后会变成1

其他状态寄存器

另外,芯片初始化自检的时候需要读取ID,用于设备识别,id寄存器如下

代码如下

#ifndef __FLASH_H

#define __FLASH_H

#include "spi.h"

#include "delay.h"

#include "ioremap.h"

#define W25Q800XEF13

#define W25Q160XEF14

#define W25Q320XEF15

#define W25Q640XEF16

extern u16 SPI_FLASH_TYPE;

#defineSPI_FLASH_CS PBout(12)

#define W25X_WriteEnable0x06

#define W25X_WriteDisable0x04

#define W25X_ReadStatusReg0x05

#define W25X_WriteStatusReg0x01

#define W25X_ReadData0x03

#define W25X_FastReadData0x0B

#define W25X_FastReadDual0x3B

#define W25X_PageProgram0x02

#define W25X_BlockErase0xD8

#define W25X_SectorErase0x20

#define W25X_ChipErase0xC7

#define W25X_PowerDown0xB9

#define W25X_ReleasePowerDown 0xAB

#define W25X_DeviceID0xAB

#define W25X_ManufactDeviceID 0x90

#define W25X_JedecDeviceID0x9F

void SpiFlashInit(void);

u16 SpiFlashReadID(void);

u8 SpiFlashReadSR(void);

void SpiFlashWriteSR(u8 sr);

void SpiFlashWriteEnable(void);

void SpiFlashWriteDisable(void);

void SpiFlashWriteNoCheck(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite);

void SpiFlashRead(u8* pBuffer,u32 ReadAddr,u16 NumByteToRead);

void SpiFlashWrite(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite);

void SpiFlashEraseChip(void);

void SpiFlashEraseSector(u32 Dst_Addr);

void SpiFlashWaitBusy(void);

void SpiFlashPowerDown(void);

void SpiFlashWakeUp(void);

u8 SpiFlashCheck(void);

#endif

#include "flash.h"

u16 SPI_FLASH_TYPE=W25Q64;

void SpiFlashInit(void)

{

GPIO_InitTypeDef GPIO_InitStructure;

RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB|RCC_APB2Periph_GPIOD|RCC_APB2Periph_GPIOG, ENABLE );

GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12;

GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;

GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

GPIO_Init(GPIOB, &GPIO_InitStructure);

GPIO_SetBits(GPIOB,GPIO_Pin_12);

GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;

GPIO_Init(GPIOD, &GPIO_InitStructure);

GPIO_SetBits(GPIOD,GPIO_Pin_2);

GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7;

GPIO_Init(GPIOG, &GPIO_InitStructure);

GPIO_SetBits(GPIOG,GPIO_Pin_7);

Spi2Init();

Spi2SetSpeed(SPI_BaudRatePrescaler_2);

SPI_FLASH_TYPE=SpiFlashReadID();

}

u8 SpiFlashReadSR(void)

{

u8 byte=0;

SPI_FLASH_CS=0;

Spi2ReadWriteByte(W25X_ReadStatusReg);

byte=Spi2ReadWriteByte(0Xff);

SPI_FLASH_CS=1;

return byte;

}

void SpiFlashWriteSR(u8 sr)

{

SPI_FLASH_CS=0;

Spi2ReadWriteByte(W25X_WriteStatusReg);

Spi2ReadWriteByte(sr);

SPI_FLASH_CS=1;

}

void SpiFlashWriteEnable(void)

{

SPI_FLASH_CS=0;

Spi2ReadWriteByte(W25X_WriteEnable);

SPI_FLASH_CS=1;

}

void SpiFlashWriteDisable(void)

{

SPI_FLASH_CS=0;

Spi2ReadWriteByte(W25X_WriteDisable);

SPI_FLASH_CS=1;

}

u16 SpiFlashReadID(void)

{

u16 Temp = 0;

SPI_FLASH_CS=0;

Spi2ReadWriteByte(0x90);

Spi2ReadWriteByte(0x00);

Temp|=Spi2ReadWriteByte(0xFF)<<8;

Temp|=Spi2ReadWriteByte(0xFF);

SPI_FLASH_CS=1;

return Temp;

}

u8 SpiFlashCheck(void)

{

u16 flashId = 0;

flashId = SpiFlashReadID();

if(flashId == W25Q64)

return 0;

else

return 1;

}

void SpiFlashRead(u8* pBuffer,u32 ReadAddr,u16 NumByteToRead)

{

u16 i;

SPI_FLASH_CS=0;

Spi2ReadWriteByte(W25X_ReadData);

Spi2ReadWriteByte((u8)((ReadAddr)>>16));

Spi2ReadWriteByte((u8)((ReadAddr)>>8));

Spi2ReadWriteByte((u8)ReadAddr);

for(i=0;i<NumByteToRead;i++)

{

pBuffer[i]=Spi2ReadWriteByte(0XFF);

}

SPI_FLASH_CS=1;

}

void SPIFlashWritePage(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)

{

u16 i;

SpiFlashWriteEnable();

SPI_FLASH_CS=0;

Spi2ReadWriteByte(W25X_PageProgram);

Spi2ReadWriteByte((u8)((WriteAddr)>>16));

Spi2ReadWriteByte((u8)((WriteAddr)>>8));

Spi2ReadWriteByte((u8)WriteAddr);

for(i=0;i<NumByteToWrite;i++)Spi2ReadWriteByte(pBuffer[i]);

SPI_FLASH_CS=1;

SpiFlashWaitBusy();

}

void SpiFlashWriteNoCheck(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)

{

u16 pageremain;

pageremain=256-WriteAddr%256;

if(NumByteToWrite<=pageremain)pageremain=NumByteToWrite;

while(1)

{

SPIFlashWritePage(pBuffer,WriteAddr,pageremain);

if(NumByteToWrite==pageremain)break;

else

{

pBuffer+=pageremain;

WriteAddr+=pageremain;

NumByteToWrite-=pageremain;

if(NumByteToWrite>256)pageremain=256;

else pageremain=NumByteToWrite;

}

};

}

u8 SPI_FLASH_BUF[4096];

void SpiFlashWrite(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)

{

u32 secpos;

u16 secoff;

u16 secremain;

u16 i;

secpos=WriteAddr/4096;

secoff=WriteAddr%4096;

secremain=4096-secoff;

if(NumByteToWrite<=secremain)secremain=NumByteToWrite;

while(1)

{

SpiFlashRead(SPI_FLASH_BUF,secpos*4096,4096);

for(i=0;i<secremain;i++)

{

if(SPI_FLASH_BUF[secoff+i]!=0XFF)break;

}

if(i<secremain)

{

SpiFlashEraseSector(secpos);

for(i=0;i<secremain;i++)

{

SPI_FLASH_BUF[i+secoff]=pBuffer[i];

}

SpiFlashWriteNoCheck(SPI_FLASH_BUF,secpos*4096,4096);

}else SpiFlashWriteNoCheck(pBuffer,WriteAddr,secremain);

if(NumByteToWrite==secremain)break;

else

{

secpos++;

secoff=0;

pBuffer+=secremain;

WriteAddr+=secremain;

NumByteToWrite-=secremain;

if(NumByteToWrite>4096)secremain=4096;

else secremain=NumByteToWrite;

}

};

}

void SpiFlashEraseChip(void)

{

SpiFlashWriteEnable();

SpiFlashWaitBusy();

SPI_FLASH_CS=0;

Spi2ReadWriteByte(W25X_ChipErase);

SPI_FLASH_CS=1;

SpiFlashWaitBusy();

}

void SpiFlashEraseSector(u32 Dst_Addr)

{

Dst_Addr*=4096;

SpiFlashWriteEnable();

SpiFlashWaitBusy();

SPI_FLASH_CS=0;

Spi2ReadWriteByte(W25X_SectorErase);

Spi2ReadWriteByte((u8)((Dst_Addr)>>16));

Spi2ReadWriteByte((u8)((Dst_Addr)>>8));

Spi2ReadWriteByte((u8)Dst_Addr);

SPI_FLASH_CS=1;

SpiFlashWaitBusy();

}

void SpiFlashWaitBusy(void)

{

while ((SpiFlashReadSR()&0x01)==0x01);

}

void SpiFlashPowerDown(void)

{

SPI_FLASH_CS=0;

Spi2ReadWriteByte(W25X_PowerDown);

SPI_FLASH_CS=1;

DelayMs(3);

}

void SpiFlashWakeUp(void)

{

SPI_FLASH_CS=0;

Spi2ReadWriteByte(W25X_ReleasePowerDown);

SPI_FLASH_CS=1;

DelayMs(3);

}

SPI偽字节在一般意义上就是指发送0XFF,是为了给设备提供处理时钟.

网址：STM32驱动W25X64存储器 https://www.yuejiaxmz.com/news/view/998286

⬅️上一篇：泰山区：“智汇+智惠”双轮驱动，

➡️下一篇：java中x^=y^=x^=y交

STM32驱动W25X64存储器

相关内容

随便看看

最新动态分享

热点动态分享

专题

推荐动态分享