GD25Qxx--SPI协议

已于 2025-02-07 15:03:27 修改
阅读量1.9k 收藏 19
点赞数 7
分类专栏： 兆易创新 文章标签： c# 开发语言
于 2024-02-19 10:06:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61973119/article/details/136162625
版权

一、GD25Qxx芯片简单介绍

        W25Q128是华邦公司推出的一款SPI接口的NOR Flash芯片，其存储空间为128Mbit，相当于16M字节。W25Q128V芯片是串行闪存，可以通过标准/两线/四线SPI控制。W25Q128一次最多可编程256个字节。页面可以按扇区擦除、块擦除、整个芯片擦除。

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

  • W25Q64存储容量共 ：64M-bit/ 8M-byte
  • W25Q128存储容量共 ：128M-bit / 16M-Byte 
  • 页：256 Bytes
  • 扇区：16 Pages（4KB）
  • 块：16 Sector（64KB）

     二、W25QXX芯片引脚说明

    1. 第1脚CS是SPI总线的片选使能接口，SPI总线支持在一条总线上连接多个芯片，为了区分当前通信的是哪个芯片，就为每个芯片连接一个独立的CS片选接口，单片机想和哪个芯片通信，就向哪个芯片的CS引脚输出低电平。
    2. 第2脚D0是SPI总线的数据输出接口。
    3. 第3脚WP是硬件写保护接口，当向此引脚输入低电平，芯片将禁止写入数据。反之，可正常写入数据。
    4. 第4脚GND是公共地。
    5. 第5脚DI是SPI总线的数据输入接口。
    6. 第6脚CLK是SPI总线的时钟输入接口。
    7. 第7脚HOLD是状态保持接口。当向此引脚输入低电平，芯片将禁止任何操作，当向此引脚输入高电平，可正常操作芯片。
    8. 第8脚VCC是电源供电接口，输入2.7-3.6V的电源。

    三、GD25Qxx指令集

    四、软件SPI代码

    STM32F207，HAL库，时钟极性=0，时钟相位=0

    #include "MySPI.h"                  // Device header

#define MYSPI_CS_PORT GPIOA
#define MYSPI_CS_PIN GPIO_PIN_4
#define MYSPI_SCK_PORT GPIOA
#define MYSPI_SCK_PIN GPIO_PIN_5
#define MYSPI_MISO_PORT GPIOA
#define MYSPI_MISO_PIN GPIO_PIN_6
#define MYSPI_MOSI_PORT GPIOA
#define MYSPI_MOSI_PIN GPIO_PIN_7

/*引脚配置层*/

/**
  * 函    数：SPI写SS引脚电平
  * 参    数：BitValue 协议层传入的当前需要写入SS的电平，范围0~1
  * 返 回 值：无
  * 注意事项：此函数需要用户实现内容，当BitValue为0时，需要置SS为低电平，当BitValue为1时，需要置SS为高电平
  */
void MySPI_W_CS(uint8_t BitValue)
{
	HAL_GPIO_WritePin(MYSPI_CS_PORT, MYSPI_CS_PIN, (GPIO_PinState)BitValue);		//根据BitValue，设置SS引脚的电平
}

/**
  * 函    数：SPI写SCK引脚电平
  * 参    数：BitValue 协议层传入的当前需要写入SCK的电平，范围0~1
  * 返 回 值：无
  * 注意事项：此函数需要用户实现内容，当BitValue为0时，需要置SCK为低电平，当BitValue为1时，需要置SCK为高电平
  */
void MySPI_W_SCK(uint8_t BitValue)
{
	HAL_GPIO_WritePin(MYSPI_SCK_PORT, MYSPI_SCK_PIN, (GPIO_PinState)BitValue);		//根据BitValue，设置SCK引脚的电平
}


/**
  * 函    数：SPI写MOSI引脚电平
  * 参    数：BitValue 协议层传入的当前需要写入MOSI的电平，范围0~1
  * 返 回 值：无
  * 注意事项：此函数需要用户实现内容，当BitValue为0时，需要置MOSI为低电平，当BitValue为1时，需要置MOSI为高电平
  */
void MySPI_W_MOSI(uint8_t BitValue)
{
	HAL_GPIO_WritePin(MYSPI_MOSI_PORT, MYSPI_MOSI_PIN, (GPIO_PinState)BitValue);		//根据BitValue，设置MOSI引脚的电平，BitValue要实现非0即1的特性
}

