W25Q128是华邦一款容量为128M-bit(16M-byte)的串行NOR Flash储存器。华邦W25Q128 (128M-bit)，被组织为65536个可编程的页，每页256bytes。擦除方式分为16页一组（即一个扇区4kbytes），128页一组（即8个扇区32kbytes），256页一组（即16个扇区或1个块64kbytes），或整个芯片擦除。该芯片有4096个可擦除扇区，或256个可擦除块。该芯片支持标准 standard spi,Dual/Quad I/O SPI，高支持的时钟频率为133MHz，在Quad-SPI模式下的连续传输速度可达532MBit/s(66MByte/s)。支持xIP片上执行技术，被广泛用于微控制器的外扩Flash。

 

        编程即写数据，由于Flash的特性，只能从1编程0，所以写数据之前Flash里面的数据不是0xFF就必须先擦除，然后才能写数据。擦除即将Flash里面的数据恢复为0xFF的过程。

        上电后设备自动处于写禁用状态（Write Enable Latch, WEL为0，WEL是只读位）。在Page Program, Sector Erase, Block Erase, Chip Erase or Write Status Register instruction（页编程、区擦除、块擦除、芯片擦除或者写状态寄存器指令）之前必须先进行写使能指令。在编程、擦除、写状态寄存器指令完成后，WEL自动变成0。

W25Q128内部寻址范围

79f9844da5fa4ae19dd40f4f23f64cd2.png

 芯片引脚封装图

136360998cba4c93962f75775d1578aa.png

        后面则需要根据W25Q128手册给的时序图进行编写程序，达到可以进行数据传输的效果。数据手册上有各种各样的指令

Read Data (03h)

ebdfa2cfb6c34055bcb5d063841eb4c8.pngWrite Status Register-1 (01h), Status Register-2 (31h) & Status Register-3 (11h) 3c39b63800fb4329895fd69447ea630d.png

手册里面还有很多，如果需要则自己去详细的读取，下面进行CubeMX的配置

首先配置时钟

26e7bfc5635a4981a146f2141b5e5ce7.png

在配置端口 

6a4727876adc403bb9df284c2005fced.png

 4f95d47815ff4c4c9ab6b5a3a9460cab.png

99b0857657eb4c0c922d1fd085b46e12.png 

5e967f9175a947cdbbaa6d4c405b987c.png 

 我这里采用的是PB12、PB13、PB14、PB15做SPI的四脚控制，然后进行主程序的操修改。 

1a1e978449e443729f8ac1331bc378b6.png

这些都是系统自动生成的，只需要看一下就行了，开始写模块化程序，然后往文件中加入头文件。

w25qxx.c