/**
  * 函    数：I2C读MISO引脚电平
  * 参    数：无
  * 返 回 值：协议层需要得到的当前MISO的电平，范围0~1
  * 注意事项：此函数需要用户实现内容，当前MISO为低电平时，返回0，当前MISO为高电平时，返回1
  */
uint8_t MySPI_R_MISO(void)
{
	return HAL_GPIO_ReadPin(MYSPI_MISO_PORT, MYSPI_MISO_PIN);			//读取MISO电平并返回
}

/**
  * 函    数：SPI初始化
  * 参    数：无
  * 返 回 值：无
  * 注意事项：此函数需要用户实现内容，实现SS、SCK、MOSI和MISO引脚的初始化
  */
void MySPI_Init(void)
{
	/*开启时钟*/
	__HAL_RCC_GPIOA_CLK_ENABLE();	//开启GPIOA的时钟
	
	/*GPIO初始化*/
	GPIO_InitTypeDef GPIO_InitStructure;
	GPIO_InitStructure.Mode = GPIO_MODE_OUTPUT_PP;
	GPIO_InitStructure.Pin = MYSPI_MOSI_PIN;
	GPIO_InitStructure.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
	HAL_GPIO_Init(MYSPI_MOSI_PORT, &GPIO_InitStructure);		
	
	GPIO_InitStructure.Pin = MYSPI_CS_PIN;
	HAL_GPIO_Init(MYSPI_CS_PORT, &GPIO_InitStructure);
	
	GPIO_InitStructure.Pin = MYSPI_SCK_PIN;
	HAL_GPIO_Init(MYSPI_SCK_PORT, &GPIO_InitStructure);
	
	GPIO_InitStructure.Mode = GPIO_MODE_INPUT;
	GPIO_InitStructure.Pin = MYSPI_MISO_PIN;
	HAL_GPIO_Init(MYSPI_MISO_PORT, &GPIO_InitStructure);					//将PA6引脚初始化为上拉输入
	
	/*设置默认电平*/
	MySPI_W_CS(1);											//SS默认高电平
	MySPI_W_SCK(0);											//SCK默认低电平
}

/*协议层*/

/**
  * 函    数：SPI交换传输一个字节，使用SPI模式0,上升沿发送数据，下降沿读取数据
  * 参    数：ByteSend 要发送的一个字节
  * 返 回 值：接收的一个字节
  */
uint8_t MySPI_SwapByte(uint8_t ByteSend)
{
	uint8_t i, ByteReceive = 0x00;					//定义接收的数据，并赋初值0x00，此处必须赋初值0x00，后面会用到
	
	for (i = 0; i < 8; i ++)						//循环8次，依次交换每一位数据
	{
		/*两个!可以对数据进行两次逻辑取反，作用是把非0值统一转换为1，即：!!(0) = 0，!!(非0) = 1*/
		MySPI_W_MOSI(!!(ByteSend & (0x80 >> i)));	//使用掩码的方式取出ByteSend的指定一位数据并写入到MOSI线
		MySPI_W_SCK(1);								//拉高SCK，上升沿移出数据
		if (MySPI_R_MISO()){ByteReceive |= (0x80 >> i);}	//读取MISO数据，并存储到Byte变量
															//当MISO为1时，置变量指定位为1，当MISO为0时，不做处理，指定位为默认的初值0
		MySPI_W_SCK(0);								//拉低SCK，下降沿移入数据
	}
	
	return ByteReceive;								//返回接收到的一个字节数据
}

    #ifndef __MYSPI_H
#define __MYSPI_H
#include "head.h"

void MySPI_Init(void);
void MySPI_W_CS(uint8_t BitValue);
uint8_t MySPI_SwapByte(uint8_t ByteSend);

#endif

    五、GD25Q128驱动代码

    #include "gd25q128.h"

uint16_t GD25Q128_TYPE = 0;
uint32_t GD25Q128_SIZE = 0;
uint8_t  GD25Q128_UID[8];


//SPI读写一个字节
//TxData:要写入的字节
//返回值:读取到的字节
static uint8_t GD25Q128_SPI_ReadWriteByte(uint8_t TxData)
{
	uint8_t RxData = 0X00;
	RxData = MySPI_SwapByte(TxData);
	return RxData;
}

//4Kbytes为一个Sector
//16个扇区为1个Block
//W25Q128
//容量为16M字节,共有128个Block,4096个Sector

//初始化SPI FLASH的IO口
int GD25Q128_Init(void)
{
	MySPI_Init();
	HAL_GPIO_WritePin(GPIOC, GPIO_PIN_4, GPIO_PIN_SET);//将HOLD置高，操作eeprom
    GD25Q128_CS_L(); /* 拉低选中 */
    GD25Q128_SPI_ReadWriteByte(0XFF);
    GD25Q128_CS_H(); /* 拉高取消 */
    GD25Q128_TYPE = GD25Q128_ReadID();          // 读取FLASH ID.
	LOG("GD25Q128_TYPE :%d\r\n",GD25Q128_TYPE);
	if(GD25Q128_TYPE == GD25Q128)
	{
		return -1;
	}
	return 0;
}

//读取GD25Q128的状态寄存器
//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
uint8_t GD25Q128_ReadSR(void)
{
    uint8_t byte = 0;
    GD25Q128_CS_L(); //使能器件
    GD25Q128_SPI_ReadWriteByte(GD25X_ReadStatusReg); //发送读取状态寄存器命令
    byte = GD25Q128_SPI_ReadWriteByte(0Xff);          //读取一个字节
    GD25Q128_CS_H();  //取消片选
    return byte;
}

//写GD25Q128状态寄存器
//只有SPR,TB,BP2,BP1,BP0(bit 7,5,4,3,2)可以写!!!
void GD25Q128_Write_SR(uint8_t sr)
{
    GD25Q128_CS_L(); //使能器件
    GD25Q128_SPI_ReadWriteByte(GD25X_WriteStatusReg);                 //发送写取状态寄存器命令
    GD25Q128_SPI_ReadWriteByte(sr);               	//写入一个字节
    GD25Q128_CS_H();  //取消片选
}

//GD25Q128写使能
//将WEL置位
void GD25Q128_Write_Enable(void)
{
    GD25Q128_CS_L(); //使能器件
    GD25Q128_SPI_ReadWriteByte(GD25X_WriteEnable); 	//发送写使能
    GD25Q128_CS_H();  //取消片选
}

//GD25Q128写禁止
//将WEL清零
void GD25Q128_Write_Disable(void)
{
    GD25Q128_CS_L(); //使能器件
    GD25Q128_SPI_ReadWriteByte(GD25X_WriteDisable);  //发送写禁止指令
    GD25Q128_CS_H();  //取消片选
}

//读取芯片ID
//返回值如下:
//0XC817,表示芯片型号为GD25Q128
uint16_t GD25Q128_ReadID(void)
{
    uint16_t Temp = 0;
    GD25Q128_CS_L();
    GD25Q128_SPI_ReadWriteByte(0x90);                            //发送读取ID命令
    GD25Q128_SPI_ReadWriteByte(0x00);
    GD25Q128_SPI_ReadWriteByte(0x00);
    GD25Q128_SPI_ReadWriteByte(0x00);
    Temp |= GD25Q128_SPI_ReadWriteByte(0xFF) << 8;
    Temp |= GD25Q128_SPI_ReadWriteByte(0xFF);
    GD25Q128_CS_H();
    return Temp;
}