#include "w25qxx.h"
#include "main.h"
uint16_t W25QXX_TYPE=W25Q128;//默认是W25Q128
//4Kbytes为一个Sector
//16个扇区为1个Block
//W25Q128
//容量为16M字节,共有128个Block,4096个Sector
//SPI2总线读写一个字节
//参数是写入的字节，返回值是读出的字节
uint8_t SPI2_ReadWriteByte(uint8_t TxData)
{
    uint8_t Rxdata;//定义一个变量Rxdata
     HAL_SPI_TransmitReceive(&hspi2,&TxData,&Rxdata,1,1000);//调用固件库函数收发数据
    return Rxdata;//返回收到的数据
}
void W25QXX_CS(uint8_t a)//软件控制函数（0为低电平，其他值为高电平）
{
    if(a==0)HAL_GPIO_WritePin(W25Q128_CS_GPIO_Port, W25Q128_CS_Pin, GPIO_PIN_RESET);
    else  HAL_GPIO_WritePin(W25Q128_CS_GPIO_Port,  W25Q128_CS_Pin, GPIO_PIN_SET);
}
//初始化SPI FLASH的IO口
uint8_t W25QXX_Init(void)
{
    uint8_t temp;//定义一个变量temp
    W25QXX_CS(1);//0片选开启，1片选关闭
    W25QXX_TYPE = W25QXX_ReadID();//读取FLASH  ID.
    if(W25QXX_TYPE == W25Q256)//SPI FLASH为W25Q256时才用设置为4字节地址模式
    {
       temp = W25QXX_ReadSR(3);//读取状态寄存器3，判断地址模式
       if((temp&0x01)==0)//如果不是4字节地址模式,则进入4字节地址模式
       {
           W25QXX_CS(0);//0片选开启，1片选关闭
           SPI2_ReadWriteByte(W25X_Enable4ByteAddr);//发送进入4字节地址模式指令
           W25QXX_CS(1);//0片选开启，1片选关闭
       }
    }
    if(W25QXX_TYPE==W25Q256||W25QXX_TYPE==W25Q128||W25QXX_TYPE==W25Q64
    ||W25QXX_TYPE==W25Q32||W25QXX_TYPE==W25Q16||W25QXX_TYPE==W25Q80)
    return 0; else return 1;//如果读出ID是现有型号列表中的一个，则识别芯片成功！
}
//读取W25QXX的状态寄存器，W25QXX一共有3个状态寄存器
//状态寄存器1：
//BIT7  6   5   4   3   2   1   0
//SPR   RV  TB BP2 BP1 BP0 WEL BUSY
//SPR:默认0,状态寄存器保护位,配合WP使用
//TB,BP2,BP1,BP0:FLASH区域写保护设置
//WEL:写使能锁定
//BUSY:忙标记位(1,忙;0,空闲)
//默认:0x00
//状态寄存器2：
//BIT7  6   5   4   3   2   1   0
//SUS   CMP LB3 LB2 LB1 (R) QE  SRP1
//状态寄存器3：
//BIT7      6    5    4   3   2   1   0
//HOLD/RST  DRV1 DRV0 (R) (R) WPS (R) (R)
//regno:状态寄存器号，范:1~3
//返回值:状态寄存器值
uint8_t W25QXX_ReadSR(uint8_t regno)
{
    uint8_t byte=0,command=0;
    switch(regno)
    {
        case 1:
            command=W25X_ReadStatusReg1;//读状态寄存器1指令
            break;
        case 2:
            command=W25X_ReadStatusReg2;//读状态寄存器2指令
            break;
        case 3:
            command=W25X_ReadStatusReg3;//读状态寄存器3指令
            break;
        default:
            command=W25X_ReadStatusReg1;//读状态寄存器1指令
            break;
    }
    W25QXX_CS(0);//0片选开启，1片选关闭
    SPI2_ReadWriteByte(command);//发送读取状态寄存器命令
    byte=SPI2_ReadWriteByte(0Xff);//读取一个字节
    W25QXX_CS(1);//0片选开启，1片选关闭
    return byte;//返回变量byte
}
//写W25QXX状态寄存器
void W25QXX_Write_SR(uint8_t regno,uint8_t  sr)
{
    uint8_t command=0;
    switch(regno)
    {
        case 1:
            command=W25X_WriteStatusReg1;//写状态寄存器1指令
            break;
        case 2:
            command=W25X_WriteStatusReg2;//写状态寄存器2指令
            break;
        case 3:
            command=W25X_WriteStatusReg3;//写状态寄存器3指令
            break;
        default:
            command=W25X_WriteStatusReg1;
            break;
    }
    W25QXX_CS(0);//0片选开启，1片选关闭
    SPI2_ReadWriteByte(command);//发送写取状态寄存器命令
    SPI2_ReadWriteByte(sr);//写入一个字节
    W25QXX_CS(1);//0片选开启，1片选关闭
}
//W25QXX写使能
//将WEL置位
void W25QXX_Write_Enable(void)
{
    W25QXX_CS(0);//0片选开启，1片选关闭
    SPI2_ReadWriteByte(W25X_WriteEnable);//发送写使能
    W25QXX_CS(1);//0片选开启，1片选关闭
}
//W25QXX写禁止
//将WEL清零
void W25QXX_Write_Disable(void)
{
    W25QXX_CS(0);//0片选开启，1片选关闭
    SPI2_ReadWriteByte(W25X_WriteDisable);//发送写禁止指令
    W25QXX_CS(1);//0片选开启，1片选关闭
}
//读取芯片ID
//高8位是厂商代号（本程序不判断厂商代号）
//低8位是容量大小
//0XEF13型号为W25Q80
//0XEF14型号为W25Q16
//0XEF15型号为W25Q32
//0XEF16型号为W25Q64
//0XEF17型号为W25Q128（目前洋桃2号开发板使用128容量芯片）
//0XEF18型号为W25Q256
uint16_t W25QXX_ReadID(void)
{
    uint16_t Temp = 0;
    W25QXX_CS(0);//0片选开启，1片选关闭
    SPI2_ReadWriteByte(0x90);//发送读取ID命令
    SPI2_ReadWriteByte(0x00);
    SPI2_ReadWriteByte(0x00);
    SPI2_ReadWriteByte(0x00);
    Temp|=SPI2_ReadWriteByte(0xFF)<<8;
    Temp|=SPI2_ReadWriteByte(0xFF);
    W25QXX_CS(1);//0片选开启，1片选关闭
    return Temp;
}
//读取SPI FLASH
//在指定地址开始读取指定长度的数据
//pBuffer:数据存储区
//ReadAddr:开始读取的地址(24bit)
//NumByteToRead:要读取的字节数(最大65535)
void W25QXX_Read(uint8_t* pBuffer,uint32_t  ReadAddr,uint16_t NumByteToRead)
{
    uint16_t i;
    W25QXX_CS(0);//0片选开启，1片选关闭
    SPI2_ReadWriteByte(W25X_ReadData);//发送读取命令
    if(W25QXX_TYPE==W25Q256)//如果是W25Q256的话地址为4字节的，要发送最高8位
    {
         SPI2_ReadWriteByte((uint8_t)((ReadAddr)>>24));
    }
     SPI2_ReadWriteByte((uint8_t)((ReadAddr)>>16));//发送24bit地址
     SPI2_ReadWriteByte((uint8_t)((ReadAddr)>>8));
    SPI2_ReadWriteByte((uint8_t)ReadAddr);
    for(i=0;i<NumByteToRead;i++)
    {
         pBuffer[i]=SPI2_ReadWriteByte(0XFF);//循环读数
    }
    W25QXX_CS(1);//0片选开启，1片选关闭
}
//SPI在一页(0~65535)内写入少于256个字节的数据
//在指定地址开始写入最大256字节的数据
//pBuffer:数据存储区
//WriteAddr:开始写入的地址(24bit)
//NumByteToWrite:要写入的字节数(最大256),该数不应该超过该页的剩余字节数!!!
void W25QXX_Write_Page(uint8_t*  pBuffer,uint32_t WriteAddr,uint16_t  NumByteToWrite)
{
    uint16_t i;
    W25QXX_Write_Enable();//SET WEL
    W25QXX_CS(0);//0片选开启，1片选关闭
    SPI2_ReadWriteByte(W25X_PageProgram);//发送写页命令
    if(W25QXX_TYPE==W25Q256)//如果是W25Q256的话地址为4字节的，要发送最高8位
    {
         SPI2_ReadWriteByte((uint8_t)((WriteAddr)>>24));
    }
     SPI2_ReadWriteByte((uint8_t)((WriteAddr)>>16));//发送24bit地址
     SPI2_ReadWriteByte((uint8_t)((WriteAddr)>>8));
    SPI2_ReadWriteByte((uint8_t)WriteAddr);
     for(i=0;i<NumByteToWrite;i++)SPI2_ReadWriteByte(pBuffer[i]);//循环写数
    W25QXX_CS(1);//0片选开启，1片选关闭
    W25QXX_Wait_Busy();//等待写入结束
}
//无检验写SPI FLASH
//必须确保所写的地址范围内的数据全部为0XFF,否则在非0XFF处写入的数据将失败!
//具有自动换页功能
//在指定地址开始写入指定长度的数据,但是要确保地址不越界!
//pBuffer:数据存储区
//WriteAddr:开始写入的地址(24bit)
//NumByteToWrite:要写入的字节数(最大65535)
//CHECK OK
void W25QXX_Write_NoCheck(uint8_t*  pBuffer,uint32_t WriteAddr,uint16_t  NumByteToWrite)
{
    uint16_t pageremain;
    pageremain=256-WriteAddr%256; //单页剩余的字节数
    if(NumByteToWrite<=pageremain)pageremain=NumByteToWrite;//不大于256个字节
    while(1)
    {
       W25QXX_Write_Page(pBuffer,WriteAddr,pageremain);
       if(NumByteToWrite==pageremain)break;//写入结束了
        else //NumByteToWrite>pageremain
       {
           pBuffer+=pageremain;
           WriteAddr+=pageremain;
           NumByteToWrite-=pageremain;            //减去已经写入了的字节数
           if(NumByteToWrite>256)pageremain=256; //一次可以写入256个字节
           else pageremain=NumByteToWrite;     //不够256个字节了
       }
    };
}
//写SPI FLASH
//在指定地址开始写入指定长度的数据
//该函数带擦除操作!
//pBuffer:数据存储区
//WriteAddr:开始写入的地址(24bit)
//NumByteToWrite:要写入的字节数(最大65535)
uint8_t W25QXX_BUFFER[4096];
void W25QXX_Write(uint8_t* pBuffer,uint32_t  WriteAddr,uint16_t NumByteToWrite)
{
    uint32_t secpos;
    uint16_t secoff;
    uint16_t secremain;
    uint16_t i;
    uint8_t* W25QXX_BUF;
    W25QXX_BUF=W25QXX_BUFFER;
    secpos=WriteAddr/4096;//扇区地址
    secoff=WriteAddr%4096;//在扇区内的偏移
    secremain=4096-secoff;//扇区剩余空间大小
    //printf("ad:%X,nb:%X\r\n",WriteAddr,NumByteToWrite);//测试用
    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;//偏移位置为0
           pBuffer+=secremain;  //指针偏移
           WriteAddr+=secremain;//写地址偏移
           NumByteToWrite-=secremain;//字节数递减
           if(NumByteToWrite>4096)secremain=4096;//下一个扇区还是写不完
           else  secremain=NumByteToWrite;//下一个扇区可以写完了
       }
    };
}
//擦除整个芯片
//等待时间超长...
void W25QXX_Erase_Chip(void)
{
    W25QXX_Write_Enable();//SET WEL
    W25QXX_Wait_Busy();//等待忙状态
    W25QXX_CS(0);//0片选开启，1片选关闭
    SPI2_ReadWriteByte(W25X_ChipErase);//发送片擦除命令
    W25QXX_CS(1);//0片选开启，1片选关闭
    W25QXX_Wait_Busy();//等待芯片擦除结束
}
//擦除一个扇区
//Dst_Addr:扇区地址 根据实际容量设置
//擦除一个扇区的最少时间:150ms
void W25QXX_Erase_Sector(uint32_t Dst_Addr)
{
    Dst_Addr*=4096;
    W25QXX_Write_Enable();//SET WEL
    W25QXX_Wait_Busy();
    W25QXX_CS(0);//0片选开启，1片选关闭
    SPI2_ReadWriteByte(W25X_SectorErase);//发送扇区擦除指令
    if(W25QXX_TYPE==W25Q256)//如果是W25Q256的话地址为4字节的，要发送最高8位
    {
         SPI2_ReadWriteByte((uint8_t)((Dst_Addr)>>24));
    }
    SPI2_ReadWriteByte((uint8_t)((Dst_Addr)>>16));//发送24bit地址
    SPI2_ReadWriteByte((uint8_t)((Dst_Addr)>>8));
    SPI2_ReadWriteByte((uint8_t)Dst_Addr);
    W25QXX_CS(1);//0片选开启，1片选关闭
    W25QXX_Wait_Busy();//等待擦除完成
}
//等待空闲
void W25QXX_Wait_Busy(void)
{
    while((W25QXX_ReadSR(1)&0x01)==0x01);//等待BUSY位清空
}
//进入掉电模式
void W25QXX_PowerDown(void)
{
    W25QXX_CS(0);//0片选开启，1片选关闭
    SPI2_ReadWriteByte(W25X_PowerDown);//发送掉电命令 0xB9
    W25QXX_CS(1);//0片选开启，1片选关闭
    delay_us(3);//等待TPD
}
//唤醒
void W25QXX_WAKEUP(void)
{
    W25QXX_CS(0);//0片选开启，1片选关闭
    SPI2_ReadWriteByte(W25X_ReleasePowerDown);//发送电源唤醒指令 0xAB
    W25QXX_CS(1);//0片选开启，1片选关闭
    delay_us(3);//等待TRES1
}