//读取SPI FLASH
//在指定地址开始读取指定长度的数据
//pBuffer:数据存储区
//ReadAddr:开始读取的地址(24bit)
//NumByteToRead:要读取的字节数(最大65535)
void GD25Q128_Read(uint8_t *pBuffer, uint32_t ReadAddr, uint16_t NumByteToRead)
{
    uint16_t i;
    GD25Q128_CS_L(); //使能器件
    GD25Q128_SPI_ReadWriteByte(GD25X_ReadData);         	//发送读取命令
    GD25Q128_SPI_ReadWriteByte((uint8_t)((ReadAddr) >> 16));  	//发送24bit地址
    GD25Q128_SPI_ReadWriteByte((uint8_t)((ReadAddr) >> 8));
    GD25Q128_SPI_ReadWriteByte((uint8_t)ReadAddr);
    for (i = 0; i < NumByteToRead; i++)
    {
        pBuffer[i] = GD25Q128_SPI_ReadWriteByte(0XFF);   	//循环读数
    }
    GD25Q128_CS_H();
}
//SPI在一页(0~65535)内写入少于256个字节的数据
//在指定地址开始写入最大256字节的数据
//pBuffer:数据存储区
//WriteAddr:开始写入的地址(24bit)
//NumByteToWrite:要写入的字节数(最大256),该数不应该超过该页的剩余字节数!!!
void GD25Q128_Write_Page(uint8_t *pBuffer, uint32_t WriteAddr, uint16_t NumByteToWrite)
{
    uint16_t i;
    GD25Q128_Write_Enable();                  	//SET WEL
    GD25Q128_CS_L(); //使能器件
    GD25Q128_SPI_ReadWriteByte(GD25X_PageProgram);      	//发送写页命令
    GD25Q128_SPI_ReadWriteByte((uint8_t)((WriteAddr) >> 16)); 	//发送24bit地址
    GD25Q128_SPI_ReadWriteByte((uint8_t)((WriteAddr) >> 8));
    GD25Q128_SPI_ReadWriteByte((uint8_t)WriteAddr);
    for (i = 0; i < NumByteToWrite; i++)
        GD25Q128_SPI_ReadWriteByte(pBuffer[i]); //循环写数
    GD25Q128_CS_H();  //取消片选
    GD25Q128_Wait_Busy();					   		//等待写入结束
}
//无检验写SPI FLASH
//必须确保所写的地址范围内的数据全部为0XFF,否则在非0XFF处写入的数据将失败!
//具有自动换页功能
//在指定地址开始写入指定长度的数据,但是要确保地址不越界!
//pBuffer:数据存储区
//WriteAddr:开始写入的地址(24bit)
//NumByteToWrite:要写入的字节数(最大65535)
//CHECK OK
void GD25Q128_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)
    {
        GD25Q128_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 GD25Q128_BUFFER[4096];
void GD25Q128_Write(uint8_t *pBuffer, uint32_t WriteAddr, uint16_t NumByteToWrite)
{
    uint32_t secpos;
    uint16_t secoff;
    uint16_t secremain;
    uint16_t i;
    uint8_t *GD25Q128_BUF;
    GD25Q128_BUF = GD25Q128_BUFFER;
    secpos = WriteAddr / 4096; 	  //扇区地址
    secoff = WriteAddr % 4096; 	  //在扇区内的偏移
    secremain = 4096 - secoff; 	  //扇区剩余空间大小
    if (NumByteToWrite <= secremain)
        secremain = NumByteToWrite; 	  //不大于4096个字节
 while (1)
    {
        GD25Q128_Read(GD25Q128_BUF, secpos * 4096, 4096); 	  //读出整个扇区的内容
        for (i = 0; i < secremain; i++) //校验数据
        {
            if (GD25Q128_BUF[secoff + i] != 0XFF)
                break; //需要擦除
        }
        if (i < secremain) //需要擦除
        {
            GD25Q128_Erase_Sector(secpos);		//擦除这个扇区
            for (i = 0; i < secremain; i++)	   		//复制
            {
                GD25Q128_BUF[i + secoff] = pBuffer[i];
            }
            GD25Q128_Write_NoCheck(GD25Q128_BUF, secpos * 4096, 4096);	   	//写入整个扇区

        }else
            GD25Q128_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 GD25Q128_Erase_Chip(void)
{
    GD25Q128_Write_Enable();                 	 	//SET WEL
    GD25Q128_Wait_Busy();
    GD25Q128_CS_L(); //使能器件
    GD25Q128_SPI_ReadWriteByte(GD25X_ChipErase);        	//发送片擦除命令
    GD25Q128_CS_H();  //取消片选
    GD25Q128_Wait_Busy();   				   		//等待芯片擦除结束
}
//擦除一个扇区
//Dst_Addr:扇区地址 根据实际容量设置
//擦除一个山区的最少时间:150ms
void GD25Q128_Erase_Sector(uint32_t Dst_Addr)
{
    //监视falsh擦除情况,测试用
    Dst_Addr *= 4096;
    GD25Q128_Write_Enable();                  	//SET WEL
    GD25Q128_Wait_Busy();
    GD25Q128_CS_L(); //使能器件
    GD25Q128_SPI_ReadWriteByte(GD25X_SectorErase);      	//发送扇区擦除指令
    GD25Q128_SPI_ReadWriteByte((uint8_t)((Dst_Addr) >> 16));  	//发送24bit地址
    GD25Q128_SPI_ReadWriteByte((uint8_t)((Dst_Addr) >> 8));
    GD25Q128_SPI_ReadWriteByte((uint8_t)Dst_Addr);
    GD25Q128_CS_H();  //取消片选
    GD25Q128_Wait_Busy();   				   		//等待擦除完成
}

//等待空闲
void GD25Q128_Wait_Busy(void)
{
    while ((GD25Q128_ReadSR() & 0x01) == 0x01);  		// 等待BUSY位清空
}

    #ifndef __GD25Q128_H__
#define __GD25Q128_H__

#include "main.h"

//GD25X系列/Q系列芯片列表
#define GD25Q80 	0XC813
#define GD25Q16 	0XC814
#define GD25Q32 	0XC815
#define GD25Q64 	0XC816
#define GD25Q128	0XC817

#define GD25Q128_CS_H()   MySPI_W_CS(1)
#define GD25Q128_CS_L()   MySPI_W_CS(0)

extern uint16_t GD25Q128_TYPE;
extern uint32_t GD25Q128_SIZE;
extern uint8_t  GD25Q128_UID[8];

//指令表
#define GD25X_WriteEnable		0x06
#define GD25X_WriteDisable		0x04
#define GD25X_ReadStatusReg		0x05
#define GD25X_WriteStatusReg	0x01
#define GD25X_ReadData			0x03
#define GD25X_FastReadData		0x0B
#define GD25X_FastReadDual		0x3B
#define GD25X_PageProgram		0x02
#define GD25X_BlockErase		0xD8
#define GD25X_SectorErase		0x20
#define GD25X_ChipErase			0xC7
#define GD25X_PowerDown			0xB9
#define GD25X_ReleasePowerDown	0xAB
#define GD25X_DeviceID			0xAB
#define GD25X_ManufactDeviceID	0x90
#define GD25X_JedecDeviceID		0x9F

int GD25Q128_Init(void);
uint16_t  GD25Q128_ReadID(void);  	    		//读取FLASH ID
uint8_t	 GD25Q128_ReadSR(void);        		//读取状态寄存器
void GD25Q128_Write_SR(uint8_t sr);  			//写状态寄存器
void GD25Q128_Write_Enable(void);  		//写使能
void GD25Q128_Write_Disable(void);		//写保护
void GD25Q128_Write_NoCheck(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite);
void GD25Q128_Read(uint8_t* pBuffer,uint32_t ReadAddr,uint16_t NumByteToRead);   //读取flash
void GD25Q128_Write(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite);//写入flash
void GD25Q128_Erase_Chip(void);    	  	//整片擦除
void GD25Q128_Erase_Sector(uint32_t Dst_Addr);	//扇区擦除
void GD25Q128_Wait_Busy(void);           	//等待空闲
void GD25Q128_Write_Page(uint8_t *pBuffer, uint32_t WriteAddr, uint16_t NumByteToWrite);

#endif

    六、SPI波形

    七、GD25QXX芯片读错误原因

    注意事项：

    • 数据写入的时候只能按照Page来写入，最多一次只能写256个字节，也就是一个页的空间。每次写入都要先擦除。
    • 数据擦除只能按扇区擦除或按块擦除。可以按 16 页一组（4KB 扇区擦除）、128 页一组（32KB 块擦除）、256 页一组（64KB 块擦除）或者整片擦除（chip erase）。
    • GD25Qxx必须去除写保护，才能更改数据，而且每次只要发送命令后再写入数据都必须先去除写保护，否则只有第一次操作被生效**。
    • GD25Qxx写完数据后必须等待BUSY位清空才能写入数据，否则会写入失败

    1. 写内存时需要注意Flash的一个要点，Flash编程只能将1写为0，而不能将0写成1，写1靠擦除。所以需要在写内存的时候将内存擦除，使用内存擦除指令擦除内存（擦除的最小单位是扇区），内存变为0xFF，然后再写内存。先擦除再写
    2. 上电后设备自动处于写禁用状态（Write Enable Latch, WEL为0，WEL是只读位）。在Page Program, Sector Erase, Block Erase, Chip Erase or Write Status Register instruction（页编程、区擦除、块擦除、芯片擦除或者写状态寄存器指令）之前必须先进行写使能指令。在编程、擦除、写状态寄存器指令完成后，WEL自动变成0。
    3. 　W25Q64BV是使用四线SPI兼容总线：串行时钟：（CLK），片选（CS），串行数据输入（DI），串行数据输出（DO）。标准SPI指令是MCU在CLK的上升沿使用DI输入引脚串行写指令，地址，数据到设备。在CLK的下降沿用DO输出引脚从设备读取数据或状态。

    4. W25Q128芯片第一次接收指令集的时候不会做出响应，所以在初始化时向芯片随便发送一个指令集（如0xFF），芯片才能正常响应。（针对部分单片机）

      spi_start();//读取ID前向芯片发送一个FF指令
      spi_swapByte(0xFF);
      spi_stop();
      w25q128_readID(&ID);//正常读取ID

    5. 配置SPI：SPI的工作模式配置为 0，即 CPOL = 0，CPHA = 0
    6. Flash的写的有个特性跟EEPROM一样，就是它的一页是256个Byte，也就是在写入的时候，一次最多可以写入256个字节的数据，超过了需要自行在代码中处理，一次最多编程256字节，写超的话会对当前页的前面数据进行覆盖。不可跨页写
    7. 写入完成之后必须要等待一定的时间，不然马上写入第二次写入会失败W25Q128_Wait_Busy();  //等待写入结束
    8. 芯片可以从当前位置读完整个芯片数据；芯片只能单页写，写之前内容需要被擦除；
    9. 写入数据程序进入硬件中断  可能是堆栈溢出，比如FReeRTOS里面每一个任务分配的空间是128BYTE,定义局部变量超过128BYTE,内存卡死。
    CH32V3xx SPI Flash GD25Q32驱动
    madao1234的博客
    10-07 514
    CH32V3xx MCU SPI Flash GD25Q32EISG 驱动调试记录
    基于STM32L4XX、HAL库的GD25Q128驱动程序设计
    zhusl6688的博客
    03-04 812
    GD25Q128是GigaDevice推出的128Mbit（16MB）串行Flash存储器，采用SPI接口，支持高速读写操作，广泛应用于嵌入式系统中存储固件、配置数据等。（Master In Slave Out）：SPI数据输入信号，连接STM32的MISO引脚。（Master Out Slave In）：SPI数据输出信号，连接STM32的MOSI引脚。（Serial Clock）：SPI时钟信号，连接STM32的SCK引脚。（Chip Select）：SPI片选信号，连接STM32的GPIO引脚。
    瑞萨e2studio(22)----移植兆易创新SPI Nor Flash之GD25Q64Flash
    热门推荐
    xh1479的博客
    11-26 1万+
    瑞萨e2studio.19--串口获取数据通过SPI存储于W25Q128外部flash概述硬件准备新建工程工程模板保存工程路径芯片配置工程模板选择SPI配置SPI属性配置片选CS管脚设置设置e2studio堆栈e2studio的重定向printf设置uart配置uart属性配置printf输出重定向到串口STM32移植瑞萨说明W25Q128说明演示效果W25Qx.cW25Qx.h主程序代码最后 概述 SPI是串行外设接口（Serial Peripheral Interface）的缩写，是一种高速的，全双工，
    RT-Thread GD25Qxx驱动调试
    madao1234的博客
    05-09 569
    GD32F4xx MCU RT-Thread 标准版实时系统下 GD25Q128 SPI Flash 驱动调试记录。
    BF53X GD25QXX
    Wangguan10000的博客
    04-25 490
    用BF53X的版调试的GD25QXXXflash芯片
    GD25Q32驱动
    csdn727的博客
    03-02 2941
    而之所以会有双线SPI和四线SPI的出现，其实主要是因为某些情况下并不需要全双工，但对通信速度有更高的要求，所以对引脚功能做了些调整。但是既然都叫SPI，说明仍然是符合SPI的协议标准的，本次只讲解标准SPI，理解了后感兴趣可以自行研究双线SPI和四线SPI。假设CPOL为0，那么在第一个上升沿时，发送方往数据线上发送一位数据，在下降沿时接收方读取一位数据，如此循环8次，一个字节就被发送和接收了。以上就是GD25Q32的驱动代码，驱动函数中是按64K擦除的，如果需要按32K擦除，则使用0x52指令即可。
    #天空星硬件SPI驱动GD25Q32
    byhyf83862547的博客
    04-27 2099
    GD25Q32是一种常见的串行闪存器件，它采用SPI（Serial Peripheral Interface）接口协议，具有高速读写和擦除功能，可用于存储和读取数据。GD25Q32芯片容量为32 Mbit（4 MB），其中名称后的数字代表不同的容量选项。不同的型号和容量选项可以满足不同应用的需求，通常被用于嵌入式设备、存储设备、路由器等高性能电子设备中。GD25Q32闪存芯片的内存分配是按照扇区（Sector）和块（Block）进行的，每个扇区的大小为4KB，每个块包含16个扇区，即一个块的大小为64KB。
    RT-Thread：GD32E103添加GD25QXX Flash
    小破孩的博客
    02-06 1426
    文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 一、pandas是什么？ 添加文件 添加路径 添加宏 运行死机 调大main线程栈 二、使用步骤 1.引入库 代码如下（示例）： import numpy as np import pandas as pd import matplotlib.pyplot as plt import seaborn as sns import warnings warnings.filterwarnings('ignor
    【8】GD32H7xx SPI Nor Flash_GD25Qxx
    madao1234的博客
    11-27 413
    GD32H7xx SPI Nor Flash （GD25Qxx）驱动调试记录
    RT-Thread littfs控制gd25q128 spi flash
    madao1234的博客
    05-21 548
    GD32F4xx RT-Thread 标准版系统下，Littlefs文件系统控制gd25qxx spi flash调试记录。
    STM32 QSPI接口驱动GD/W25Qxx配置简要
    perseverance51博客
    10-12 2147
    STM32 QSPI接口驱动GD/W25Qxx配置简要
    国产化FLASH芯片（GD25Q256、GD5F2GQ5UEYIG） datasheet文档及驱动说明
    05-05
    国产化FLASH芯片 datasheet文档及驱动说明 nor flash：GD25Q256 nand flash：GD5F2GQ5UEYIG
    兆易flash数据手册GD25Q64C-Rev3.0
    06-30
    兆易flash数据手册GD25Q64C-Rev3.0
    GD25Q32C.pdf
    07-31
    规格书GD25Q32,FLASH ,有需要的朋友可以分享借鉴。
    GD25Q128耳机音频电路板PCB/源码设计，4路音频输出-电路方案
    04-21
    本设计是基于GD25Q128耳机音频电路板PCB/源码设计，并支持4路音频输出。该GD25Q128耳机音频电路板开发板主要功能是将音频存在Flash中,通过I2S/DAC播放音频。另外为增加娱乐性还设计了4路音频输出，其中两路为CS4344，两路为芯片自带DAC，即I2S两通道,DAC两通道。电路CPU使用的是GD32F105RCT6，但是跟这个片pin-pin兼容的起码有四五款，这里不详叙。CS4344是个低成本的I2S接口DAC，直接驱动耳机.效果对本人来讲觉得很不错了。GD25Q128耳机音频电路板实物截图: GD25Q128耳机音频电路板电路 PCB截图: GD25Q128耳机音频电路板PCB/源码等资料截图:
    GD25Q32数据手册
    03-25
    GD25Q32，32M flash储存器，带加密功能，双倍速读
    《RT-Thread：GD32E103移植USB-Host优化文章》.rar
    04-01
    GD25QXX是一款常见的SPI接口的闪存芯片，用于存储大量数据。在RT-Thread中，对其进行移植意味着实现了与该芯片的通信驱动，可以读写数据。同时，挂载文件系统意味着使用了某种文件系统（如FATFS），使得用户可以以...
    STM32F103标准库开发---SPI实验---读写 W25Q128 外部 Flash
    MQ0522的博客
    08-14 4358
    本次实验的 MCU 是 STM32F103C8T6 芯片，通过 SPI 通信实现 W25Q128 的读写操作。不了解串口通信的朋友，可以看下面这几篇文章。接收到 W25Q128 设备ID 为。
    STM32 W25QXX芯片
    DOF526570的博客
    04-15 1719
    下面只介绍W25Q64标准SPI接口，因为目前开发板上的封装使用的就是标准SPI接口。下表是W25QXX的常用命令表2. 硬件设计D1指示灯用来提示系统运行状态，K_UP按键用来控制W25Q64数据写入，K_DOWN按键用来控制W25Q64数据读取，串口1用来打印写入和读取的数据信息D1指示灯K_UP和K_DOWN按键USART1SPIW25Q64软件设计STM32CubeMX设置RCC设置外接HSE，时钟设置为72M。
    W25QXX_ID函数解读
    最新发布
    03-31
    <think>好的，我现在需要帮助用户解析W25QXX_ID函数的功能和用法。首先，用户的问题是关于嵌入式系统中常见的SPI Flash存储器W25QXX系列芯片的，具体是W25QXX_ID函数的功能和使用方法。我需要结合提供的引用内容来回答。 首先，查看用户提供的引用内容。引用[1]提到了写使能函数，其中使用了W25QXX_CS=0和SPI2_ReadWriteByte发送写使能指令。引用[2]说明在main函数中初始化SPI并测试Flash，读取ID正确。引用[3]提到W25QXX和GD25XX在ID读取上的差异，以及厂商ID校验的问题。引用[4]是关于SPI的工作模式，可能涉及通信配置。 接下来，我需要确定W25QXX_ID函数的作用。通常，读取芯片ID的函数会发送特定的指令到Flash芯片，然后接收返回的厂商ID和设备ID。根据引用[3]，厂商ID可能会有差异，比如W25QXX是0xEF，而GD25XX是0xC8。因此，这个函数的主要功能应该是通过SPI通信发送读ID指令，并获取这两个字节的ID数据。 然后，使用方法方面，用户需要初始化SPI接口，配置正确的CPOL和CPHA模式（引用[4]中的SPI模式），然后调用该函数。函数内部应该会拉低片选信号（CS），发送读ID指令（如0x9F），然后读取返回的数据。需要注意的是，某些情况下可能需要先使能写操作（引用[1]中的写使能），但读取ID通常不需要写使能，因为它是只读操作。不过，用户可能需要注意芯片是否处于写保护状态，如果状态寄存器有保护位，可能需要先解除保护才能读取ID，但根据引用[3]，如果下载算法中没有厂商ID校验，可能不需要。 另外，代码示例方面，用户提供的引用中有SPI读写函数的使用，比如SPI2_ReadWriteByte，这可能用于发送指令和接收数据。函数需要返回组合后的ID值，比如将厂商ID和设备ID合并为16位或32位数据。 可能的问题点包括：SPI模式是否正确配置，片选信号是否正确控制，以及是否处理了厂商ID的差异。例如，如果用户使用的是GD25XX芯片，但代码中预期的是W25QXX的厂商ID，可能会导致校验失败，需要根据引用[3]中的说明进行调整。 总结来说，W25QXX_ID函数用于获取芯片的厂商和设备ID，使用步骤包括初始化SPI、发送指令、读取数据，并注意不同厂商的ID差异。同时需要确保SPI配置正确，片选信号操作正确。</think>### W25QXX_ID函数功能解析 #### 一、功能说明 $W25QXX\_ID()$ 是用于读取SPI Flash芯片 **厂商ID** 和 **设备ID** 的核心函数。通过发送$0x9F$指令（JEDEC标准指令），可获取包含厂商编码、存储类型和容量的组合数据[^3]。 #### 二、实现原理 1. **SPI通信配置** 需匹配SPI模式（如$SPI\_MODE\_0$或$SPI\_MODE\_3$）[^4]，通过拉低片选信号$W25QXX\_CS$激活通信。 2. **指令传输** ```c // 伪代码示例 void W25QXX_ReadID(uint16_t *id) { W25QXX_CS = 0; SPI_ReadWriteByte(0x9F); // 发送读ID指令 *id = (SPI_ReadWriteByte(0xFF) << 8) | SPI_ReadWriteByte(0xFF); W25QXX_CS = 1; } ``` 返回数据格式： - 第1字节：厂商ID（如W25Q80为$0xEF$，GD25Q64为$0xC8$[^3]） - 第2字节：设备ID（含容量标识） #### 三、使用方法 1. **初始化SPI接口** 调用`usr_spi0_init()`完成SPI控制器配置[^2]。 2. **执行ID读取** ```c uint16_t flash_id; W25QXX_ReadID(&flash_id); printf("ID: 0x%04X", flash_id); ``` 3. **ID验证** 对比预期值（如W25Q128的完整ID为$0xEF4018$），需注意不同厂商的ID差异[^3]。 #### 四、典型问题 1. **ID读取失败** - 检查SPI时钟极性与相位是否匹配[^4] - 验证片选信号是否有效拉低 - 排查硬件接线（SO引脚是否正常） 2. **厂商兼容性** 若使用GD25QXX芯片，需适配ID校验逻辑或关闭校验。
    评论
    添加红包

    请填写红包祝福语或标题

    个

    红包个数最小为10个

    元

    红包金额最低5元

    当前余额3.43元 前往充值 >
    需支付：10.00元
    成就一亿技术人!
    领取后你会自动成为博主和红包主的粉丝 规则
    hope_wisdom
    发出的红包
    实付元
    使用余额支付
    点击重新获取
    扫码支付
    钱包余额 0

    抵扣说明：

    1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
    2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

    余额充值