w25q128.h

#ifndef W25Q128_W25QXX_H_
#define W25Q128_W25QXX_H_

#include "stm32f1xx_hal.h" //HAL库文件声明
#include "../delay/delay.h"

//25系列FLASH芯片厂商与容量代号（厂商代号EF）
#define W25Q80    0XEF13
#define W25Q16    0XEF14
#define W25Q32    0XEF15
#define W25Q64    0XEF16
#define W25Q128   0XEF17
#define W25Q256 0XEF18
#define EX_FLASH_ADD 0x000000 //W25Q128的地址是24位宽
extern uint16_t W25QXX_TYPE;//定义W25QXX芯片型号
extern SPI_HandleTypeDef hspi2;
//////////////////////////////////////////////////////////////////////////////////
//指令表
#define W25X_WriteEnable             0x06
#define W25X_WriteDisable            0x04
#define W25X_ReadStatusReg1      0x05
#define W25X_ReadStatusReg2      0x35
#define W25X_ReadStatusReg3      0x15
#define W25X_WriteStatusReg1         0x01
#define W25X_WriteStatusReg2         0x31
#define W25X_WriteStatusReg3     0x11
#define W25X_ReadData             0x03
#define W25X_FastReadData         0x0B
#define W25X_FastReadDual         0x3B
#define W25X_PageProgram          0x02
#define W25X_BlockErase              0xD8
#define W25X_SectorErase          0x20
#define W25X_ChipErase            0xC7
#define W25X_PowerDown            0xB9
#define W25X_ReleasePowerDown    0xAB
#define W25X_DeviceID             0xAB
#define W25X_ManufactDeviceID    0x90
#define W25X_JedecDeviceID           0x9F
#define W25X_Enable4ByteAddr         0xB7
#define W25X_Exit4ByteAddr        0xE9
uint8_t SPI2_ReadWriteByte(uint8_t  TxData);//SPI2总线底层读写
void W25QXX_CS(uint8_t a);//W25QXX片选引脚控制
uint8_t W25QXX_Init(void);//初始化W25QXX函数
uint16_t  W25QXX_ReadID(void);//读取FLASH ID
uint8_t W25QXX_ReadSR(uint8_t regno);//读取状态寄存器
void W25QXX_4ByteAddr_Enable(void);//使能4字节地址模式
void W25QXX_Write_SR(uint8_t regno,uint8_t  sr);//写状态寄存器
void W25QXX_Write_Enable(void);//写使能
void W25QXX_Write_Disable(void);//写保护
void W25QXX_Write_NoCheck(uint8_t*  pBuffer,uint32_t WriteAddr,uint16_t  NumByteToWrite);//无检验写SPI FLASH
void W25QXX_Read(uint8_t* pBuffer,uint32_t  ReadAddr,uint16_t NumByteToRead);//读取flash
void W25QXX_Write(uint8_t* pBuffer,uint32_t  WriteAddr,uint16_t NumByteToWrite);//写入flash
void W25QXX_Erase_Chip(void);//整片擦除
void W25QXX_Erase_Sector(uint32_t  Dst_Addr);//扇区擦除
void W25QXX_Wait_Busy(void);//等待空闲
void W25QXX_PowerDown(void);//进入掉电模式
void W25QXX_WAKEUP(void);//唤醒

#endif /* W25Q128_W25QXX_H_ */

这时你会发现，程序很多，但只需要理解那些是需要用的那些其重点函数。

这里面用到了delay的程序

delay.c

#include "delay.h"

void delay_us(uint32_t us) //利用CPU循环实现的非精准应用的微秒延时函数
{
    uint32_t delay = (HAL_RCC_GetHCLKFreq() / 8000000 * us); //使用HAL_RCC_GetHCLKFreq()函数获取主频值，经算法得到1微秒的循环次数
    while (delay--); //循环delay次，达到1微秒延时
}

delay.h

#ifndef DELAY_DELAY_H_
#define DELAY_DELAY_H_

#include "stm32f1xx_hal.h" //HAL库文件声明
void delay_us(uint32_t us); //C文件中的函数声明

#endif /* DELAY_DELAY_H_ */

而我们在使用这些的时候，则是通过应用程序方面去进行编写的。

eee55b8264584c63b47ff12b8659a802.png

 在main.c下面创一个自定义的uint8_t的自变量数组，数组是需要根据自己的需求来进行使用的。

3ee59b7982db48e1ba9f23cc6c6295d4.png

368663e7de6a40e994241c230ddf9d44.png

ff164a804e0c4af08a79089942a42be0.png

 就这样可以进行操作了。

总结：

        如果想深入理解就去看手册，掌握使用就会用就行。

 

# stm32 # 单片机 # arm
Logo
2048 AI社区

有“AI”的1024 = 2048，欢迎大家加入2048 AI社区

更多推荐

Expect脚本实战：多条件匹配与防卡死技巧

在自动化测试和系统初始化中，我们常常使用 Expect 脚本来完成一系列交互操作，比如自动输入密码、监听输出并作出响应。然而，实际项目中可能遇到多步骤输出匹配的场景：只有在 先匹配到某一行输出，再匹配到另一行输出 时，才需要做出响应。同时，如果 “testX failed” 出现了，但 “set params error” 没有在合理时间内出现，不要卡死，而是打印警告并继续。这个写法的问题在于：如

avatar 2048 AI社区

AI模型版本控制的标签管理：架构师的技巧

在AI模型生命周期中，版本控制是保障模型可追溯性、协作效率与生产可靠性的核心环节。而标签管理作为版本控制的"语义接口"，其设计质量直接决定了团队对模型版本的理解、检索与复用能力。本文从架构师视角出发，结合第一性原理与MLOps实践，系统阐述AI模型标签管理的理论框架、架构设计、实现机制与高级考量。通过拆解标签的"唯一标识+语义描述"本质，提出四维标签模型。

avatar 2048 AI社区

Expect脚本实战：多条件匹配与防卡死技巧

在自动化测试和系统初始化中，我们常常使用 Expect 脚本来完成一系列交互操作，比如自动输入密码、监听输出并作出响应。然而，实际项目中可能遇到多步骤输出匹配的场景：只有在 先匹配到某一行输出，再匹配到另一行输出 时，才需要做出响应。同时，如果 “testX failed” 出现了，但 “set params error” 没有在合理时间内出现，不要卡死，而是打印警告并继续。这个写法的问题在于：如

avatar 2048 AI社区